Blame - arch/m68k/ifpsp060/src/fplsp.S - android_kernel_lge_hammerhead

blob: fdb79b927ef1671e63f1a1bf9b73487b524adc8e [file] [log] [blame]

Linus Torvalds	1da177e	2005-04-16 15:20:36 -0700	[diff] [blame]	1	~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
				2	MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
				3	M68000 Hi-Performance Microprocessor Division
				4	M68060 Software Package
				5	Production Release P1.00 -- October 10, 1994
				6
				7	M68060 Software Package Copyright © 1993, 1994 Motorola Inc. All rights reserved.
				8
				9	THE SOFTWARE is provided on an "AS IS" basis and without warranty.
				10	To the maximum extent permitted by applicable law,
				11	MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
				12	INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
				13	and any warranty against infringement with regard to the SOFTWARE
				14	(INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.
				15
				16	To the maximum extent permitted by applicable law,
				17	IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
				18	(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
				19	BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
				20	ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
				21	Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.
				22
				23	You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
				24	so long as this entire notice is retained without alteration in any modified and/or
				25	redistributed versions, and that such modified versions are clearly identified as such.
				26	No licenses are granted by implication, estoppel or otherwise under any patents
				27	or 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
				275	set LOCAL_SIZE, 192 # stack frame size(bytes)
				276	set LV, -LOCAL_SIZE # stack offset
				277
				278	set EXC_SR, 0x4 # stack status register
				279	set EXC_PC, 0x6 # stack pc
				280	set EXC_VOFF, 0xa # stacked vector offset
				281	set EXC_EA, 0xc # stacked <ea>
				282
				283	set EXC_FP, 0x0 # frame pointer
				284
				285	set EXC_AREGS, -68 # offset of all address regs
				286	set EXC_DREGS, -100 # offset of all data regs
				287	set EXC_FPREGS, -36 # offset of all fp regs
				288
				289	set EXC_A7, EXC_AREGS+(7*4) # offset of saved a7
				290	set OLD_A7, EXC_AREGS+(6*4) # extra copy of saved a7
				291	set EXC_A6, EXC_AREGS+(6*4) # offset of saved a6
				292	set EXC_A5, EXC_AREGS+(5*4)
				293	set EXC_A4, EXC_AREGS+(4*4)
				294	set EXC_A3, EXC_AREGS+(3*4)
				295	set EXC_A2, EXC_AREGS+(2*4)
				296	set EXC_A1, EXC_AREGS+(1*4)
				297	set EXC_A0, EXC_AREGS+(0*4)
				298	set EXC_D7, EXC_DREGS+(7*4)
				299	set EXC_D6, EXC_DREGS+(6*4)
				300	set EXC_D5, EXC_DREGS+(5*4)
				301	set EXC_D4, EXC_DREGS+(4*4)
				302	set EXC_D3, EXC_DREGS+(3*4)
				303	set EXC_D2, EXC_DREGS+(2*4)
				304	set EXC_D1, EXC_DREGS+(1*4)
				305	set EXC_D0, EXC_DREGS+(0*4)
				306
				307	set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0
				308	set EXC_FP1, EXC_FPREGS+(1*12) # offset of saved fp1
				309	set EXC_FP2, EXC_FPREGS+(2*12) # offset of saved fp2 (not used)
				310
				311	set FP_SCR1, LV+80 # fp scratch 1
				312	set FP_SCR1_EX, FP_SCR1+0
				313	set FP_SCR1_SGN, FP_SCR1+2
				314	set FP_SCR1_HI, FP_SCR1+4
				315	set FP_SCR1_LO, FP_SCR1+8
				316
				317	set FP_SCR0, LV+68 # fp scratch 0
				318	set FP_SCR0_EX, FP_SCR0+0
				319	set FP_SCR0_SGN, FP_SCR0+2
				320	set FP_SCR0_HI, FP_SCR0+4
				321	set FP_SCR0_LO, FP_SCR0+8
				322
				323	set FP_DST, LV+56 # fp destination operand
				324	set FP_DST_EX, FP_DST+0
				325	set FP_DST_SGN, FP_DST+2
				326	set FP_DST_HI, FP_DST+4
				327	set FP_DST_LO, FP_DST+8
				328
				329	set FP_SRC, LV+44 # fp source operand
				330	set FP_SRC_EX, FP_SRC+0
				331	set FP_SRC_SGN, FP_SRC+2
				332	set FP_SRC_HI, FP_SRC+4
				333	set FP_SRC_LO, FP_SRC+8
				334
				335	set USER_FPIAR, LV+40 # FP instr address register
				336
				337	set USER_FPSR, LV+36 # FP status register
				338	set FPSR_CC, USER_FPSR+0 # FPSR condition codes
				339	set FPSR_QBYTE, USER_FPSR+1 # FPSR qoutient byte
				340	set FPSR_EXCEPT, USER_FPSR+2 # FPSR exception status byte
				341	set FPSR_AEXCEPT, USER_FPSR+3 # FPSR accrued exception byte
				342
				343	set USER_FPCR, LV+32 # FP control register
				344	set FPCR_ENABLE, USER_FPCR+2 # FPCR exception enable
				345	set FPCR_MODE, USER_FPCR+3 # FPCR rounding mode control
				346
				347	set L_SCR3, LV+28 # integer scratch 3
				348	set L_SCR2, LV+24 # integer scratch 2
				349	set L_SCR1, LV+20 # integer scratch 1
				350
				351	set STORE_FLG, LV+19 # flag: operand store (ie. not fcmp/ftst)
				352
				353	set EXC_TEMP2, LV+24 # temporary space
				354	set EXC_TEMP, LV+16 # temporary space
				355
				356	set DTAG, LV+15 # destination operand type
				357	set STAG, LV+14 # source operand type
				358
				359	set SPCOND_FLG, LV+10 # flag: special case (see below)
				360
				361	set EXC_CC, LV+8 # saved condition codes
				362	set EXC_EXTWPTR, LV+4 # saved current PC (active)
				363	set EXC_EXTWORD, LV+2 # saved extension word
				364	set EXC_CMDREG, LV+2 # saved extension word
				365	set EXC_OPWORD, LV+0 # saved operation word
				366
				367	################################
				368
				369	# Helpful macros
				370
				371	set FTEMP, 0 # offsets within an
				372	set FTEMP_EX, 0 # extended precision
				373	set FTEMP_SGN, 2 # value saved in memory.
				374	set FTEMP_HI, 4
				375	set FTEMP_LO, 8
				376	set FTEMP_GRS, 12
				377
				378	set LOCAL, 0 # offsets within an
				379	set LOCAL_EX, 0 # extended precision
				380	set LOCAL_SGN, 2 # value saved in memory.
				381	set LOCAL_HI, 4
				382	set LOCAL_LO, 8
				383	set LOCAL_GRS, 12
				384
				385	set DST, 0 # offsets within an
				386	set DST_EX, 0 # extended precision
				387	set DST_HI, 4 # value saved in memory.
				388	set DST_LO, 8
				389
				390	set SRC, 0 # offsets within an
				391	set SRC_EX, 0 # extended precision
				392	set SRC_HI, 4 # value saved in memory.
				393	set SRC_LO, 8
				394
				395	set SGL_LO, 0x3f81 # min sgl prec exponent
				396	set SGL_HI, 0x407e # max sgl prec exponent
				397	set DBL_LO, 0x3c01 # min dbl prec exponent
				398	set DBL_HI, 0x43fe # max dbl prec exponent
				399	set EXT_LO, 0x0 # min ext prec exponent
				400	set EXT_HI, 0x7ffe # max ext prec exponent
				401
				402	set EXT_BIAS, 0x3fff # extended precision bias
				403	set SGL_BIAS, 0x007f # single precision bias
				404	set DBL_BIAS, 0x03ff # double precision bias
				405
				406	set NORM, 0x00 # operand type for STAG/DTAG
				407	set ZERO, 0x01 # operand type for STAG/DTAG
				408	set INF, 0x02 # operand type for STAG/DTAG
				409	set QNAN, 0x03 # operand type for STAG/DTAG
				410	set DENORM, 0x04 # operand type for STAG/DTAG
				411	set SNAN, 0x05 # operand type for STAG/DTAG
				412	set UNNORM, 0x06 # operand type for STAG/DTAG
				413
				414	##################
				415	# FPSR/FPCR bits #
				416	##################
				417	set neg_bit, 0x3 # negative result
				418	set z_bit, 0x2 # zero result
				419	set inf_bit, 0x1 # infinite result
				420	set nan_bit, 0x0 # NAN result
				421
				422	set q_sn_bit, 0x7 # sign bit of quotient byte
				423
				424	set bsun_bit, 7 # branch on unordered
				425	set snan_bit, 6 # signalling NAN
				426	set operr_bit, 5 # operand error
				427	set ovfl_bit, 4 # overflow
				428	set unfl_bit, 3 # underflow
				429	set dz_bit, 2 # divide by zero
				430	set inex2_bit, 1 # inexact result 2
				431	set inex1_bit, 0 # inexact result 1
				432
				433	set aiop_bit, 7 # accrued inexact operation bit
				434	set aovfl_bit, 6 # accrued overflow bit
				435	set aunfl_bit, 5 # accrued underflow bit
				436	set adz_bit, 4 # accrued dz bit
				437	set ainex_bit, 3 # accrued inexact bit
				438
				439	#############################
				440	# FPSR individual bit masks #
				441	#############################
				442	set neg_mask, 0x08000000 # negative bit mask (lw)
				443	set inf_mask, 0x02000000 # infinity bit mask (lw)
				444	set z_mask, 0x04000000 # zero bit mask (lw)
				445	set nan_mask, 0x01000000 # nan bit mask (lw)
				446
				447	set neg_bmask, 0x08 # negative bit mask (byte)
				448	set inf_bmask, 0x02 # infinity bit mask (byte)
				449	set z_bmask, 0x04 # zero bit mask (byte)
				450	set nan_bmask, 0x01 # nan bit mask (byte)
				451
				452	set bsun_mask, 0x00008000 # bsun exception mask
				453	set snan_mask, 0x00004000 # snan exception mask
				454	set operr_mask, 0x00002000 # operr exception mask
				455	set ovfl_mask, 0x00001000 # overflow exception mask
				456	set unfl_mask, 0x00000800 # underflow exception mask
				457	set dz_mask, 0x00000400 # dz exception mask
				458	set inex2_mask, 0x00000200 # inex2 exception mask
				459	set inex1_mask, 0x00000100 # inex1 exception mask
				460
				461	set aiop_mask, 0x00000080 # accrued illegal operation
				462	set aovfl_mask, 0x00000040 # accrued overflow
				463	set aunfl_mask, 0x00000020 # accrued underflow
				464	set adz_mask, 0x00000010 # accrued divide by zero
				465	set ainex_mask, 0x00000008 # accrued inexact
				466
				467	######################################
				468	# FPSR combinations used in the FPSP #
				469	######################################
				470	set dzinf_mask, inf_mask+dz_mask+adz_mask
				471	set opnan_mask, nan_mask+operr_mask+aiop_mask
				472	set nzi_mask, 0x01ffffff #clears N, Z, and I
				473	set unfinx_mask, unfl_mask+inex2_mask+aunfl_mask+ainex_mask
				474	set unf2inx_mask, unfl_mask+inex2_mask+ainex_mask
				475	set ovfinx_mask, ovfl_mask+inex2_mask+aovfl_mask+ainex_mask
				476	set inx1a_mask, inex1_mask+ainex_mask
				477	set inx2a_mask, inex2_mask+ainex_mask
				478	set snaniop_mask, nan_mask+snan_mask+aiop_mask
				479	set snaniop2_mask, snan_mask+aiop_mask
				480	set naniop_mask, nan_mask+aiop_mask
				481	set neginf_mask, neg_mask+inf_mask
				482	set infaiop_mask, inf_mask+aiop_mask
				483	set negz_mask, neg_mask+z_mask
				484	set opaop_mask, operr_mask+aiop_mask
				485	set unfl_inx_mask, unfl_mask+aunfl_mask+ainex_mask
				486	set ovfl_inx_mask, ovfl_mask+aovfl_mask+ainex_mask
				487
				488	#########
				489	# misc. #
				490	#########
				491	set rnd_stky_bit, 29 # stky bit pos in longword
				492
				493	set sign_bit, 0x7 # sign bit
				494	set signan_bit, 0x6 # signalling nan bit
				495
				496	set sgl_thresh, 0x3f81 # minimum sgl exponent
				497	set dbl_thresh, 0x3c01 # minimum dbl exponent
				498
				499	set x_mode, 0x0 # extended precision
				500	set s_mode, 0x4 # single precision
				501	set d_mode, 0x8 # double precision
				502
				503	set rn_mode, 0x0 # round-to-nearest
				504	set rz_mode, 0x1 # round-to-zero
				505	set rm_mode, 0x2 # round-tp-minus-infinity
				506	set rp_mode, 0x3 # round-to-plus-infinity
				507
				508	set mantissalen, 64 # length of mantissa in bits
				509
				510	set BYTE, 1 # len(byte) == 1 byte
				511	set WORD, 2 # len(word) == 2 bytes
				512	set LONG, 4 # len(longword) == 2 bytes
				513
				514	set BSUN_VEC, 0xc0 # bsun vector offset
				515	set INEX_VEC, 0xc4 # inexact vector offset
				516	set DZ_VEC, 0xc8 # dz vector offset
				517	set UNFL_VEC, 0xcc # unfl vector offset
				518	set OPERR_VEC, 0xd0 # operr vector offset
				519	set OVFL_VEC, 0xd4 # ovfl vector offset
				520	set SNAN_VEC, 0xd8 # snan vector offset
				521
				522	###########################
				523	# SPecial CONDition FLaGs #
				524	###########################
				525	set ftrapcc_flg, 0x01 # flag bit: ftrapcc exception
				526	set fbsun_flg, 0x02 # flag bit: bsun exception
				527	set mia7_flg, 0x04 # flag bit: (a7)+ <ea>
				528	set mda7_flg, 0x08 # flag bit: -(a7) <ea>
				529	set fmovm_flg, 0x40 # flag bit: fmovm instruction
				530	set immed_flg, 0x80 # flag bit: &<data> <ea>
				531
				532	set ftrapcc_bit, 0x0
				533	set fbsun_bit, 0x1
				534	set mia7_bit, 0x2
				535	set mda7_bit, 0x3
				536	set immed_bit, 0x7
				537
				538	##################################
				539	# TRANSCENDENTAL "LAST-OP" FLAGS #
				540	##################################
				541	set FMUL_OP, 0x0 # fmul instr performed last
				542	set FDIV_OP, 0x1 # fdiv performed last
				543	set FADD_OP, 0x2 # fadd performed last
				544	set FMOV_OP, 0x3 # fmov performed last
				545
				546	#############
				547	# CONSTANTS #
				548	#############
				549	T1: long 0x40C62D38,0xD3D64634 # 16381 LOG2 LEAD
				550	T2: long 0x3D6F90AE,0xB1E75CC7 # 16381 LOG2 TRAIL
				551
				552	PI: long 0x40000000,0xC90FDAA2,0x2168C235,0x00000000
				553	PIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
				554
				555	TWOBYPI:
				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 + rr(B1+s(B2+ ... + sB8)), #
				4934	# s = r*r. #
				4935	# Exit. #
				4936	# #
				4937	# 6. (k is even) Set j := k/2, sgn := (-1)*j. Return sgnsin(r) #
				4938	# where sin(r) is approximated by an odd polynomial in r #
				4939	# r + rs(A1+s(A2+ ... + sA7)), 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
				4979	SINA7: long 0xBD6AAA77,0xCCC994F5
				4980	SINA6: long 0x3DE61209,0x7AAE8DA1
				4981	SINA5: long 0xBE5AE645,0x2A118AE4
				4982	SINA4: long 0x3EC71DE3,0xA5341531
				4983	SINA3: long 0xBF2A01A0,0x1A018B59,0x00000000,0x00000000
				4984	SINA2: long 0x3FF80000,0x88888888,0x888859AF,0x00000000
				4985	SINA1: long 0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000
				4986
				4987	COSB8: long 0x3D2AC4D0,0xD6011EE3
				4988	COSB7: long 0xBDA9396F,0x9F45AC19
				4989	COSB6: long 0x3E21EED9,0x0612C972
				4990	COSB5: long 0xBE927E4F,0xB79D9FCF
				4991	COSB4: long 0x3EFA01A0,0x1A01D423,0x00000000,0x00000000
				4992	COSB3: long 0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000
				4993	COSB2: long 0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E
				4994	COSB1: 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
				5015	ssin:
				5016	mov.l &0,ADJN(%a6) # yes; SET ADJN TO 0
				5017	bra.b SINBGN
				5018
				5019	############################################
				5020	global scos
				5021	scos:
				5022	mov.l &1,ADJN(%a6) # yes; SET ADJN TO 1
				5023
				5024	############################################
				5025	SINBGN:
				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
				5040	SOK1:
				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.
				5047	SINMAIN:
				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
				5064	SINCONT:
				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 SGNSIN(R). SGNSIN(R) IS COMPUTED BY
				5076	#--R' + R'S(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE
				5077	#--R' = SGNR, S=RR. 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.
				5082	SINPOLY:
				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 SGNCOS(R). SGNCOS(R) IS COMPUTED BY
				5129	#--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE
				5130	#--S=RR AND S'=SGNS. 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.
				5136	COSPOLY:
				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.
				5194	SINBORS:
				5195	cmp.l %d1,&0x3FFF8000
				5196	bgt.l SREDUCEX
				5197
				5198	SINSM:
				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.
				5205	SINTINY:
				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
				5213	COSTINY:
				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
				5222	ssind:
				5223	bra t_extdnrm
				5224
				5225	############################################
				5226	global scosd
				5227	#--COS(X) = 1 FOR DENORMALIZED X
				5228	scosd:
				5229	fmov.s &0x3F800000,%fp0 # fp0 = 1.0
				5230	bra t_pinx2
				5231
				5232	##################################################
				5233
				5234	global ssincos
				5235	ssincos:
				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
				5250	SCOK1:
				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.
				5258	SCMAIN:
				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
				5274	SCCONT:
				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
				5282	SNODD:
				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
				5356	NEVEN:
				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
				5431	SCBORS:
				5432	cmp.l %d1,&0x3FFF8000
				5433	bgt.w SREDUCEX
				5434
				5435	################################################
				5436
				5437	SCSM:
				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
				5453	ssincosd:
				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.
				5465	SREDUCEX:
				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*16383PI/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*16383PI/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)
				5492	sred_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)
				5502	SLOOP:
				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
				5510	SCONTLOOP:
				5511	sub.l &27,%d1 # d0 = L := K-27
				5512	mov.b &0,ENDFLAG(%a6)
				5513	bra.b SWORK
				5514	SLASTLOOP:
				5515	clr.l %d1 # d0 = L := 0
				5516	mov.b &1,ENDFLAG(%a6)
				5517
				5518	SWORK:
				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) ) < 229.
				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)263 + 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) - NP1 - NP2, 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
				5595	SRESTORE:
				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 + rs(P1 + s(P2 + sP3)), and #
				5635	# V = 1 + s(Q1 + s(Q2 + s(Q3 + sQ4))), 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 + rs(P1 + s(P2 + sP3)), and #
				5641	# V = 1 + s(Q1 + s(Q2 + s(Q3 + sQ4))), 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
				5653	TANQ4:
				5654	long 0x3EA0B759,0xF50F8688
				5655	TANP3:
				5656	long 0xBEF2BAA5,0xA8924F04
				5657
				5658	TANQ3:
				5659	long 0xBF346F59,0xB39BA65F,0x00000000,0x00000000
				5660
				5661	TANP2:
				5662	long 0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000
				5663
				5664	TANQ2:
				5665	long 0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000
				5666
				5667	TANP1:
				5668	long 0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000
				5669
				5670	TANQ1:
				5671	long 0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000
				5672
				5673	INVTWOPI:
				5674	long 0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000
				5675
				5676	TWOPI1:
				5677	long 0x40010000,0xC90FDAA2,0x00000000,0x00000000
				5678	TWOPI2:
				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
				5685	PITBL:
				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
				5759	stan:
				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
				5769	TANOK1:
				5770	cmp.l %d1,&0x4004BC7E # \|X\| < 15 PI?
				5771	blt.b TANMAIN
				5772	bra.w REDUCEX
				5773
				5774	TANMAIN:
				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
				5794	TANCONT:
				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
				5836	NODD:
				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
				5875	TANBORS:
				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
				5881	TANSM:
				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
				5890	stand:
				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.
				5896	REDUCEX:
				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*16383PI/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*16383PI/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)
				5923	red_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)
				5933	LOOP:
				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
				5941	CONTLOOP:
				5942	sub.l &27,%d1 # d0 = L := K-27
				5943	mov.b &0,ENDFLAG(%a6)
				5944	bra.b WORK
				5945	LASTLOOP:
				5946	clr.l %d1 # d0 = L := 0
				5947	mov.b &1,ENDFLAG(%a6)
				5948
				5949	WORK:
				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) ) < 229.
				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)263 + 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) - NP1 - NP2, 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
				6026	RESTORE:
				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
				6077	ATANA3: long 0xBFF6687E,0x314987D8
				6078	ATANA2: long 0x4002AC69,0x34A26DB3
				6079	ATANA1: long 0xBFC2476F,0x4E1DA28E
				6080
				6081	ATANB6: long 0x3FB34444,0x7F876989
				6082	ATANB5: long 0xBFB744EE,0x7FAF45DB
				6083	ATANB4: long 0x3FBC71C6,0x46940220
				6084	ATANB3: long 0xBFC24924,0x921872F9
				6085	ATANB2: long 0x3FC99999,0x99998FA9
				6086	ATANB1: long 0xBFD55555,0x55555555
				6087
				6088	ATANC5: long 0xBFB70BF3,0x98539E6A
				6089	ATANC4: long 0x3FBC7187,0x962D1D7D
				6090	ATANC3: long 0xBFC24924,0x827107B8
				6091	ATANC2: long 0x3FC99999,0x9996263E
				6092	ATANC1: long 0xBFD55555,0x55555536
				6093
				6094	PPIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
				6095	NPIBY2: long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000
				6096
				6097	PTINY: long 0x00010000,0x80000000,0x00000000,0x00000000
				6098	NTINY: long 0x80010000,0x80000000,0x00000000,0x00000000
				6099
				6100	ATANTBL:
				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
				6241	satan:
				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
				6253	ATANOK1:
				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
				6279	ATANMAIN:
				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 XF, NOTE THAT XF > 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 + A1UV(A2 + V(A3 + V)), V = U*U
				6318	#--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.
				6319	#--THE NATURAL FORM IS U + UV(A1 + V(A2 + VA3))
				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 A1UV 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 # A1UV
				6334	fmul.x %fp2,%fp1 # A1UV(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
				6343	ATANBORS:
				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
				6349	ATANSM:
				6350	#--\|X\| <= 1/16
				6351	#--IF \|X\| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
				6352	#--ATAN(X) BY X + XY(B1+Y(B2+Y(B3+Y(B4+Y(B5+Y*B6)))))
				6353	#--WHICH IS X + XY( [B1+Z(B3+ZB5)] + [Y(B2+Z(B4+Z*B6)] )
				6354	#--WHERE Y = XX, AND Z = YY.
				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+ZB6)
				6377	fmul.x %fp3,%fp1 # Z(B3+ZB5)
				6378
				6379	fadd.d ATANB2(%pc),%fp2 # B2+Z(B4+ZB6)
				6380	fadd.d ATANB1(%pc),%fp1 # B1+Z(B3+ZB5)
				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+ZB5)]+[Y(B2+Z(B4+Z*B6))]
				6386
				6387	fmul.x %fp1,%fp0 # XY([B1+Z(B3+ZB5)]+[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
				6395	ATANTINY:
				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
				6404	ATANBIG:
				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+YC5)))), X' = -1/X, Y = X'*X'
				6412	#--THIS CAN BE RE-WRITTEN AS
				6413	#--X'+X'Y( [C1+Z(C3+ZC5)] + [Y(C2+ZC4)] ), 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+ZC5), FP3 RELEASED
				6439	fmul.x %fp0,%fp2 # Y(C2+ZC4)
				6440
				6441	fadd.d ATANC1(%pc),%fp1 # C1+Z(C3+ZC5)
				6442	fmul.x X(%a6),%fp0 # X'*Y
				6443
				6444	fadd.x %fp2,%fp1 # [Y(C2+ZC4)]+[C1+Z(C3+ZC5)]
				6445
				6446	fmul.x %fp1,%fp0 # X'Y([B1+Z(B3+ZB5)]
				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
				6456	neg_big:
				6457	fadd.x NPIBY2(%pc),%fp0
				6458	bra t_minx2
				6459
				6460	pos_big:
				6461	fadd.x PPIBY2(%pc),%fp0
				6462	bra t_pinx2
				6463
				6464	ATANHUGE:
				6465	#--RETURN SIGN(X)(PIBY2 - TINY) = SIGN(X)PIBY2 - SIGN(X)*TINY
				6466	tst.b (%a0)
				6467	bpl.b pos_huge
				6468
				6469	neg_huge:
				6470	fmov.x NPIBY2(%pc),%fp0
				6471	fmov.l %d0,%fpcr
				6472	fadd.x PTINY(%pc),%fp0
				6473	bra t_minx2
				6474
				6475	pos_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
				6483	satand:
				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
				6523	sasin:
				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
				6543	ASINMAIN:
				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
				6559	ASINBIG:
				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.
				6565	ASINONE:
				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
				6576	ASINTINY:
				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
				6584	sasind:
				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
				6624	sacos:
				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
				6636	ACOSMAIN:
				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
				6654	ACOSBIG:
				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
				6665	ACOSM1:
				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
				6671	ACOSP1:
				6672	bra ld_pzero # answer is positive zero
				6673
				6674	global sacosd
				6675	#--ACOS(X) = PI/2 FOR DENORMALIZED X
				6676	sacosd:
				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	# X64/log2 - N = f - epsX 64/log2 #
				6775	# X - Nlog2/64 = flog2/64 - eps*X #
				6776	# #
				6777	# #
				6778	# Now \|X\| <= 16446 log2, thus #
				6779	# #
				6780	# \|X - Nlog2/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 + RR(A1 + R(A2 + R(A3 + R(A4 + RA5)))) #
				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 + RS(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+RR(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 = [ RS(A2 + S(A4 + SA6)) ] + #
				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 + XX(B1 + X(B2 + ... + XB12)) #
				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 + ( SB1 + Q ) where S = XX and #
				6983	# Q = XS(B2 + X(B3 + ... + XB12)) #
				6984	# d) To fully utilize the pipeline, Q is separated into #
				6985	# two independent pieces of roughly equal complexity #
				6986	# Q = [ XS(B2 + S(B4 + ... + SB12)) ] + #
				6987	# [ SS(B3 + S(B5 + ... + SB11)) ] #
				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
				7002	L2: long 0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000
				7003
				7004	EEXPA3: long 0x3FA55555,0x55554CC1
				7005	EEXPA2: long 0x3FC55555,0x55554A54
				7006
				7007	EM1A4: long 0x3F811111,0x11174385
				7008	EM1A3: long 0x3FA55555,0x55554F5A
				7009
				7010	EM1A2: long 0x3FC55555,0x55555555,0x00000000,0x00000000
				7011
				7012	EM1B8: long 0x3EC71DE3,0xA5774682
				7013	EM1B7: long 0x3EFA01A0,0x19D7CB68
				7014
				7015	EM1B6: long 0x3F2A01A0,0x1A019DF3
				7016	EM1B5: long 0x3F56C16C,0x16C170E2
				7017
				7018	EM1B4: long 0x3F811111,0x11111111
				7019	EM1B3: long 0x3FA55555,0x55555555
				7020
				7021	EM1B2: long 0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB
				7022	long 0x00000000
				7023
				7024	TWO140: long 0x48B00000,0x00000000
				7025	TWON140:
				7026	long 0x37300000,0x00000000
				7027
				7028	EEXPTBL:
				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
				7101	setox:
				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
				7111	EXPC1:
				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
				7118	EXPMAIN:
				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
				7140	EXPCONT1:
				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 + RR(A1 + R(A2 + R(A3 + R(A4 + RA5))))
				7153	#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
				7154	#--[R+RS(A2+SA4)] + [S(A1+S(A3+SA5))]
				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+SA5)
				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+SA4)
				7174
				7175	fadd.s &0x3F000000,%fp2 # fp2 IS A1+S(A3+SA5)
				7176	fmul.x %fp0,%fp3 # fp3 IS RS(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+RS(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
				7198	ADJUST:
				7199	fmul.x ADJSCALE(%a6),%fp0
				7200	NORMAL:
				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
				7206	EXPSM:
				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
				7213	EEXPBIG:
				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
				7244	EXP2BIG:
				7245	#--Step 9
				7246	tst.b (%a0) # is X positive or negative?
				7247	bmi t_unfl2
				7248	bra t_ovfl2
				7249
				7250	global setoxd
				7251	setoxd:
				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
				7264	setoxm1:
				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
				7275	EM1CON1:
				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
				7283	EM1MAIN:
				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 + RR(A1 + R(A2 + R(A3 + R(A4 + R(A5 + R*A6)))))
				7316	#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
				7317	#--[RS(A2+S(A4+SA6))] + [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+SA6)
				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+SA5)
				7338	add.w &0x3FFF,%d1 # biased expo. of 2^(-M)
				7339	fadd.d EM1A2(%pc),%fp2 # fp2 IS A2+S(A4+SA6)
				7340	fadd.s &0x3F000000,%fp3 # fp3 IS A1+S(A3+SA5)
				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 RS(A2+S(A4+SA6))
				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
				7372	MLE63:
				7373	#--Step 6.3 M <= 63
				7374	cmp.l %d1,&-3
				7375	bge.b MGEN3
				7376	MLTN3:
				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
				7382	MGEN3:
				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
				7389	EM1SCALE:
				7390	#--Step 6.6
				7391	fmov.l %d0,%fpcr
				7392	fmul.x SC(%a6),%fp0
				7393	bra t_inx2
				7394
				7395	EM1SM:
				7396	#--Step 7 \|X\| < 1/4.
				7397	cmp.l %d1,&0x3FBE0000 # 2^(-65)
				7398	bge.b EM1POLY
				7399
				7400	EM1TINY:
				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
				7414	EM12TINY:
				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
				7427	EM1POLY:
				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 SS(B3+...)
				7465	fmul.x (%a0),%fp1 # fp1 is XS(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
				7478	EM1BIG:
				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
				7490	setoxm1d:
				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
				7516	sgetexp:
				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
				7524	sgetexpn:
				7525	mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
				7526	rts
				7527
				7528	global sgetexpd
				7529	sgetexpd:
				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
				7538	sgetman:
				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
				7551	sgetmann:
				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
				7560	sgetmand:
				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
				7610	TWO16380:
				7611	long 0x7FFB0000,0x80000000,0x00000000,0x00000000
				7612
				7613	global scosh
				7614	scosh:
				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
				7645	COSHBIG:
				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
				7666	COSHHUGE:
				7667	bra t_ovfl2
				7668
				7669	global scoshd
				7670	#--COSH(X) = 1 FOR DENORMALIZED X
				7671	scoshd:
				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)HugeHuge 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
				7726	ssinh:
				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
				7765	SINHBIG:
				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
				7793	ssinhd:
				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
				7851	stanh:
				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
				7893	TANHBORS:
				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
				7936	TANHSM:
				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
				7943	TANHHUGE:
				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
				7957	stanhd:
				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	#########################################################################
				8023	LOGOF2:
				8024	long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
				8025
				8026	one:
				8027	long 0x3F800000
				8028	zero:
				8029	long 0x00000000
				8030	infty:
				8031	long 0x7F800000
				8032	negone:
				8033	long 0xBF800000
				8034
				8035	LOGA6:
				8036	long 0x3FC2499A,0xB5E4040B
				8037	LOGA5:
				8038	long 0xBFC555B5,0x848CB7DB
				8039
				8040	LOGA4:
				8041	long 0x3FC99999,0x987D8730
				8042	LOGA3:
				8043	long 0xBFCFFFFF,0xFF6F7E97
				8044
				8045	LOGA2:
				8046	long 0x3FD55555,0x555555A4
				8047	LOGA1:
				8048	long 0xBFE00000,0x00000008
				8049
				8050	LOGB5:
				8051	long 0x3F175496,0xADD7DAD6
				8052	LOGB4:
				8053	long 0x3F3C71C2,0xFE80C7E0
				8054
				8055	LOGB3:
				8056	long 0x3F624924,0x928BCCFF
				8057	LOGB2:
				8058	long 0x3F899999,0x999995EC
				8059
				8060	LOGB1:
				8061	long 0x3FB55555,0x55555555
				8062	TWO:
				8063	long 0x40000000,0x00000000
				8064
				8065	LTHOLD:
				8066	long 0x3f990000,0x80000000,0x00000000,0x00000000
				8067
				8068	LOGTBL:
				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
				8213	slogn:
				8214	fmov.x (%a0),%fp0 # LOAD INPUT
				8215	mov.l &0x00000000,ADJK(%a6)
				8216
				8217	LOGBGN:
				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
				8236	LOGMAIN:
				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
				8276	LP1CONT1:
				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+UA6))))) WHICH IS
				8286	#--[U + V(A1+V(A3+VA5))] + [UV(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+VA6)
				8298	fmul.x %fp3,%fp2 # V(A3+VA5)
				8299
				8300	fadd.d LOGA2(%pc),%fp1 # A2+V(A4+VA6)
				8301	fadd.d LOGA1(%pc),%fp2 # A1+V(A3+VA5)
				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 # UV(A2+V(A4+VA6))
				8308	fadd.x %fp2,%fp0 # U+V(A1+V(A3+V*A5))
				8309
				8310	fadd.x (%a0),%fp1 # LOG(F)+UV(A2+V(A4+VA6))
				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
				8319	LOGNEAR1:
				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
				8335	LP1CONT2:
				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=UU, W=VV, CALCULATE
				8341	#--U + UV(B1 + V(B2 + V(B3 + V(B4 + VB5)))) BY
				8342	#--U + UV( [B1 + W(B3 + WB5)] + [V(B2 + WB4)] )
				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+WB5), FP3 RELEASED
				8359
				8360	fmul.x %fp0,%fp2 # V(B2+WB4)
				8361
				8362	fadd.d LOGB1(%pc),%fp1 # B1+W(B3+WB5)
				8363	fmul.x SAVEU(%a6),%fp0 # FP0 IS U*V
				8364
				8365	fadd.x %fp2,%fp1 # B1+W(B3+WB5) + V(B2+WB4), FP2 RELEASED
				8366	fmovm.x (%sp)+,&0x30 # FP2-3 RESTORED
				8367
				8368	fmul.x %fp1,%fp0 # UV( [B1+W(B3+WB5)] + [V(B2+WB4)] )
				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
				8375	LOGNEG:
				8376	bra t_operr
				8377
				8378	global slognd
				8379	slognd:
				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
				8398	Hi_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
				8417	Hi_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
				8441	slognp1:
				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
				8451	LP1REAL:
				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
				8469	LP1NEAR1:
				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
				8476	LP1ONE16:
				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
				8484	LP1CARE:
				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
				8500	KISNEG1:
				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
				8518	KISZERO:
				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
				8535	LP1NEG0:
				8536	#--FPCR SAVED. D0 IS X IN COMPACT FORM.
				8537	cmp.l %d1,&0
				8538	blt.b LP1NEG
				8539	LP1ZERO:
				8540	fmov.s negone(%pc),%fp0
				8541
				8542	fmov.l %d0,%fpcr
				8543	bra t_dz
				8544
				8545	LP1NEG:
				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
				8554	slognp1d:
				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
				8600	satanh:
				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
				8634	ATANHBIG:
				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
				8642	satanhd:
				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
				8730	INV_L10:
				8731	long 0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000
				8732
				8733	INV_L2:
				8734	long 0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000
				8735
				8736	global slog10
				8737	#--entry point for Log10(X), X is normalized
				8738	slog10:
				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
				8754	slog10d:
				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
				8766	slog2:
				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
				8786	continue:
				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
				8794	invalid:
				8795	bra t_operr
				8796
				8797	global slog2d
				8798	#--entry point for Log2(X), X is denormalized
				8799	slog2d:
				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 = 2X or 10X #
				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	# 2X = 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 := Xlog_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 - NL1)-NL2) * 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	# 10X = 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 + rr(A1+r(A2+...+rA5)). #
				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
				8883	L2TEN64:
				8884	long 0x406A934F,0x0979A371 # 64LOG10/LOG2
				8885	L10TWO1:
				8886	long 0x3F734413,0x509F8000 # LOG2/64LOG10
				8887
				8888	L10TWO2:
				8889	long 0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000
				8890
				8891	LOG10: long 0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000
				8892
				8893	LOG2: long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
				8894
				8895	EXPA5: long 0x3F56C16D,0x6F7BD0B2
				8896	EXPA4: long 0x3F811112,0x302C712C
				8897	EXPA3: long 0x3FA55555,0x55554CC1
				8898	EXPA2: long 0x3FC55555,0x55554A54
				8899	EXPA1: long 0x3FE00000,0x00000000,0x00000000,0x00000000
				8900
				8901	TEXPTBL:
				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
				8985	stwotox:
				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
				8997	TWOOK1:
				8998	cmp.l %d1,&0x400D80C0 # \|X\| > 16480?
				8999	ble.b TWOMAIN
				9000	bra.w EXPBORS
				9001
				9002	TWOMAIN:
				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
				9046	EXPBORS:
				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
				9057	TEXPBIG:
				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
				9066	EXPNEG:
				9067	bra t_unfl2 # t_unfl expects positive value
				9068
				9069	global stwotoxd
				9070	stwotoxd:
				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
				9082	stentox:
				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
				9094	TENOK1:
				9095	cmp.l %d1,&0x400B9B07 # \|X\| <= 16480*log2/log10 ?
				9096	ble.b TENMAIN
				9097	bra.w EXPBORS
				9098
				9099	TENMAIN:
				9100	#--USUAL CASE, 2^(-70) <= \|X\| <= 16480 LOG 2 / LOG 10
				9101
				9102	fmov.x %fp0,%fp1
				9103	fmul.d L2TEN64(%pc),%fp1 # X64LOG10/LOG2
				9104	fmov.l %fp1,INT(%a6) # N=INT(X64LOG10/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
				9147	expr:
				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+SA5)
				9166	fmul.x %fp1,%fp3 # FP3 IS S(A2+SA4)
				9167
				9168	fadd.d EXPA1(%pc),%fp2 # FP2 IS A1+S(A3+SA5)
				9169	fmul.x %fp0,%fp3 # FP3 IS RS(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+RS(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^M2^(J/64) + 2^M2^(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
				9194	stentoxd:
				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
				9218	set SIGN, L_SCR1
				9219
				9220	global sscale
				9221	sscale:
				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	#
				9238	src_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.
				9250	sok_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
				9284	sok_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.
				9294	sok_norm:
				9295	fmovm.x DST(%a1),&0x80 # load fp0 with normalized src
				9296	sok_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
				9305	sok_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	#
				9315	src_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	#
				9326	src_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
				9335	ssmall_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
				9415	Scale:
				9416	long 0x00010000,0x80000000,0x00000000,0x00000000
				9417
				9418	global smod
				9419	smod:
				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
				9426	srem:
				9427	clr.b FPSR_QBYTE(%a6)
				9428	mov.l %d0,-(%sp) # save ctrl bits
				9429	mov.b &0x1,Mod_Flag(%a6)
				9430
				9431	Mod_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
				9449	HiY_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
				9460	HiY_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
				9474	Y_Normal:
				9475	add.l &0x00003FFE,%d3 # (D3,D4,D5) normalized
				9476	# ...with bias $7FFD
				9477
				9478	Chk_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
				9494	HiX_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
				9505	HiX_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
				9519	X_Normal:
				9520	add.l &0x00003FFE,%d0 # (D0,D1,D2) normalized
				9521	# ...with bias $7FFD
				9522
				9523	Init:
				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
				9542	Mod_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
				9545	Mod_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
				9558	R_NE_Y:
				9559	#..use the borrow of the previous compare
				9560	bcs.b R_LT_Y # borrow is set iff R < Y
				9561
				9562	R_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
				9570	R_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
				9585	PostLoop:
				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
				9593	HiR_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
				9604	HiR_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	#
				9618	Get_Mod:
				9619	cmp.l %d0,&0x000041FE
				9620	bge.b No_Scale
				9621	Do_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
				9632	No_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	#
				9647	ModOrRem:
				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
				9663	Not_EQ:
				9664	bcs.b Fix_Sign
				9665
				9666	Last_Sub:
				9667	#
				9668	fsub.x Y(%a6),%fp0 # no exceptions
				9669	addq.l &1,%d3 # Q := Q + 1
				9670
				9671	#
				9672	Fix_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	#
				9680	Get_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	#
				9695	Restore:
				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
				9711	Finish:
				9712	mov.b &FMOV_OP,%d1 # last inst is MOVE
				9713	fmov.x %fp0,%fp0 # capture exceptions & round
				9714	bra t_catch2
				9715
				9716	Rem_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
				9725	Q_Big:
				9726	clr.l %d3
				9727
				9728	Set_R_0:
				9729	fmov.s &0x00000000,%fp0
				9730	clr.b Sc_Flag(%a6)
				9731	bra.w Fix_Sign
				9732
				9733	Tie_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
				9772	tag:
				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
				9777	not_inf_or_nan_x:
				9778	btst &0x7,FTEMP_HI(%a0)
				9779	beq.b not_norm_x
				9780	is_norm_x:
				9781	mov.b &NORM, %d0
				9782	rts
				9783	not_norm_x:
				9784	tst.w %d0 # is exponent = 0?
				9785	bne.b is_unnorm_x
				9786	not_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
				9791	is_zero_x:
				9792	mov.b &ZERO, %d0
				9793	rts
				9794	is_denorm_x:
				9795	mov.b &DENORM, %d0
				9796	rts
				9797	is_unnorm_x:
				9798	bsr.l unnorm_fix # convert to norm,denorm,or zero
				9799	rts
				9800	is_unnorm_reg_x:
				9801	mov.b &UNNORM, %d0
				9802	rts
				9803	inf_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
				9809	is_inf_x:
				9810	mov.b &INF, %d0
				9811	rts
				9812	is_nan_x:
				9813	mov.b &QNAN, %d0
				9814	rts
				9815
				9816	#############################################################
				9817
				9818	qnan: 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
				9847	t_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
				9852	t_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.
				9864	dz_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
				9871	dz_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.
				9883	dz_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
				9916	t_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.
				9928	operr_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
				9937	pls_huge:
				9938	long 0x7ffe0000,0xffffffff,0xffffffff
				9939	mns_huge:
				9940	long 0xfffe0000,0xffffffff,0xffffffff
				9941	pls_tiny:
				9942	long 0x00000000,0x80000000,0x00000000
				9943	mns_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
				9972	t_unfl:
				9973	tst.b SRC_EX(%a0)
				9974	bpl.b unf_pos
				9975
				9976	global t_unfl2
				9977	t_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
				9988	unf_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
				10030	t_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
				10050	ovfl_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
				10056	ovfl_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
				10060	ovfl_sc_inx:
				10061	ori.l &inex2_mask,USER_FPSR(%a6) # set INEX2
				10062	bra.b ovfl_work # continue
				10063
				10064	global t_ovfl
				10065	t_ovfl:
				10066	ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
				10067	ovfl_work:
				10068	tst.b SRC_EX(%a0)
				10069	bpl.b ovfl_p
				10070	ovfl_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
				10080	ovfl_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
				10091	t_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
				10129	t_catch2:
				10130	fmov.l %fpsr,%d0
				10131	or.l %d0,USER_FPSR(%a6)
				10132	bra.b inx2_work
				10133
				10134	global t_catch
				10135	t_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
				10165	t_inx2:
				10166	fblt.w t_minx2
				10167	fbeq.w inx2_zero
				10168
				10169	global t_pinx2
				10170	t_pinx2:
				10171	ori.w &inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX
				10172	bra.b inx2_work
				10173
				10174	global t_minx2
				10175	t_minx2:
				10176	ori.l &inx2a_mask+neg_mask,USER_FPSR(%a6)
				10177
				10178	inx2_work:
				10179	btst &inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?
				10180	bne.b inx2_work_ena # yes
				10181	rts
				10182	inx2_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
				10188	inx2_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
				10218	t_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
				10227	t_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
				10242	sto_cos:
				10243	rts
				10244
				10245	##########################################
				10246
				10247	#
				10248	# dst_qnan --- force result when destination is a NaN
				10249	#
				10250	global dst_qnan
				10251	dst_qnan:
				10252	fmov.x DST(%a1),%fp0
				10253	tst.b DST_EX(%a1)
				10254	bmi.b dst_qnan_m
				10255	dst_qnan_p:
				10256	mov.b &nan_bmask,FPSR_CC(%a6)
				10257	rts
				10258	dst_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
				10266	src_qnan:
				10267	fmov.x SRC(%a0),%fp0
				10268	tst.b SRC_EX(%a0)
				10269	bmi.b src_qnan_m
				10270	src_qnan_p:
				10271	mov.b &nan_bmask,FPSR_CC(%a6)
				10272	rts
				10273	src_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
				10463	src_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
				10471	ld_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
				10478	ld_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
				10487	dst_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
				10496	src_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
				10504	ld_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
				10513	ld_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
				10522	dst_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	#################################################################
				10533	szr_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
				10544	sopr_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
				10555	setoxm1i:
				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
				10564	src_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
				10572	ld_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
				10581	ld_mone:
				10582	fmov.s &0xbf800000,%fp0 # load -1
				10583	mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
				10584	rts
				10585
				10586	ppiby2: long 0x3fff0000, 0xc90fdaa2, 0x2168c235
				10587	mpiby2: long 0xbfff0000, 0xc90fdaa2, 0x2168c235
				10588
				10589	#################################################################
				10590	# spi_2(): Return signed PI/2 according to sign of src operand. #
				10591	#################################################################
				10592	global spi_2
				10593	spi_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
				10601	ld_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
				10610	ld_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
				10625	ssincosz:
				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
				10632	sincoszp:
				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
				10643	ssincosi:
				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
				10652	ssincosqnan:
				10653	fmov.x LOCAL_EX(%a0),%fp1
				10654	bra.w src_qnan
				10655
				10656	########################################################################
				10657
				10658	global smod_sdnrm
				10659	global smod_snorm
				10660	smod_sdnrm:
				10661	smod_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
				10673	smod_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
				10685	smod_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
				10696	smod_zro:
				10697	srem_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
				10707	smod_fpn:
				10708	srem_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
				10721	smod_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
				10728	smod_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
				10735	srem_sdnrm:
				10736	srem_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
				10748	srem_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
				10760	srem_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
				10775	sscale_snorm:
				10776	sscale_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
				10788	sscale_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
				10800	sscale_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
				10810	sop_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
				10836	norm:
				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
				10846	norm_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
				10863	norm_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
				10899	unnorm_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	#
				10906	unnorm_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	#
				10915	unnorm_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	#
				10940	unnorm_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	#
				10959	unnorm_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	#
				10976	unnorm_zero:
				10977	and.w &0x8000, FTEMP_EX(%a0) # force exponent to zero
				10978
				10979	mov.b &ZERO, %d0 # fix optype tag
				10980	rts