xref: /openbmc/linux/arch/m68k/ifpsp060/src/fplsp.S (revision 96de0e25)
1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
3M68000 Hi-Performance Microprocessor Division
4M68060 Software Package
5Production Release P1.00 -- October 10, 1994
6
7M68060 Software Package Copyright © 1993, 1994 Motorola Inc.  All rights reserved.
8
9THE SOFTWARE is provided on an "AS IS" basis and without warranty.
10To the maximum extent permitted by applicable law,
11MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
12INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
13and any warranty against infringement with regard to the SOFTWARE
14(INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.
15
16To the maximum extent permitted by applicable law,
17IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
18(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
19BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
20ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
21Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.
22
23You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
24so long as this entire notice is retained without alteration in any modified and/or
25redistributed versions, and that such modified versions are clearly identified as such.
26No licenses are granted by implication, estoppel or otherwise under any patents
27or trademarks of Motorola, Inc.
28~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
29#
30# lfptop.s:
31#	This file is appended to the top of the 060ILSP package
32# and contains the entry points into the package. The user, in
33# effect, branches to one of the branch table entries located here.
34#
35
36	bra.l	_facoss_
37	short	0x0000
38	bra.l	_facosd_
39	short	0x0000
40	bra.l	_facosx_
41	short	0x0000
42
43	bra.l	_fasins_
44	short	0x0000
45	bra.l	_fasind_
46	short	0x0000
47	bra.l	_fasinx_
48	short	0x0000
49
50	bra.l	_fatans_
51	short	0x0000
52	bra.l	_fatand_
53	short	0x0000
54	bra.l	_fatanx_
55	short	0x0000
56
57	bra.l	_fatanhs_
58	short	0x0000
59	bra.l	_fatanhd_
60	short	0x0000
61	bra.l	_fatanhx_
62	short	0x0000
63
64	bra.l	_fcoss_
65	short	0x0000
66	bra.l	_fcosd_
67	short	0x0000
68	bra.l	_fcosx_
69	short	0x0000
70
71	bra.l	_fcoshs_
72	short	0x0000
73	bra.l	_fcoshd_
74	short	0x0000
75	bra.l	_fcoshx_
76	short	0x0000
77
78	bra.l	_fetoxs_
79	short	0x0000
80	bra.l	_fetoxd_
81	short	0x0000
82	bra.l	_fetoxx_
83	short	0x0000
84
85	bra.l	_fetoxm1s_
86	short	0x0000
87	bra.l	_fetoxm1d_
88	short	0x0000
89	bra.l	_fetoxm1x_
90	short	0x0000
91
92	bra.l	_fgetexps_
93	short	0x0000
94	bra.l	_fgetexpd_
95	short	0x0000
96	bra.l	_fgetexpx_
97	short	0x0000
98
99	bra.l	_fgetmans_
100	short	0x0000
101	bra.l	_fgetmand_
102	short	0x0000
103	bra.l	_fgetmanx_
104	short	0x0000
105
106	bra.l	_flog10s_
107	short	0x0000
108	bra.l	_flog10d_
109	short	0x0000
110	bra.l	_flog10x_
111	short	0x0000
112
113	bra.l	_flog2s_
114	short	0x0000
115	bra.l	_flog2d_
116	short	0x0000
117	bra.l	_flog2x_
118	short	0x0000
119
120	bra.l	_flogns_
121	short	0x0000
122	bra.l	_flognd_
123	short	0x0000
124	bra.l	_flognx_
125	short	0x0000
126
127	bra.l	_flognp1s_
128	short	0x0000
129	bra.l	_flognp1d_
130	short	0x0000
131	bra.l	_flognp1x_
132	short	0x0000
133
134	bra.l	_fmods_
135	short	0x0000
136	bra.l	_fmodd_
137	short	0x0000
138	bra.l	_fmodx_
139	short	0x0000
140
141	bra.l	_frems_
142	short	0x0000
143	bra.l	_fremd_
144	short	0x0000
145	bra.l	_fremx_
146	short	0x0000
147
148	bra.l	_fscales_
149	short	0x0000
150	bra.l	_fscaled_
151	short	0x0000
152	bra.l	_fscalex_
153	short	0x0000
154
155	bra.l	_fsins_
156	short	0x0000
157	bra.l	_fsind_
158	short	0x0000
159	bra.l	_fsinx_
160	short	0x0000
161
162	bra.l	_fsincoss_
163	short	0x0000
164	bra.l	_fsincosd_
165	short	0x0000
166	bra.l	_fsincosx_
167	short	0x0000
168
169	bra.l	_fsinhs_
170	short	0x0000
171	bra.l	_fsinhd_
172	short	0x0000
173	bra.l	_fsinhx_
174	short	0x0000
175
176	bra.l	_ftans_
177	short	0x0000
178	bra.l	_ftand_
179	short	0x0000
180	bra.l	_ftanx_
181	short	0x0000
182
183	bra.l	_ftanhs_
184	short	0x0000
185	bra.l	_ftanhd_
186	short	0x0000
187	bra.l	_ftanhx_
188	short	0x0000
189
190	bra.l	_ftentoxs_
191	short	0x0000
192	bra.l	_ftentoxd_
193	short	0x0000
194	bra.l	_ftentoxx_
195	short	0x0000
196
197	bra.l	_ftwotoxs_
198	short	0x0000
199	bra.l	_ftwotoxd_
200	short	0x0000
201	bra.l	_ftwotoxx_
202	short	0x0000
203
204	bra.l	_fabss_
205	short	0x0000
206	bra.l	_fabsd_
207	short	0x0000
208	bra.l	_fabsx_
209	short	0x0000
210
211	bra.l	_fadds_
212	short	0x0000
213	bra.l	_faddd_
214	short	0x0000
215	bra.l	_faddx_
216	short	0x0000
217
218	bra.l	_fdivs_
219	short	0x0000
220	bra.l	_fdivd_
221	short	0x0000
222	bra.l	_fdivx_
223	short	0x0000
224
225	bra.l	_fints_
226	short	0x0000
227	bra.l	_fintd_
228	short	0x0000
229	bra.l	_fintx_
230	short	0x0000
231
232	bra.l	_fintrzs_
233	short	0x0000
234	bra.l	_fintrzd_
235	short	0x0000
236	bra.l	_fintrzx_
237	short	0x0000
238
239	bra.l	_fmuls_
240	short	0x0000
241	bra.l	_fmuld_
242	short	0x0000
243	bra.l	_fmulx_
244	short	0x0000
245
246	bra.l	_fnegs_
247	short	0x0000
248	bra.l	_fnegd_
249	short	0x0000
250	bra.l	_fnegx_
251	short	0x0000
252
253	bra.l	_fsqrts_
254	short	0x0000
255	bra.l	_fsqrtd_
256	short	0x0000
257	bra.l	_fsqrtx_
258	short	0x0000
259
260	bra.l	_fsubs_
261	short	0x0000
262	bra.l	_fsubd_
263	short	0x0000
264	bra.l	_fsubx_
265	short	0x0000
266
267# leave room for future possible additions
268	align	0x400
269
270#
271# This file contains a set of define statements for constants
272# in order to promote readability within the corecode itself.
273#
274
275set LOCAL_SIZE,		192			# stack frame size(bytes)
276set LV,			-LOCAL_SIZE		# stack offset
277
278set EXC_SR,		0x4			# stack status register
279set EXC_PC,		0x6			# stack pc
280set EXC_VOFF,		0xa			# stacked vector offset
281set EXC_EA,		0xc			# stacked <ea>
282
283set EXC_FP,		0x0			# frame pointer
284
285set EXC_AREGS,		-68			# offset of all address regs
286set EXC_DREGS,		-100			# offset of all data regs
287set EXC_FPREGS,		-36			# offset of all fp regs
288
289set EXC_A7,		EXC_AREGS+(7*4)		# offset of saved a7
290set OLD_A7,		EXC_AREGS+(6*4)		# extra copy of saved a7
291set EXC_A6,		EXC_AREGS+(6*4)		# offset of saved a6
292set EXC_A5,		EXC_AREGS+(5*4)
293set EXC_A4,		EXC_AREGS+(4*4)
294set EXC_A3,		EXC_AREGS+(3*4)
295set EXC_A2,		EXC_AREGS+(2*4)
296set EXC_A1,		EXC_AREGS+(1*4)
297set EXC_A0,		EXC_AREGS+(0*4)
298set EXC_D7,		EXC_DREGS+(7*4)
299set EXC_D6,		EXC_DREGS+(6*4)
300set EXC_D5,		EXC_DREGS+(5*4)
301set EXC_D4,		EXC_DREGS+(4*4)
302set EXC_D3,		EXC_DREGS+(3*4)
303set EXC_D2,		EXC_DREGS+(2*4)
304set EXC_D1,		EXC_DREGS+(1*4)
305set EXC_D0,		EXC_DREGS+(0*4)
306
307set EXC_FP0,		EXC_FPREGS+(0*12)	# offset of saved fp0
308set EXC_FP1,		EXC_FPREGS+(1*12)	# offset of saved fp1
309set EXC_FP2,		EXC_FPREGS+(2*12)	# offset of saved fp2 (not used)
310
311set FP_SCR1,		LV+80			# fp scratch 1
312set FP_SCR1_EX,		FP_SCR1+0
313set FP_SCR1_SGN,	FP_SCR1+2
314set FP_SCR1_HI,		FP_SCR1+4
315set FP_SCR1_LO,		FP_SCR1+8
316
317set FP_SCR0,		LV+68			# fp scratch 0
318set FP_SCR0_EX,		FP_SCR0+0
319set FP_SCR0_SGN,	FP_SCR0+2
320set FP_SCR0_HI,		FP_SCR0+4
321set FP_SCR0_LO,		FP_SCR0+8
322
323set FP_DST,		LV+56			# fp destination operand
324set FP_DST_EX,		FP_DST+0
325set FP_DST_SGN,		FP_DST+2
326set FP_DST_HI,		FP_DST+4
327set FP_DST_LO,		FP_DST+8
328
329set FP_SRC,		LV+44			# fp source operand
330set FP_SRC_EX,		FP_SRC+0
331set FP_SRC_SGN,		FP_SRC+2
332set FP_SRC_HI,		FP_SRC+4
333set FP_SRC_LO,		FP_SRC+8
334
335set USER_FPIAR,		LV+40			# FP instr address register
336
337set USER_FPSR,		LV+36			# FP status register
338set FPSR_CC,		USER_FPSR+0		# FPSR condition codes
339set FPSR_QBYTE,		USER_FPSR+1		# FPSR qoutient byte
340set FPSR_EXCEPT,	USER_FPSR+2		# FPSR exception status byte
341set FPSR_AEXCEPT,	USER_FPSR+3		# FPSR accrued exception byte
342
343set USER_FPCR,		LV+32			# FP control register
344set FPCR_ENABLE,	USER_FPCR+2		# FPCR exception enable
345set FPCR_MODE,		USER_FPCR+3		# FPCR rounding mode control
346
347set L_SCR3,		LV+28			# integer scratch 3
348set L_SCR2,		LV+24			# integer scratch 2
349set L_SCR1,		LV+20			# integer scratch 1
350
351set STORE_FLG,		LV+19			# flag: operand store (ie. not fcmp/ftst)
352
353set EXC_TEMP2,		LV+24			# temporary space
354set EXC_TEMP,		LV+16			# temporary space
355
356set DTAG,		LV+15			# destination operand type
357set STAG,		LV+14			# source operand type
358
359set SPCOND_FLG,		LV+10			# flag: special case (see below)
360
361set EXC_CC,		LV+8			# saved condition codes
362set EXC_EXTWPTR,	LV+4			# saved current PC (active)
363set EXC_EXTWORD,	LV+2			# saved extension word
364set EXC_CMDREG,		LV+2			# saved extension word
365set EXC_OPWORD,		LV+0			# saved operation word
366
367################################
368
369# Helpful macros
370
371set FTEMP,		0			# offsets within an
372set FTEMP_EX,		0			# extended precision
373set FTEMP_SGN,		2			# value saved in memory.
374set FTEMP_HI,		4
375set FTEMP_LO,		8
376set FTEMP_GRS,		12
377
378set LOCAL,		0			# offsets within an
379set LOCAL_EX,		0			# extended precision
380set LOCAL_SGN,		2			# value saved in memory.
381set LOCAL_HI,		4
382set LOCAL_LO,		8
383set LOCAL_GRS,		12
384
385set DST,		0			# offsets within an
386set DST_EX,		0			# extended precision
387set DST_HI,		4			# value saved in memory.
388set DST_LO,		8
389
390set SRC,		0			# offsets within an
391set SRC_EX,		0			# extended precision
392set SRC_HI,		4			# value saved in memory.
393set SRC_LO,		8
394
395set SGL_LO,		0x3f81			# min sgl prec exponent
396set SGL_HI,		0x407e			# max sgl prec exponent
397set DBL_LO,		0x3c01			# min dbl prec exponent
398set DBL_HI,		0x43fe			# max dbl prec exponent
399set EXT_LO,		0x0			# min ext prec exponent
400set EXT_HI,		0x7ffe			# max ext prec exponent
401
402set EXT_BIAS,		0x3fff			# extended precision bias
403set SGL_BIAS,		0x007f			# single precision bias
404set DBL_BIAS,		0x03ff			# double precision bias
405
406set NORM,		0x00			# operand type for STAG/DTAG
407set ZERO,		0x01			# operand type for STAG/DTAG
408set INF,		0x02			# operand type for STAG/DTAG
409set QNAN,		0x03			# operand type for STAG/DTAG
410set DENORM,		0x04			# operand type for STAG/DTAG
411set SNAN,		0x05			# operand type for STAG/DTAG
412set UNNORM,		0x06			# operand type for STAG/DTAG
413
414##################
415# FPSR/FPCR bits #
416##################
417set neg_bit,		0x3			# negative result
418set z_bit,		0x2			# zero result
419set inf_bit,		0x1			# infinite result
420set nan_bit,		0x0			# NAN result
421
422set q_sn_bit,		0x7			# sign bit of quotient byte
423
424set bsun_bit,		7			# branch on unordered
425set snan_bit,		6			# signalling NAN
426set operr_bit,		5			# operand error
427set ovfl_bit,		4			# overflow
428set unfl_bit,		3			# underflow
429set dz_bit,		2			# divide by zero
430set inex2_bit,		1			# inexact result 2
431set inex1_bit,		0			# inexact result 1
432
433set aiop_bit,		7			# accrued inexact operation bit
434set aovfl_bit,		6			# accrued overflow bit
435set aunfl_bit,		5			# accrued underflow bit
436set adz_bit,		4			# accrued dz bit
437set ainex_bit,		3			# accrued inexact bit
438
439#############################
440# FPSR individual bit masks #
441#############################
442set neg_mask,		0x08000000		# negative bit mask (lw)
443set inf_mask,		0x02000000		# infinity bit mask (lw)
444set z_mask,		0x04000000		# zero bit mask (lw)
445set nan_mask,		0x01000000		# nan bit mask (lw)
446
447set neg_bmask,		0x08			# negative bit mask (byte)
448set inf_bmask,		0x02			# infinity bit mask (byte)
449set z_bmask,		0x04			# zero bit mask (byte)
450set nan_bmask,		0x01			# nan bit mask (byte)
451
452set bsun_mask,		0x00008000		# bsun exception mask
453set snan_mask,		0x00004000		# snan exception mask
454set operr_mask,		0x00002000		# operr exception mask
455set ovfl_mask,		0x00001000		# overflow exception mask
456set unfl_mask,		0x00000800		# underflow exception mask
457set dz_mask,		0x00000400		# dz exception mask
458set inex2_mask,		0x00000200		# inex2 exception mask
459set inex1_mask,		0x00000100		# inex1 exception mask
460
461set aiop_mask,		0x00000080		# accrued illegal operation
462set aovfl_mask,		0x00000040		# accrued overflow
463set aunfl_mask,		0x00000020		# accrued underflow
464set adz_mask,		0x00000010		# accrued divide by zero
465set ainex_mask,		0x00000008		# accrued inexact
466
467######################################
468# FPSR combinations used in the FPSP #
469######################################
470set dzinf_mask,		inf_mask+dz_mask+adz_mask
471set opnan_mask,		nan_mask+operr_mask+aiop_mask
472set nzi_mask,		0x01ffffff		#clears N, Z, and I
473set unfinx_mask,	unfl_mask+inex2_mask+aunfl_mask+ainex_mask
474set unf2inx_mask,	unfl_mask+inex2_mask+ainex_mask
475set ovfinx_mask,	ovfl_mask+inex2_mask+aovfl_mask+ainex_mask
476set inx1a_mask,		inex1_mask+ainex_mask
477set inx2a_mask,		inex2_mask+ainex_mask
478set snaniop_mask,	nan_mask+snan_mask+aiop_mask
479set snaniop2_mask,	snan_mask+aiop_mask
480set naniop_mask,	nan_mask+aiop_mask
481set neginf_mask,	neg_mask+inf_mask
482set infaiop_mask,	inf_mask+aiop_mask
483set negz_mask,		neg_mask+z_mask
484set opaop_mask,		operr_mask+aiop_mask
485set unfl_inx_mask,	unfl_mask+aunfl_mask+ainex_mask
486set ovfl_inx_mask,	ovfl_mask+aovfl_mask+ainex_mask
487
488#########
489# misc. #
490#########
491set rnd_stky_bit,	29			# stky bit pos in longword
492
493set sign_bit,		0x7			# sign bit
494set signan_bit,		0x6			# signalling nan bit
495
496set sgl_thresh,		0x3f81			# minimum sgl exponent
497set dbl_thresh,		0x3c01			# minimum dbl exponent
498
499set x_mode,		0x0			# extended precision
500set s_mode,		0x4			# single precision
501set d_mode,		0x8			# double precision
502
503set rn_mode,		0x0			# round-to-nearest
504set rz_mode,		0x1			# round-to-zero
505set rm_mode,		0x2			# round-tp-minus-infinity
506set rp_mode,		0x3			# round-to-plus-infinity
507
508set mantissalen,	64			# length of mantissa in bits
509
510set BYTE,		1			# len(byte) == 1 byte
511set WORD,		2			# len(word) == 2 bytes
512set LONG,		4			# len(longword) == 2 bytes
513
514set BSUN_VEC,		0xc0			# bsun    vector offset
515set INEX_VEC,		0xc4			# inexact vector offset
516set DZ_VEC,		0xc8			# dz      vector offset
517set UNFL_VEC,		0xcc			# unfl    vector offset
518set OPERR_VEC,		0xd0			# operr   vector offset
519set OVFL_VEC,		0xd4			# ovfl    vector offset
520set SNAN_VEC,		0xd8			# snan    vector offset
521
522###########################
523# SPecial CONDition FLaGs #
524###########################
525set ftrapcc_flg,	0x01			# flag bit: ftrapcc exception
526set fbsun_flg,		0x02			# flag bit: bsun exception
527set mia7_flg,		0x04			# flag bit: (a7)+ <ea>
528set mda7_flg,		0x08			# flag bit: -(a7) <ea>
529set fmovm_flg,		0x40			# flag bit: fmovm instruction
530set immed_flg,		0x80			# flag bit: &<data> <ea>
531
532set ftrapcc_bit,	0x0
533set fbsun_bit,		0x1
534set mia7_bit,		0x2
535set mda7_bit,		0x3
536set immed_bit,		0x7
537
538##################################
539# TRANSCENDENTAL "LAST-OP" FLAGS #
540##################################
541set FMUL_OP,		0x0			# fmul instr performed last
542set FDIV_OP,		0x1			# fdiv performed last
543set FADD_OP,		0x2			# fadd performed last
544set FMOV_OP,		0x3			# fmov performed last
545
546#############
547# CONSTANTS #
548#############
549T1:	long		0x40C62D38,0xD3D64634	# 16381 LOG2 LEAD
550T2:	long		0x3D6F90AE,0xB1E75CC7	# 16381 LOG2 TRAIL
551
552PI:	long		0x40000000,0xC90FDAA2,0x2168C235,0x00000000
553PIBY2:	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
554
555TWOBYPI:
556	long		0x3FE45F30,0x6DC9C883
557
558#########################################################################
559# MONADIC TEMPLATE							#
560#########################################################################
561	global		_fsins_
562_fsins_:
563	link		%a6,&-LOCAL_SIZE
564
565	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
566	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
567	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
568
569	fmov.l		&0x0,%fpcr		# zero FPCR
570
571#
572#	copy, convert, and tag input argument
573#
574	fmov.s		0x8(%a6),%fp0		# load sgl input
575	fmov.x		%fp0,FP_SRC(%a6)
576	lea		FP_SRC(%a6),%a0
577	bsr.l		tag			# fetch operand type
578	mov.b		%d0,STAG(%a6)
579	mov.b		%d0,%d1
580
581	andi.l		&0x00ff00ff,USER_FPSR(%a6)
582
583	clr.l		%d0
584	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
585
586	tst.b		%d1
587	bne.b		_L0_2s
588	bsr.l		ssin			# operand is a NORM
589	bra.b		_L0_6s
590_L0_2s:
591	cmpi.b		%d1,&ZERO		# is operand a ZERO?
592	bne.b		_L0_3s			# no
593	bsr.l		src_zero			# yes
594	bra.b		_L0_6s
595_L0_3s:
596	cmpi.b		%d1,&INF		# is operand an INF?
597	bne.b		_L0_4s			# no
598	bsr.l		t_operr			# yes
599	bra.b		_L0_6s
600_L0_4s:
601	cmpi.b		%d1,&QNAN		# is operand a QNAN?
602	bne.b		_L0_5s			# no
603	bsr.l		src_qnan			# yes
604	bra.b		_L0_6s
605_L0_5s:
606	bsr.l		ssind			# operand is a DENORM
607_L0_6s:
608
609#
610#	Result is now in FP0
611#
612	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
613	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
614	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
615	unlk		%a6
616	rts
617
618	global		_fsind_
619_fsind_:
620	link		%a6,&-LOCAL_SIZE
621
622	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
623	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
624	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
625
626	fmov.l		&0x0,%fpcr		# zero FPCR
627
628#
629#	copy, convert, and tag input argument
630#
631	fmov.d		0x8(%a6),%fp0		# load dbl input
632	fmov.x		%fp0,FP_SRC(%a6)
633	lea		FP_SRC(%a6),%a0
634	bsr.l		tag			# fetch operand type
635	mov.b		%d0,STAG(%a6)
636	mov.b		%d0,%d1
637
638	andi.l		&0x00ff00ff,USER_FPSR(%a6)
639
640	clr.l		%d0
641	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
642
643	mov.b		%d1,STAG(%a6)
644	tst.b		%d1
645	bne.b		_L0_2d
646	bsr.l		ssin			# operand is a NORM
647	bra.b		_L0_6d
648_L0_2d:
649	cmpi.b		%d1,&ZERO		# is operand a ZERO?
650	bne.b		_L0_3d			# no
651	bsr.l		src_zero			# yes
652	bra.b		_L0_6d
653_L0_3d:
654	cmpi.b		%d1,&INF		# is operand an INF?
655	bne.b		_L0_4d			# no
656	bsr.l		t_operr			# yes
657	bra.b		_L0_6d
658_L0_4d:
659	cmpi.b		%d1,&QNAN		# is operand a QNAN?
660	bne.b		_L0_5d			# no
661	bsr.l		src_qnan			# yes
662	bra.b		_L0_6d
663_L0_5d:
664	bsr.l		ssind			# operand is a DENORM
665_L0_6d:
666
667#
668#	Result is now in FP0
669#
670	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
671	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
672	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
673	unlk		%a6
674	rts
675
676	global		_fsinx_
677_fsinx_:
678	link		%a6,&-LOCAL_SIZE
679
680	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
681	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
682	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
683
684	fmov.l		&0x0,%fpcr		# zero FPCR
685
686#
687#	copy, convert, and tag input argument
688#
689	lea		FP_SRC(%a6),%a0
690	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
691	mov.l		0x8+0x4(%a6),0x4(%a0)
692	mov.l		0x8+0x8(%a6),0x8(%a0)
693	bsr.l		tag			# fetch operand type
694	mov.b		%d0,STAG(%a6)
695	mov.b		%d0,%d1
696
697	andi.l		&0x00ff00ff,USER_FPSR(%a6)
698
699	clr.l		%d0
700	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
701
702	tst.b		%d1
703	bne.b		_L0_2x
704	bsr.l		ssin			# operand is a NORM
705	bra.b		_L0_6x
706_L0_2x:
707	cmpi.b		%d1,&ZERO		# is operand a ZERO?
708	bne.b		_L0_3x			# no
709	bsr.l		src_zero			# yes
710	bra.b		_L0_6x
711_L0_3x:
712	cmpi.b		%d1,&INF		# is operand an INF?
713	bne.b		_L0_4x			# no
714	bsr.l		t_operr			# yes
715	bra.b		_L0_6x
716_L0_4x:
717	cmpi.b		%d1,&QNAN		# is operand a QNAN?
718	bne.b		_L0_5x			# no
719	bsr.l		src_qnan			# yes
720	bra.b		_L0_6x
721_L0_5x:
722	bsr.l		ssind			# operand is a DENORM
723_L0_6x:
724
725#
726#	Result is now in FP0
727#
728	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
729	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
730	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
731	unlk		%a6
732	rts
733
734
735#########################################################################
736# MONADIC TEMPLATE							#
737#########################################################################
738	global		_fcoss_
739_fcoss_:
740	link		%a6,&-LOCAL_SIZE
741
742	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
743	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
744	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
745
746	fmov.l		&0x0,%fpcr		# zero FPCR
747
748#
749#	copy, convert, and tag input argument
750#
751	fmov.s		0x8(%a6),%fp0		# load sgl input
752	fmov.x		%fp0,FP_SRC(%a6)
753	lea		FP_SRC(%a6),%a0
754	bsr.l		tag			# fetch operand type
755	mov.b		%d0,STAG(%a6)
756	mov.b		%d0,%d1
757
758	andi.l		&0x00ff00ff,USER_FPSR(%a6)
759
760	clr.l		%d0
761	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
762
763	tst.b		%d1
764	bne.b		_L1_2s
765	bsr.l		scos			# operand is a NORM
766	bra.b		_L1_6s
767_L1_2s:
768	cmpi.b		%d1,&ZERO		# is operand a ZERO?
769	bne.b		_L1_3s			# no
770	bsr.l		ld_pone			# yes
771	bra.b		_L1_6s
772_L1_3s:
773	cmpi.b		%d1,&INF		# is operand an INF?
774	bne.b		_L1_4s			# no
775	bsr.l		t_operr			# yes
776	bra.b		_L1_6s
777_L1_4s:
778	cmpi.b		%d1,&QNAN		# is operand a QNAN?
779	bne.b		_L1_5s			# no
780	bsr.l		src_qnan			# yes
781	bra.b		_L1_6s
782_L1_5s:
783	bsr.l		scosd			# operand is a DENORM
784_L1_6s:
785
786#
787#	Result is now in FP0
788#
789	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
790	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
791	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
792	unlk		%a6
793	rts
794
795	global		_fcosd_
796_fcosd_:
797	link		%a6,&-LOCAL_SIZE
798
799	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
800	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
801	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
802
803	fmov.l		&0x0,%fpcr		# zero FPCR
804
805#
806#	copy, convert, and tag input argument
807#
808	fmov.d		0x8(%a6),%fp0		# load dbl input
809	fmov.x		%fp0,FP_SRC(%a6)
810	lea		FP_SRC(%a6),%a0
811	bsr.l		tag			# fetch operand type
812	mov.b		%d0,STAG(%a6)
813	mov.b		%d0,%d1
814
815	andi.l		&0x00ff00ff,USER_FPSR(%a6)
816
817	clr.l		%d0
818	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
819
820	mov.b		%d1,STAG(%a6)
821	tst.b		%d1
822	bne.b		_L1_2d
823	bsr.l		scos			# operand is a NORM
824	bra.b		_L1_6d
825_L1_2d:
826	cmpi.b		%d1,&ZERO		# is operand a ZERO?
827	bne.b		_L1_3d			# no
828	bsr.l		ld_pone			# yes
829	bra.b		_L1_6d
830_L1_3d:
831	cmpi.b		%d1,&INF		# is operand an INF?
832	bne.b		_L1_4d			# no
833	bsr.l		t_operr			# yes
834	bra.b		_L1_6d
835_L1_4d:
836	cmpi.b		%d1,&QNAN		# is operand a QNAN?
837	bne.b		_L1_5d			# no
838	bsr.l		src_qnan			# yes
839	bra.b		_L1_6d
840_L1_5d:
841	bsr.l		scosd			# operand is a DENORM
842_L1_6d:
843
844#
845#	Result is now in FP0
846#
847	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
848	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
849	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
850	unlk		%a6
851	rts
852
853	global		_fcosx_
854_fcosx_:
855	link		%a6,&-LOCAL_SIZE
856
857	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
858	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
859	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
860
861	fmov.l		&0x0,%fpcr		# zero FPCR
862
863#
864#	copy, convert, and tag input argument
865#
866	lea		FP_SRC(%a6),%a0
867	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
868	mov.l		0x8+0x4(%a6),0x4(%a0)
869	mov.l		0x8+0x8(%a6),0x8(%a0)
870	bsr.l		tag			# fetch operand type
871	mov.b		%d0,STAG(%a6)
872	mov.b		%d0,%d1
873
874	andi.l		&0x00ff00ff,USER_FPSR(%a6)
875
876	clr.l		%d0
877	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
878
879	tst.b		%d1
880	bne.b		_L1_2x
881	bsr.l		scos			# operand is a NORM
882	bra.b		_L1_6x
883_L1_2x:
884	cmpi.b		%d1,&ZERO		# is operand a ZERO?
885	bne.b		_L1_3x			# no
886	bsr.l		ld_pone			# yes
887	bra.b		_L1_6x
888_L1_3x:
889	cmpi.b		%d1,&INF		# is operand an INF?
890	bne.b		_L1_4x			# no
891	bsr.l		t_operr			# yes
892	bra.b		_L1_6x
893_L1_4x:
894	cmpi.b		%d1,&QNAN		# is operand a QNAN?
895	bne.b		_L1_5x			# no
896	bsr.l		src_qnan			# yes
897	bra.b		_L1_6x
898_L1_5x:
899	bsr.l		scosd			# operand is a DENORM
900_L1_6x:
901
902#
903#	Result is now in FP0
904#
905	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
906	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
907	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
908	unlk		%a6
909	rts
910
911
912#########################################################################
913# MONADIC TEMPLATE							#
914#########################################################################
915	global		_fsinhs_
916_fsinhs_:
917	link		%a6,&-LOCAL_SIZE
918
919	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
920	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
921	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
922
923	fmov.l		&0x0,%fpcr		# zero FPCR
924
925#
926#	copy, convert, and tag input argument
927#
928	fmov.s		0x8(%a6),%fp0		# load sgl input
929	fmov.x		%fp0,FP_SRC(%a6)
930	lea		FP_SRC(%a6),%a0
931	bsr.l		tag			# fetch operand type
932	mov.b		%d0,STAG(%a6)
933	mov.b		%d0,%d1
934
935	andi.l		&0x00ff00ff,USER_FPSR(%a6)
936
937	clr.l		%d0
938	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
939
940	tst.b		%d1
941	bne.b		_L2_2s
942	bsr.l		ssinh			# operand is a NORM
943	bra.b		_L2_6s
944_L2_2s:
945	cmpi.b		%d1,&ZERO		# is operand a ZERO?
946	bne.b		_L2_3s			# no
947	bsr.l		src_zero			# yes
948	bra.b		_L2_6s
949_L2_3s:
950	cmpi.b		%d1,&INF		# is operand an INF?
951	bne.b		_L2_4s			# no
952	bsr.l		src_inf			# yes
953	bra.b		_L2_6s
954_L2_4s:
955	cmpi.b		%d1,&QNAN		# is operand a QNAN?
956	bne.b		_L2_5s			# no
957	bsr.l		src_qnan			# yes
958	bra.b		_L2_6s
959_L2_5s:
960	bsr.l		ssinhd			# operand is a DENORM
961_L2_6s:
962
963#
964#	Result is now in FP0
965#
966	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
967	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
968	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
969	unlk		%a6
970	rts
971
972	global		_fsinhd_
973_fsinhd_:
974	link		%a6,&-LOCAL_SIZE
975
976	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
977	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
978	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
979
980	fmov.l		&0x0,%fpcr		# zero FPCR
981
982#
983#	copy, convert, and tag input argument
984#
985	fmov.d		0x8(%a6),%fp0		# load dbl input
986	fmov.x		%fp0,FP_SRC(%a6)
987	lea		FP_SRC(%a6),%a0
988	bsr.l		tag			# fetch operand type
989	mov.b		%d0,STAG(%a6)
990	mov.b		%d0,%d1
991
992	andi.l		&0x00ff00ff,USER_FPSR(%a6)
993
994	clr.l		%d0
995	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
996
997	mov.b		%d1,STAG(%a6)
998	tst.b		%d1
999	bne.b		_L2_2d
1000	bsr.l		ssinh			# operand is a NORM
1001	bra.b		_L2_6d
1002_L2_2d:
1003	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1004	bne.b		_L2_3d			# no
1005	bsr.l		src_zero			# yes
1006	bra.b		_L2_6d
1007_L2_3d:
1008	cmpi.b		%d1,&INF		# is operand an INF?
1009	bne.b		_L2_4d			# no
1010	bsr.l		src_inf			# yes
1011	bra.b		_L2_6d
1012_L2_4d:
1013	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1014	bne.b		_L2_5d			# no
1015	bsr.l		src_qnan			# yes
1016	bra.b		_L2_6d
1017_L2_5d:
1018	bsr.l		ssinhd			# operand is a DENORM
1019_L2_6d:
1020
1021#
1022#	Result is now in FP0
1023#
1024	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1025	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1026	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1027	unlk		%a6
1028	rts
1029
1030	global		_fsinhx_
1031_fsinhx_:
1032	link		%a6,&-LOCAL_SIZE
1033
1034	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1035	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1036	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1037
1038	fmov.l		&0x0,%fpcr		# zero FPCR
1039
1040#
1041#	copy, convert, and tag input argument
1042#
1043	lea		FP_SRC(%a6),%a0
1044	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
1045	mov.l		0x8+0x4(%a6),0x4(%a0)
1046	mov.l		0x8+0x8(%a6),0x8(%a0)
1047	bsr.l		tag			# fetch operand type
1048	mov.b		%d0,STAG(%a6)
1049	mov.b		%d0,%d1
1050
1051	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1052
1053	clr.l		%d0
1054	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1055
1056	tst.b		%d1
1057	bne.b		_L2_2x
1058	bsr.l		ssinh			# operand is a NORM
1059	bra.b		_L2_6x
1060_L2_2x:
1061	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1062	bne.b		_L2_3x			# no
1063	bsr.l		src_zero			# yes
1064	bra.b		_L2_6x
1065_L2_3x:
1066	cmpi.b		%d1,&INF		# is operand an INF?
1067	bne.b		_L2_4x			# no
1068	bsr.l		src_inf			# yes
1069	bra.b		_L2_6x
1070_L2_4x:
1071	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1072	bne.b		_L2_5x			# no
1073	bsr.l		src_qnan			# yes
1074	bra.b		_L2_6x
1075_L2_5x:
1076	bsr.l		ssinhd			# operand is a DENORM
1077_L2_6x:
1078
1079#
1080#	Result is now in FP0
1081#
1082	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1083	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1084	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1085	unlk		%a6
1086	rts
1087
1088
1089#########################################################################
1090# MONADIC TEMPLATE							#
1091#########################################################################
1092	global		_flognp1s_
1093_flognp1s_:
1094	link		%a6,&-LOCAL_SIZE
1095
1096	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1097	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1098	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1099
1100	fmov.l		&0x0,%fpcr		# zero FPCR
1101
1102#
1103#	copy, convert, and tag input argument
1104#
1105	fmov.s		0x8(%a6),%fp0		# load sgl input
1106	fmov.x		%fp0,FP_SRC(%a6)
1107	lea		FP_SRC(%a6),%a0
1108	bsr.l		tag			# fetch operand type
1109	mov.b		%d0,STAG(%a6)
1110	mov.b		%d0,%d1
1111
1112	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1113
1114	clr.l		%d0
1115	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1116
1117	tst.b		%d1
1118	bne.b		_L3_2s
1119	bsr.l		slognp1			# operand is a NORM
1120	bra.b		_L3_6s
1121_L3_2s:
1122	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1123	bne.b		_L3_3s			# no
1124	bsr.l		src_zero			# yes
1125	bra.b		_L3_6s
1126_L3_3s:
1127	cmpi.b		%d1,&INF		# is operand an INF?
1128	bne.b		_L3_4s			# no
1129	bsr.l		sopr_inf			# yes
1130	bra.b		_L3_6s
1131_L3_4s:
1132	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1133	bne.b		_L3_5s			# no
1134	bsr.l		src_qnan			# yes
1135	bra.b		_L3_6s
1136_L3_5s:
1137	bsr.l		slognp1d			# operand is a DENORM
1138_L3_6s:
1139
1140#
1141#	Result is now in FP0
1142#
1143	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1144	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1145	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1146	unlk		%a6
1147	rts
1148
1149	global		_flognp1d_
1150_flognp1d_:
1151	link		%a6,&-LOCAL_SIZE
1152
1153	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1154	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1155	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1156
1157	fmov.l		&0x0,%fpcr		# zero FPCR
1158
1159#
1160#	copy, convert, and tag input argument
1161#
1162	fmov.d		0x8(%a6),%fp0		# load dbl input
1163	fmov.x		%fp0,FP_SRC(%a6)
1164	lea		FP_SRC(%a6),%a0
1165	bsr.l		tag			# fetch operand type
1166	mov.b		%d0,STAG(%a6)
1167	mov.b		%d0,%d1
1168
1169	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1170
1171	clr.l		%d0
1172	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1173
1174	mov.b		%d1,STAG(%a6)
1175	tst.b		%d1
1176	bne.b		_L3_2d
1177	bsr.l		slognp1			# operand is a NORM
1178	bra.b		_L3_6d
1179_L3_2d:
1180	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1181	bne.b		_L3_3d			# no
1182	bsr.l		src_zero			# yes
1183	bra.b		_L3_6d
1184_L3_3d:
1185	cmpi.b		%d1,&INF		# is operand an INF?
1186	bne.b		_L3_4d			# no
1187	bsr.l		sopr_inf			# yes
1188	bra.b		_L3_6d
1189_L3_4d:
1190	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1191	bne.b		_L3_5d			# no
1192	bsr.l		src_qnan			# yes
1193	bra.b		_L3_6d
1194_L3_5d:
1195	bsr.l		slognp1d			# operand is a DENORM
1196_L3_6d:
1197
1198#
1199#	Result is now in FP0
1200#
1201	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1202	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1203	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1204	unlk		%a6
1205	rts
1206
1207	global		_flognp1x_
1208_flognp1x_:
1209	link		%a6,&-LOCAL_SIZE
1210
1211	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1212	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1213	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1214
1215	fmov.l		&0x0,%fpcr		# zero FPCR
1216
1217#
1218#	copy, convert, and tag input argument
1219#
1220	lea		FP_SRC(%a6),%a0
1221	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
1222	mov.l		0x8+0x4(%a6),0x4(%a0)
1223	mov.l		0x8+0x8(%a6),0x8(%a0)
1224	bsr.l		tag			# fetch operand type
1225	mov.b		%d0,STAG(%a6)
1226	mov.b		%d0,%d1
1227
1228	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1229
1230	clr.l		%d0
1231	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1232
1233	tst.b		%d1
1234	bne.b		_L3_2x
1235	bsr.l		slognp1			# operand is a NORM
1236	bra.b		_L3_6x
1237_L3_2x:
1238	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1239	bne.b		_L3_3x			# no
1240	bsr.l		src_zero			# yes
1241	bra.b		_L3_6x
1242_L3_3x:
1243	cmpi.b		%d1,&INF		# is operand an INF?
1244	bne.b		_L3_4x			# no
1245	bsr.l		sopr_inf			# yes
1246	bra.b		_L3_6x
1247_L3_4x:
1248	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1249	bne.b		_L3_5x			# no
1250	bsr.l		src_qnan			# yes
1251	bra.b		_L3_6x
1252_L3_5x:
1253	bsr.l		slognp1d			# operand is a DENORM
1254_L3_6x:
1255
1256#
1257#	Result is now in FP0
1258#
1259	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1260	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1261	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1262	unlk		%a6
1263	rts
1264
1265
1266#########################################################################
1267# MONADIC TEMPLATE							#
1268#########################################################################
1269	global		_fetoxm1s_
1270_fetoxm1s_:
1271	link		%a6,&-LOCAL_SIZE
1272
1273	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1274	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1275	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1276
1277	fmov.l		&0x0,%fpcr		# zero FPCR
1278
1279#
1280#	copy, convert, and tag input argument
1281#
1282	fmov.s		0x8(%a6),%fp0		# load sgl input
1283	fmov.x		%fp0,FP_SRC(%a6)
1284	lea		FP_SRC(%a6),%a0
1285	bsr.l		tag			# fetch operand type
1286	mov.b		%d0,STAG(%a6)
1287	mov.b		%d0,%d1
1288
1289	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1290
1291	clr.l		%d0
1292	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1293
1294	tst.b		%d1
1295	bne.b		_L4_2s
1296	bsr.l		setoxm1			# operand is a NORM
1297	bra.b		_L4_6s
1298_L4_2s:
1299	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1300	bne.b		_L4_3s			# no
1301	bsr.l		src_zero			# yes
1302	bra.b		_L4_6s
1303_L4_3s:
1304	cmpi.b		%d1,&INF		# is operand an INF?
1305	bne.b		_L4_4s			# no
1306	bsr.l		setoxm1i			# yes
1307	bra.b		_L4_6s
1308_L4_4s:
1309	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1310	bne.b		_L4_5s			# no
1311	bsr.l		src_qnan			# yes
1312	bra.b		_L4_6s
1313_L4_5s:
1314	bsr.l		setoxm1d			# operand is a DENORM
1315_L4_6s:
1316
1317#
1318#	Result is now in FP0
1319#
1320	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1321	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1322	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1323	unlk		%a6
1324	rts
1325
1326	global		_fetoxm1d_
1327_fetoxm1d_:
1328	link		%a6,&-LOCAL_SIZE
1329
1330	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1331	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1332	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1333
1334	fmov.l		&0x0,%fpcr		# zero FPCR
1335
1336#
1337#	copy, convert, and tag input argument
1338#
1339	fmov.d		0x8(%a6),%fp0		# load dbl input
1340	fmov.x		%fp0,FP_SRC(%a6)
1341	lea		FP_SRC(%a6),%a0
1342	bsr.l		tag			# fetch operand type
1343	mov.b		%d0,STAG(%a6)
1344	mov.b		%d0,%d1
1345
1346	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1347
1348	clr.l		%d0
1349	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1350
1351	mov.b		%d1,STAG(%a6)
1352	tst.b		%d1
1353	bne.b		_L4_2d
1354	bsr.l		setoxm1			# operand is a NORM
1355	bra.b		_L4_6d
1356_L4_2d:
1357	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1358	bne.b		_L4_3d			# no
1359	bsr.l		src_zero			# yes
1360	bra.b		_L4_6d
1361_L4_3d:
1362	cmpi.b		%d1,&INF		# is operand an INF?
1363	bne.b		_L4_4d			# no
1364	bsr.l		setoxm1i			# yes
1365	bra.b		_L4_6d
1366_L4_4d:
1367	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1368	bne.b		_L4_5d			# no
1369	bsr.l		src_qnan			# yes
1370	bra.b		_L4_6d
1371_L4_5d:
1372	bsr.l		setoxm1d			# operand is a DENORM
1373_L4_6d:
1374
1375#
1376#	Result is now in FP0
1377#
1378	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1379	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1380	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1381	unlk		%a6
1382	rts
1383
1384	global		_fetoxm1x_
1385_fetoxm1x_:
1386	link		%a6,&-LOCAL_SIZE
1387
1388	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1389	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1390	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1391
1392	fmov.l		&0x0,%fpcr		# zero FPCR
1393
1394#
1395#	copy, convert, and tag input argument
1396#
1397	lea		FP_SRC(%a6),%a0
1398	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
1399	mov.l		0x8+0x4(%a6),0x4(%a0)
1400	mov.l		0x8+0x8(%a6),0x8(%a0)
1401	bsr.l		tag			# fetch operand type
1402	mov.b		%d0,STAG(%a6)
1403	mov.b		%d0,%d1
1404
1405	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1406
1407	clr.l		%d0
1408	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1409
1410	tst.b		%d1
1411	bne.b		_L4_2x
1412	bsr.l		setoxm1			# operand is a NORM
1413	bra.b		_L4_6x
1414_L4_2x:
1415	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1416	bne.b		_L4_3x			# no
1417	bsr.l		src_zero			# yes
1418	bra.b		_L4_6x
1419_L4_3x:
1420	cmpi.b		%d1,&INF		# is operand an INF?
1421	bne.b		_L4_4x			# no
1422	bsr.l		setoxm1i			# yes
1423	bra.b		_L4_6x
1424_L4_4x:
1425	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1426	bne.b		_L4_5x			# no
1427	bsr.l		src_qnan			# yes
1428	bra.b		_L4_6x
1429_L4_5x:
1430	bsr.l		setoxm1d			# operand is a DENORM
1431_L4_6x:
1432
1433#
1434#	Result is now in FP0
1435#
1436	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1437	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1438	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1439	unlk		%a6
1440	rts
1441
1442
1443#########################################################################
1444# MONADIC TEMPLATE							#
1445#########################################################################
1446	global		_ftanhs_
1447_ftanhs_:
1448	link		%a6,&-LOCAL_SIZE
1449
1450	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1451	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1452	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1453
1454	fmov.l		&0x0,%fpcr		# zero FPCR
1455
1456#
1457#	copy, convert, and tag input argument
1458#
1459	fmov.s		0x8(%a6),%fp0		# load sgl input
1460	fmov.x		%fp0,FP_SRC(%a6)
1461	lea		FP_SRC(%a6),%a0
1462	bsr.l		tag			# fetch operand type
1463	mov.b		%d0,STAG(%a6)
1464	mov.b		%d0,%d1
1465
1466	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1467
1468	clr.l		%d0
1469	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1470
1471	tst.b		%d1
1472	bne.b		_L5_2s
1473	bsr.l		stanh			# operand is a NORM
1474	bra.b		_L5_6s
1475_L5_2s:
1476	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1477	bne.b		_L5_3s			# no
1478	bsr.l		src_zero			# yes
1479	bra.b		_L5_6s
1480_L5_3s:
1481	cmpi.b		%d1,&INF		# is operand an INF?
1482	bne.b		_L5_4s			# no
1483	bsr.l		src_one			# yes
1484	bra.b		_L5_6s
1485_L5_4s:
1486	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1487	bne.b		_L5_5s			# no
1488	bsr.l		src_qnan			# yes
1489	bra.b		_L5_6s
1490_L5_5s:
1491	bsr.l		stanhd			# operand is a DENORM
1492_L5_6s:
1493
1494#
1495#	Result is now in FP0
1496#
1497	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1498	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1499	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1500	unlk		%a6
1501	rts
1502
1503	global		_ftanhd_
1504_ftanhd_:
1505	link		%a6,&-LOCAL_SIZE
1506
1507	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1508	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1509	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1510
1511	fmov.l		&0x0,%fpcr		# zero FPCR
1512
1513#
1514#	copy, convert, and tag input argument
1515#
1516	fmov.d		0x8(%a6),%fp0		# load dbl input
1517	fmov.x		%fp0,FP_SRC(%a6)
1518	lea		FP_SRC(%a6),%a0
1519	bsr.l		tag			# fetch operand type
1520	mov.b		%d0,STAG(%a6)
1521	mov.b		%d0,%d1
1522
1523	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1524
1525	clr.l		%d0
1526	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1527
1528	mov.b		%d1,STAG(%a6)
1529	tst.b		%d1
1530	bne.b		_L5_2d
1531	bsr.l		stanh			# operand is a NORM
1532	bra.b		_L5_6d
1533_L5_2d:
1534	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1535	bne.b		_L5_3d			# no
1536	bsr.l		src_zero			# yes
1537	bra.b		_L5_6d
1538_L5_3d:
1539	cmpi.b		%d1,&INF		# is operand an INF?
1540	bne.b		_L5_4d			# no
1541	bsr.l		src_one			# yes
1542	bra.b		_L5_6d
1543_L5_4d:
1544	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1545	bne.b		_L5_5d			# no
1546	bsr.l		src_qnan			# yes
1547	bra.b		_L5_6d
1548_L5_5d:
1549	bsr.l		stanhd			# operand is a DENORM
1550_L5_6d:
1551
1552#
1553#	Result is now in FP0
1554#
1555	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1556	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1557	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1558	unlk		%a6
1559	rts
1560
1561	global		_ftanhx_
1562_ftanhx_:
1563	link		%a6,&-LOCAL_SIZE
1564
1565	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1566	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1567	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1568
1569	fmov.l		&0x0,%fpcr		# zero FPCR
1570
1571#
1572#	copy, convert, and tag input argument
1573#
1574	lea		FP_SRC(%a6),%a0
1575	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
1576	mov.l		0x8+0x4(%a6),0x4(%a0)
1577	mov.l		0x8+0x8(%a6),0x8(%a0)
1578	bsr.l		tag			# fetch operand type
1579	mov.b		%d0,STAG(%a6)
1580	mov.b		%d0,%d1
1581
1582	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1583
1584	clr.l		%d0
1585	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1586
1587	tst.b		%d1
1588	bne.b		_L5_2x
1589	bsr.l		stanh			# operand is a NORM
1590	bra.b		_L5_6x
1591_L5_2x:
1592	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1593	bne.b		_L5_3x			# no
1594	bsr.l		src_zero			# yes
1595	bra.b		_L5_6x
1596_L5_3x:
1597	cmpi.b		%d1,&INF		# is operand an INF?
1598	bne.b		_L5_4x			# no
1599	bsr.l		src_one			# yes
1600	bra.b		_L5_6x
1601_L5_4x:
1602	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1603	bne.b		_L5_5x			# no
1604	bsr.l		src_qnan			# yes
1605	bra.b		_L5_6x
1606_L5_5x:
1607	bsr.l		stanhd			# operand is a DENORM
1608_L5_6x:
1609
1610#
1611#	Result is now in FP0
1612#
1613	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1614	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1615	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1616	unlk		%a6
1617	rts
1618
1619
1620#########################################################################
1621# MONADIC TEMPLATE							#
1622#########################################################################
1623	global		_fatans_
1624_fatans_:
1625	link		%a6,&-LOCAL_SIZE
1626
1627	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1628	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1629	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1630
1631	fmov.l		&0x0,%fpcr		# zero FPCR
1632
1633#
1634#	copy, convert, and tag input argument
1635#
1636	fmov.s		0x8(%a6),%fp0		# load sgl input
1637	fmov.x		%fp0,FP_SRC(%a6)
1638	lea		FP_SRC(%a6),%a0
1639	bsr.l		tag			# fetch operand type
1640	mov.b		%d0,STAG(%a6)
1641	mov.b		%d0,%d1
1642
1643	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1644
1645	clr.l		%d0
1646	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1647
1648	tst.b		%d1
1649	bne.b		_L6_2s
1650	bsr.l		satan			# operand is a NORM
1651	bra.b		_L6_6s
1652_L6_2s:
1653	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1654	bne.b		_L6_3s			# no
1655	bsr.l		src_zero			# yes
1656	bra.b		_L6_6s
1657_L6_3s:
1658	cmpi.b		%d1,&INF		# is operand an INF?
1659	bne.b		_L6_4s			# no
1660	bsr.l		spi_2			# yes
1661	bra.b		_L6_6s
1662_L6_4s:
1663	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1664	bne.b		_L6_5s			# no
1665	bsr.l		src_qnan			# yes
1666	bra.b		_L6_6s
1667_L6_5s:
1668	bsr.l		satand			# operand is a DENORM
1669_L6_6s:
1670
1671#
1672#	Result is now in FP0
1673#
1674	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1675	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1676	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1677	unlk		%a6
1678	rts
1679
1680	global		_fatand_
1681_fatand_:
1682	link		%a6,&-LOCAL_SIZE
1683
1684	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1685	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1686	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1687
1688	fmov.l		&0x0,%fpcr		# zero FPCR
1689
1690#
1691#	copy, convert, and tag input argument
1692#
1693	fmov.d		0x8(%a6),%fp0		# load dbl input
1694	fmov.x		%fp0,FP_SRC(%a6)
1695	lea		FP_SRC(%a6),%a0
1696	bsr.l		tag			# fetch operand type
1697	mov.b		%d0,STAG(%a6)
1698	mov.b		%d0,%d1
1699
1700	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1701
1702	clr.l		%d0
1703	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1704
1705	mov.b		%d1,STAG(%a6)
1706	tst.b		%d1
1707	bne.b		_L6_2d
1708	bsr.l		satan			# operand is a NORM
1709	bra.b		_L6_6d
1710_L6_2d:
1711	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1712	bne.b		_L6_3d			# no
1713	bsr.l		src_zero			# yes
1714	bra.b		_L6_6d
1715_L6_3d:
1716	cmpi.b		%d1,&INF		# is operand an INF?
1717	bne.b		_L6_4d			# no
1718	bsr.l		spi_2			# yes
1719	bra.b		_L6_6d
1720_L6_4d:
1721	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1722	bne.b		_L6_5d			# no
1723	bsr.l		src_qnan			# yes
1724	bra.b		_L6_6d
1725_L6_5d:
1726	bsr.l		satand			# operand is a DENORM
1727_L6_6d:
1728
1729#
1730#	Result is now in FP0
1731#
1732	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1733	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1734	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1735	unlk		%a6
1736	rts
1737
1738	global		_fatanx_
1739_fatanx_:
1740	link		%a6,&-LOCAL_SIZE
1741
1742	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1743	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1744	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1745
1746	fmov.l		&0x0,%fpcr		# zero FPCR
1747
1748#
1749#	copy, convert, and tag input argument
1750#
1751	lea		FP_SRC(%a6),%a0
1752	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
1753	mov.l		0x8+0x4(%a6),0x4(%a0)
1754	mov.l		0x8+0x8(%a6),0x8(%a0)
1755	bsr.l		tag			# fetch operand type
1756	mov.b		%d0,STAG(%a6)
1757	mov.b		%d0,%d1
1758
1759	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1760
1761	clr.l		%d0
1762	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1763
1764	tst.b		%d1
1765	bne.b		_L6_2x
1766	bsr.l		satan			# operand is a NORM
1767	bra.b		_L6_6x
1768_L6_2x:
1769	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1770	bne.b		_L6_3x			# no
1771	bsr.l		src_zero			# yes
1772	bra.b		_L6_6x
1773_L6_3x:
1774	cmpi.b		%d1,&INF		# is operand an INF?
1775	bne.b		_L6_4x			# no
1776	bsr.l		spi_2			# yes
1777	bra.b		_L6_6x
1778_L6_4x:
1779	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1780	bne.b		_L6_5x			# no
1781	bsr.l		src_qnan			# yes
1782	bra.b		_L6_6x
1783_L6_5x:
1784	bsr.l		satand			# operand is a DENORM
1785_L6_6x:
1786
1787#
1788#	Result is now in FP0
1789#
1790	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1791	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1792	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1793	unlk		%a6
1794	rts
1795
1796
1797#########################################################################
1798# MONADIC TEMPLATE							#
1799#########################################################################
1800	global		_fasins_
1801_fasins_:
1802	link		%a6,&-LOCAL_SIZE
1803
1804	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1805	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1806	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1807
1808	fmov.l		&0x0,%fpcr		# zero FPCR
1809
1810#
1811#	copy, convert, and tag input argument
1812#
1813	fmov.s		0x8(%a6),%fp0		# load sgl input
1814	fmov.x		%fp0,FP_SRC(%a6)
1815	lea		FP_SRC(%a6),%a0
1816	bsr.l		tag			# fetch operand type
1817	mov.b		%d0,STAG(%a6)
1818	mov.b		%d0,%d1
1819
1820	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1821
1822	clr.l		%d0
1823	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1824
1825	tst.b		%d1
1826	bne.b		_L7_2s
1827	bsr.l		sasin			# operand is a NORM
1828	bra.b		_L7_6s
1829_L7_2s:
1830	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1831	bne.b		_L7_3s			# no
1832	bsr.l		src_zero			# yes
1833	bra.b		_L7_6s
1834_L7_3s:
1835	cmpi.b		%d1,&INF		# is operand an INF?
1836	bne.b		_L7_4s			# no
1837	bsr.l		t_operr			# yes
1838	bra.b		_L7_6s
1839_L7_4s:
1840	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1841	bne.b		_L7_5s			# no
1842	bsr.l		src_qnan			# yes
1843	bra.b		_L7_6s
1844_L7_5s:
1845	bsr.l		sasind			# operand is a DENORM
1846_L7_6s:
1847
1848#
1849#	Result is now in FP0
1850#
1851	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1852	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1853	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1854	unlk		%a6
1855	rts
1856
1857	global		_fasind_
1858_fasind_:
1859	link		%a6,&-LOCAL_SIZE
1860
1861	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1862	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1863	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1864
1865	fmov.l		&0x0,%fpcr		# zero FPCR
1866
1867#
1868#	copy, convert, and tag input argument
1869#
1870	fmov.d		0x8(%a6),%fp0		# load dbl input
1871	fmov.x		%fp0,FP_SRC(%a6)
1872	lea		FP_SRC(%a6),%a0
1873	bsr.l		tag			# fetch operand type
1874	mov.b		%d0,STAG(%a6)
1875	mov.b		%d0,%d1
1876
1877	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1878
1879	clr.l		%d0
1880	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1881
1882	mov.b		%d1,STAG(%a6)
1883	tst.b		%d1
1884	bne.b		_L7_2d
1885	bsr.l		sasin			# operand is a NORM
1886	bra.b		_L7_6d
1887_L7_2d:
1888	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1889	bne.b		_L7_3d			# no
1890	bsr.l		src_zero			# yes
1891	bra.b		_L7_6d
1892_L7_3d:
1893	cmpi.b		%d1,&INF		# is operand an INF?
1894	bne.b		_L7_4d			# no
1895	bsr.l		t_operr			# yes
1896	bra.b		_L7_6d
1897_L7_4d:
1898	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1899	bne.b		_L7_5d			# no
1900	bsr.l		src_qnan			# yes
1901	bra.b		_L7_6d
1902_L7_5d:
1903	bsr.l		sasind			# operand is a DENORM
1904_L7_6d:
1905
1906#
1907#	Result is now in FP0
1908#
1909	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1910	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1911	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1912	unlk		%a6
1913	rts
1914
1915	global		_fasinx_
1916_fasinx_:
1917	link		%a6,&-LOCAL_SIZE
1918
1919	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1920	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1921	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1922
1923	fmov.l		&0x0,%fpcr		# zero FPCR
1924
1925#
1926#	copy, convert, and tag input argument
1927#
1928	lea		FP_SRC(%a6),%a0
1929	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
1930	mov.l		0x8+0x4(%a6),0x4(%a0)
1931	mov.l		0x8+0x8(%a6),0x8(%a0)
1932	bsr.l		tag			# fetch operand type
1933	mov.b		%d0,STAG(%a6)
1934	mov.b		%d0,%d1
1935
1936	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1937
1938	clr.l		%d0
1939	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
1940
1941	tst.b		%d1
1942	bne.b		_L7_2x
1943	bsr.l		sasin			# operand is a NORM
1944	bra.b		_L7_6x
1945_L7_2x:
1946	cmpi.b		%d1,&ZERO		# is operand a ZERO?
1947	bne.b		_L7_3x			# no
1948	bsr.l		src_zero			# yes
1949	bra.b		_L7_6x
1950_L7_3x:
1951	cmpi.b		%d1,&INF		# is operand an INF?
1952	bne.b		_L7_4x			# no
1953	bsr.l		t_operr			# yes
1954	bra.b		_L7_6x
1955_L7_4x:
1956	cmpi.b		%d1,&QNAN		# is operand a QNAN?
1957	bne.b		_L7_5x			# no
1958	bsr.l		src_qnan			# yes
1959	bra.b		_L7_6x
1960_L7_5x:
1961	bsr.l		sasind			# operand is a DENORM
1962_L7_6x:
1963
1964#
1965#	Result is now in FP0
1966#
1967	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
1968	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1969	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
1970	unlk		%a6
1971	rts
1972
1973
1974#########################################################################
1975# MONADIC TEMPLATE							#
1976#########################################################################
1977	global		_fatanhs_
1978_fatanhs_:
1979	link		%a6,&-LOCAL_SIZE
1980
1981	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
1982	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1983	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
1984
1985	fmov.l		&0x0,%fpcr		# zero FPCR
1986
1987#
1988#	copy, convert, and tag input argument
1989#
1990	fmov.s		0x8(%a6),%fp0		# load sgl input
1991	fmov.x		%fp0,FP_SRC(%a6)
1992	lea		FP_SRC(%a6),%a0
1993	bsr.l		tag			# fetch operand type
1994	mov.b		%d0,STAG(%a6)
1995	mov.b		%d0,%d1
1996
1997	andi.l		&0x00ff00ff,USER_FPSR(%a6)
1998
1999	clr.l		%d0
2000	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2001
2002	tst.b		%d1
2003	bne.b		_L8_2s
2004	bsr.l		satanh			# operand is a NORM
2005	bra.b		_L8_6s
2006_L8_2s:
2007	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2008	bne.b		_L8_3s			# no
2009	bsr.l		src_zero			# yes
2010	bra.b		_L8_6s
2011_L8_3s:
2012	cmpi.b		%d1,&INF		# is operand an INF?
2013	bne.b		_L8_4s			# no
2014	bsr.l		t_operr			# yes
2015	bra.b		_L8_6s
2016_L8_4s:
2017	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2018	bne.b		_L8_5s			# no
2019	bsr.l		src_qnan			# yes
2020	bra.b		_L8_6s
2021_L8_5s:
2022	bsr.l		satanhd			# operand is a DENORM
2023_L8_6s:
2024
2025#
2026#	Result is now in FP0
2027#
2028	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2029	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2030	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2031	unlk		%a6
2032	rts
2033
2034	global		_fatanhd_
2035_fatanhd_:
2036	link		%a6,&-LOCAL_SIZE
2037
2038	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2039	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2040	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2041
2042	fmov.l		&0x0,%fpcr		# zero FPCR
2043
2044#
2045#	copy, convert, and tag input argument
2046#
2047	fmov.d		0x8(%a6),%fp0		# load dbl input
2048	fmov.x		%fp0,FP_SRC(%a6)
2049	lea		FP_SRC(%a6),%a0
2050	bsr.l		tag			# fetch operand type
2051	mov.b		%d0,STAG(%a6)
2052	mov.b		%d0,%d1
2053
2054	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2055
2056	clr.l		%d0
2057	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2058
2059	mov.b		%d1,STAG(%a6)
2060	tst.b		%d1
2061	bne.b		_L8_2d
2062	bsr.l		satanh			# operand is a NORM
2063	bra.b		_L8_6d
2064_L8_2d:
2065	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2066	bne.b		_L8_3d			# no
2067	bsr.l		src_zero			# yes
2068	bra.b		_L8_6d
2069_L8_3d:
2070	cmpi.b		%d1,&INF		# is operand an INF?
2071	bne.b		_L8_4d			# no
2072	bsr.l		t_operr			# yes
2073	bra.b		_L8_6d
2074_L8_4d:
2075	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2076	bne.b		_L8_5d			# no
2077	bsr.l		src_qnan			# yes
2078	bra.b		_L8_6d
2079_L8_5d:
2080	bsr.l		satanhd			# operand is a DENORM
2081_L8_6d:
2082
2083#
2084#	Result is now in FP0
2085#
2086	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2087	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2088	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2089	unlk		%a6
2090	rts
2091
2092	global		_fatanhx_
2093_fatanhx_:
2094	link		%a6,&-LOCAL_SIZE
2095
2096	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2097	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2098	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2099
2100	fmov.l		&0x0,%fpcr		# zero FPCR
2101
2102#
2103#	copy, convert, and tag input argument
2104#
2105	lea		FP_SRC(%a6),%a0
2106	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
2107	mov.l		0x8+0x4(%a6),0x4(%a0)
2108	mov.l		0x8+0x8(%a6),0x8(%a0)
2109	bsr.l		tag			# fetch operand type
2110	mov.b		%d0,STAG(%a6)
2111	mov.b		%d0,%d1
2112
2113	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2114
2115	clr.l		%d0
2116	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2117
2118	tst.b		%d1
2119	bne.b		_L8_2x
2120	bsr.l		satanh			# operand is a NORM
2121	bra.b		_L8_6x
2122_L8_2x:
2123	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2124	bne.b		_L8_3x			# no
2125	bsr.l		src_zero			# yes
2126	bra.b		_L8_6x
2127_L8_3x:
2128	cmpi.b		%d1,&INF		# is operand an INF?
2129	bne.b		_L8_4x			# no
2130	bsr.l		t_operr			# yes
2131	bra.b		_L8_6x
2132_L8_4x:
2133	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2134	bne.b		_L8_5x			# no
2135	bsr.l		src_qnan			# yes
2136	bra.b		_L8_6x
2137_L8_5x:
2138	bsr.l		satanhd			# operand is a DENORM
2139_L8_6x:
2140
2141#
2142#	Result is now in FP0
2143#
2144	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2145	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2146	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2147	unlk		%a6
2148	rts
2149
2150
2151#########################################################################
2152# MONADIC TEMPLATE							#
2153#########################################################################
2154	global		_ftans_
2155_ftans_:
2156	link		%a6,&-LOCAL_SIZE
2157
2158	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2159	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2160	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2161
2162	fmov.l		&0x0,%fpcr		# zero FPCR
2163
2164#
2165#	copy, convert, and tag input argument
2166#
2167	fmov.s		0x8(%a6),%fp0		# load sgl input
2168	fmov.x		%fp0,FP_SRC(%a6)
2169	lea		FP_SRC(%a6),%a0
2170	bsr.l		tag			# fetch operand type
2171	mov.b		%d0,STAG(%a6)
2172	mov.b		%d0,%d1
2173
2174	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2175
2176	clr.l		%d0
2177	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2178
2179	tst.b		%d1
2180	bne.b		_L9_2s
2181	bsr.l		stan			# operand is a NORM
2182	bra.b		_L9_6s
2183_L9_2s:
2184	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2185	bne.b		_L9_3s			# no
2186	bsr.l		src_zero			# yes
2187	bra.b		_L9_6s
2188_L9_3s:
2189	cmpi.b		%d1,&INF		# is operand an INF?
2190	bne.b		_L9_4s			# no
2191	bsr.l		t_operr			# yes
2192	bra.b		_L9_6s
2193_L9_4s:
2194	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2195	bne.b		_L9_5s			# no
2196	bsr.l		src_qnan			# yes
2197	bra.b		_L9_6s
2198_L9_5s:
2199	bsr.l		stand			# operand is a DENORM
2200_L9_6s:
2201
2202#
2203#	Result is now in FP0
2204#
2205	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2206	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2207	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2208	unlk		%a6
2209	rts
2210
2211	global		_ftand_
2212_ftand_:
2213	link		%a6,&-LOCAL_SIZE
2214
2215	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2216	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2217	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2218
2219	fmov.l		&0x0,%fpcr		# zero FPCR
2220
2221#
2222#	copy, convert, and tag input argument
2223#
2224	fmov.d		0x8(%a6),%fp0		# load dbl input
2225	fmov.x		%fp0,FP_SRC(%a6)
2226	lea		FP_SRC(%a6),%a0
2227	bsr.l		tag			# fetch operand type
2228	mov.b		%d0,STAG(%a6)
2229	mov.b		%d0,%d1
2230
2231	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2232
2233	clr.l		%d0
2234	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2235
2236	mov.b		%d1,STAG(%a6)
2237	tst.b		%d1
2238	bne.b		_L9_2d
2239	bsr.l		stan			# operand is a NORM
2240	bra.b		_L9_6d
2241_L9_2d:
2242	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2243	bne.b		_L9_3d			# no
2244	bsr.l		src_zero			# yes
2245	bra.b		_L9_6d
2246_L9_3d:
2247	cmpi.b		%d1,&INF		# is operand an INF?
2248	bne.b		_L9_4d			# no
2249	bsr.l		t_operr			# yes
2250	bra.b		_L9_6d
2251_L9_4d:
2252	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2253	bne.b		_L9_5d			# no
2254	bsr.l		src_qnan			# yes
2255	bra.b		_L9_6d
2256_L9_5d:
2257	bsr.l		stand			# operand is a DENORM
2258_L9_6d:
2259
2260#
2261#	Result is now in FP0
2262#
2263	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2264	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2265	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2266	unlk		%a6
2267	rts
2268
2269	global		_ftanx_
2270_ftanx_:
2271	link		%a6,&-LOCAL_SIZE
2272
2273	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2274	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2275	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2276
2277	fmov.l		&0x0,%fpcr		# zero FPCR
2278
2279#
2280#	copy, convert, and tag input argument
2281#
2282	lea		FP_SRC(%a6),%a0
2283	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
2284	mov.l		0x8+0x4(%a6),0x4(%a0)
2285	mov.l		0x8+0x8(%a6),0x8(%a0)
2286	bsr.l		tag			# fetch operand type
2287	mov.b		%d0,STAG(%a6)
2288	mov.b		%d0,%d1
2289
2290	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2291
2292	clr.l		%d0
2293	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2294
2295	tst.b		%d1
2296	bne.b		_L9_2x
2297	bsr.l		stan			# operand is a NORM
2298	bra.b		_L9_6x
2299_L9_2x:
2300	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2301	bne.b		_L9_3x			# no
2302	bsr.l		src_zero			# yes
2303	bra.b		_L9_6x
2304_L9_3x:
2305	cmpi.b		%d1,&INF		# is operand an INF?
2306	bne.b		_L9_4x			# no
2307	bsr.l		t_operr			# yes
2308	bra.b		_L9_6x
2309_L9_4x:
2310	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2311	bne.b		_L9_5x			# no
2312	bsr.l		src_qnan			# yes
2313	bra.b		_L9_6x
2314_L9_5x:
2315	bsr.l		stand			# operand is a DENORM
2316_L9_6x:
2317
2318#
2319#	Result is now in FP0
2320#
2321	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2322	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2323	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2324	unlk		%a6
2325	rts
2326
2327
2328#########################################################################
2329# MONADIC TEMPLATE							#
2330#########################################################################
2331	global		_fetoxs_
2332_fetoxs_:
2333	link		%a6,&-LOCAL_SIZE
2334
2335	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2336	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2337	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2338
2339	fmov.l		&0x0,%fpcr		# zero FPCR
2340
2341#
2342#	copy, convert, and tag input argument
2343#
2344	fmov.s		0x8(%a6),%fp0		# load sgl input
2345	fmov.x		%fp0,FP_SRC(%a6)
2346	lea		FP_SRC(%a6),%a0
2347	bsr.l		tag			# fetch operand type
2348	mov.b		%d0,STAG(%a6)
2349	mov.b		%d0,%d1
2350
2351	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2352
2353	clr.l		%d0
2354	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2355
2356	tst.b		%d1
2357	bne.b		_L10_2s
2358	bsr.l		setox			# operand is a NORM
2359	bra.b		_L10_6s
2360_L10_2s:
2361	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2362	bne.b		_L10_3s			# no
2363	bsr.l		ld_pone			# yes
2364	bra.b		_L10_6s
2365_L10_3s:
2366	cmpi.b		%d1,&INF		# is operand an INF?
2367	bne.b		_L10_4s			# no
2368	bsr.l		szr_inf			# yes
2369	bra.b		_L10_6s
2370_L10_4s:
2371	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2372	bne.b		_L10_5s			# no
2373	bsr.l		src_qnan			# yes
2374	bra.b		_L10_6s
2375_L10_5s:
2376	bsr.l		setoxd			# operand is a DENORM
2377_L10_6s:
2378
2379#
2380#	Result is now in FP0
2381#
2382	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2383	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2384	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2385	unlk		%a6
2386	rts
2387
2388	global		_fetoxd_
2389_fetoxd_:
2390	link		%a6,&-LOCAL_SIZE
2391
2392	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2393	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2394	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2395
2396	fmov.l		&0x0,%fpcr		# zero FPCR
2397
2398#
2399#	copy, convert, and tag input argument
2400#
2401	fmov.d		0x8(%a6),%fp0		# load dbl input
2402	fmov.x		%fp0,FP_SRC(%a6)
2403	lea		FP_SRC(%a6),%a0
2404	bsr.l		tag			# fetch operand type
2405	mov.b		%d0,STAG(%a6)
2406	mov.b		%d0,%d1
2407
2408	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2409
2410	clr.l		%d0
2411	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2412
2413	mov.b		%d1,STAG(%a6)
2414	tst.b		%d1
2415	bne.b		_L10_2d
2416	bsr.l		setox			# operand is a NORM
2417	bra.b		_L10_6d
2418_L10_2d:
2419	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2420	bne.b		_L10_3d			# no
2421	bsr.l		ld_pone			# yes
2422	bra.b		_L10_6d
2423_L10_3d:
2424	cmpi.b		%d1,&INF		# is operand an INF?
2425	bne.b		_L10_4d			# no
2426	bsr.l		szr_inf			# yes
2427	bra.b		_L10_6d
2428_L10_4d:
2429	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2430	bne.b		_L10_5d			# no
2431	bsr.l		src_qnan			# yes
2432	bra.b		_L10_6d
2433_L10_5d:
2434	bsr.l		setoxd			# operand is a DENORM
2435_L10_6d:
2436
2437#
2438#	Result is now in FP0
2439#
2440	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2441	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2442	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2443	unlk		%a6
2444	rts
2445
2446	global		_fetoxx_
2447_fetoxx_:
2448	link		%a6,&-LOCAL_SIZE
2449
2450	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2451	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2452	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2453
2454	fmov.l		&0x0,%fpcr		# zero FPCR
2455
2456#
2457#	copy, convert, and tag input argument
2458#
2459	lea		FP_SRC(%a6),%a0
2460	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
2461	mov.l		0x8+0x4(%a6),0x4(%a0)
2462	mov.l		0x8+0x8(%a6),0x8(%a0)
2463	bsr.l		tag			# fetch operand type
2464	mov.b		%d0,STAG(%a6)
2465	mov.b		%d0,%d1
2466
2467	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2468
2469	clr.l		%d0
2470	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2471
2472	tst.b		%d1
2473	bne.b		_L10_2x
2474	bsr.l		setox			# operand is a NORM
2475	bra.b		_L10_6x
2476_L10_2x:
2477	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2478	bne.b		_L10_3x			# no
2479	bsr.l		ld_pone			# yes
2480	bra.b		_L10_6x
2481_L10_3x:
2482	cmpi.b		%d1,&INF		# is operand an INF?
2483	bne.b		_L10_4x			# no
2484	bsr.l		szr_inf			# yes
2485	bra.b		_L10_6x
2486_L10_4x:
2487	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2488	bne.b		_L10_5x			# no
2489	bsr.l		src_qnan			# yes
2490	bra.b		_L10_6x
2491_L10_5x:
2492	bsr.l		setoxd			# operand is a DENORM
2493_L10_6x:
2494
2495#
2496#	Result is now in FP0
2497#
2498	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2499	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2500	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2501	unlk		%a6
2502	rts
2503
2504
2505#########################################################################
2506# MONADIC TEMPLATE							#
2507#########################################################################
2508	global		_ftwotoxs_
2509_ftwotoxs_:
2510	link		%a6,&-LOCAL_SIZE
2511
2512	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2513	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2514	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2515
2516	fmov.l		&0x0,%fpcr		# zero FPCR
2517
2518#
2519#	copy, convert, and tag input argument
2520#
2521	fmov.s		0x8(%a6),%fp0		# load sgl input
2522	fmov.x		%fp0,FP_SRC(%a6)
2523	lea		FP_SRC(%a6),%a0
2524	bsr.l		tag			# fetch operand type
2525	mov.b		%d0,STAG(%a6)
2526	mov.b		%d0,%d1
2527
2528	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2529
2530	clr.l		%d0
2531	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2532
2533	tst.b		%d1
2534	bne.b		_L11_2s
2535	bsr.l		stwotox			# operand is a NORM
2536	bra.b		_L11_6s
2537_L11_2s:
2538	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2539	bne.b		_L11_3s			# no
2540	bsr.l		ld_pone			# yes
2541	bra.b		_L11_6s
2542_L11_3s:
2543	cmpi.b		%d1,&INF		# is operand an INF?
2544	bne.b		_L11_4s			# no
2545	bsr.l		szr_inf			# yes
2546	bra.b		_L11_6s
2547_L11_4s:
2548	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2549	bne.b		_L11_5s			# no
2550	bsr.l		src_qnan			# yes
2551	bra.b		_L11_6s
2552_L11_5s:
2553	bsr.l		stwotoxd			# operand is a DENORM
2554_L11_6s:
2555
2556#
2557#	Result is now in FP0
2558#
2559	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2560	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2561	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2562	unlk		%a6
2563	rts
2564
2565	global		_ftwotoxd_
2566_ftwotoxd_:
2567	link		%a6,&-LOCAL_SIZE
2568
2569	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2570	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2571	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2572
2573	fmov.l		&0x0,%fpcr		# zero FPCR
2574
2575#
2576#	copy, convert, and tag input argument
2577#
2578	fmov.d		0x8(%a6),%fp0		# load dbl input
2579	fmov.x		%fp0,FP_SRC(%a6)
2580	lea		FP_SRC(%a6),%a0
2581	bsr.l		tag			# fetch operand type
2582	mov.b		%d0,STAG(%a6)
2583	mov.b		%d0,%d1
2584
2585	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2586
2587	clr.l		%d0
2588	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2589
2590	mov.b		%d1,STAG(%a6)
2591	tst.b		%d1
2592	bne.b		_L11_2d
2593	bsr.l		stwotox			# operand is a NORM
2594	bra.b		_L11_6d
2595_L11_2d:
2596	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2597	bne.b		_L11_3d			# no
2598	bsr.l		ld_pone			# yes
2599	bra.b		_L11_6d
2600_L11_3d:
2601	cmpi.b		%d1,&INF		# is operand an INF?
2602	bne.b		_L11_4d			# no
2603	bsr.l		szr_inf			# yes
2604	bra.b		_L11_6d
2605_L11_4d:
2606	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2607	bne.b		_L11_5d			# no
2608	bsr.l		src_qnan			# yes
2609	bra.b		_L11_6d
2610_L11_5d:
2611	bsr.l		stwotoxd			# operand is a DENORM
2612_L11_6d:
2613
2614#
2615#	Result is now in FP0
2616#
2617	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2618	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2619	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2620	unlk		%a6
2621	rts
2622
2623	global		_ftwotoxx_
2624_ftwotoxx_:
2625	link		%a6,&-LOCAL_SIZE
2626
2627	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2628	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2629	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2630
2631	fmov.l		&0x0,%fpcr		# zero FPCR
2632
2633#
2634#	copy, convert, and tag input argument
2635#
2636	lea		FP_SRC(%a6),%a0
2637	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
2638	mov.l		0x8+0x4(%a6),0x4(%a0)
2639	mov.l		0x8+0x8(%a6),0x8(%a0)
2640	bsr.l		tag			# fetch operand type
2641	mov.b		%d0,STAG(%a6)
2642	mov.b		%d0,%d1
2643
2644	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2645
2646	clr.l		%d0
2647	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2648
2649	tst.b		%d1
2650	bne.b		_L11_2x
2651	bsr.l		stwotox			# operand is a NORM
2652	bra.b		_L11_6x
2653_L11_2x:
2654	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2655	bne.b		_L11_3x			# no
2656	bsr.l		ld_pone			# yes
2657	bra.b		_L11_6x
2658_L11_3x:
2659	cmpi.b		%d1,&INF		# is operand an INF?
2660	bne.b		_L11_4x			# no
2661	bsr.l		szr_inf			# yes
2662	bra.b		_L11_6x
2663_L11_4x:
2664	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2665	bne.b		_L11_5x			# no
2666	bsr.l		src_qnan			# yes
2667	bra.b		_L11_6x
2668_L11_5x:
2669	bsr.l		stwotoxd			# operand is a DENORM
2670_L11_6x:
2671
2672#
2673#	Result is now in FP0
2674#
2675	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2676	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2677	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2678	unlk		%a6
2679	rts
2680
2681
2682#########################################################################
2683# MONADIC TEMPLATE							#
2684#########################################################################
2685	global		_ftentoxs_
2686_ftentoxs_:
2687	link		%a6,&-LOCAL_SIZE
2688
2689	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2690	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2691	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2692
2693	fmov.l		&0x0,%fpcr		# zero FPCR
2694
2695#
2696#	copy, convert, and tag input argument
2697#
2698	fmov.s		0x8(%a6),%fp0		# load sgl input
2699	fmov.x		%fp0,FP_SRC(%a6)
2700	lea		FP_SRC(%a6),%a0
2701	bsr.l		tag			# fetch operand type
2702	mov.b		%d0,STAG(%a6)
2703	mov.b		%d0,%d1
2704
2705	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2706
2707	clr.l		%d0
2708	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2709
2710	tst.b		%d1
2711	bne.b		_L12_2s
2712	bsr.l		stentox			# operand is a NORM
2713	bra.b		_L12_6s
2714_L12_2s:
2715	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2716	bne.b		_L12_3s			# no
2717	bsr.l		ld_pone			# yes
2718	bra.b		_L12_6s
2719_L12_3s:
2720	cmpi.b		%d1,&INF		# is operand an INF?
2721	bne.b		_L12_4s			# no
2722	bsr.l		szr_inf			# yes
2723	bra.b		_L12_6s
2724_L12_4s:
2725	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2726	bne.b		_L12_5s			# no
2727	bsr.l		src_qnan			# yes
2728	bra.b		_L12_6s
2729_L12_5s:
2730	bsr.l		stentoxd			# operand is a DENORM
2731_L12_6s:
2732
2733#
2734#	Result is now in FP0
2735#
2736	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2737	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2738	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2739	unlk		%a6
2740	rts
2741
2742	global		_ftentoxd_
2743_ftentoxd_:
2744	link		%a6,&-LOCAL_SIZE
2745
2746	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2747	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2748	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2749
2750	fmov.l		&0x0,%fpcr		# zero FPCR
2751
2752#
2753#	copy, convert, and tag input argument
2754#
2755	fmov.d		0x8(%a6),%fp0		# load dbl input
2756	fmov.x		%fp0,FP_SRC(%a6)
2757	lea		FP_SRC(%a6),%a0
2758	bsr.l		tag			# fetch operand type
2759	mov.b		%d0,STAG(%a6)
2760	mov.b		%d0,%d1
2761
2762	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2763
2764	clr.l		%d0
2765	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2766
2767	mov.b		%d1,STAG(%a6)
2768	tst.b		%d1
2769	bne.b		_L12_2d
2770	bsr.l		stentox			# operand is a NORM
2771	bra.b		_L12_6d
2772_L12_2d:
2773	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2774	bne.b		_L12_3d			# no
2775	bsr.l		ld_pone			# yes
2776	bra.b		_L12_6d
2777_L12_3d:
2778	cmpi.b		%d1,&INF		# is operand an INF?
2779	bne.b		_L12_4d			# no
2780	bsr.l		szr_inf			# yes
2781	bra.b		_L12_6d
2782_L12_4d:
2783	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2784	bne.b		_L12_5d			# no
2785	bsr.l		src_qnan			# yes
2786	bra.b		_L12_6d
2787_L12_5d:
2788	bsr.l		stentoxd			# operand is a DENORM
2789_L12_6d:
2790
2791#
2792#	Result is now in FP0
2793#
2794	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2795	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2796	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2797	unlk		%a6
2798	rts
2799
2800	global		_ftentoxx_
2801_ftentoxx_:
2802	link		%a6,&-LOCAL_SIZE
2803
2804	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2805	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2806	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2807
2808	fmov.l		&0x0,%fpcr		# zero FPCR
2809
2810#
2811#	copy, convert, and tag input argument
2812#
2813	lea		FP_SRC(%a6),%a0
2814	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
2815	mov.l		0x8+0x4(%a6),0x4(%a0)
2816	mov.l		0x8+0x8(%a6),0x8(%a0)
2817	bsr.l		tag			# fetch operand type
2818	mov.b		%d0,STAG(%a6)
2819	mov.b		%d0,%d1
2820
2821	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2822
2823	clr.l		%d0
2824	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2825
2826	tst.b		%d1
2827	bne.b		_L12_2x
2828	bsr.l		stentox			# operand is a NORM
2829	bra.b		_L12_6x
2830_L12_2x:
2831	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2832	bne.b		_L12_3x			# no
2833	bsr.l		ld_pone			# yes
2834	bra.b		_L12_6x
2835_L12_3x:
2836	cmpi.b		%d1,&INF		# is operand an INF?
2837	bne.b		_L12_4x			# no
2838	bsr.l		szr_inf			# yes
2839	bra.b		_L12_6x
2840_L12_4x:
2841	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2842	bne.b		_L12_5x			# no
2843	bsr.l		src_qnan			# yes
2844	bra.b		_L12_6x
2845_L12_5x:
2846	bsr.l		stentoxd			# operand is a DENORM
2847_L12_6x:
2848
2849#
2850#	Result is now in FP0
2851#
2852	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2853	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2854	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2855	unlk		%a6
2856	rts
2857
2858
2859#########################################################################
2860# MONADIC TEMPLATE							#
2861#########################################################################
2862	global		_flogns_
2863_flogns_:
2864	link		%a6,&-LOCAL_SIZE
2865
2866	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2867	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2868	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2869
2870	fmov.l		&0x0,%fpcr		# zero FPCR
2871
2872#
2873#	copy, convert, and tag input argument
2874#
2875	fmov.s		0x8(%a6),%fp0		# load sgl input
2876	fmov.x		%fp0,FP_SRC(%a6)
2877	lea		FP_SRC(%a6),%a0
2878	bsr.l		tag			# fetch operand type
2879	mov.b		%d0,STAG(%a6)
2880	mov.b		%d0,%d1
2881
2882	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2883
2884	clr.l		%d0
2885	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2886
2887	tst.b		%d1
2888	bne.b		_L13_2s
2889	bsr.l		slogn			# operand is a NORM
2890	bra.b		_L13_6s
2891_L13_2s:
2892	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2893	bne.b		_L13_3s			# no
2894	bsr.l		t_dz2			# yes
2895	bra.b		_L13_6s
2896_L13_3s:
2897	cmpi.b		%d1,&INF		# is operand an INF?
2898	bne.b		_L13_4s			# no
2899	bsr.l		sopr_inf			# yes
2900	bra.b		_L13_6s
2901_L13_4s:
2902	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2903	bne.b		_L13_5s			# no
2904	bsr.l		src_qnan			# yes
2905	bra.b		_L13_6s
2906_L13_5s:
2907	bsr.l		slognd			# operand is a DENORM
2908_L13_6s:
2909
2910#
2911#	Result is now in FP0
2912#
2913	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2914	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2915	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2916	unlk		%a6
2917	rts
2918
2919	global		_flognd_
2920_flognd_:
2921	link		%a6,&-LOCAL_SIZE
2922
2923	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2924	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2925	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2926
2927	fmov.l		&0x0,%fpcr		# zero FPCR
2928
2929#
2930#	copy, convert, and tag input argument
2931#
2932	fmov.d		0x8(%a6),%fp0		# load dbl input
2933	fmov.x		%fp0,FP_SRC(%a6)
2934	lea		FP_SRC(%a6),%a0
2935	bsr.l		tag			# fetch operand type
2936	mov.b		%d0,STAG(%a6)
2937	mov.b		%d0,%d1
2938
2939	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2940
2941	clr.l		%d0
2942	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
2943
2944	mov.b		%d1,STAG(%a6)
2945	tst.b		%d1
2946	bne.b		_L13_2d
2947	bsr.l		slogn			# operand is a NORM
2948	bra.b		_L13_6d
2949_L13_2d:
2950	cmpi.b		%d1,&ZERO		# is operand a ZERO?
2951	bne.b		_L13_3d			# no
2952	bsr.l		t_dz2			# yes
2953	bra.b		_L13_6d
2954_L13_3d:
2955	cmpi.b		%d1,&INF		# is operand an INF?
2956	bne.b		_L13_4d			# no
2957	bsr.l		sopr_inf			# yes
2958	bra.b		_L13_6d
2959_L13_4d:
2960	cmpi.b		%d1,&QNAN		# is operand a QNAN?
2961	bne.b		_L13_5d			# no
2962	bsr.l		src_qnan			# yes
2963	bra.b		_L13_6d
2964_L13_5d:
2965	bsr.l		slognd			# operand is a DENORM
2966_L13_6d:
2967
2968#
2969#	Result is now in FP0
2970#
2971	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
2972	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2973	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
2974	unlk		%a6
2975	rts
2976
2977	global		_flognx_
2978_flognx_:
2979	link		%a6,&-LOCAL_SIZE
2980
2981	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
2982	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2983	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
2984
2985	fmov.l		&0x0,%fpcr		# zero FPCR
2986
2987#
2988#	copy, convert, and tag input argument
2989#
2990	lea		FP_SRC(%a6),%a0
2991	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
2992	mov.l		0x8+0x4(%a6),0x4(%a0)
2993	mov.l		0x8+0x8(%a6),0x8(%a0)
2994	bsr.l		tag			# fetch operand type
2995	mov.b		%d0,STAG(%a6)
2996	mov.b		%d0,%d1
2997
2998	andi.l		&0x00ff00ff,USER_FPSR(%a6)
2999
3000	clr.l		%d0
3001	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3002
3003	tst.b		%d1
3004	bne.b		_L13_2x
3005	bsr.l		slogn			# operand is a NORM
3006	bra.b		_L13_6x
3007_L13_2x:
3008	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3009	bne.b		_L13_3x			# no
3010	bsr.l		t_dz2			# yes
3011	bra.b		_L13_6x
3012_L13_3x:
3013	cmpi.b		%d1,&INF		# is operand an INF?
3014	bne.b		_L13_4x			# no
3015	bsr.l		sopr_inf			# yes
3016	bra.b		_L13_6x
3017_L13_4x:
3018	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3019	bne.b		_L13_5x			# no
3020	bsr.l		src_qnan			# yes
3021	bra.b		_L13_6x
3022_L13_5x:
3023	bsr.l		slognd			# operand is a DENORM
3024_L13_6x:
3025
3026#
3027#	Result is now in FP0
3028#
3029	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3030	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3031	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3032	unlk		%a6
3033	rts
3034
3035
3036#########################################################################
3037# MONADIC TEMPLATE							#
3038#########################################################################
3039	global		_flog10s_
3040_flog10s_:
3041	link		%a6,&-LOCAL_SIZE
3042
3043	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3044	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3045	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3046
3047	fmov.l		&0x0,%fpcr		# zero FPCR
3048
3049#
3050#	copy, convert, and tag input argument
3051#
3052	fmov.s		0x8(%a6),%fp0		# load sgl input
3053	fmov.x		%fp0,FP_SRC(%a6)
3054	lea		FP_SRC(%a6),%a0
3055	bsr.l		tag			# fetch operand type
3056	mov.b		%d0,STAG(%a6)
3057	mov.b		%d0,%d1
3058
3059	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3060
3061	clr.l		%d0
3062	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3063
3064	tst.b		%d1
3065	bne.b		_L14_2s
3066	bsr.l		slog10			# operand is a NORM
3067	bra.b		_L14_6s
3068_L14_2s:
3069	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3070	bne.b		_L14_3s			# no
3071	bsr.l		t_dz2			# yes
3072	bra.b		_L14_6s
3073_L14_3s:
3074	cmpi.b		%d1,&INF		# is operand an INF?
3075	bne.b		_L14_4s			# no
3076	bsr.l		sopr_inf			# yes
3077	bra.b		_L14_6s
3078_L14_4s:
3079	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3080	bne.b		_L14_5s			# no
3081	bsr.l		src_qnan			# yes
3082	bra.b		_L14_6s
3083_L14_5s:
3084	bsr.l		slog10d			# operand is a DENORM
3085_L14_6s:
3086
3087#
3088#	Result is now in FP0
3089#
3090	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3091	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3092	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3093	unlk		%a6
3094	rts
3095
3096	global		_flog10d_
3097_flog10d_:
3098	link		%a6,&-LOCAL_SIZE
3099
3100	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3101	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3102	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3103
3104	fmov.l		&0x0,%fpcr		# zero FPCR
3105
3106#
3107#	copy, convert, and tag input argument
3108#
3109	fmov.d		0x8(%a6),%fp0		# load dbl input
3110	fmov.x		%fp0,FP_SRC(%a6)
3111	lea		FP_SRC(%a6),%a0
3112	bsr.l		tag			# fetch operand type
3113	mov.b		%d0,STAG(%a6)
3114	mov.b		%d0,%d1
3115
3116	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3117
3118	clr.l		%d0
3119	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3120
3121	mov.b		%d1,STAG(%a6)
3122	tst.b		%d1
3123	bne.b		_L14_2d
3124	bsr.l		slog10			# operand is a NORM
3125	bra.b		_L14_6d
3126_L14_2d:
3127	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3128	bne.b		_L14_3d			# no
3129	bsr.l		t_dz2			# yes
3130	bra.b		_L14_6d
3131_L14_3d:
3132	cmpi.b		%d1,&INF		# is operand an INF?
3133	bne.b		_L14_4d			# no
3134	bsr.l		sopr_inf			# yes
3135	bra.b		_L14_6d
3136_L14_4d:
3137	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3138	bne.b		_L14_5d			# no
3139	bsr.l		src_qnan			# yes
3140	bra.b		_L14_6d
3141_L14_5d:
3142	bsr.l		slog10d			# operand is a DENORM
3143_L14_6d:
3144
3145#
3146#	Result is now in FP0
3147#
3148	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3149	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3150	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3151	unlk		%a6
3152	rts
3153
3154	global		_flog10x_
3155_flog10x_:
3156	link		%a6,&-LOCAL_SIZE
3157
3158	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3159	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3160	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3161
3162	fmov.l		&0x0,%fpcr		# zero FPCR
3163
3164#
3165#	copy, convert, and tag input argument
3166#
3167	lea		FP_SRC(%a6),%a0
3168	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
3169	mov.l		0x8+0x4(%a6),0x4(%a0)
3170	mov.l		0x8+0x8(%a6),0x8(%a0)
3171	bsr.l		tag			# fetch operand type
3172	mov.b		%d0,STAG(%a6)
3173	mov.b		%d0,%d1
3174
3175	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3176
3177	clr.l		%d0
3178	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3179
3180	tst.b		%d1
3181	bne.b		_L14_2x
3182	bsr.l		slog10			# operand is a NORM
3183	bra.b		_L14_6x
3184_L14_2x:
3185	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3186	bne.b		_L14_3x			# no
3187	bsr.l		t_dz2			# yes
3188	bra.b		_L14_6x
3189_L14_3x:
3190	cmpi.b		%d1,&INF		# is operand an INF?
3191	bne.b		_L14_4x			# no
3192	bsr.l		sopr_inf			# yes
3193	bra.b		_L14_6x
3194_L14_4x:
3195	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3196	bne.b		_L14_5x			# no
3197	bsr.l		src_qnan			# yes
3198	bra.b		_L14_6x
3199_L14_5x:
3200	bsr.l		slog10d			# operand is a DENORM
3201_L14_6x:
3202
3203#
3204#	Result is now in FP0
3205#
3206	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3207	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3208	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3209	unlk		%a6
3210	rts
3211
3212
3213#########################################################################
3214# MONADIC TEMPLATE							#
3215#########################################################################
3216	global		_flog2s_
3217_flog2s_:
3218	link		%a6,&-LOCAL_SIZE
3219
3220	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3221	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3222	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3223
3224	fmov.l		&0x0,%fpcr		# zero FPCR
3225
3226#
3227#	copy, convert, and tag input argument
3228#
3229	fmov.s		0x8(%a6),%fp0		# load sgl input
3230	fmov.x		%fp0,FP_SRC(%a6)
3231	lea		FP_SRC(%a6),%a0
3232	bsr.l		tag			# fetch operand type
3233	mov.b		%d0,STAG(%a6)
3234	mov.b		%d0,%d1
3235
3236	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3237
3238	clr.l		%d0
3239	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3240
3241	tst.b		%d1
3242	bne.b		_L15_2s
3243	bsr.l		slog2			# operand is a NORM
3244	bra.b		_L15_6s
3245_L15_2s:
3246	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3247	bne.b		_L15_3s			# no
3248	bsr.l		t_dz2			# yes
3249	bra.b		_L15_6s
3250_L15_3s:
3251	cmpi.b		%d1,&INF		# is operand an INF?
3252	bne.b		_L15_4s			# no
3253	bsr.l		sopr_inf			# yes
3254	bra.b		_L15_6s
3255_L15_4s:
3256	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3257	bne.b		_L15_5s			# no
3258	bsr.l		src_qnan			# yes
3259	bra.b		_L15_6s
3260_L15_5s:
3261	bsr.l		slog2d			# operand is a DENORM
3262_L15_6s:
3263
3264#
3265#	Result is now in FP0
3266#
3267	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3268	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3269	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3270	unlk		%a6
3271	rts
3272
3273	global		_flog2d_
3274_flog2d_:
3275	link		%a6,&-LOCAL_SIZE
3276
3277	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3278	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3279	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3280
3281	fmov.l		&0x0,%fpcr		# zero FPCR
3282
3283#
3284#	copy, convert, and tag input argument
3285#
3286	fmov.d		0x8(%a6),%fp0		# load dbl input
3287	fmov.x		%fp0,FP_SRC(%a6)
3288	lea		FP_SRC(%a6),%a0
3289	bsr.l		tag			# fetch operand type
3290	mov.b		%d0,STAG(%a6)
3291	mov.b		%d0,%d1
3292
3293	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3294
3295	clr.l		%d0
3296	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3297
3298	mov.b		%d1,STAG(%a6)
3299	tst.b		%d1
3300	bne.b		_L15_2d
3301	bsr.l		slog2			# operand is a NORM
3302	bra.b		_L15_6d
3303_L15_2d:
3304	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3305	bne.b		_L15_3d			# no
3306	bsr.l		t_dz2			# yes
3307	bra.b		_L15_6d
3308_L15_3d:
3309	cmpi.b		%d1,&INF		# is operand an INF?
3310	bne.b		_L15_4d			# no
3311	bsr.l		sopr_inf			# yes
3312	bra.b		_L15_6d
3313_L15_4d:
3314	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3315	bne.b		_L15_5d			# no
3316	bsr.l		src_qnan			# yes
3317	bra.b		_L15_6d
3318_L15_5d:
3319	bsr.l		slog2d			# operand is a DENORM
3320_L15_6d:
3321
3322#
3323#	Result is now in FP0
3324#
3325	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3326	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3327	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3328	unlk		%a6
3329	rts
3330
3331	global		_flog2x_
3332_flog2x_:
3333	link		%a6,&-LOCAL_SIZE
3334
3335	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3336	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3337	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3338
3339	fmov.l		&0x0,%fpcr		# zero FPCR
3340
3341#
3342#	copy, convert, and tag input argument
3343#
3344	lea		FP_SRC(%a6),%a0
3345	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
3346	mov.l		0x8+0x4(%a6),0x4(%a0)
3347	mov.l		0x8+0x8(%a6),0x8(%a0)
3348	bsr.l		tag			# fetch operand type
3349	mov.b		%d0,STAG(%a6)
3350	mov.b		%d0,%d1
3351
3352	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3353
3354	clr.l		%d0
3355	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3356
3357	tst.b		%d1
3358	bne.b		_L15_2x
3359	bsr.l		slog2			# operand is a NORM
3360	bra.b		_L15_6x
3361_L15_2x:
3362	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3363	bne.b		_L15_3x			# no
3364	bsr.l		t_dz2			# yes
3365	bra.b		_L15_6x
3366_L15_3x:
3367	cmpi.b		%d1,&INF		# is operand an INF?
3368	bne.b		_L15_4x			# no
3369	bsr.l		sopr_inf			# yes
3370	bra.b		_L15_6x
3371_L15_4x:
3372	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3373	bne.b		_L15_5x			# no
3374	bsr.l		src_qnan			# yes
3375	bra.b		_L15_6x
3376_L15_5x:
3377	bsr.l		slog2d			# operand is a DENORM
3378_L15_6x:
3379
3380#
3381#	Result is now in FP0
3382#
3383	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3384	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3385	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3386	unlk		%a6
3387	rts
3388
3389
3390#########################################################################
3391# MONADIC TEMPLATE							#
3392#########################################################################
3393	global		_fcoshs_
3394_fcoshs_:
3395	link		%a6,&-LOCAL_SIZE
3396
3397	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3398	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3399	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3400
3401	fmov.l		&0x0,%fpcr		# zero FPCR
3402
3403#
3404#	copy, convert, and tag input argument
3405#
3406	fmov.s		0x8(%a6),%fp0		# load sgl input
3407	fmov.x		%fp0,FP_SRC(%a6)
3408	lea		FP_SRC(%a6),%a0
3409	bsr.l		tag			# fetch operand type
3410	mov.b		%d0,STAG(%a6)
3411	mov.b		%d0,%d1
3412
3413	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3414
3415	clr.l		%d0
3416	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3417
3418	tst.b		%d1
3419	bne.b		_L16_2s
3420	bsr.l		scosh			# operand is a NORM
3421	bra.b		_L16_6s
3422_L16_2s:
3423	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3424	bne.b		_L16_3s			# no
3425	bsr.l		ld_pone			# yes
3426	bra.b		_L16_6s
3427_L16_3s:
3428	cmpi.b		%d1,&INF		# is operand an INF?
3429	bne.b		_L16_4s			# no
3430	bsr.l		ld_pinf			# yes
3431	bra.b		_L16_6s
3432_L16_4s:
3433	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3434	bne.b		_L16_5s			# no
3435	bsr.l		src_qnan			# yes
3436	bra.b		_L16_6s
3437_L16_5s:
3438	bsr.l		scoshd			# operand is a DENORM
3439_L16_6s:
3440
3441#
3442#	Result is now in FP0
3443#
3444	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3445	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3446	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3447	unlk		%a6
3448	rts
3449
3450	global		_fcoshd_
3451_fcoshd_:
3452	link		%a6,&-LOCAL_SIZE
3453
3454	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3455	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3456	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3457
3458	fmov.l		&0x0,%fpcr		# zero FPCR
3459
3460#
3461#	copy, convert, and tag input argument
3462#
3463	fmov.d		0x8(%a6),%fp0		# load dbl input
3464	fmov.x		%fp0,FP_SRC(%a6)
3465	lea		FP_SRC(%a6),%a0
3466	bsr.l		tag			# fetch operand type
3467	mov.b		%d0,STAG(%a6)
3468	mov.b		%d0,%d1
3469
3470	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3471
3472	clr.l		%d0
3473	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3474
3475	mov.b		%d1,STAG(%a6)
3476	tst.b		%d1
3477	bne.b		_L16_2d
3478	bsr.l		scosh			# operand is a NORM
3479	bra.b		_L16_6d
3480_L16_2d:
3481	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3482	bne.b		_L16_3d			# no
3483	bsr.l		ld_pone			# yes
3484	bra.b		_L16_6d
3485_L16_3d:
3486	cmpi.b		%d1,&INF		# is operand an INF?
3487	bne.b		_L16_4d			# no
3488	bsr.l		ld_pinf			# yes
3489	bra.b		_L16_6d
3490_L16_4d:
3491	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3492	bne.b		_L16_5d			# no
3493	bsr.l		src_qnan			# yes
3494	bra.b		_L16_6d
3495_L16_5d:
3496	bsr.l		scoshd			# operand is a DENORM
3497_L16_6d:
3498
3499#
3500#	Result is now in FP0
3501#
3502	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3503	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3504	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3505	unlk		%a6
3506	rts
3507
3508	global		_fcoshx_
3509_fcoshx_:
3510	link		%a6,&-LOCAL_SIZE
3511
3512	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3513	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3514	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3515
3516	fmov.l		&0x0,%fpcr		# zero FPCR
3517
3518#
3519#	copy, convert, and tag input argument
3520#
3521	lea		FP_SRC(%a6),%a0
3522	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
3523	mov.l		0x8+0x4(%a6),0x4(%a0)
3524	mov.l		0x8+0x8(%a6),0x8(%a0)
3525	bsr.l		tag			# fetch operand type
3526	mov.b		%d0,STAG(%a6)
3527	mov.b		%d0,%d1
3528
3529	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3530
3531	clr.l		%d0
3532	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3533
3534	tst.b		%d1
3535	bne.b		_L16_2x
3536	bsr.l		scosh			# operand is a NORM
3537	bra.b		_L16_6x
3538_L16_2x:
3539	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3540	bne.b		_L16_3x			# no
3541	bsr.l		ld_pone			# yes
3542	bra.b		_L16_6x
3543_L16_3x:
3544	cmpi.b		%d1,&INF		# is operand an INF?
3545	bne.b		_L16_4x			# no
3546	bsr.l		ld_pinf			# yes
3547	bra.b		_L16_6x
3548_L16_4x:
3549	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3550	bne.b		_L16_5x			# no
3551	bsr.l		src_qnan			# yes
3552	bra.b		_L16_6x
3553_L16_5x:
3554	bsr.l		scoshd			# operand is a DENORM
3555_L16_6x:
3556
3557#
3558#	Result is now in FP0
3559#
3560	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3561	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3562	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3563	unlk		%a6
3564	rts
3565
3566
3567#########################################################################
3568# MONADIC TEMPLATE							#
3569#########################################################################
3570	global		_facoss_
3571_facoss_:
3572	link		%a6,&-LOCAL_SIZE
3573
3574	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3575	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3576	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3577
3578	fmov.l		&0x0,%fpcr		# zero FPCR
3579
3580#
3581#	copy, convert, and tag input argument
3582#
3583	fmov.s		0x8(%a6),%fp0		# load sgl input
3584	fmov.x		%fp0,FP_SRC(%a6)
3585	lea		FP_SRC(%a6),%a0
3586	bsr.l		tag			# fetch operand type
3587	mov.b		%d0,STAG(%a6)
3588	mov.b		%d0,%d1
3589
3590	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3591
3592	clr.l		%d0
3593	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3594
3595	tst.b		%d1
3596	bne.b		_L17_2s
3597	bsr.l		sacos			# operand is a NORM
3598	bra.b		_L17_6s
3599_L17_2s:
3600	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3601	bne.b		_L17_3s			# no
3602	bsr.l		ld_ppi2			# yes
3603	bra.b		_L17_6s
3604_L17_3s:
3605	cmpi.b		%d1,&INF		# is operand an INF?
3606	bne.b		_L17_4s			# no
3607	bsr.l		t_operr			# yes
3608	bra.b		_L17_6s
3609_L17_4s:
3610	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3611	bne.b		_L17_5s			# no
3612	bsr.l		src_qnan			# yes
3613	bra.b		_L17_6s
3614_L17_5s:
3615	bsr.l		sacosd			# operand is a DENORM
3616_L17_6s:
3617
3618#
3619#	Result is now in FP0
3620#
3621	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3622	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3623	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3624	unlk		%a6
3625	rts
3626
3627	global		_facosd_
3628_facosd_:
3629	link		%a6,&-LOCAL_SIZE
3630
3631	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3632	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3633	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3634
3635	fmov.l		&0x0,%fpcr		# zero FPCR
3636
3637#
3638#	copy, convert, and tag input argument
3639#
3640	fmov.d		0x8(%a6),%fp0		# load dbl input
3641	fmov.x		%fp0,FP_SRC(%a6)
3642	lea		FP_SRC(%a6),%a0
3643	bsr.l		tag			# fetch operand type
3644	mov.b		%d0,STAG(%a6)
3645	mov.b		%d0,%d1
3646
3647	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3648
3649	clr.l		%d0
3650	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3651
3652	mov.b		%d1,STAG(%a6)
3653	tst.b		%d1
3654	bne.b		_L17_2d
3655	bsr.l		sacos			# operand is a NORM
3656	bra.b		_L17_6d
3657_L17_2d:
3658	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3659	bne.b		_L17_3d			# no
3660	bsr.l		ld_ppi2			# yes
3661	bra.b		_L17_6d
3662_L17_3d:
3663	cmpi.b		%d1,&INF		# is operand an INF?
3664	bne.b		_L17_4d			# no
3665	bsr.l		t_operr			# yes
3666	bra.b		_L17_6d
3667_L17_4d:
3668	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3669	bne.b		_L17_5d			# no
3670	bsr.l		src_qnan			# yes
3671	bra.b		_L17_6d
3672_L17_5d:
3673	bsr.l		sacosd			# operand is a DENORM
3674_L17_6d:
3675
3676#
3677#	Result is now in FP0
3678#
3679	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3680	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3681	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3682	unlk		%a6
3683	rts
3684
3685	global		_facosx_
3686_facosx_:
3687	link		%a6,&-LOCAL_SIZE
3688
3689	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3690	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3691	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3692
3693	fmov.l		&0x0,%fpcr		# zero FPCR
3694
3695#
3696#	copy, convert, and tag input argument
3697#
3698	lea		FP_SRC(%a6),%a0
3699	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
3700	mov.l		0x8+0x4(%a6),0x4(%a0)
3701	mov.l		0x8+0x8(%a6),0x8(%a0)
3702	bsr.l		tag			# fetch operand type
3703	mov.b		%d0,STAG(%a6)
3704	mov.b		%d0,%d1
3705
3706	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3707
3708	clr.l		%d0
3709	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3710
3711	tst.b		%d1
3712	bne.b		_L17_2x
3713	bsr.l		sacos			# operand is a NORM
3714	bra.b		_L17_6x
3715_L17_2x:
3716	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3717	bne.b		_L17_3x			# no
3718	bsr.l		ld_ppi2			# yes
3719	bra.b		_L17_6x
3720_L17_3x:
3721	cmpi.b		%d1,&INF		# is operand an INF?
3722	bne.b		_L17_4x			# no
3723	bsr.l		t_operr			# yes
3724	bra.b		_L17_6x
3725_L17_4x:
3726	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3727	bne.b		_L17_5x			# no
3728	bsr.l		src_qnan			# yes
3729	bra.b		_L17_6x
3730_L17_5x:
3731	bsr.l		sacosd			# operand is a DENORM
3732_L17_6x:
3733
3734#
3735#	Result is now in FP0
3736#
3737	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3738	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3739	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3740	unlk		%a6
3741	rts
3742
3743
3744#########################################################################
3745# MONADIC TEMPLATE							#
3746#########################################################################
3747	global		_fgetexps_
3748_fgetexps_:
3749	link		%a6,&-LOCAL_SIZE
3750
3751	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3752	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3753	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3754
3755	fmov.l		&0x0,%fpcr		# zero FPCR
3756
3757#
3758#	copy, convert, and tag input argument
3759#
3760	fmov.s		0x8(%a6),%fp0		# load sgl input
3761	fmov.x		%fp0,FP_SRC(%a6)
3762	lea		FP_SRC(%a6),%a0
3763	bsr.l		tag			# fetch operand type
3764	mov.b		%d0,STAG(%a6)
3765	mov.b		%d0,%d1
3766
3767	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3768
3769	clr.l		%d0
3770	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3771
3772	tst.b		%d1
3773	bne.b		_L18_2s
3774	bsr.l		sgetexp			# operand is a NORM
3775	bra.b		_L18_6s
3776_L18_2s:
3777	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3778	bne.b		_L18_3s			# no
3779	bsr.l		src_zero			# yes
3780	bra.b		_L18_6s
3781_L18_3s:
3782	cmpi.b		%d1,&INF		# is operand an INF?
3783	bne.b		_L18_4s			# no
3784	bsr.l		t_operr			# yes
3785	bra.b		_L18_6s
3786_L18_4s:
3787	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3788	bne.b		_L18_5s			# no
3789	bsr.l		src_qnan			# yes
3790	bra.b		_L18_6s
3791_L18_5s:
3792	bsr.l		sgetexpd			# operand is a DENORM
3793_L18_6s:
3794
3795#
3796#	Result is now in FP0
3797#
3798	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3799	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3800	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3801	unlk		%a6
3802	rts
3803
3804	global		_fgetexpd_
3805_fgetexpd_:
3806	link		%a6,&-LOCAL_SIZE
3807
3808	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3809	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3810	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3811
3812	fmov.l		&0x0,%fpcr		# zero FPCR
3813
3814#
3815#	copy, convert, and tag input argument
3816#
3817	fmov.d		0x8(%a6),%fp0		# load dbl input
3818	fmov.x		%fp0,FP_SRC(%a6)
3819	lea		FP_SRC(%a6),%a0
3820	bsr.l		tag			# fetch operand type
3821	mov.b		%d0,STAG(%a6)
3822	mov.b		%d0,%d1
3823
3824	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3825
3826	clr.l		%d0
3827	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3828
3829	mov.b		%d1,STAG(%a6)
3830	tst.b		%d1
3831	bne.b		_L18_2d
3832	bsr.l		sgetexp			# operand is a NORM
3833	bra.b		_L18_6d
3834_L18_2d:
3835	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3836	bne.b		_L18_3d			# no
3837	bsr.l		src_zero			# yes
3838	bra.b		_L18_6d
3839_L18_3d:
3840	cmpi.b		%d1,&INF		# is operand an INF?
3841	bne.b		_L18_4d			# no
3842	bsr.l		t_operr			# yes
3843	bra.b		_L18_6d
3844_L18_4d:
3845	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3846	bne.b		_L18_5d			# no
3847	bsr.l		src_qnan			# yes
3848	bra.b		_L18_6d
3849_L18_5d:
3850	bsr.l		sgetexpd			# operand is a DENORM
3851_L18_6d:
3852
3853#
3854#	Result is now in FP0
3855#
3856	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3857	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3858	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3859	unlk		%a6
3860	rts
3861
3862	global		_fgetexpx_
3863_fgetexpx_:
3864	link		%a6,&-LOCAL_SIZE
3865
3866	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3867	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3868	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3869
3870	fmov.l		&0x0,%fpcr		# zero FPCR
3871
3872#
3873#	copy, convert, and tag input argument
3874#
3875	lea		FP_SRC(%a6),%a0
3876	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
3877	mov.l		0x8+0x4(%a6),0x4(%a0)
3878	mov.l		0x8+0x8(%a6),0x8(%a0)
3879	bsr.l		tag			# fetch operand type
3880	mov.b		%d0,STAG(%a6)
3881	mov.b		%d0,%d1
3882
3883	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3884
3885	clr.l		%d0
3886	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3887
3888	tst.b		%d1
3889	bne.b		_L18_2x
3890	bsr.l		sgetexp			# operand is a NORM
3891	bra.b		_L18_6x
3892_L18_2x:
3893	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3894	bne.b		_L18_3x			# no
3895	bsr.l		src_zero			# yes
3896	bra.b		_L18_6x
3897_L18_3x:
3898	cmpi.b		%d1,&INF		# is operand an INF?
3899	bne.b		_L18_4x			# no
3900	bsr.l		t_operr			# yes
3901	bra.b		_L18_6x
3902_L18_4x:
3903	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3904	bne.b		_L18_5x			# no
3905	bsr.l		src_qnan			# yes
3906	bra.b		_L18_6x
3907_L18_5x:
3908	bsr.l		sgetexpd			# operand is a DENORM
3909_L18_6x:
3910
3911#
3912#	Result is now in FP0
3913#
3914	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3915	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3916	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3917	unlk		%a6
3918	rts
3919
3920
3921#########################################################################
3922# MONADIC TEMPLATE							#
3923#########################################################################
3924	global		_fgetmans_
3925_fgetmans_:
3926	link		%a6,&-LOCAL_SIZE
3927
3928	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3929	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3930	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3931
3932	fmov.l		&0x0,%fpcr		# zero FPCR
3933
3934#
3935#	copy, convert, and tag input argument
3936#
3937	fmov.s		0x8(%a6),%fp0		# load sgl input
3938	fmov.x		%fp0,FP_SRC(%a6)
3939	lea		FP_SRC(%a6),%a0
3940	bsr.l		tag			# fetch operand type
3941	mov.b		%d0,STAG(%a6)
3942	mov.b		%d0,%d1
3943
3944	andi.l		&0x00ff00ff,USER_FPSR(%a6)
3945
3946	clr.l		%d0
3947	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
3948
3949	tst.b		%d1
3950	bne.b		_L19_2s
3951	bsr.l		sgetman			# operand is a NORM
3952	bra.b		_L19_6s
3953_L19_2s:
3954	cmpi.b		%d1,&ZERO		# is operand a ZERO?
3955	bne.b		_L19_3s			# no
3956	bsr.l		src_zero			# yes
3957	bra.b		_L19_6s
3958_L19_3s:
3959	cmpi.b		%d1,&INF		# is operand an INF?
3960	bne.b		_L19_4s			# no
3961	bsr.l		t_operr			# yes
3962	bra.b		_L19_6s
3963_L19_4s:
3964	cmpi.b		%d1,&QNAN		# is operand a QNAN?
3965	bne.b		_L19_5s			# no
3966	bsr.l		src_qnan			# yes
3967	bra.b		_L19_6s
3968_L19_5s:
3969	bsr.l		sgetmand			# operand is a DENORM
3970_L19_6s:
3971
3972#
3973#	Result is now in FP0
3974#
3975	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
3976	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3977	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
3978	unlk		%a6
3979	rts
3980
3981	global		_fgetmand_
3982_fgetmand_:
3983	link		%a6,&-LOCAL_SIZE
3984
3985	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
3986	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3987	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
3988
3989	fmov.l		&0x0,%fpcr		# zero FPCR
3990
3991#
3992#	copy, convert, and tag input argument
3993#
3994	fmov.d		0x8(%a6),%fp0		# load dbl input
3995	fmov.x		%fp0,FP_SRC(%a6)
3996	lea		FP_SRC(%a6),%a0
3997	bsr.l		tag			# fetch operand type
3998	mov.b		%d0,STAG(%a6)
3999	mov.b		%d0,%d1
4000
4001	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4002
4003	clr.l		%d0
4004	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4005
4006	mov.b		%d1,STAG(%a6)
4007	tst.b		%d1
4008	bne.b		_L19_2d
4009	bsr.l		sgetman			# operand is a NORM
4010	bra.b		_L19_6d
4011_L19_2d:
4012	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4013	bne.b		_L19_3d			# no
4014	bsr.l		src_zero			# yes
4015	bra.b		_L19_6d
4016_L19_3d:
4017	cmpi.b		%d1,&INF		# is operand an INF?
4018	bne.b		_L19_4d			# no
4019	bsr.l		t_operr			# yes
4020	bra.b		_L19_6d
4021_L19_4d:
4022	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4023	bne.b		_L19_5d			# no
4024	bsr.l		src_qnan			# yes
4025	bra.b		_L19_6d
4026_L19_5d:
4027	bsr.l		sgetmand			# operand is a DENORM
4028_L19_6d:
4029
4030#
4031#	Result is now in FP0
4032#
4033	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4034	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4035	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4036	unlk		%a6
4037	rts
4038
4039	global		_fgetmanx_
4040_fgetmanx_:
4041	link		%a6,&-LOCAL_SIZE
4042
4043	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4044	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4045	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4046
4047	fmov.l		&0x0,%fpcr		# zero FPCR
4048
4049#
4050#	copy, convert, and tag input argument
4051#
4052	lea		FP_SRC(%a6),%a0
4053	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
4054	mov.l		0x8+0x4(%a6),0x4(%a0)
4055	mov.l		0x8+0x8(%a6),0x8(%a0)
4056	bsr.l		tag			# fetch operand type
4057	mov.b		%d0,STAG(%a6)
4058	mov.b		%d0,%d1
4059
4060	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4061
4062	clr.l		%d0
4063	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4064
4065	tst.b		%d1
4066	bne.b		_L19_2x
4067	bsr.l		sgetman			# operand is a NORM
4068	bra.b		_L19_6x
4069_L19_2x:
4070	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4071	bne.b		_L19_3x			# no
4072	bsr.l		src_zero			# yes
4073	bra.b		_L19_6x
4074_L19_3x:
4075	cmpi.b		%d1,&INF		# is operand an INF?
4076	bne.b		_L19_4x			# no
4077	bsr.l		t_operr			# yes
4078	bra.b		_L19_6x
4079_L19_4x:
4080	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4081	bne.b		_L19_5x			# no
4082	bsr.l		src_qnan			# yes
4083	bra.b		_L19_6x
4084_L19_5x:
4085	bsr.l		sgetmand			# operand is a DENORM
4086_L19_6x:
4087
4088#
4089#	Result is now in FP0
4090#
4091	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4092	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4093	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4094	unlk		%a6
4095	rts
4096
4097
4098#########################################################################
4099# MONADIC TEMPLATE							#
4100#########################################################################
4101	global		_fsincoss_
4102_fsincoss_:
4103	link		%a6,&-LOCAL_SIZE
4104
4105	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4106	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4107	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4108
4109	fmov.l		&0x0,%fpcr		# zero FPCR
4110
4111#
4112#	copy, convert, and tag input argument
4113#
4114	fmov.s		0x8(%a6),%fp0		# load sgl input
4115	fmov.x		%fp0,FP_SRC(%a6)
4116	lea		FP_SRC(%a6),%a0
4117	bsr.l		tag			# fetch operand type
4118	mov.b		%d0,STAG(%a6)
4119	mov.b		%d0,%d1
4120
4121	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4122
4123	clr.l		%d0
4124	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4125
4126	tst.b		%d1
4127	bne.b		_L20_2s
4128	bsr.l		ssincos			# operand is a NORM
4129	bra.b		_L20_6s
4130_L20_2s:
4131	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4132	bne.b		_L20_3s			# no
4133	bsr.l		ssincosz			# yes
4134	bra.b		_L20_6s
4135_L20_3s:
4136	cmpi.b		%d1,&INF		# is operand an INF?
4137	bne.b		_L20_4s			# no
4138	bsr.l		ssincosi			# yes
4139	bra.b		_L20_6s
4140_L20_4s:
4141	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4142	bne.b		_L20_5s			# no
4143	bsr.l		ssincosqnan			# yes
4144	bra.b		_L20_6s
4145_L20_5s:
4146	bsr.l		ssincosd			# operand is a DENORM
4147_L20_6s:
4148
4149#
4150#	Result is now in FP0
4151#
4152	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4153	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4154	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
4155	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
4156	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
4157	unlk		%a6
4158	rts
4159
4160	global		_fsincosd_
4161_fsincosd_:
4162	link		%a6,&-LOCAL_SIZE
4163
4164	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4165	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4166	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4167
4168	fmov.l		&0x0,%fpcr		# zero FPCR
4169
4170#
4171#	copy, convert, and tag input argument
4172#
4173	fmov.d		0x8(%a6),%fp0		# load dbl input
4174	fmov.x		%fp0,FP_SRC(%a6)
4175	lea		FP_SRC(%a6),%a0
4176	bsr.l		tag			# fetch operand type
4177	mov.b		%d0,STAG(%a6)
4178	mov.b		%d0,%d1
4179
4180	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4181
4182	clr.l		%d0
4183	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4184
4185	mov.b		%d1,STAG(%a6)
4186	tst.b		%d1
4187	bne.b		_L20_2d
4188	bsr.l		ssincos			# operand is a NORM
4189	bra.b		_L20_6d
4190_L20_2d:
4191	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4192	bne.b		_L20_3d			# no
4193	bsr.l		ssincosz			# yes
4194	bra.b		_L20_6d
4195_L20_3d:
4196	cmpi.b		%d1,&INF		# is operand an INF?
4197	bne.b		_L20_4d			# no
4198	bsr.l		ssincosi			# yes
4199	bra.b		_L20_6d
4200_L20_4d:
4201	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4202	bne.b		_L20_5d			# no
4203	bsr.l		ssincosqnan			# yes
4204	bra.b		_L20_6d
4205_L20_5d:
4206	bsr.l		ssincosd			# operand is a DENORM
4207_L20_6d:
4208
4209#
4210#	Result is now in FP0
4211#
4212	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4213	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4214	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
4215	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
4216	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
4217	unlk		%a6
4218	rts
4219
4220	global		_fsincosx_
4221_fsincosx_:
4222	link		%a6,&-LOCAL_SIZE
4223
4224	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4225	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4226	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4227
4228	fmov.l		&0x0,%fpcr		# zero FPCR
4229
4230#
4231#	copy, convert, and tag input argument
4232#
4233	lea		FP_SRC(%a6),%a0
4234	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext input
4235	mov.l		0x8+0x4(%a6),0x4(%a0)
4236	mov.l		0x8+0x8(%a6),0x8(%a0)
4237	bsr.l		tag			# fetch operand type
4238	mov.b		%d0,STAG(%a6)
4239	mov.b		%d0,%d1
4240
4241	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4242
4243	clr.l		%d0
4244	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4245
4246	tst.b		%d1
4247	bne.b		_L20_2x
4248	bsr.l		ssincos			# operand is a NORM
4249	bra.b		_L20_6x
4250_L20_2x:
4251	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4252	bne.b		_L20_3x			# no
4253	bsr.l		ssincosz			# yes
4254	bra.b		_L20_6x
4255_L20_3x:
4256	cmpi.b		%d1,&INF		# is operand an INF?
4257	bne.b		_L20_4x			# no
4258	bsr.l		ssincosi			# yes
4259	bra.b		_L20_6x
4260_L20_4x:
4261	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4262	bne.b		_L20_5x			# no
4263	bsr.l		ssincosqnan			# yes
4264	bra.b		_L20_6x
4265_L20_5x:
4266	bsr.l		ssincosd			# operand is a DENORM
4267_L20_6x:
4268
4269#
4270#	Result is now in FP0
4271#
4272	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4273	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4274	fmovm.x		&0x03,-(%sp)		# store off fp0/fp1
4275	fmovm.x		(%sp)+,&0x40		# fp0 now in fp1
4276	fmovm.x		(%sp)+,&0x80		# fp1 now in fp0
4277	unlk		%a6
4278	rts
4279
4280
4281#########################################################################
4282# DYADIC TEMPLATE							#
4283#########################################################################
4284	global		_frems_
4285_frems_:
4286	link		%a6,&-LOCAL_SIZE
4287
4288	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4289	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4290	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4291
4292	fmov.l		&0x0,%fpcr		# zero FPCR
4293
4294#
4295#	copy, convert, and tag input argument
4296#
4297	fmov.s		0x8(%a6),%fp0		# load sgl dst
4298	fmov.x		%fp0,FP_DST(%a6)
4299	lea		FP_DST(%a6),%a0
4300	bsr.l		tag			# fetch operand type
4301	mov.b		%d0,DTAG(%a6)
4302
4303	fmov.s		0xc(%a6),%fp0		# load sgl src
4304	fmov.x		%fp0,FP_SRC(%a6)
4305	lea		FP_SRC(%a6),%a0
4306	bsr.l		tag			# fetch operand type
4307	mov.b		%d0,STAG(%a6)
4308	mov.l		%d0,%d1
4309
4310	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4311
4312	clr.l		%d0
4313	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4314
4315	lea		FP_SRC(%a6),%a0		# pass ptr to src
4316	lea		FP_DST(%a6),%a1		# pass ptr to dst
4317
4318	tst.b		%d1
4319	bne.b		_L21_2s
4320	bsr.l		srem_snorm			# operand is a NORM
4321	bra.b		_L21_6s
4322_L21_2s:
4323	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4324	bne.b		_L21_3s			# no
4325	bsr.l		srem_szero			# yes
4326	bra.b		_L21_6s
4327_L21_3s:
4328	cmpi.b		%d1,&INF		# is operand an INF?
4329	bne.b		_L21_4s			# no
4330	bsr.l		srem_sinf			# yes
4331	bra.b		_L21_6s
4332_L21_4s:
4333	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4334	bne.b		_L21_5s			# no
4335	bsr.l		sop_sqnan			# yes
4336	bra.b		_L21_6s
4337_L21_5s:
4338	bsr.l		srem_sdnrm			# operand is a DENORM
4339_L21_6s:
4340
4341#
4342#	Result is now in FP0
4343#
4344	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4345	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4346	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4347	unlk		%a6
4348	rts
4349
4350	global		_fremd_
4351_fremd_:
4352	link		%a6,&-LOCAL_SIZE
4353
4354	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4355	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4356	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4357
4358	fmov.l		&0x0,%fpcr		# zero FPCR
4359
4360#
4361#	copy, convert, and tag input argument
4362#
4363	fmov.d		0x8(%a6),%fp0		# load dbl dst
4364	fmov.x		%fp0,FP_DST(%a6)
4365	lea		FP_DST(%a6),%a0
4366	bsr.l		tag			# fetch operand type
4367	mov.b		%d0,DTAG(%a6)
4368
4369	fmov.d		0x10(%a6),%fp0		# load dbl src
4370	fmov.x		%fp0,FP_SRC(%a6)
4371	lea		FP_SRC(%a6),%a0
4372	bsr.l		tag			# fetch operand type
4373	mov.b		%d0,STAG(%a6)
4374	mov.l		%d0,%d1
4375
4376	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4377
4378	clr.l		%d0
4379	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4380
4381	lea		FP_SRC(%a6),%a0		# pass ptr to src
4382	lea		FP_DST(%a6),%a1		# pass ptr to dst
4383
4384	tst.b		%d1
4385	bne.b		_L21_2d
4386	bsr.l		srem_snorm			# operand is a NORM
4387	bra.b		_L21_6d
4388_L21_2d:
4389	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4390	bne.b		_L21_3d			# no
4391	bsr.l		srem_szero			# yes
4392	bra.b		_L21_6d
4393_L21_3d:
4394	cmpi.b		%d1,&INF		# is operand an INF?
4395	bne.b		_L21_4d			# no
4396	bsr.l		srem_sinf			# yes
4397	bra.b		_L21_6d
4398_L21_4d:
4399	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4400	bne.b		_L21_5d			# no
4401	bsr.l		sop_sqnan			# yes
4402	bra.b		_L21_6d
4403_L21_5d:
4404	bsr.l		srem_sdnrm			# operand is a DENORM
4405_L21_6d:
4406
4407#
4408#	Result is now in FP0
4409#
4410	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4411	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4412	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4413	unlk		%a6
4414	rts
4415
4416	global		_fremx_
4417_fremx_:
4418	link		%a6,&-LOCAL_SIZE
4419
4420	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4421	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4422	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4423
4424	fmov.l		&0x0,%fpcr		# zero FPCR
4425
4426#
4427#	copy, convert, and tag input argument
4428#
4429	lea		FP_DST(%a6),%a0
4430	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
4431	mov.l		0x8+0x4(%a6),0x4(%a0)
4432	mov.l		0x8+0x8(%a6),0x8(%a0)
4433	bsr.l		tag			# fetch operand type
4434	mov.b		%d0,DTAG(%a6)
4435
4436	lea		FP_SRC(%a6),%a0
4437	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
4438	mov.l		0x14+0x4(%a6),0x4(%a0)
4439	mov.l		0x14+0x8(%a6),0x8(%a0)
4440	bsr.l		tag			# fetch operand type
4441	mov.b		%d0,STAG(%a6)
4442	mov.l		%d0,%d1
4443
4444	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4445
4446	clr.l		%d0
4447	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4448
4449	lea		FP_SRC(%a6),%a0		# pass ptr to src
4450	lea		FP_DST(%a6),%a1		# pass ptr to dst
4451
4452	tst.b		%d1
4453	bne.b		_L21_2x
4454	bsr.l		srem_snorm			# operand is a NORM
4455	bra.b		_L21_6x
4456_L21_2x:
4457	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4458	bne.b		_L21_3x			# no
4459	bsr.l		srem_szero			# yes
4460	bra.b		_L21_6x
4461_L21_3x:
4462	cmpi.b		%d1,&INF		# is operand an INF?
4463	bne.b		_L21_4x			# no
4464	bsr.l		srem_sinf			# yes
4465	bra.b		_L21_6x
4466_L21_4x:
4467	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4468	bne.b		_L21_5x			# no
4469	bsr.l		sop_sqnan			# yes
4470	bra.b		_L21_6x
4471_L21_5x:
4472	bsr.l		srem_sdnrm			# operand is a DENORM
4473_L21_6x:
4474
4475#
4476#	Result is now in FP0
4477#
4478	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4479	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4480	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4481	unlk		%a6
4482	rts
4483
4484
4485#########################################################################
4486# DYADIC TEMPLATE							#
4487#########################################################################
4488	global		_fmods_
4489_fmods_:
4490	link		%a6,&-LOCAL_SIZE
4491
4492	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4493	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4494	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4495
4496	fmov.l		&0x0,%fpcr		# zero FPCR
4497
4498#
4499#	copy, convert, and tag input argument
4500#
4501	fmov.s		0x8(%a6),%fp0		# load sgl dst
4502	fmov.x		%fp0,FP_DST(%a6)
4503	lea		FP_DST(%a6),%a0
4504	bsr.l		tag			# fetch operand type
4505	mov.b		%d0,DTAG(%a6)
4506
4507	fmov.s		0xc(%a6),%fp0		# load sgl src
4508	fmov.x		%fp0,FP_SRC(%a6)
4509	lea		FP_SRC(%a6),%a0
4510	bsr.l		tag			# fetch operand type
4511	mov.b		%d0,STAG(%a6)
4512	mov.l		%d0,%d1
4513
4514	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4515
4516	clr.l		%d0
4517	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4518
4519	lea		FP_SRC(%a6),%a0		# pass ptr to src
4520	lea		FP_DST(%a6),%a1		# pass ptr to dst
4521
4522	tst.b		%d1
4523	bne.b		_L22_2s
4524	bsr.l		smod_snorm			# operand is a NORM
4525	bra.b		_L22_6s
4526_L22_2s:
4527	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4528	bne.b		_L22_3s			# no
4529	bsr.l		smod_szero			# yes
4530	bra.b		_L22_6s
4531_L22_3s:
4532	cmpi.b		%d1,&INF		# is operand an INF?
4533	bne.b		_L22_4s			# no
4534	bsr.l		smod_sinf			# yes
4535	bra.b		_L22_6s
4536_L22_4s:
4537	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4538	bne.b		_L22_5s			# no
4539	bsr.l		sop_sqnan			# yes
4540	bra.b		_L22_6s
4541_L22_5s:
4542	bsr.l		smod_sdnrm			# operand is a DENORM
4543_L22_6s:
4544
4545#
4546#	Result is now in FP0
4547#
4548	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4549	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4550	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4551	unlk		%a6
4552	rts
4553
4554	global		_fmodd_
4555_fmodd_:
4556	link		%a6,&-LOCAL_SIZE
4557
4558	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4559	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4560	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4561
4562	fmov.l		&0x0,%fpcr		# zero FPCR
4563
4564#
4565#	copy, convert, and tag input argument
4566#
4567	fmov.d		0x8(%a6),%fp0		# load dbl dst
4568	fmov.x		%fp0,FP_DST(%a6)
4569	lea		FP_DST(%a6),%a0
4570	bsr.l		tag			# fetch operand type
4571	mov.b		%d0,DTAG(%a6)
4572
4573	fmov.d		0x10(%a6),%fp0		# load dbl src
4574	fmov.x		%fp0,FP_SRC(%a6)
4575	lea		FP_SRC(%a6),%a0
4576	bsr.l		tag			# fetch operand type
4577	mov.b		%d0,STAG(%a6)
4578	mov.l		%d0,%d1
4579
4580	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4581
4582	clr.l		%d0
4583	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4584
4585	lea		FP_SRC(%a6),%a0		# pass ptr to src
4586	lea		FP_DST(%a6),%a1		# pass ptr to dst
4587
4588	tst.b		%d1
4589	bne.b		_L22_2d
4590	bsr.l		smod_snorm			# operand is a NORM
4591	bra.b		_L22_6d
4592_L22_2d:
4593	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4594	bne.b		_L22_3d			# no
4595	bsr.l		smod_szero			# yes
4596	bra.b		_L22_6d
4597_L22_3d:
4598	cmpi.b		%d1,&INF		# is operand an INF?
4599	bne.b		_L22_4d			# no
4600	bsr.l		smod_sinf			# yes
4601	bra.b		_L22_6d
4602_L22_4d:
4603	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4604	bne.b		_L22_5d			# no
4605	bsr.l		sop_sqnan			# yes
4606	bra.b		_L22_6d
4607_L22_5d:
4608	bsr.l		smod_sdnrm			# operand is a DENORM
4609_L22_6d:
4610
4611#
4612#	Result is now in FP0
4613#
4614	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4615	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4616	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4617	unlk		%a6
4618	rts
4619
4620	global		_fmodx_
4621_fmodx_:
4622	link		%a6,&-LOCAL_SIZE
4623
4624	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4625	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4626	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4627
4628	fmov.l		&0x0,%fpcr		# zero FPCR
4629
4630#
4631#	copy, convert, and tag input argument
4632#
4633	lea		FP_DST(%a6),%a0
4634	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
4635	mov.l		0x8+0x4(%a6),0x4(%a0)
4636	mov.l		0x8+0x8(%a6),0x8(%a0)
4637	bsr.l		tag			# fetch operand type
4638	mov.b		%d0,DTAG(%a6)
4639
4640	lea		FP_SRC(%a6),%a0
4641	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
4642	mov.l		0x14+0x4(%a6),0x4(%a0)
4643	mov.l		0x14+0x8(%a6),0x8(%a0)
4644	bsr.l		tag			# fetch operand type
4645	mov.b		%d0,STAG(%a6)
4646	mov.l		%d0,%d1
4647
4648	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4649
4650	clr.l		%d0
4651	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4652
4653	lea		FP_SRC(%a6),%a0		# pass ptr to src
4654	lea		FP_DST(%a6),%a1		# pass ptr to dst
4655
4656	tst.b		%d1
4657	bne.b		_L22_2x
4658	bsr.l		smod_snorm			# operand is a NORM
4659	bra.b		_L22_6x
4660_L22_2x:
4661	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4662	bne.b		_L22_3x			# no
4663	bsr.l		smod_szero			# yes
4664	bra.b		_L22_6x
4665_L22_3x:
4666	cmpi.b		%d1,&INF		# is operand an INF?
4667	bne.b		_L22_4x			# no
4668	bsr.l		smod_sinf			# yes
4669	bra.b		_L22_6x
4670_L22_4x:
4671	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4672	bne.b		_L22_5x			# no
4673	bsr.l		sop_sqnan			# yes
4674	bra.b		_L22_6x
4675_L22_5x:
4676	bsr.l		smod_sdnrm			# operand is a DENORM
4677_L22_6x:
4678
4679#
4680#	Result is now in FP0
4681#
4682	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4683	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4684	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4685	unlk		%a6
4686	rts
4687
4688
4689#########################################################################
4690# DYADIC TEMPLATE							#
4691#########################################################################
4692	global		_fscales_
4693_fscales_:
4694	link		%a6,&-LOCAL_SIZE
4695
4696	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4697	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4698	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4699
4700	fmov.l		&0x0,%fpcr		# zero FPCR
4701
4702#
4703#	copy, convert, and tag input argument
4704#
4705	fmov.s		0x8(%a6),%fp0		# load sgl dst
4706	fmov.x		%fp0,FP_DST(%a6)
4707	lea		FP_DST(%a6),%a0
4708	bsr.l		tag			# fetch operand type
4709	mov.b		%d0,DTAG(%a6)
4710
4711	fmov.s		0xc(%a6),%fp0		# load sgl src
4712	fmov.x		%fp0,FP_SRC(%a6)
4713	lea		FP_SRC(%a6),%a0
4714	bsr.l		tag			# fetch operand type
4715	mov.b		%d0,STAG(%a6)
4716	mov.l		%d0,%d1
4717
4718	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4719
4720	clr.l		%d0
4721	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4722
4723	lea		FP_SRC(%a6),%a0		# pass ptr to src
4724	lea		FP_DST(%a6),%a1		# pass ptr to dst
4725
4726	tst.b		%d1
4727	bne.b		_L23_2s
4728	bsr.l		sscale_snorm			# operand is a NORM
4729	bra.b		_L23_6s
4730_L23_2s:
4731	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4732	bne.b		_L23_3s			# no
4733	bsr.l		sscale_szero			# yes
4734	bra.b		_L23_6s
4735_L23_3s:
4736	cmpi.b		%d1,&INF		# is operand an INF?
4737	bne.b		_L23_4s			# no
4738	bsr.l		sscale_sinf			# yes
4739	bra.b		_L23_6s
4740_L23_4s:
4741	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4742	bne.b		_L23_5s			# no
4743	bsr.l		sop_sqnan			# yes
4744	bra.b		_L23_6s
4745_L23_5s:
4746	bsr.l		sscale_sdnrm			# operand is a DENORM
4747_L23_6s:
4748
4749#
4750#	Result is now in FP0
4751#
4752	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4753	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4754	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4755	unlk		%a6
4756	rts
4757
4758	global		_fscaled_
4759_fscaled_:
4760	link		%a6,&-LOCAL_SIZE
4761
4762	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4763	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4764	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4765
4766	fmov.l		&0x0,%fpcr		# zero FPCR
4767
4768#
4769#	copy, convert, and tag input argument
4770#
4771	fmov.d		0x8(%a6),%fp0		# load dbl dst
4772	fmov.x		%fp0,FP_DST(%a6)
4773	lea		FP_DST(%a6),%a0
4774	bsr.l		tag			# fetch operand type
4775	mov.b		%d0,DTAG(%a6)
4776
4777	fmov.d		0x10(%a6),%fp0		# load dbl src
4778	fmov.x		%fp0,FP_SRC(%a6)
4779	lea		FP_SRC(%a6),%a0
4780	bsr.l		tag			# fetch operand type
4781	mov.b		%d0,STAG(%a6)
4782	mov.l		%d0,%d1
4783
4784	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4785
4786	clr.l		%d0
4787	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4788
4789	lea		FP_SRC(%a6),%a0		# pass ptr to src
4790	lea		FP_DST(%a6),%a1		# pass ptr to dst
4791
4792	tst.b		%d1
4793	bne.b		_L23_2d
4794	bsr.l		sscale_snorm			# operand is a NORM
4795	bra.b		_L23_6d
4796_L23_2d:
4797	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4798	bne.b		_L23_3d			# no
4799	bsr.l		sscale_szero			# yes
4800	bra.b		_L23_6d
4801_L23_3d:
4802	cmpi.b		%d1,&INF		# is operand an INF?
4803	bne.b		_L23_4d			# no
4804	bsr.l		sscale_sinf			# yes
4805	bra.b		_L23_6d
4806_L23_4d:
4807	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4808	bne.b		_L23_5d			# no
4809	bsr.l		sop_sqnan			# yes
4810	bra.b		_L23_6d
4811_L23_5d:
4812	bsr.l		sscale_sdnrm			# operand is a DENORM
4813_L23_6d:
4814
4815#
4816#	Result is now in FP0
4817#
4818	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4819	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4820	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4821	unlk		%a6
4822	rts
4823
4824	global		_fscalex_
4825_fscalex_:
4826	link		%a6,&-LOCAL_SIZE
4827
4828	movm.l		&0x0303,EXC_DREGS(%a6)	# save d0-d1/a0-a1
4829	fmovm.l		%fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4830	fmovm.x		&0xc0,EXC_FP0(%a6)	# save fp0/fp1
4831
4832	fmov.l		&0x0,%fpcr		# zero FPCR
4833
4834#
4835#	copy, convert, and tag input argument
4836#
4837	lea		FP_DST(%a6),%a0
4838	mov.l		0x8+0x0(%a6),0x0(%a0)	# load ext dst
4839	mov.l		0x8+0x4(%a6),0x4(%a0)
4840	mov.l		0x8+0x8(%a6),0x8(%a0)
4841	bsr.l		tag			# fetch operand type
4842	mov.b		%d0,DTAG(%a6)
4843
4844	lea		FP_SRC(%a6),%a0
4845	mov.l		0x14+0x0(%a6),0x0(%a0)	# load ext src
4846	mov.l		0x14+0x4(%a6),0x4(%a0)
4847	mov.l		0x14+0x8(%a6),0x8(%a0)
4848	bsr.l		tag			# fetch operand type
4849	mov.b		%d0,STAG(%a6)
4850	mov.l		%d0,%d1
4851
4852	andi.l		&0x00ff00ff,USER_FPSR(%a6)
4853
4854	clr.l		%d0
4855	mov.b		FPCR_MODE(%a6),%d0	# pass rnd mode,prec
4856
4857	lea		FP_SRC(%a6),%a0		# pass ptr to src
4858	lea		FP_DST(%a6),%a1		# pass ptr to dst
4859
4860	tst.b		%d1
4861	bne.b		_L23_2x
4862	bsr.l		sscale_snorm			# operand is a NORM
4863	bra.b		_L23_6x
4864_L23_2x:
4865	cmpi.b		%d1,&ZERO		# is operand a ZERO?
4866	bne.b		_L23_3x			# no
4867	bsr.l		sscale_szero			# yes
4868	bra.b		_L23_6x
4869_L23_3x:
4870	cmpi.b		%d1,&INF		# is operand an INF?
4871	bne.b		_L23_4x			# no
4872	bsr.l		sscale_sinf			# yes
4873	bra.b		_L23_6x
4874_L23_4x:
4875	cmpi.b		%d1,&QNAN		# is operand a QNAN?
4876	bne.b		_L23_5x			# no
4877	bsr.l		sop_sqnan			# yes
4878	bra.b		_L23_6x
4879_L23_5x:
4880	bsr.l		sscale_sdnrm			# operand is a DENORM
4881_L23_6x:
4882
4883#
4884#	Result is now in FP0
4885#
4886	movm.l		EXC_DREGS(%a6),&0x0303	# restore d0-d1/a0-a1
4887	fmovm.l		USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4888	fmovm.x		EXC_FP1(%a6),&0x40	# restore fp1
4889	unlk		%a6
4890	rts
4891
4892
4893#########################################################################
4894# ssin():     computes the sine of a normalized input			#
4895# ssind():    computes the sine of a denormalized input			#
4896# scos():     computes the cosine of a normalized input			#
4897# scosd():    computes the cosine of a denormalized input		#
4898# ssincos():  computes the sine and cosine of a normalized input	#
4899# ssincosd(): computes the sine and cosine of a denormalized input	#
4900#									#
4901# INPUT *************************************************************** #
4902#	a0 = pointer to extended precision input			#
4903#	d0 = round precision,mode					#
4904#									#
4905# OUTPUT ************************************************************** #
4906#	fp0 = sin(X) or cos(X)						#
4907#									#
4908#    For ssincos(X):							#
4909#	fp0 = sin(X)							#
4910#	fp1 = cos(X)							#
4911#									#
4912# ACCURACY and MONOTONICITY ******************************************* #
4913#	The returned result is within 1 ulp in 64 significant bit, i.e.	#
4914#	within 0.5001 ulp to 53 bits if the result is subsequently	#
4915#	rounded to double precision. The result is provably monotonic	#
4916#	in double precision.						#
4917#									#
4918# ALGORITHM ***********************************************************	#
4919#									#
4920#	SIN and COS:							#
4921#	1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1.	#
4922#									#
4923#	2. If |X| >= 15Pi or |X| < 2**(-40), go to 7.			#
4924#									#
4925#	3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
4926#		k = N mod 4, so in particular, k = 0,1,2,or 3.		#
4927#		Overwrite k by k := k + AdjN.				#
4928#									#
4929#	4. If k is even, go to 6.					#
4930#									#
4931#	5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j.			#
4932#		Return sgn*cos(r) where cos(r) is approximated by an	#
4933#		even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)),	#
4934#		s = r*r.						#
4935#		Exit.							#
4936#									#
4937#	6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r)	#
4938#		where sin(r) is approximated by an odd polynomial in r	#
4939#		r + r*s*(A1+s*(A2+ ... + s*A7)),	s = r*r.	#
4940#		Exit.							#
4941#									#
4942#	7. If |X| > 1, go to 9.						#
4943#									#
4944#	8. (|X|<2**(-40)) If SIN is invoked, return X;			#
4945#		otherwise return 1.					#
4946#									#
4947#	9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,		#
4948#		go back to 3.						#
4949#									#
4950#	SINCOS:								#
4951#	1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.			#
4952#									#
4953#	2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
4954#		k = N mod 4, so in particular, k = 0,1,2,or 3.		#
4955#									#
4956#	3. If k is even, go to 5.					#
4957#									#
4958#	4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie.	#
4959#		j1 exclusive or with the l.s.b. of k.			#
4960#		sgn1 := (-1)**j1, sgn2 := (-1)**j2.			#
4961#		SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where	#
4962#		sin(r) and cos(r) are computed as odd and even		#
4963#		polynomials in r, respectively. Exit			#
4964#									#
4965#	5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1.			#
4966#		SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where	#
4967#		sin(r) and cos(r) are computed as odd and even		#
4968#		polynomials in r, respectively. Exit			#
4969#									#
4970#	6. If |X| > 1, go to 8.						#
4971#									#
4972#	7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit.		#
4973#									#
4974#	8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,		#
4975#		go back to 2.						#
4976#									#
4977#########################################################################
4978
4979SINA7:	long		0xBD6AAA77,0xCCC994F5
4980SINA6:	long		0x3DE61209,0x7AAE8DA1
4981SINA5:	long		0xBE5AE645,0x2A118AE4
4982SINA4:	long		0x3EC71DE3,0xA5341531
4983SINA3:	long		0xBF2A01A0,0x1A018B59,0x00000000,0x00000000
4984SINA2:	long		0x3FF80000,0x88888888,0x888859AF,0x00000000
4985SINA1:	long		0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000
4986
4987COSB8:	long		0x3D2AC4D0,0xD6011EE3
4988COSB7:	long		0xBDA9396F,0x9F45AC19
4989COSB6:	long		0x3E21EED9,0x0612C972
4990COSB5:	long		0xBE927E4F,0xB79D9FCF
4991COSB4:	long		0x3EFA01A0,0x1A01D423,0x00000000,0x00000000
4992COSB3:	long		0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000
4993COSB2:	long		0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E
4994COSB1:	long		0xBF000000
4995
4996	set		INARG,FP_SCR0
4997
4998	set		X,FP_SCR0
4999#	set		XDCARE,X+2
5000	set		XFRAC,X+4
5001
5002	set		RPRIME,FP_SCR0
5003	set		SPRIME,FP_SCR1
5004
5005	set		POSNEG1,L_SCR1
5006	set		TWOTO63,L_SCR1
5007
5008	set		ENDFLAG,L_SCR2
5009	set		INT,L_SCR2
5010
5011	set		ADJN,L_SCR3
5012
5013############################################
5014	global		ssin
5015ssin:
5016	mov.l		&0,ADJN(%a6)		# yes; SET ADJN TO 0
5017	bra.b		SINBGN
5018
5019############################################
5020	global		scos
5021scos:
5022	mov.l		&1,ADJN(%a6)		# yes; SET ADJN TO 1
5023
5024############################################
5025SINBGN:
5026#--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE
5027
5028	fmov.x		(%a0),%fp0		# LOAD INPUT
5029	fmov.x		%fp0,X(%a6)		# save input at X
5030
5031# "COMPACTIFY" X
5032	mov.l		(%a0),%d1		# put exp in hi word
5033	mov.w		4(%a0),%d1		# fetch hi(man)
5034	and.l		&0x7FFFFFFF,%d1		# strip sign
5035
5036	cmpi.l		%d1,&0x3FD78000		# is |X| >= 2**(-40)?
5037	bge.b		SOK1			# no
5038	bra.w		SINSM			# yes; input is very small
5039
5040SOK1:
5041	cmp.l		%d1,&0x4004BC7E		# is |X| < 15 PI?
5042	blt.b		SINMAIN			# no
5043	bra.w		SREDUCEX		# yes; input is very large
5044
5045#--THIS IS THE USUAL CASE, |X| <= 15 PI.
5046#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5047SINMAIN:
5048	fmov.x		%fp0,%fp1
5049	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
5050
5051	lea		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
5052
5053	fmov.l		%fp1,INT(%a6)		# CONVERT TO INTEGER
5054
5055	mov.l		INT(%a6),%d1		# make a copy of N
5056	asl.l		&4,%d1			# N *= 16
5057	add.l		%d1,%a1			# tbl_addr = a1 + (N*16)
5058
5059# A1 IS THE ADDRESS OF N*PIBY2
5060# ...WHICH IS IN TWO PIECES Y1 & Y2
5061	fsub.x		(%a1)+,%fp0		# X-Y1
5062	fsub.s		(%a1),%fp0		# fp0 = R = (X-Y1)-Y2
5063
5064SINCONT:
5065#--continuation from REDUCEX
5066
5067#--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDED
5068	mov.l		INT(%a6),%d1
5069	add.l		ADJN(%a6),%d1		# SEE IF D0 IS ODD OR EVEN
5070	ror.l		&1,%d1			# D0 WAS ODD IFF D0 IS NEGATIVE
5071	cmp.l		%d1,&0
5072	blt.w		COSPOLY
5073
5074#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
5075#--THEN WE RETURN	SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY
5076#--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE
5077#--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS
5078#--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))])
5079#--WHERE T=S*S.
5080#--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION
5081#--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT.
5082SINPOLY:
5083	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
5084
5085	fmov.x		%fp0,X(%a6)		# X IS R
5086	fmul.x		%fp0,%fp0		# FP0 IS S
5087
5088	fmov.d		SINA7(%pc),%fp3
5089	fmov.d		SINA6(%pc),%fp2
5090
5091	fmov.x		%fp0,%fp1
5092	fmul.x		%fp1,%fp1		# FP1 IS T
5093
5094	ror.l		&1,%d1
5095	and.l		&0x80000000,%d1
5096# ...LEAST SIG. BIT OF D0 IN SIGN POSITION
5097	eor.l		%d1,X(%a6)		# X IS NOW R'= SGN*R
5098
5099	fmul.x		%fp1,%fp3		# TA7
5100	fmul.x		%fp1,%fp2		# TA6
5101
5102	fadd.d		SINA5(%pc),%fp3		# A5+TA7
5103	fadd.d		SINA4(%pc),%fp2		# A4+TA6
5104
5105	fmul.x		%fp1,%fp3		# T(A5+TA7)
5106	fmul.x		%fp1,%fp2		# T(A4+TA6)
5107
5108	fadd.d		SINA3(%pc),%fp3		# A3+T(A5+TA7)
5109	fadd.x		SINA2(%pc),%fp2		# A2+T(A4+TA6)
5110
5111	fmul.x		%fp3,%fp1		# T(A3+T(A5+TA7))
5112
5113	fmul.x		%fp0,%fp2		# S(A2+T(A4+TA6))
5114	fadd.x		SINA1(%pc),%fp1		# A1+T(A3+T(A5+TA7))
5115	fmul.x		X(%a6),%fp0		# R'*S
5116
5117	fadd.x		%fp2,%fp1		# [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]
5118
5119	fmul.x		%fp1,%fp0		# SIN(R')-R'
5120
5121	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
5122
5123	fmov.l		%d0,%fpcr		# restore users round mode,prec
5124	fadd.x		X(%a6),%fp0		# last inst - possible exception set
5125	bra		t_inx2
5126
5127#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
5128#--THEN WE RETURN	SGN*COS(R). SGN*COS(R) IS COMPUTED BY
5129#--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE
5130#--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS
5131#--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))])
5132#--WHERE T=S*S.
5133#--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION
5134#--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2
5135#--AND IS THEREFORE STORED AS SINGLE PRECISION.
5136COSPOLY:
5137	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
5138
5139	fmul.x		%fp0,%fp0		# FP0 IS S
5140
5141	fmov.d		COSB8(%pc),%fp2
5142	fmov.d		COSB7(%pc),%fp3
5143
5144	fmov.x		%fp0,%fp1
5145	fmul.x		%fp1,%fp1		# FP1 IS T
5146
5147	fmov.x		%fp0,X(%a6)		# X IS S
5148	ror.l		&1,%d1
5149	and.l		&0x80000000,%d1
5150# ...LEAST SIG. BIT OF D0 IN SIGN POSITION
5151
5152	fmul.x		%fp1,%fp2		# TB8
5153
5154	eor.l		%d1,X(%a6)		# X IS NOW S'= SGN*S
5155	and.l		&0x80000000,%d1
5156
5157	fmul.x		%fp1,%fp3		# TB7
5158
5159	or.l		&0x3F800000,%d1		# D0 IS SGN IN SINGLE
5160	mov.l		%d1,POSNEG1(%a6)
5161
5162	fadd.d		COSB6(%pc),%fp2		# B6+TB8
5163	fadd.d		COSB5(%pc),%fp3		# B5+TB7
5164
5165	fmul.x		%fp1,%fp2		# T(B6+TB8)
5166	fmul.x		%fp1,%fp3		# T(B5+TB7)
5167
5168	fadd.d		COSB4(%pc),%fp2		# B4+T(B6+TB8)
5169	fadd.x		COSB3(%pc),%fp3		# B3+T(B5+TB7)
5170
5171	fmul.x		%fp1,%fp2		# T(B4+T(B6+TB8))
5172	fmul.x		%fp3,%fp1		# T(B3+T(B5+TB7))
5173
5174	fadd.x		COSB2(%pc),%fp2		# B2+T(B4+T(B6+TB8))
5175	fadd.s		COSB1(%pc),%fp1		# B1+T(B3+T(B5+TB7))
5176
5177	fmul.x		%fp2,%fp0		# S(B2+T(B4+T(B6+TB8)))
5178
5179	fadd.x		%fp1,%fp0
5180
5181	fmul.x		X(%a6),%fp0
5182
5183	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
5184
5185	fmov.l		%d0,%fpcr		# restore users round mode,prec
5186	fadd.s		POSNEG1(%a6),%fp0	# last inst - possible exception set
5187	bra		t_inx2
5188
5189##############################################
5190
5191# SINe: Big OR Small?
5192#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5193#--IF |X| < 2**(-40), RETURN X OR 1.
5194SINBORS:
5195	cmp.l		%d1,&0x3FFF8000
5196	bgt.l		SREDUCEX
5197
5198SINSM:
5199	mov.l		ADJN(%a6),%d1
5200	cmp.l		%d1,&0
5201	bgt.b		COSTINY
5202
5203# here, the operation may underflow iff the precision is sgl or dbl.
5204# extended denorms are handled through another entry point.
5205SINTINY:
5206#	mov.w		&0x0000,XDCARE(%a6)	# JUST IN CASE
5207
5208	fmov.l		%d0,%fpcr		# restore users round mode,prec
5209	mov.b		&FMOV_OP,%d1		# last inst is MOVE
5210	fmov.x		X(%a6),%fp0		# last inst - possible exception set
5211	bra		t_catch
5212
5213COSTINY:
5214	fmov.s		&0x3F800000,%fp0	# fp0 = 1.0
5215	fmov.l		%d0,%fpcr		# restore users round mode,prec
5216	fadd.s		&0x80800000,%fp0	# last inst - possible exception set
5217	bra		t_pinx2
5218
5219################################################
5220	global		ssind
5221#--SIN(X) = X FOR DENORMALIZED X
5222ssind:
5223	bra		t_extdnrm
5224
5225############################################
5226	global		scosd
5227#--COS(X) = 1 FOR DENORMALIZED X
5228scosd:
5229	fmov.s		&0x3F800000,%fp0	# fp0 = 1.0
5230	bra		t_pinx2
5231
5232##################################################
5233
5234	global		ssincos
5235ssincos:
5236#--SET ADJN TO 4
5237	mov.l		&4,ADJN(%a6)
5238
5239	fmov.x		(%a0),%fp0		# LOAD INPUT
5240	fmov.x		%fp0,X(%a6)
5241
5242	mov.l		(%a0),%d1
5243	mov.w		4(%a0),%d1
5244	and.l		&0x7FFFFFFF,%d1		# COMPACTIFY X
5245
5246	cmp.l		%d1,&0x3FD78000		# |X| >= 2**(-40)?
5247	bge.b		SCOK1
5248	bra.w		SCSM
5249
5250SCOK1:
5251	cmp.l		%d1,&0x4004BC7E		# |X| < 15 PI?
5252	blt.b		SCMAIN
5253	bra.w		SREDUCEX
5254
5255
5256#--THIS IS THE USUAL CASE, |X| <= 15 PI.
5257#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5258SCMAIN:
5259	fmov.x		%fp0,%fp1
5260
5261	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
5262
5263	lea		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
5264
5265	fmov.l		%fp1,INT(%a6)		# CONVERT TO INTEGER
5266
5267	mov.l		INT(%a6),%d1
5268	asl.l		&4,%d1
5269	add.l		%d1,%a1			# ADDRESS OF N*PIBY2, IN Y1, Y2
5270
5271	fsub.x		(%a1)+,%fp0		# X-Y1
5272	fsub.s		(%a1),%fp0		# FP0 IS R = (X-Y1)-Y2
5273
5274SCCONT:
5275#--continuation point from REDUCEX
5276
5277	mov.l		INT(%a6),%d1
5278	ror.l		&1,%d1
5279	cmp.l		%d1,&0			# D0 < 0 IFF N IS ODD
5280	bge.w		NEVEN
5281
5282SNODD:
5283#--REGISTERS SAVED SO FAR: D0, A0, FP2.
5284	fmovm.x		&0x04,-(%sp)		# save fp2
5285
5286	fmov.x		%fp0,RPRIME(%a6)
5287	fmul.x		%fp0,%fp0		# FP0 IS S = R*R
5288	fmov.d		SINA7(%pc),%fp1		# A7
5289	fmov.d		COSB8(%pc),%fp2		# B8
5290	fmul.x		%fp0,%fp1		# SA7
5291	fmul.x		%fp0,%fp2		# SB8
5292
5293	mov.l		%d2,-(%sp)
5294	mov.l		%d1,%d2
5295	ror.l		&1,%d2
5296	and.l		&0x80000000,%d2
5297	eor.l		%d1,%d2
5298	and.l		&0x80000000,%d2
5299
5300	fadd.d		SINA6(%pc),%fp1		# A6+SA7
5301	fadd.d		COSB7(%pc),%fp2		# B7+SB8
5302
5303	fmul.x		%fp0,%fp1		# S(A6+SA7)
5304	eor.l		%d2,RPRIME(%a6)
5305	mov.l		(%sp)+,%d2
5306	fmul.x		%fp0,%fp2		# S(B7+SB8)
5307	ror.l		&1,%d1
5308	and.l		&0x80000000,%d1
5309	mov.l		&0x3F800000,POSNEG1(%a6)
5310	eor.l		%d1,POSNEG1(%a6)
5311
5312	fadd.d		SINA5(%pc),%fp1		# A5+S(A6+SA7)
5313	fadd.d		COSB6(%pc),%fp2		# B6+S(B7+SB8)
5314
5315	fmul.x		%fp0,%fp1		# S(A5+S(A6+SA7))
5316	fmul.x		%fp0,%fp2		# S(B6+S(B7+SB8))
5317	fmov.x		%fp0,SPRIME(%a6)
5318
5319	fadd.d		SINA4(%pc),%fp1		# A4+S(A5+S(A6+SA7))
5320	eor.l		%d1,SPRIME(%a6)
5321	fadd.d		COSB5(%pc),%fp2		# B5+S(B6+S(B7+SB8))
5322
5323	fmul.x		%fp0,%fp1		# S(A4+...)
5324	fmul.x		%fp0,%fp2		# S(B5+...)
5325
5326	fadd.d		SINA3(%pc),%fp1		# A3+S(A4+...)
5327	fadd.d		COSB4(%pc),%fp2		# B4+S(B5+...)
5328
5329	fmul.x		%fp0,%fp1		# S(A3+...)
5330	fmul.x		%fp0,%fp2		# S(B4+...)
5331
5332	fadd.x		SINA2(%pc),%fp1		# A2+S(A3+...)
5333	fadd.x		COSB3(%pc),%fp2		# B3+S(B4+...)
5334
5335	fmul.x		%fp0,%fp1		# S(A2+...)
5336	fmul.x		%fp0,%fp2		# S(B3+...)
5337
5338	fadd.x		SINA1(%pc),%fp1		# A1+S(A2+...)
5339	fadd.x		COSB2(%pc),%fp2		# B2+S(B3+...)
5340
5341	fmul.x		%fp0,%fp1		# S(A1+...)
5342	fmul.x		%fp2,%fp0		# S(B2+...)
5343
5344	fmul.x		RPRIME(%a6),%fp1	# R'S(A1+...)
5345	fadd.s		COSB1(%pc),%fp0		# B1+S(B2...)
5346	fmul.x		SPRIME(%a6),%fp0	# S'(B1+S(B2+...))
5347
5348	fmovm.x		(%sp)+,&0x20		# restore fp2
5349
5350	fmov.l		%d0,%fpcr
5351	fadd.x		RPRIME(%a6),%fp1	# COS(X)
5352	bsr		sto_cos			# store cosine result
5353	fadd.s		POSNEG1(%a6),%fp0	# SIN(X)
5354	bra		t_inx2
5355
5356NEVEN:
5357#--REGISTERS SAVED SO FAR: FP2.
5358	fmovm.x		&0x04,-(%sp)		# save fp2
5359
5360	fmov.x		%fp0,RPRIME(%a6)
5361	fmul.x		%fp0,%fp0		# FP0 IS S = R*R
5362
5363	fmov.d		COSB8(%pc),%fp1		# B8
5364	fmov.d		SINA7(%pc),%fp2		# A7
5365
5366	fmul.x		%fp0,%fp1		# SB8
5367	fmov.x		%fp0,SPRIME(%a6)
5368	fmul.x		%fp0,%fp2		# SA7
5369
5370	ror.l		&1,%d1
5371	and.l		&0x80000000,%d1
5372
5373	fadd.d		COSB7(%pc),%fp1		# B7+SB8
5374	fadd.d		SINA6(%pc),%fp2		# A6+SA7
5375
5376	eor.l		%d1,RPRIME(%a6)
5377	eor.l		%d1,SPRIME(%a6)
5378
5379	fmul.x		%fp0,%fp1		# S(B7+SB8)
5380
5381	or.l		&0x3F800000,%d1
5382	mov.l		%d1,POSNEG1(%a6)
5383
5384	fmul.x		%fp0,%fp2		# S(A6+SA7)
5385
5386	fadd.d		COSB6(%pc),%fp1		# B6+S(B7+SB8)
5387	fadd.d		SINA5(%pc),%fp2		# A5+S(A6+SA7)
5388
5389	fmul.x		%fp0,%fp1		# S(B6+S(B7+SB8))
5390	fmul.x		%fp0,%fp2		# S(A5+S(A6+SA7))
5391
5392	fadd.d		COSB5(%pc),%fp1		# B5+S(B6+S(B7+SB8))
5393	fadd.d		SINA4(%pc),%fp2		# A4+S(A5+S(A6+SA7))
5394
5395	fmul.x		%fp0,%fp1		# S(B5+...)
5396	fmul.x		%fp0,%fp2		# S(A4+...)
5397
5398	fadd.d		COSB4(%pc),%fp1		# B4+S(B5+...)
5399	fadd.d		SINA3(%pc),%fp2		# A3+S(A4+...)
5400
5401	fmul.x		%fp0,%fp1		# S(B4+...)
5402	fmul.x		%fp0,%fp2		# S(A3+...)
5403
5404	fadd.x		COSB3(%pc),%fp1		# B3+S(B4+...)
5405	fadd.x		SINA2(%pc),%fp2		# A2+S(A3+...)
5406
5407	fmul.x		%fp0,%fp1		# S(B3+...)
5408	fmul.x		%fp0,%fp2		# S(A2+...)
5409
5410	fadd.x		COSB2(%pc),%fp1		# B2+S(B3+...)
5411	fadd.x		SINA1(%pc),%fp2		# A1+S(A2+...)
5412
5413	fmul.x		%fp0,%fp1		# S(B2+...)
5414	fmul.x		%fp2,%fp0		# s(a1+...)
5415
5416
5417	fadd.s		COSB1(%pc),%fp1		# B1+S(B2...)
5418	fmul.x		RPRIME(%a6),%fp0	# R'S(A1+...)
5419	fmul.x		SPRIME(%a6),%fp1	# S'(B1+S(B2+...))
5420
5421	fmovm.x		(%sp)+,&0x20		# restore fp2
5422
5423	fmov.l		%d0,%fpcr
5424	fadd.s		POSNEG1(%a6),%fp1	# COS(X)
5425	bsr		sto_cos			# store cosine result
5426	fadd.x		RPRIME(%a6),%fp0	# SIN(X)
5427	bra		t_inx2
5428
5429################################################
5430
5431SCBORS:
5432	cmp.l		%d1,&0x3FFF8000
5433	bgt.w		SREDUCEX
5434
5435################################################
5436
5437SCSM:
5438#	mov.w		&0x0000,XDCARE(%a6)
5439	fmov.s		&0x3F800000,%fp1
5440
5441	fmov.l		%d0,%fpcr
5442	fsub.s		&0x00800000,%fp1
5443	bsr		sto_cos			# store cosine result
5444	fmov.l		%fpcr,%d0		# d0 must have fpcr,too
5445	mov.b		&FMOV_OP,%d1		# last inst is MOVE
5446	fmov.x		X(%a6),%fp0
5447	bra		t_catch
5448
5449##############################################
5450
5451	global		ssincosd
5452#--SIN AND COS OF X FOR DENORMALIZED X
5453ssincosd:
5454	mov.l		%d0,-(%sp)		# save d0
5455	fmov.s		&0x3F800000,%fp1
5456	bsr		sto_cos			# store cosine result
5457	mov.l		(%sp)+,%d0		# restore d0
5458	bra		t_extdnrm
5459
5460############################################
5461
5462#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
5463#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
5464#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
5465SREDUCEX:
5466	fmovm.x		&0x3c,-(%sp)		# save {fp2-fp5}
5467	mov.l		%d2,-(%sp)		# save d2
5468	fmov.s		&0x00000000,%fp1	# fp1 = 0
5469
5470#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
5471#--there is a danger of unwanted overflow in first LOOP iteration.  In this
5472#--case, reduce argument by one remainder step to make subsequent reduction
5473#--safe.
5474	cmp.l		%d1,&0x7ffeffff		# is arg dangerously large?
5475	bne.b		SLOOP			# no
5476
5477# yes; create 2**16383*PI/2
5478	mov.w		&0x7ffe,FP_SCR0_EX(%a6)
5479	mov.l		&0xc90fdaa2,FP_SCR0_HI(%a6)
5480	clr.l		FP_SCR0_LO(%a6)
5481
5482# create low half of 2**16383*PI/2 at FP_SCR1
5483	mov.w		&0x7fdc,FP_SCR1_EX(%a6)
5484	mov.l		&0x85a308d3,FP_SCR1_HI(%a6)
5485	clr.l		FP_SCR1_LO(%a6)
5486
5487	ftest.x		%fp0			# test sign of argument
5488	fblt.w		sred_neg
5489
5490	or.b		&0x80,FP_SCR0_EX(%a6)	# positive arg
5491	or.b		&0x80,FP_SCR1_EX(%a6)
5492sred_neg:
5493	fadd.x		FP_SCR0(%a6),%fp0	# high part of reduction is exact
5494	fmov.x		%fp0,%fp1		# save high result in fp1
5495	fadd.x		FP_SCR1(%a6),%fp0	# low part of reduction
5496	fsub.x		%fp0,%fp1		# determine low component of result
5497	fadd.x		FP_SCR1(%a6),%fp1	# fp0/fp1 are reduced argument.
5498
5499#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5500#--integer quotient will be stored in N
5501#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5502SLOOP:
5503	fmov.x		%fp0,INARG(%a6)		# +-2**K * F, 1 <= F < 2
5504	mov.w		INARG(%a6),%d1
5505	mov.l		%d1,%a1			# save a copy of D0
5506	and.l		&0x00007FFF,%d1
5507	sub.l		&0x00003FFF,%d1		# d0 = K
5508	cmp.l		%d1,&28
5509	ble.b		SLASTLOOP
5510SCONTLOOP:
5511	sub.l		&27,%d1			# d0 = L := K-27
5512	mov.b		&0,ENDFLAG(%a6)
5513	bra.b		SWORK
5514SLASTLOOP:
5515	clr.l		%d1			# d0 = L := 0
5516	mov.b		&1,ENDFLAG(%a6)
5517
5518SWORK:
5519#--FIND THE REMAINDER OF (R,r) W.R.T.	2**L * (PI/2). L IS SO CHOSEN
5520#--THAT	INT( X * (2/PI) / 2**(L) ) < 2**29.
5521
5522#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
5523#--2**L * (PIby2_1), 2**L * (PIby2_2)
5524
5525	mov.l		&0x00003FFE,%d2		# BIASED EXP OF 2/PI
5526	sub.l		%d1,%d2			# BIASED EXP OF 2**(-L)*(2/PI)
5527
5528	mov.l		&0xA2F9836E,FP_SCR0_HI(%a6)
5529	mov.l		&0x4E44152A,FP_SCR0_LO(%a6)
5530	mov.w		%d2,FP_SCR0_EX(%a6)	# FP_SCR0 = 2**(-L)*(2/PI)
5531
5532	fmov.x		%fp0,%fp2
5533	fmul.x		FP_SCR0(%a6),%fp2	# fp2 = X * 2**(-L)*(2/PI)
5534
5535#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5536#--FLOATING POINT FORMAT, THE TWO FMOVE'S	FMOVE.L FP <--> N
5537#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
5538#--(SIGN(INARG)*2**63	+	FP2) - SIGN(INARG)*2**63 WILL GIVE
5539#--US THE DESIRED VALUE IN FLOATING POINT.
5540	mov.l		%a1,%d2
5541	swap		%d2
5542	and.l		&0x80000000,%d2
5543	or.l		&0x5F000000,%d2		# d2 = SIGN(INARG)*2**63 IN SGL
5544	mov.l		%d2,TWOTO63(%a6)
5545	fadd.s		TWOTO63(%a6),%fp2	# THE FRACTIONAL PART OF FP1 IS ROUNDED
5546	fsub.s		TWOTO63(%a6),%fp2	# fp2 = N
5547#	fint.x		%fp2
5548
5549#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
5550	mov.l		%d1,%d2			# d2 = L
5551
5552	add.l		&0x00003FFF,%d2		# BIASED EXP OF 2**L * (PI/2)
5553	mov.w		%d2,FP_SCR0_EX(%a6)
5554	mov.l		&0xC90FDAA2,FP_SCR0_HI(%a6)
5555	clr.l		FP_SCR0_LO(%a6)		# FP_SCR0 = 2**(L) * Piby2_1
5556
5557	add.l		&0x00003FDD,%d1
5558	mov.w		%d1,FP_SCR1_EX(%a6)
5559	mov.l		&0x85A308D3,FP_SCR1_HI(%a6)
5560	clr.l		FP_SCR1_LO(%a6)		# FP_SCR1 = 2**(L) * Piby2_2
5561
5562	mov.b		ENDFLAG(%a6),%d1
5563
5564#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
5565#--P2 = 2**(L) * Piby2_2
5566	fmov.x		%fp2,%fp4		# fp4 = N
5567	fmul.x		FP_SCR0(%a6),%fp4	# fp4 = W = N*P1
5568	fmov.x		%fp2,%fp5		# fp5 = N
5569	fmul.x		FP_SCR1(%a6),%fp5	# fp5 = w = N*P2
5570	fmov.x		%fp4,%fp3		# fp3 = W = N*P1
5571
5572#--we want P+p = W+w  but  |p| <= half ulp of P
5573#--Then, we need to compute  A := R-P   and  a := r-p
5574	fadd.x		%fp5,%fp3		# fp3 = P
5575	fsub.x		%fp3,%fp4		# fp4 = W-P
5576
5577	fsub.x		%fp3,%fp0		# fp0 = A := R - P
5578	fadd.x		%fp5,%fp4		# fp4 = p = (W-P)+w
5579
5580	fmov.x		%fp0,%fp3		# fp3 = A
5581	fsub.x		%fp4,%fp1		# fp1 = a := r - p
5582
5583#--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
5584#--|r| <= half ulp of R.
5585	fadd.x		%fp1,%fp0		# fp0 = R := A+a
5586#--No need to calculate r if this is the last loop
5587	cmp.b		%d1,&0
5588	bgt.w		SRESTORE
5589
5590#--Need to calculate r
5591	fsub.x		%fp0,%fp3		# fp3 = A-R
5592	fadd.x		%fp3,%fp1		# fp1 = r := (A-R)+a
5593	bra.w		SLOOP
5594
5595SRESTORE:
5596	fmov.l		%fp2,INT(%a6)
5597	mov.l		(%sp)+,%d2		# restore d2
5598	fmovm.x		(%sp)+,&0x3c		# restore {fp2-fp5}
5599
5600	mov.l		ADJN(%a6),%d1
5601	cmp.l		%d1,&4
5602
5603	blt.w		SINCONT
5604	bra.w		SCCONT
5605
5606#########################################################################
5607# stan():  computes the tangent of a normalized input			#
5608# stand(): computes the tangent of a denormalized input			#
5609#									#
5610# INPUT *************************************************************** #
5611#	a0 = pointer to extended precision input			#
5612#	d0 = round precision,mode					#
5613#									#
5614# OUTPUT ************************************************************** #
5615#	fp0 = tan(X)							#
5616#									#
5617# ACCURACY and MONOTONICITY ******************************************* #
5618#	The returned result is within 3 ulp in 64 significant bit, i.e. #
5619#	within 0.5001 ulp to 53 bits if the result is subsequently	#
5620#	rounded to double precision. The result is provably monotonic	#
5621#	in double precision.						#
5622#									#
5623# ALGORITHM *********************************************************** #
5624#									#
5625#	1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.			#
5626#									#
5627#	2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let	#
5628#		k = N mod 2, so in particular, k = 0 or 1.		#
5629#									#
5630#	3. If k is odd, go to 5.					#
5631#									#
5632#	4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a	#
5633#		rational function U/V where				#
5634#		U = r + r*s*(P1 + s*(P2 + s*P3)), and			#
5635#		V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))),  s = r*r.	#
5636#		Exit.							#
5637#									#
5638#	4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by #
5639#		a rational function U/V where				#
5640#		U = r + r*s*(P1 + s*(P2 + s*P3)), and			#
5641#		V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r,	#
5642#		-Cot(r) = -V/U. Exit.					#
5643#									#
5644#	6. If |X| > 1, go to 8.						#
5645#									#
5646#	7. (|X|<2**(-40)) Tan(X) = X. Exit.				#
5647#									#
5648#	8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back	#
5649#		to 2.							#
5650#									#
5651#########################################################################
5652
5653TANQ4:
5654	long		0x3EA0B759,0xF50F8688
5655TANP3:
5656	long		0xBEF2BAA5,0xA8924F04
5657
5658TANQ3:
5659	long		0xBF346F59,0xB39BA65F,0x00000000,0x00000000
5660
5661TANP2:
5662	long		0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000
5663
5664TANQ2:
5665	long		0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000
5666
5667TANP1:
5668	long		0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000
5669
5670TANQ1:
5671	long		0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000
5672
5673INVTWOPI:
5674	long		0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000
5675
5676TWOPI1:
5677	long		0x40010000,0xC90FDAA2,0x00000000,0x00000000
5678TWOPI2:
5679	long		0x3FDF0000,0x85A308D4,0x00000000,0x00000000
5680
5681#--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING
5682#--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT
5683#--MOST 69 BITS LONG.
5684#	global		PITBL
5685PITBL:
5686	long		0xC0040000,0xC90FDAA2,0x2168C235,0x21800000
5687	long		0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000
5688	long		0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000
5689	long		0xC0040000,0xB6365E22,0xEE46F000,0x21480000
5690	long		0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000
5691	long		0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000
5692	long		0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000
5693	long		0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000
5694	long		0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000
5695	long		0xC0040000,0x90836524,0x88034B96,0x20B00000
5696	long		0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000
5697	long		0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000
5698	long		0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000
5699	long		0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000
5700	long		0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000
5701	long		0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000
5702	long		0xC0030000,0xC90FDAA2,0x2168C235,0x21000000
5703	long		0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000
5704	long		0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000
5705	long		0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000
5706	long		0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000
5707	long		0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000
5708	long		0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000
5709	long		0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000
5710	long		0xC0020000,0xC90FDAA2,0x2168C235,0x20800000
5711	long		0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000
5712	long		0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000
5713	long		0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000
5714	long		0xC0010000,0xC90FDAA2,0x2168C235,0x20000000
5715	long		0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000
5716	long		0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000
5717	long		0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000
5718	long		0x00000000,0x00000000,0x00000000,0x00000000
5719	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000
5720	long		0x40000000,0xC90FDAA2,0x2168C235,0x9F800000
5721	long		0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000
5722	long		0x40010000,0xC90FDAA2,0x2168C235,0xA0000000
5723	long		0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000
5724	long		0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000
5725	long		0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000
5726	long		0x40020000,0xC90FDAA2,0x2168C235,0xA0800000
5727	long		0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000
5728	long		0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000
5729	long		0x40030000,0x8A3AE64F,0x76F80584,0x21080000
5730	long		0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000
5731	long		0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000
5732	long		0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000
5733	long		0x40030000,0xBC7EDCF7,0xFF523611,0x21680000
5734	long		0x40030000,0xC90FDAA2,0x2168C235,0xA1000000
5735	long		0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000
5736	long		0x40030000,0xE231D5F6,0x6595DA7B,0x21300000
5737	long		0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000
5738	long		0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000
5739	long		0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000
5740	long		0x40040000,0x8A3AE64F,0x76F80584,0x21880000
5741	long		0x40040000,0x90836524,0x88034B96,0xA0B00000
5742	long		0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000
5743	long		0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000
5744	long		0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000
5745	long		0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000
5746	long		0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000
5747	long		0x40040000,0xB6365E22,0xEE46F000,0xA1480000
5748	long		0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000
5749	long		0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000
5750	long		0x40040000,0xC90FDAA2,0x2168C235,0xA1800000
5751
5752	set		INARG,FP_SCR0
5753
5754	set		TWOTO63,L_SCR1
5755	set		INT,L_SCR1
5756	set		ENDFLAG,L_SCR2
5757
5758	global		stan
5759stan:
5760	fmov.x		(%a0),%fp0		# LOAD INPUT
5761
5762	mov.l		(%a0),%d1
5763	mov.w		4(%a0),%d1
5764	and.l		&0x7FFFFFFF,%d1
5765
5766	cmp.l		%d1,&0x3FD78000		# |X| >= 2**(-40)?
5767	bge.b		TANOK1
5768	bra.w		TANSM
5769TANOK1:
5770	cmp.l		%d1,&0x4004BC7E		# |X| < 15 PI?
5771	blt.b		TANMAIN
5772	bra.w		REDUCEX
5773
5774TANMAIN:
5775#--THIS IS THE USUAL CASE, |X| <= 15 PI.
5776#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5777	fmov.x		%fp0,%fp1
5778	fmul.d		TWOBYPI(%pc),%fp1	# X*2/PI
5779
5780	lea.l		PITBL+0x200(%pc),%a1	# TABLE OF N*PI/2, N = -32,...,32
5781
5782	fmov.l		%fp1,%d1		# CONVERT TO INTEGER
5783
5784	asl.l		&4,%d1
5785	add.l		%d1,%a1			# ADDRESS N*PIBY2 IN Y1, Y2
5786
5787	fsub.x		(%a1)+,%fp0		# X-Y1
5788
5789	fsub.s		(%a1),%fp0		# FP0 IS R = (X-Y1)-Y2
5790
5791	ror.l		&5,%d1
5792	and.l		&0x80000000,%d1		# D0 WAS ODD IFF D0 < 0
5793
5794TANCONT:
5795	fmovm.x		&0x0c,-(%sp)		# save fp2,fp3
5796
5797	cmp.l		%d1,&0
5798	blt.w		NODD
5799
5800	fmov.x		%fp0,%fp1
5801	fmul.x		%fp1,%fp1		# S = R*R
5802
5803	fmov.d		TANQ4(%pc),%fp3
5804	fmov.d		TANP3(%pc),%fp2
5805
5806	fmul.x		%fp1,%fp3		# SQ4
5807	fmul.x		%fp1,%fp2		# SP3
5808
5809	fadd.d		TANQ3(%pc),%fp3		# Q3+SQ4
5810	fadd.x		TANP2(%pc),%fp2		# P2+SP3
5811
5812	fmul.x		%fp1,%fp3		# S(Q3+SQ4)
5813	fmul.x		%fp1,%fp2		# S(P2+SP3)
5814
5815	fadd.x		TANQ2(%pc),%fp3		# Q2+S(Q3+SQ4)
5816	fadd.x		TANP1(%pc),%fp2		# P1+S(P2+SP3)
5817
5818	fmul.x		%fp1,%fp3		# S(Q2+S(Q3+SQ4))
5819	fmul.x		%fp1,%fp2		# S(P1+S(P2+SP3))
5820
5821	fadd.x		TANQ1(%pc),%fp3		# Q1+S(Q2+S(Q3+SQ4))
5822	fmul.x		%fp0,%fp2		# RS(P1+S(P2+SP3))
5823
5824	fmul.x		%fp3,%fp1		# S(Q1+S(Q2+S(Q3+SQ4)))
5825
5826	fadd.x		%fp2,%fp0		# R+RS(P1+S(P2+SP3))
5827
5828	fadd.s		&0x3F800000,%fp1	# 1+S(Q1+...)
5829
5830	fmovm.x		(%sp)+,&0x30		# restore fp2,fp3
5831
5832	fmov.l		%d0,%fpcr		# restore users round mode,prec
5833	fdiv.x		%fp1,%fp0		# last inst - possible exception set
5834	bra		t_inx2
5835
5836NODD:
5837	fmov.x		%fp0,%fp1
5838	fmul.x		%fp0,%fp0		# S = R*R
5839
5840	fmov.d		TANQ4(%pc),%fp3
5841	fmov.d		TANP3(%pc),%fp2
5842
5843	fmul.x		%fp0,%fp3		# SQ4
5844	fmul.x		%fp0,%fp2		# SP3
5845
5846	fadd.d		TANQ3(%pc),%fp3		# Q3+SQ4
5847	fadd.x		TANP2(%pc),%fp2		# P2+SP3
5848
5849	fmul.x		%fp0,%fp3		# S(Q3+SQ4)
5850	fmul.x		%fp0,%fp2		# S(P2+SP3)
5851
5852	fadd.x		TANQ2(%pc),%fp3		# Q2+S(Q3+SQ4)
5853	fadd.x		TANP1(%pc),%fp2		# P1+S(P2+SP3)
5854
5855	fmul.x		%fp0,%fp3		# S(Q2+S(Q3+SQ4))
5856	fmul.x		%fp0,%fp2		# S(P1+S(P2+SP3))
5857
5858	fadd.x		TANQ1(%pc),%fp3		# Q1+S(Q2+S(Q3+SQ4))
5859	fmul.x		%fp1,%fp2		# RS(P1+S(P2+SP3))
5860
5861	fmul.x		%fp3,%fp0		# S(Q1+S(Q2+S(Q3+SQ4)))
5862
5863	fadd.x		%fp2,%fp1		# R+RS(P1+S(P2+SP3))
5864	fadd.s		&0x3F800000,%fp0	# 1+S(Q1+...)
5865
5866	fmovm.x		(%sp)+,&0x30		# restore fp2,fp3
5867
5868	fmov.x		%fp1,-(%sp)
5869	eor.l		&0x80000000,(%sp)
5870
5871	fmov.l		%d0,%fpcr		# restore users round mode,prec
5872	fdiv.x		(%sp)+,%fp0		# last inst - possible exception set
5873	bra		t_inx2
5874
5875TANBORS:
5876#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5877#--IF |X| < 2**(-40), RETURN X OR 1.
5878	cmp.l		%d1,&0x3FFF8000
5879	bgt.b		REDUCEX
5880
5881TANSM:
5882	fmov.x		%fp0,-(%sp)
5883	fmov.l		%d0,%fpcr		# restore users round mode,prec
5884	mov.b		&FMOV_OP,%d1		# last inst is MOVE
5885	fmov.x		(%sp)+,%fp0		# last inst - posibble exception set
5886	bra		t_catch
5887
5888	global		stand
5889#--TAN(X) = X FOR DENORMALIZED X
5890stand:
5891	bra		t_extdnrm
5892
5893#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
5894#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
5895#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
5896REDUCEX:
5897	fmovm.x		&0x3c,-(%sp)		# save {fp2-fp5}
5898	mov.l		%d2,-(%sp)		# save d2
5899	fmov.s		&0x00000000,%fp1	# fp1 = 0
5900
5901#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
5902#--there is a danger of unwanted overflow in first LOOP iteration.  In this
5903#--case, reduce argument by one remainder step to make subsequent reduction
5904#--safe.
5905	cmp.l		%d1,&0x7ffeffff		# is arg dangerously large?
5906	bne.b		LOOP			# no
5907
5908# yes; create 2**16383*PI/2
5909	mov.w		&0x7ffe,FP_SCR0_EX(%a6)
5910	mov.l		&0xc90fdaa2,FP_SCR0_HI(%a6)
5911	clr.l		FP_SCR0_LO(%a6)
5912
5913# create low half of 2**16383*PI/2 at FP_SCR1
5914	mov.w		&0x7fdc,FP_SCR1_EX(%a6)
5915	mov.l		&0x85a308d3,FP_SCR1_HI(%a6)
5916	clr.l		FP_SCR1_LO(%a6)
5917
5918	ftest.x		%fp0			# test sign of argument
5919	fblt.w		red_neg
5920
5921	or.b		&0x80,FP_SCR0_EX(%a6)	# positive arg
5922	or.b		&0x80,FP_SCR1_EX(%a6)
5923red_neg:
5924	fadd.x		FP_SCR0(%a6),%fp0	# high part of reduction is exact
5925	fmov.x		%fp0,%fp1		# save high result in fp1
5926	fadd.x		FP_SCR1(%a6),%fp0	# low part of reduction
5927	fsub.x		%fp0,%fp1		# determine low component of result
5928	fadd.x		FP_SCR1(%a6),%fp1	# fp0/fp1 are reduced argument.
5929
5930#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5931#--integer quotient will be stored in N
5932#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5933LOOP:
5934	fmov.x		%fp0,INARG(%a6)		# +-2**K * F, 1 <= F < 2
5935	mov.w		INARG(%a6),%d1
5936	mov.l		%d1,%a1			# save a copy of D0
5937	and.l		&0x00007FFF,%d1
5938	sub.l		&0x00003FFF,%d1		# d0 = K
5939	cmp.l		%d1,&28
5940	ble.b		LASTLOOP
5941CONTLOOP:
5942	sub.l		&27,%d1			# d0 = L := K-27
5943	mov.b		&0,ENDFLAG(%a6)
5944	bra.b		WORK
5945LASTLOOP:
5946	clr.l		%d1			# d0 = L := 0
5947	mov.b		&1,ENDFLAG(%a6)
5948
5949WORK:
5950#--FIND THE REMAINDER OF (R,r) W.R.T.	2**L * (PI/2). L IS SO CHOSEN
5951#--THAT	INT( X * (2/PI) / 2**(L) ) < 2**29.
5952
5953#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
5954#--2**L * (PIby2_1), 2**L * (PIby2_2)
5955
5956	mov.l		&0x00003FFE,%d2		# BIASED EXP OF 2/PI
5957	sub.l		%d1,%d2			# BIASED EXP OF 2**(-L)*(2/PI)
5958
5959	mov.l		&0xA2F9836E,FP_SCR0_HI(%a6)
5960	mov.l		&0x4E44152A,FP_SCR0_LO(%a6)
5961	mov.w		%d2,FP_SCR0_EX(%a6)	# FP_SCR0 = 2**(-L)*(2/PI)
5962
5963	fmov.x		%fp0,%fp2
5964	fmul.x		FP_SCR0(%a6),%fp2	# fp2 = X * 2**(-L)*(2/PI)
5965
5966#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5967#--FLOATING POINT FORMAT, THE TWO FMOVE'S	FMOVE.L FP <--> N
5968#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
5969#--(SIGN(INARG)*2**63	+	FP2) - SIGN(INARG)*2**63 WILL GIVE
5970#--US THE DESIRED VALUE IN FLOATING POINT.
5971	mov.l		%a1,%d2
5972	swap		%d2
5973	and.l		&0x80000000,%d2
5974	or.l		&0x5F000000,%d2		# d2 = SIGN(INARG)*2**63 IN SGL
5975	mov.l		%d2,TWOTO63(%a6)
5976	fadd.s		TWOTO63(%a6),%fp2	# THE FRACTIONAL PART OF FP1 IS ROUNDED
5977	fsub.s		TWOTO63(%a6),%fp2	# fp2 = N
5978#	fintrz.x	%fp2,%fp2
5979
5980#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
5981	mov.l		%d1,%d2			# d2 = L
5982
5983	add.l		&0x00003FFF,%d2		# BIASED EXP OF 2**L * (PI/2)
5984	mov.w		%d2,FP_SCR0_EX(%a6)
5985	mov.l		&0xC90FDAA2,FP_SCR0_HI(%a6)
5986	clr.l		FP_SCR0_LO(%a6)		# FP_SCR0 = 2**(L) * Piby2_1
5987
5988	add.l		&0x00003FDD,%d1
5989	mov.w		%d1,FP_SCR1_EX(%a6)
5990	mov.l		&0x85A308D3,FP_SCR1_HI(%a6)
5991	clr.l		FP_SCR1_LO(%a6)		# FP_SCR1 = 2**(L) * Piby2_2
5992
5993	mov.b		ENDFLAG(%a6),%d1
5994
5995#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
5996#--P2 = 2**(L) * Piby2_2
5997	fmov.x		%fp2,%fp4		# fp4 = N
5998	fmul.x		FP_SCR0(%a6),%fp4	# fp4 = W = N*P1
5999	fmov.x		%fp2,%fp5		# fp5 = N
6000	fmul.x		FP_SCR1(%a6),%fp5	# fp5 = w = N*P2
6001	fmov.x		%fp4,%fp3		# fp3 = W = N*P1
6002
6003#--we want P+p = W+w  but  |p| <= half ulp of P
6004#--Then, we need to compute  A := R-P   and  a := r-p
6005	fadd.x		%fp5,%fp3		# fp3 = P
6006	fsub.x		%fp3,%fp4		# fp4 = W-P
6007
6008	fsub.x		%fp3,%fp0		# fp0 = A := R - P
6009	fadd.x		%fp5,%fp4		# fp4 = p = (W-P)+w
6010
6011	fmov.x		%fp0,%fp3		# fp3 = A
6012	fsub.x		%fp4,%fp1		# fp1 = a := r - p
6013
6014#--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
6015#--|r| <= half ulp of R.
6016	fadd.x		%fp1,%fp0		# fp0 = R := A+a
6017#--No need to calculate r if this is the last loop
6018	cmp.b		%d1,&0
6019	bgt.w		RESTORE
6020
6021#--Need to calculate r
6022	fsub.x		%fp0,%fp3		# fp3 = A-R
6023	fadd.x		%fp3,%fp1		# fp1 = r := (A-R)+a
6024	bra.w		LOOP
6025
6026RESTORE:
6027	fmov.l		%fp2,INT(%a6)
6028	mov.l		(%sp)+,%d2		# restore d2
6029	fmovm.x		(%sp)+,&0x3c		# restore {fp2-fp5}
6030
6031	mov.l		INT(%a6),%d1
6032	ror.l		&1,%d1
6033
6034	bra.w		TANCONT
6035
6036#########################################################################
6037# satan():  computes the arctangent of a normalized number		#
6038# satand(): computes the arctangent of a denormalized number		#
6039#									#
6040# INPUT	*************************************************************** #
6041#	a0 = pointer to extended precision input			#
6042#	d0 = round precision,mode					#
6043#									#
6044# OUTPUT ************************************************************** #
6045#	fp0 = arctan(X)							#
6046#									#
6047# ACCURACY and MONOTONICITY ******************************************* #
6048#	The returned result is within 2 ulps in	64 significant bit,	#
6049#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
6050#	rounded to double precision. The result is provably monotonic	#
6051#	in double precision.						#
6052#									#
6053# ALGORITHM *********************************************************** #
6054#	Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5.		#
6055#									#
6056#	Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x.			#
6057#		Note that k = -4, -3,..., or 3.				#
6058#		Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5	#
6059#		significant bits of X with a bit-1 attached at the 6-th	#
6060#		bit position. Define u to be u = (X-F) / (1 + X*F).	#
6061#									#
6062#	Step 3. Approximate arctan(u) by a polynomial poly.		#
6063#									#
6064#	Step 4. Return arctan(F) + poly, arctan(F) is fetched from a	#
6065#		table of values calculated beforehand. Exit.		#
6066#									#
6067#	Step 5. If |X| >= 16, go to Step 7.				#
6068#									#
6069#	Step 6. Approximate arctan(X) by an odd polynomial in X. Exit.	#
6070#									#
6071#	Step 7. Define X' = -1/X. Approximate arctan(X') by an odd	#
6072#		polynomial in X'.					#
6073#		Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit.		#
6074#									#
6075#########################################################################
6076
6077ATANA3:	long		0xBFF6687E,0x314987D8
6078ATANA2:	long		0x4002AC69,0x34A26DB3
6079ATANA1:	long		0xBFC2476F,0x4E1DA28E
6080
6081ATANB6:	long		0x3FB34444,0x7F876989
6082ATANB5:	long		0xBFB744EE,0x7FAF45DB
6083ATANB4:	long		0x3FBC71C6,0x46940220
6084ATANB3:	long		0xBFC24924,0x921872F9
6085ATANB2:	long		0x3FC99999,0x99998FA9
6086ATANB1:	long		0xBFD55555,0x55555555
6087
6088ATANC5:	long		0xBFB70BF3,0x98539E6A
6089ATANC4:	long		0x3FBC7187,0x962D1D7D
6090ATANC3:	long		0xBFC24924,0x827107B8
6091ATANC2:	long		0x3FC99999,0x9996263E
6092ATANC1:	long		0xBFD55555,0x55555536
6093
6094PPIBY2:	long		0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
6095NPIBY2:	long		0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000
6096
6097PTINY:	long		0x00010000,0x80000000,0x00000000,0x00000000
6098NTINY:	long		0x80010000,0x80000000,0x00000000,0x00000000
6099
6100ATANTBL:
6101	long		0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000
6102	long		0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000
6103	long		0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000
6104	long		0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000
6105	long		0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000
6106	long		0x3FFB0000,0xAB98E943,0x62765619,0x00000000
6107	long		0x3FFB0000,0xB389E502,0xF9C59862,0x00000000
6108	long		0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000
6109	long		0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000
6110	long		0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000
6111	long		0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000
6112	long		0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000
6113	long		0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000
6114	long		0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000
6115	long		0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000
6116	long		0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000
6117	long		0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000
6118	long		0x3FFC0000,0x8B232A08,0x304282D8,0x00000000
6119	long		0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000
6120	long		0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000
6121	long		0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000
6122	long		0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000
6123	long		0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000
6124	long		0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000
6125	long		0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000
6126	long		0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000
6127	long		0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000
6128	long		0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000
6129	long		0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000
6130	long		0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000
6131	long		0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000
6132	long		0x3FFC0000,0xF7170A28,0xECC06666,0x00000000
6133	long		0x3FFD0000,0x812FD288,0x332DAD32,0x00000000
6134	long		0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000
6135	long		0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000
6136	long		0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000
6137	long		0x3FFD0000,0x9EB68949,0x3889A227,0x00000000
6138	long		0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000
6139	long		0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000
6140	long		0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000
6141	long		0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000
6142	long		0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000
6143	long		0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000
6144	long		0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000
6145	long		0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000
6146	long		0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000
6147	long		0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000
6148	long		0x3FFD0000,0xEA2D764F,0x64315989,0x00000000
6149	long		0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000
6150	long		0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000
6151	long		0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000
6152	long		0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000
6153	long		0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000
6154	long		0x3FFE0000,0x97731420,0x365E538C,0x00000000
6155	long		0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000
6156	long		0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000
6157	long		0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000
6158	long		0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000
6159	long		0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000
6160	long		0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000
6161	long		0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000
6162	long		0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000
6163	long		0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000
6164	long		0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000
6165	long		0x3FFE0000,0xCD000549,0xADEC7159,0x00000000
6166	long		0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000
6167	long		0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000
6168	long		0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000
6169	long		0x3FFE0000,0xE8771129,0xC4353259,0x00000000
6170	long		0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000
6171	long		0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000
6172	long		0x3FFE0000,0xF919039D,0x758B8D41,0x00000000
6173	long		0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000
6174	long		0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000
6175	long		0x3FFF0000,0x83889E35,0x49D108E1,0x00000000
6176	long		0x3FFF0000,0x859CFA76,0x511D724B,0x00000000
6177	long		0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000
6178	long		0x3FFF0000,0x89732FD1,0x9557641B,0x00000000
6179	long		0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000
6180	long		0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000
6181	long		0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000
6182	long		0x3FFF0000,0x922DA7D7,0x91888487,0x00000000
6183	long		0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000
6184	long		0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000
6185	long		0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000
6186	long		0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000
6187	long		0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000
6188	long		0x3FFF0000,0x9F100575,0x006CC571,0x00000000
6189	long		0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000
6190	long		0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000
6191	long		0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000
6192	long		0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000
6193	long		0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000
6194	long		0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000
6195	long		0x3FFF0000,0xA83A5153,0x0956168F,0x00000000
6196	long		0x3FFF0000,0xA93A2007,0x7539546E,0x00000000
6197	long		0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000
6198	long		0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000
6199	long		0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000
6200	long		0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000
6201	long		0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000
6202	long		0x3FFF0000,0xB1846515,0x0F71496A,0x00000000
6203	long		0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000
6204	long		0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000
6205	long		0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000
6206	long		0x3FFF0000,0xB525529D,0x562246BD,0x00000000
6207	long		0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000
6208	long		0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000
6209	long		0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000
6210	long		0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000
6211	long		0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000
6212	long		0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000
6213	long		0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000
6214	long		0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000
6215	long		0x3FFF0000,0xBB471285,0x7637E17D,0x00000000
6216	long		0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000
6217	long		0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000
6218	long		0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000
6219	long		0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000
6220	long		0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000
6221	long		0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000
6222	long		0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000
6223	long		0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000
6224	long		0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000
6225	long		0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000
6226	long		0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000
6227	long		0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000
6228	long		0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000
6229
6230	set		X,FP_SCR0
6231	set		XDCARE,X+2
6232	set		XFRAC,X+4
6233	set		XFRACLO,X+8
6234
6235	set		ATANF,FP_SCR1
6236	set		ATANFHI,ATANF+4
6237	set		ATANFLO,ATANF+8
6238
6239	global		satan
6240#--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
6241satan:
6242	fmov.x		(%a0),%fp0		# LOAD INPUT
6243
6244	mov.l		(%a0),%d1
6245	mov.w		4(%a0),%d1
6246	fmov.x		%fp0,X(%a6)
6247	and.l		&0x7FFFFFFF,%d1
6248
6249	cmp.l		%d1,&0x3FFB8000		# |X| >= 1/16?
6250	bge.b		ATANOK1
6251	bra.w		ATANSM
6252
6253ATANOK1:
6254	cmp.l		%d1,&0x4002FFFF		# |X| < 16 ?
6255	ble.b		ATANMAIN
6256	bra.w		ATANBIG
6257
6258#--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE
6259#--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ).
6260#--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN
6261#--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE
6262#--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS
6263#--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR
6264#--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO
6265#--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE
6266#--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL
6267#--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE
6268#--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION
6269#--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION
6270#--WILL INVOLVE A VERY LONG POLYNOMIAL.
6271
6272#--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS
6273#--WE CHOSE F TO BE +-2^K * 1.BBBB1
6274#--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE
6275#--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE
6276#--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS
6277#-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).
6278
6279ATANMAIN:
6280
6281	and.l		&0xF8000000,XFRAC(%a6)	# FIRST 5 BITS
6282	or.l		&0x04000000,XFRAC(%a6)	# SET 6-TH BIT TO 1
6283	mov.l		&0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F
6284
6285	fmov.x		%fp0,%fp1		# FP1 IS X
6286	fmul.x		X(%a6),%fp1		# FP1 IS X*F, NOTE THAT X*F > 0
6287	fsub.x		X(%a6),%fp0		# FP0 IS X-F
6288	fadd.s		&0x3F800000,%fp1	# FP1 IS 1 + X*F
6289	fdiv.x		%fp1,%fp0		# FP0 IS U = (X-F)/(1+X*F)
6290
6291#--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)
6292#--CREATE ATAN(F) AND STORE IT IN ATANF, AND
6293#--SAVE REGISTERS FP2.
6294
6295	mov.l		%d2,-(%sp)		# SAVE d2 TEMPORARILY
6296	mov.l		%d1,%d2			# THE EXP AND 16 BITS OF X
6297	and.l		&0x00007800,%d1		# 4 VARYING BITS OF F'S FRACTION
6298	and.l		&0x7FFF0000,%d2		# EXPONENT OF F
6299	sub.l		&0x3FFB0000,%d2		# K+4
6300	asr.l		&1,%d2
6301	add.l		%d2,%d1			# THE 7 BITS IDENTIFYING F
6302	asr.l		&7,%d1			# INDEX INTO TBL OF ATAN(|F|)
6303	lea		ATANTBL(%pc),%a1
6304	add.l		%d1,%a1			# ADDRESS OF ATAN(|F|)
6305	mov.l		(%a1)+,ATANF(%a6)
6306	mov.l		(%a1)+,ATANFHI(%a6)
6307	mov.l		(%a1)+,ATANFLO(%a6)	# ATANF IS NOW ATAN(|F|)
6308	mov.l		X(%a6),%d1		# LOAD SIGN AND EXPO. AGAIN
6309	and.l		&0x80000000,%d1		# SIGN(F)
6310	or.l		%d1,ATANF(%a6)		# ATANF IS NOW SIGN(F)*ATAN(|F|)
6311	mov.l		(%sp)+,%d2		# RESTORE d2
6312
6313#--THAT'S ALL I HAVE TO DO FOR NOW,
6314#--BUT ALAS, THE DIVIDE IS STILL CRANKING!
6315
6316#--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
6317#--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U
6318#--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.
6319#--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3))
6320#--WHAT WE HAVE HERE IS MERELY	A1 = A3, A2 = A1/A3, A3 = A2/A3.
6321#--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT
6322#--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCED
6323
6324	fmovm.x		&0x04,-(%sp)		# save fp2
6325
6326	fmov.x		%fp0,%fp1
6327	fmul.x		%fp1,%fp1
6328	fmov.d		ATANA3(%pc),%fp2
6329	fadd.x		%fp1,%fp2		# A3+V
6330	fmul.x		%fp1,%fp2		# V*(A3+V)
6331	fmul.x		%fp0,%fp1		# U*V
6332	fadd.d		ATANA2(%pc),%fp2	# A2+V*(A3+V)
6333	fmul.d		ATANA1(%pc),%fp1	# A1*U*V
6334	fmul.x		%fp2,%fp1		# A1*U*V*(A2+V*(A3+V))
6335	fadd.x		%fp1,%fp0		# ATAN(U), FP1 RELEASED
6336
6337	fmovm.x		(%sp)+,&0x20		# restore fp2
6338
6339	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
6340	fadd.x		ATANF(%a6),%fp0		# ATAN(X)
6341	bra		t_inx2
6342
6343ATANBORS:
6344#--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
6345#--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
6346	cmp.l		%d1,&0x3FFF8000
6347	bgt.w		ATANBIG			# I.E. |X| >= 16
6348
6349ATANSM:
6350#--|X| <= 1/16
6351#--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
6352#--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))
6353#--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )
6354#--WHERE Y = X*X, AND Z = Y*Y.
6355
6356	cmp.l		%d1,&0x3FD78000
6357	blt.w		ATANTINY
6358
6359#--COMPUTE POLYNOMIAL
6360	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
6361
6362	fmul.x		%fp0,%fp0		# FPO IS Y = X*X
6363
6364	fmov.x		%fp0,%fp1
6365	fmul.x		%fp1,%fp1		# FP1 IS Z = Y*Y
6366
6367	fmov.d		ATANB6(%pc),%fp2
6368	fmov.d		ATANB5(%pc),%fp3
6369
6370	fmul.x		%fp1,%fp2		# Z*B6
6371	fmul.x		%fp1,%fp3		# Z*B5
6372
6373	fadd.d		ATANB4(%pc),%fp2	# B4+Z*B6
6374	fadd.d		ATANB3(%pc),%fp3	# B3+Z*B5
6375
6376	fmul.x		%fp1,%fp2		# Z*(B4+Z*B6)
6377	fmul.x		%fp3,%fp1		# Z*(B3+Z*B5)
6378
6379	fadd.d		ATANB2(%pc),%fp2	# B2+Z*(B4+Z*B6)
6380	fadd.d		ATANB1(%pc),%fp1	# B1+Z*(B3+Z*B5)
6381
6382	fmul.x		%fp0,%fp2		# Y*(B2+Z*(B4+Z*B6))
6383	fmul.x		X(%a6),%fp0		# X*Y
6384
6385	fadd.x		%fp2,%fp1		# [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]
6386
6387	fmul.x		%fp1,%fp0		# X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
6388
6389	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
6390
6391	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
6392	fadd.x		X(%a6),%fp0
6393	bra		t_inx2
6394
6395ATANTINY:
6396#--|X| < 2^(-40), ATAN(X) = X
6397
6398	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
6399	mov.b		&FMOV_OP,%d1		# last inst is MOVE
6400	fmov.x		X(%a6),%fp0		# last inst - possible exception set
6401
6402	bra		t_catch
6403
6404ATANBIG:
6405#--IF |X| > 2^(100), RETURN	SIGN(X)*(PI/2 - TINY). OTHERWISE,
6406#--RETURN SIGN(X)*PI/2 + ATAN(-1/X).
6407	cmp.l		%d1,&0x40638000
6408	bgt.w		ATANHUGE
6409
6410#--APPROXIMATE ATAN(-1/X) BY
6411#--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'
6412#--THIS CAN BE RE-WRITTEN AS
6413#--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.
6414
6415	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
6416
6417	fmov.s		&0xBF800000,%fp1	# LOAD -1
6418	fdiv.x		%fp0,%fp1		# FP1 IS -1/X
6419
6420#--DIVIDE IS STILL CRANKING
6421
6422	fmov.x		%fp1,%fp0		# FP0 IS X'
6423	fmul.x		%fp0,%fp0		# FP0 IS Y = X'*X'
6424	fmov.x		%fp1,X(%a6)		# X IS REALLY X'
6425
6426	fmov.x		%fp0,%fp1
6427	fmul.x		%fp1,%fp1		# FP1 IS Z = Y*Y
6428
6429	fmov.d		ATANC5(%pc),%fp3
6430	fmov.d		ATANC4(%pc),%fp2
6431
6432	fmul.x		%fp1,%fp3		# Z*C5
6433	fmul.x		%fp1,%fp2		# Z*B4
6434
6435	fadd.d		ATANC3(%pc),%fp3	# C3+Z*C5
6436	fadd.d		ATANC2(%pc),%fp2	# C2+Z*C4
6437
6438	fmul.x		%fp3,%fp1		# Z*(C3+Z*C5), FP3 RELEASED
6439	fmul.x		%fp0,%fp2		# Y*(C2+Z*C4)
6440
6441	fadd.d		ATANC1(%pc),%fp1	# C1+Z*(C3+Z*C5)
6442	fmul.x		X(%a6),%fp0		# X'*Y
6443
6444	fadd.x		%fp2,%fp1		# [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]
6445
6446	fmul.x		%fp1,%fp0		# X'*Y*([B1+Z*(B3+Z*B5)]
6447#					...	+[Y*(B2+Z*(B4+Z*B6))])
6448	fadd.x		X(%a6),%fp0
6449
6450	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
6451
6452	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
6453	tst.b		(%a0)
6454	bpl.b		pos_big
6455
6456neg_big:
6457	fadd.x		NPIBY2(%pc),%fp0
6458	bra		t_minx2
6459
6460pos_big:
6461	fadd.x		PPIBY2(%pc),%fp0
6462	bra		t_pinx2
6463
6464ATANHUGE:
6465#--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINY
6466	tst.b		(%a0)
6467	bpl.b		pos_huge
6468
6469neg_huge:
6470	fmov.x		NPIBY2(%pc),%fp0
6471	fmov.l		%d0,%fpcr
6472	fadd.x		PTINY(%pc),%fp0
6473	bra		t_minx2
6474
6475pos_huge:
6476	fmov.x		PPIBY2(%pc),%fp0
6477	fmov.l		%d0,%fpcr
6478	fadd.x		NTINY(%pc),%fp0
6479	bra		t_pinx2
6480
6481	global		satand
6482#--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENT
6483satand:
6484	bra		t_extdnrm
6485
6486#########################################################################
6487# sasin():  computes the inverse sine of a normalized input		#
6488# sasind(): computes the inverse sine of a denormalized input		#
6489#									#
6490# INPUT ***************************************************************	#
6491#	a0 = pointer to extended precision input			#
6492#	d0 = round precision,mode					#
6493#									#
6494# OUTPUT **************************************************************	#
6495#	fp0 = arcsin(X)							#
6496#									#
6497# ACCURACY and MONOTONICITY *******************************************	#
6498#	The returned result is within 3 ulps in	64 significant bit,	#
6499#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
6500#	rounded to double precision. The result is provably monotonic	#
6501#	in double precision.						#
6502#									#
6503# ALGORITHM ***********************************************************	#
6504#									#
6505#	ASIN								#
6506#	1. If |X| >= 1, go to 3.					#
6507#									#
6508#	2. (|X| < 1) Calculate asin(X) by				#
6509#		z := sqrt( [1-X][1+X] )					#
6510#		asin(X) = atan( x / z ).				#
6511#		Exit.							#
6512#									#
6513#	3. If |X| > 1, go to 5.						#
6514#									#
6515#	4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.#
6516#									#
6517#	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
6518#		Exit.							#
6519#									#
6520#########################################################################
6521
6522	global		sasin
6523sasin:
6524	fmov.x		(%a0),%fp0		# LOAD INPUT
6525
6526	mov.l		(%a0),%d1
6527	mov.w		4(%a0),%d1
6528	and.l		&0x7FFFFFFF,%d1
6529	cmp.l		%d1,&0x3FFF8000
6530	bge.b		ASINBIG
6531
6532# This catch is added here for the '060 QSP. Originally, the call to
6533# satan() would handle this case by causing the exception which would
6534# not be caught until gen_except(). Now, with the exceptions being
6535# detected inside of satan(), the exception would have been handled there
6536# instead of inside sasin() as expected.
6537	cmp.l		%d1,&0x3FD78000
6538	blt.w		ASINTINY
6539
6540#--THIS IS THE USUAL CASE, |X| < 1
6541#--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )
6542
6543ASINMAIN:
6544	fmov.s		&0x3F800000,%fp1
6545	fsub.x		%fp0,%fp1		# 1-X
6546	fmovm.x		&0x4,-(%sp)		#  {fp2}
6547	fmov.s		&0x3F800000,%fp2
6548	fadd.x		%fp0,%fp2		# 1+X
6549	fmul.x		%fp2,%fp1		# (1+X)(1-X)
6550	fmovm.x		(%sp)+,&0x20		#  {fp2}
6551	fsqrt.x		%fp1			# SQRT([1-X][1+X])
6552	fdiv.x		%fp1,%fp0		# X/SQRT([1-X][1+X])
6553	fmovm.x		&0x01,-(%sp)		# save X/SQRT(...)
6554	lea		(%sp),%a0		# pass ptr to X/SQRT(...)
6555	bsr		satan
6556	add.l		&0xc,%sp		# clear X/SQRT(...) from stack
6557	bra		t_inx2
6558
6559ASINBIG:
6560	fabs.x		%fp0			# |X|
6561	fcmp.s		%fp0,&0x3F800000
6562	fbgt		t_operr			# cause an operr exception
6563
6564#--|X| = 1, ASIN(X) = +- PI/2.
6565ASINONE:
6566	fmov.x		PIBY2(%pc),%fp0
6567	mov.l		(%a0),%d1
6568	and.l		&0x80000000,%d1		# SIGN BIT OF X
6569	or.l		&0x3F800000,%d1		# +-1 IN SGL FORMAT
6570	mov.l		%d1,-(%sp)		# push SIGN(X) IN SGL-FMT
6571	fmov.l		%d0,%fpcr
6572	fmul.s		(%sp)+,%fp0
6573	bra		t_inx2
6574
6575#--|X| < 2^(-40), ATAN(X) = X
6576ASINTINY:
6577	fmov.l		%d0,%fpcr		# restore users rnd mode,prec
6578	mov.b		&FMOV_OP,%d1		# last inst is MOVE
6579	fmov.x		(%a0),%fp0		# last inst - possible exception
6580	bra		t_catch
6581
6582	global		sasind
6583#--ASIN(X) = X FOR DENORMALIZED X
6584sasind:
6585	bra		t_extdnrm
6586
6587#########################################################################
6588# sacos():  computes the inverse cosine of a normalized input		#
6589# sacosd(): computes the inverse cosine of a denormalized input		#
6590#									#
6591# INPUT ***************************************************************	#
6592#	a0 = pointer to extended precision input			#
6593#	d0 = round precision,mode					#
6594#									#
6595# OUTPUT ************************************************************** #
6596#	fp0 = arccos(X)							#
6597#									#
6598# ACCURACY and MONOTONICITY *******************************************	#
6599#	The returned result is within 3 ulps in	64 significant bit,	#
6600#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
6601#	rounded to double precision. The result is provably monotonic	#
6602#	in double precision.						#
6603#									#
6604# ALGORITHM *********************************************************** #
6605#									#
6606#	ACOS								#
6607#	1. If |X| >= 1, go to 3.					#
6608#									#
6609#	2. (|X| < 1) Calculate acos(X) by				#
6610#		z := (1-X) / (1+X)					#
6611#		acos(X) = 2 * atan( sqrt(z) ).				#
6612#		Exit.							#
6613#									#
6614#	3. If |X| > 1, go to 5.						#
6615#									#
6616#	4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit.	#
6617#									#
6618#	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
6619#		Exit.							#
6620#									#
6621#########################################################################
6622
6623	global		sacos
6624sacos:
6625	fmov.x		(%a0),%fp0		# LOAD INPUT
6626
6627	mov.l		(%a0),%d1		# pack exp w/ upper 16 fraction
6628	mov.w		4(%a0),%d1
6629	and.l		&0x7FFFFFFF,%d1
6630	cmp.l		%d1,&0x3FFF8000
6631	bge.b		ACOSBIG
6632
6633#--THIS IS THE USUAL CASE, |X| < 1
6634#--ACOS(X) = 2 * ATAN(	SQRT( (1-X)/(1+X) ) )
6635
6636ACOSMAIN:
6637	fmov.s		&0x3F800000,%fp1
6638	fadd.x		%fp0,%fp1		# 1+X
6639	fneg.x		%fp0			# -X
6640	fadd.s		&0x3F800000,%fp0	# 1-X
6641	fdiv.x		%fp1,%fp0		# (1-X)/(1+X)
6642	fsqrt.x		%fp0			# SQRT((1-X)/(1+X))
6643	mov.l		%d0,-(%sp)		# save original users fpcr
6644	clr.l		%d0
6645	fmovm.x		&0x01,-(%sp)		# save SQRT(...) to stack
6646	lea		(%sp),%a0		# pass ptr to sqrt
6647	bsr		satan			# ATAN(SQRT([1-X]/[1+X]))
6648	add.l		&0xc,%sp		# clear SQRT(...) from stack
6649
6650	fmov.l		(%sp)+,%fpcr		# restore users round prec,mode
6651	fadd.x		%fp0,%fp0		# 2 * ATAN( STUFF )
6652	bra		t_pinx2
6653
6654ACOSBIG:
6655	fabs.x		%fp0
6656	fcmp.s		%fp0,&0x3F800000
6657	fbgt		t_operr			# cause an operr exception
6658
6659#--|X| = 1, ACOS(X) = 0 OR PI
6660	tst.b		(%a0)			# is X positive or negative?
6661	bpl.b		ACOSP1
6662
6663#--X = -1
6664#Returns PI and inexact exception
6665ACOSM1:
6666	fmov.x		PI(%pc),%fp0		# load PI
6667	fmov.l		%d0,%fpcr		# load round mode,prec
6668	fadd.s		&0x00800000,%fp0	# add a small value
6669	bra		t_pinx2
6670
6671ACOSP1:
6672	bra		ld_pzero		# answer is positive zero
6673
6674	global		sacosd
6675#--ACOS(X) = PI/2 FOR DENORMALIZED X
6676sacosd:
6677	fmov.l		%d0,%fpcr		# load user's rnd mode/prec
6678	fmov.x		PIBY2(%pc),%fp0
6679	bra		t_pinx2
6680
6681#########################################################################
6682# setox():    computes the exponential for a normalized input		#
6683# setoxd():   computes the exponential for a denormalized input		#
6684# setoxm1():  computes the exponential minus 1 for a normalized input	#
6685# setoxm1d(): computes the exponential minus 1 for a denormalized input	#
6686#									#
6687# INPUT	*************************************************************** #
6688#	a0 = pointer to extended precision input			#
6689#	d0 = round precision,mode					#
6690#									#
6691# OUTPUT ************************************************************** #
6692#	fp0 = exp(X) or exp(X)-1					#
6693#									#
6694# ACCURACY and MONOTONICITY ******************************************* #
6695#	The returned result is within 0.85 ulps in 64 significant bit,	#
6696#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6697#	rounded to double precision. The result is provably monotonic	#
6698#	in double precision.						#
6699#									#
6700# ALGORITHM and IMPLEMENTATION **************************************** #
6701#									#
6702#	setoxd								#
6703#	------								#
6704#	Step 1.	Set ans := 1.0						#
6705#									#
6706#	Step 2.	Return	ans := ans + sign(X)*2^(-126). Exit.		#
6707#	Notes:	This will always generate one exception -- inexact.	#
6708#									#
6709#									#
6710#	setox								#
6711#	-----								#
6712#									#
6713#	Step 1.	Filter out extreme cases of input argument.		#
6714#		1.1	If |X| >= 2^(-65), go to Step 1.3.		#
6715#		1.2	Go to Step 7.					#
6716#		1.3	If |X| < 16380 log(2), go to Step 2.		#
6717#		1.4	Go to Step 8.					#
6718#	Notes:	The usual case should take the branches 1.1 -> 1.3 -> 2.#
6719#		To avoid the use of floating-point comparisons, a	#
6720#		compact representation of |X| is used. This format is a	#
6721#		32-bit integer, the upper (more significant) 16 bits	#
6722#		are the sign and biased exponent field of |X|; the	#
6723#		lower 16 bits are the 16 most significant fraction	#
6724#		(including the explicit bit) bits of |X|. Consequently,	#
6725#		the comparisons in Steps 1.1 and 1.3 can be performed	#
6726#		by integer comparison. Note also that the constant	#
6727#		16380 log(2) used in Step 1.3 is also in the compact	#
6728#		form. Thus taking the branch to Step 2 guarantees	#
6729#		|X| < 16380 log(2). There is no harm to have a small	#
6730#		number of cases where |X| is less than,	but close to,	#
6731#		16380 log(2) and the branch to Step 9 is taken.		#
6732#									#
6733#	Step 2.	Calculate N = round-to-nearest-int( X * 64/log2 ).	#
6734#		2.1	Set AdjFlag := 0 (indicates the branch 1.3 -> 2 #
6735#			was taken)					#
6736#		2.2	N := round-to-nearest-integer( X * 64/log2 ).	#
6737#		2.3	Calculate	J = N mod 64; so J = 0,1,2,..., #
6738#			or 63.						#
6739#		2.4	Calculate	M = (N - J)/64; so N = 64M + J.	#
6740#		2.5	Calculate the address of the stored value of	#
6741#			2^(J/64).					#
6742#		2.6	Create the value Scale = 2^M.			#
6743#	Notes:	The calculation in 2.2 is really performed by		#
6744#			Z := X * constant				#
6745#			N := round-to-nearest-integer(Z)		#
6746#		where							#
6747#			constant := single-precision( 64/log 2 ).	#
6748#									#
6749#		Using a single-precision constant avoids memory		#
6750#		access. Another effect of using a single-precision	#
6751#		"constant" is that the calculated value Z is		#
6752#									#
6753#			Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24).	#
6754#									#
6755#		This error has to be considered later in Steps 3 and 4.	#
6756#									#
6757#	Step 3.	Calculate X - N*log2/64.				#
6758#		3.1	R := X + N*L1,					#
6759#				where L1 := single-precision(-log2/64).	#
6760#		3.2	R := R + N*L2,					#
6761#				L2 := extended-precision(-log2/64 - L1).#
6762#	Notes:	a) The way L1 and L2 are chosen ensures L1+L2		#
6763#		approximate the value -log2/64 to 88 bits of accuracy.	#
6764#		b) N*L1 is exact because N is no longer than 22 bits	#
6765#		and L1 is no longer than 24 bits.			#
6766#		c) The calculation X+N*L1 is also exact due to		#
6767#		cancellation. Thus, R is practically X+N(L1+L2) to full	#
6768#		64 bits.						#
6769#		d) It is important to estimate how large can |R| be	#
6770#		after Step 3.2.						#
6771#									#
6772#		N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24)	#
6773#		X*64/log2 (1+eps)	=	N + f,	|f| <= 0.5	#
6774#		X*64/log2 - N	=	f - eps*X 64/log2		#
6775#		X - N*log2/64	=	f*log2/64 - eps*X		#
6776#									#
6777#									#
6778#		Now |X| <= 16446 log2, thus				#
6779#									#
6780#			|X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64	#
6781#					<= 0.57 log2/64.		#
6782#		 This bound will be used in Step 4.			#
6783#									#
6784#	Step 4.	Approximate exp(R)-1 by a polynomial			#
6785#		p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))	#
6786#	Notes:	a) In order to reduce memory access, the coefficients	#
6787#		are made as "short" as possible: A1 (which is 1/2), A4	#
6788#		and A5 are single precision; A2 and A3 are double	#
6789#		precision.						#
6790#		b) Even with the restrictions above,			#
6791#		   |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062.	#
6792#		Note that 0.0062 is slightly bigger than 0.57 log2/64.	#
6793#		c) To fully utilize the pipeline, p is separated into	#
6794#		two independent pieces of roughly equal complexities	#
6795#			p = [ R + R*S*(A2 + S*A4) ]	+		#
6796#				[ S*(A1 + S*(A3 + S*A5)) ]		#
6797#		where S = R*R.						#
6798#									#
6799#	Step 5.	Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by		#
6800#				ans := T + ( T*p + t)			#
6801#		where T and t are the stored values for 2^(J/64).	#
6802#	Notes:	2^(J/64) is stored as T and t where T+t approximates	#
6803#		2^(J/64) to roughly 85 bits; T is in extended precision	#
6804#		and t is in single precision. Note also that T is	#
6805#		rounded to 62 bits so that the last two bits of T are	#
6806#		zero. The reason for such a special form is that T-1,	#
6807#		T-2, and T-8 will all be exact --- a property that will	#
6808#		give much more accurate computation of the function	#
6809#		EXPM1.							#
6810#									#
6811#	Step 6.	Reconstruction of exp(X)				#
6812#			exp(X) = 2^M * 2^(J/64) * exp(R).		#
6813#		6.1	If AdjFlag = 0, go to 6.3			#
6814#		6.2	ans := ans * AdjScale				#
6815#		6.3	Restore the user FPCR				#
6816#		6.4	Return ans := ans * Scale. Exit.		#
6817#	Notes:	If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R,	#
6818#		|M| <= 16380, and Scale = 2^M. Moreover, exp(X) will	#
6819#		neither overflow nor underflow. If AdjFlag = 1, that	#
6820#		means that						#
6821#			X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380.	#
6822#		Hence, exp(X) may overflow or underflow or neither.	#
6823#		When that is the case, AdjScale = 2^(M1) where M1 is	#
6824#		approximately M. Thus 6.2 will never cause		#
6825#		over/underflow. Possible exception in 6.4 is overflow	#
6826#		or underflow. The inexact exception is not generated in	#
6827#		6.4. Although one can argue that the inexact flag	#
6828#		should always be raised, to simulate that exception	#
6829#		cost to much than the flag is worth in practical uses.	#
6830#									#
6831#	Step 7.	Return 1 + X.						#
6832#		7.1	ans := X					#
6833#		7.2	Restore user FPCR.				#
6834#		7.3	Return ans := 1 + ans. Exit			#
6835#	Notes:	For non-zero X, the inexact exception will always be	#
6836#		raised by 7.3. That is the only exception raised by 7.3.#
6837#		Note also that we use the FMOVEM instruction to move X	#
6838#		in Step 7.1 to avoid unnecessary trapping. (Although	#
6839#		the FMOVEM may not seem relevant since X is normalized,	#
6840#		the precaution will be useful in the library version of	#
6841#		this code where the separate entry for denormalized	#
6842#		inputs will be done away with.)				#
6843#									#
6844#	Step 8.	Handle exp(X) where |X| >= 16380log2.			#
6845#		8.1	If |X| > 16480 log2, go to Step 9.		#
6846#		(mimic 2.2 - 2.6)					#
6847#		8.2	N := round-to-integer( X * 64/log2 )		#
6848#		8.3	Calculate J = N mod 64, J = 0,1,...,63		#
6849#		8.4	K := (N-J)/64, M1 := truncate(K/2), M = K-M1,	#
6850#			AdjFlag := 1.					#
6851#		8.5	Calculate the address of the stored value	#
6852#			2^(J/64).					#
6853#		8.6	Create the values Scale = 2^M, AdjScale = 2^M1.	#
6854#		8.7	Go to Step 3.					#
6855#	Notes:	Refer to notes for 2.2 - 2.6.				#
6856#									#
6857#	Step 9.	Handle exp(X), |X| > 16480 log2.			#
6858#		9.1	If X < 0, go to 9.3				#
6859#		9.2	ans := Huge, go to 9.4				#
6860#		9.3	ans := Tiny.					#
6861#		9.4	Restore user FPCR.				#
6862#		9.5	Return ans := ans * ans. Exit.			#
6863#	Notes:	Exp(X) will surely overflow or underflow, depending on	#
6864#		X's sign. "Huge" and "Tiny" are respectively large/tiny	#
6865#		extended-precision numbers whose square over/underflow	#
6866#		with an inexact result. Thus, 9.5 always raises the	#
6867#		inexact together with either overflow or underflow.	#
6868#									#
6869#	setoxm1d							#
6870#	--------							#
6871#									#
6872#	Step 1.	Set ans := 0						#
6873#									#
6874#	Step 2.	Return	ans := X + ans. Exit.				#
6875#	Notes:	This will return X with the appropriate rounding	#
6876#		 precision prescribed by the user FPCR.			#
6877#									#
6878#	setoxm1								#
6879#	-------								#
6880#									#
6881#	Step 1.	Check |X|						#
6882#		1.1	If |X| >= 1/4, go to Step 1.3.			#
6883#		1.2	Go to Step 7.					#
6884#		1.3	If |X| < 70 log(2), go to Step 2.		#
6885#		1.4	Go to Step 10.					#
6886#	Notes:	The usual case should take the branches 1.1 -> 1.3 -> 2.#
6887#		However, it is conceivable |X| can be small very often	#
6888#		because EXPM1 is intended to evaluate exp(X)-1		#
6889#		accurately when |X| is small. For further details on	#
6890#		the comparisons, see the notes on Step 1 of setox.	#
6891#									#
6892#	Step 2.	Calculate N = round-to-nearest-int( X * 64/log2 ).	#
6893#		2.1	N := round-to-nearest-integer( X * 64/log2 ).	#
6894#		2.2	Calculate	J = N mod 64; so J = 0,1,2,..., #
6895#			or 63.						#
6896#		2.3	Calculate	M = (N - J)/64; so N = 64M + J.	#
6897#		2.4	Calculate the address of the stored value of	#
6898#			2^(J/64).					#
6899#		2.5	Create the values Sc = 2^M and			#
6900#			OnebySc := -2^(-M).				#
6901#	Notes:	See the notes on Step 2 of setox.			#
6902#									#
6903#	Step 3.	Calculate X - N*log2/64.				#
6904#		3.1	R := X + N*L1,					#
6905#				where L1 := single-precision(-log2/64).	#
6906#		3.2	R := R + N*L2,					#
6907#				L2 := extended-precision(-log2/64 - L1).#
6908#	Notes:	Applying the analysis of Step 3 of setox in this case	#
6909#		shows that |R| <= 0.0055 (note that |X| <= 70 log2 in	#
6910#		this case).						#
6911#									#
6912#	Step 4.	Approximate exp(R)-1 by a polynomial			#
6913#			p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6)))))	#
6914#	Notes:	a) In order to reduce memory access, the coefficients	#
6915#		are made as "short" as possible: A1 (which is 1/2), A5	#
6916#		and A6 are single precision; A2, A3 and A4 are double	#
6917#		precision.						#
6918#		b) Even with the restriction above,			#
6919#			|p - (exp(R)-1)| <	|R| * 2^(-72.7)		#
6920#		for all |R| <= 0.0055.					#
6921#		c) To fully utilize the pipeline, p is separated into	#
6922#		two independent pieces of roughly equal complexity	#
6923#			p = [ R*S*(A2 + S*(A4 + S*A6)) ]	+	#
6924#				[ R + S*(A1 + S*(A3 + S*A5)) ]		#
6925#		where S = R*R.						#
6926#									#
6927#	Step 5.	Compute 2^(J/64)*p by					#
6928#				p := T*p				#
6929#		where T and t are the stored values for 2^(J/64).	#
6930#	Notes:	2^(J/64) is stored as T and t where T+t approximates	#
6931#		2^(J/64) to roughly 85 bits; T is in extended precision	#
6932#		and t is in single precision. Note also that T is	#
6933#		rounded to 62 bits so that the last two bits of T are	#
6934#		zero. The reason for such a special form is that T-1,	#
6935#		T-2, and T-8 will all be exact --- a property that will	#
6936#		be exploited in Step 6 below. The total relative error	#
6937#		in p is no bigger than 2^(-67.7) compared to the final	#
6938#		result.							#
6939#									#
6940#	Step 6.	Reconstruction of exp(X)-1				#
6941#			exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ).	#
6942#		6.1	If M <= 63, go to Step 6.3.			#
6943#		6.2	ans := T + (p + (t + OnebySc)). Go to 6.6	#
6944#		6.3	If M >= -3, go to 6.5.				#
6945#		6.4	ans := (T + (p + t)) + OnebySc. Go to 6.6	#
6946#		6.5	ans := (T + OnebySc) + (p + t).			#
6947#		6.6	Restore user FPCR.				#
6948#		6.7	Return ans := Sc * ans. Exit.			#
6949#	Notes:	The various arrangements of the expressions give	#
6950#		accurate evaluations.					#
6951#									#
6952#	Step 7.	exp(X)-1 for |X| < 1/4.					#
6953#		7.1	If |X| >= 2^(-65), go to Step 9.		#
6954#		7.2	Go to Step 8.					#
6955#									#
6956#	Step 8.	Calculate exp(X)-1, |X| < 2^(-65).			#
6957#		8.1	If |X| < 2^(-16312), goto 8.3			#
6958#		8.2	Restore FPCR; return ans := X - 2^(-16382).	#
6959#			Exit.						#
6960#		8.3	X := X * 2^(140).				#
6961#		8.4	Restore FPCR; ans := ans - 2^(-16382).		#
6962#		 Return ans := ans*2^(140). Exit			#
6963#	Notes:	The idea is to return "X - tiny" under the user		#
6964#		precision and rounding modes. To avoid unnecessary	#
6965#		inefficiency, we stay away from denormalized numbers	#
6966#		the best we can. For |X| >= 2^(-16312), the		#
6967#		straightforward 8.2 generates the inexact exception as	#
6968#		the case warrants.					#
6969#									#
6970#	Step 9.	Calculate exp(X)-1, |X| < 1/4, by a polynomial		#
6971#			p = X + X*X*(B1 + X*(B2 + ... + X*B12))		#
6972#	Notes:	a) In order to reduce memory access, the coefficients	#
6973#		are made as "short" as possible: B1 (which is 1/2), B9	#
6974#		to B12 are single precision; B3 to B8 are double	#
6975#		precision; and B2 is double extended.			#
6976#		b) Even with the restriction above,			#
6977#			|p - (exp(X)-1)| < |X| 2^(-70.6)		#
6978#		for all |X| <= 0.251.					#
6979#		Note that 0.251 is slightly bigger than 1/4.		#
6980#		c) To fully preserve accuracy, the polynomial is	#
6981#		computed as						#
6982#			X + ( S*B1 +	Q ) where S = X*X and		#
6983#			Q	=	X*S*(B2 + X*(B3 + ... + X*B12))	#
6984#		d) To fully utilize the pipeline, Q is separated into	#
6985#		two independent pieces of roughly equal complexity	#
6986#			Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] +	#
6987#				[ S*S*(B3 + S*(B5 + ... + S*B11)) ]	#
6988#									#
6989#	Step 10. Calculate exp(X)-1 for |X| >= 70 log 2.		#
6990#		10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all	#
6991#		practical purposes. Therefore, go to Step 1 of setox.	#
6992#		10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical	#
6993#		purposes.						#
6994#		ans := -1						#
6995#		Restore user FPCR					#
6996#		Return ans := ans + 2^(-126). Exit.			#
6997#	Notes:	10.2 will always create an inexact and return -1 + tiny	#
6998#		in the user rounding precision and mode.		#
6999#									#
7000#########################################################################
7001
7002L2:	long		0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000
7003
7004EEXPA3:	long		0x3FA55555,0x55554CC1
7005EEXPA2:	long		0x3FC55555,0x55554A54
7006
7007EM1A4:	long		0x3F811111,0x11174385
7008EM1A3:	long		0x3FA55555,0x55554F5A
7009
7010EM1A2:	long		0x3FC55555,0x55555555,0x00000000,0x00000000
7011
7012EM1B8:	long		0x3EC71DE3,0xA5774682
7013EM1B7:	long		0x3EFA01A0,0x19D7CB68
7014
7015EM1B6:	long		0x3F2A01A0,0x1A019DF3
7016EM1B5:	long		0x3F56C16C,0x16C170E2
7017
7018EM1B4:	long		0x3F811111,0x11111111
7019EM1B3:	long		0x3FA55555,0x55555555
7020
7021EM1B2:	long		0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB
7022	long		0x00000000
7023
7024TWO140:	long		0x48B00000,0x00000000
7025TWON140:
7026	long		0x37300000,0x00000000
7027
7028EEXPTBL:
7029	long		0x3FFF0000,0x80000000,0x00000000,0x00000000
7030	long		0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9B
7031	long		0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9
7032	long		0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369
7033	long		0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95C
7034	long		0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9F
7035	long		0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729
7036	long		0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AF
7037	long		0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCF
7038	long		0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DA
7039	long		0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051
7040	long		0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029
7041	long		0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494
7042	long		0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0
7043	long		0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457D
7044	long		0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537
7045	long		0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DD
7046	long		0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087
7047	long		0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818
7048	long		0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494D
7049	long		0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890
7050	long		0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691C
7051	long		0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05
7052	long		0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126
7053	long		0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140
7054	long		0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DA
7055	long		0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4A
7056	long		0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDC
7057	long		0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAC
7058	long		0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610
7059	long		0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90
7060	long		0x3FFF0000,0xB311C412,0xA9112488,0x201F678A
7061	long		0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13
7062	long		0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30
7063	long		0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CC
7064	long		0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6
7065	long		0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70
7066	long		0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518
7067	long		0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41
7068	long		0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137B
7069	long		0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568
7070	long		0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2E
7071	long		0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03
7072	long		0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907D
7073	long		0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4
7074	long		0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45C
7075	long		0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9
7076	long		0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21
7077	long		0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2F
7078	long		0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439F
7079	long		0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207
7080	long		0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175
7081	long		0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4B
7082	long		0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5
7083	long		0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47A
7084	long		0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22
7085	long		0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945
7086	long		0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5B
7087	long		0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3
7088	long		0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05
7089	long		0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19
7090	long		0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5
7091	long		0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22
7092	long		0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3A
7093
7094	set		ADJFLAG,L_SCR2
7095	set		SCALE,FP_SCR0
7096	set		ADJSCALE,FP_SCR1
7097	set		SC,FP_SCR0
7098	set		ONEBYSC,FP_SCR1
7099
7100	global		setox
7101setox:
7102#--entry point for EXP(X), here X is finite, non-zero, and not NaN's
7103
7104#--Step 1.
7105	mov.l		(%a0),%d1		# load part of input X
7106	and.l		&0x7FFF0000,%d1		# biased expo. of X
7107	cmp.l		%d1,&0x3FBE0000		# 2^(-65)
7108	bge.b		EXPC1			# normal case
7109	bra		EXPSM
7110
7111EXPC1:
7112#--The case |X| >= 2^(-65)
7113	mov.w		4(%a0),%d1		# expo. and partial sig. of |X|
7114	cmp.l		%d1,&0x400CB167		# 16380 log2 trunc. 16 bits
7115	blt.b		EXPMAIN			# normal case
7116	bra		EEXPBIG
7117
7118EXPMAIN:
7119#--Step 2.
7120#--This is the normal branch:	2^(-65) <= |X| < 16380 log2.
7121	fmov.x		(%a0),%fp0		# load input from (a0)
7122
7123	fmov.x		%fp0,%fp1
7124	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
7125	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
7126	mov.l		&0,ADJFLAG(%a6)
7127	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
7128	lea		EEXPTBL(%pc),%a1
7129	fmov.l		%d1,%fp0		# convert to floating-format
7130
7131	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
7132	and.l		&0x3F,%d1		# D0 is J = N mod 64
7133	lsl.l		&4,%d1
7134	add.l		%d1,%a1			# address of 2^(J/64)
7135	mov.l		L_SCR1(%a6),%d1
7136	asr.l		&6,%d1			# D0 is M
7137	add.w		&0x3FFF,%d1		# biased expo. of 2^(M)
7138	mov.w		L2(%pc),L_SCR1(%a6)	# prefetch L2, no need in CB
7139
7140EXPCONT1:
7141#--Step 3.
7142#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7143#--a0 points to 2^(J/64), D0 is biased expo. of 2^(M)
7144	fmov.x		%fp0,%fp2
7145	fmul.s		&0xBC317218,%fp0	# N * L1, L1 = lead(-log2/64)
7146	fmul.x		L2(%pc),%fp2		# N * L2, L1+L2 = -log2/64
7147	fadd.x		%fp1,%fp0		# X + N*L1
7148	fadd.x		%fp2,%fp0		# fp0 is R, reduced arg.
7149
7150#--Step 4.
7151#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7152#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))
7153#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
7154#--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))]
7155
7156	fmov.x		%fp0,%fp1
7157	fmul.x		%fp1,%fp1		# fp1 IS S = R*R
7158
7159	fmov.s		&0x3AB60B70,%fp2	# fp2 IS A5
7160
7161	fmul.x		%fp1,%fp2		# fp2 IS S*A5
7162	fmov.x		%fp1,%fp3
7163	fmul.s		&0x3C088895,%fp3	# fp3 IS S*A4
7164
7165	fadd.d		EEXPA3(%pc),%fp2	# fp2 IS A3+S*A5
7166	fadd.d		EEXPA2(%pc),%fp3	# fp3 IS A2+S*A4
7167
7168	fmul.x		%fp1,%fp2		# fp2 IS S*(A3+S*A5)
7169	mov.w		%d1,SCALE(%a6)		# SCALE is 2^(M) in extended
7170	mov.l		&0x80000000,SCALE+4(%a6)
7171	clr.l		SCALE+8(%a6)
7172
7173	fmul.x		%fp1,%fp3		# fp3 IS S*(A2+S*A4)
7174
7175	fadd.s		&0x3F000000,%fp2	# fp2 IS A1+S*(A3+S*A5)
7176	fmul.x		%fp0,%fp3		# fp3 IS R*S*(A2+S*A4)
7177
7178	fmul.x		%fp1,%fp2		# fp2 IS S*(A1+S*(A3+S*A5))
7179	fadd.x		%fp3,%fp0		# fp0 IS R+R*S*(A2+S*A4),
7180
7181	fmov.x		(%a1)+,%fp1		# fp1 is lead. pt. of 2^(J/64)
7182	fadd.x		%fp2,%fp0		# fp0 is EXP(R) - 1
7183
7184#--Step 5
7185#--final reconstruction process
7186#--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) )
7187
7188	fmul.x		%fp1,%fp0		# 2^(J/64)*(Exp(R)-1)
7189	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
7190	fadd.s		(%a1),%fp0		# accurate 2^(J/64)
7191
7192	fadd.x		%fp1,%fp0		# 2^(J/64) + 2^(J/64)*...
7193	mov.l		ADJFLAG(%a6),%d1
7194
7195#--Step 6
7196	tst.l		%d1
7197	beq.b		NORMAL
7198ADJUST:
7199	fmul.x		ADJSCALE(%a6),%fp0
7200NORMAL:
7201	fmov.l		%d0,%fpcr		# restore user FPCR
7202	mov.b		&FMUL_OP,%d1		# last inst is MUL
7203	fmul.x		SCALE(%a6),%fp0		# multiply 2^(M)
7204	bra		t_catch
7205
7206EXPSM:
7207#--Step 7
7208	fmovm.x		(%a0),&0x80		# load X
7209	fmov.l		%d0,%fpcr
7210	fadd.s		&0x3F800000,%fp0	# 1+X in user mode
7211	bra		t_pinx2
7212
7213EEXPBIG:
7214#--Step 8
7215	cmp.l		%d1,&0x400CB27C		# 16480 log2
7216	bgt.b		EXP2BIG
7217#--Steps 8.2 -- 8.6
7218	fmov.x		(%a0),%fp0		# load input from (a0)
7219
7220	fmov.x		%fp0,%fp1
7221	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
7222	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
7223	mov.l		&1,ADJFLAG(%a6)
7224	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
7225	lea		EEXPTBL(%pc),%a1
7226	fmov.l		%d1,%fp0		# convert to floating-format
7227	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
7228	and.l		&0x3F,%d1		# D0 is J = N mod 64
7229	lsl.l		&4,%d1
7230	add.l		%d1,%a1			# address of 2^(J/64)
7231	mov.l		L_SCR1(%a6),%d1
7232	asr.l		&6,%d1			# D0 is K
7233	mov.l		%d1,L_SCR1(%a6)		# save K temporarily
7234	asr.l		&1,%d1			# D0 is M1
7235	sub.l		%d1,L_SCR1(%a6)		# a1 is M
7236	add.w		&0x3FFF,%d1		# biased expo. of 2^(M1)
7237	mov.w		%d1,ADJSCALE(%a6)	# ADJSCALE := 2^(M1)
7238	mov.l		&0x80000000,ADJSCALE+4(%a6)
7239	clr.l		ADJSCALE+8(%a6)
7240	mov.l		L_SCR1(%a6),%d1		# D0 is M
7241	add.w		&0x3FFF,%d1		# biased expo. of 2^(M)
7242	bra.w		EXPCONT1		# go back to Step 3
7243
7244EXP2BIG:
7245#--Step 9
7246	tst.b		(%a0)			# is X positive or negative?
7247	bmi		t_unfl2
7248	bra		t_ovfl2
7249
7250	global		setoxd
7251setoxd:
7252#--entry point for EXP(X), X is denormalized
7253	mov.l		(%a0),-(%sp)
7254	andi.l		&0x80000000,(%sp)
7255	ori.l		&0x00800000,(%sp)	# sign(X)*2^(-126)
7256
7257	fmov.s		&0x3F800000,%fp0
7258
7259	fmov.l		%d0,%fpcr
7260	fadd.s		(%sp)+,%fp0
7261	bra		t_pinx2
7262
7263	global		setoxm1
7264setoxm1:
7265#--entry point for EXPM1(X), here X is finite, non-zero, non-NaN
7266
7267#--Step 1.
7268#--Step 1.1
7269	mov.l		(%a0),%d1		# load part of input X
7270	and.l		&0x7FFF0000,%d1		# biased expo. of X
7271	cmp.l		%d1,&0x3FFD0000		# 1/4
7272	bge.b		EM1CON1			# |X| >= 1/4
7273	bra		EM1SM
7274
7275EM1CON1:
7276#--Step 1.3
7277#--The case |X| >= 1/4
7278	mov.w		4(%a0),%d1		# expo. and partial sig. of |X|
7279	cmp.l		%d1,&0x4004C215		# 70log2 rounded up to 16 bits
7280	ble.b		EM1MAIN			# 1/4 <= |X| <= 70log2
7281	bra		EM1BIG
7282
7283EM1MAIN:
7284#--Step 2.
7285#--This is the case:	1/4 <= |X| <= 70 log2.
7286	fmov.x		(%a0),%fp0		# load input from (a0)
7287
7288	fmov.x		%fp0,%fp1
7289	fmul.s		&0x42B8AA3B,%fp0	# 64/log2 * X
7290	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
7291	fmov.l		%fp0,%d1		# N = int( X * 64/log2 )
7292	lea		EEXPTBL(%pc),%a1
7293	fmov.l		%d1,%fp0		# convert to floating-format
7294
7295	mov.l		%d1,L_SCR1(%a6)		# save N temporarily
7296	and.l		&0x3F,%d1		# D0 is J = N mod 64
7297	lsl.l		&4,%d1
7298	add.l		%d1,%a1			# address of 2^(J/64)
7299	mov.l		L_SCR1(%a6),%d1
7300	asr.l		&6,%d1			# D0 is M
7301	mov.l		%d1,L_SCR1(%a6)		# save a copy of M
7302
7303#--Step 3.
7304#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7305#--a0 points to 2^(J/64), D0 and a1 both contain M
7306	fmov.x		%fp0,%fp2
7307	fmul.s		&0xBC317218,%fp0	# N * L1, L1 = lead(-log2/64)
7308	fmul.x		L2(%pc),%fp2		# N * L2, L1+L2 = -log2/64
7309	fadd.x		%fp1,%fp0		# X + N*L1
7310	fadd.x		%fp2,%fp0		# fp0 is R, reduced arg.
7311	add.w		&0x3FFF,%d1		# D0 is biased expo. of 2^M
7312
7313#--Step 4.
7314#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7315#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6)))))
7316#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
7317#--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))]
7318
7319	fmov.x		%fp0,%fp1
7320	fmul.x		%fp1,%fp1		# fp1 IS S = R*R
7321
7322	fmov.s		&0x3950097B,%fp2	# fp2 IS a6
7323
7324	fmul.x		%fp1,%fp2		# fp2 IS S*A6
7325	fmov.x		%fp1,%fp3
7326	fmul.s		&0x3AB60B6A,%fp3	# fp3 IS S*A5
7327
7328	fadd.d		EM1A4(%pc),%fp2		# fp2 IS A4+S*A6
7329	fadd.d		EM1A3(%pc),%fp3		# fp3 IS A3+S*A5
7330	mov.w		%d1,SC(%a6)		# SC is 2^(M) in extended
7331	mov.l		&0x80000000,SC+4(%a6)
7332	clr.l		SC+8(%a6)
7333
7334	fmul.x		%fp1,%fp2		# fp2 IS S*(A4+S*A6)
7335	mov.l		L_SCR1(%a6),%d1		# D0 is	M
7336	neg.w		%d1			# D0 is -M
7337	fmul.x		%fp1,%fp3		# fp3 IS S*(A3+S*A5)
7338	add.w		&0x3FFF,%d1		# biased expo. of 2^(-M)
7339	fadd.d		EM1A2(%pc),%fp2		# fp2 IS A2+S*(A4+S*A6)
7340	fadd.s		&0x3F000000,%fp3	# fp3 IS A1+S*(A3+S*A5)
7341
7342	fmul.x		%fp1,%fp2		# fp2 IS S*(A2+S*(A4+S*A6))
7343	or.w		&0x8000,%d1		# signed/expo. of -2^(-M)
7344	mov.w		%d1,ONEBYSC(%a6)	# OnebySc is -2^(-M)
7345	mov.l		&0x80000000,ONEBYSC+4(%a6)
7346	clr.l		ONEBYSC+8(%a6)
7347	fmul.x		%fp3,%fp1		# fp1 IS S*(A1+S*(A3+S*A5))
7348
7349	fmul.x		%fp0,%fp2		# fp2 IS R*S*(A2+S*(A4+S*A6))
7350	fadd.x		%fp1,%fp0		# fp0 IS R+S*(A1+S*(A3+S*A5))
7351
7352	fadd.x		%fp2,%fp0		# fp0 IS EXP(R)-1
7353
7354	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
7355
7356#--Step 5
7357#--Compute 2^(J/64)*p
7358
7359	fmul.x		(%a1),%fp0		# 2^(J/64)*(Exp(R)-1)
7360
7361#--Step 6
7362#--Step 6.1
7363	mov.l		L_SCR1(%a6),%d1		# retrieve M
7364	cmp.l		%d1,&63
7365	ble.b		MLE63
7366#--Step 6.2	M >= 64
7367	fmov.s		12(%a1),%fp1		# fp1 is t
7368	fadd.x		ONEBYSC(%a6),%fp1	# fp1 is t+OnebySc
7369	fadd.x		%fp1,%fp0		# p+(t+OnebySc), fp1 released
7370	fadd.x		(%a1),%fp0		# T+(p+(t+OnebySc))
7371	bra		EM1SCALE
7372MLE63:
7373#--Step 6.3	M <= 63
7374	cmp.l		%d1,&-3
7375	bge.b		MGEN3
7376MLTN3:
7377#--Step 6.4	M <= -4
7378	fadd.s		12(%a1),%fp0		# p+t
7379	fadd.x		(%a1),%fp0		# T+(p+t)
7380	fadd.x		ONEBYSC(%a6),%fp0	# OnebySc + (T+(p+t))
7381	bra		EM1SCALE
7382MGEN3:
7383#--Step 6.5	-3 <= M <= 63
7384	fmov.x		(%a1)+,%fp1		# fp1 is T
7385	fadd.s		(%a1),%fp0		# fp0 is p+t
7386	fadd.x		ONEBYSC(%a6),%fp1	# fp1 is T+OnebySc
7387	fadd.x		%fp1,%fp0		# (T+OnebySc)+(p+t)
7388
7389EM1SCALE:
7390#--Step 6.6
7391	fmov.l		%d0,%fpcr
7392	fmul.x		SC(%a6),%fp0
7393	bra		t_inx2
7394
7395EM1SM:
7396#--Step 7	|X| < 1/4.
7397	cmp.l		%d1,&0x3FBE0000		# 2^(-65)
7398	bge.b		EM1POLY
7399
7400EM1TINY:
7401#--Step 8	|X| < 2^(-65)
7402	cmp.l		%d1,&0x00330000		# 2^(-16312)
7403	blt.b		EM12TINY
7404#--Step 8.2
7405	mov.l		&0x80010000,SC(%a6)	# SC is -2^(-16382)
7406	mov.l		&0x80000000,SC+4(%a6)
7407	clr.l		SC+8(%a6)
7408	fmov.x		(%a0),%fp0
7409	fmov.l		%d0,%fpcr
7410	mov.b		&FADD_OP,%d1		# last inst is ADD
7411	fadd.x		SC(%a6),%fp0
7412	bra		t_catch
7413
7414EM12TINY:
7415#--Step 8.3
7416	fmov.x		(%a0),%fp0
7417	fmul.d		TWO140(%pc),%fp0
7418	mov.l		&0x80010000,SC(%a6)
7419	mov.l		&0x80000000,SC+4(%a6)
7420	clr.l		SC+8(%a6)
7421	fadd.x		SC(%a6),%fp0
7422	fmov.l		%d0,%fpcr
7423	mov.b		&FMUL_OP,%d1		# last inst is MUL
7424	fmul.d		TWON140(%pc),%fp0
7425	bra		t_catch
7426
7427EM1POLY:
7428#--Step 9	exp(X)-1 by a simple polynomial
7429	fmov.x		(%a0),%fp0		# fp0 is X
7430	fmul.x		%fp0,%fp0		# fp0 is S := X*X
7431	fmovm.x		&0xc,-(%sp)		# save fp2 {%fp2/%fp3}
7432	fmov.s		&0x2F30CAA8,%fp1	# fp1 is B12
7433	fmul.x		%fp0,%fp1		# fp1 is S*B12
7434	fmov.s		&0x310F8290,%fp2	# fp2 is B11
7435	fadd.s		&0x32D73220,%fp1	# fp1 is B10+S*B12
7436
7437	fmul.x		%fp0,%fp2		# fp2 is S*B11
7438	fmul.x		%fp0,%fp1		# fp1 is S*(B10 + ...
7439
7440	fadd.s		&0x3493F281,%fp2	# fp2 is B9+S*...
7441	fadd.d		EM1B8(%pc),%fp1		# fp1 is B8+S*...
7442
7443	fmul.x		%fp0,%fp2		# fp2 is S*(B9+...
7444	fmul.x		%fp0,%fp1		# fp1 is S*(B8+...
7445
7446	fadd.d		EM1B7(%pc),%fp2		# fp2 is B7+S*...
7447	fadd.d		EM1B6(%pc),%fp1		# fp1 is B6+S*...
7448
7449	fmul.x		%fp0,%fp2		# fp2 is S*(B7+...
7450	fmul.x		%fp0,%fp1		# fp1 is S*(B6+...
7451
7452	fadd.d		EM1B5(%pc),%fp2		# fp2 is B5+S*...
7453	fadd.d		EM1B4(%pc),%fp1		# fp1 is B4+S*...
7454
7455	fmul.x		%fp0,%fp2		# fp2 is S*(B5+...
7456	fmul.x		%fp0,%fp1		# fp1 is S*(B4+...
7457
7458	fadd.d		EM1B3(%pc),%fp2		# fp2 is B3+S*...
7459	fadd.x		EM1B2(%pc),%fp1		# fp1 is B2+S*...
7460
7461	fmul.x		%fp0,%fp2		# fp2 is S*(B3+...
7462	fmul.x		%fp0,%fp1		# fp1 is S*(B2+...
7463
7464	fmul.x		%fp0,%fp2		# fp2 is S*S*(B3+...)
7465	fmul.x		(%a0),%fp1		# fp1 is X*S*(B2...
7466
7467	fmul.s		&0x3F000000,%fp0	# fp0 is S*B1
7468	fadd.x		%fp2,%fp1		# fp1 is Q
7469
7470	fmovm.x		(%sp)+,&0x30		# fp2 restored {%fp2/%fp3}
7471
7472	fadd.x		%fp1,%fp0		# fp0 is S*B1+Q
7473
7474	fmov.l		%d0,%fpcr
7475	fadd.x		(%a0),%fp0
7476	bra		t_inx2
7477
7478EM1BIG:
7479#--Step 10	|X| > 70 log2
7480	mov.l		(%a0),%d1
7481	cmp.l		%d1,&0
7482	bgt.w		EXPC1
7483#--Step 10.2
7484	fmov.s		&0xBF800000,%fp0	# fp0 is -1
7485	fmov.l		%d0,%fpcr
7486	fadd.s		&0x00800000,%fp0	# -1 + 2^(-126)
7487	bra		t_minx2
7488
7489	global		setoxm1d
7490setoxm1d:
7491#--entry point for EXPM1(X), here X is denormalized
7492#--Step 0.
7493	bra		t_extdnrm
7494
7495#########################################################################
7496# sgetexp():  returns the exponent portion of the input argument.	#
7497#	      The exponent bias is removed and the exponent value is	#
7498#	      returned as an extended precision number in fp0.		#
7499# sgetexpd(): handles denormalized numbers.				#
7500#									#
7501# sgetman():  extracts the mantissa of the input argument. The		#
7502#	      mantissa is converted to an extended precision number w/	#
7503#	      an exponent of $3fff and is returned in fp0. The range of #
7504#	      the result is [1.0 - 2.0).				#
7505# sgetmand(): handles denormalized numbers.				#
7506#									#
7507# INPUT *************************************************************** #
7508#	a0  = pointer to extended precision input			#
7509#									#
7510# OUTPUT ************************************************************** #
7511#	fp0 = exponent(X) or mantissa(X)				#
7512#									#
7513#########################################################################
7514
7515	global		sgetexp
7516sgetexp:
7517	mov.w		SRC_EX(%a0),%d0		# get the exponent
7518	bclr		&0xf,%d0		# clear the sign bit
7519	subi.w		&0x3fff,%d0		# subtract off the bias
7520	fmov.w		%d0,%fp0		# return exp in fp0
7521	blt.b		sgetexpn		# it's negative
7522	rts
7523
7524sgetexpn:
7525	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
7526	rts
7527
7528	global		sgetexpd
7529sgetexpd:
7530	bsr.l		norm			# normalize
7531	neg.w		%d0			# new exp = -(shft amt)
7532	subi.w		&0x3fff,%d0		# subtract off the bias
7533	fmov.w		%d0,%fp0		# return exp in fp0
7534	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
7535	rts
7536
7537	global		sgetman
7538sgetman:
7539	mov.w		SRC_EX(%a0),%d0		# get the exp
7540	ori.w		&0x7fff,%d0		# clear old exp
7541	bclr		&0xe,%d0		# make it the new exp +-3fff
7542
7543# here, we build the result in a tmp location so as not to disturb the input
7544	mov.l		SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp loc
7545	mov.l		SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp loc
7546	mov.w		%d0,FP_SCR0_EX(%a6)	# insert new exponent
7547	fmov.x		FP_SCR0(%a6),%fp0	# put new value back in fp0
7548	bmi.b		sgetmann		# it's negative
7549	rts
7550
7551sgetmann:
7552	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
7553	rts
7554
7555#
7556# For denormalized numbers, shift the mantissa until the j-bit = 1,
7557# then load the exponent with +/1 $3fff.
7558#
7559	global		sgetmand
7560sgetmand:
7561	bsr.l		norm			# normalize exponent
7562	bra.b		sgetman
7563
7564#########################################################################
7565# scosh():  computes the hyperbolic cosine of a normalized input	#
7566# scoshd(): computes the hyperbolic cosine of a denormalized input	#
7567#									#
7568# INPUT ***************************************************************	#
7569#	a0 = pointer to extended precision input			#
7570#	d0 = round precision,mode					#
7571#									#
7572# OUTPUT **************************************************************	#
7573#	fp0 = cosh(X)							#
7574#									#
7575# ACCURACY and MONOTONICITY *******************************************	#
7576#	The returned result is within 3 ulps in 64 significant bit,	#
7577#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
7578#	rounded to double precision. The result is provably monotonic	#
7579#	in double precision.						#
7580#									#
7581# ALGORITHM ***********************************************************	#
7582#									#
7583#	COSH								#
7584#	1. If |X| > 16380 log2, go to 3.				#
7585#									#
7586#	2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae	#
7587#		y = |X|, z = exp(Y), and				#
7588#		cosh(X) = (1/2)*( z + 1/z ).				#
7589#		Exit.							#
7590#									#
7591#	3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5.		#
7592#									#
7593#	4. (16380 log2 < |X| <= 16480 log2)				#
7594#		cosh(X) = sign(X) * exp(|X|)/2.				#
7595#		However, invoking exp(|X|) may cause premature		#
7596#		overflow. Thus, we calculate sinh(X) as follows:	#
7597#		Y	:= |X|						#
7598#		Fact	:=	2**(16380)				#
7599#		Y'	:= Y - 16381 log2				#
7600#		cosh(X) := Fact * exp(Y').				#
7601#		Exit.							#
7602#									#
7603#	5. (|X| > 16480 log2) sinh(X) must overflow. Return		#
7604#		Huge*Huge to generate overflow and an infinity with	#
7605#		the appropriate sign. Huge is the largest finite number	#
7606#		in extended format. Exit.				#
7607#									#
7608#########################################################################
7609
7610TWO16380:
7611	long		0x7FFB0000,0x80000000,0x00000000,0x00000000
7612
7613	global		scosh
7614scosh:
7615	fmov.x		(%a0),%fp0		# LOAD INPUT
7616
7617	mov.l		(%a0),%d1
7618	mov.w		4(%a0),%d1
7619	and.l		&0x7FFFFFFF,%d1
7620	cmp.l		%d1,&0x400CB167
7621	bgt.b		COSHBIG
7622
7623#--THIS IS THE USUAL CASE, |X| < 16380 LOG2
7624#--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) )
7625
7626	fabs.x		%fp0			# |X|
7627
7628	mov.l		%d0,-(%sp)
7629	clr.l		%d0
7630	fmovm.x		&0x01,-(%sp)		# save |X| to stack
7631	lea		(%sp),%a0		# pass ptr to |X|
7632	bsr		setox			# FP0 IS EXP(|X|)
7633	add.l		&0xc,%sp		# erase |X| from stack
7634	fmul.s		&0x3F000000,%fp0	# (1/2)EXP(|X|)
7635	mov.l		(%sp)+,%d0
7636
7637	fmov.s		&0x3E800000,%fp1	# (1/4)
7638	fdiv.x		%fp0,%fp1		# 1/(2 EXP(|X|))
7639
7640	fmov.l		%d0,%fpcr
7641	mov.b		&FADD_OP,%d1		# last inst is ADD
7642	fadd.x		%fp1,%fp0
7643	bra		t_catch
7644
7645COSHBIG:
7646	cmp.l		%d1,&0x400CB2B3
7647	bgt.b		COSHHUGE
7648
7649	fabs.x		%fp0
7650	fsub.d		T1(%pc),%fp0		# (|X|-16381LOG2_LEAD)
7651	fsub.d		T2(%pc),%fp0		# |X| - 16381 LOG2, ACCURATE
7652
7653	mov.l		%d0,-(%sp)
7654	clr.l		%d0
7655	fmovm.x		&0x01,-(%sp)		# save fp0 to stack
7656	lea		(%sp),%a0		# pass ptr to fp0
7657	bsr		setox
7658	add.l		&0xc,%sp		# clear fp0 from stack
7659	mov.l		(%sp)+,%d0
7660
7661	fmov.l		%d0,%fpcr
7662	mov.b		&FMUL_OP,%d1		# last inst is MUL
7663	fmul.x		TWO16380(%pc),%fp0
7664	bra		t_catch
7665
7666COSHHUGE:
7667	bra		t_ovfl2
7668
7669	global		scoshd
7670#--COSH(X) = 1 FOR DENORMALIZED X
7671scoshd:
7672	fmov.s		&0x3F800000,%fp0
7673
7674	fmov.l		%d0,%fpcr
7675	fadd.s		&0x00800000,%fp0
7676	bra		t_pinx2
7677
7678#########################################################################
7679# ssinh():  computes the hyperbolic sine of a normalized input		#
7680# ssinhd(): computes the hyperbolic sine of a denormalized input	#
7681#									#
7682# INPUT *************************************************************** #
7683#	a0 = pointer to extended precision input			#
7684#	d0 = round precision,mode					#
7685#									#
7686# OUTPUT ************************************************************** #
7687#	fp0 = sinh(X)							#
7688#									#
7689# ACCURACY and MONOTONICITY *******************************************	#
7690#	The returned result is within 3 ulps in 64 significant bit,	#
7691#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7692#	rounded to double precision. The result is provably monotonic	#
7693#	in double precision.						#
7694#									#
7695# ALGORITHM *********************************************************** #
7696#									#
7697#       SINH								#
7698#       1. If |X| > 16380 log2, go to 3.				#
7699#									#
7700#       2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula	#
7701#               y = |X|, sgn = sign(X), and z = expm1(Y),		#
7702#               sinh(X) = sgn*(1/2)*( z + z/(1+z) ).			#
7703#          Exit.							#
7704#									#
7705#       3. If |X| > 16480 log2, go to 5.				#
7706#									#
7707#       4. (16380 log2 < |X| <= 16480 log2)				#
7708#               sinh(X) = sign(X) * exp(|X|)/2.				#
7709#          However, invoking exp(|X|) may cause premature overflow.	#
7710#          Thus, we calculate sinh(X) as follows:			#
7711#             Y       := |X|						#
7712#             sgn     := sign(X)					#
7713#             sgnFact := sgn * 2**(16380)				#
7714#             Y'      := Y - 16381 log2					#
7715#             sinh(X) := sgnFact * exp(Y').				#
7716#          Exit.							#
7717#									#
7718#       5. (|X| > 16480 log2) sinh(X) must overflow. Return		#
7719#          sign(X)*Huge*Huge to generate overflow and an infinity with	#
7720#          the appropriate sign. Huge is the largest finite number in	#
7721#          extended format. Exit.					#
7722#									#
7723#########################################################################
7724
7725	global		ssinh
7726ssinh:
7727	fmov.x		(%a0),%fp0		# LOAD INPUT
7728
7729	mov.l		(%a0),%d1
7730	mov.w		4(%a0),%d1
7731	mov.l		%d1,%a1			# save (compacted) operand
7732	and.l		&0x7FFFFFFF,%d1
7733	cmp.l		%d1,&0x400CB167
7734	bgt.b		SINHBIG
7735
7736#--THIS IS THE USUAL CASE, |X| < 16380 LOG2
7737#--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) )
7738
7739	fabs.x		%fp0			# Y = |X|
7740
7741	movm.l		&0x8040,-(%sp)		# {a1/d0}
7742	fmovm.x		&0x01,-(%sp)		# save Y on stack
7743	lea		(%sp),%a0		# pass ptr to Y
7744	clr.l		%d0
7745	bsr		setoxm1			# FP0 IS Z = EXPM1(Y)
7746	add.l		&0xc,%sp		# clear Y from stack
7747	fmov.l		&0,%fpcr
7748	movm.l		(%sp)+,&0x0201		# {a1/d0}
7749
7750	fmov.x		%fp0,%fp1
7751	fadd.s		&0x3F800000,%fp1	# 1+Z
7752	fmov.x		%fp0,-(%sp)
7753	fdiv.x		%fp1,%fp0		# Z/(1+Z)
7754	mov.l		%a1,%d1
7755	and.l		&0x80000000,%d1
7756	or.l		&0x3F000000,%d1
7757	fadd.x		(%sp)+,%fp0
7758	mov.l		%d1,-(%sp)
7759
7760	fmov.l		%d0,%fpcr
7761	mov.b		&FMUL_OP,%d1		# last inst is MUL
7762	fmul.s		(%sp)+,%fp0		# last fp inst - possible exceptions set
7763	bra		t_catch
7764
7765SINHBIG:
7766	cmp.l		%d1,&0x400CB2B3
7767	bgt		t_ovfl
7768	fabs.x		%fp0
7769	fsub.d		T1(%pc),%fp0		# (|X|-16381LOG2_LEAD)
7770	mov.l		&0,-(%sp)
7771	mov.l		&0x80000000,-(%sp)
7772	mov.l		%a1,%d1
7773	and.l		&0x80000000,%d1
7774	or.l		&0x7FFB0000,%d1
7775	mov.l		%d1,-(%sp)		# EXTENDED FMT
7776	fsub.d		T2(%pc),%fp0		# |X| - 16381 LOG2, ACCURATE
7777
7778	mov.l		%d0,-(%sp)
7779	clr.l		%d0
7780	fmovm.x		&0x01,-(%sp)		# save fp0 on stack
7781	lea		(%sp),%a0		# pass ptr to fp0
7782	bsr		setox
7783	add.l		&0xc,%sp		# clear fp0 from stack
7784
7785	mov.l		(%sp)+,%d0
7786	fmov.l		%d0,%fpcr
7787	mov.b		&FMUL_OP,%d1		# last inst is MUL
7788	fmul.x		(%sp)+,%fp0		# possible exception
7789	bra		t_catch
7790
7791	global		ssinhd
7792#--SINH(X) = X FOR DENORMALIZED X
7793ssinhd:
7794	bra		t_extdnrm
7795
7796#########################################################################
7797# stanh():  computes the hyperbolic tangent of a normalized input	#
7798# stanhd(): computes the hyperbolic tangent of a denormalized input	#
7799#									#
7800# INPUT ***************************************************************	#
7801#	a0 = pointer to extended precision input			#
7802#	d0 = round precision,mode					#
7803#									#
7804# OUTPUT **************************************************************	#
7805#	fp0 = tanh(X)							#
7806#									#
7807# ACCURACY and MONOTONICITY *******************************************	#
7808#	The returned result is within 3 ulps in 64 significant bit,	#
7809#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7810#	rounded to double precision. The result is provably monotonic	#
7811#	in double precision.						#
7812#									#
7813# ALGORITHM ***********************************************************	#
7814#									#
7815#	TANH								#
7816#	1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3.		#
7817#									#
7818#	2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by		#
7819#		sgn := sign(X), y := 2|X|, z := expm1(Y), and		#
7820#		tanh(X) = sgn*( z/(2+z) ).				#
7821#		Exit.							#
7822#									#
7823#	3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1,		#
7824#		go to 7.						#
7825#									#
7826#	4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6.		#
7827#									#
7828#	5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by		#
7829#		sgn := sign(X), y := 2|X|, z := exp(Y),			#
7830#		tanh(X) = sgn - [ sgn*2/(1+z) ].			#
7831#		Exit.							#
7832#									#
7833#	6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we	#
7834#		calculate Tanh(X) by					#
7835#		sgn := sign(X), Tiny := 2**(-126),			#
7836#		tanh(X) := sgn - sgn*Tiny.				#
7837#		Exit.							#
7838#									#
7839#	7. (|X| < 2**(-40)). Tanh(X) = X.	Exit.			#
7840#									#
7841#########################################################################
7842
7843	set		X,FP_SCR0
7844	set		XFRAC,X+4
7845
7846	set		SGN,L_SCR3
7847
7848	set		V,FP_SCR0
7849
7850	global		stanh
7851stanh:
7852	fmov.x		(%a0),%fp0		# LOAD INPUT
7853
7854	fmov.x		%fp0,X(%a6)
7855	mov.l		(%a0),%d1
7856	mov.w		4(%a0),%d1
7857	mov.l		%d1,X(%a6)
7858	and.l		&0x7FFFFFFF,%d1
7859	cmp.l		%d1, &0x3fd78000	# is |X| < 2^(-40)?
7860	blt.w		TANHBORS		# yes
7861	cmp.l		%d1, &0x3fffddce	# is |X| > (5/2)LOG2?
7862	bgt.w		TANHBORS		# yes
7863
7864#--THIS IS THE USUAL CASE
7865#--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2).
7866
7867	mov.l		X(%a6),%d1
7868	mov.l		%d1,SGN(%a6)
7869	and.l		&0x7FFF0000,%d1
7870	add.l		&0x00010000,%d1		# EXPONENT OF 2|X|
7871	mov.l		%d1,X(%a6)
7872	and.l		&0x80000000,SGN(%a6)
7873	fmov.x		X(%a6),%fp0		# FP0 IS Y = 2|X|
7874
7875	mov.l		%d0,-(%sp)
7876	clr.l		%d0
7877	fmovm.x		&0x1,-(%sp)		# save Y on stack
7878	lea		(%sp),%a0		# pass ptr to Y
7879	bsr		setoxm1			# FP0 IS Z = EXPM1(Y)
7880	add.l		&0xc,%sp		# clear Y from stack
7881	mov.l		(%sp)+,%d0
7882
7883	fmov.x		%fp0,%fp1
7884	fadd.s		&0x40000000,%fp1	# Z+2
7885	mov.l		SGN(%a6),%d1
7886	fmov.x		%fp1,V(%a6)
7887	eor.l		%d1,V(%a6)
7888
7889	fmov.l		%d0,%fpcr		# restore users round prec,mode
7890	fdiv.x		V(%a6),%fp0
7891	bra		t_inx2
7892
7893TANHBORS:
7894	cmp.l		%d1,&0x3FFF8000
7895	blt.w		TANHSM
7896
7897	cmp.l		%d1,&0x40048AA1
7898	bgt.w		TANHHUGE
7899
7900#-- (5/2) LOG2 < |X| < 50 LOG2,
7901#--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X),
7902#--TANH(X) = SGN -	SGN*2/[EXP(Y)+1].
7903
7904	mov.l		X(%a6),%d1
7905	mov.l		%d1,SGN(%a6)
7906	and.l		&0x7FFF0000,%d1
7907	add.l		&0x00010000,%d1		# EXPO OF 2|X|
7908	mov.l		%d1,X(%a6)		# Y = 2|X|
7909	and.l		&0x80000000,SGN(%a6)
7910	mov.l		SGN(%a6),%d1
7911	fmov.x		X(%a6),%fp0		# Y = 2|X|
7912
7913	mov.l		%d0,-(%sp)
7914	clr.l		%d0
7915	fmovm.x		&0x01,-(%sp)		# save Y on stack
7916	lea		(%sp),%a0		# pass ptr to Y
7917	bsr		setox			# FP0 IS EXP(Y)
7918	add.l		&0xc,%sp		# clear Y from stack
7919	mov.l		(%sp)+,%d0
7920	mov.l		SGN(%a6),%d1
7921	fadd.s		&0x3F800000,%fp0	# EXP(Y)+1
7922
7923	eor.l		&0xC0000000,%d1		# -SIGN(X)*2
7924	fmov.s		%d1,%fp1		# -SIGN(X)*2 IN SGL FMT
7925	fdiv.x		%fp0,%fp1		# -SIGN(X)2 / [EXP(Y)+1 ]
7926
7927	mov.l		SGN(%a6),%d1
7928	or.l		&0x3F800000,%d1		# SGN
7929	fmov.s		%d1,%fp0		# SGN IN SGL FMT
7930
7931	fmov.l		%d0,%fpcr		# restore users round prec,mode
7932	mov.b		&FADD_OP,%d1		# last inst is ADD
7933	fadd.x		%fp1,%fp0
7934	bra		t_inx2
7935
7936TANHSM:
7937	fmov.l		%d0,%fpcr		# restore users round prec,mode
7938	mov.b		&FMOV_OP,%d1		# last inst is MOVE
7939	fmov.x		X(%a6),%fp0		# last inst - possible exception set
7940	bra		t_catch
7941
7942#---RETURN SGN(X) - SGN(X)EPS
7943TANHHUGE:
7944	mov.l		X(%a6),%d1
7945	and.l		&0x80000000,%d1
7946	or.l		&0x3F800000,%d1
7947	fmov.s		%d1,%fp0
7948	and.l		&0x80000000,%d1
7949	eor.l		&0x80800000,%d1		# -SIGN(X)*EPS
7950
7951	fmov.l		%d0,%fpcr		# restore users round prec,mode
7952	fadd.s		%d1,%fp0
7953	bra		t_inx2
7954
7955	global		stanhd
7956#--TANH(X) = X FOR DENORMALIZED X
7957stanhd:
7958	bra		t_extdnrm
7959
7960#########################################################################
7961# slogn():    computes the natural logarithm of a normalized input	#
7962# slognd():   computes the natural logarithm of a denormalized input	#
7963# slognp1():  computes the log(1+X) of a normalized input		#
7964# slognp1d(): computes the log(1+X) of a denormalized input		#
7965#									#
7966# INPUT ***************************************************************	#
7967#	a0 = pointer to extended precision input			#
7968#	d0 = round precision,mode					#
7969#									#
7970# OUTPUT **************************************************************	#
7971#	fp0 = log(X) or log(1+X)					#
7972#									#
7973# ACCURACY and MONOTONICITY *******************************************	#
7974#	The returned result is within 2 ulps in 64 significant bit,	#
7975#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
7976#	rounded to double precision. The result is provably monotonic	#
7977#	in double precision.						#
7978#									#
7979# ALGORITHM ***********************************************************	#
7980#	LOGN:								#
7981#	Step 1. If |X-1| < 1/16, approximate log(X) by an odd		#
7982#		polynomial in u, where u = 2(X-1)/(X+1). Otherwise,	#
7983#		move on to Step 2.					#
7984#									#
7985#	Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first	#
7986#		seven significant bits of Y plus 2**(-7), i.e.		#
7987#		F = 1.xxxxxx1 in base 2 where the six "x" match those	#
7988#		of Y. Note that |Y-F| <= 2**(-7).			#
7989#									#
7990#	Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a		#
7991#		polynomial in u, log(1+u) = poly.			#
7992#									#
7993#	Step 4. Reconstruct						#
7994#		log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u)	#
7995#		by k*log(2) + (log(F) + poly). The values of log(F) are	#
7996#		calculated beforehand and stored in the program.	#
7997#									#
7998#	lognp1:								#
7999#	Step 1: If |X| < 1/16, approximate log(1+X) by an odd		#
8000#		polynomial in u where u = 2X/(2+X). Otherwise, move on	#
8001#		to Step 2.						#
8002#									#
8003#	Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done	#
8004#		in Step 2 of the algorithm for LOGN and compute		#
8005#		log(1+X) as k*log(2) + log(F) + poly where poly		#
8006#		approximates log(1+u), u = (Y-F)/F.			#
8007#									#
8008#	Implementation Notes:						#
8009#	Note 1. There are 64 different possible values for F, thus 64	#
8010#		log(F)'s need to be tabulated. Moreover, the values of	#
8011#		1/F are also tabulated so that the division in (Y-F)/F	#
8012#		can be performed by a multiplication.			#
8013#									#
8014#	Note 2. In Step 2 of lognp1, in order to preserved accuracy,	#
8015#		the value Y-F has to be calculated carefully when	#
8016#		1/2 <= X < 3/2.						#
8017#									#
8018#	Note 3. To fully exploit the pipeline, polynomials are usually	#
8019#		separated into two parts evaluated independently before	#
8020#		being added up.						#
8021#									#
8022#########################################################################
8023LOGOF2:
8024	long		0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
8025
8026one:
8027	long		0x3F800000
8028zero:
8029	long		0x00000000
8030infty:
8031	long		0x7F800000
8032negone:
8033	long		0xBF800000
8034
8035LOGA6:
8036	long		0x3FC2499A,0xB5E4040B
8037LOGA5:
8038	long		0xBFC555B5,0x848CB7DB
8039
8040LOGA4:
8041	long		0x3FC99999,0x987D8730
8042LOGA3:
8043	long		0xBFCFFFFF,0xFF6F7E97
8044
8045LOGA2:
8046	long		0x3FD55555,0x555555A4
8047LOGA1:
8048	long		0xBFE00000,0x00000008
8049
8050LOGB5:
8051	long		0x3F175496,0xADD7DAD6
8052LOGB4:
8053	long		0x3F3C71C2,0xFE80C7E0
8054
8055LOGB3:
8056	long		0x3F624924,0x928BCCFF
8057LOGB2:
8058	long		0x3F899999,0x999995EC
8059
8060LOGB1:
8061	long		0x3FB55555,0x55555555
8062TWO:
8063	long		0x40000000,0x00000000
8064
8065LTHOLD:
8066	long		0x3f990000,0x80000000,0x00000000,0x00000000
8067
8068LOGTBL:
8069	long		0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000
8070	long		0x3FF70000,0xFF015358,0x833C47E2,0x00000000
8071	long		0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000
8072	long		0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000
8073	long		0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000
8074	long		0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000
8075	long		0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000
8076	long		0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000
8077	long		0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000
8078	long		0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000
8079	long		0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000
8080	long		0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000
8081	long		0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000
8082	long		0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000
8083	long		0x3FFE0000,0xE525982A,0xF70C880E,0x00000000
8084	long		0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000
8085	long		0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000
8086	long		0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000
8087	long		0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000
8088	long		0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000
8089	long		0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000
8090	long		0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000
8091	long		0x3FFE0000,0xD901B203,0x6406C80E,0x00000000
8092	long		0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000
8093	long		0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000
8094	long		0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000
8095	long		0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000
8096	long		0x3FFC0000,0xC3FD0329,0x06488481,0x00000000
8097	long		0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000
8098	long		0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000
8099	long		0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000
8100	long		0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000
8101	long		0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000
8102	long		0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000
8103	long		0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000
8104	long		0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000
8105	long		0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000
8106	long		0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000
8107	long		0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000
8108	long		0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000
8109	long		0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000
8110	long		0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000
8111	long		0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000
8112	long		0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000
8113	long		0x3FFE0000,0xBD691047,0x07661AA3,0x00000000
8114	long		0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000
8115	long		0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000
8116	long		0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000
8117	long		0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000
8118	long		0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000
8119	long		0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000
8120	long		0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000
8121	long		0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000
8122	long		0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000
8123	long		0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000
8124	long		0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000
8125	long		0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000
8126	long		0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000
8127	long		0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000
8128	long		0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000
8129	long		0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000
8130	long		0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000
8131	long		0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000
8132	long		0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000
8133	long		0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000
8134	long		0x3FFD0000,0xD2420487,0x2DD85160,0x00000000
8135	long		0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000
8136	long		0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000
8137	long		0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000
8138	long		0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000
8139	long		0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000
8140	long		0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000
8141	long		0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000
8142	long		0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000
8143	long		0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000
8144	long		0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000
8145	long		0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000
8146	long		0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000
8147	long		0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000
8148	long		0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000
8149	long		0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000
8150	long		0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000
8151	long		0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000
8152	long		0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000
8153	long		0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000
8154	long		0x3FFE0000,0x825EFCED,0x49369330,0x00000000
8155	long		0x3FFE0000,0x9868C809,0x868C8098,0x00000000
8156	long		0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000
8157	long		0x3FFE0000,0x97012E02,0x5C04B809,0x00000000
8158	long		0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000
8159	long		0x3FFE0000,0x95A02568,0x095A0257,0x00000000
8160	long		0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000
8161	long		0x3FFE0000,0x94458094,0x45809446,0x00000000
8162	long		0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000
8163	long		0x3FFE0000,0x92F11384,0x0497889C,0x00000000
8164	long		0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000
8165	long		0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000
8166	long		0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000
8167	long		0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000
8168	long		0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000
8169	long		0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000
8170	long		0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000
8171	long		0x3FFE0000,0x8DDA5202,0x37694809,0x00000000
8172	long		0x3FFE0000,0x9723A1B7,0x20134203,0x00000000
8173	long		0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000
8174	long		0x3FFE0000,0x995899C8,0x90EB8990,0x00000000
8175	long		0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000
8176	long		0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000
8177	long		0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000
8178	long		0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000
8179	long		0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000
8180	long		0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000
8181	long		0x3FFE0000,0x87F78087,0xF78087F8,0x00000000
8182	long		0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000
8183	long		0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000
8184	long		0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000
8185	long		0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000
8186	long		0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000
8187	long		0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000
8188	long		0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000
8189	long		0x3FFE0000,0x83993052,0x3FBE3368,0x00000000
8190	long		0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000
8191	long		0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000
8192	long		0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000
8193	long		0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000
8194	long		0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000
8195	long		0x3FFE0000,0x80808080,0x80808081,0x00000000
8196	long		0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000
8197
8198	set		ADJK,L_SCR1
8199
8200	set		X,FP_SCR0
8201	set		XDCARE,X+2
8202	set		XFRAC,X+4
8203
8204	set		F,FP_SCR1
8205	set		FFRAC,F+4
8206
8207	set		KLOG2,FP_SCR0
8208
8209	set		SAVEU,FP_SCR0
8210
8211	global		slogn
8212#--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S
8213slogn:
8214	fmov.x		(%a0),%fp0		# LOAD INPUT
8215	mov.l		&0x00000000,ADJK(%a6)
8216
8217LOGBGN:
8218#--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
8219#--A FINITE, NON-ZERO, NORMALIZED NUMBER.
8220
8221	mov.l		(%a0),%d1
8222	mov.w		4(%a0),%d1
8223
8224	mov.l		(%a0),X(%a6)
8225	mov.l		4(%a0),X+4(%a6)
8226	mov.l		8(%a0),X+8(%a6)
8227
8228	cmp.l		%d1,&0			# CHECK IF X IS NEGATIVE
8229	blt.w		LOGNEG			# LOG OF NEGATIVE ARGUMENT IS INVALID
8230# X IS POSITIVE, CHECK IF X IS NEAR 1
8231	cmp.l		%d1,&0x3ffef07d		# IS X < 15/16?
8232	blt.b		LOGMAIN			# YES
8233	cmp.l		%d1,&0x3fff8841		# IS X > 17/16?
8234	ble.w		LOGNEAR1		# NO
8235
8236LOGMAIN:
8237#--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1
8238
8239#--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY.
8240#--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.
8241#--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y)
8242#--			 = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F).
8243#--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING
8244#--LOG(1+U) CAN BE VERY EFFICIENT.
8245#--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO
8246#--DIVISION IS NEEDED TO CALCULATE (Y-F)/F.
8247
8248#--GET K, Y, F, AND ADDRESS OF 1/F.
8249	asr.l		&8,%d1
8250	asr.l		&8,%d1			# SHIFTED 16 BITS, BIASED EXPO. OF X
8251	sub.l		&0x3FFF,%d1		# THIS IS K
8252	add.l		ADJK(%a6),%d1		# ADJUST K, ORIGINAL INPUT MAY BE  DENORM.
8253	lea		LOGTBL(%pc),%a0		# BASE ADDRESS OF 1/F AND LOG(F)
8254	fmov.l		%d1,%fp1		# CONVERT K TO FLOATING-POINT FORMAT
8255
8256#--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F
8257	mov.l		&0x3FFF0000,X(%a6)	# X IS NOW Y, I.E. 2^(-K)*X
8258	mov.l		XFRAC(%a6),FFRAC(%a6)
8259	and.l		&0xFE000000,FFRAC(%a6)	# FIRST 7 BITS OF Y
8260	or.l		&0x01000000,FFRAC(%a6)	# GET F: ATTACH A 1 AT THE EIGHTH BIT
8261	mov.l		FFRAC(%a6),%d1	# READY TO GET ADDRESS OF 1/F
8262	and.l		&0x7E000000,%d1
8263	asr.l		&8,%d1
8264	asr.l		&8,%d1
8265	asr.l		&4,%d1			# SHIFTED 20, D0 IS THE DISPLACEMENT
8266	add.l		%d1,%a0			# A0 IS THE ADDRESS FOR 1/F
8267
8268	fmov.x		X(%a6),%fp0
8269	mov.l		&0x3fff0000,F(%a6)
8270	clr.l		F+8(%a6)
8271	fsub.x		F(%a6),%fp0		# Y-F
8272	fmovm.x		&0xc,-(%sp)		# SAVE FP2-3 WHILE FP0 IS NOT READY
8273#--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
8274#--REGISTERS SAVED: FPCR, FP1, FP2
8275
8276LP1CONT1:
8277#--AN RE-ENTRY POINT FOR LOGNP1
8278	fmul.x		(%a0),%fp0		# FP0 IS U = (Y-F)/F
8279	fmul.x		LOGOF2(%pc),%fp1	# GET K*LOG2 WHILE FP0 IS NOT READY
8280	fmov.x		%fp0,%fp2
8281	fmul.x		%fp2,%fp2		# FP2 IS V=U*U
8282	fmov.x		%fp1,KLOG2(%a6)		# PUT K*LOG2 IN MEMEORY, FREE FP1
8283
8284#--LOG(1+U) IS APPROXIMATED BY
8285#--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS
8286#--[U + V*(A1+V*(A3+V*A5))]  +  [U*V*(A2+V*(A4+V*A6))]
8287
8288	fmov.x		%fp2,%fp3
8289	fmov.x		%fp2,%fp1
8290
8291	fmul.d		LOGA6(%pc),%fp1		# V*A6
8292	fmul.d		LOGA5(%pc),%fp2		# V*A5
8293
8294	fadd.d		LOGA4(%pc),%fp1		# A4+V*A6
8295	fadd.d		LOGA3(%pc),%fp2		# A3+V*A5
8296
8297	fmul.x		%fp3,%fp1		# V*(A4+V*A6)
8298	fmul.x		%fp3,%fp2		# V*(A3+V*A5)
8299
8300	fadd.d		LOGA2(%pc),%fp1		# A2+V*(A4+V*A6)
8301	fadd.d		LOGA1(%pc),%fp2		# A1+V*(A3+V*A5)
8302
8303	fmul.x		%fp3,%fp1		# V*(A2+V*(A4+V*A6))
8304	add.l		&16,%a0			# ADDRESS OF LOG(F)
8305	fmul.x		%fp3,%fp2		# V*(A1+V*(A3+V*A5))
8306
8307	fmul.x		%fp0,%fp1		# U*V*(A2+V*(A4+V*A6))
8308	fadd.x		%fp2,%fp0		# U+V*(A1+V*(A3+V*A5))
8309
8310	fadd.x		(%a0),%fp1		# LOG(F)+U*V*(A2+V*(A4+V*A6))
8311	fmovm.x		(%sp)+,&0x30		# RESTORE FP2-3
8312	fadd.x		%fp1,%fp0		# FP0 IS LOG(F) + LOG(1+U)
8313
8314	fmov.l		%d0,%fpcr
8315	fadd.x		KLOG2(%a6),%fp0		# FINAL ADD
8316	bra		t_inx2
8317
8318
8319LOGNEAR1:
8320
8321# if the input is exactly equal to one, then exit through ld_pzero.
8322# if these 2 lines weren't here, the correct answer would be returned
8323# but the INEX2 bit would be set.
8324	fcmp.b		%fp0,&0x1		# is it equal to one?
8325	fbeq.l		ld_pzero		# yes
8326
8327#--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
8328	fmov.x		%fp0,%fp1
8329	fsub.s		one(%pc),%fp1		# FP1 IS X-1
8330	fadd.s		one(%pc),%fp0		# FP0 IS X+1
8331	fadd.x		%fp1,%fp1		# FP1 IS 2(X-1)
8332#--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
8333#--IN U, U = 2(X-1)/(X+1) = FP1/FP0
8334
8335LP1CONT2:
8336#--THIS IS AN RE-ENTRY POINT FOR LOGNP1
8337	fdiv.x		%fp0,%fp1		# FP1 IS U
8338	fmovm.x		&0xc,-(%sp)		# SAVE FP2-3
8339#--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3
8340#--LET V=U*U, W=V*V, CALCULATE
8341#--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY
8342#--U + U*V*(  [B1 + W*(B3 + W*B5)]  +  [V*(B2 + W*B4)]  )
8343	fmov.x		%fp1,%fp0
8344	fmul.x		%fp0,%fp0		# FP0 IS V
8345	fmov.x		%fp1,SAVEU(%a6)		# STORE U IN MEMORY, FREE FP1
8346	fmov.x		%fp0,%fp1
8347	fmul.x		%fp1,%fp1		# FP1 IS W
8348
8349	fmov.d		LOGB5(%pc),%fp3
8350	fmov.d		LOGB4(%pc),%fp2
8351
8352	fmul.x		%fp1,%fp3		# W*B5
8353	fmul.x		%fp1,%fp2		# W*B4
8354
8355	fadd.d		LOGB3(%pc),%fp3		# B3+W*B5
8356	fadd.d		LOGB2(%pc),%fp2		# B2+W*B4
8357
8358	fmul.x		%fp3,%fp1		# W*(B3+W*B5), FP3 RELEASED
8359
8360	fmul.x		%fp0,%fp2		# V*(B2+W*B4)
8361
8362	fadd.d		LOGB1(%pc),%fp1		# B1+W*(B3+W*B5)
8363	fmul.x		SAVEU(%a6),%fp0		# FP0 IS U*V
8364
8365	fadd.x		%fp2,%fp1		# B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED
8366	fmovm.x		(%sp)+,&0x30		# FP2-3 RESTORED
8367
8368	fmul.x		%fp1,%fp0		# U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
8369
8370	fmov.l		%d0,%fpcr
8371	fadd.x		SAVEU(%a6),%fp0
8372	bra		t_inx2
8373
8374#--REGISTERS SAVED FPCR. LOG(-VE) IS INVALID
8375LOGNEG:
8376	bra		t_operr
8377
8378	global		slognd
8379slognd:
8380#--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
8381
8382	mov.l		&-100,ADJK(%a6)		# INPUT = 2^(ADJK) * FP0
8383
8384#----normalize the input value by left shifting k bits (k to be determined
8385#----below), adjusting exponent and storing -k to  ADJK
8386#----the value TWOTO100 is no longer needed.
8387#----Note that this code assumes the denormalized input is NON-ZERO.
8388
8389	movm.l		&0x3f00,-(%sp)		# save some registers  {d2-d7}
8390	mov.l		(%a0),%d3		# D3 is exponent of smallest norm. #
8391	mov.l		4(%a0),%d4
8392	mov.l		8(%a0),%d5		# (D4,D5) is (Hi_X,Lo_X)
8393	clr.l		%d2			# D2 used for holding K
8394
8395	tst.l		%d4
8396	bne.b		Hi_not0
8397
8398Hi_0:
8399	mov.l		%d5,%d4
8400	clr.l		%d5
8401	mov.l		&32,%d2
8402	clr.l		%d6
8403	bfffo		%d4{&0:&32},%d6
8404	lsl.l		%d6,%d4
8405	add.l		%d6,%d2			# (D3,D4,D5) is normalized
8406
8407	mov.l		%d3,X(%a6)
8408	mov.l		%d4,XFRAC(%a6)
8409	mov.l		%d5,XFRAC+4(%a6)
8410	neg.l		%d2
8411	mov.l		%d2,ADJK(%a6)
8412	fmov.x		X(%a6),%fp0
8413	movm.l		(%sp)+,&0xfc		# restore registers {d2-d7}
8414	lea		X(%a6),%a0
8415	bra.w		LOGBGN			# begin regular log(X)
8416
8417Hi_not0:
8418	clr.l		%d6
8419	bfffo		%d4{&0:&32},%d6		# find first 1
8420	mov.l		%d6,%d2			# get k
8421	lsl.l		%d6,%d4
8422	mov.l		%d5,%d7			# a copy of D5
8423	lsl.l		%d6,%d5
8424	neg.l		%d6
8425	add.l		&32,%d6
8426	lsr.l		%d6,%d7
8427	or.l		%d7,%d4			# (D3,D4,D5) normalized
8428
8429	mov.l		%d3,X(%a6)
8430	mov.l		%d4,XFRAC(%a6)
8431	mov.l		%d5,XFRAC+4(%a6)
8432	neg.l		%d2
8433	mov.l		%d2,ADJK(%a6)
8434	fmov.x		X(%a6),%fp0
8435	movm.l		(%sp)+,&0xfc		# restore registers {d2-d7}
8436	lea		X(%a6),%a0
8437	bra.w		LOGBGN			# begin regular log(X)
8438
8439	global		slognp1
8440#--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S
8441slognp1:
8442	fmov.x		(%a0),%fp0		# LOAD INPUT
8443	fabs.x		%fp0			# test magnitude
8444	fcmp.x		%fp0,LTHOLD(%pc)	# compare with min threshold
8445	fbgt.w		LP1REAL			# if greater, continue
8446	fmov.l		%d0,%fpcr
8447	mov.b		&FMOV_OP,%d1		# last inst is MOVE
8448	fmov.x		(%a0),%fp0		# return signed argument
8449	bra		t_catch
8450
8451LP1REAL:
8452	fmov.x		(%a0),%fp0		# LOAD INPUT
8453	mov.l		&0x00000000,ADJK(%a6)
8454	fmov.x		%fp0,%fp1		# FP1 IS INPUT Z
8455	fadd.s		one(%pc),%fp0		# X := ROUND(1+Z)
8456	fmov.x		%fp0,X(%a6)
8457	mov.w		XFRAC(%a6),XDCARE(%a6)
8458	mov.l		X(%a6),%d1
8459	cmp.l		%d1,&0
8460	ble.w		LP1NEG0			# LOG OF ZERO OR -VE
8461	cmp.l		%d1,&0x3ffe8000		# IS BOUNDS [1/2,3/2]?
8462	blt.w		LOGMAIN
8463	cmp.l		%d1,&0x3fffc000
8464	bgt.w		LOGMAIN
8465#--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z,
8466#--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE,
8467#--SIMPLY INVOKE LOG(X) FOR LOG(1+Z).
8468
8469LP1NEAR1:
8470#--NEXT SEE IF EXP(-1/16) < X < EXP(1/16)
8471	cmp.l		%d1,&0x3ffef07d
8472	blt.w		LP1CARE
8473	cmp.l		%d1,&0x3fff8841
8474	bgt.w		LP1CARE
8475
8476LP1ONE16:
8477#--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2)
8478#--WHERE U = 2Z/(2+Z) = 2Z/(1+X).
8479	fadd.x		%fp1,%fp1		# FP1 IS 2Z
8480	fadd.s		one(%pc),%fp0		# FP0 IS 1+X
8481#--U = FP1/FP0
8482	bra.w		LP1CONT2
8483
8484LP1CARE:
8485#--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE
8486#--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST
8487#--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2],
8488#--THERE ARE ONLY TWO CASES.
8489#--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z
8490#--CASE 2: 1+Z > 1, THEN K = 0  AND Y-F = (1-F) + Z
8491#--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
8492#--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.
8493
8494	mov.l		XFRAC(%a6),FFRAC(%a6)
8495	and.l		&0xFE000000,FFRAC(%a6)
8496	or.l		&0x01000000,FFRAC(%a6)	# F OBTAINED
8497	cmp.l		%d1,&0x3FFF8000		# SEE IF 1+Z > 1
8498	bge.b		KISZERO
8499
8500KISNEG1:
8501	fmov.s		TWO(%pc),%fp0
8502	mov.l		&0x3fff0000,F(%a6)
8503	clr.l		F+8(%a6)
8504	fsub.x		F(%a6),%fp0		# 2-F
8505	mov.l		FFRAC(%a6),%d1
8506	and.l		&0x7E000000,%d1
8507	asr.l		&8,%d1
8508	asr.l		&8,%d1
8509	asr.l		&4,%d1			# D0 CONTAINS DISPLACEMENT FOR 1/F
8510	fadd.x		%fp1,%fp1		# GET 2Z
8511	fmovm.x		&0xc,-(%sp)		# SAVE FP2  {%fp2/%fp3}
8512	fadd.x		%fp1,%fp0		# FP0 IS Y-F = (2-F)+2Z
8513	lea		LOGTBL(%pc),%a0		# A0 IS ADDRESS OF 1/F
8514	add.l		%d1,%a0
8515	fmov.s		negone(%pc),%fp1	# FP1 IS K = -1
8516	bra.w		LP1CONT1
8517
8518KISZERO:
8519	fmov.s		one(%pc),%fp0
8520	mov.l		&0x3fff0000,F(%a6)
8521	clr.l		F+8(%a6)
8522	fsub.x		F(%a6),%fp0		# 1-F
8523	mov.l		FFRAC(%a6),%d1
8524	and.l		&0x7E000000,%d1
8525	asr.l		&8,%d1
8526	asr.l		&8,%d1
8527	asr.l		&4,%d1
8528	fadd.x		%fp1,%fp0		# FP0 IS Y-F
8529	fmovm.x		&0xc,-(%sp)		# FP2 SAVED {%fp2/%fp3}
8530	lea		LOGTBL(%pc),%a0
8531	add.l		%d1,%a0			# A0 IS ADDRESS OF 1/F
8532	fmov.s		zero(%pc),%fp1		# FP1 IS K = 0
8533	bra.w		LP1CONT1
8534
8535LP1NEG0:
8536#--FPCR SAVED. D0 IS X IN COMPACT FORM.
8537	cmp.l		%d1,&0
8538	blt.b		LP1NEG
8539LP1ZERO:
8540	fmov.s		negone(%pc),%fp0
8541
8542	fmov.l		%d0,%fpcr
8543	bra		t_dz
8544
8545LP1NEG:
8546	fmov.s		zero(%pc),%fp0
8547
8548	fmov.l		%d0,%fpcr
8549	bra		t_operr
8550
8551	global		slognp1d
8552#--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT
8553# Simply return the denorm
8554slognp1d:
8555	bra		t_extdnrm
8556
8557#########################################################################
8558# satanh():  computes the inverse hyperbolic tangent of a norm input	#
8559# satanhd(): computes the inverse hyperbolic tangent of a denorm input	#
8560#									#
8561# INPUT ***************************************************************	#
8562#	a0 = pointer to extended precision input			#
8563#	d0 = round precision,mode					#
8564#									#
8565# OUTPUT **************************************************************	#
8566#	fp0 = arctanh(X)						#
8567#									#
8568# ACCURACY and MONOTONICITY *******************************************	#
8569#	The returned result is within 3 ulps in	64 significant bit,	#
8570#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
8571#	rounded to double precision. The result is provably monotonic	#
8572#	in double precision.						#
8573#									#
8574# ALGORITHM ***********************************************************	#
8575#									#
8576#	ATANH								#
8577#	1. If |X| >= 1, go to 3.					#
8578#									#
8579#	2. (|X| < 1) Calculate atanh(X) by				#
8580#		sgn := sign(X)						#
8581#		y := |X|						#
8582#		z := 2y/(1-y)						#
8583#		atanh(X) := sgn * (1/2) * logp1(z)			#
8584#		Exit.							#
8585#									#
8586#	3. If |X| > 1, go to 5.						#
8587#									#
8588#	4. (|X| = 1) Generate infinity with an appropriate sign and	#
8589#		divide-by-zero by					#
8590#		sgn := sign(X)						#
8591#		atan(X) := sgn / (+0).					#
8592#		Exit.							#
8593#									#
8594#	5. (|X| > 1) Generate an invalid operation by 0 * infinity.	#
8595#		Exit.							#
8596#									#
8597#########################################################################
8598
8599	global		satanh
8600satanh:
8601	mov.l		(%a0),%d1
8602	mov.w		4(%a0),%d1
8603	and.l		&0x7FFFFFFF,%d1
8604	cmp.l		%d1,&0x3FFF8000
8605	bge.b		ATANHBIG
8606
8607#--THIS IS THE USUAL CASE, |X| < 1
8608#--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z).
8609
8610	fabs.x		(%a0),%fp0		# Y = |X|
8611	fmov.x		%fp0,%fp1
8612	fneg.x		%fp1			# -Y
8613	fadd.x		%fp0,%fp0		# 2Y
8614	fadd.s		&0x3F800000,%fp1	# 1-Y
8615	fdiv.x		%fp1,%fp0		# 2Y/(1-Y)
8616	mov.l		(%a0),%d1
8617	and.l		&0x80000000,%d1
8618	or.l		&0x3F000000,%d1		# SIGN(X)*HALF
8619	mov.l		%d1,-(%sp)
8620
8621	mov.l		%d0,-(%sp)		# save rnd prec,mode
8622	clr.l		%d0			# pass ext prec,RN
8623	fmovm.x		&0x01,-(%sp)		# save Z on stack
8624	lea		(%sp),%a0		# pass ptr to Z
8625	bsr		slognp1			# LOG1P(Z)
8626	add.l		&0xc,%sp		# clear Z from stack
8627
8628	mov.l		(%sp)+,%d0		# fetch old prec,mode
8629	fmov.l		%d0,%fpcr		# load it
8630	mov.b		&FMUL_OP,%d1		# last inst is MUL
8631	fmul.s		(%sp)+,%fp0
8632	bra		t_catch
8633
8634ATANHBIG:
8635	fabs.x		(%a0),%fp0		# |X|
8636	fcmp.s		%fp0,&0x3F800000
8637	fbgt		t_operr
8638	bra		t_dz
8639
8640	global		satanhd
8641#--ATANH(X) = X FOR DENORMALIZED X
8642satanhd:
8643	bra		t_extdnrm
8644
8645#########################################################################
8646# slog10():  computes the base-10 logarithm of a normalized input	#
8647# slog10d(): computes the base-10 logarithm of a denormalized input	#
8648# slog2():   computes the base-2 logarithm of a normalized input	#
8649# slog2d():  computes the base-2 logarithm of a denormalized input	#
8650#									#
8651# INPUT *************************************************************** #
8652#	a0 = pointer to extended precision input			#
8653#	d0 = round precision,mode					#
8654#									#
8655# OUTPUT **************************************************************	#
8656#	fp0 = log_10(X) or log_2(X)					#
8657#									#
8658# ACCURACY and MONOTONICITY *******************************************	#
8659#	The returned result is within 1.7 ulps in 64 significant bit,	#
8660#	i.e. within 0.5003 ulp to 53 bits if the result is subsequently	#
8661#	rounded to double precision. The result is provably monotonic	#
8662#	in double precision.						#
8663#									#
8664# ALGORITHM ***********************************************************	#
8665#									#
8666#       slog10d:							#
8667#									#
8668#       Step 0.	If X < 0, create a NaN and raise the invalid operation	#
8669#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
8670#       Notes:  Default means round-to-nearest mode, no floating-point	#
8671#               traps, and precision control = double extended.		#
8672#									#
8673#       Step 1. Call slognd to obtain Y = log(X), the natural log of X.	#
8674#       Notes:  Even if X is denormalized, log(X) is always normalized.	#
8675#									#
8676#       Step 2.  Compute log_10(X) = log(X) * (1/log(10)).		#
8677#            2.1 Restore the user FPCR					#
8678#            2.2 Return ans := Y * INV_L10.				#
8679#									#
8680#       slog10:								#
8681#									#
8682#       Step 0. If X < 0, create a NaN and raise the invalid operation	#
8683#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
8684#       Notes:  Default means round-to-nearest mode, no floating-point	#
8685#               traps, and precision control = double extended.		#
8686#									#
8687#       Step 1. Call sLogN to obtain Y = log(X), the natural log of X.	#
8688#									#
8689#       Step 2.   Compute log_10(X) = log(X) * (1/log(10)).		#
8690#            2.1  Restore the user FPCR					#
8691#            2.2  Return ans := Y * INV_L10.				#
8692#									#
8693#       sLog2d:								#
8694#									#
8695#       Step 0. If X < 0, create a NaN and raise the invalid operation	#
8696#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
8697#       Notes:  Default means round-to-nearest mode, no floating-point	#
8698#               traps, and precision control = double extended.		#
8699#									#
8700#       Step 1. Call slognd to obtain Y = log(X), the natural log of X.	#
8701#       Notes:  Even if X is denormalized, log(X) is always normalized.	#
8702#									#
8703#       Step 2.   Compute log_10(X) = log(X) * (1/log(2)).		#
8704#            2.1  Restore the user FPCR					#
8705#            2.2  Return ans := Y * INV_L2.				#
8706#									#
8707#       sLog2:								#
8708#									#
8709#       Step 0. If X < 0, create a NaN and raise the invalid operation	#
8710#               flag. Otherwise, save FPCR in D1; set FpCR to default.	#
8711#       Notes:  Default means round-to-nearest mode, no floating-point	#
8712#               traps, and precision control = double extended.		#
8713#									#
8714#       Step 1. If X is not an integer power of two, i.e., X != 2^k,	#
8715#               go to Step 3.						#
8716#									#
8717#       Step 2.   Return k.						#
8718#            2.1  Get integer k, X = 2^k.				#
8719#            2.2  Restore the user FPCR.				#
8720#            2.3  Return ans := convert-to-double-extended(k).		#
8721#									#
8722#       Step 3. Call sLogN to obtain Y = log(X), the natural log of X.	#
8723#									#
8724#       Step 4.   Compute log_2(X) = log(X) * (1/log(2)).		#
8725#            4.1  Restore the user FPCR					#
8726#            4.2  Return ans := Y * INV_L2.				#
8727#									#
8728#########################################################################
8729
8730INV_L10:
8731	long		0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000
8732
8733INV_L2:
8734	long		0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000
8735
8736	global		slog10
8737#--entry point for Log10(X), X is normalized
8738slog10:
8739	fmov.b		&0x1,%fp0
8740	fcmp.x		%fp0,(%a0)		# if operand == 1,
8741	fbeq.l		ld_pzero		# return an EXACT zero
8742
8743	mov.l		(%a0),%d1
8744	blt.w		invalid
8745	mov.l		%d0,-(%sp)
8746	clr.l		%d0
8747	bsr		slogn			# log(X), X normal.
8748	fmov.l		(%sp)+,%fpcr
8749	fmul.x		INV_L10(%pc),%fp0
8750	bra		t_inx2
8751
8752	global		slog10d
8753#--entry point for Log10(X), X is denormalized
8754slog10d:
8755	mov.l		(%a0),%d1
8756	blt.w		invalid
8757	mov.l		%d0,-(%sp)
8758	clr.l		%d0
8759	bsr		slognd			# log(X), X denorm.
8760	fmov.l		(%sp)+,%fpcr
8761	fmul.x		INV_L10(%pc),%fp0
8762	bra		t_minx2
8763
8764	global		slog2
8765#--entry point for Log2(X), X is normalized
8766slog2:
8767	mov.l		(%a0),%d1
8768	blt.w		invalid
8769
8770	mov.l		8(%a0),%d1
8771	bne.b		continue		# X is not 2^k
8772
8773	mov.l		4(%a0),%d1
8774	and.l		&0x7FFFFFFF,%d1
8775	bne.b		continue
8776
8777#--X = 2^k.
8778	mov.w		(%a0),%d1
8779	and.l		&0x00007FFF,%d1
8780	sub.l		&0x3FFF,%d1
8781	beq.l		ld_pzero
8782	fmov.l		%d0,%fpcr
8783	fmov.l		%d1,%fp0
8784	bra		t_inx2
8785
8786continue:
8787	mov.l		%d0,-(%sp)
8788	clr.l		%d0
8789	bsr		slogn			# log(X), X normal.
8790	fmov.l		(%sp)+,%fpcr
8791	fmul.x		INV_L2(%pc),%fp0
8792	bra		t_inx2
8793
8794invalid:
8795	bra		t_operr
8796
8797	global		slog2d
8798#--entry point for Log2(X), X is denormalized
8799slog2d:
8800	mov.l		(%a0),%d1
8801	blt.w		invalid
8802	mov.l		%d0,-(%sp)
8803	clr.l		%d0
8804	bsr		slognd			# log(X), X denorm.
8805	fmov.l		(%sp)+,%fpcr
8806	fmul.x		INV_L2(%pc),%fp0
8807	bra		t_minx2
8808
8809#########################################################################
8810# stwotox():  computes 2**X for a normalized input			#
8811# stwotoxd(): computes 2**X for a denormalized input			#
8812# stentox():  computes 10**X for a normalized input			#
8813# stentoxd(): computes 10**X for a denormalized input			#
8814#									#
8815# INPUT ***************************************************************	#
8816#	a0 = pointer to extended precision input			#
8817#	d0 = round precision,mode					#
8818#									#
8819# OUTPUT **************************************************************	#
8820#	fp0 = 2**X or 10**X						#
8821#									#
8822# ACCURACY and MONOTONICITY *******************************************	#
8823#	The returned result is within 2 ulps in 64 significant bit,	#
8824#	i.e. within 0.5001 ulp to 53 bits if the result is subsequently	#
8825#	rounded to double precision. The result is provably monotonic	#
8826#	in double precision.						#
8827#									#
8828# ALGORITHM ***********************************************************	#
8829#									#
8830#	twotox								#
8831#	1. If |X| > 16480, go to ExpBig.				#
8832#									#
8833#	2. If |X| < 2**(-70), go to ExpSm.				#
8834#									#
8835#	3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore	#
8836#		decompose N as						#
8837#		 N = 64(M + M') + j,  j = 0,1,2,...,63.			#
8838#									#
8839#	4. Overwrite r := r * log2. Then				#
8840#		2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).		#
8841#		Go to expr to compute that expression.			#
8842#									#
8843#	tentox								#
8844#	1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig.	#
8845#									#
8846#	2. If |X| < 2**(-70), go to ExpSm.				#
8847#									#
8848#	3. Set y := X*log_2(10)*64 (base 2 log of 10). Set		#
8849#		N := round-to-int(y). Decompose N as			#
8850#		 N = 64(M + M') + j,  j = 0,1,2,...,63.			#
8851#									#
8852#	4. Define r as							#
8853#		r := ((X - N*L1)-N*L2) * L10				#
8854#		where L1, L2 are the leading and trailing parts of	#
8855#		log_10(2)/64 and L10 is the natural log of 10. Then	#
8856#		10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).		#
8857#		Go to expr to compute that expression.			#
8858#									#
8859#	expr								#
8860#	1. Fetch 2**(j/64) from table as Fact1 and Fact2.		#
8861#									#
8862#	2. Overwrite Fact1 and Fact2 by					#
8863#		Fact1 := 2**(M) * Fact1					#
8864#		Fact2 := 2**(M) * Fact2					#
8865#		Thus Fact1 + Fact2 = 2**(M) * 2**(j/64).		#
8866#									#
8867#	3. Calculate P where 1 + P approximates exp(r):			#
8868#		P = r + r*r*(A1+r*(A2+...+r*A5)).			#
8869#									#
8870#	4. Let AdjFact := 2**(M'). Return				#
8871#		AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ).		#
8872#		Exit.							#
8873#									#
8874#	ExpBig								#
8875#	1. Generate overflow by Huge * Huge if X > 0; otherwise,	#
8876#	        generate underflow by Tiny * Tiny.			#
8877#									#
8878#	ExpSm								#
8879#	1. Return 1 + X.						#
8880#									#
8881#########################################################################
8882
8883L2TEN64:
8884	long		0x406A934F,0x0979A371	# 64LOG10/LOG2
8885L10TWO1:
8886	long		0x3F734413,0x509F8000	# LOG2/64LOG10
8887
8888L10TWO2:
8889	long		0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000
8890
8891LOG10:	long		0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000
8892
8893LOG2:	long		0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
8894
8895EXPA5:	long		0x3F56C16D,0x6F7BD0B2
8896EXPA4:	long		0x3F811112,0x302C712C
8897EXPA3:	long		0x3FA55555,0x55554CC1
8898EXPA2:	long		0x3FC55555,0x55554A54
8899EXPA1:	long		0x3FE00000,0x00000000,0x00000000,0x00000000
8900
8901TEXPTBL:
8902	long		0x3FFF0000,0x80000000,0x00000000,0x3F738000
8903	long		0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CA
8904	long		0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9
8905	long		0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9
8906	long		0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DA
8907	long		0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85C
8908	long		0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1
8909	long		0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CA
8910	long		0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373
8911	long		0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670
8912	long		0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700
8913	long		0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0
8914	long		0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6D
8915	long		0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319
8916	long		0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2B
8917	long		0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5
8918	long		0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5A
8919	long		0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7B
8920	long		0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAF
8921	long		0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DA
8922	long		0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDD
8923	long		0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96E
8924	long		0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90B
8925	long		0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DB
8926	long		0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EB
8927	long		0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274
8928	long		0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83C
8929	long		0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00
8930	long		0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301
8931	long		0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367
8932	long		0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05F
8933	long		0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3C
8934	long		0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FB
8935	long		0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CB
8936	long		0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3C
8937	long		0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AA
8938	long		0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFD
8939	long		0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51
8940	long		0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88A
8941	long		0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2
8942	long		0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8AB
8943	long		0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17
8944	long		0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3C
8945	long		0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8
8946	long		0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53
8947	long		0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AE
8948	long		0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124
8949	long		0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243
8950	long		0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69A
8951	long		0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61
8952	long		0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610
8953	long		0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1
8954	long		0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12
8955	long		0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFE
8956	long		0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4
8957	long		0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22F
8958	long		0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4A
8959	long		0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01A
8960	long		0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAC
8961	long		0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3F
8962	long		0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73A
8963	long		0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795
8964	long		0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84B
8965	long		0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581
8966
8967	set		INT,L_SCR1
8968
8969	set		X,FP_SCR0
8970	set		XDCARE,X+2
8971	set		XFRAC,X+4
8972
8973	set		ADJFACT,FP_SCR0
8974
8975	set		FACT1,FP_SCR0
8976	set		FACT1HI,FACT1+4
8977	set		FACT1LOW,FACT1+8
8978
8979	set		FACT2,FP_SCR1
8980	set		FACT2HI,FACT2+4
8981	set		FACT2LOW,FACT2+8
8982
8983	global		stwotox
8984#--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
8985stwotox:
8986	fmovm.x		(%a0),&0x80		# LOAD INPUT
8987
8988	mov.l		(%a0),%d1
8989	mov.w		4(%a0),%d1
8990	fmov.x		%fp0,X(%a6)
8991	and.l		&0x7FFFFFFF,%d1
8992
8993	cmp.l		%d1,&0x3FB98000		# |X| >= 2**(-70)?
8994	bge.b		TWOOK1
8995	bra.w		EXPBORS
8996
8997TWOOK1:
8998	cmp.l		%d1,&0x400D80C0		# |X| > 16480?
8999	ble.b		TWOMAIN
9000	bra.w		EXPBORS
9001
9002TWOMAIN:
9003#--USUAL CASE, 2^(-70) <= |X| <= 16480
9004
9005	fmov.x		%fp0,%fp1
9006	fmul.s		&0x42800000,%fp1	# 64 * X
9007	fmov.l		%fp1,INT(%a6)		# N = ROUND-TO-INT(64 X)
9008	mov.l		%d2,-(%sp)
9009	lea		TEXPTBL(%pc),%a1	# LOAD ADDRESS OF TABLE OF 2^(J/64)
9010	fmov.l		INT(%a6),%fp1		# N --> FLOATING FMT
9011	mov.l		INT(%a6),%d1
9012	mov.l		%d1,%d2
9013	and.l		&0x3F,%d1		# D0 IS J
9014	asl.l		&4,%d1			# DISPLACEMENT FOR 2^(J/64)
9015	add.l		%d1,%a1			# ADDRESS FOR 2^(J/64)
9016	asr.l		&6,%d2			# d2 IS L, N = 64L + J
9017	mov.l		%d2,%d1
9018	asr.l		&1,%d1			# D0 IS M
9019	sub.l		%d1,%d2			# d2 IS M', N = 64(M+M') + J
9020	add.l		&0x3FFF,%d2
9021
9022#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
9023#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
9024#--ADJFACT = 2^(M').
9025#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9026
9027	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
9028
9029	fmul.s		&0x3C800000,%fp1	# (1/64)*N
9030	mov.l		(%a1)+,FACT1(%a6)
9031	mov.l		(%a1)+,FACT1HI(%a6)
9032	mov.l		(%a1)+,FACT1LOW(%a6)
9033	mov.w		(%a1)+,FACT2(%a6)
9034
9035	fsub.x		%fp1,%fp0		# X - (1/64)*INT(64 X)
9036
9037	mov.w		(%a1)+,FACT2HI(%a6)
9038	clr.w		FACT2HI+2(%a6)
9039	clr.l		FACT2LOW(%a6)
9040	add.w		%d1,FACT1(%a6)
9041	fmul.x		LOG2(%pc),%fp0		# FP0 IS R
9042	add.w		%d1,FACT2(%a6)
9043
9044	bra.w		expr
9045
9046EXPBORS:
9047#--FPCR, D0 SAVED
9048	cmp.l		%d1,&0x3FFF8000
9049	bgt.b		TEXPBIG
9050
9051#--|X| IS SMALL, RETURN 1 + X
9052
9053	fmov.l		%d0,%fpcr		# restore users round prec,mode
9054	fadd.s		&0x3F800000,%fp0	# RETURN 1 + X
9055	bra		t_pinx2
9056
9057TEXPBIG:
9058#--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW
9059#--REGISTERS SAVE SO FAR ARE FPCR AND  D0
9060	mov.l		X(%a6),%d1
9061	cmp.l		%d1,&0
9062	blt.b		EXPNEG
9063
9064	bra		t_ovfl2			# t_ovfl expects positive value
9065
9066EXPNEG:
9067	bra		t_unfl2			# t_unfl expects positive value
9068
9069	global		stwotoxd
9070stwotoxd:
9071#--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENT
9072
9073	fmov.l		%d0,%fpcr		# set user's rounding mode/precision
9074	fmov.s		&0x3F800000,%fp0	# RETURN 1 + X
9075	mov.l		(%a0),%d1
9076	or.l		&0x00800001,%d1
9077	fadd.s		%d1,%fp0
9078	bra		t_pinx2
9079
9080	global		stentox
9081#--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
9082stentox:
9083	fmovm.x		(%a0),&0x80		# LOAD INPUT
9084
9085	mov.l		(%a0),%d1
9086	mov.w		4(%a0),%d1
9087	fmov.x		%fp0,X(%a6)
9088	and.l		&0x7FFFFFFF,%d1
9089
9090	cmp.l		%d1,&0x3FB98000		# |X| >= 2**(-70)?
9091	bge.b		TENOK1
9092	bra.w		EXPBORS
9093
9094TENOK1:
9095	cmp.l		%d1,&0x400B9B07		# |X| <= 16480*log2/log10 ?
9096	ble.b		TENMAIN
9097	bra.w		EXPBORS
9098
9099TENMAIN:
9100#--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10
9101
9102	fmov.x		%fp0,%fp1
9103	fmul.d		L2TEN64(%pc),%fp1	# X*64*LOG10/LOG2
9104	fmov.l		%fp1,INT(%a6)		# N=INT(X*64*LOG10/LOG2)
9105	mov.l		%d2,-(%sp)
9106	lea		TEXPTBL(%pc),%a1	# LOAD ADDRESS OF TABLE OF 2^(J/64)
9107	fmov.l		INT(%a6),%fp1		# N --> FLOATING FMT
9108	mov.l		INT(%a6),%d1
9109	mov.l		%d1,%d2
9110	and.l		&0x3F,%d1		# D0 IS J
9111	asl.l		&4,%d1			# DISPLACEMENT FOR 2^(J/64)
9112	add.l		%d1,%a1			# ADDRESS FOR 2^(J/64)
9113	asr.l		&6,%d2			# d2 IS L, N = 64L + J
9114	mov.l		%d2,%d1
9115	asr.l		&1,%d1			# D0 IS M
9116	sub.l		%d1,%d2			# d2 IS M', N = 64(M+M') + J
9117	add.l		&0x3FFF,%d2
9118
9119#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
9120#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
9121#--ADJFACT = 2^(M').
9122#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9123	fmovm.x		&0x0c,-(%sp)		# save fp2/fp3
9124
9125	fmov.x		%fp1,%fp2
9126
9127	fmul.d		L10TWO1(%pc),%fp1	# N*(LOG2/64LOG10)_LEAD
9128	mov.l		(%a1)+,FACT1(%a6)
9129
9130	fmul.x		L10TWO2(%pc),%fp2	# N*(LOG2/64LOG10)_TRAIL
9131
9132	mov.l		(%a1)+,FACT1HI(%a6)
9133	mov.l		(%a1)+,FACT1LOW(%a6)
9134	fsub.x		%fp1,%fp0		# X - N L_LEAD
9135	mov.w		(%a1)+,FACT2(%a6)
9136
9137	fsub.x		%fp2,%fp0		# X - N L_TRAIL
9138
9139	mov.w		(%a1)+,FACT2HI(%a6)
9140	clr.w		FACT2HI+2(%a6)
9141	clr.l		FACT2LOW(%a6)
9142
9143	fmul.x		LOG10(%pc),%fp0		# FP0 IS R
9144	add.w		%d1,FACT1(%a6)
9145	add.w		%d1,FACT2(%a6)
9146
9147expr:
9148#--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN.
9149#--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64).
9150#--FP0 IS R. THE FOLLOWING CODE COMPUTES
9151#--	2**(M'+M) * 2**(J/64) * EXP(R)
9152
9153	fmov.x		%fp0,%fp1
9154	fmul.x		%fp1,%fp1		# FP1 IS S = R*R
9155
9156	fmov.d		EXPA5(%pc),%fp2		# FP2 IS A5
9157	fmov.d		EXPA4(%pc),%fp3		# FP3 IS A4
9158
9159	fmul.x		%fp1,%fp2		# FP2 IS S*A5
9160	fmul.x		%fp1,%fp3		# FP3 IS S*A4
9161
9162	fadd.d		EXPA3(%pc),%fp2		# FP2 IS A3+S*A5
9163	fadd.d		EXPA2(%pc),%fp3		# FP3 IS A2+S*A4
9164
9165	fmul.x		%fp1,%fp2		# FP2 IS S*(A3+S*A5)
9166	fmul.x		%fp1,%fp3		# FP3 IS S*(A2+S*A4)
9167
9168	fadd.d		EXPA1(%pc),%fp2		# FP2 IS A1+S*(A3+S*A5)
9169	fmul.x		%fp0,%fp3		# FP3 IS R*S*(A2+S*A4)
9170
9171	fmul.x		%fp1,%fp2		# FP2 IS S*(A1+S*(A3+S*A5))
9172	fadd.x		%fp3,%fp0		# FP0 IS R+R*S*(A2+S*A4)
9173	fadd.x		%fp2,%fp0		# FP0 IS EXP(R) - 1
9174
9175	fmovm.x		(%sp)+,&0x30		# restore fp2/fp3
9176
9177#--FINAL RECONSTRUCTION PROCESS
9178#--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1)  -  (1 OR 0)
9179
9180	fmul.x		FACT1(%a6),%fp0
9181	fadd.x		FACT2(%a6),%fp0
9182	fadd.x		FACT1(%a6),%fp0
9183
9184	fmov.l		%d0,%fpcr		# restore users round prec,mode
9185	mov.w		%d2,ADJFACT(%a6)	# INSERT EXPONENT
9186	mov.l		(%sp)+,%d2
9187	mov.l		&0x80000000,ADJFACT+4(%a6)
9188	clr.l		ADJFACT+8(%a6)
9189	mov.b		&FMUL_OP,%d1		# last inst is MUL
9190	fmul.x		ADJFACT(%a6),%fp0	# FINAL ADJUSTMENT
9191	bra		t_catch
9192
9193	global		stentoxd
9194stentoxd:
9195#--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENT
9196
9197	fmov.l		%d0,%fpcr		# set user's rounding mode/precision
9198	fmov.s		&0x3F800000,%fp0	# RETURN 1 + X
9199	mov.l		(%a0),%d1
9200	or.l		&0x00800001,%d1
9201	fadd.s		%d1,%fp0
9202	bra		t_pinx2
9203
9204#########################################################################
9205# sscale(): computes the destination operand scaled by the source	#
9206#	    operand. If the absoulute value of the source operand is	#
9207#	    >= 2^14, an overflow or underflow is returned.		#
9208#									#
9209# INPUT *************************************************************** #
9210#	a0  = pointer to double-extended source operand X		#
9211#	a1  = pointer to double-extended destination operand Y		#
9212#									#
9213# OUTPUT ************************************************************** #
9214#	fp0 =  scale(X,Y)						#
9215#									#
9216#########################################################################
9217
9218set	SIGN,		L_SCR1
9219
9220	global		sscale
9221sscale:
9222	mov.l		%d0,-(%sp)		# store off ctrl bits for now
9223
9224	mov.w		DST_EX(%a1),%d1		# get dst exponent
9225	smi.b		SIGN(%a6)		# use SIGN to hold dst sign
9226	andi.l		&0x00007fff,%d1		# strip sign from dst exp
9227
9228	mov.w		SRC_EX(%a0),%d0		# check src bounds
9229	andi.w		&0x7fff,%d0		# clr src sign bit
9230	cmpi.w		%d0,&0x3fff		# is src ~ ZERO?
9231	blt.w		src_small		# yes
9232	cmpi.w		%d0,&0x400c		# no; is src too big?
9233	bgt.w		src_out			# yes
9234
9235#
9236# Source is within 2^14 range.
9237#
9238src_ok:
9239	fintrz.x	SRC(%a0),%fp0		# calc int of src
9240	fmov.l		%fp0,%d0		# int src to d0
9241# don't want any accrued bits from the fintrz showing up later since
9242# we may need to read the fpsr for the last fp op in t_catch2().
9243	fmov.l		&0x0,%fpsr
9244
9245	tst.b		DST_HI(%a1)		# is dst denormalized?
9246	bmi.b		sok_norm
9247
9248# the dst is a DENORM. normalize the DENORM and add the adjustment to
9249# the src value. then, jump to the norm part of the routine.
9250sok_dnrm:
9251	mov.l		%d0,-(%sp)		# save src for now
9252
9253	mov.w		DST_EX(%a1),FP_SCR0_EX(%a6) # make a copy
9254	mov.l		DST_HI(%a1),FP_SCR0_HI(%a6)
9255	mov.l		DST_LO(%a1),FP_SCR0_LO(%a6)
9256
9257	lea		FP_SCR0(%a6),%a0	# pass ptr to DENORM
9258	bsr.l		norm			# normalize the DENORM
9259	neg.l		%d0
9260	add.l		(%sp)+,%d0		# add adjustment to src
9261
9262	fmovm.x		FP_SCR0(%a6),&0x80	# load normalized DENORM
9263
9264	cmpi.w		%d0,&-0x3fff		# is the shft amt really low?
9265	bge.b		sok_norm2		# thank goodness no
9266
9267# the multiply factor that we're trying to create should be a denorm
9268# for the multiply to work. therefore, we're going to actually do a
9269# multiply with a denorm which will cause an unimplemented data type
9270# exception to be put into the machine which will be caught and corrected
9271# later. we don't do this with the DENORMs above because this method
9272# is slower. but, don't fret, I don't see it being used much either.
9273	fmov.l		(%sp)+,%fpcr		# restore user fpcr
9274	mov.l		&0x80000000,%d1		# load normalized mantissa
9275	subi.l		&-0x3fff,%d0		# how many should we shift?
9276	neg.l		%d0			# make it positive
9277	cmpi.b		%d0,&0x20		# is it > 32?
9278	bge.b		sok_dnrm_32		# yes
9279	lsr.l		%d0,%d1			# no; bit stays in upper lw
9280	clr.l		-(%sp)			# insert zero low mantissa
9281	mov.l		%d1,-(%sp)		# insert new high mantissa
9282	clr.l		-(%sp)			# make zero exponent
9283	bra.b		sok_norm_cont
9284sok_dnrm_32:
9285	subi.b		&0x20,%d0		# get shift count
9286	lsr.l		%d0,%d1			# make low mantissa longword
9287	mov.l		%d1,-(%sp)		# insert new low mantissa
9288	clr.l		-(%sp)			# insert zero high mantissa
9289	clr.l		-(%sp)			# make zero exponent
9290	bra.b		sok_norm_cont
9291
9292# the src will force the dst to a DENORM value or worse. so, let's
9293# create an fp multiply that will create the result.
9294sok_norm:
9295	fmovm.x		DST(%a1),&0x80		# load fp0 with normalized src
9296sok_norm2:
9297	fmov.l		(%sp)+,%fpcr		# restore user fpcr
9298
9299	addi.w		&0x3fff,%d0		# turn src amt into exp value
9300	swap		%d0			# put exponent in high word
9301	clr.l		-(%sp)			# insert new exponent
9302	mov.l		&0x80000000,-(%sp)	# insert new high mantissa
9303	mov.l		%d0,-(%sp)		# insert new lo mantissa
9304
9305sok_norm_cont:
9306	fmov.l		%fpcr,%d0		# d0 needs fpcr for t_catch2
9307	mov.b		&FMUL_OP,%d1		# last inst is MUL
9308	fmul.x		(%sp)+,%fp0		# do the multiply
9309	bra		t_catch2		# catch any exceptions
9310
9311#
9312# Source is outside of 2^14 range.  Test the sign and branch
9313# to the appropriate exception handler.
9314#
9315src_out:
9316	mov.l		(%sp)+,%d0		# restore ctrl bits
9317	exg		%a0,%a1			# swap src,dst ptrs
9318	tst.b		SRC_EX(%a1)		# is src negative?
9319	bmi		t_unfl			# yes; underflow
9320	bra		t_ovfl_sc		# no; overflow
9321
9322#
9323# The source input is below 1, so we check for denormalized numbers
9324# and set unfl.
9325#
9326src_small:
9327	tst.b		DST_HI(%a1)		# is dst denormalized?
9328	bpl.b		ssmall_done		# yes
9329
9330	mov.l		(%sp)+,%d0
9331	fmov.l		%d0,%fpcr		# no; load control bits
9332	mov.b		&FMOV_OP,%d1		# last inst is MOVE
9333	fmov.x		DST(%a1),%fp0		# simply return dest
9334	bra		t_catch2
9335ssmall_done:
9336	mov.l		(%sp)+,%d0		# load control bits into d1
9337	mov.l		%a1,%a0			# pass ptr to dst
9338	bra		t_resdnrm
9339
9340#########################################################################
9341# smod(): computes the fp MOD of the input values X,Y.			#
9342# srem(): computes the fp (IEEE) REM of the input values X,Y.		#
9343#									#
9344# INPUT *************************************************************** #
9345#	a0 = pointer to extended precision input X			#
9346#	a1 = pointer to extended precision input Y			#
9347#	d0 = round precision,mode					#
9348#									#
9349#	The input operands X and Y can be either normalized or		#
9350#	denormalized.							#
9351#									#
9352# OUTPUT ************************************************************** #
9353#      fp0 = FREM(X,Y) or FMOD(X,Y)					#
9354#									#
9355# ALGORITHM *********************************************************** #
9356#									#
9357#       Step 1.  Save and strip signs of X and Y: signX := sign(X),	#
9358#                signY := sign(Y), X := |X|, Y := |Y|,			#
9359#                signQ := signX EOR signY. Record whether MOD or REM	#
9360#                is requested.						#
9361#									#
9362#       Step 2.  Set L := expo(X)-expo(Y), k := 0, Q := 0.		#
9363#                If (L < 0) then					#
9364#                   R := X, go to Step 4.				#
9365#                else							#
9366#                   R := 2^(-L)X, j := L.				#
9367#                endif							#
9368#									#
9369#       Step 3.  Perform MOD(X,Y)					#
9370#            3.1 If R = Y, go to Step 9.				#
9371#            3.2 If R > Y, then { R := R - Y, Q := Q + 1}		#
9372#            3.3 If j = 0, go to Step 4.				#
9373#            3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to	#
9374#                Step 3.1.						#
9375#									#
9376#       Step 4.  At this point, R = X - QY = MOD(X,Y). Set		#
9377#                Last_Subtract := false (used in Step 7 below). If	#
9378#                MOD is requested, go to Step 6.			#
9379#									#
9380#       Step 5.  R = MOD(X,Y), but REM(X,Y) is requested.		#
9381#            5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to	#
9382#                Step 6.						#
9383#            5.2 If R > Y/2, then { set Last_Subtract := true,		#
9384#                Q := Q + 1, Y := signY*Y }. Go to Step 6.		#
9385#            5.3 This is the tricky case of R = Y/2. If Q is odd,	#
9386#                then { Q := Q + 1, signX := -signX }.			#
9387#									#
9388#       Step 6.  R := signX*R.						#
9389#									#
9390#       Step 7.  If Last_Subtract = true, R := R - Y.			#
9391#									#
9392#       Step 8.  Return signQ, last 7 bits of Q, and R as required.	#
9393#									#
9394#       Step 9.  At this point, R = 2^(-j)*X - Q Y = Y. Thus,		#
9395#                X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1),		#
9396#                R := 0. Return signQ, last 7 bits of Q, and R.		#
9397#									#
9398#########################################################################
9399
9400	set		Mod_Flag,L_SCR3
9401	set		Sc_Flag,L_SCR3+1
9402
9403	set		SignY,L_SCR2
9404	set		SignX,L_SCR2+2
9405	set		SignQ,L_SCR3+2
9406
9407	set		Y,FP_SCR0
9408	set		Y_Hi,Y+4
9409	set		Y_Lo,Y+8
9410
9411	set		R,FP_SCR1
9412	set		R_Hi,R+4
9413	set		R_Lo,R+8
9414
9415Scale:
9416	long		0x00010000,0x80000000,0x00000000,0x00000000
9417
9418	global		smod
9419smod:
9420	clr.b		FPSR_QBYTE(%a6)
9421	mov.l		%d0,-(%sp)		# save ctrl bits
9422	clr.b		Mod_Flag(%a6)
9423	bra.b		Mod_Rem
9424
9425	global		srem
9426srem:
9427	clr.b		FPSR_QBYTE(%a6)
9428	mov.l		%d0,-(%sp)		# save ctrl bits
9429	mov.b		&0x1,Mod_Flag(%a6)
9430
9431Mod_Rem:
9432#..Save sign of X and Y
9433	movm.l		&0x3f00,-(%sp)		# save data registers
9434	mov.w		SRC_EX(%a0),%d3
9435	mov.w		%d3,SignY(%a6)
9436	and.l		&0x00007FFF,%d3		# Y := |Y|
9437
9438#
9439	mov.l		SRC_HI(%a0),%d4
9440	mov.l		SRC_LO(%a0),%d5		# (D3,D4,D5) is |Y|
9441
9442	tst.l		%d3
9443	bne.b		Y_Normal
9444
9445	mov.l		&0x00003FFE,%d3		# $3FFD + 1
9446	tst.l		%d4
9447	bne.b		HiY_not0
9448
9449HiY_0:
9450	mov.l		%d5,%d4
9451	clr.l		%d5
9452	sub.l		&32,%d3
9453	clr.l		%d6
9454	bfffo		%d4{&0:&32},%d6
9455	lsl.l		%d6,%d4
9456	sub.l		%d6,%d3			# (D3,D4,D5) is normalized
9457#	                                        ...with bias $7FFD
9458	bra.b		Chk_X
9459
9460HiY_not0:
9461	clr.l		%d6
9462	bfffo		%d4{&0:&32},%d6
9463	sub.l		%d6,%d3
9464	lsl.l		%d6,%d4
9465	mov.l		%d5,%d7			# a copy of D5
9466	lsl.l		%d6,%d5
9467	neg.l		%d6
9468	add.l		&32,%d6
9469	lsr.l		%d6,%d7
9470	or.l		%d7,%d4			# (D3,D4,D5) normalized
9471#                                       ...with bias $7FFD
9472	bra.b		Chk_X
9473
9474Y_Normal:
9475	add.l		&0x00003FFE,%d3		# (D3,D4,D5) normalized
9476#                                       ...with bias $7FFD
9477
9478Chk_X:
9479	mov.w		DST_EX(%a1),%d0
9480	mov.w		%d0,SignX(%a6)
9481	mov.w		SignY(%a6),%d1
9482	eor.l		%d0,%d1
9483	and.l		&0x00008000,%d1
9484	mov.w		%d1,SignQ(%a6)		# sign(Q) obtained
9485	and.l		&0x00007FFF,%d0
9486	mov.l		DST_HI(%a1),%d1
9487	mov.l		DST_LO(%a1),%d2		# (D0,D1,D2) is |X|
9488	tst.l		%d0
9489	bne.b		X_Normal
9490	mov.l		&0x00003FFE,%d0
9491	tst.l		%d1
9492	bne.b		HiX_not0
9493
9494HiX_0:
9495	mov.l		%d2,%d1
9496	clr.l		%d2
9497	sub.l		&32,%d0
9498	clr.l		%d6
9499	bfffo		%d1{&0:&32},%d6
9500	lsl.l		%d6,%d1
9501	sub.l		%d6,%d0			# (D0,D1,D2) is normalized
9502#                                       ...with bias $7FFD
9503	bra.b		Init
9504
9505HiX_not0:
9506	clr.l		%d6
9507	bfffo		%d1{&0:&32},%d6
9508	sub.l		%d6,%d0
9509	lsl.l		%d6,%d1
9510	mov.l		%d2,%d7			# a copy of D2
9511	lsl.l		%d6,%d2
9512	neg.l		%d6
9513	add.l		&32,%d6
9514	lsr.l		%d6,%d7
9515	or.l		%d7,%d1			# (D0,D1,D2) normalized
9516#                                       ...with bias $7FFD
9517	bra.b		Init
9518
9519X_Normal:
9520	add.l		&0x00003FFE,%d0		# (D0,D1,D2) normalized
9521#                                       ...with bias $7FFD
9522
9523Init:
9524#
9525	mov.l		%d3,L_SCR1(%a6)		# save biased exp(Y)
9526	mov.l		%d0,-(%sp)		# save biased exp(X)
9527	sub.l		%d3,%d0			# L := expo(X)-expo(Y)
9528
9529	clr.l		%d6			# D6 := carry <- 0
9530	clr.l		%d3			# D3 is Q
9531	mov.l		&0,%a1			# A1 is k; j+k=L, Q=0
9532
9533#..(Carry,D1,D2) is R
9534	tst.l		%d0
9535	bge.b		Mod_Loop_pre
9536
9537#..expo(X) < expo(Y). Thus X = mod(X,Y)
9538#
9539	mov.l		(%sp)+,%d0		# restore d0
9540	bra.w		Get_Mod
9541
9542Mod_Loop_pre:
9543	addq.l		&0x4,%sp		# erase exp(X)
9544#..At this point  R = 2^(-L)X; Q = 0; k = 0; and  k+j = L
9545Mod_Loop:
9546	tst.l		%d6			# test carry bit
9547	bgt.b		R_GT_Y
9548
9549#..At this point carry = 0, R = (D1,D2), Y = (D4,D5)
9550	cmp.l		%d1,%d4			# compare hi(R) and hi(Y)
9551	bne.b		R_NE_Y
9552	cmp.l		%d2,%d5			# compare lo(R) and lo(Y)
9553	bne.b		R_NE_Y
9554
9555#..At this point, R = Y
9556	bra.w		Rem_is_0
9557
9558R_NE_Y:
9559#..use the borrow of the previous compare
9560	bcs.b		R_LT_Y			# borrow is set iff R < Y
9561
9562R_GT_Y:
9563#..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0
9564#..and Y < (D1,D2) < 2Y. Either way, perform R - Y
9565	sub.l		%d5,%d2			# lo(R) - lo(Y)
9566	subx.l		%d4,%d1			# hi(R) - hi(Y)
9567	clr.l		%d6			# clear carry
9568	addq.l		&1,%d3			# Q := Q + 1
9569
9570R_LT_Y:
9571#..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0.
9572	tst.l		%d0			# see if j = 0.
9573	beq.b		PostLoop
9574
9575	add.l		%d3,%d3			# Q := 2Q
9576	add.l		%d2,%d2			# lo(R) = 2lo(R)
9577	roxl.l		&1,%d1			# hi(R) = 2hi(R) + carry
9578	scs		%d6			# set Carry if 2(R) overflows
9579	addq.l		&1,%a1			# k := k+1
9580	subq.l		&1,%d0			# j := j - 1
9581#..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y.
9582
9583	bra.b		Mod_Loop
9584
9585PostLoop:
9586#..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y.
9587
9588#..normalize R.
9589	mov.l		L_SCR1(%a6),%d0		# new biased expo of R
9590	tst.l		%d1
9591	bne.b		HiR_not0
9592
9593HiR_0:
9594	mov.l		%d2,%d1
9595	clr.l		%d2
9596	sub.l		&32,%d0
9597	clr.l		%d6
9598	bfffo		%d1{&0:&32},%d6
9599	lsl.l		%d6,%d1
9600	sub.l		%d6,%d0			# (D0,D1,D2) is normalized
9601#                                       ...with bias $7FFD
9602	bra.b		Get_Mod
9603
9604HiR_not0:
9605	clr.l		%d6
9606	bfffo		%d1{&0:&32},%d6
9607	bmi.b		Get_Mod			# already normalized
9608	sub.l		%d6,%d0
9609	lsl.l		%d6,%d1
9610	mov.l		%d2,%d7			# a copy of D2
9611	lsl.l		%d6,%d2
9612	neg.l		%d6
9613	add.l		&32,%d6
9614	lsr.l		%d6,%d7
9615	or.l		%d7,%d1			# (D0,D1,D2) normalized
9616
9617#
9618Get_Mod:
9619	cmp.l		%d0,&0x000041FE
9620	bge.b		No_Scale
9621Do_Scale:
9622	mov.w		%d0,R(%a6)
9623	mov.l		%d1,R_Hi(%a6)
9624	mov.l		%d2,R_Lo(%a6)
9625	mov.l		L_SCR1(%a6),%d6
9626	mov.w		%d6,Y(%a6)
9627	mov.l		%d4,Y_Hi(%a6)
9628	mov.l		%d5,Y_Lo(%a6)
9629	fmov.x		R(%a6),%fp0		# no exception
9630	mov.b		&1,Sc_Flag(%a6)
9631	bra.b		ModOrRem
9632No_Scale:
9633	mov.l		%d1,R_Hi(%a6)
9634	mov.l		%d2,R_Lo(%a6)
9635	sub.l		&0x3FFE,%d0
9636	mov.w		%d0,R(%a6)
9637	mov.l		L_SCR1(%a6),%d6
9638	sub.l		&0x3FFE,%d6
9639	mov.l		%d6,L_SCR1(%a6)
9640	fmov.x		R(%a6),%fp0
9641	mov.w		%d6,Y(%a6)
9642	mov.l		%d4,Y_Hi(%a6)
9643	mov.l		%d5,Y_Lo(%a6)
9644	clr.b		Sc_Flag(%a6)
9645
9646#
9647ModOrRem:
9648	tst.b		Mod_Flag(%a6)
9649	beq.b		Fix_Sign
9650
9651	mov.l		L_SCR1(%a6),%d6		# new biased expo(Y)
9652	subq.l		&1,%d6			# biased expo(Y/2)
9653	cmp.l		%d0,%d6
9654	blt.b		Fix_Sign
9655	bgt.b		Last_Sub
9656
9657	cmp.l		%d1,%d4
9658	bne.b		Not_EQ
9659	cmp.l		%d2,%d5
9660	bne.b		Not_EQ
9661	bra.w		Tie_Case
9662
9663Not_EQ:
9664	bcs.b		Fix_Sign
9665
9666Last_Sub:
9667#
9668	fsub.x		Y(%a6),%fp0		# no exceptions
9669	addq.l		&1,%d3			# Q := Q + 1
9670
9671#
9672Fix_Sign:
9673#..Get sign of X
9674	mov.w		SignX(%a6),%d6
9675	bge.b		Get_Q
9676	fneg.x		%fp0
9677
9678#..Get Q
9679#
9680Get_Q:
9681	clr.l		%d6
9682	mov.w		SignQ(%a6),%d6		# D6 is sign(Q)
9683	mov.l		&8,%d7
9684	lsr.l		%d7,%d6
9685	and.l		&0x0000007F,%d3		# 7 bits of Q
9686	or.l		%d6,%d3			# sign and bits of Q
9687#	swap		%d3
9688#	fmov.l		%fpsr,%d6
9689#	and.l		&0xFF00FFFF,%d6
9690#	or.l		%d3,%d6
9691#	fmov.l		%d6,%fpsr		# put Q in fpsr
9692	mov.b		%d3,FPSR_QBYTE(%a6)	# put Q in fpsr
9693
9694#
9695Restore:
9696	movm.l		(%sp)+,&0xfc		#  {%d2-%d7}
9697	mov.l		(%sp)+,%d0
9698	fmov.l		%d0,%fpcr
9699	tst.b		Sc_Flag(%a6)
9700	beq.b		Finish
9701	mov.b		&FMUL_OP,%d1		# last inst is MUL
9702	fmul.x		Scale(%pc),%fp0		# may cause underflow
9703	bra		t_catch2
9704# the '040 package did this apparently to see if the dst operand for the
9705# preceding fmul was a denorm. but, it better not have been since the
9706# algorithm just got done playing with fp0 and expected no exceptions
9707# as a result. trust me...
9708#	bra		t_avoid_unsupp		# check for denorm as a
9709#						;result of the scaling
9710
9711Finish:
9712	mov.b		&FMOV_OP,%d1		# last inst is MOVE
9713	fmov.x		%fp0,%fp0		# capture exceptions & round
9714	bra		t_catch2
9715
9716Rem_is_0:
9717#..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)
9718	addq.l		&1,%d3
9719	cmp.l		%d0,&8			# D0 is j
9720	bge.b		Q_Big
9721
9722	lsl.l		%d0,%d3
9723	bra.b		Set_R_0
9724
9725Q_Big:
9726	clr.l		%d3
9727
9728Set_R_0:
9729	fmov.s		&0x00000000,%fp0
9730	clr.b		Sc_Flag(%a6)
9731	bra.w		Fix_Sign
9732
9733Tie_Case:
9734#..Check parity of Q
9735	mov.l		%d3,%d6
9736	and.l		&0x00000001,%d6
9737	tst.l		%d6
9738	beq.w		Fix_Sign		# Q is even
9739
9740#..Q is odd, Q := Q + 1, signX := -signX
9741	addq.l		&1,%d3
9742	mov.w		SignX(%a6),%d6
9743	eor.l		&0x00008000,%d6
9744	mov.w		%d6,SignX(%a6)
9745	bra.w		Fix_Sign
9746
9747#########################################################################
9748# XDEF ****************************************************************	#
9749#	tag(): return the optype of the input ext fp number		#
9750#									#
9751#	This routine is used by the 060FPLSP.				#
9752#									#
9753# XREF ****************************************************************	#
9754#	None								#
9755#									#
9756# INPUT ***************************************************************	#
9757#	a0 = pointer to extended precision operand			#
9758#									#
9759# OUTPUT **************************************************************	#
9760#	d0 = value of type tag						#
9761#		one of: NORM, INF, QNAN, SNAN, DENORM, ZERO		#
9762#									#
9763# ALGORITHM ***********************************************************	#
9764#	Simply test the exponent, j-bit, and mantissa values to		#
9765# determine the type of operand.					#
9766#	If it's an unnormalized zero, alter the operand and force it	#
9767# to be a normal zero.							#
9768#									#
9769#########################################################################
9770
9771	global		tag
9772tag:
9773	mov.w		FTEMP_EX(%a0), %d0	# extract exponent
9774	andi.w		&0x7fff, %d0		# strip off sign
9775	cmpi.w		%d0, &0x7fff		# is (EXP == MAX)?
9776	beq.b		inf_or_nan_x
9777not_inf_or_nan_x:
9778	btst		&0x7,FTEMP_HI(%a0)
9779	beq.b		not_norm_x
9780is_norm_x:
9781	mov.b		&NORM, %d0
9782	rts
9783not_norm_x:
9784	tst.w		%d0			# is exponent = 0?
9785	bne.b		is_unnorm_x
9786not_unnorm_x:
9787	tst.l		FTEMP_HI(%a0)
9788	bne.b		is_denorm_x
9789	tst.l		FTEMP_LO(%a0)
9790	bne.b		is_denorm_x
9791is_zero_x:
9792	mov.b		&ZERO, %d0
9793	rts
9794is_denorm_x:
9795	mov.b		&DENORM, %d0
9796	rts
9797is_unnorm_x:
9798	bsr.l		unnorm_fix		# convert to norm,denorm,or zero
9799	rts
9800is_unnorm_reg_x:
9801	mov.b		&UNNORM, %d0
9802	rts
9803inf_or_nan_x:
9804	tst.l		FTEMP_LO(%a0)
9805	bne.b		is_nan_x
9806	mov.l		FTEMP_HI(%a0), %d0
9807	and.l		&0x7fffffff, %d0	# msb is a don't care!
9808	bne.b		is_nan_x
9809is_inf_x:
9810	mov.b		&INF, %d0
9811	rts
9812is_nan_x:
9813	mov.b		&QNAN, %d0
9814	rts
9815
9816#############################################################
9817
9818qnan:	long		0x7fff0000, 0xffffffff, 0xffffffff
9819
9820#########################################################################
9821# XDEF ****************************************************************	#
9822#	t_dz(): Handle 060FPLSP dz exception for "flogn" emulation.	#
9823#	t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation.	#
9824#									#
9825#	These rouitnes are used by the 060FPLSP package.		#
9826#									#
9827# XREF ****************************************************************	#
9828#	None								#
9829#									#
9830# INPUT ***************************************************************	#
9831#	a0 = pointer to extended precision source operand.		#
9832#									#
9833# OUTPUT **************************************************************	#
9834#	fp0 = default DZ result.					#
9835#									#
9836# ALGORITHM ***********************************************************	#
9837#	Transcendental emulation for the 060FPLSP has detected that	#
9838# a DZ exception should occur for the instruction. If DZ is disabled,	#
9839# return the default result.						#
9840#	If DZ is enabled, the dst operand should be returned unscathed	#
9841# in fp0 while fp1 is used to create a DZ exception so that the		#
9842# operating system can log that such an event occurred.			#
9843#									#
9844#########################################################################
9845
9846	global		t_dz
9847t_dz:
9848	tst.b		SRC_EX(%a0)		# check sign for neg or pos
9849	bpl.b		dz_pinf			# branch if pos sign
9850
9851	global		t_dz2
9852t_dz2:
9853	ori.l		&dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZ
9854
9855	btst		&dz_bit,FPCR_ENABLE(%a6)
9856	bne.b		dz_minf_ena
9857
9858# dz is disabled. return a -INF.
9859	fmov.s		&0xff800000,%fp0	# return -INF
9860	rts
9861
9862# dz is enabled. create a dz exception so the user can record it
9863# but use fp1 instead. return the dst operand unscathed in fp0.
9864dz_minf_ena:
9865	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
9866	fmov.l		USER_FPCR(%a6),%fpcr
9867	fmov.s		&0xbf800000,%fp1	# load -1
9868	fdiv.s		&0x00000000,%fp1	# -1 / 0
9869	rts
9870
9871dz_pinf:
9872	ori.l		&dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZ
9873
9874	btst		&dz_bit,FPCR_ENABLE(%a6)
9875	bne.b		dz_pinf_ena
9876
9877# dz is disabled. return a +INF.
9878	fmov.s		&0x7f800000,%fp0	# return +INF
9879	rts
9880
9881# dz is enabled. create a dz exception so the user can record it
9882# but use fp1 instead. return the dst operand unscathed in fp0.
9883dz_pinf_ena:
9884	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
9885	fmov.l		USER_FPCR(%a6),%fpcr
9886	fmov.s		&0x3f800000,%fp1	# load +1
9887	fdiv.s		&0x00000000,%fp1	# +1 / 0
9888	rts
9889
9890#########################################################################
9891# XDEF ****************************************************************	#
9892#	t_operr(): Handle 060FPLSP OPERR exception during emulation.	#
9893#									#
9894#	This routine is used by the 060FPLSP package.			#
9895#									#
9896# XREF ****************************************************************	#
9897#	None.								#
9898#									#
9899# INPUT ***************************************************************	#
9900#	fp1 = source operand						#
9901#									#
9902# OUTPUT **************************************************************	#
9903#	fp0 = default result						#
9904#	fp1 = unchanged							#
9905#									#
9906# ALGORITHM ***********************************************************	#
9907#	An operand error should occur as the result of transcendental	#
9908# emulation in the 060FPLSP. If OPERR is disabled, just return a NAN	#
9909# in fp0. If OPERR is enabled, return the dst operand unscathed in fp0	#
9910# and the source operand in fp1. Use fp2 to create an OPERR exception	#
9911# so that the operating system can log the event.			#
9912#									#
9913#########################################################################
9914
9915	global		t_operr
9916t_operr:
9917	ori.l		&opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOP
9918
9919	btst		&operr_bit,FPCR_ENABLE(%a6)
9920	bne.b		operr_ena
9921
9922# operr is disabled. return a QNAN in fp0
9923	fmovm.x		qnan(%pc),&0x80		# return QNAN
9924	rts
9925
9926# operr is enabled. create an operr exception so the user can record it
9927# but use fp2 instead. return the dst operand unscathed in fp0.
9928operr_ena:
9929	fmovm.x		EXC_FP0(%a6),&0x80	# return fp0 unscathed
9930	fmov.l		USER_FPCR(%a6),%fpcr
9931	fmovm.x		&0x04,-(%sp)		# save fp2
9932	fmov.s		&0x7f800000,%fp2	# load +INF
9933	fmul.s		&0x00000000,%fp2	# +INF x 0
9934	fmovm.x		(%sp)+,&0x20		# restore fp2
9935	rts
9936
9937pls_huge:
9938	long		0x7ffe0000,0xffffffff,0xffffffff
9939mns_huge:
9940	long		0xfffe0000,0xffffffff,0xffffffff
9941pls_tiny:
9942	long		0x00000000,0x80000000,0x00000000
9943mns_tiny:
9944	long		0x80000000,0x80000000,0x00000000
9945
9946#########################################################################
9947# XDEF ****************************************************************	#
9948#	t_unfl(): Handle 060FPLSP underflow exception during emulation.	#
9949#	t_unfl2(): Handle 060FPLSP underflow exception during		#
9950#	           emulation. result always positive.			#
9951#									#
9952#	This routine is used by the 060FPLSP package.			#
9953#									#
9954# XREF ****************************************************************	#
9955#	None.								#
9956#									#
9957# INPUT ***************************************************************	#
9958#	a0 = pointer to extended precision source operand		#
9959#									#
9960# OUTPUT **************************************************************	#
9961#	fp0 = default underflow result					#
9962#									#
9963# ALGORITHM ***********************************************************	#
9964#	An underflow should occur as the result of transcendental	#
9965# emulation in the 060FPLSP. Create an underflow by using "fmul"	#
9966# and two very small numbers of appropriate sign so the operating	#
9967# system can log the event.						#
9968#									#
9969#########################################################################
9970
9971	global		t_unfl
9972t_unfl:
9973	tst.b		SRC_EX(%a0)
9974	bpl.b		unf_pos
9975
9976	global		t_unfl2
9977t_unfl2:
9978	ori.l		&unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEX
9979
9980	fmov.l		USER_FPCR(%a6),%fpcr
9981	fmovm.x		mns_tiny(%pc),&0x80
9982	fmul.x		pls_tiny(%pc),%fp0
9983
9984	fmov.l		%fpsr,%d0
9985	rol.l		&0x8,%d0
9986	mov.b		%d0,FPSR_CC(%a6)
9987	rts
9988unf_pos:
9989	ori.w		&unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEX
9990
9991	fmov.l		USER_FPCR(%a6),%fpcr
9992	fmovm.x		pls_tiny(%pc),&0x80
9993	fmul.x		%fp0,%fp0
9994
9995	fmov.l		%fpsr,%d0
9996	rol.l		&0x8,%d0
9997	mov.b		%d0,FPSR_CC(%a6)
9998	rts
9999
10000#########################################################################
10001# XDEF ****************************************************************	#
10002#	t_ovfl(): Handle 060FPLSP overflow exception during emulation.	#
10003#		  (monadic)						#
10004#	t_ovfl2(): Handle 060FPLSP overflow exception during		#
10005#	           emulation. result always positive. (dyadic)		#
10006#	t_ovfl_sc(): Handle 060FPLSP overflow exception during		#
10007#	             emulation for "fscale".				#
10008#									#
10009#	This routine is used by the 060FPLSP package.			#
10010#									#
10011# XREF ****************************************************************	#
10012#	None.								#
10013#									#
10014# INPUT ***************************************************************	#
10015#	a0 = pointer to extended precision source operand		#
10016#									#
10017# OUTPUT **************************************************************	#
10018#	fp0 = default underflow result					#
10019#									#
10020# ALGORITHM ***********************************************************	#
10021#	An overflow should occur as the result of transcendental	#
10022# emulation in the 060FPLSP. Create an overflow by using "fmul"		#
10023# and two very lareg numbers of appropriate sign so the operating	#
10024# system can log the event.						#
10025#	For t_ovfl_sc() we take special care not to lose the INEX2 bit.	#
10026#									#
10027#########################################################################
10028
10029	global		t_ovfl_sc
10030t_ovfl_sc:
10031	ori.l		&ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEX
10032
10033	mov.b		%d0,%d1			# fetch rnd prec,mode
10034	andi.b		&0xc0,%d1		# extract prec
10035	beq.w		ovfl_work
10036
10037# dst op is a DENORM. we have to normalize the mantissa to see if the
10038# result would be inexact for the given precision. make a copy of the
10039# dst so we don't screw up the version passed to us.
10040	mov.w		LOCAL_EX(%a0),FP_SCR0_EX(%a6)
10041	mov.l		LOCAL_HI(%a0),FP_SCR0_HI(%a6)
10042	mov.l		LOCAL_LO(%a0),FP_SCR0_LO(%a6)
10043	lea		FP_SCR0(%a6),%a0	# pass ptr to FP_SCR0
10044	movm.l		&0xc080,-(%sp)		# save d0-d1/a0
10045	bsr.l		norm			# normalize mantissa
10046	movm.l		(%sp)+,&0x0103		# restore d0-d1/a0
10047
10048	cmpi.b		%d1,&0x40		# is precision sgl?
10049	bne.b		ovfl_sc_dbl		# no; dbl
10050ovfl_sc_sgl:
10051	tst.l		LOCAL_LO(%a0)		# is lo lw of sgl set?
10052	bne.b		ovfl_sc_inx		# yes
10053	tst.b		3+LOCAL_HI(%a0)		# is lo byte of hi lw set?
10054	bne.b		ovfl_sc_inx		# yes
10055	bra.w		ovfl_work		# don't set INEX2
10056ovfl_sc_dbl:
10057	mov.l		LOCAL_LO(%a0),%d1	# are any of lo 11 bits of
10058	andi.l		&0x7ff,%d1		# dbl mantissa set?
10059	beq.w		ovfl_work		# no; don't set INEX2
10060ovfl_sc_inx:
10061	ori.l		&inex2_mask,USER_FPSR(%a6) # set INEX2
10062	bra.b		ovfl_work		# continue
10063
10064	global		t_ovfl
10065t_ovfl:
10066	ori.w		&ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
10067ovfl_work:
10068	tst.b		SRC_EX(%a0)
10069	bpl.b		ovfl_p
10070ovfl_m:
10071	fmov.l		USER_FPCR(%a6),%fpcr
10072	fmovm.x		mns_huge(%pc),&0x80
10073	fmul.x		pls_huge(%pc),%fp0
10074
10075	fmov.l		%fpsr,%d0
10076	rol.l		&0x8,%d0
10077	ori.b		&neg_mask,%d0
10078	mov.b		%d0,FPSR_CC(%a6)
10079	rts
10080ovfl_p:
10081	fmov.l		USER_FPCR(%a6),%fpcr
10082	fmovm.x		pls_huge(%pc),&0x80
10083	fmul.x		pls_huge(%pc),%fp0
10084
10085	fmov.l		%fpsr,%d0
10086	rol.l		&0x8,%d0
10087	mov.b		%d0,FPSR_CC(%a6)
10088	rts
10089
10090	global		t_ovfl2
10091t_ovfl2:
10092	ori.w		&ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
10093	fmov.l		USER_FPCR(%a6),%fpcr
10094	fmovm.x		pls_huge(%pc),&0x80
10095	fmul.x		pls_huge(%pc),%fp0
10096
10097	fmov.l		%fpsr,%d0
10098	rol.l		&0x8,%d0
10099	mov.b		%d0,FPSR_CC(%a6)
10100	rts
10101
10102#########################################################################
10103# XDEF ****************************************************************	#
10104#	t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during	#
10105#		   emulation.						#
10106#	t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during	#
10107#		    emulation.						#
10108#									#
10109#	These routines are used by the 060FPLSP package.		#
10110#									#
10111# XREF ****************************************************************	#
10112#	None.								#
10113#									#
10114# INPUT ***************************************************************	#
10115#	fp0 = default underflow or overflow result			#
10116#									#
10117# OUTPUT **************************************************************	#
10118#	fp0 = default result						#
10119#									#
10120# ALGORITHM ***********************************************************	#
10121#	If an overflow or underflow occurred during the last		#
10122# instruction of transcendental 060FPLSP emulation, then it has already	#
10123# occurred and has been logged. Now we need to see if an inexact	#
10124# exception should occur.						#
10125#									#
10126#########################################################################
10127
10128	global		t_catch2
10129t_catch2:
10130	fmov.l		%fpsr,%d0
10131	or.l		%d0,USER_FPSR(%a6)
10132	bra.b		inx2_work
10133
10134	global		t_catch
10135t_catch:
10136	fmov.l		%fpsr,%d0
10137	or.l		%d0,USER_FPSR(%a6)
10138
10139#########################################################################
10140# XDEF ****************************************************************	#
10141#	t_inx2(): Handle inexact 060FPLSP exception during emulation.	#
10142#	t_pinx2(): Handle inexact 060FPLSP exception for "+" results.	#
10143#	t_minx2(): Handle inexact 060FPLSP exception for "-" results.	#
10144#									#
10145# XREF ****************************************************************	#
10146#	None.								#
10147#									#
10148# INPUT ***************************************************************	#
10149#	fp0 = default result						#
10150#									#
10151# OUTPUT **************************************************************	#
10152#	fp0 = default result						#
10153#									#
10154# ALGORITHM ***********************************************************	#
10155#	The last instruction of transcendental emulation for the	#
10156# 060FPLSP should be inexact. So, if inexact is enabled, then we create	#
10157# the event here by adding a large and very small number together	#
10158# so that the operating system can log the event.			#
10159#	Must check, too, if the result was zero, in which case we just	#
10160# set the FPSR bits and return.						#
10161#									#
10162#########################################################################
10163
10164	global		t_inx2
10165t_inx2:
10166	fblt.w		t_minx2
10167	fbeq.w		inx2_zero
10168
10169	global		t_pinx2
10170t_pinx2:
10171	ori.w		&inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX
10172	bra.b		inx2_work
10173
10174	global		t_minx2
10175t_minx2:
10176	ori.l		&inx2a_mask+neg_mask,USER_FPSR(%a6)
10177
10178inx2_work:
10179	btst		&inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?
10180	bne.b		inx2_work_ena		# yes
10181	rts
10182inx2_work_ena:
10183	fmov.l		USER_FPCR(%a6),%fpcr	# insert user's exceptions
10184	fmov.s		&0x3f800000,%fp1	# load +1
10185	fadd.x		pls_tiny(%pc),%fp1	# cause exception
10186	rts
10187
10188inx2_zero:
10189	mov.b		&z_bmask,FPSR_CC(%a6)
10190	ori.w		&inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEX
10191	rts
10192
10193#########################################################################
10194# XDEF ****************************************************************	#
10195#	t_extdnrm(): Handle DENORM inputs in 060FPLSP.			#
10196#	t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale".	#
10197#									#
10198#	This routine is used by the 060FPLSP package.			#
10199#									#
10200# XREF ****************************************************************	#
10201#	None.								#
10202#									#
10203# INPUT ***************************************************************	#
10204#	a0 = pointer to extended precision input operand		#
10205#									#
10206# OUTPUT **************************************************************	#
10207#	fp0 = default result						#
10208#									#
10209# ALGORITHM ***********************************************************	#
10210#	For all functions that have a denormalized input and that	#
10211# f(x)=x, this is the entry point.					#
10212#	DENORM value is moved using "fmove" which triggers an exception	#
10213# if enabled so the operating system can log the event.			#
10214#									#
10215#########################################################################
10216
10217	global		t_extdnrm
10218t_extdnrm:
10219	fmov.l		USER_FPCR(%a6),%fpcr
10220	fmov.x		SRC_EX(%a0),%fp0
10221	fmov.l		%fpsr,%d0
10222	ori.l		&unfinx_mask,%d0
10223	or.l		%d0,USER_FPSR(%a6)
10224	rts
10225
10226	global		t_resdnrm
10227t_resdnrm:
10228	fmov.l		USER_FPCR(%a6),%fpcr
10229	fmov.x		SRC_EX(%a0),%fp0
10230	fmov.l		%fpsr,%d0
10231	or.l		%d0,USER_FPSR(%a6)
10232	rts
10233
10234##########################################
10235
10236#
10237# sto_cos:
10238#	This is used by fsincos library emulation. The correct
10239# values are already in fp0 and fp1 so we do nothing here.
10240#
10241	global		sto_cos
10242sto_cos:
10243	rts
10244
10245##########################################
10246
10247#
10248#	dst_qnan --- force result when destination is a NaN
10249#
10250	global		dst_qnan
10251dst_qnan:
10252	fmov.x		DST(%a1),%fp0
10253	tst.b		DST_EX(%a1)
10254	bmi.b		dst_qnan_m
10255dst_qnan_p:
10256	mov.b		&nan_bmask,FPSR_CC(%a6)
10257	rts
10258dst_qnan_m:
10259	mov.b		&nan_bmask+neg_bmask,FPSR_CC(%a6)
10260	rts
10261
10262#
10263#	src_qnan --- force result when source is a NaN
10264#
10265	global		src_qnan
10266src_qnan:
10267	fmov.x		SRC(%a0),%fp0
10268	tst.b		SRC_EX(%a0)
10269	bmi.b		src_qnan_m
10270src_qnan_p:
10271	mov.b		&nan_bmask,FPSR_CC(%a6)
10272	rts
10273src_qnan_m:
10274	mov.b		&nan_bmask+neg_bmask,FPSR_CC(%a6)
10275	rts
10276
10277##########################################
10278
10279#
10280#	Native instruction support
10281#
10282#	Some systems may need entry points even for 68060 native
10283#	instructions.  These routines are provided for
10284#	convenience.
10285#
10286	global		_fadds_
10287_fadds_:
10288	fmov.l		%fpcr,-(%sp)		# save fpcr
10289	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10290	fmov.s		0x8(%sp),%fp0		# load sgl dst
10291	fmov.l		(%sp)+,%fpcr		# restore fpcr
10292	fadd.s		0x8(%sp),%fp0		# fadd w/ sgl src
10293	rts
10294
10295	global		_faddd_
10296_faddd_:
10297	fmov.l		%fpcr,-(%sp)		# save fpcr
10298	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10299	fmov.d		0x8(%sp),%fp0		# load dbl dst
10300	fmov.l		(%sp)+,%fpcr		# restore fpcr
10301	fadd.d		0xc(%sp),%fp0		# fadd w/ dbl src
10302	rts
10303
10304	global		_faddx_
10305_faddx_:
10306	fmovm.x		0x4(%sp),&0x80		# load ext dst
10307	fadd.x		0x10(%sp),%fp0		# fadd w/ ext src
10308	rts
10309
10310	global		_fsubs_
10311_fsubs_:
10312	fmov.l		%fpcr,-(%sp)		# save fpcr
10313	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10314	fmov.s		0x8(%sp),%fp0		# load sgl dst
10315	fmov.l		(%sp)+,%fpcr		# restore fpcr
10316	fsub.s		0x8(%sp),%fp0		# fsub w/ sgl src
10317	rts
10318
10319	global		_fsubd_
10320_fsubd_:
10321	fmov.l		%fpcr,-(%sp)		# save fpcr
10322	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10323	fmov.d		0x8(%sp),%fp0		# load dbl dst
10324	fmov.l		(%sp)+,%fpcr		# restore fpcr
10325	fsub.d		0xc(%sp),%fp0		# fsub w/ dbl src
10326	rts
10327
10328	global		_fsubx_
10329_fsubx_:
10330	fmovm.x		0x4(%sp),&0x80		# load ext dst
10331	fsub.x		0x10(%sp),%fp0		# fsub w/ ext src
10332	rts
10333
10334	global		_fmuls_
10335_fmuls_:
10336	fmov.l		%fpcr,-(%sp)		# save fpcr
10337	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10338	fmov.s		0x8(%sp),%fp0		# load sgl dst
10339	fmov.l		(%sp)+,%fpcr		# restore fpcr
10340	fmul.s		0x8(%sp),%fp0		# fmul w/ sgl src
10341	rts
10342
10343	global		_fmuld_
10344_fmuld_:
10345	fmov.l		%fpcr,-(%sp)		# save fpcr
10346	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10347	fmov.d		0x8(%sp),%fp0		# load dbl dst
10348	fmov.l		(%sp)+,%fpcr		# restore fpcr
10349	fmul.d		0xc(%sp),%fp0		# fmul w/ dbl src
10350	rts
10351
10352	global		_fmulx_
10353_fmulx_:
10354	fmovm.x		0x4(%sp),&0x80		# load ext dst
10355	fmul.x		0x10(%sp),%fp0		# fmul w/ ext src
10356	rts
10357
10358	global		_fdivs_
10359_fdivs_:
10360	fmov.l		%fpcr,-(%sp)		# save fpcr
10361	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10362	fmov.s		0x8(%sp),%fp0		# load sgl dst
10363	fmov.l		(%sp)+,%fpcr		# restore fpcr
10364	fdiv.s		0x8(%sp),%fp0		# fdiv w/ sgl src
10365	rts
10366
10367	global		_fdivd_
10368_fdivd_:
10369	fmov.l		%fpcr,-(%sp)		# save fpcr
10370	fmov.l		&0x00000000,%fpcr	# clear fpcr for load
10371	fmov.d		0x8(%sp),%fp0		# load dbl dst
10372	fmov.l		(%sp)+,%fpcr		# restore fpcr
10373	fdiv.d		0xc(%sp),%fp0		# fdiv w/ dbl src
10374	rts
10375
10376	global		_fdivx_
10377_fdivx_:
10378	fmovm.x		0x4(%sp),&0x80		# load ext dst
10379	fdiv.x		0x10(%sp),%fp0		# fdiv w/ ext src
10380	rts
10381
10382	global		_fabss_
10383_fabss_:
10384	fabs.s		0x4(%sp),%fp0		# fabs w/ sgl src
10385	rts
10386
10387	global		_fabsd_
10388_fabsd_:
10389	fabs.d		0x4(%sp),%fp0		# fabs w/ dbl src
10390	rts
10391
10392	global		_fabsx_
10393_fabsx_:
10394	fabs.x		0x4(%sp),%fp0		# fabs w/ ext src
10395	rts
10396
10397	global		_fnegs_
10398_fnegs_:
10399	fneg.s		0x4(%sp),%fp0		# fneg w/ sgl src
10400	rts
10401
10402	global		_fnegd_
10403_fnegd_:
10404	fneg.d		0x4(%sp),%fp0		# fneg w/ dbl src
10405	rts
10406
10407	global		_fnegx_
10408_fnegx_:
10409	fneg.x		0x4(%sp),%fp0		# fneg w/ ext src
10410	rts
10411
10412	global		_fsqrts_
10413_fsqrts_:
10414	fsqrt.s		0x4(%sp),%fp0		# fsqrt w/ sgl src
10415	rts
10416
10417	global		_fsqrtd_
10418_fsqrtd_:
10419	fsqrt.d		0x4(%sp),%fp0		# fsqrt w/ dbl src
10420	rts
10421
10422	global		_fsqrtx_
10423_fsqrtx_:
10424	fsqrt.x		0x4(%sp),%fp0		# fsqrt w/ ext src
10425	rts
10426
10427	global		_fints_
10428_fints_:
10429	fint.s		0x4(%sp),%fp0		# fint w/ sgl src
10430	rts
10431
10432	global		_fintd_
10433_fintd_:
10434	fint.d		0x4(%sp),%fp0		# fint w/ dbl src
10435	rts
10436
10437	global		_fintx_
10438_fintx_:
10439	fint.x		0x4(%sp),%fp0		# fint w/ ext src
10440	rts
10441
10442	global		_fintrzs_
10443_fintrzs_:
10444	fintrz.s	0x4(%sp),%fp0		# fintrz w/ sgl src
10445	rts
10446
10447	global		_fintrzd_
10448_fintrzd_:
10449	fintrz.d	0x4(%sp),%fp0		# fintrx w/ dbl src
10450	rts
10451
10452	global		_fintrzx_
10453_fintrzx_:
10454	fintrz.x	0x4(%sp),%fp0		# fintrz w/ ext src
10455	rts
10456
10457########################################################################
10458
10459#########################################################################
10460# src_zero(): Return signed zero according to sign of src operand.	#
10461#########################################################################
10462	global		src_zero
10463src_zero:
10464	tst.b		SRC_EX(%a0)		# get sign of src operand
10465	bmi.b		ld_mzero		# if neg, load neg zero
10466
10467#
10468# ld_pzero(): return a positive zero.
10469#
10470	global		ld_pzero
10471ld_pzero:
10472	fmov.s		&0x00000000,%fp0	# load +0
10473	mov.b		&z_bmask,FPSR_CC(%a6)	# set 'Z' ccode bit
10474	rts
10475
10476# ld_mzero(): return a negative zero.
10477	global		ld_mzero
10478ld_mzero:
10479	fmov.s		&0x80000000,%fp0	# load -0
10480	mov.b		&neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bits
10481	rts
10482
10483#########################################################################
10484# dst_zero(): Return signed zero according to sign of dst operand.	#
10485#########################################################################
10486	global		dst_zero
10487dst_zero:
10488	tst.b		DST_EX(%a1)		# get sign of dst operand
10489	bmi.b		ld_mzero		# if neg, load neg zero
10490	bra.b		ld_pzero		# load positive zero
10491
10492#########################################################################
10493# src_inf(): Return signed inf according to sign of src operand.	#
10494#########################################################################
10495	global		src_inf
10496src_inf:
10497	tst.b		SRC_EX(%a0)		# get sign of src operand
10498	bmi.b		ld_minf			# if negative branch
10499
10500#
10501# ld_pinf(): return a positive infinity.
10502#
10503	global		ld_pinf
10504ld_pinf:
10505	fmov.s		&0x7f800000,%fp0	# load +INF
10506	mov.b		&inf_bmask,FPSR_CC(%a6)	# set 'INF' ccode bit
10507	rts
10508
10509#
10510# ld_minf():return a negative infinity.
10511#
10512	global		ld_minf
10513ld_minf:
10514	fmov.s		&0xff800000,%fp0	# load -INF
10515	mov.b		&neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bits
10516	rts
10517
10518#########################################################################
10519# dst_inf(): Return signed inf according to sign of dst operand.	#
10520#########################################################################
10521	global		dst_inf
10522dst_inf:
10523	tst.b		DST_EX(%a1)		# get sign of dst operand
10524	bmi.b		ld_minf			# if negative branch
10525	bra.b		ld_pinf
10526
10527	global		szr_inf
10528#################################################################
10529# szr_inf(): Return +ZERO for a negative src operand or		#
10530#	            +INF for a positive src operand.		#
10531#	     Routine used for fetox, ftwotox, and ftentox.	#
10532#################################################################
10533szr_inf:
10534	tst.b		SRC_EX(%a0)		# check sign of source
10535	bmi.b		ld_pzero
10536	bra.b		ld_pinf
10537
10538#########################################################################
10539# sopr_inf(): Return +INF for a positive src operand or			#
10540#	      jump to operand error routine for a negative src operand.	#
10541#	      Routine used for flogn, flognp1, flog10, and flog2.	#
10542#########################################################################
10543	global		sopr_inf
10544sopr_inf:
10545	tst.b		SRC_EX(%a0)		# check sign of source
10546	bmi.w		t_operr
10547	bra.b		ld_pinf
10548
10549#################################################################
10550# setoxm1i(): Return minus one for a negative src operand or	#
10551#	      positive infinity for a positive src operand.	#
10552#	      Routine used for fetoxm1.				#
10553#################################################################
10554	global		setoxm1i
10555setoxm1i:
10556	tst.b		SRC_EX(%a0)		# check sign of source
10557	bmi.b		ld_mone
10558	bra.b		ld_pinf
10559
10560#########################################################################
10561# src_one(): Return signed one according to sign of src operand.	#
10562#########################################################################
10563	global		src_one
10564src_one:
10565	tst.b		SRC_EX(%a0)		# check sign of source
10566	bmi.b		ld_mone
10567
10568#
10569# ld_pone(): return positive one.
10570#
10571	global		ld_pone
10572ld_pone:
10573	fmov.s		&0x3f800000,%fp0	# load +1
10574	clr.b		FPSR_CC(%a6)
10575	rts
10576
10577#
10578# ld_mone(): return negative one.
10579#
10580	global		ld_mone
10581ld_mone:
10582	fmov.s		&0xbf800000,%fp0	# load -1
10583	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' ccode bit
10584	rts
10585
10586ppiby2:	long		0x3fff0000, 0xc90fdaa2, 0x2168c235
10587mpiby2:	long		0xbfff0000, 0xc90fdaa2, 0x2168c235
10588
10589#################################################################
10590# spi_2(): Return signed PI/2 according to sign of src operand.	#
10591#################################################################
10592	global		spi_2
10593spi_2:
10594	tst.b		SRC_EX(%a0)		# check sign of source
10595	bmi.b		ld_mpi2
10596
10597#
10598# ld_ppi2(): return positive PI/2.
10599#
10600	global		ld_ppi2
10601ld_ppi2:
10602	fmov.l		%d0,%fpcr
10603	fmov.x		ppiby2(%pc),%fp0	# load +pi/2
10604	bra.w		t_pinx2			# set INEX2
10605
10606#
10607# ld_mpi2(): return negative PI/2.
10608#
10609	global		ld_mpi2
10610ld_mpi2:
10611	fmov.l		%d0,%fpcr
10612	fmov.x		mpiby2(%pc),%fp0	# load -pi/2
10613	bra.w		t_minx2			# set INEX2
10614
10615####################################################
10616# The following routines give support for fsincos. #
10617####################################################
10618
10619#
10620# ssincosz(): When the src operand is ZERO, store a one in the
10621#	      cosine register and return a ZERO in fp0 w/ the same sign
10622#	      as the src operand.
10623#
10624	global		ssincosz
10625ssincosz:
10626	fmov.s		&0x3f800000,%fp1
10627	tst.b		SRC_EX(%a0)		# test sign
10628	bpl.b		sincoszp
10629	fmov.s		&0x80000000,%fp0	# return sin result in fp0
10630	mov.b		&z_bmask+neg_bmask,FPSR_CC(%a6)
10631	rts
10632sincoszp:
10633	fmov.s		&0x00000000,%fp0	# return sin result in fp0
10634	mov.b		&z_bmask,FPSR_CC(%a6)
10635	rts
10636
10637#
10638# ssincosi(): When the src operand is INF, store a QNAN in the cosine
10639#	      register and jump to the operand error routine for negative
10640#	      src operands.
10641#
10642	global		ssincosi
10643ssincosi:
10644	fmov.x		qnan(%pc),%fp1		# load NAN
10645	bra.w		t_operr
10646
10647#
10648# ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine
10649#		 register and branch to the src QNAN routine.
10650#
10651	global		ssincosqnan
10652ssincosqnan:
10653	fmov.x		LOCAL_EX(%a0),%fp1
10654	bra.w		src_qnan
10655
10656########################################################################
10657
10658	global		smod_sdnrm
10659	global		smod_snorm
10660smod_sdnrm:
10661smod_snorm:
10662	mov.b		DTAG(%a6),%d1
10663	beq.l		smod
10664	cmpi.b		%d1,&ZERO
10665	beq.w		smod_zro
10666	cmpi.b		%d1,&INF
10667	beq.l		t_operr
10668	cmpi.b		%d1,&DENORM
10669	beq.l		smod
10670	bra.l		dst_qnan
10671
10672	global		smod_szero
10673smod_szero:
10674	mov.b		DTAG(%a6),%d1
10675	beq.l		t_operr
10676	cmpi.b		%d1,&ZERO
10677	beq.l		t_operr
10678	cmpi.b		%d1,&INF
10679	beq.l		t_operr
10680	cmpi.b		%d1,&DENORM
10681	beq.l		t_operr
10682	bra.l		dst_qnan
10683
10684	global		smod_sinf
10685smod_sinf:
10686	mov.b		DTAG(%a6),%d1
10687	beq.l		smod_fpn
10688	cmpi.b		%d1,&ZERO
10689	beq.l		smod_zro
10690	cmpi.b		%d1,&INF
10691	beq.l		t_operr
10692	cmpi.b		%d1,&DENORM
10693	beq.l		smod_fpn
10694	bra.l		dst_qnan
10695
10696smod_zro:
10697srem_zro:
10698	mov.b		SRC_EX(%a0),%d1		# get src sign
10699	mov.b		DST_EX(%a1),%d0		# get dst sign
10700	eor.b		%d0,%d1			# get qbyte sign
10701	andi.b		&0x80,%d1
10702	mov.b		%d1,FPSR_QBYTE(%a6)
10703	tst.b		%d0
10704	bpl.w		ld_pzero
10705	bra.w		ld_mzero
10706
10707smod_fpn:
10708srem_fpn:
10709	clr.b		FPSR_QBYTE(%a6)
10710	mov.l		%d0,-(%sp)
10711	mov.b		SRC_EX(%a0),%d1		# get src sign
10712	mov.b		DST_EX(%a1),%d0		# get dst sign
10713	eor.b		%d0,%d1			# get qbyte sign
10714	andi.b		&0x80,%d1
10715	mov.b		%d1,FPSR_QBYTE(%a6)
10716	cmpi.b		DTAG(%a6),&DENORM
10717	bne.b		smod_nrm
10718	lea		DST(%a1),%a0
10719	mov.l		(%sp)+,%d0
10720	bra		t_resdnrm
10721smod_nrm:
10722	fmov.l		(%sp)+,%fpcr
10723	fmov.x		DST(%a1),%fp0
10724	tst.b		DST_EX(%a1)
10725	bmi.b		smod_nrm_neg
10726	rts
10727
10728smod_nrm_neg:
10729	mov.b		&neg_bmask,FPSR_CC(%a6)	# set 'N' code
10730	rts
10731
10732#########################################################################
10733	global		srem_snorm
10734	global		srem_sdnrm
10735srem_sdnrm:
10736srem_snorm:
10737	mov.b		DTAG(%a6),%d1
10738	beq.l		srem
10739	cmpi.b		%d1,&ZERO
10740	beq.w		srem_zro
10741	cmpi.b		%d1,&INF
10742	beq.l		t_operr
10743	cmpi.b		%d1,&DENORM
10744	beq.l		srem
10745	bra.l		dst_qnan
10746
10747	global		srem_szero
10748srem_szero:
10749	mov.b		DTAG(%a6),%d1
10750	beq.l		t_operr
10751	cmpi.b		%d1,&ZERO
10752	beq.l		t_operr
10753	cmpi.b		%d1,&INF
10754	beq.l		t_operr
10755	cmpi.b		%d1,&DENORM
10756	beq.l		t_operr
10757	bra.l		dst_qnan
10758
10759	global		srem_sinf
10760srem_sinf:
10761	mov.b		DTAG(%a6),%d1
10762	beq.w		srem_fpn
10763	cmpi.b		%d1,&ZERO
10764	beq.w		srem_zro
10765	cmpi.b		%d1,&INF
10766	beq.l		t_operr
10767	cmpi.b		%d1,&DENORM
10768	beq.l		srem_fpn
10769	bra.l		dst_qnan
10770
10771#########################################################################
10772
10773	global		sscale_snorm
10774	global		sscale_sdnrm
10775sscale_snorm:
10776sscale_sdnrm:
10777	mov.b		DTAG(%a6),%d1
10778	beq.l		sscale
10779	cmpi.b		%d1,&ZERO
10780	beq.l		dst_zero
10781	cmpi.b		%d1,&INF
10782	beq.l		dst_inf
10783	cmpi.b		%d1,&DENORM
10784	beq.l		sscale
10785	bra.l		dst_qnan
10786
10787	global		sscale_szero
10788sscale_szero:
10789	mov.b		DTAG(%a6),%d1
10790	beq.l		sscale
10791	cmpi.b		%d1,&ZERO
10792	beq.l		dst_zero
10793	cmpi.b		%d1,&INF
10794	beq.l		dst_inf
10795	cmpi.b		%d1,&DENORM
10796	beq.l		sscale
10797	bra.l		dst_qnan
10798
10799	global		sscale_sinf
10800sscale_sinf:
10801	mov.b		DTAG(%a6),%d1
10802	beq.l		t_operr
10803	cmpi.b		%d1,&QNAN
10804	beq.l		dst_qnan
10805	bra.l		t_operr
10806
10807########################################################################
10808
10809	global		sop_sqnan
10810sop_sqnan:
10811	mov.b		DTAG(%a6),%d1
10812	cmpi.b		%d1,&QNAN
10813	beq.l		dst_qnan
10814	bra.l		src_qnan
10815
10816#########################################################################
10817# norm(): normalize the mantissa of an extended precision input. the	#
10818#	  input operand should not be normalized already.		#
10819#									#
10820# XDEF ****************************************************************	#
10821#	norm()								#
10822#									#
10823# XREF **************************************************************** #
10824#	none								#
10825#									#
10826# INPUT *************************************************************** #
10827#	a0 = pointer fp extended precision operand to normalize		#
10828#									#
10829# OUTPUT ************************************************************** #
10830#	d0 = number of bit positions the mantissa was shifted		#
10831#	a0 = the input operand's mantissa is normalized; the exponent	#
10832#	     is unchanged.						#
10833#									#
10834#########################################################################
10835	global		norm
10836norm:
10837	mov.l		%d2, -(%sp)		# create some temp regs
10838	mov.l		%d3, -(%sp)
10839
10840	mov.l		FTEMP_HI(%a0), %d0	# load hi(mantissa)
10841	mov.l		FTEMP_LO(%a0), %d1	# load lo(mantissa)
10842
10843	bfffo		%d0{&0:&32}, %d2	# how many places to shift?
10844	beq.b		norm_lo			# hi(man) is all zeroes!
10845
10846norm_hi:
10847	lsl.l		%d2, %d0		# left shift hi(man)
10848	bfextu		%d1{&0:%d2}, %d3	# extract lo bits
10849
10850	or.l		%d3, %d0		# create hi(man)
10851	lsl.l		%d2, %d1		# create lo(man)
10852
10853	mov.l		%d0, FTEMP_HI(%a0)	# store new hi(man)
10854	mov.l		%d1, FTEMP_LO(%a0)	# store new lo(man)
10855
10856	mov.l		%d2, %d0		# return shift amount
10857
10858	mov.l		(%sp)+, %d3		# restore temp regs
10859	mov.l		(%sp)+, %d2
10860
10861	rts
10862
10863norm_lo:
10864	bfffo		%d1{&0:&32}, %d2	# how many places to shift?
10865	lsl.l		%d2, %d1		# shift lo(man)
10866	add.l		&32, %d2		# add 32 to shft amount
10867
10868	mov.l		%d1, FTEMP_HI(%a0)	# store hi(man)
10869	clr.l		FTEMP_LO(%a0)		# lo(man) is now zero
10870
10871	mov.l		%d2, %d0		# return shift amount
10872
10873	mov.l		(%sp)+, %d3		# restore temp regs
10874	mov.l		(%sp)+, %d2
10875
10876	rts
10877
10878#########################################################################
10879# unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO	#
10880#		- returns corresponding optype tag			#
10881#									#
10882# XDEF ****************************************************************	#
10883#	unnorm_fix()							#
10884#									#
10885# XREF **************************************************************** #
10886#	norm() - normalize the mantissa					#
10887#									#
10888# INPUT *************************************************************** #
10889#	a0 = pointer to unnormalized extended precision number		#
10890#									#
10891# OUTPUT ************************************************************** #
10892#	d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO	#
10893#	a0 = input operand has been converted to a norm, denorm, or	#
10894#	     zero; both the exponent and mantissa are changed.		#
10895#									#
10896#########################################################################
10897
10898	global		unnorm_fix
10899unnorm_fix:
10900	bfffo		FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed?
10901	bne.b		unnorm_shift		# hi(man) is not all zeroes
10902
10903#
10904# hi(man) is all zeroes so see if any bits in lo(man) are set
10905#
10906unnorm_chk_lo:
10907	bfffo		FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?
10908	beq.w		unnorm_zero		# yes
10909
10910	add.w		&32, %d0		# no; fix shift distance
10911
10912#
10913# d0 = # shifts needed for complete normalization
10914#
10915unnorm_shift:
10916	clr.l		%d1			# clear top word
10917	mov.w		FTEMP_EX(%a0), %d1	# extract exponent
10918	and.w		&0x7fff, %d1		# strip off sgn
10919
10920	cmp.w		%d0, %d1		# will denorm push exp < 0?
10921	bgt.b		unnorm_nrm_zero		# yes; denorm only until exp = 0
10922
10923#
10924# exponent would not go < 0. therefore, number stays normalized
10925#
10926	sub.w		%d0, %d1		# shift exponent value
10927	mov.w		FTEMP_EX(%a0), %d0	# load old exponent
10928	and.w		&0x8000, %d0		# save old sign
10929	or.w		%d0, %d1		# {sgn,new exp}
10930	mov.w		%d1, FTEMP_EX(%a0)	# insert new exponent
10931
10932	bsr.l		norm			# normalize UNNORM
10933
10934	mov.b		&NORM, %d0		# return new optype tag
10935	rts
10936
10937#
10938# exponent would go < 0, so only denormalize until exp = 0
10939#
10940unnorm_nrm_zero:
10941	cmp.b		%d1, &32		# is exp <= 32?
10942	bgt.b		unnorm_nrm_zero_lrg	# no; go handle large exponent
10943
10944	bfextu		FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man)
10945	mov.l		%d0, FTEMP_HI(%a0)	# save new hi(man)
10946
10947	mov.l		FTEMP_LO(%a0), %d0	# fetch old lo(man)
10948	lsl.l		%d1, %d0		# extract new lo(man)
10949	mov.l		%d0, FTEMP_LO(%a0)	# save new lo(man)
10950
10951	and.w		&0x8000, FTEMP_EX(%a0)	# set exp = 0
10952
10953	mov.b		&DENORM, %d0		# return new optype tag
10954	rts
10955
10956#
10957# only mantissa bits set are in lo(man)
10958#
10959unnorm_nrm_zero_lrg:
10960	sub.w		&32, %d1		# adjust shft amt by 32
10961
10962	mov.l		FTEMP_LO(%a0), %d0	# fetch old lo(man)
10963	lsl.l		%d1, %d0		# left shift lo(man)
10964
10965	mov.l		%d0, FTEMP_HI(%a0)	# store new hi(man)
10966	clr.l		FTEMP_LO(%a0)		# lo(man) = 0
10967
10968	and.w		&0x8000, FTEMP_EX(%a0)	# set exp = 0
10969
10970	mov.b		&DENORM, %d0		# return new optype tag
10971	rts
10972
10973#
10974# whole mantissa is zero so this UNNORM is actually a zero
10975#
10976unnorm_zero:
10977	and.w		&0x8000, FTEMP_EX(%a0)	# force exponent to zero
10978
10979	mov.b		&ZERO, %d0		# fix optype tag
10980	rts
10981