?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Test initialisation of MUIA_List_AdjustWidth and MUIA_List_AdjustHeight, and
[AROS.git] / arch / m68k-all / m680x0 / 060sp / dist / fplsp.s
blob1b84b39d8eb98181f3a4ba7eb7733d249f9cffb0
1 #
2 # $NetBSD: fplsp.s,v 1.2 2003/02/05 00:02:32 perry Exp $
3 #
4
5 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
6 # MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
7 # M68000 Hi-Performance Microprocessor Division
8 # M68060 Software Package Production Release
9 #
10 # M68060 Software Package Copyright (C) 1993, 1994, 1995, 1996 Motorola Inc.
11 # All rights reserved.
12 #
13 # THE SOFTWARE is provided on an "AS IS" basis and without warranty.
14 # To the maximum extent permitted by applicable law,
15 # MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
16 # INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS
17 # FOR A PARTICULAR PURPOSE and any warranty against infringement with
18 # regard to the SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF)
19 # and any accompanying written materials.
20 #
21 # To the maximum extent permitted by applicable law,
22 # IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
23 # (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
24 # BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
25 # ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
26 #
27 # Motorola assumes no responsibility for the maintenance and support
28 # of the SOFTWARE.
29 #
30 # You are hereby granted a copyright license to use, modify, and distribute the
31 # SOFTWARE so long as this entire notice is retained without alteration
32 # in any modified and/or redistributed versions, and that such modified
33 # versions are clearly identified as such.
34 # No licenses are granted by implication, estoppel or otherwise under any
35 # patents or trademarks of Motorola, Inc.
36 #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
37
38 #
39 # lfptop.s:
40 # This file is appended to the top of the 060ILSP package
41 # and contains the entry points into the package. The user, in
42 # effect, branches to one of the branch table entries located here.
43 #
44
45 bra.l _facoss_
46 short 0x0000
47 bra.l _facosd_
48 short 0x0000
49 bra.l _facosx_
50 short 0x0000
51
52 bra.l _fasins_
53 short 0x0000
54 bra.l _fasind_
55 short 0x0000
56 bra.l _fasinx_
57 short 0x0000
58
59 bra.l _fatans_
60 short 0x0000
61 bra.l _fatand_
62 short 0x0000
63 bra.l _fatanx_
64 short 0x0000
65
66 bra.l _fatanhs_
67 short 0x0000
68 bra.l _fatanhd_
69 short 0x0000
70 bra.l _fatanhx_
71 short 0x0000
72
73 bra.l _fcoss_
74 short 0x0000
75 bra.l _fcosd_
76 short 0x0000
77 bra.l _fcosx_
78 short 0x0000
79
80 bra.l _fcoshs_
81 short 0x0000
82 bra.l _fcoshd_
83 short 0x0000
84 bra.l _fcoshx_
85 short 0x0000
86
87 bra.l _fetoxs_
88 short 0x0000
89 bra.l _fetoxd_
90 short 0x0000
91 bra.l _fetoxx_
92 short 0x0000
93
94 bra.l _fetoxm1s_
95 short 0x0000
96 bra.l _fetoxm1d_
97 short 0x0000
98 bra.l _fetoxm1x_
99 short 0x0000
100
101 bra.l _fgetexps_
102 short 0x0000
103 bra.l _fgetexpd_
104 short 0x0000
105 bra.l _fgetexpx_
106 short 0x0000
107
108 bra.l _fgetmans_
109 short 0x0000
110 bra.l _fgetmand_
111 short 0x0000
112 bra.l _fgetmanx_
113 short 0x0000
114
115 bra.l _flog10s_
116 short 0x0000
117 bra.l _flog10d_
118 short 0x0000
119 bra.l _flog10x_
120 short 0x0000
121
122 bra.l _flog2s_
123 short 0x0000
124 bra.l _flog2d_
125 short 0x0000
126 bra.l _flog2x_
127 short 0x0000
128
129 bra.l _flogns_
130 short 0x0000
131 bra.l _flognd_
132 short 0x0000
133 bra.l _flognx_
134 short 0x0000
135
136 bra.l _flognp1s_
137 short 0x0000
138 bra.l _flognp1d_
139 short 0x0000
140 bra.l _flognp1x_
141 short 0x0000
142
143 bra.l _fmods_
144 short 0x0000
145 bra.l _fmodd_
146 short 0x0000
147 bra.l _fmodx_
148 short 0x0000
149
150 bra.l _frems_
151 short 0x0000
152 bra.l _fremd_
153 short 0x0000
154 bra.l _fremx_
155 short 0x0000
156
157 bra.l _fscales_
158 short 0x0000
159 bra.l _fscaled_
160 short 0x0000
161 bra.l _fscalex_
162 short 0x0000
163
164 bra.l _fsins_
165 short 0x0000
166 bra.l _fsind_
167 short 0x0000
168 bra.l _fsinx_
169 short 0x0000
170
171 bra.l _fsincoss_
172 short 0x0000
173 bra.l _fsincosd_
174 short 0x0000
175 bra.l _fsincosx_
176 short 0x0000
177
178 bra.l _fsinhs_
179 short 0x0000
180 bra.l _fsinhd_
181 short 0x0000
182 bra.l _fsinhx_
183 short 0x0000
184
185 bra.l _ftans_
186 short 0x0000
187 bra.l _ftand_
188 short 0x0000
189 bra.l _ftanx_
190 short 0x0000
191
192 bra.l _ftanhs_
193 short 0x0000
194 bra.l _ftanhd_
195 short 0x0000
196 bra.l _ftanhx_
197 short 0x0000
198
199 bra.l _ftentoxs_
200 short 0x0000
201 bra.l _ftentoxd_
202 short 0x0000
203 bra.l _ftentoxx_
204 short 0x0000
205
206 bra.l _ftwotoxs_
207 short 0x0000
208 bra.l _ftwotoxd_
209 short 0x0000
210 bra.l _ftwotoxx_
211 short 0x0000
212
213 bra.l _fabss_
214 short 0x0000
215 bra.l _fabsd_
216 short 0x0000
217 bra.l _fabsx_
218 short 0x0000
219
220 bra.l _fadds_
221 short 0x0000
222 bra.l _faddd_
223 short 0x0000
224 bra.l _faddx_
225 short 0x0000
226
227 bra.l _fdivs_
228 short 0x0000
229 bra.l _fdivd_
230 short 0x0000
231 bra.l _fdivx_
232 short 0x0000
233
234 bra.l _fints_
235 short 0x0000
236 bra.l _fintd_
237 short 0x0000
238 bra.l _fintx_
239 short 0x0000
240
241 bra.l _fintrzs_
242 short 0x0000
243 bra.l _fintrzd_
244 short 0x0000
245 bra.l _fintrzx_
246 short 0x0000
247
248 bra.l _fmuls_
249 short 0x0000
250 bra.l _fmuld_
251 short 0x0000
252 bra.l _fmulx_
253 short 0x0000
254
255 bra.l _fnegs_
256 short 0x0000
257 bra.l _fnegd_
258 short 0x0000
259 bra.l _fnegx_
260 short 0x0000
261
262 bra.l _fsqrts_
263 short 0x0000
264 bra.l _fsqrtd_
265 short 0x0000
266 bra.l _fsqrtx_
267 short 0x0000
268
269 bra.l _fsubs_
270 short 0x0000
271 bra.l _fsubd_
272 short 0x0000
273 bra.l _fsubx_
274 short 0x0000
275
276 # leave room for future possible additions
277 align 0x400
278
279 #
280 # This file contains a set of define statements for constants
281 # in order to promote readability within the corecode itself.
282 #
283
284 set LOCAL_SIZE, 192 # stack frame size(bytes)
285 set LV, -LOCAL_SIZE # stack offset
286
287 set EXC_SR, 0x4 # stack status register
288 set EXC_PC, 0x6 # stack pc
289 set EXC_VOFF, 0xa # stacked vector offset
290 set EXC_EA, 0xc # stacked <ea>
291
292 set EXC_FP, 0x0 # frame pointer
293
294 set EXC_AREGS, -68 # offset of all address regs
295 set EXC_DREGS, -100 # offset of all data regs
296 set EXC_FPREGS, -36 # offset of all fp regs
297
298 set EXC_A7, EXC_AREGS+(7*4) # offset of saved a7
299 set OLD_A7, EXC_AREGS+(6*4) # extra copy of saved a7
300 set EXC_A6, EXC_AREGS+(6*4) # offset of saved a6
301 set EXC_A5, EXC_AREGS+(5*4)
302 set EXC_A4, EXC_AREGS+(4*4)
303 set EXC_A3, EXC_AREGS+(3*4)
304 set EXC_A2, EXC_AREGS+(2*4)
305 set EXC_A1, EXC_AREGS+(1*4)
306 set EXC_A0, EXC_AREGS+(0*4)
307 set EXC_D7, EXC_DREGS+(7*4)
308 set EXC_D6, EXC_DREGS+(6*4)
309 set EXC_D5, EXC_DREGS+(5*4)
310 set EXC_D4, EXC_DREGS+(4*4)
311 set EXC_D3, EXC_DREGS+(3*4)
312 set EXC_D2, EXC_DREGS+(2*4)
313 set EXC_D1, EXC_DREGS+(1*4)
314 set EXC_D0, EXC_DREGS+(0*4)
315
316 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0
317 set EXC_FP1, EXC_FPREGS+(1*12) # offset of saved fp1
318 set EXC_FP2, EXC_FPREGS+(2*12) # offset of saved fp2 (not used)
319
320 set FP_SCR1, LV+80 # fp scratch 1
321 set FP_SCR1_EX, FP_SCR1+0
322 set FP_SCR1_SGN, FP_SCR1+2
323 set FP_SCR1_HI, FP_SCR1+4
324 set FP_SCR1_LO, FP_SCR1+8
325
326 set FP_SCR0, LV+68 # fp scratch 0
327 set FP_SCR0_EX, FP_SCR0+0
328 set FP_SCR0_SGN, FP_SCR0+2
329 set FP_SCR0_HI, FP_SCR0+4
330 set FP_SCR0_LO, FP_SCR0+8
331
332 set FP_DST, LV+56 # fp destination operand
333 set FP_DST_EX, FP_DST+0
334 set FP_DST_SGN, FP_DST+2
335 set FP_DST_HI, FP_DST+4
336 set FP_DST_LO, FP_DST+8
337
338 set FP_SRC, LV+44 # fp source operand
339 set FP_SRC_EX, FP_SRC+0
340 set FP_SRC_SGN, FP_SRC+2
341 set FP_SRC_HI, FP_SRC+4
342 set FP_SRC_LO, FP_SRC+8
343
344 set USER_FPIAR, LV+40 # FP instr address register
345
346 set USER_FPSR, LV+36 # FP status register
347 set FPSR_CC, USER_FPSR+0 # FPSR condition codes
348 set FPSR_QBYTE, USER_FPSR+1 # FPSR qoutient byte
349 set FPSR_EXCEPT, USER_FPSR+2 # FPSR exception status byte
350 set FPSR_AEXCEPT, USER_FPSR+3 # FPSR accrued exception byte
351
352 set USER_FPCR, LV+32 # FP control register
353 set FPCR_ENABLE, USER_FPCR+2 # FPCR exception enable
354 set FPCR_MODE, USER_FPCR+3 # FPCR rounding mode control
355
356 set L_SCR3, LV+28 # integer scratch 3
357 set L_SCR2, LV+24 # integer scratch 2
358 set L_SCR1, LV+20 # integer scratch 1
359
360 set STORE_FLG, LV+19 # flag: operand store (ie. not fcmp/ftst)
361
362 set EXC_TEMP2, LV+24 # temporary space
363 set EXC_TEMP, LV+16 # temporary space
364
365 set DTAG, LV+15 # destination operand type
366 set STAG, LV+14 # source operand type
367
368 set SPCOND_FLG, LV+10 # flag: special case (see below)
369
370 set EXC_CC, LV+8 # saved condition codes
371 set EXC_EXTWPTR, LV+4 # saved current PC (active)
372 set EXC_EXTWORD, LV+2 # saved extension word
373 set EXC_CMDREG, LV+2 # saved extension word
374 set EXC_OPWORD, LV+0 # saved operation word
375
376 ################################
377
378 # Helpful macros
379
380 set FTEMP, 0 # offsets within an
381 set FTEMP_EX, 0 # extended precision
382 set FTEMP_SGN, 2 # value saved in memory.
383 set FTEMP_HI, 4
384 set FTEMP_LO, 8
385 set FTEMP_GRS, 12
386
387 set LOCAL, 0 # offsets within an
388 set LOCAL_EX, 0 # extended precision
389 set LOCAL_SGN, 2 # value saved in memory.
390 set LOCAL_HI, 4
391 set LOCAL_LO, 8
392 set LOCAL_GRS, 12
393
394 set DST, 0 # offsets within an
395 set DST_EX, 0 # extended precision
396 set DST_HI, 4 # value saved in memory.
397 set DST_LO, 8
398
399 set SRC, 0 # offsets within an
400 set SRC_EX, 0 # extended precision
401 set SRC_HI, 4 # value saved in memory.
402 set SRC_LO, 8
403
404 set SGL_LO, 0x3f81 # min sgl prec exponent
405 set SGL_HI, 0x407e # max sgl prec exponent
406 set DBL_LO, 0x3c01 # min dbl prec exponent
407 set DBL_HI, 0x43fe # max dbl prec exponent
408 set EXT_LO, 0x0 # min ext prec exponent
409 set EXT_HI, 0x7ffe # max ext prec exponent
410
411 set EXT_BIAS, 0x3fff # extended precision bias
412 set SGL_BIAS, 0x007f # single precision bias
413 set DBL_BIAS, 0x03ff # double precision bias
414
415 set NORM, 0x00 # operand type for STAG/DTAG
416 set ZERO, 0x01 # operand type for STAG/DTAG
417 set INF, 0x02 # operand type for STAG/DTAG
418 set QNAN, 0x03 # operand type for STAG/DTAG
419 set DENORM, 0x04 # operand type for STAG/DTAG
420 set SNAN, 0x05 # operand type for STAG/DTAG
421 set UNNORM, 0x06 # operand type for STAG/DTAG
422
423 ##################
424 # FPSR/FPCR bits #
425 ##################
426 set neg_bit, 0x3 # negative result
427 set z_bit, 0x2 # zero result
428 set inf_bit, 0x1 # infinite result
429 set nan_bit, 0x0 # NAN result
430
431 set q_sn_bit, 0x7 # sign bit of quotient byte
432
433 set bsun_bit, 7 # branch on unordered
434 set snan_bit, 6 # signalling NAN
435 set operr_bit, 5 # operand error
436 set ovfl_bit, 4 # overflow
437 set unfl_bit, 3 # underflow
438 set dz_bit, 2 # divide by zero
439 set inex2_bit, 1 # inexact result 2
440 set inex1_bit, 0 # inexact result 1
441
442 set aiop_bit, 7 # accrued inexact operation bit
443 set aovfl_bit, 6 # accrued overflow bit
444 set aunfl_bit, 5 # accrued underflow bit
445 set adz_bit, 4 # accrued dz bit
446 set ainex_bit, 3 # accrued inexact bit
447
448 #############################
449 # FPSR individual bit masks #
450 #############################
451 set neg_mask, 0x08000000 # negative bit mask (lw)
452 set inf_mask, 0x02000000 # infinity bit mask (lw)
453 set z_mask, 0x04000000 # zero bit mask (lw)
454 set nan_mask, 0x01000000 # nan bit mask (lw)
455
456 set neg_bmask, 0x08 # negative bit mask (byte)
457 set inf_bmask, 0x02 # infinity bit mask (byte)
458 set z_bmask, 0x04 # zero bit mask (byte)
459 set nan_bmask, 0x01 # nan bit mask (byte)
460
461 set bsun_mask, 0x00008000 # bsun exception mask
462 set snan_mask, 0x00004000 # snan exception mask
463 set operr_mask, 0x00002000 # operr exception mask
464 set ovfl_mask, 0x00001000 # overflow exception mask
465 set unfl_mask, 0x00000800 # underflow exception mask
466 set dz_mask, 0x00000400 # dz exception mask
467 set inex2_mask, 0x00000200 # inex2 exception mask
468 set inex1_mask, 0x00000100 # inex1 exception mask
469
470 set aiop_mask, 0x00000080 # accrued illegal operation
471 set aovfl_mask, 0x00000040 # accrued overflow
472 set aunfl_mask, 0x00000020 # accrued underflow
473 set adz_mask, 0x00000010 # accrued divide by zero
474 set ainex_mask, 0x00000008 # accrued inexact
475
476 ######################################
477 # FPSR combinations used in the FPSP #
478 ######################################
479 set dzinf_mask, inf_mask+dz_mask+adz_mask
480 set opnan_mask, nan_mask+operr_mask+aiop_mask
481 set nzi_mask, 0x01ffffff #clears N, Z, and I
482 set unfinx_mask, unfl_mask+inex2_mask+aunfl_mask+ainex_mask
483 set unf2inx_mask, unfl_mask+inex2_mask+ainex_mask
484 set ovfinx_mask, ovfl_mask+inex2_mask+aovfl_mask+ainex_mask
485 set inx1a_mask, inex1_mask+ainex_mask
486 set inx2a_mask, inex2_mask+ainex_mask
487 set snaniop_mask, nan_mask+snan_mask+aiop_mask
488 set snaniop2_mask, snan_mask+aiop_mask
489 set naniop_mask, nan_mask+aiop_mask
490 set neginf_mask, neg_mask+inf_mask
491 set infaiop_mask, inf_mask+aiop_mask
492 set negz_mask, neg_mask+z_mask
493 set opaop_mask, operr_mask+aiop_mask
494 set unfl_inx_mask, unfl_mask+aunfl_mask+ainex_mask
495 set ovfl_inx_mask, ovfl_mask+aovfl_mask+ainex_mask
496
497 #########
498 # misc. #
499 #########
500 set rnd_stky_bit, 29 # stky bit pos in longword
501
502 set sign_bit, 0x7 # sign bit
503 set signan_bit, 0x6 # signalling nan bit
504
505 set sgl_thresh, 0x3f81 # minimum sgl exponent
506 set dbl_thresh, 0x3c01 # minimum dbl exponent
507
508 set x_mode, 0x0 # extended precision
509 set s_mode, 0x4 # single precision
510 set d_mode, 0x8 # double precision
511
512 set rn_mode, 0x0 # round-to-nearest
513 set rz_mode, 0x1 # round-to-zero
514 set rm_mode, 0x2 # round-tp-minus-infinity
515 set rp_mode, 0x3 # round-to-plus-infinity
516
517 set mantissalen, 64 # length of mantissa in bits
518
519 set BYTE, 1 # len(byte) == 1 byte
520 set WORD, 2 # len(word) == 2 bytes
521 set LONG, 4 # len(longword) == 2 bytes
522
523 set BSUN_VEC, 0xc0 # bsun vector offset
524 set INEX_VEC, 0xc4 # inexact vector offset
525 set DZ_VEC, 0xc8 # dz vector offset
526 set UNFL_VEC, 0xcc # unfl vector offset
527 set OPERR_VEC, 0xd0 # operr vector offset
528 set OVFL_VEC, 0xd4 # ovfl vector offset
529 set SNAN_VEC, 0xd8 # snan vector offset
530
531 ###########################
532 # SPecial CONDition FLaGs #
533 ###########################
534 set ftrapcc_flg, 0x01 # flag bit: ftrapcc exception
535 set fbsun_flg, 0x02 # flag bit: bsun exception
536 set mia7_flg, 0x04 # flag bit: (a7)+ <ea>
537 set mda7_flg, 0x08 # flag bit: -(a7) <ea>
538 set fmovm_flg, 0x40 # flag bit: fmovm instruction
539 set immed_flg, 0x80 # flag bit: &<data> <ea>
540
541 set ftrapcc_bit, 0x0
542 set fbsun_bit, 0x1
543 set mia7_bit, 0x2
544 set mda7_bit, 0x3
545 set immed_bit, 0x7
546
547 ##################################
548 # TRANSCENDENTAL "LAST-OP" FLAGS #
549 ##################################
550 set FMUL_OP, 0x0 # fmul instr performed last
551 set FDIV_OP, 0x1 # fdiv performed last
552 set FADD_OP, 0x2 # fadd performed last
553 set FMOV_OP, 0x3 # fmov performed last
554
555 #############
556 # CONSTANTS #
557 #############
558 T1: long 0x40C62D38,0xD3D64634 # 16381 LOG2 LEAD
559 T2: long 0x3D6F90AE,0xB1E75CC7 # 16381 LOG2 TRAIL
560
561 PI: long 0x40000000,0xC90FDAA2,0x2168C235,0x00000000
562 PIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
563
564 TWOBYPI:
565 long 0x3FE45F30,0x6DC9C883
566
567 #########################################################################
568 # MONADIC TEMPLATE #
569 #########################################################################
570 global _fsins_
571 _fsins_:
572 link %a6,&-LOCAL_SIZE
573
574 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
575 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
576 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
577
578 fmov.l &0x0,%fpcr # zero FPCR
579
580 #
581 # copy, convert, and tag input argument
582 #
583 fmov.s 0x8(%a6),%fp0 # load sgl input
584 fmov.x %fp0,FP_SRC(%a6)
585 lea FP_SRC(%a6),%a0
586 bsr.l tag # fetch operand type
587 mov.b %d0,STAG(%a6)
588 mov.b %d0,%d1
589
590 andi.l &0x00ff00ff,USER_FPSR(%a6)
591
592 clr.l %d0
593 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
594
595 tst.b %d1
596 bne.b _L0_2s
597 bsr.l ssin # operand is a NORM
598 bra.b _L0_6s
599 _L0_2s:
600 cmpi.b %d1,&ZERO # is operand a ZERO?
601 bne.b _L0_3s # no
602 bsr.l src_zero # yes
603 bra.b _L0_6s
604 _L0_3s:
605 cmpi.b %d1,&INF # is operand an INF?
606 bne.b _L0_4s # no
607 bsr.l t_operr # yes
608 bra.b _L0_6s
609 _L0_4s:
610 cmpi.b %d1,&QNAN # is operand a QNAN?
611 bne.b _L0_5s # no
612 bsr.l src_qnan # yes
613 bra.b _L0_6s
614 _L0_5s:
615 bsr.l ssind # operand is a DENORM
616 _L0_6s:
617
618 #
619 # Result is now in FP0
620 #
621 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
622 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
623 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
624 unlk %a6
625 rts
626
627 global _fsind_
628 _fsind_:
629 link %a6,&-LOCAL_SIZE
630
631 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
632 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
633 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
634
635 fmov.l &0x0,%fpcr # zero FPCR
636
637 #
638 # copy, convert, and tag input argument
639 #
640 fmov.d 0x8(%a6),%fp0 # load dbl input
641 fmov.x %fp0,FP_SRC(%a6)
642 lea FP_SRC(%a6),%a0
643 bsr.l tag # fetch operand type
644 mov.b %d0,STAG(%a6)
645 mov.b %d0,%d1
646
647 andi.l &0x00ff00ff,USER_FPSR(%a6)
648
649 clr.l %d0
650 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
651
652 mov.b %d1,STAG(%a6)
653 tst.b %d1
654 bne.b _L0_2d
655 bsr.l ssin # operand is a NORM
656 bra.b _L0_6d
657 _L0_2d:
658 cmpi.b %d1,&ZERO # is operand a ZERO?
659 bne.b _L0_3d # no
660 bsr.l src_zero # yes
661 bra.b _L0_6d
662 _L0_3d:
663 cmpi.b %d1,&INF # is operand an INF?
664 bne.b _L0_4d # no
665 bsr.l t_operr # yes
666 bra.b _L0_6d
667 _L0_4d:
668 cmpi.b %d1,&QNAN # is operand a QNAN?
669 bne.b _L0_5d # no
670 bsr.l src_qnan # yes
671 bra.b _L0_6d
672 _L0_5d:
673 bsr.l ssind # operand is a DENORM
674 _L0_6d:
675
676 #
677 # Result is now in FP0
678 #
679 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
680 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
681 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
682 unlk %a6
683 rts
684
685 global _fsinx_
686 _fsinx_:
687 link %a6,&-LOCAL_SIZE
688
689 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
690 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
691 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
692
693 fmov.l &0x0,%fpcr # zero FPCR
694
695 #
696 # copy, convert, and tag input argument
697 #
698 lea FP_SRC(%a6),%a0
699 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
700 mov.l 0x8+0x4(%a6),0x4(%a0)
701 mov.l 0x8+0x8(%a6),0x8(%a0)
702 bsr.l tag # fetch operand type
703 mov.b %d0,STAG(%a6)
704 mov.b %d0,%d1
705
706 andi.l &0x00ff00ff,USER_FPSR(%a6)
707
708 clr.l %d0
709 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
710
711 tst.b %d1
712 bne.b _L0_2x
713 bsr.l ssin # operand is a NORM
714 bra.b _L0_6x
715 _L0_2x:
716 cmpi.b %d1,&ZERO # is operand a ZERO?
717 bne.b _L0_3x # no
718 bsr.l src_zero # yes
719 bra.b _L0_6x
720 _L0_3x:
721 cmpi.b %d1,&INF # is operand an INF?
722 bne.b _L0_4x # no
723 bsr.l t_operr # yes
724 bra.b _L0_6x
725 _L0_4x:
726 cmpi.b %d1,&QNAN # is operand a QNAN?
727 bne.b _L0_5x # no
728 bsr.l src_qnan # yes
729 bra.b _L0_6x
730 _L0_5x:
731 bsr.l ssind # operand is a DENORM
732 _L0_6x:
733
734 #
735 # Result is now in FP0
736 #
737 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
738 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
739 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
740 unlk %a6
741 rts
742
743
744 #########################################################################
745 # MONADIC TEMPLATE #
746 #########################################################################
747 global _fcoss_
748 _fcoss_:
749 link %a6,&-LOCAL_SIZE
750
751 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
752 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
753 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
754
755 fmov.l &0x0,%fpcr # zero FPCR
756
757 #
758 # copy, convert, and tag input argument
759 #
760 fmov.s 0x8(%a6),%fp0 # load sgl input
761 fmov.x %fp0,FP_SRC(%a6)
762 lea FP_SRC(%a6),%a0
763 bsr.l tag # fetch operand type
764 mov.b %d0,STAG(%a6)
765 mov.b %d0,%d1
766
767 andi.l &0x00ff00ff,USER_FPSR(%a6)
768
769 clr.l %d0
770 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
771
772 tst.b %d1
773 bne.b _L1_2s
774 bsr.l scos # operand is a NORM
775 bra.b _L1_6s
776 _L1_2s:
777 cmpi.b %d1,&ZERO # is operand a ZERO?
778 bne.b _L1_3s # no
779 bsr.l ld_pone # yes
780 bra.b _L1_6s
781 _L1_3s:
782 cmpi.b %d1,&INF # is operand an INF?
783 bne.b _L1_4s # no
784 bsr.l t_operr # yes
785 bra.b _L1_6s
786 _L1_4s:
787 cmpi.b %d1,&QNAN # is operand a QNAN?
788 bne.b _L1_5s # no
789 bsr.l src_qnan # yes
790 bra.b _L1_6s
791 _L1_5s:
792 bsr.l scosd # operand is a DENORM
793 _L1_6s:
794
795 #
796 # Result is now in FP0
797 #
798 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
799 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
800 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
801 unlk %a6
802 rts
803
804 global _fcosd_
805 _fcosd_:
806 link %a6,&-LOCAL_SIZE
807
808 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
809 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
810 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
811
812 fmov.l &0x0,%fpcr # zero FPCR
813
814 #
815 # copy, convert, and tag input argument
816 #
817 fmov.d 0x8(%a6),%fp0 # load dbl input
818 fmov.x %fp0,FP_SRC(%a6)
819 lea FP_SRC(%a6),%a0
820 bsr.l tag # fetch operand type
821 mov.b %d0,STAG(%a6)
822 mov.b %d0,%d1
823
824 andi.l &0x00ff00ff,USER_FPSR(%a6)
825
826 clr.l %d0
827 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
828
829 mov.b %d1,STAG(%a6)
830 tst.b %d1
831 bne.b _L1_2d
832 bsr.l scos # operand is a NORM
833 bra.b _L1_6d
834 _L1_2d:
835 cmpi.b %d1,&ZERO # is operand a ZERO?
836 bne.b _L1_3d # no
837 bsr.l ld_pone # yes
838 bra.b _L1_6d
839 _L1_3d:
840 cmpi.b %d1,&INF # is operand an INF?
841 bne.b _L1_4d # no
842 bsr.l t_operr # yes
843 bra.b _L1_6d
844 _L1_4d:
845 cmpi.b %d1,&QNAN # is operand a QNAN?
846 bne.b _L1_5d # no
847 bsr.l src_qnan # yes
848 bra.b _L1_6d
849 _L1_5d:
850 bsr.l scosd # operand is a DENORM
851 _L1_6d:
852
853 #
854 # Result is now in FP0
855 #
856 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
857 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
858 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
859 unlk %a6
860 rts
861
862 global _fcosx_
863 _fcosx_:
864 link %a6,&-LOCAL_SIZE
865
866 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
867 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
868 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
869
870 fmov.l &0x0,%fpcr # zero FPCR
871
872 #
873 # copy, convert, and tag input argument
874 #
875 lea FP_SRC(%a6),%a0
876 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
877 mov.l 0x8+0x4(%a6),0x4(%a0)
878 mov.l 0x8+0x8(%a6),0x8(%a0)
879 bsr.l tag # fetch operand type
880 mov.b %d0,STAG(%a6)
881 mov.b %d0,%d1
882
883 andi.l &0x00ff00ff,USER_FPSR(%a6)
884
885 clr.l %d0
886 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
887
888 tst.b %d1
889 bne.b _L1_2x
890 bsr.l scos # operand is a NORM
891 bra.b _L1_6x
892 _L1_2x:
893 cmpi.b %d1,&ZERO # is operand a ZERO?
894 bne.b _L1_3x # no
895 bsr.l ld_pone # yes
896 bra.b _L1_6x
897 _L1_3x:
898 cmpi.b %d1,&INF # is operand an INF?
899 bne.b _L1_4x # no
900 bsr.l t_operr # yes
901 bra.b _L1_6x
902 _L1_4x:
903 cmpi.b %d1,&QNAN # is operand a QNAN?
904 bne.b _L1_5x # no
905 bsr.l src_qnan # yes
906 bra.b _L1_6x
907 _L1_5x:
908 bsr.l scosd # operand is a DENORM
909 _L1_6x:
910
911 #
912 # Result is now in FP0
913 #
914 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
915 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
916 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
917 unlk %a6
918 rts
919
920
921 #########################################################################
922 # MONADIC TEMPLATE #
923 #########################################################################
924 global _fsinhs_
925 _fsinhs_:
926 link %a6,&-LOCAL_SIZE
927
928 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
929 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
930 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
931
932 fmov.l &0x0,%fpcr # zero FPCR
933
934 #
935 # copy, convert, and tag input argument
936 #
937 fmov.s 0x8(%a6),%fp0 # load sgl input
938 fmov.x %fp0,FP_SRC(%a6)
939 lea FP_SRC(%a6),%a0
940 bsr.l tag # fetch operand type
941 mov.b %d0,STAG(%a6)
942 mov.b %d0,%d1
943
944 andi.l &0x00ff00ff,USER_FPSR(%a6)
945
946 clr.l %d0
947 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
948
949 tst.b %d1
950 bne.b _L2_2s
951 bsr.l ssinh # operand is a NORM
952 bra.b _L2_6s
953 _L2_2s:
954 cmpi.b %d1,&ZERO # is operand a ZERO?
955 bne.b _L2_3s # no
956 bsr.l src_zero # yes
957 bra.b _L2_6s
958 _L2_3s:
959 cmpi.b %d1,&INF # is operand an INF?
960 bne.b _L2_4s # no
961 bsr.l src_inf # yes
962 bra.b _L2_6s
963 _L2_4s:
964 cmpi.b %d1,&QNAN # is operand a QNAN?
965 bne.b _L2_5s # no
966 bsr.l src_qnan # yes
967 bra.b _L2_6s
968 _L2_5s:
969 bsr.l ssinhd # operand is a DENORM
970 _L2_6s:
971
972 #
973 # Result is now in FP0
974 #
975 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
976 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
977 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
978 unlk %a6
979 rts
980
981 global _fsinhd_
982 _fsinhd_:
983 link %a6,&-LOCAL_SIZE
984
985 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
986 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
987 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
988
989 fmov.l &0x0,%fpcr # zero FPCR
990
991 #
992 # copy, convert, and tag input argument
993 #
994 fmov.d 0x8(%a6),%fp0 # load dbl input
995 fmov.x %fp0,FP_SRC(%a6)
996 lea FP_SRC(%a6),%a0
997 bsr.l tag # fetch operand type
998 mov.b %d0,STAG(%a6)
999 mov.b %d0,%d1
1000
1001 andi.l &0x00ff00ff,USER_FPSR(%a6)
1002
1003 clr.l %d0
1004 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1005
1006 mov.b %d1,STAG(%a6)
1007 tst.b %d1
1008 bne.b _L2_2d
1009 bsr.l ssinh # operand is a NORM
1010 bra.b _L2_6d
1011 _L2_2d:
1012 cmpi.b %d1,&ZERO # is operand a ZERO?
1013 bne.b _L2_3d # no
1014 bsr.l src_zero # yes
1015 bra.b _L2_6d
1016 _L2_3d:
1017 cmpi.b %d1,&INF # is operand an INF?
1018 bne.b _L2_4d # no
1019 bsr.l src_inf # yes
1020 bra.b _L2_6d
1021 _L2_4d:
1022 cmpi.b %d1,&QNAN # is operand a QNAN?
1023 bne.b _L2_5d # no
1024 bsr.l src_qnan # yes
1025 bra.b _L2_6d
1026 _L2_5d:
1027 bsr.l ssinhd # operand is a DENORM
1028 _L2_6d:
1029
1030 #
1031 # Result is now in FP0
1032 #
1033 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1034 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1035 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1036 unlk %a6
1037 rts
1038
1039 global _fsinhx_
1040 _fsinhx_:
1041 link %a6,&-LOCAL_SIZE
1042
1043 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1044 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1045 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1046
1047 fmov.l &0x0,%fpcr # zero FPCR
1048
1049 #
1050 # copy, convert, and tag input argument
1051 #
1052 lea FP_SRC(%a6),%a0
1053 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
1054 mov.l 0x8+0x4(%a6),0x4(%a0)
1055 mov.l 0x8+0x8(%a6),0x8(%a0)
1056 bsr.l tag # fetch operand type
1057 mov.b %d0,STAG(%a6)
1058 mov.b %d0,%d1
1059
1060 andi.l &0x00ff00ff,USER_FPSR(%a6)
1061
1062 clr.l %d0
1063 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1064
1065 tst.b %d1
1066 bne.b _L2_2x
1067 bsr.l ssinh # operand is a NORM
1068 bra.b _L2_6x
1069 _L2_2x:
1070 cmpi.b %d1,&ZERO # is operand a ZERO?
1071 bne.b _L2_3x # no
1072 bsr.l src_zero # yes
1073 bra.b _L2_6x
1074 _L2_3x:
1075 cmpi.b %d1,&INF # is operand an INF?
1076 bne.b _L2_4x # no
1077 bsr.l src_inf # yes
1078 bra.b _L2_6x
1079 _L2_4x:
1080 cmpi.b %d1,&QNAN # is operand a QNAN?
1081 bne.b _L2_5x # no
1082 bsr.l src_qnan # yes
1083 bra.b _L2_6x
1084 _L2_5x:
1085 bsr.l ssinhd # operand is a DENORM
1086 _L2_6x:
1087
1088 #
1089 # Result is now in FP0
1090 #
1091 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1092 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1093 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1094 unlk %a6
1095 rts
1096
1097
1098 #########################################################################
1099 # MONADIC TEMPLATE #
1100 #########################################################################
1101 global _flognp1s_
1102 _flognp1s_:
1103 link %a6,&-LOCAL_SIZE
1104
1105 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1106 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1107 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1108
1109 fmov.l &0x0,%fpcr # zero FPCR
1110
1111 #
1112 # copy, convert, and tag input argument
1113 #
1114 fmov.s 0x8(%a6),%fp0 # load sgl input
1115 fmov.x %fp0,FP_SRC(%a6)
1116 lea FP_SRC(%a6),%a0
1117 bsr.l tag # fetch operand type
1118 mov.b %d0,STAG(%a6)
1119 mov.b %d0,%d1
1120
1121 andi.l &0x00ff00ff,USER_FPSR(%a6)
1122
1123 clr.l %d0
1124 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1125
1126 tst.b %d1
1127 bne.b _L3_2s
1128 bsr.l slognp1 # operand is a NORM
1129 bra.b _L3_6s
1130 _L3_2s:
1131 cmpi.b %d1,&ZERO # is operand a ZERO?
1132 bne.b _L3_3s # no
1133 bsr.l src_zero # yes
1134 bra.b _L3_6s
1135 _L3_3s:
1136 cmpi.b %d1,&INF # is operand an INF?
1137 bne.b _L3_4s # no
1138 bsr.l sopr_inf # yes
1139 bra.b _L3_6s
1140 _L3_4s:
1141 cmpi.b %d1,&QNAN # is operand a QNAN?
1142 bne.b _L3_5s # no
1143 bsr.l src_qnan # yes
1144 bra.b _L3_6s
1145 _L3_5s:
1146 bsr.l slognp1d # operand is a DENORM
1147 _L3_6s:
1148
1149 #
1150 # Result is now in FP0
1151 #
1152 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1153 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1154 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1155 unlk %a6
1156 rts
1157
1158 global _flognp1d_
1159 _flognp1d_:
1160 link %a6,&-LOCAL_SIZE
1161
1162 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1163 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1164 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1165
1166 fmov.l &0x0,%fpcr # zero FPCR
1167
1168 #
1169 # copy, convert, and tag input argument
1170 #
1171 fmov.d 0x8(%a6),%fp0 # load dbl input
1172 fmov.x %fp0,FP_SRC(%a6)
1173 lea FP_SRC(%a6),%a0
1174 bsr.l tag # fetch operand type
1175 mov.b %d0,STAG(%a6)
1176 mov.b %d0,%d1
1177
1178 andi.l &0x00ff00ff,USER_FPSR(%a6)
1179
1180 clr.l %d0
1181 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1182
1183 mov.b %d1,STAG(%a6)
1184 tst.b %d1
1185 bne.b _L3_2d
1186 bsr.l slognp1 # operand is a NORM
1187 bra.b _L3_6d
1188 _L3_2d:
1189 cmpi.b %d1,&ZERO # is operand a ZERO?
1190 bne.b _L3_3d # no
1191 bsr.l src_zero # yes
1192 bra.b _L3_6d
1193 _L3_3d:
1194 cmpi.b %d1,&INF # is operand an INF?
1195 bne.b _L3_4d # no
1196 bsr.l sopr_inf # yes
1197 bra.b _L3_6d
1198 _L3_4d:
1199 cmpi.b %d1,&QNAN # is operand a QNAN?
1200 bne.b _L3_5d # no
1201 bsr.l src_qnan # yes
1202 bra.b _L3_6d
1203 _L3_5d:
1204 bsr.l slognp1d # operand is a DENORM
1205 _L3_6d:
1206
1207 #
1208 # Result is now in FP0
1209 #
1210 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1211 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1212 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1213 unlk %a6
1214 rts
1215
1216 global _flognp1x_
1217 _flognp1x_:
1218 link %a6,&-LOCAL_SIZE
1219
1220 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1221 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1222 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1223
1224 fmov.l &0x0,%fpcr # zero FPCR
1225
1226 #
1227 # copy, convert, and tag input argument
1228 #
1229 lea FP_SRC(%a6),%a0
1230 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
1231 mov.l 0x8+0x4(%a6),0x4(%a0)
1232 mov.l 0x8+0x8(%a6),0x8(%a0)
1233 bsr.l tag # fetch operand type
1234 mov.b %d0,STAG(%a6)
1235 mov.b %d0,%d1
1236
1237 andi.l &0x00ff00ff,USER_FPSR(%a6)
1238
1239 clr.l %d0
1240 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1241
1242 tst.b %d1
1243 bne.b _L3_2x
1244 bsr.l slognp1 # operand is a NORM
1245 bra.b _L3_6x
1246 _L3_2x:
1247 cmpi.b %d1,&ZERO # is operand a ZERO?
1248 bne.b _L3_3x # no
1249 bsr.l src_zero # yes
1250 bra.b _L3_6x
1251 _L3_3x:
1252 cmpi.b %d1,&INF # is operand an INF?
1253 bne.b _L3_4x # no
1254 bsr.l sopr_inf # yes
1255 bra.b _L3_6x
1256 _L3_4x:
1257 cmpi.b %d1,&QNAN # is operand a QNAN?
1258 bne.b _L3_5x # no
1259 bsr.l src_qnan # yes
1260 bra.b _L3_6x
1261 _L3_5x:
1262 bsr.l slognp1d # operand is a DENORM
1263 _L3_6x:
1264
1265 #
1266 # Result is now in FP0
1267 #
1268 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1269 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1270 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1271 unlk %a6
1272 rts
1273
1274
1275 #########################################################################
1276 # MONADIC TEMPLATE #
1277 #########################################################################
1278 global _fetoxm1s_
1279 _fetoxm1s_:
1280 link %a6,&-LOCAL_SIZE
1281
1282 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1283 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1284 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1285
1286 fmov.l &0x0,%fpcr # zero FPCR
1287
1288 #
1289 # copy, convert, and tag input argument
1290 #
1291 fmov.s 0x8(%a6),%fp0 # load sgl input
1292 fmov.x %fp0,FP_SRC(%a6)
1293 lea FP_SRC(%a6),%a0
1294 bsr.l tag # fetch operand type
1295 mov.b %d0,STAG(%a6)
1296 mov.b %d0,%d1
1297
1298 andi.l &0x00ff00ff,USER_FPSR(%a6)
1299
1300 clr.l %d0
1301 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1302
1303 tst.b %d1
1304 bne.b _L4_2s
1305 bsr.l setoxm1 # operand is a NORM
1306 bra.b _L4_6s
1307 _L4_2s:
1308 cmpi.b %d1,&ZERO # is operand a ZERO?
1309 bne.b _L4_3s # no
1310 bsr.l src_zero # yes
1311 bra.b _L4_6s
1312 _L4_3s:
1313 cmpi.b %d1,&INF # is operand an INF?
1314 bne.b _L4_4s # no
1315 bsr.l setoxm1i # yes
1316 bra.b _L4_6s
1317 _L4_4s:
1318 cmpi.b %d1,&QNAN # is operand a QNAN?
1319 bne.b _L4_5s # no
1320 bsr.l src_qnan # yes
1321 bra.b _L4_6s
1322 _L4_5s:
1323 bsr.l setoxm1d # operand is a DENORM
1324 _L4_6s:
1325
1326 #
1327 # Result is now in FP0
1328 #
1329 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1330 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1331 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1332 unlk %a6
1333 rts
1334
1335 global _fetoxm1d_
1336 _fetoxm1d_:
1337 link %a6,&-LOCAL_SIZE
1338
1339 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1340 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1341 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1342
1343 fmov.l &0x0,%fpcr # zero FPCR
1344
1345 #
1346 # copy, convert, and tag input argument
1347 #
1348 fmov.d 0x8(%a6),%fp0 # load dbl input
1349 fmov.x %fp0,FP_SRC(%a6)
1350 lea FP_SRC(%a6),%a0
1351 bsr.l tag # fetch operand type
1352 mov.b %d0,STAG(%a6)
1353 mov.b %d0,%d1
1354
1355 andi.l &0x00ff00ff,USER_FPSR(%a6)
1356
1357 clr.l %d0
1358 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1359
1360 mov.b %d1,STAG(%a6)
1361 tst.b %d1
1362 bne.b _L4_2d
1363 bsr.l setoxm1 # operand is a NORM
1364 bra.b _L4_6d
1365 _L4_2d:
1366 cmpi.b %d1,&ZERO # is operand a ZERO?
1367 bne.b _L4_3d # no
1368 bsr.l src_zero # yes
1369 bra.b _L4_6d
1370 _L4_3d:
1371 cmpi.b %d1,&INF # is operand an INF?
1372 bne.b _L4_4d # no
1373 bsr.l setoxm1i # yes
1374 bra.b _L4_6d
1375 _L4_4d:
1376 cmpi.b %d1,&QNAN # is operand a QNAN?
1377 bne.b _L4_5d # no
1378 bsr.l src_qnan # yes
1379 bra.b _L4_6d
1380 _L4_5d:
1381 bsr.l setoxm1d # operand is a DENORM
1382 _L4_6d:
1383
1384 #
1385 # Result is now in FP0
1386 #
1387 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1388 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1389 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1390 unlk %a6
1391 rts
1392
1393 global _fetoxm1x_
1394 _fetoxm1x_:
1395 link %a6,&-LOCAL_SIZE
1396
1397 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1398 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1399 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1400
1401 fmov.l &0x0,%fpcr # zero FPCR
1402
1403 #
1404 # copy, convert, and tag input argument
1405 #
1406 lea FP_SRC(%a6),%a0
1407 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
1408 mov.l 0x8+0x4(%a6),0x4(%a0)
1409 mov.l 0x8+0x8(%a6),0x8(%a0)
1410 bsr.l tag # fetch operand type
1411 mov.b %d0,STAG(%a6)
1412 mov.b %d0,%d1
1413
1414 andi.l &0x00ff00ff,USER_FPSR(%a6)
1415
1416 clr.l %d0
1417 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1418
1419 tst.b %d1
1420 bne.b _L4_2x
1421 bsr.l setoxm1 # operand is a NORM
1422 bra.b _L4_6x
1423 _L4_2x:
1424 cmpi.b %d1,&ZERO # is operand a ZERO?
1425 bne.b _L4_3x # no
1426 bsr.l src_zero # yes
1427 bra.b _L4_6x
1428 _L4_3x:
1429 cmpi.b %d1,&INF # is operand an INF?
1430 bne.b _L4_4x # no
1431 bsr.l setoxm1i # yes
1432 bra.b _L4_6x
1433 _L4_4x:
1434 cmpi.b %d1,&QNAN # is operand a QNAN?
1435 bne.b _L4_5x # no
1436 bsr.l src_qnan # yes
1437 bra.b _L4_6x
1438 _L4_5x:
1439 bsr.l setoxm1d # operand is a DENORM
1440 _L4_6x:
1441
1442 #
1443 # Result is now in FP0
1444 #
1445 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1446 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1447 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1448 unlk %a6
1449 rts
1450
1451
1452 #########################################################################
1453 # MONADIC TEMPLATE #
1454 #########################################################################
1455 global _ftanhs_
1456 _ftanhs_:
1457 link %a6,&-LOCAL_SIZE
1458
1459 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1460 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1461 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1462
1463 fmov.l &0x0,%fpcr # zero FPCR
1464
1465 #
1466 # copy, convert, and tag input argument
1467 #
1468 fmov.s 0x8(%a6),%fp0 # load sgl input
1469 fmov.x %fp0,FP_SRC(%a6)
1470 lea FP_SRC(%a6),%a0
1471 bsr.l tag # fetch operand type
1472 mov.b %d0,STAG(%a6)
1473 mov.b %d0,%d1
1474
1475 andi.l &0x00ff00ff,USER_FPSR(%a6)
1476
1477 clr.l %d0
1478 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1479
1480 tst.b %d1
1481 bne.b _L5_2s
1482 bsr.l stanh # operand is a NORM
1483 bra.b _L5_6s
1484 _L5_2s:
1485 cmpi.b %d1,&ZERO # is operand a ZERO?
1486 bne.b _L5_3s # no
1487 bsr.l src_zero # yes
1488 bra.b _L5_6s
1489 _L5_3s:
1490 cmpi.b %d1,&INF # is operand an INF?
1491 bne.b _L5_4s # no
1492 bsr.l src_one # yes
1493 bra.b _L5_6s
1494 _L5_4s:
1495 cmpi.b %d1,&QNAN # is operand a QNAN?
1496 bne.b _L5_5s # no
1497 bsr.l src_qnan # yes
1498 bra.b _L5_6s
1499 _L5_5s:
1500 bsr.l stanhd # operand is a DENORM
1501 _L5_6s:
1502
1503 #
1504 # Result is now in FP0
1505 #
1506 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1507 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1508 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1509 unlk %a6
1510 rts
1511
1512 global _ftanhd_
1513 _ftanhd_:
1514 link %a6,&-LOCAL_SIZE
1515
1516 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1517 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1518 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1519
1520 fmov.l &0x0,%fpcr # zero FPCR
1521
1522 #
1523 # copy, convert, and tag input argument
1524 #
1525 fmov.d 0x8(%a6),%fp0 # load dbl input
1526 fmov.x %fp0,FP_SRC(%a6)
1527 lea FP_SRC(%a6),%a0
1528 bsr.l tag # fetch operand type
1529 mov.b %d0,STAG(%a6)
1530 mov.b %d0,%d1
1531
1532 andi.l &0x00ff00ff,USER_FPSR(%a6)
1533
1534 clr.l %d0
1535 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1536
1537 mov.b %d1,STAG(%a6)
1538 tst.b %d1
1539 bne.b _L5_2d
1540 bsr.l stanh # operand is a NORM
1541 bra.b _L5_6d
1542 _L5_2d:
1543 cmpi.b %d1,&ZERO # is operand a ZERO?
1544 bne.b _L5_3d # no
1545 bsr.l src_zero # yes
1546 bra.b _L5_6d
1547 _L5_3d:
1548 cmpi.b %d1,&INF # is operand an INF?
1549 bne.b _L5_4d # no
1550 bsr.l src_one # yes
1551 bra.b _L5_6d
1552 _L5_4d:
1553 cmpi.b %d1,&QNAN # is operand a QNAN?
1554 bne.b _L5_5d # no
1555 bsr.l src_qnan # yes
1556 bra.b _L5_6d
1557 _L5_5d:
1558 bsr.l stanhd # operand is a DENORM
1559 _L5_6d:
1560
1561 #
1562 # Result is now in FP0
1563 #
1564 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1565 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1566 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1567 unlk %a6
1568 rts
1569
1570 global _ftanhx_
1571 _ftanhx_:
1572 link %a6,&-LOCAL_SIZE
1573
1574 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1575 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1576 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1577
1578 fmov.l &0x0,%fpcr # zero FPCR
1579
1580 #
1581 # copy, convert, and tag input argument
1582 #
1583 lea FP_SRC(%a6),%a0
1584 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
1585 mov.l 0x8+0x4(%a6),0x4(%a0)
1586 mov.l 0x8+0x8(%a6),0x8(%a0)
1587 bsr.l tag # fetch operand type
1588 mov.b %d0,STAG(%a6)
1589 mov.b %d0,%d1
1590
1591 andi.l &0x00ff00ff,USER_FPSR(%a6)
1592
1593 clr.l %d0
1594 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1595
1596 tst.b %d1
1597 bne.b _L5_2x
1598 bsr.l stanh # operand is a NORM
1599 bra.b _L5_6x
1600 _L5_2x:
1601 cmpi.b %d1,&ZERO # is operand a ZERO?
1602 bne.b _L5_3x # no
1603 bsr.l src_zero # yes
1604 bra.b _L5_6x
1605 _L5_3x:
1606 cmpi.b %d1,&INF # is operand an INF?
1607 bne.b _L5_4x # no
1608 bsr.l src_one # yes
1609 bra.b _L5_6x
1610 _L5_4x:
1611 cmpi.b %d1,&QNAN # is operand a QNAN?
1612 bne.b _L5_5x # no
1613 bsr.l src_qnan # yes
1614 bra.b _L5_6x
1615 _L5_5x:
1616 bsr.l stanhd # operand is a DENORM
1617 _L5_6x:
1618
1619 #
1620 # Result is now in FP0
1621 #
1622 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1623 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1624 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1625 unlk %a6
1626 rts
1627
1628
1629 #########################################################################
1630 # MONADIC TEMPLATE #
1631 #########################################################################
1632 global _fatans_
1633 _fatans_:
1634 link %a6,&-LOCAL_SIZE
1635
1636 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1637 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1638 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1639
1640 fmov.l &0x0,%fpcr # zero FPCR
1641
1642 #
1643 # copy, convert, and tag input argument
1644 #
1645 fmov.s 0x8(%a6),%fp0 # load sgl input
1646 fmov.x %fp0,FP_SRC(%a6)
1647 lea FP_SRC(%a6),%a0
1648 bsr.l tag # fetch operand type
1649 mov.b %d0,STAG(%a6)
1650 mov.b %d0,%d1
1651
1652 andi.l &0x00ff00ff,USER_FPSR(%a6)
1653
1654 clr.l %d0
1655 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1656
1657 tst.b %d1
1658 bne.b _L6_2s
1659 bsr.l satan # operand is a NORM
1660 bra.b _L6_6s
1661 _L6_2s:
1662 cmpi.b %d1,&ZERO # is operand a ZERO?
1663 bne.b _L6_3s # no
1664 bsr.l src_zero # yes
1665 bra.b _L6_6s
1666 _L6_3s:
1667 cmpi.b %d1,&INF # is operand an INF?
1668 bne.b _L6_4s # no
1669 bsr.l spi_2 # yes
1670 bra.b _L6_6s
1671 _L6_4s:
1672 cmpi.b %d1,&QNAN # is operand a QNAN?
1673 bne.b _L6_5s # no
1674 bsr.l src_qnan # yes
1675 bra.b _L6_6s
1676 _L6_5s:
1677 bsr.l satand # operand is a DENORM
1678 _L6_6s:
1679
1680 #
1681 # Result is now in FP0
1682 #
1683 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1684 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1685 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1686 unlk %a6
1687 rts
1688
1689 global _fatand_
1690 _fatand_:
1691 link %a6,&-LOCAL_SIZE
1692
1693 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1694 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1695 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1696
1697 fmov.l &0x0,%fpcr # zero FPCR
1698
1699 #
1700 # copy, convert, and tag input argument
1701 #
1702 fmov.d 0x8(%a6),%fp0 # load dbl input
1703 fmov.x %fp0,FP_SRC(%a6)
1704 lea FP_SRC(%a6),%a0
1705 bsr.l tag # fetch operand type
1706 mov.b %d0,STAG(%a6)
1707 mov.b %d0,%d1
1708
1709 andi.l &0x00ff00ff,USER_FPSR(%a6)
1710
1711 clr.l %d0
1712 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1713
1714 mov.b %d1,STAG(%a6)
1715 tst.b %d1
1716 bne.b _L6_2d
1717 bsr.l satan # operand is a NORM
1718 bra.b _L6_6d
1719 _L6_2d:
1720 cmpi.b %d1,&ZERO # is operand a ZERO?
1721 bne.b _L6_3d # no
1722 bsr.l src_zero # yes
1723 bra.b _L6_6d
1724 _L6_3d:
1725 cmpi.b %d1,&INF # is operand an INF?
1726 bne.b _L6_4d # no
1727 bsr.l spi_2 # yes
1728 bra.b _L6_6d
1729 _L6_4d:
1730 cmpi.b %d1,&QNAN # is operand a QNAN?
1731 bne.b _L6_5d # no
1732 bsr.l src_qnan # yes
1733 bra.b _L6_6d
1734 _L6_5d:
1735 bsr.l satand # operand is a DENORM
1736 _L6_6d:
1737
1738 #
1739 # Result is now in FP0
1740 #
1741 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1742 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1743 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1744 unlk %a6
1745 rts
1746
1747 global _fatanx_
1748 _fatanx_:
1749 link %a6,&-LOCAL_SIZE
1750
1751 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1752 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1753 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1754
1755 fmov.l &0x0,%fpcr # zero FPCR
1756
1757 #
1758 # copy, convert, and tag input argument
1759 #
1760 lea FP_SRC(%a6),%a0
1761 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
1762 mov.l 0x8+0x4(%a6),0x4(%a0)
1763 mov.l 0x8+0x8(%a6),0x8(%a0)
1764 bsr.l tag # fetch operand type
1765 mov.b %d0,STAG(%a6)
1766 mov.b %d0,%d1
1767
1768 andi.l &0x00ff00ff,USER_FPSR(%a6)
1769
1770 clr.l %d0
1771 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1772
1773 tst.b %d1
1774 bne.b _L6_2x
1775 bsr.l satan # operand is a NORM
1776 bra.b _L6_6x
1777 _L6_2x:
1778 cmpi.b %d1,&ZERO # is operand a ZERO?
1779 bne.b _L6_3x # no
1780 bsr.l src_zero # yes
1781 bra.b _L6_6x
1782 _L6_3x:
1783 cmpi.b %d1,&INF # is operand an INF?
1784 bne.b _L6_4x # no
1785 bsr.l spi_2 # yes
1786 bra.b _L6_6x
1787 _L6_4x:
1788 cmpi.b %d1,&QNAN # is operand a QNAN?
1789 bne.b _L6_5x # no
1790 bsr.l src_qnan # yes
1791 bra.b _L6_6x
1792 _L6_5x:
1793 bsr.l satand # operand is a DENORM
1794 _L6_6x:
1795
1796 #
1797 # Result is now in FP0
1798 #
1799 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1800 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1801 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1802 unlk %a6
1803 rts
1804
1805
1806 #########################################################################
1807 # MONADIC TEMPLATE #
1808 #########################################################################
1809 global _fasins_
1810 _fasins_:
1811 link %a6,&-LOCAL_SIZE
1812
1813 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1814 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1815 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1816
1817 fmov.l &0x0,%fpcr # zero FPCR
1818
1819 #
1820 # copy, convert, and tag input argument
1821 #
1822 fmov.s 0x8(%a6),%fp0 # load sgl input
1823 fmov.x %fp0,FP_SRC(%a6)
1824 lea FP_SRC(%a6),%a0
1825 bsr.l tag # fetch operand type
1826 mov.b %d0,STAG(%a6)
1827 mov.b %d0,%d1
1828
1829 andi.l &0x00ff00ff,USER_FPSR(%a6)
1830
1831 clr.l %d0
1832 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1833
1834 tst.b %d1
1835 bne.b _L7_2s
1836 bsr.l sasin # operand is a NORM
1837 bra.b _L7_6s
1838 _L7_2s:
1839 cmpi.b %d1,&ZERO # is operand a ZERO?
1840 bne.b _L7_3s # no
1841 bsr.l src_zero # yes
1842 bra.b _L7_6s
1843 _L7_3s:
1844 cmpi.b %d1,&INF # is operand an INF?
1845 bne.b _L7_4s # no
1846 bsr.l t_operr # yes
1847 bra.b _L7_6s
1848 _L7_4s:
1849 cmpi.b %d1,&QNAN # is operand a QNAN?
1850 bne.b _L7_5s # no
1851 bsr.l src_qnan # yes
1852 bra.b _L7_6s
1853 _L7_5s:
1854 bsr.l sasind # operand is a DENORM
1855 _L7_6s:
1856
1857 #
1858 # Result is now in FP0
1859 #
1860 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1861 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1862 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1863 unlk %a6
1864 rts
1865
1866 global _fasind_
1867 _fasind_:
1868 link %a6,&-LOCAL_SIZE
1869
1870 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1871 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1872 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1873
1874 fmov.l &0x0,%fpcr # zero FPCR
1875
1876 #
1877 # copy, convert, and tag input argument
1878 #
1879 fmov.d 0x8(%a6),%fp0 # load dbl input
1880 fmov.x %fp0,FP_SRC(%a6)
1881 lea FP_SRC(%a6),%a0
1882 bsr.l tag # fetch operand type
1883 mov.b %d0,STAG(%a6)
1884 mov.b %d0,%d1
1885
1886 andi.l &0x00ff00ff,USER_FPSR(%a6)
1887
1888 clr.l %d0
1889 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1890
1891 mov.b %d1,STAG(%a6)
1892 tst.b %d1
1893 bne.b _L7_2d
1894 bsr.l sasin # operand is a NORM
1895 bra.b _L7_6d
1896 _L7_2d:
1897 cmpi.b %d1,&ZERO # is operand a ZERO?
1898 bne.b _L7_3d # no
1899 bsr.l src_zero # yes
1900 bra.b _L7_6d
1901 _L7_3d:
1902 cmpi.b %d1,&INF # is operand an INF?
1903 bne.b _L7_4d # no
1904 bsr.l t_operr # yes
1905 bra.b _L7_6d
1906 _L7_4d:
1907 cmpi.b %d1,&QNAN # is operand a QNAN?
1908 bne.b _L7_5d # no
1909 bsr.l src_qnan # yes
1910 bra.b _L7_6d
1911 _L7_5d:
1912 bsr.l sasind # operand is a DENORM
1913 _L7_6d:
1914
1915 #
1916 # Result is now in FP0
1917 #
1918 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1919 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1920 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1921 unlk %a6
1922 rts
1923
1924 global _fasinx_
1925 _fasinx_:
1926 link %a6,&-LOCAL_SIZE
1927
1928 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1929 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1930 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1931
1932 fmov.l &0x0,%fpcr # zero FPCR
1933
1934 #
1935 # copy, convert, and tag input argument
1936 #
1937 lea FP_SRC(%a6),%a0
1938 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
1939 mov.l 0x8+0x4(%a6),0x4(%a0)
1940 mov.l 0x8+0x8(%a6),0x8(%a0)
1941 bsr.l tag # fetch operand type
1942 mov.b %d0,STAG(%a6)
1943 mov.b %d0,%d1
1944
1945 andi.l &0x00ff00ff,USER_FPSR(%a6)
1946
1947 clr.l %d0
1948 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
1949
1950 tst.b %d1
1951 bne.b _L7_2x
1952 bsr.l sasin # operand is a NORM
1953 bra.b _L7_6x
1954 _L7_2x:
1955 cmpi.b %d1,&ZERO # is operand a ZERO?
1956 bne.b _L7_3x # no
1957 bsr.l src_zero # yes
1958 bra.b _L7_6x
1959 _L7_3x:
1960 cmpi.b %d1,&INF # is operand an INF?
1961 bne.b _L7_4x # no
1962 bsr.l t_operr # yes
1963 bra.b _L7_6x
1964 _L7_4x:
1965 cmpi.b %d1,&QNAN # is operand a QNAN?
1966 bne.b _L7_5x # no
1967 bsr.l src_qnan # yes
1968 bra.b _L7_6x
1969 _L7_5x:
1970 bsr.l sasind # operand is a DENORM
1971 _L7_6x:
1972
1973 #
1974 # Result is now in FP0
1975 #
1976 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
1977 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1978 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
1979 unlk %a6
1980 rts
1981
1982
1983 #########################################################################
1984 # MONADIC TEMPLATE #
1985 #########################################################################
1986 global _fatanhs_
1987 _fatanhs_:
1988 link %a6,&-LOCAL_SIZE
1989
1990 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
1991 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1992 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
1993
1994 fmov.l &0x0,%fpcr # zero FPCR
1995
1996 #
1997 # copy, convert, and tag input argument
1998 #
1999 fmov.s 0x8(%a6),%fp0 # load sgl input
2000 fmov.x %fp0,FP_SRC(%a6)
2001 lea FP_SRC(%a6),%a0
2002 bsr.l tag # fetch operand type
2003 mov.b %d0,STAG(%a6)
2004 mov.b %d0,%d1
2005
2006 andi.l &0x00ff00ff,USER_FPSR(%a6)
2007
2008 clr.l %d0
2009 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2010
2011 tst.b %d1
2012 bne.b _L8_2s
2013 bsr.l satanh # operand is a NORM
2014 bra.b _L8_6s
2015 _L8_2s:
2016 cmpi.b %d1,&ZERO # is operand a ZERO?
2017 bne.b _L8_3s # no
2018 bsr.l src_zero # yes
2019 bra.b _L8_6s
2020 _L8_3s:
2021 cmpi.b %d1,&INF # is operand an INF?
2022 bne.b _L8_4s # no
2023 bsr.l t_operr # yes
2024 bra.b _L8_6s
2025 _L8_4s:
2026 cmpi.b %d1,&QNAN # is operand a QNAN?
2027 bne.b _L8_5s # no
2028 bsr.l src_qnan # yes
2029 bra.b _L8_6s
2030 _L8_5s:
2031 bsr.l satanhd # operand is a DENORM
2032 _L8_6s:
2033
2034 #
2035 # Result is now in FP0
2036 #
2037 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2038 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2039 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2040 unlk %a6
2041 rts
2042
2043 global _fatanhd_
2044 _fatanhd_:
2045 link %a6,&-LOCAL_SIZE
2046
2047 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2048 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2049 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2050
2051 fmov.l &0x0,%fpcr # zero FPCR
2052
2053 #
2054 # copy, convert, and tag input argument
2055 #
2056 fmov.d 0x8(%a6),%fp0 # load dbl input
2057 fmov.x %fp0,FP_SRC(%a6)
2058 lea FP_SRC(%a6),%a0
2059 bsr.l tag # fetch operand type
2060 mov.b %d0,STAG(%a6)
2061 mov.b %d0,%d1
2062
2063 andi.l &0x00ff00ff,USER_FPSR(%a6)
2064
2065 clr.l %d0
2066 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2067
2068 mov.b %d1,STAG(%a6)
2069 tst.b %d1
2070 bne.b _L8_2d
2071 bsr.l satanh # operand is a NORM
2072 bra.b _L8_6d
2073 _L8_2d:
2074 cmpi.b %d1,&ZERO # is operand a ZERO?
2075 bne.b _L8_3d # no
2076 bsr.l src_zero # yes
2077 bra.b _L8_6d
2078 _L8_3d:
2079 cmpi.b %d1,&INF # is operand an INF?
2080 bne.b _L8_4d # no
2081 bsr.l t_operr # yes
2082 bra.b _L8_6d
2083 _L8_4d:
2084 cmpi.b %d1,&QNAN # is operand a QNAN?
2085 bne.b _L8_5d # no
2086 bsr.l src_qnan # yes
2087 bra.b _L8_6d
2088 _L8_5d:
2089 bsr.l satanhd # operand is a DENORM
2090 _L8_6d:
2091
2092 #
2093 # Result is now in FP0
2094 #
2095 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2096 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2097 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2098 unlk %a6
2099 rts
2100
2101 global _fatanhx_
2102 _fatanhx_:
2103 link %a6,&-LOCAL_SIZE
2104
2105 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2106 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2107 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2108
2109 fmov.l &0x0,%fpcr # zero FPCR
2110
2111 #
2112 # copy, convert, and tag input argument
2113 #
2114 lea FP_SRC(%a6),%a0
2115 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
2116 mov.l 0x8+0x4(%a6),0x4(%a0)
2117 mov.l 0x8+0x8(%a6),0x8(%a0)
2118 bsr.l tag # fetch operand type
2119 mov.b %d0,STAG(%a6)
2120 mov.b %d0,%d1
2121
2122 andi.l &0x00ff00ff,USER_FPSR(%a6)
2123
2124 clr.l %d0
2125 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2126
2127 tst.b %d1
2128 bne.b _L8_2x
2129 bsr.l satanh # operand is a NORM
2130 bra.b _L8_6x
2131 _L8_2x:
2132 cmpi.b %d1,&ZERO # is operand a ZERO?
2133 bne.b _L8_3x # no
2134 bsr.l src_zero # yes
2135 bra.b _L8_6x
2136 _L8_3x:
2137 cmpi.b %d1,&INF # is operand an INF?
2138 bne.b _L8_4x # no
2139 bsr.l t_operr # yes
2140 bra.b _L8_6x
2141 _L8_4x:
2142 cmpi.b %d1,&QNAN # is operand a QNAN?
2143 bne.b _L8_5x # no
2144 bsr.l src_qnan # yes
2145 bra.b _L8_6x
2146 _L8_5x:
2147 bsr.l satanhd # operand is a DENORM
2148 _L8_6x:
2149
2150 #
2151 # Result is now in FP0
2152 #
2153 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2154 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2155 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2156 unlk %a6
2157 rts
2158
2159
2160 #########################################################################
2161 # MONADIC TEMPLATE #
2162 #########################################################################
2163 global _ftans_
2164 _ftans_:
2165 link %a6,&-LOCAL_SIZE
2166
2167 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2168 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2169 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2170
2171 fmov.l &0x0,%fpcr # zero FPCR
2172
2173 #
2174 # copy, convert, and tag input argument
2175 #
2176 fmov.s 0x8(%a6),%fp0 # load sgl input
2177 fmov.x %fp0,FP_SRC(%a6)
2178 lea FP_SRC(%a6),%a0
2179 bsr.l tag # fetch operand type
2180 mov.b %d0,STAG(%a6)
2181 mov.b %d0,%d1
2182
2183 andi.l &0x00ff00ff,USER_FPSR(%a6)
2184
2185 clr.l %d0
2186 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2187
2188 tst.b %d1
2189 bne.b _L9_2s
2190 bsr.l stan # operand is a NORM
2191 bra.b _L9_6s
2192 _L9_2s:
2193 cmpi.b %d1,&ZERO # is operand a ZERO?
2194 bne.b _L9_3s # no
2195 bsr.l src_zero # yes
2196 bra.b _L9_6s
2197 _L9_3s:
2198 cmpi.b %d1,&INF # is operand an INF?
2199 bne.b _L9_4s # no
2200 bsr.l t_operr # yes
2201 bra.b _L9_6s
2202 _L9_4s:
2203 cmpi.b %d1,&QNAN # is operand a QNAN?
2204 bne.b _L9_5s # no
2205 bsr.l src_qnan # yes
2206 bra.b _L9_6s
2207 _L9_5s:
2208 bsr.l stand # operand is a DENORM
2209 _L9_6s:
2210
2211 #
2212 # Result is now in FP0
2213 #
2214 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2215 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2216 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2217 unlk %a6
2218 rts
2219
2220 global _ftand_
2221 _ftand_:
2222 link %a6,&-LOCAL_SIZE
2223
2224 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2225 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2226 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2227
2228 fmov.l &0x0,%fpcr # zero FPCR
2229
2230 #
2231 # copy, convert, and tag input argument
2232 #
2233 fmov.d 0x8(%a6),%fp0 # load dbl input
2234 fmov.x %fp0,FP_SRC(%a6)
2235 lea FP_SRC(%a6),%a0
2236 bsr.l tag # fetch operand type
2237 mov.b %d0,STAG(%a6)
2238 mov.b %d0,%d1
2239
2240 andi.l &0x00ff00ff,USER_FPSR(%a6)
2241
2242 clr.l %d0
2243 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2244
2245 mov.b %d1,STAG(%a6)
2246 tst.b %d1
2247 bne.b _L9_2d
2248 bsr.l stan # operand is a NORM
2249 bra.b _L9_6d
2250 _L9_2d:
2251 cmpi.b %d1,&ZERO # is operand a ZERO?
2252 bne.b _L9_3d # no
2253 bsr.l src_zero # yes
2254 bra.b _L9_6d
2255 _L9_3d:
2256 cmpi.b %d1,&INF # is operand an INF?
2257 bne.b _L9_4d # no
2258 bsr.l t_operr # yes
2259 bra.b _L9_6d
2260 _L9_4d:
2261 cmpi.b %d1,&QNAN # is operand a QNAN?
2262 bne.b _L9_5d # no
2263 bsr.l src_qnan # yes
2264 bra.b _L9_6d
2265 _L9_5d:
2266 bsr.l stand # operand is a DENORM
2267 _L9_6d:
2268
2269 #
2270 # Result is now in FP0
2271 #
2272 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2273 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2274 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2275 unlk %a6
2276 rts
2277
2278 global _ftanx_
2279 _ftanx_:
2280 link %a6,&-LOCAL_SIZE
2281
2282 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2283 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2284 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2285
2286 fmov.l &0x0,%fpcr # zero FPCR
2287
2288 #
2289 # copy, convert, and tag input argument
2290 #
2291 lea FP_SRC(%a6),%a0
2292 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
2293 mov.l 0x8+0x4(%a6),0x4(%a0)
2294 mov.l 0x8+0x8(%a6),0x8(%a0)
2295 bsr.l tag # fetch operand type
2296 mov.b %d0,STAG(%a6)
2297 mov.b %d0,%d1
2298
2299 andi.l &0x00ff00ff,USER_FPSR(%a6)
2300
2301 clr.l %d0
2302 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2303
2304 tst.b %d1
2305 bne.b _L9_2x
2306 bsr.l stan # operand is a NORM
2307 bra.b _L9_6x
2308 _L9_2x:
2309 cmpi.b %d1,&ZERO # is operand a ZERO?
2310 bne.b _L9_3x # no
2311 bsr.l src_zero # yes
2312 bra.b _L9_6x
2313 _L9_3x:
2314 cmpi.b %d1,&INF # is operand an INF?
2315 bne.b _L9_4x # no
2316 bsr.l t_operr # yes
2317 bra.b _L9_6x
2318 _L9_4x:
2319 cmpi.b %d1,&QNAN # is operand a QNAN?
2320 bne.b _L9_5x # no
2321 bsr.l src_qnan # yes
2322 bra.b _L9_6x
2323 _L9_5x:
2324 bsr.l stand # operand is a DENORM
2325 _L9_6x:
2326
2327 #
2328 # Result is now in FP0
2329 #
2330 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2331 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2332 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2333 unlk %a6
2334 rts
2335
2336
2337 #########################################################################
2338 # MONADIC TEMPLATE #
2339 #########################################################################
2340 global _fetoxs_
2341 _fetoxs_:
2342 link %a6,&-LOCAL_SIZE
2343
2344 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2345 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2346 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2347
2348 fmov.l &0x0,%fpcr # zero FPCR
2349
2350 #
2351 # copy, convert, and tag input argument
2352 #
2353 fmov.s 0x8(%a6),%fp0 # load sgl input
2354 fmov.x %fp0,FP_SRC(%a6)
2355 lea FP_SRC(%a6),%a0
2356 bsr.l tag # fetch operand type
2357 mov.b %d0,STAG(%a6)
2358 mov.b %d0,%d1
2359
2360 andi.l &0x00ff00ff,USER_FPSR(%a6)
2361
2362 clr.l %d0
2363 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2364
2365 tst.b %d1
2366 bne.b _L10_2s
2367 bsr.l setox # operand is a NORM
2368 bra.b _L10_6s
2369 _L10_2s:
2370 cmpi.b %d1,&ZERO # is operand a ZERO?
2371 bne.b _L10_3s # no
2372 bsr.l ld_pone # yes
2373 bra.b _L10_6s
2374 _L10_3s:
2375 cmpi.b %d1,&INF # is operand an INF?
2376 bne.b _L10_4s # no
2377 bsr.l szr_inf # yes
2378 bra.b _L10_6s
2379 _L10_4s:
2380 cmpi.b %d1,&QNAN # is operand a QNAN?
2381 bne.b _L10_5s # no
2382 bsr.l src_qnan # yes
2383 bra.b _L10_6s
2384 _L10_5s:
2385 bsr.l setoxd # operand is a DENORM
2386 _L10_6s:
2387
2388 #
2389 # Result is now in FP0
2390 #
2391 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2392 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2393 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2394 unlk %a6
2395 rts
2396
2397 global _fetoxd_
2398 _fetoxd_:
2399 link %a6,&-LOCAL_SIZE
2400
2401 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2402 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2403 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2404
2405 fmov.l &0x0,%fpcr # zero FPCR
2406
2407 #
2408 # copy, convert, and tag input argument
2409 #
2410 fmov.d 0x8(%a6),%fp0 # load dbl input
2411 fmov.x %fp0,FP_SRC(%a6)
2412 lea FP_SRC(%a6),%a0
2413 bsr.l tag # fetch operand type
2414 mov.b %d0,STAG(%a6)
2415 mov.b %d0,%d1
2416
2417 andi.l &0x00ff00ff,USER_FPSR(%a6)
2418
2419 clr.l %d0
2420 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2421
2422 mov.b %d1,STAG(%a6)
2423 tst.b %d1
2424 bne.b _L10_2d
2425 bsr.l setox # operand is a NORM
2426 bra.b _L10_6d
2427 _L10_2d:
2428 cmpi.b %d1,&ZERO # is operand a ZERO?
2429 bne.b _L10_3d # no
2430 bsr.l ld_pone # yes
2431 bra.b _L10_6d
2432 _L10_3d:
2433 cmpi.b %d1,&INF # is operand an INF?
2434 bne.b _L10_4d # no
2435 bsr.l szr_inf # yes
2436 bra.b _L10_6d
2437 _L10_4d:
2438 cmpi.b %d1,&QNAN # is operand a QNAN?
2439 bne.b _L10_5d # no
2440 bsr.l src_qnan # yes
2441 bra.b _L10_6d
2442 _L10_5d:
2443 bsr.l setoxd # operand is a DENORM
2444 _L10_6d:
2445
2446 #
2447 # Result is now in FP0
2448 #
2449 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2450 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2451 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2452 unlk %a6
2453 rts
2454
2455 global _fetoxx_
2456 _fetoxx_:
2457 link %a6,&-LOCAL_SIZE
2458
2459 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2460 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2461 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2462
2463 fmov.l &0x0,%fpcr # zero FPCR
2464
2465 #
2466 # copy, convert, and tag input argument
2467 #
2468 lea FP_SRC(%a6),%a0
2469 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
2470 mov.l 0x8+0x4(%a6),0x4(%a0)
2471 mov.l 0x8+0x8(%a6),0x8(%a0)
2472 bsr.l tag # fetch operand type
2473 mov.b %d0,STAG(%a6)
2474 mov.b %d0,%d1
2475
2476 andi.l &0x00ff00ff,USER_FPSR(%a6)
2477
2478 clr.l %d0
2479 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2480
2481 tst.b %d1
2482 bne.b _L10_2x
2483 bsr.l setox # operand is a NORM
2484 bra.b _L10_6x
2485 _L10_2x:
2486 cmpi.b %d1,&ZERO # is operand a ZERO?
2487 bne.b _L10_3x # no
2488 bsr.l ld_pone # yes
2489 bra.b _L10_6x
2490 _L10_3x:
2491 cmpi.b %d1,&INF # is operand an INF?
2492 bne.b _L10_4x # no
2493 bsr.l szr_inf # yes
2494 bra.b _L10_6x
2495 _L10_4x:
2496 cmpi.b %d1,&QNAN # is operand a QNAN?
2497 bne.b _L10_5x # no
2498 bsr.l src_qnan # yes
2499 bra.b _L10_6x
2500 _L10_5x:
2501 bsr.l setoxd # operand is a DENORM
2502 _L10_6x:
2503
2504 #
2505 # Result is now in FP0
2506 #
2507 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2508 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2509 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2510 unlk %a6
2511 rts
2512
2513
2514 #########################################################################
2515 # MONADIC TEMPLATE #
2516 #########################################################################
2517 global _ftwotoxs_
2518 _ftwotoxs_:
2519 link %a6,&-LOCAL_SIZE
2520
2521 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2522 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2523 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2524
2525 fmov.l &0x0,%fpcr # zero FPCR
2526
2527 #
2528 # copy, convert, and tag input argument
2529 #
2530 fmov.s 0x8(%a6),%fp0 # load sgl input
2531 fmov.x %fp0,FP_SRC(%a6)
2532 lea FP_SRC(%a6),%a0
2533 bsr.l tag # fetch operand type
2534 mov.b %d0,STAG(%a6)
2535 mov.b %d0,%d1
2536
2537 andi.l &0x00ff00ff,USER_FPSR(%a6)
2538
2539 clr.l %d0
2540 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2541
2542 tst.b %d1
2543 bne.b _L11_2s
2544 bsr.l stwotox # operand is a NORM
2545 bra.b _L11_6s
2546 _L11_2s:
2547 cmpi.b %d1,&ZERO # is operand a ZERO?
2548 bne.b _L11_3s # no
2549 bsr.l ld_pone # yes
2550 bra.b _L11_6s
2551 _L11_3s:
2552 cmpi.b %d1,&INF # is operand an INF?
2553 bne.b _L11_4s # no
2554 bsr.l szr_inf # yes
2555 bra.b _L11_6s
2556 _L11_4s:
2557 cmpi.b %d1,&QNAN # is operand a QNAN?
2558 bne.b _L11_5s # no
2559 bsr.l src_qnan # yes
2560 bra.b _L11_6s
2561 _L11_5s:
2562 bsr.l stwotoxd # operand is a DENORM
2563 _L11_6s:
2564
2565 #
2566 # Result is now in FP0
2567 #
2568 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2569 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2570 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2571 unlk %a6
2572 rts
2573
2574 global _ftwotoxd_
2575 _ftwotoxd_:
2576 link %a6,&-LOCAL_SIZE
2577
2578 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2579 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2580 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2581
2582 fmov.l &0x0,%fpcr # zero FPCR
2583
2584 #
2585 # copy, convert, and tag input argument
2586 #
2587 fmov.d 0x8(%a6),%fp0 # load dbl input
2588 fmov.x %fp0,FP_SRC(%a6)
2589 lea FP_SRC(%a6),%a0
2590 bsr.l tag # fetch operand type
2591 mov.b %d0,STAG(%a6)
2592 mov.b %d0,%d1
2593
2594 andi.l &0x00ff00ff,USER_FPSR(%a6)
2595
2596 clr.l %d0
2597 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2598
2599 mov.b %d1,STAG(%a6)
2600 tst.b %d1
2601 bne.b _L11_2d
2602 bsr.l stwotox # operand is a NORM
2603 bra.b _L11_6d
2604 _L11_2d:
2605 cmpi.b %d1,&ZERO # is operand a ZERO?
2606 bne.b _L11_3d # no
2607 bsr.l ld_pone # yes
2608 bra.b _L11_6d
2609 _L11_3d:
2610 cmpi.b %d1,&INF # is operand an INF?
2611 bne.b _L11_4d # no
2612 bsr.l szr_inf # yes
2613 bra.b _L11_6d
2614 _L11_4d:
2615 cmpi.b %d1,&QNAN # is operand a QNAN?
2616 bne.b _L11_5d # no
2617 bsr.l src_qnan # yes
2618 bra.b _L11_6d
2619 _L11_5d:
2620 bsr.l stwotoxd # operand is a DENORM
2621 _L11_6d:
2622
2623 #
2624 # Result is now in FP0
2625 #
2626 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2627 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2628 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2629 unlk %a6
2630 rts
2631
2632 global _ftwotoxx_
2633 _ftwotoxx_:
2634 link %a6,&-LOCAL_SIZE
2635
2636 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2637 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2638 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2639
2640 fmov.l &0x0,%fpcr # zero FPCR
2641
2642 #
2643 # copy, convert, and tag input argument
2644 #
2645 lea FP_SRC(%a6),%a0
2646 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
2647 mov.l 0x8+0x4(%a6),0x4(%a0)
2648 mov.l 0x8+0x8(%a6),0x8(%a0)
2649 bsr.l tag # fetch operand type
2650 mov.b %d0,STAG(%a6)
2651 mov.b %d0,%d1
2652
2653 andi.l &0x00ff00ff,USER_FPSR(%a6)
2654
2655 clr.l %d0
2656 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2657
2658 tst.b %d1
2659 bne.b _L11_2x
2660 bsr.l stwotox # operand is a NORM
2661 bra.b _L11_6x
2662 _L11_2x:
2663 cmpi.b %d1,&ZERO # is operand a ZERO?
2664 bne.b _L11_3x # no
2665 bsr.l ld_pone # yes
2666 bra.b _L11_6x
2667 _L11_3x:
2668 cmpi.b %d1,&INF # is operand an INF?
2669 bne.b _L11_4x # no
2670 bsr.l szr_inf # yes
2671 bra.b _L11_6x
2672 _L11_4x:
2673 cmpi.b %d1,&QNAN # is operand a QNAN?
2674 bne.b _L11_5x # no
2675 bsr.l src_qnan # yes
2676 bra.b _L11_6x
2677 _L11_5x:
2678 bsr.l stwotoxd # operand is a DENORM
2679 _L11_6x:
2680
2681 #
2682 # Result is now in FP0
2683 #
2684 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2685 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2686 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2687 unlk %a6
2688 rts
2689
2690
2691 #########################################################################
2692 # MONADIC TEMPLATE #
2693 #########################################################################
2694 global _ftentoxs_
2695 _ftentoxs_:
2696 link %a6,&-LOCAL_SIZE
2697
2698 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2699 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2700 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2701
2702 fmov.l &0x0,%fpcr # zero FPCR
2703
2704 #
2705 # copy, convert, and tag input argument
2706 #
2707 fmov.s 0x8(%a6),%fp0 # load sgl input
2708 fmov.x %fp0,FP_SRC(%a6)
2709 lea FP_SRC(%a6),%a0
2710 bsr.l tag # fetch operand type
2711 mov.b %d0,STAG(%a6)
2712 mov.b %d0,%d1
2713
2714 andi.l &0x00ff00ff,USER_FPSR(%a6)
2715
2716 clr.l %d0
2717 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2718
2719 tst.b %d1
2720 bne.b _L12_2s
2721 bsr.l stentox # operand is a NORM
2722 bra.b _L12_6s
2723 _L12_2s:
2724 cmpi.b %d1,&ZERO # is operand a ZERO?
2725 bne.b _L12_3s # no
2726 bsr.l ld_pone # yes
2727 bra.b _L12_6s
2728 _L12_3s:
2729 cmpi.b %d1,&INF # is operand an INF?
2730 bne.b _L12_4s # no
2731 bsr.l szr_inf # yes
2732 bra.b _L12_6s
2733 _L12_4s:
2734 cmpi.b %d1,&QNAN # is operand a QNAN?
2735 bne.b _L12_5s # no
2736 bsr.l src_qnan # yes
2737 bra.b _L12_6s
2738 _L12_5s:
2739 bsr.l stentoxd # operand is a DENORM
2740 _L12_6s:
2741
2742 #
2743 # Result is now in FP0
2744 #
2745 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2746 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2747 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2748 unlk %a6
2749 rts
2750
2751 global _ftentoxd_
2752 _ftentoxd_:
2753 link %a6,&-LOCAL_SIZE
2754
2755 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2756 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2757 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2758
2759 fmov.l &0x0,%fpcr # zero FPCR
2760
2761 #
2762 # copy, convert, and tag input argument
2763 #
2764 fmov.d 0x8(%a6),%fp0 # load dbl input
2765 fmov.x %fp0,FP_SRC(%a6)
2766 lea FP_SRC(%a6),%a0
2767 bsr.l tag # fetch operand type
2768 mov.b %d0,STAG(%a6)
2769 mov.b %d0,%d1
2770
2771 andi.l &0x00ff00ff,USER_FPSR(%a6)
2772
2773 clr.l %d0
2774 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2775
2776 mov.b %d1,STAG(%a6)
2777 tst.b %d1
2778 bne.b _L12_2d
2779 bsr.l stentox # operand is a NORM
2780 bra.b _L12_6d
2781 _L12_2d:
2782 cmpi.b %d1,&ZERO # is operand a ZERO?
2783 bne.b _L12_3d # no
2784 bsr.l ld_pone # yes
2785 bra.b _L12_6d
2786 _L12_3d:
2787 cmpi.b %d1,&INF # is operand an INF?
2788 bne.b _L12_4d # no
2789 bsr.l szr_inf # yes
2790 bra.b _L12_6d
2791 _L12_4d:
2792 cmpi.b %d1,&QNAN # is operand a QNAN?
2793 bne.b _L12_5d # no
2794 bsr.l src_qnan # yes
2795 bra.b _L12_6d
2796 _L12_5d:
2797 bsr.l stentoxd # operand is a DENORM
2798 _L12_6d:
2799
2800 #
2801 # Result is now in FP0
2802 #
2803 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2804 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2805 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2806 unlk %a6
2807 rts
2808
2809 global _ftentoxx_
2810 _ftentoxx_:
2811 link %a6,&-LOCAL_SIZE
2812
2813 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2814 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2815 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2816
2817 fmov.l &0x0,%fpcr # zero FPCR
2818
2819 #
2820 # copy, convert, and tag input argument
2821 #
2822 lea FP_SRC(%a6),%a0
2823 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
2824 mov.l 0x8+0x4(%a6),0x4(%a0)
2825 mov.l 0x8+0x8(%a6),0x8(%a0)
2826 bsr.l tag # fetch operand type
2827 mov.b %d0,STAG(%a6)
2828 mov.b %d0,%d1
2829
2830 andi.l &0x00ff00ff,USER_FPSR(%a6)
2831
2832 clr.l %d0
2833 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2834
2835 tst.b %d1
2836 bne.b _L12_2x
2837 bsr.l stentox # operand is a NORM
2838 bra.b _L12_6x
2839 _L12_2x:
2840 cmpi.b %d1,&ZERO # is operand a ZERO?
2841 bne.b _L12_3x # no
2842 bsr.l ld_pone # yes
2843 bra.b _L12_6x
2844 _L12_3x:
2845 cmpi.b %d1,&INF # is operand an INF?
2846 bne.b _L12_4x # no
2847 bsr.l szr_inf # yes
2848 bra.b _L12_6x
2849 _L12_4x:
2850 cmpi.b %d1,&QNAN # is operand a QNAN?
2851 bne.b _L12_5x # no
2852 bsr.l src_qnan # yes
2853 bra.b _L12_6x
2854 _L12_5x:
2855 bsr.l stentoxd # operand is a DENORM
2856 _L12_6x:
2857
2858 #
2859 # Result is now in FP0
2860 #
2861 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2862 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2863 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2864 unlk %a6
2865 rts
2866
2867
2868 #########################################################################
2869 # MONADIC TEMPLATE #
2870 #########################################################################
2871 global _flogns_
2872 _flogns_:
2873 link %a6,&-LOCAL_SIZE
2874
2875 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2876 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2877 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2878
2879 fmov.l &0x0,%fpcr # zero FPCR
2880
2881 #
2882 # copy, convert, and tag input argument
2883 #
2884 fmov.s 0x8(%a6),%fp0 # load sgl input
2885 fmov.x %fp0,FP_SRC(%a6)
2886 lea FP_SRC(%a6),%a0
2887 bsr.l tag # fetch operand type
2888 mov.b %d0,STAG(%a6)
2889 mov.b %d0,%d1
2890
2891 andi.l &0x00ff00ff,USER_FPSR(%a6)
2892
2893 clr.l %d0
2894 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2895
2896 tst.b %d1
2897 bne.b _L13_2s
2898 bsr.l slogn # operand is a NORM
2899 bra.b _L13_6s
2900 _L13_2s:
2901 cmpi.b %d1,&ZERO # is operand a ZERO?
2902 bne.b _L13_3s # no
2903 bsr.l t_dz2 # yes
2904 bra.b _L13_6s
2905 _L13_3s:
2906 cmpi.b %d1,&INF # is operand an INF?
2907 bne.b _L13_4s # no
2908 bsr.l sopr_inf # yes
2909 bra.b _L13_6s
2910 _L13_4s:
2911 cmpi.b %d1,&QNAN # is operand a QNAN?
2912 bne.b _L13_5s # no
2913 bsr.l src_qnan # yes
2914 bra.b _L13_6s
2915 _L13_5s:
2916 bsr.l slognd # operand is a DENORM
2917 _L13_6s:
2918
2919 #
2920 # Result is now in FP0
2921 #
2922 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2923 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2924 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2925 unlk %a6
2926 rts
2927
2928 global _flognd_
2929 _flognd_:
2930 link %a6,&-LOCAL_SIZE
2931
2932 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2933 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2934 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2935
2936 fmov.l &0x0,%fpcr # zero FPCR
2937
2938 #
2939 # copy, convert, and tag input argument
2940 #
2941 fmov.d 0x8(%a6),%fp0 # load dbl input
2942 fmov.x %fp0,FP_SRC(%a6)
2943 lea FP_SRC(%a6),%a0
2944 bsr.l tag # fetch operand type
2945 mov.b %d0,STAG(%a6)
2946 mov.b %d0,%d1
2947
2948 andi.l &0x00ff00ff,USER_FPSR(%a6)
2949
2950 clr.l %d0
2951 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
2952
2953 mov.b %d1,STAG(%a6)
2954 tst.b %d1
2955 bne.b _L13_2d
2956 bsr.l slogn # operand is a NORM
2957 bra.b _L13_6d
2958 _L13_2d:
2959 cmpi.b %d1,&ZERO # is operand a ZERO?
2960 bne.b _L13_3d # no
2961 bsr.l t_dz2 # yes
2962 bra.b _L13_6d
2963 _L13_3d:
2964 cmpi.b %d1,&INF # is operand an INF?
2965 bne.b _L13_4d # no
2966 bsr.l sopr_inf # yes
2967 bra.b _L13_6d
2968 _L13_4d:
2969 cmpi.b %d1,&QNAN # is operand a QNAN?
2970 bne.b _L13_5d # no
2971 bsr.l src_qnan # yes
2972 bra.b _L13_6d
2973 _L13_5d:
2974 bsr.l slognd # operand is a DENORM
2975 _L13_6d:
2976
2977 #
2978 # Result is now in FP0
2979 #
2980 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
2981 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2982 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
2983 unlk %a6
2984 rts
2985
2986 global _flognx_
2987 _flognx_:
2988 link %a6,&-LOCAL_SIZE
2989
2990 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
2991 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2992 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
2993
2994 fmov.l &0x0,%fpcr # zero FPCR
2995
2996 #
2997 # copy, convert, and tag input argument
2998 #
2999 lea FP_SRC(%a6),%a0
3000 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
3001 mov.l 0x8+0x4(%a6),0x4(%a0)
3002 mov.l 0x8+0x8(%a6),0x8(%a0)
3003 bsr.l tag # fetch operand type
3004 mov.b %d0,STAG(%a6)
3005 mov.b %d0,%d1
3006
3007 andi.l &0x00ff00ff,USER_FPSR(%a6)
3008
3009 clr.l %d0
3010 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3011
3012 tst.b %d1
3013 bne.b _L13_2x
3014 bsr.l slogn # operand is a NORM
3015 bra.b _L13_6x
3016 _L13_2x:
3017 cmpi.b %d1,&ZERO # is operand a ZERO?
3018 bne.b _L13_3x # no
3019 bsr.l t_dz2 # yes
3020 bra.b _L13_6x
3021 _L13_3x:
3022 cmpi.b %d1,&INF # is operand an INF?
3023 bne.b _L13_4x # no
3024 bsr.l sopr_inf # yes
3025 bra.b _L13_6x
3026 _L13_4x:
3027 cmpi.b %d1,&QNAN # is operand a QNAN?
3028 bne.b _L13_5x # no
3029 bsr.l src_qnan # yes
3030 bra.b _L13_6x
3031 _L13_5x:
3032 bsr.l slognd # operand is a DENORM
3033 _L13_6x:
3034
3035 #
3036 # Result is now in FP0
3037 #
3038 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3039 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3040 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3041 unlk %a6
3042 rts
3043
3044
3045 #########################################################################
3046 # MONADIC TEMPLATE #
3047 #########################################################################
3048 global _flog10s_
3049 _flog10s_:
3050 link %a6,&-LOCAL_SIZE
3051
3052 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3053 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3054 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3055
3056 fmov.l &0x0,%fpcr # zero FPCR
3057
3058 #
3059 # copy, convert, and tag input argument
3060 #
3061 fmov.s 0x8(%a6),%fp0 # load sgl input
3062 fmov.x %fp0,FP_SRC(%a6)
3063 lea FP_SRC(%a6),%a0
3064 bsr.l tag # fetch operand type
3065 mov.b %d0,STAG(%a6)
3066 mov.b %d0,%d1
3067
3068 andi.l &0x00ff00ff,USER_FPSR(%a6)
3069
3070 clr.l %d0
3071 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3072
3073 tst.b %d1
3074 bne.b _L14_2s
3075 bsr.l slog10 # operand is a NORM
3076 bra.b _L14_6s
3077 _L14_2s:
3078 cmpi.b %d1,&ZERO # is operand a ZERO?
3079 bne.b _L14_3s # no
3080 bsr.l t_dz2 # yes
3081 bra.b _L14_6s
3082 _L14_3s:
3083 cmpi.b %d1,&INF # is operand an INF?
3084 bne.b _L14_4s # no
3085 bsr.l sopr_inf # yes
3086 bra.b _L14_6s
3087 _L14_4s:
3088 cmpi.b %d1,&QNAN # is operand a QNAN?
3089 bne.b _L14_5s # no
3090 bsr.l src_qnan # yes
3091 bra.b _L14_6s
3092 _L14_5s:
3093 bsr.l slog10d # operand is a DENORM
3094 _L14_6s:
3095
3096 #
3097 # Result is now in FP0
3098 #
3099 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3100 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3101 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3102 unlk %a6
3103 rts
3104
3105 global _flog10d_
3106 _flog10d_:
3107 link %a6,&-LOCAL_SIZE
3108
3109 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3110 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3111 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3112
3113 fmov.l &0x0,%fpcr # zero FPCR
3114
3115 #
3116 # copy, convert, and tag input argument
3117 #
3118 fmov.d 0x8(%a6),%fp0 # load dbl input
3119 fmov.x %fp0,FP_SRC(%a6)
3120 lea FP_SRC(%a6),%a0
3121 bsr.l tag # fetch operand type
3122 mov.b %d0,STAG(%a6)
3123 mov.b %d0,%d1
3124
3125 andi.l &0x00ff00ff,USER_FPSR(%a6)
3126
3127 clr.l %d0
3128 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3129
3130 mov.b %d1,STAG(%a6)
3131 tst.b %d1
3132 bne.b _L14_2d
3133 bsr.l slog10 # operand is a NORM
3134 bra.b _L14_6d
3135 _L14_2d:
3136 cmpi.b %d1,&ZERO # is operand a ZERO?
3137 bne.b _L14_3d # no
3138 bsr.l t_dz2 # yes
3139 bra.b _L14_6d
3140 _L14_3d:
3141 cmpi.b %d1,&INF # is operand an INF?
3142 bne.b _L14_4d # no
3143 bsr.l sopr_inf # yes
3144 bra.b _L14_6d
3145 _L14_4d:
3146 cmpi.b %d1,&QNAN # is operand a QNAN?
3147 bne.b _L14_5d # no
3148 bsr.l src_qnan # yes
3149 bra.b _L14_6d
3150 _L14_5d:
3151 bsr.l slog10d # operand is a DENORM
3152 _L14_6d:
3153
3154 #
3155 # Result is now in FP0
3156 #
3157 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3158 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3159 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3160 unlk %a6
3161 rts
3162
3163 global _flog10x_
3164 _flog10x_:
3165 link %a6,&-LOCAL_SIZE
3166
3167 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3168 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3169 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3170
3171 fmov.l &0x0,%fpcr # zero FPCR
3172
3173 #
3174 # copy, convert, and tag input argument
3175 #
3176 lea FP_SRC(%a6),%a0
3177 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
3178 mov.l 0x8+0x4(%a6),0x4(%a0)
3179 mov.l 0x8+0x8(%a6),0x8(%a0)
3180 bsr.l tag # fetch operand type
3181 mov.b %d0,STAG(%a6)
3182 mov.b %d0,%d1
3183
3184 andi.l &0x00ff00ff,USER_FPSR(%a6)
3185
3186 clr.l %d0
3187 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3188
3189 tst.b %d1
3190 bne.b _L14_2x
3191 bsr.l slog10 # operand is a NORM
3192 bra.b _L14_6x
3193 _L14_2x:
3194 cmpi.b %d1,&ZERO # is operand a ZERO?
3195 bne.b _L14_3x # no
3196 bsr.l t_dz2 # yes
3197 bra.b _L14_6x
3198 _L14_3x:
3199 cmpi.b %d1,&INF # is operand an INF?
3200 bne.b _L14_4x # no
3201 bsr.l sopr_inf # yes
3202 bra.b _L14_6x
3203 _L14_4x:
3204 cmpi.b %d1,&QNAN # is operand a QNAN?
3205 bne.b _L14_5x # no
3206 bsr.l src_qnan # yes
3207 bra.b _L14_6x
3208 _L14_5x:
3209 bsr.l slog10d # operand is a DENORM
3210 _L14_6x:
3211
3212 #
3213 # Result is now in FP0
3214 #
3215 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3216 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3217 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3218 unlk %a6
3219 rts
3220
3221
3222 #########################################################################
3223 # MONADIC TEMPLATE #
3224 #########################################################################
3225 global _flog2s_
3226 _flog2s_:
3227 link %a6,&-LOCAL_SIZE
3228
3229 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3230 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3231 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3232
3233 fmov.l &0x0,%fpcr # zero FPCR
3234
3235 #
3236 # copy, convert, and tag input argument
3237 #
3238 fmov.s 0x8(%a6),%fp0 # load sgl input
3239 fmov.x %fp0,FP_SRC(%a6)
3240 lea FP_SRC(%a6),%a0
3241 bsr.l tag # fetch operand type
3242 mov.b %d0,STAG(%a6)
3243 mov.b %d0,%d1
3244
3245 andi.l &0x00ff00ff,USER_FPSR(%a6)
3246
3247 clr.l %d0
3248 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3249
3250 tst.b %d1
3251 bne.b _L15_2s
3252 bsr.l slog2 # operand is a NORM
3253 bra.b _L15_6s
3254 _L15_2s:
3255 cmpi.b %d1,&ZERO # is operand a ZERO?
3256 bne.b _L15_3s # no
3257 bsr.l t_dz2 # yes
3258 bra.b _L15_6s
3259 _L15_3s:
3260 cmpi.b %d1,&INF # is operand an INF?
3261 bne.b _L15_4s # no
3262 bsr.l sopr_inf # yes
3263 bra.b _L15_6s
3264 _L15_4s:
3265 cmpi.b %d1,&QNAN # is operand a QNAN?
3266 bne.b _L15_5s # no
3267 bsr.l src_qnan # yes
3268 bra.b _L15_6s
3269 _L15_5s:
3270 bsr.l slog2d # operand is a DENORM
3271 _L15_6s:
3272
3273 #
3274 # Result is now in FP0
3275 #
3276 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3277 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3278 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3279 unlk %a6
3280 rts
3281
3282 global _flog2d_
3283 _flog2d_:
3284 link %a6,&-LOCAL_SIZE
3285
3286 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3287 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3288 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3289
3290 fmov.l &0x0,%fpcr # zero FPCR
3291
3292 #
3293 # copy, convert, and tag input argument
3294 #
3295 fmov.d 0x8(%a6),%fp0 # load dbl input
3296 fmov.x %fp0,FP_SRC(%a6)
3297 lea FP_SRC(%a6),%a0
3298 bsr.l tag # fetch operand type
3299 mov.b %d0,STAG(%a6)
3300 mov.b %d0,%d1
3301
3302 andi.l &0x00ff00ff,USER_FPSR(%a6)
3303
3304 clr.l %d0
3305 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3306
3307 mov.b %d1,STAG(%a6)
3308 tst.b %d1
3309 bne.b _L15_2d
3310 bsr.l slog2 # operand is a NORM
3311 bra.b _L15_6d
3312 _L15_2d:
3313 cmpi.b %d1,&ZERO # is operand a ZERO?
3314 bne.b _L15_3d # no
3315 bsr.l t_dz2 # yes
3316 bra.b _L15_6d
3317 _L15_3d:
3318 cmpi.b %d1,&INF # is operand an INF?
3319 bne.b _L15_4d # no
3320 bsr.l sopr_inf # yes
3321 bra.b _L15_6d
3322 _L15_4d:
3323 cmpi.b %d1,&QNAN # is operand a QNAN?
3324 bne.b _L15_5d # no
3325 bsr.l src_qnan # yes
3326 bra.b _L15_6d
3327 _L15_5d:
3328 bsr.l slog2d # operand is a DENORM
3329 _L15_6d:
3330
3331 #
3332 # Result is now in FP0
3333 #
3334 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3335 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3336 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3337 unlk %a6
3338 rts
3339
3340 global _flog2x_
3341 _flog2x_:
3342 link %a6,&-LOCAL_SIZE
3343
3344 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3345 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3346 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3347
3348 fmov.l &0x0,%fpcr # zero FPCR
3349
3350 #
3351 # copy, convert, and tag input argument
3352 #
3353 lea FP_SRC(%a6),%a0
3354 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
3355 mov.l 0x8+0x4(%a6),0x4(%a0)
3356 mov.l 0x8+0x8(%a6),0x8(%a0)
3357 bsr.l tag # fetch operand type
3358 mov.b %d0,STAG(%a6)
3359 mov.b %d0,%d1
3360
3361 andi.l &0x00ff00ff,USER_FPSR(%a6)
3362
3363 clr.l %d0
3364 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3365
3366 tst.b %d1
3367 bne.b _L15_2x
3368 bsr.l slog2 # operand is a NORM
3369 bra.b _L15_6x
3370 _L15_2x:
3371 cmpi.b %d1,&ZERO # is operand a ZERO?
3372 bne.b _L15_3x # no
3373 bsr.l t_dz2 # yes
3374 bra.b _L15_6x
3375 _L15_3x:
3376 cmpi.b %d1,&INF # is operand an INF?
3377 bne.b _L15_4x # no
3378 bsr.l sopr_inf # yes
3379 bra.b _L15_6x
3380 _L15_4x:
3381 cmpi.b %d1,&QNAN # is operand a QNAN?
3382 bne.b _L15_5x # no
3383 bsr.l src_qnan # yes
3384 bra.b _L15_6x
3385 _L15_5x:
3386 bsr.l slog2d # operand is a DENORM
3387 _L15_6x:
3388
3389 #
3390 # Result is now in FP0
3391 #
3392 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3393 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3394 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3395 unlk %a6
3396 rts
3397
3398
3399 #########################################################################
3400 # MONADIC TEMPLATE #
3401 #########################################################################
3402 global _fcoshs_
3403 _fcoshs_:
3404 link %a6,&-LOCAL_SIZE
3405
3406 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3407 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3408 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3409
3410 fmov.l &0x0,%fpcr # zero FPCR
3411
3412 #
3413 # copy, convert, and tag input argument
3414 #
3415 fmov.s 0x8(%a6),%fp0 # load sgl input
3416 fmov.x %fp0,FP_SRC(%a6)
3417 lea FP_SRC(%a6),%a0
3418 bsr.l tag # fetch operand type
3419 mov.b %d0,STAG(%a6)
3420 mov.b %d0,%d1
3421
3422 andi.l &0x00ff00ff,USER_FPSR(%a6)
3423
3424 clr.l %d0
3425 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3426
3427 tst.b %d1
3428 bne.b _L16_2s
3429 bsr.l scosh # operand is a NORM
3430 bra.b _L16_6s
3431 _L16_2s:
3432 cmpi.b %d1,&ZERO # is operand a ZERO?
3433 bne.b _L16_3s # no
3434 bsr.l ld_pone # yes
3435 bra.b _L16_6s
3436 _L16_3s:
3437 cmpi.b %d1,&INF # is operand an INF?
3438 bne.b _L16_4s # no
3439 bsr.l ld_pinf # yes
3440 bra.b _L16_6s
3441 _L16_4s:
3442 cmpi.b %d1,&QNAN # is operand a QNAN?
3443 bne.b _L16_5s # no
3444 bsr.l src_qnan # yes
3445 bra.b _L16_6s
3446 _L16_5s:
3447 bsr.l scoshd # operand is a DENORM
3448 _L16_6s:
3449
3450 #
3451 # Result is now in FP0
3452 #
3453 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3454 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3455 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3456 unlk %a6
3457 rts
3458
3459 global _fcoshd_
3460 _fcoshd_:
3461 link %a6,&-LOCAL_SIZE
3462
3463 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3464 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3465 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3466
3467 fmov.l &0x0,%fpcr # zero FPCR
3468
3469 #
3470 # copy, convert, and tag input argument
3471 #
3472 fmov.d 0x8(%a6),%fp0 # load dbl input
3473 fmov.x %fp0,FP_SRC(%a6)
3474 lea FP_SRC(%a6),%a0
3475 bsr.l tag # fetch operand type
3476 mov.b %d0,STAG(%a6)
3477 mov.b %d0,%d1
3478
3479 andi.l &0x00ff00ff,USER_FPSR(%a6)
3480
3481 clr.l %d0
3482 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3483
3484 mov.b %d1,STAG(%a6)
3485 tst.b %d1
3486 bne.b _L16_2d
3487 bsr.l scosh # operand is a NORM
3488 bra.b _L16_6d
3489 _L16_2d:
3490 cmpi.b %d1,&ZERO # is operand a ZERO?
3491 bne.b _L16_3d # no
3492 bsr.l ld_pone # yes
3493 bra.b _L16_6d
3494 _L16_3d:
3495 cmpi.b %d1,&INF # is operand an INF?
3496 bne.b _L16_4d # no
3497 bsr.l ld_pinf # yes
3498 bra.b _L16_6d
3499 _L16_4d:
3500 cmpi.b %d1,&QNAN # is operand a QNAN?
3501 bne.b _L16_5d # no
3502 bsr.l src_qnan # yes
3503 bra.b _L16_6d
3504 _L16_5d:
3505 bsr.l scoshd # operand is a DENORM
3506 _L16_6d:
3507
3508 #
3509 # Result is now in FP0
3510 #
3511 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3512 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3513 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3514 unlk %a6
3515 rts
3516
3517 global _fcoshx_
3518 _fcoshx_:
3519 link %a6,&-LOCAL_SIZE
3520
3521 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3522 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3523 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3524
3525 fmov.l &0x0,%fpcr # zero FPCR
3526
3527 #
3528 # copy, convert, and tag input argument
3529 #
3530 lea FP_SRC(%a6),%a0
3531 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
3532 mov.l 0x8+0x4(%a6),0x4(%a0)
3533 mov.l 0x8+0x8(%a6),0x8(%a0)
3534 bsr.l tag # fetch operand type
3535 mov.b %d0,STAG(%a6)
3536 mov.b %d0,%d1
3537
3538 andi.l &0x00ff00ff,USER_FPSR(%a6)
3539
3540 clr.l %d0
3541 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3542
3543 tst.b %d1
3544 bne.b _L16_2x
3545 bsr.l scosh # operand is a NORM
3546 bra.b _L16_6x
3547 _L16_2x:
3548 cmpi.b %d1,&ZERO # is operand a ZERO?
3549 bne.b _L16_3x # no
3550 bsr.l ld_pone # yes
3551 bra.b _L16_6x
3552 _L16_3x:
3553 cmpi.b %d1,&INF # is operand an INF?
3554 bne.b _L16_4x # no
3555 bsr.l ld_pinf # yes
3556 bra.b _L16_6x
3557 _L16_4x:
3558 cmpi.b %d1,&QNAN # is operand a QNAN?
3559 bne.b _L16_5x # no
3560 bsr.l src_qnan # yes
3561 bra.b _L16_6x
3562 _L16_5x:
3563 bsr.l scoshd # operand is a DENORM
3564 _L16_6x:
3565
3566 #
3567 # Result is now in FP0
3568 #
3569 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3570 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3571 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3572 unlk %a6
3573 rts
3574
3575
3576 #########################################################################
3577 # MONADIC TEMPLATE #
3578 #########################################################################
3579 global _facoss_
3580 _facoss_:
3581 link %a6,&-LOCAL_SIZE
3582
3583 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3584 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3585 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3586
3587 fmov.l &0x0,%fpcr # zero FPCR
3588
3589 #
3590 # copy, convert, and tag input argument
3591 #
3592 fmov.s 0x8(%a6),%fp0 # load sgl input
3593 fmov.x %fp0,FP_SRC(%a6)
3594 lea FP_SRC(%a6),%a0
3595 bsr.l tag # fetch operand type
3596 mov.b %d0,STAG(%a6)
3597 mov.b %d0,%d1
3598
3599 andi.l &0x00ff00ff,USER_FPSR(%a6)
3600
3601 clr.l %d0
3602 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3603
3604 tst.b %d1
3605 bne.b _L17_2s
3606 bsr.l sacos # operand is a NORM
3607 bra.b _L17_6s
3608 _L17_2s:
3609 cmpi.b %d1,&ZERO # is operand a ZERO?
3610 bne.b _L17_3s # no
3611 bsr.l ld_ppi2 # yes
3612 bra.b _L17_6s
3613 _L17_3s:
3614 cmpi.b %d1,&INF # is operand an INF?
3615 bne.b _L17_4s # no
3616 bsr.l t_operr # yes
3617 bra.b _L17_6s
3618 _L17_4s:
3619 cmpi.b %d1,&QNAN # is operand a QNAN?
3620 bne.b _L17_5s # no
3621 bsr.l src_qnan # yes
3622 bra.b _L17_6s
3623 _L17_5s:
3624 bsr.l sacosd # operand is a DENORM
3625 _L17_6s:
3626
3627 #
3628 # Result is now in FP0
3629 #
3630 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3631 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3632 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3633 unlk %a6
3634 rts
3635
3636 global _facosd_
3637 _facosd_:
3638 link %a6,&-LOCAL_SIZE
3639
3640 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3641 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3642 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3643
3644 fmov.l &0x0,%fpcr # zero FPCR
3645
3646 #
3647 # copy, convert, and tag input argument
3648 #
3649 fmov.d 0x8(%a6),%fp0 # load dbl input
3650 fmov.x %fp0,FP_SRC(%a6)
3651 lea FP_SRC(%a6),%a0
3652 bsr.l tag # fetch operand type
3653 mov.b %d0,STAG(%a6)
3654 mov.b %d0,%d1
3655
3656 andi.l &0x00ff00ff,USER_FPSR(%a6)
3657
3658 clr.l %d0
3659 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3660
3661 mov.b %d1,STAG(%a6)
3662 tst.b %d1
3663 bne.b _L17_2d
3664 bsr.l sacos # operand is a NORM
3665 bra.b _L17_6d
3666 _L17_2d:
3667 cmpi.b %d1,&ZERO # is operand a ZERO?
3668 bne.b _L17_3d # no
3669 bsr.l ld_ppi2 # yes
3670 bra.b _L17_6d
3671 _L17_3d:
3672 cmpi.b %d1,&INF # is operand an INF?
3673 bne.b _L17_4d # no
3674 bsr.l t_operr # yes
3675 bra.b _L17_6d
3676 _L17_4d:
3677 cmpi.b %d1,&QNAN # is operand a QNAN?
3678 bne.b _L17_5d # no
3679 bsr.l src_qnan # yes
3680 bra.b _L17_6d
3681 _L17_5d:
3682 bsr.l sacosd # operand is a DENORM
3683 _L17_6d:
3684
3685 #
3686 # Result is now in FP0
3687 #
3688 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3689 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3690 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3691 unlk %a6
3692 rts
3693
3694 global _facosx_
3695 _facosx_:
3696 link %a6,&-LOCAL_SIZE
3697
3698 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3699 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3700 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3701
3702 fmov.l &0x0,%fpcr # zero FPCR
3703
3704 #
3705 # copy, convert, and tag input argument
3706 #
3707 lea FP_SRC(%a6),%a0
3708 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
3709 mov.l 0x8+0x4(%a6),0x4(%a0)
3710 mov.l 0x8+0x8(%a6),0x8(%a0)
3711 bsr.l tag # fetch operand type
3712 mov.b %d0,STAG(%a6)
3713 mov.b %d0,%d1
3714
3715 andi.l &0x00ff00ff,USER_FPSR(%a6)
3716
3717 clr.l %d0
3718 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3719
3720 tst.b %d1
3721 bne.b _L17_2x
3722 bsr.l sacos # operand is a NORM
3723 bra.b _L17_6x
3724 _L17_2x:
3725 cmpi.b %d1,&ZERO # is operand a ZERO?
3726 bne.b _L17_3x # no
3727 bsr.l ld_ppi2 # yes
3728 bra.b _L17_6x
3729 _L17_3x:
3730 cmpi.b %d1,&INF # is operand an INF?
3731 bne.b _L17_4x # no
3732 bsr.l t_operr # yes
3733 bra.b _L17_6x
3734 _L17_4x:
3735 cmpi.b %d1,&QNAN # is operand a QNAN?
3736 bne.b _L17_5x # no
3737 bsr.l src_qnan # yes
3738 bra.b _L17_6x
3739 _L17_5x:
3740 bsr.l sacosd # operand is a DENORM
3741 _L17_6x:
3742
3743 #
3744 # Result is now in FP0
3745 #
3746 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3747 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3748 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3749 unlk %a6
3750 rts
3751
3752
3753 #########################################################################
3754 # MONADIC TEMPLATE #
3755 #########################################################################
3756 global _fgetexps_
3757 _fgetexps_:
3758 link %a6,&-LOCAL_SIZE
3759
3760 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3761 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3762 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3763
3764 fmov.l &0x0,%fpcr # zero FPCR
3765
3766 #
3767 # copy, convert, and tag input argument
3768 #
3769 fmov.s 0x8(%a6),%fp0 # load sgl input
3770 fmov.x %fp0,FP_SRC(%a6)
3771 lea FP_SRC(%a6),%a0
3772 bsr.l tag # fetch operand type
3773 mov.b %d0,STAG(%a6)
3774 mov.b %d0,%d1
3775
3776 andi.l &0x00ff00ff,USER_FPSR(%a6)
3777
3778 clr.l %d0
3779 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3780
3781 tst.b %d1
3782 bne.b _L18_2s
3783 bsr.l sgetexp # operand is a NORM
3784 bra.b _L18_6s
3785 _L18_2s:
3786 cmpi.b %d1,&ZERO # is operand a ZERO?
3787 bne.b _L18_3s # no
3788 bsr.l src_zero # yes
3789 bra.b _L18_6s
3790 _L18_3s:
3791 cmpi.b %d1,&INF # is operand an INF?
3792 bne.b _L18_4s # no
3793 bsr.l t_operr # yes
3794 bra.b _L18_6s
3795 _L18_4s:
3796 cmpi.b %d1,&QNAN # is operand a QNAN?
3797 bne.b _L18_5s # no
3798 bsr.l src_qnan # yes
3799 bra.b _L18_6s
3800 _L18_5s:
3801 bsr.l sgetexpd # operand is a DENORM
3802 _L18_6s:
3803
3804 #
3805 # Result is now in FP0
3806 #
3807 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3808 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3809 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3810 unlk %a6
3811 rts
3812
3813 global _fgetexpd_
3814 _fgetexpd_:
3815 link %a6,&-LOCAL_SIZE
3816
3817 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3818 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3819 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3820
3821 fmov.l &0x0,%fpcr # zero FPCR
3822
3823 #
3824 # copy, convert, and tag input argument
3825 #
3826 fmov.d 0x8(%a6),%fp0 # load dbl input
3827 fmov.x %fp0,FP_SRC(%a6)
3828 lea FP_SRC(%a6),%a0
3829 bsr.l tag # fetch operand type
3830 mov.b %d0,STAG(%a6)
3831 mov.b %d0,%d1
3832
3833 andi.l &0x00ff00ff,USER_FPSR(%a6)
3834
3835 clr.l %d0
3836 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3837
3838 mov.b %d1,STAG(%a6)
3839 tst.b %d1
3840 bne.b _L18_2d
3841 bsr.l sgetexp # operand is a NORM
3842 bra.b _L18_6d
3843 _L18_2d:
3844 cmpi.b %d1,&ZERO # is operand a ZERO?
3845 bne.b _L18_3d # no
3846 bsr.l src_zero # yes
3847 bra.b _L18_6d
3848 _L18_3d:
3849 cmpi.b %d1,&INF # is operand an INF?
3850 bne.b _L18_4d # no
3851 bsr.l t_operr # yes
3852 bra.b _L18_6d
3853 _L18_4d:
3854 cmpi.b %d1,&QNAN # is operand a QNAN?
3855 bne.b _L18_5d # no
3856 bsr.l src_qnan # yes
3857 bra.b _L18_6d
3858 _L18_5d:
3859 bsr.l sgetexpd # operand is a DENORM
3860 _L18_6d:
3861
3862 #
3863 # Result is now in FP0
3864 #
3865 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3866 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3867 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3868 unlk %a6
3869 rts
3870
3871 global _fgetexpx_
3872 _fgetexpx_:
3873 link %a6,&-LOCAL_SIZE
3874
3875 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3876 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3877 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3878
3879 fmov.l &0x0,%fpcr # zero FPCR
3880
3881 #
3882 # copy, convert, and tag input argument
3883 #
3884 lea FP_SRC(%a6),%a0
3885 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
3886 mov.l 0x8+0x4(%a6),0x4(%a0)
3887 mov.l 0x8+0x8(%a6),0x8(%a0)
3888 bsr.l tag # fetch operand type
3889 mov.b %d0,STAG(%a6)
3890 mov.b %d0,%d1
3891
3892 andi.l &0x00ff00ff,USER_FPSR(%a6)
3893
3894 clr.l %d0
3895 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3896
3897 tst.b %d1
3898 bne.b _L18_2x
3899 bsr.l sgetexp # operand is a NORM
3900 bra.b _L18_6x
3901 _L18_2x:
3902 cmpi.b %d1,&ZERO # is operand a ZERO?
3903 bne.b _L18_3x # no
3904 bsr.l src_zero # yes
3905 bra.b _L18_6x
3906 _L18_3x:
3907 cmpi.b %d1,&INF # is operand an INF?
3908 bne.b _L18_4x # no
3909 bsr.l t_operr # yes
3910 bra.b _L18_6x
3911 _L18_4x:
3912 cmpi.b %d1,&QNAN # is operand a QNAN?
3913 bne.b _L18_5x # no
3914 bsr.l src_qnan # yes
3915 bra.b _L18_6x
3916 _L18_5x:
3917 bsr.l sgetexpd # operand is a DENORM
3918 _L18_6x:
3919
3920 #
3921 # Result is now in FP0
3922 #
3923 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3924 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3925 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3926 unlk %a6
3927 rts
3928
3929
3930 #########################################################################
3931 # MONADIC TEMPLATE #
3932 #########################################################################
3933 global _fgetmans_
3934 _fgetmans_:
3935 link %a6,&-LOCAL_SIZE
3936
3937 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3938 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3939 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3940
3941 fmov.l &0x0,%fpcr # zero FPCR
3942
3943 #
3944 # copy, convert, and tag input argument
3945 #
3946 fmov.s 0x8(%a6),%fp0 # load sgl input
3947 fmov.x %fp0,FP_SRC(%a6)
3948 lea FP_SRC(%a6),%a0
3949 bsr.l tag # fetch operand type
3950 mov.b %d0,STAG(%a6)
3951 mov.b %d0,%d1
3952
3953 andi.l &0x00ff00ff,USER_FPSR(%a6)
3954
3955 clr.l %d0
3956 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
3957
3958 tst.b %d1
3959 bne.b _L19_2s
3960 bsr.l sgetman # operand is a NORM
3961 bra.b _L19_6s
3962 _L19_2s:
3963 cmpi.b %d1,&ZERO # is operand a ZERO?
3964 bne.b _L19_3s # no
3965 bsr.l src_zero # yes
3966 bra.b _L19_6s
3967 _L19_3s:
3968 cmpi.b %d1,&INF # is operand an INF?
3969 bne.b _L19_4s # no
3970 bsr.l t_operr # yes
3971 bra.b _L19_6s
3972 _L19_4s:
3973 cmpi.b %d1,&QNAN # is operand a QNAN?
3974 bne.b _L19_5s # no
3975 bsr.l src_qnan # yes
3976 bra.b _L19_6s
3977 _L19_5s:
3978 bsr.l sgetmand # operand is a DENORM
3979 _L19_6s:
3980
3981 #
3982 # Result is now in FP0
3983 #
3984 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
3985 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3986 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
3987 unlk %a6
3988 rts
3989
3990 global _fgetmand_
3991 _fgetmand_:
3992 link %a6,&-LOCAL_SIZE
3993
3994 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
3995 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3996 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
3997
3998 fmov.l &0x0,%fpcr # zero FPCR
3999
4000 #
4001 # copy, convert, and tag input argument
4002 #
4003 fmov.d 0x8(%a6),%fp0 # load dbl input
4004 fmov.x %fp0,FP_SRC(%a6)
4005 lea FP_SRC(%a6),%a0
4006 bsr.l tag # fetch operand type
4007 mov.b %d0,STAG(%a6)
4008 mov.b %d0,%d1
4009
4010 andi.l &0x00ff00ff,USER_FPSR(%a6)
4011
4012 clr.l %d0
4013 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4014
4015 mov.b %d1,STAG(%a6)
4016 tst.b %d1
4017 bne.b _L19_2d
4018 bsr.l sgetman # operand is a NORM
4019 bra.b _L19_6d
4020 _L19_2d:
4021 cmpi.b %d1,&ZERO # is operand a ZERO?
4022 bne.b _L19_3d # no
4023 bsr.l src_zero # yes
4024 bra.b _L19_6d
4025 _L19_3d:
4026 cmpi.b %d1,&INF # is operand an INF?
4027 bne.b _L19_4d # no
4028 bsr.l t_operr # yes
4029 bra.b _L19_6d
4030 _L19_4d:
4031 cmpi.b %d1,&QNAN # is operand a QNAN?
4032 bne.b _L19_5d # no
4033 bsr.l src_qnan # yes
4034 bra.b _L19_6d
4035 _L19_5d:
4036 bsr.l sgetmand # operand is a DENORM
4037 _L19_6d:
4038
4039 #
4040 # Result is now in FP0
4041 #
4042 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4043 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4044 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4045 unlk %a6
4046 rts
4047
4048 global _fgetmanx_
4049 _fgetmanx_:
4050 link %a6,&-LOCAL_SIZE
4051
4052 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4053 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4054 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4055
4056 fmov.l &0x0,%fpcr # zero FPCR
4057
4058 #
4059 # copy, convert, and tag input argument
4060 #
4061 lea FP_SRC(%a6),%a0
4062 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
4063 mov.l 0x8+0x4(%a6),0x4(%a0)
4064 mov.l 0x8+0x8(%a6),0x8(%a0)
4065 bsr.l tag # fetch operand type
4066 mov.b %d0,STAG(%a6)
4067 mov.b %d0,%d1
4068
4069 andi.l &0x00ff00ff,USER_FPSR(%a6)
4070
4071 clr.l %d0
4072 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4073
4074 tst.b %d1
4075 bne.b _L19_2x
4076 bsr.l sgetman # operand is a NORM
4077 bra.b _L19_6x
4078 _L19_2x:
4079 cmpi.b %d1,&ZERO # is operand a ZERO?
4080 bne.b _L19_3x # no
4081 bsr.l src_zero # yes
4082 bra.b _L19_6x
4083 _L19_3x:
4084 cmpi.b %d1,&INF # is operand an INF?
4085 bne.b _L19_4x # no
4086 bsr.l t_operr # yes
4087 bra.b _L19_6x
4088 _L19_4x:
4089 cmpi.b %d1,&QNAN # is operand a QNAN?
4090 bne.b _L19_5x # no
4091 bsr.l src_qnan # yes
4092 bra.b _L19_6x
4093 _L19_5x:
4094 bsr.l sgetmand # operand is a DENORM
4095 _L19_6x:
4096
4097 #
4098 # Result is now in FP0
4099 #
4100 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4101 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4102 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4103 unlk %a6
4104 rts
4105
4106
4107 #########################################################################
4108 # MONADIC TEMPLATE #
4109 #########################################################################
4110 global _fsincoss_
4111 _fsincoss_:
4112 link %a6,&-LOCAL_SIZE
4113
4114 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4115 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4116 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4117
4118 fmov.l &0x0,%fpcr # zero FPCR
4119
4120 #
4121 # copy, convert, and tag input argument
4122 #
4123 fmov.s 0x8(%a6),%fp0 # load sgl input
4124 fmov.x %fp0,FP_SRC(%a6)
4125 lea FP_SRC(%a6),%a0
4126 bsr.l tag # fetch operand type
4127 mov.b %d0,STAG(%a6)
4128 mov.b %d0,%d1
4129
4130 andi.l &0x00ff00ff,USER_FPSR(%a6)
4131
4132 clr.l %d0
4133 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4134
4135 tst.b %d1
4136 bne.b _L20_2s
4137 bsr.l ssincos # operand is a NORM
4138 bra.b _L20_6s
4139 _L20_2s:
4140 cmpi.b %d1,&ZERO # is operand a ZERO?
4141 bne.b _L20_3s # no
4142 bsr.l ssincosz # yes
4143 bra.b _L20_6s
4144 _L20_3s:
4145 cmpi.b %d1,&INF # is operand an INF?
4146 bne.b _L20_4s # no
4147 bsr.l ssincosi # yes
4148 bra.b _L20_6s
4149 _L20_4s:
4150 cmpi.b %d1,&QNAN # is operand a QNAN?
4151 bne.b _L20_5s # no
4152 bsr.l ssincosqnan # yes
4153 bra.b _L20_6s
4154 _L20_5s:
4155 bsr.l ssincosd # operand is a DENORM
4156 _L20_6s:
4157
4158 #
4159 # Result is now in FP0
4160 #
4161 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4162 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4163 fmovm.x &0x03,-(%sp) # store off fp0/fp1
4164 fmovm.x (%sp)+,&0x40 # fp0 now in fp1
4165 fmovm.x (%sp)+,&0x80 # fp1 now in fp0
4166 unlk %a6
4167 rts
4168
4169 global _fsincosd_
4170 _fsincosd_:
4171 link %a6,&-LOCAL_SIZE
4172
4173 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4174 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4175 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4176
4177 fmov.l &0x0,%fpcr # zero FPCR
4178
4179 #
4180 # copy, convert, and tag input argument
4181 #
4182 fmov.d 0x8(%a6),%fp0 # load dbl input
4183 fmov.x %fp0,FP_SRC(%a6)
4184 lea FP_SRC(%a6),%a0
4185 bsr.l tag # fetch operand type
4186 mov.b %d0,STAG(%a6)
4187 mov.b %d0,%d1
4188
4189 andi.l &0x00ff00ff,USER_FPSR(%a6)
4190
4191 clr.l %d0
4192 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4193
4194 mov.b %d1,STAG(%a6)
4195 tst.b %d1
4196 bne.b _L20_2d
4197 bsr.l ssincos # operand is a NORM
4198 bra.b _L20_6d
4199 _L20_2d:
4200 cmpi.b %d1,&ZERO # is operand a ZERO?
4201 bne.b _L20_3d # no
4202 bsr.l ssincosz # yes
4203 bra.b _L20_6d
4204 _L20_3d:
4205 cmpi.b %d1,&INF # is operand an INF?
4206 bne.b _L20_4d # no
4207 bsr.l ssincosi # yes
4208 bra.b _L20_6d
4209 _L20_4d:
4210 cmpi.b %d1,&QNAN # is operand a QNAN?
4211 bne.b _L20_5d # no
4212 bsr.l ssincosqnan # yes
4213 bra.b _L20_6d
4214 _L20_5d:
4215 bsr.l ssincosd # operand is a DENORM
4216 _L20_6d:
4217
4218 #
4219 # Result is now in FP0
4220 #
4221 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4222 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4223 fmovm.x &0x03,-(%sp) # store off fp0/fp1
4224 fmovm.x (%sp)+,&0x40 # fp0 now in fp1
4225 fmovm.x (%sp)+,&0x80 # fp1 now in fp0
4226 unlk %a6
4227 rts
4228
4229 global _fsincosx_
4230 _fsincosx_:
4231 link %a6,&-LOCAL_SIZE
4232
4233 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4234 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4235 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4236
4237 fmov.l &0x0,%fpcr # zero FPCR
4238
4239 #
4240 # copy, convert, and tag input argument
4241 #
4242 lea FP_SRC(%a6),%a0
4243 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input
4244 mov.l 0x8+0x4(%a6),0x4(%a0)
4245 mov.l 0x8+0x8(%a6),0x8(%a0)
4246 bsr.l tag # fetch operand type
4247 mov.b %d0,STAG(%a6)
4248 mov.b %d0,%d1
4249
4250 andi.l &0x00ff00ff,USER_FPSR(%a6)
4251
4252 clr.l %d0
4253 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4254
4255 tst.b %d1
4256 bne.b _L20_2x
4257 bsr.l ssincos # operand is a NORM
4258 bra.b _L20_6x
4259 _L20_2x:
4260 cmpi.b %d1,&ZERO # is operand a ZERO?
4261 bne.b _L20_3x # no
4262 bsr.l ssincosz # yes
4263 bra.b _L20_6x
4264 _L20_3x:
4265 cmpi.b %d1,&INF # is operand an INF?
4266 bne.b _L20_4x # no
4267 bsr.l ssincosi # yes
4268 bra.b _L20_6x
4269 _L20_4x:
4270 cmpi.b %d1,&QNAN # is operand a QNAN?
4271 bne.b _L20_5x # no
4272 bsr.l ssincosqnan # yes
4273 bra.b _L20_6x
4274 _L20_5x:
4275 bsr.l ssincosd # operand is a DENORM
4276 _L20_6x:
4277
4278 #
4279 # Result is now in FP0
4280 #
4281 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4282 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4283 fmovm.x &0x03,-(%sp) # store off fp0/fp1
4284 fmovm.x (%sp)+,&0x40 # fp0 now in fp1
4285 fmovm.x (%sp)+,&0x80 # fp1 now in fp0
4286 unlk %a6
4287 rts
4288
4289
4290 #########################################################################
4291 # DYADIC TEMPLATE #
4292 #########################################################################
4293 global _frems_
4294 _frems_:
4295 link %a6,&-LOCAL_SIZE
4296
4297 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4298 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4299 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4300
4301 fmov.l &0x0,%fpcr # zero FPCR
4302
4303 #
4304 # copy, convert, and tag input argument
4305 #
4306 fmov.s 0x8(%a6),%fp0 # load sgl dst
4307 fmov.x %fp0,FP_DST(%a6)
4308 lea FP_DST(%a6),%a0
4309 bsr.l tag # fetch operand type
4310 mov.b %d0,DTAG(%a6)
4311
4312 fmov.s 0xc(%a6),%fp0 # load sgl src
4313 fmov.x %fp0,FP_SRC(%a6)
4314 lea FP_SRC(%a6),%a0
4315 bsr.l tag # fetch operand type
4316 mov.b %d0,STAG(%a6)
4317 mov.l %d0,%d1
4318
4319 andi.l &0x00ff00ff,USER_FPSR(%a6)
4320
4321 clr.l %d0
4322 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4323
4324 lea FP_SRC(%a6),%a0 # pass ptr to src
4325 lea FP_DST(%a6),%a1 # pass ptr to dst
4326
4327 tst.b %d1
4328 bne.b _L21_2s
4329 bsr.l srem_snorm # operand is a NORM
4330 bra.b _L21_6s
4331 _L21_2s:
4332 cmpi.b %d1,&ZERO # is operand a ZERO?
4333 bne.b _L21_3s # no
4334 bsr.l srem_szero # yes
4335 bra.b _L21_6s
4336 _L21_3s:
4337 cmpi.b %d1,&INF # is operand an INF?
4338 bne.b _L21_4s # no
4339 bsr.l srem_sinf # yes
4340 bra.b _L21_6s
4341 _L21_4s:
4342 cmpi.b %d1,&QNAN # is operand a QNAN?
4343 bne.b _L21_5s # no
4344 bsr.l sop_sqnan # yes
4345 bra.b _L21_6s
4346 _L21_5s:
4347 bsr.l srem_sdnrm # operand is a DENORM
4348 _L21_6s:
4349
4350 #
4351 # Result is now in FP0
4352 #
4353 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4354 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4355 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4356 unlk %a6
4357 rts
4358
4359 global _fremd_
4360 _fremd_:
4361 link %a6,&-LOCAL_SIZE
4362
4363 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4364 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4365 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4366
4367 fmov.l &0x0,%fpcr # zero FPCR
4368
4369 #
4370 # copy, convert, and tag input argument
4371 #
4372 fmov.d 0x8(%a6),%fp0 # load dbl dst
4373 fmov.x %fp0,FP_DST(%a6)
4374 lea FP_DST(%a6),%a0
4375 bsr.l tag # fetch operand type
4376 mov.b %d0,DTAG(%a6)
4377
4378 fmov.d 0x10(%a6),%fp0 # load dbl src
4379 fmov.x %fp0,FP_SRC(%a6)
4380 lea FP_SRC(%a6),%a0
4381 bsr.l tag # fetch operand type
4382 mov.b %d0,STAG(%a6)
4383 mov.l %d0,%d1
4384
4385 andi.l &0x00ff00ff,USER_FPSR(%a6)
4386
4387 clr.l %d0
4388 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4389
4390 lea FP_SRC(%a6),%a0 # pass ptr to src
4391 lea FP_DST(%a6),%a1 # pass ptr to dst
4392
4393 tst.b %d1
4394 bne.b _L21_2d
4395 bsr.l srem_snorm # operand is a NORM
4396 bra.b _L21_6d
4397 _L21_2d:
4398 cmpi.b %d1,&ZERO # is operand a ZERO?
4399 bne.b _L21_3d # no
4400 bsr.l srem_szero # yes
4401 bra.b _L21_6d
4402 _L21_3d:
4403 cmpi.b %d1,&INF # is operand an INF?
4404 bne.b _L21_4d # no
4405 bsr.l srem_sinf # yes
4406 bra.b _L21_6d
4407 _L21_4d:
4408 cmpi.b %d1,&QNAN # is operand a QNAN?
4409 bne.b _L21_5d # no
4410 bsr.l sop_sqnan # yes
4411 bra.b _L21_6d
4412 _L21_5d:
4413 bsr.l srem_sdnrm # operand is a DENORM
4414 _L21_6d:
4415
4416 #
4417 # Result is now in FP0
4418 #
4419 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4420 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4421 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4422 unlk %a6
4423 rts
4424
4425 global _fremx_
4426 _fremx_:
4427 link %a6,&-LOCAL_SIZE
4428
4429 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4430 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4431 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4432
4433 fmov.l &0x0,%fpcr # zero FPCR
4434
4435 #
4436 # copy, convert, and tag input argument
4437 #
4438 lea FP_DST(%a6),%a0
4439 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dst
4440 mov.l 0x8+0x4(%a6),0x4(%a0)
4441 mov.l 0x8+0x8(%a6),0x8(%a0)
4442 bsr.l tag # fetch operand type
4443 mov.b %d0,DTAG(%a6)
4444
4445 lea FP_SRC(%a6),%a0
4446 mov.l 0x14+0x0(%a6),0x0(%a0) # load ext src
4447 mov.l 0x14+0x4(%a6),0x4(%a0)
4448 mov.l 0x14+0x8(%a6),0x8(%a0)
4449 bsr.l tag # fetch operand type
4450 mov.b %d0,STAG(%a6)
4451 mov.l %d0,%d1
4452
4453 andi.l &0x00ff00ff,USER_FPSR(%a6)
4454
4455 clr.l %d0
4456 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4457
4458 lea FP_SRC(%a6),%a0 # pass ptr to src
4459 lea FP_DST(%a6),%a1 # pass ptr to dst
4460
4461 tst.b %d1
4462 bne.b _L21_2x
4463 bsr.l srem_snorm # operand is a NORM
4464 bra.b _L21_6x
4465 _L21_2x:
4466 cmpi.b %d1,&ZERO # is operand a ZERO?
4467 bne.b _L21_3x # no
4468 bsr.l srem_szero # yes
4469 bra.b _L21_6x
4470 _L21_3x:
4471 cmpi.b %d1,&INF # is operand an INF?
4472 bne.b _L21_4x # no
4473 bsr.l srem_sinf # yes
4474 bra.b _L21_6x
4475 _L21_4x:
4476 cmpi.b %d1,&QNAN # is operand a QNAN?
4477 bne.b _L21_5x # no
4478 bsr.l sop_sqnan # yes
4479 bra.b _L21_6x
4480 _L21_5x:
4481 bsr.l srem_sdnrm # operand is a DENORM
4482 _L21_6x:
4483
4484 #
4485 # Result is now in FP0
4486 #
4487 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4488 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4489 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4490 unlk %a6
4491 rts
4492
4493
4494 #########################################################################
4495 # DYADIC TEMPLATE #
4496 #########################################################################
4497 global _fmods_
4498 _fmods_:
4499 link %a6,&-LOCAL_SIZE
4500
4501 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4502 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4503 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4504
4505 fmov.l &0x0,%fpcr # zero FPCR
4506
4507 #
4508 # copy, convert, and tag input argument
4509 #
4510 fmov.s 0x8(%a6),%fp0 # load sgl dst
4511 fmov.x %fp0,FP_DST(%a6)
4512 lea FP_DST(%a6),%a0
4513 bsr.l tag # fetch operand type
4514 mov.b %d0,DTAG(%a6)
4515
4516 fmov.s 0xc(%a6),%fp0 # load sgl src
4517 fmov.x %fp0,FP_SRC(%a6)
4518 lea FP_SRC(%a6),%a0
4519 bsr.l tag # fetch operand type
4520 mov.b %d0,STAG(%a6)
4521 mov.l %d0,%d1
4522
4523 andi.l &0x00ff00ff,USER_FPSR(%a6)
4524
4525 clr.l %d0
4526 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4527
4528 lea FP_SRC(%a6),%a0 # pass ptr to src
4529 lea FP_DST(%a6),%a1 # pass ptr to dst
4530
4531 tst.b %d1
4532 bne.b _L22_2s
4533 bsr.l smod_snorm # operand is a NORM
4534 bra.b _L22_6s
4535 _L22_2s:
4536 cmpi.b %d1,&ZERO # is operand a ZERO?
4537 bne.b _L22_3s # no
4538 bsr.l smod_szero # yes
4539 bra.b _L22_6s
4540 _L22_3s:
4541 cmpi.b %d1,&INF # is operand an INF?
4542 bne.b _L22_4s # no
4543 bsr.l smod_sinf # yes
4544 bra.b _L22_6s
4545 _L22_4s:
4546 cmpi.b %d1,&QNAN # is operand a QNAN?
4547 bne.b _L22_5s # no
4548 bsr.l sop_sqnan # yes
4549 bra.b _L22_6s
4550 _L22_5s:
4551 bsr.l smod_sdnrm # operand is a DENORM
4552 _L22_6s:
4553
4554 #
4555 # Result is now in FP0
4556 #
4557 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4558 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4559 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4560 unlk %a6
4561 rts
4562
4563 global _fmodd_
4564 _fmodd_:
4565 link %a6,&-LOCAL_SIZE
4566
4567 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4568 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4569 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4570
4571 fmov.l &0x0,%fpcr # zero FPCR
4572
4573 #
4574 # copy, convert, and tag input argument
4575 #
4576 fmov.d 0x8(%a6),%fp0 # load dbl dst
4577 fmov.x %fp0,FP_DST(%a6)
4578 lea FP_DST(%a6),%a0
4579 bsr.l tag # fetch operand type
4580 mov.b %d0,DTAG(%a6)
4581
4582 fmov.d 0x10(%a6),%fp0 # load dbl src
4583 fmov.x %fp0,FP_SRC(%a6)
4584 lea FP_SRC(%a6),%a0
4585 bsr.l tag # fetch operand type
4586 mov.b %d0,STAG(%a6)
4587 mov.l %d0,%d1
4588
4589 andi.l &0x00ff00ff,USER_FPSR(%a6)
4590
4591 clr.l %d0
4592 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4593
4594 lea FP_SRC(%a6),%a0 # pass ptr to src
4595 lea FP_DST(%a6),%a1 # pass ptr to dst
4596
4597 tst.b %d1
4598 bne.b _L22_2d
4599 bsr.l smod_snorm # operand is a NORM
4600 bra.b _L22_6d
4601 _L22_2d:
4602 cmpi.b %d1,&ZERO # is operand a ZERO?
4603 bne.b _L22_3d # no
4604 bsr.l smod_szero # yes
4605 bra.b _L22_6d
4606 _L22_3d:
4607 cmpi.b %d1,&INF # is operand an INF?
4608 bne.b _L22_4d # no
4609 bsr.l smod_sinf # yes
4610 bra.b _L22_6d
4611 _L22_4d:
4612 cmpi.b %d1,&QNAN # is operand a QNAN?
4613 bne.b _L22_5d # no
4614 bsr.l sop_sqnan # yes
4615 bra.b _L22_6d
4616 _L22_5d:
4617 bsr.l smod_sdnrm # operand is a DENORM
4618 _L22_6d:
4619
4620 #
4621 # Result is now in FP0
4622 #
4623 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4624 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4625 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4626 unlk %a6
4627 rts
4628
4629 global _fmodx_
4630 _fmodx_:
4631 link %a6,&-LOCAL_SIZE
4632
4633 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4634 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4635 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4636
4637 fmov.l &0x0,%fpcr # zero FPCR
4638
4639 #
4640 # copy, convert, and tag input argument
4641 #
4642 lea FP_DST(%a6),%a0
4643 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dst
4644 mov.l 0x8+0x4(%a6),0x4(%a0)
4645 mov.l 0x8+0x8(%a6),0x8(%a0)
4646 bsr.l tag # fetch operand type
4647 mov.b %d0,DTAG(%a6)
4648
4649 lea FP_SRC(%a6),%a0
4650 mov.l 0x14+0x0(%a6),0x0(%a0) # load ext src
4651 mov.l 0x14+0x4(%a6),0x4(%a0)
4652 mov.l 0x14+0x8(%a6),0x8(%a0)
4653 bsr.l tag # fetch operand type
4654 mov.b %d0,STAG(%a6)
4655 mov.l %d0,%d1
4656
4657 andi.l &0x00ff00ff,USER_FPSR(%a6)
4658
4659 clr.l %d0
4660 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4661
4662 lea FP_SRC(%a6),%a0 # pass ptr to src
4663 lea FP_DST(%a6),%a1 # pass ptr to dst
4664
4665 tst.b %d1
4666 bne.b _L22_2x
4667 bsr.l smod_snorm # operand is a NORM
4668 bra.b _L22_6x
4669 _L22_2x:
4670 cmpi.b %d1,&ZERO # is operand a ZERO?
4671 bne.b _L22_3x # no
4672 bsr.l smod_szero # yes
4673 bra.b _L22_6x
4674 _L22_3x:
4675 cmpi.b %d1,&INF # is operand an INF?
4676 bne.b _L22_4x # no
4677 bsr.l smod_sinf # yes
4678 bra.b _L22_6x
4679 _L22_4x:
4680 cmpi.b %d1,&QNAN # is operand a QNAN?
4681 bne.b _L22_5x # no
4682 bsr.l sop_sqnan # yes
4683 bra.b _L22_6x
4684 _L22_5x:
4685 bsr.l smod_sdnrm # operand is a DENORM
4686 _L22_6x:
4687
4688 #
4689 # Result is now in FP0
4690 #
4691 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4692 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4693 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4694 unlk %a6
4695 rts
4696
4697
4698 #########################################################################
4699 # DYADIC TEMPLATE #
4700 #########################################################################
4701 global _fscales_
4702 _fscales_:
4703 link %a6,&-LOCAL_SIZE
4704
4705 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4706 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4707 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4708
4709 fmov.l &0x0,%fpcr # zero FPCR
4710
4711 #
4712 # copy, convert, and tag input argument
4713 #
4714 fmov.s 0x8(%a6),%fp0 # load sgl dst
4715 fmov.x %fp0,FP_DST(%a6)
4716 lea FP_DST(%a6),%a0
4717 bsr.l tag # fetch operand type
4718 mov.b %d0,DTAG(%a6)
4719
4720 fmov.s 0xc(%a6),%fp0 # load sgl src
4721 fmov.x %fp0,FP_SRC(%a6)
4722 lea FP_SRC(%a6),%a0
4723 bsr.l tag # fetch operand type
4724 mov.b %d0,STAG(%a6)
4725 mov.l %d0,%d1
4726
4727 andi.l &0x00ff00ff,USER_FPSR(%a6)
4728
4729 clr.l %d0
4730 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4731
4732 lea FP_SRC(%a6),%a0 # pass ptr to src
4733 lea FP_DST(%a6),%a1 # pass ptr to dst
4734
4735 tst.b %d1
4736 bne.b _L23_2s
4737 bsr.l sscale_snorm # operand is a NORM
4738 bra.b _L23_6s
4739 _L23_2s:
4740 cmpi.b %d1,&ZERO # is operand a ZERO?
4741 bne.b _L23_3s # no
4742 bsr.l sscale_szero # yes
4743 bra.b _L23_6s
4744 _L23_3s:
4745 cmpi.b %d1,&INF # is operand an INF?
4746 bne.b _L23_4s # no
4747 bsr.l sscale_sinf # yes
4748 bra.b _L23_6s
4749 _L23_4s:
4750 cmpi.b %d1,&QNAN # is operand a QNAN?
4751 bne.b _L23_5s # no
4752 bsr.l sop_sqnan # yes
4753 bra.b _L23_6s
4754 _L23_5s:
4755 bsr.l sscale_sdnrm # operand is a DENORM
4756 _L23_6s:
4757
4758 #
4759 # Result is now in FP0
4760 #
4761 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4762 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4763 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4764 unlk %a6
4765 rts
4766
4767 global _fscaled_
4768 _fscaled_:
4769 link %a6,&-LOCAL_SIZE
4770
4771 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4772 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4773 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4774
4775 fmov.l &0x0,%fpcr # zero FPCR
4776
4777 #
4778 # copy, convert, and tag input argument
4779 #
4780 fmov.d 0x8(%a6),%fp0 # load dbl dst
4781 fmov.x %fp0,FP_DST(%a6)
4782 lea FP_DST(%a6),%a0
4783 bsr.l tag # fetch operand type
4784 mov.b %d0,DTAG(%a6)
4785
4786 fmov.d 0x10(%a6),%fp0 # load dbl src
4787 fmov.x %fp0,FP_SRC(%a6)
4788 lea FP_SRC(%a6),%a0
4789 bsr.l tag # fetch operand type
4790 mov.b %d0,STAG(%a6)
4791 mov.l %d0,%d1
4792
4793 andi.l &0x00ff00ff,USER_FPSR(%a6)
4794
4795 clr.l %d0
4796 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4797
4798 lea FP_SRC(%a6),%a0 # pass ptr to src
4799 lea FP_DST(%a6),%a1 # pass ptr to dst
4800
4801 tst.b %d1
4802 bne.b _L23_2d
4803 bsr.l sscale_snorm # operand is a NORM
4804 bra.b _L23_6d
4805 _L23_2d:
4806 cmpi.b %d1,&ZERO # is operand a ZERO?
4807 bne.b _L23_3d # no
4808 bsr.l sscale_szero # yes
4809 bra.b _L23_6d
4810 _L23_3d:
4811 cmpi.b %d1,&INF # is operand an INF?
4812 bne.b _L23_4d # no
4813 bsr.l sscale_sinf # yes
4814 bra.b _L23_6d
4815 _L23_4d:
4816 cmpi.b %d1,&QNAN # is operand a QNAN?
4817 bne.b _L23_5d # no
4818 bsr.l sop_sqnan # yes
4819 bra.b _L23_6d
4820 _L23_5d:
4821 bsr.l sscale_sdnrm # operand is a DENORM
4822 _L23_6d:
4823
4824 #
4825 # Result is now in FP0
4826 #
4827 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4828 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4829 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4830 unlk %a6
4831 rts
4832
4833 global _fscalex_
4834 _fscalex_:
4835 link %a6,&-LOCAL_SIZE
4836
4837 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1
4838 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4839 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1
4840
4841 fmov.l &0x0,%fpcr # zero FPCR
4842
4843 #
4844 # copy, convert, and tag input argument
4845 #
4846 lea FP_DST(%a6),%a0
4847 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dst
4848 mov.l 0x8+0x4(%a6),0x4(%a0)
4849 mov.l 0x8+0x8(%a6),0x8(%a0)
4850 bsr.l tag # fetch operand type
4851 mov.b %d0,DTAG(%a6)
4852
4853 lea FP_SRC(%a6),%a0
4854 mov.l 0x14+0x0(%a6),0x0(%a0) # load ext src
4855 mov.l 0x14+0x4(%a6),0x4(%a0)
4856 mov.l 0x14+0x8(%a6),0x8(%a0)
4857 bsr.l tag # fetch operand type
4858 mov.b %d0,STAG(%a6)
4859 mov.l %d0,%d1
4860
4861 andi.l &0x00ff00ff,USER_FPSR(%a6)
4862
4863 clr.l %d0
4864 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec
4865
4866 lea FP_SRC(%a6),%a0 # pass ptr to src
4867 lea FP_DST(%a6),%a1 # pass ptr to dst
4868
4869 tst.b %d1
4870 bne.b _L23_2x
4871 bsr.l sscale_snorm # operand is a NORM
4872 bra.b _L23_6x
4873 _L23_2x:
4874 cmpi.b %d1,&ZERO # is operand a ZERO?
4875 bne.b _L23_3x # no
4876 bsr.l sscale_szero # yes
4877 bra.b _L23_6x
4878 _L23_3x:
4879 cmpi.b %d1,&INF # is operand an INF?
4880 bne.b _L23_4x # no
4881 bsr.l sscale_sinf # yes
4882 bra.b _L23_6x
4883 _L23_4x:
4884 cmpi.b %d1,&QNAN # is operand a QNAN?
4885 bne.b _L23_5x # no
4886 bsr.l sop_sqnan # yes
4887 bra.b _L23_6x
4888 _L23_5x:
4889 bsr.l sscale_sdnrm # operand is a DENORM
4890 _L23_6x:
4891
4892 #
4893 # Result is now in FP0
4894 #
4895 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1
4896 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4897 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1
4898 unlk %a6
4899 rts
4900
4901
4902 #########################################################################
4903 # ssin(): computes the sine of a normalized input #
4904 # ssind(): computes the sine of a denormalized input #
4905 # scos(): computes the cosine of a normalized input #
4906 # scosd(): computes the cosine of a denormalized input #
4907 # ssincos(): computes the sine and cosine of a normalized input #
4908 # ssincosd(): computes the sine and cosine of a denormalized input #
4909 # #
4910 # INPUT *************************************************************** #
4911 # a0 = pointer to extended precision input #
4912 # d0 = round precision,mode #
4913 # #
4914 # OUTPUT ************************************************************** #
4915 # fp0 = sin(X) or cos(X) #
4916 # #
4917 # For ssincos(X): #
4918 # fp0 = sin(X) #
4919 # fp1 = cos(X) #
4920 # #
4921 # ACCURACY and MONOTONICITY ******************************************* #
4922 # The returned result is within 1 ulp in 64 significant bit, i.e. #
4923 # within 0.5001 ulp to 53 bits if the result is subsequently #
4924 # rounded to double precision. The result is provably monotonic #
4925 # in double precision. #
4926 # #
4927 # ALGORITHM *********************************************************** #
4928 # #
4929 # SIN and COS: #
4930 # 1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1. #
4931 # #
4932 # 2. If |X| >= 15Pi or |X| < 2**(-40), go to 7. #
4933 # #
4934 # 3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let #
4935 # k = N mod 4, so in particular, k = 0,1,2,or 3. #
4936 # Overwrite k by k := k + AdjN. #
4937 # #
4938 # 4. If k is even, go to 6. #
4939 # #
4940 # 5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j. #
4941 # Return sgn*cos(r) where cos(r) is approximated by an #
4942 # even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)), #
4943 # s = r*r. #
4944 # Exit. #
4945 # #
4946 # 6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r) #
4947 # where sin(r) is approximated by an odd polynomial in r #
4948 # r + r*s*(A1+s*(A2+ ... + s*A7)), s = r*r. #
4949 # Exit. #
4950 # #
4951 # 7. If |X| > 1, go to 9. #
4952 # #
4953 # 8. (|X|<2**(-40)) If SIN is invoked, return X; #
4954 # otherwise return 1. #
4955 # #
4956 # 9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, #
4957 # go back to 3. #
4958 # #
4959 # SINCOS: #
4960 # 1. If |X| >= 15Pi or |X| < 2**(-40), go to 6. #
4961 # #
4962 # 2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let #
4963 # k = N mod 4, so in particular, k = 0,1,2,or 3. #
4964 # #
4965 # 3. If k is even, go to 5. #
4966 # #
4967 # 4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie. #
4968 # j1 exclusive or with the l.s.b. of k. #
4969 # sgn1 := (-1)**j1, sgn2 := (-1)**j2. #
4970 # SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where #
4971 # sin(r) and cos(r) are computed as odd and even #
4972 # polynomials in r, respectively. Exit #
4973 # #
4974 # 5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1. #
4975 # SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where #
4976 # sin(r) and cos(r) are computed as odd and even #
4977 # polynomials in r, respectively. Exit #
4978 # #
4979 # 6. If |X| > 1, go to 8. #
4980 # #
4981 # 7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit. #
4982 # #
4983 # 8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, #
4984 # go back to 2. #
4985 # #
4986 #########################################################################
4987
4988 SINA7: long 0xBD6AAA77,0xCCC994F5
4989 SINA6: long 0x3DE61209,0x7AAE8DA1
4990 SINA5: long 0xBE5AE645,0x2A118AE4
4991 SINA4: long 0x3EC71DE3,0xA5341531
4992 SINA3: long 0xBF2A01A0,0x1A018B59,0x00000000,0x00000000
4993 SINA2: long 0x3FF80000,0x88888888,0x888859AF,0x00000000
4994 SINA1: long 0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000
4995
4996 COSB8: long 0x3D2AC4D0,0xD6011EE3
4997 COSB7: long 0xBDA9396F,0x9F45AC19
4998 COSB6: long 0x3E21EED9,0x0612C972
4999 COSB5: long 0xBE927E4F,0xB79D9FCF
5000 COSB4: long 0x3EFA01A0,0x1A01D423,0x00000000,0x00000000
5001 COSB3: long 0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000
5002 COSB2: long 0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E
5003 COSB1: long 0xBF000000
5004
5005 set INARG,FP_SCR0
5006
5007 set X,FP_SCR0
5008 # set XDCARE,X+2
5009 set XFRAC,X+4
5010
5011 set RPRIME,FP_SCR0
5012 set SPRIME,FP_SCR1
5013
5014 set POSNEG1,L_SCR1
5015 set TWOTO63,L_SCR1
5016
5017 set ENDFLAG,L_SCR2
5018 set INT,L_SCR2
5019
5020 set ADJN,L_SCR3
5021
5022 ############################################
5023 global ssin
5024 ssin:
5025 mov.l &0,ADJN(%a6) # yes; SET ADJN TO 0
5026 bra.b SINBGN
5027
5028 ############################################
5029 global scos
5030 scos:
5031 mov.l &1,ADJN(%a6) # yes; SET ADJN TO 1
5032
5033 ############################################
5034 SINBGN:
5035 #--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE
5036
5037 fmov.x (%a0),%fp0 # LOAD INPUT
5038 fmov.x %fp0,X(%a6) # save input at X
5039
5040 # "COMPACTIFY" X
5041 mov.l (%a0),%d1 # put exp in hi word
5042 mov.w 4(%a0),%d1 # fetch hi(man)
5043 and.l &0x7FFFFFFF,%d1 # strip sign
5044
5045 cmpi.l %d1,&0x3FD78000 # is |X| >= 2**(-40)?
5046 bge.b SOK1 # no
5047 bra.w SINSM # yes; input is very small
5048
5049 SOK1:
5050 cmp.l %d1,&0x4004BC7E # is |X| < 15 PI?
5051 blt.b SINMAIN # no
5052 bra.w SREDUCEX # yes; input is very large
5053
5054 #--THIS IS THE USUAL CASE, |X| <= 15 PI.
5055 #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5056 SINMAIN:
5057 fmov.x %fp0,%fp1
5058 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5059
5060 lea PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32
5061
5062 fmov.l %fp1,INT(%a6) # CONVERT TO INTEGER
5063
5064 mov.l INT(%a6),%d1 # make a copy of N
5065 asl.l &4,%d1 # N *= 16
5066 add.l %d1,%a1 # tbl_addr = a1 + (N*16)
5067
5068 # A1 IS THE ADDRESS OF N*PIBY2
5069 # ...WHICH IS IN TWO PIECES Y1 & Y2
5070 fsub.x (%a1)+,%fp0 # X-Y1
5071 fsub.s (%a1),%fp0 # fp0 = R = (X-Y1)-Y2
5072
5073 SINCONT:
5074 #--continuation from REDUCEX
5075
5076 #--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDED
5077 mov.l INT(%a6),%d1
5078 add.l ADJN(%a6),%d1 # SEE IF D0 IS ODD OR EVEN
5079 ror.l &1,%d1 # D0 WAS ODD IFF D0 IS NEGATIVE
5080 cmp.l %d1,&0
5081 blt.w COSPOLY
5082
5083 #--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
5084 #--THEN WE RETURN SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY
5085 #--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE
5086 #--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS
5087 #--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))])
5088 #--WHERE T=S*S.
5089 #--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION
5090 #--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT.
5091 SINPOLY:
5092 fmovm.x &0x0c,-(%sp) # save fp2/fp3
5093
5094 fmov.x %fp0,X(%a6) # X IS R
5095 fmul.x %fp0,%fp0 # FP0 IS S
5096
5097 fmov.d SINA7(%pc),%fp3
5098 fmov.d SINA6(%pc),%fp2
5099
5100 fmov.x %fp0,%fp1
5101 fmul.x %fp1,%fp1 # FP1 IS T
5102
5103 ror.l &1,%d1
5104 and.l &0x80000000,%d1
5105 # ...LEAST SIG. BIT OF D0 IN SIGN POSITION
5106 eor.l %d1,X(%a6) # X IS NOW R'= SGN*R
5107
5108 fmul.x %fp1,%fp3 # TA7
5109 fmul.x %fp1,%fp2 # TA6
5110
5111 fadd.d SINA5(%pc),%fp3 # A5+TA7
5112 fadd.d SINA4(%pc),%fp2 # A4+TA6
5113
5114 fmul.x %fp1,%fp3 # T(A5+TA7)
5115 fmul.x %fp1,%fp2 # T(A4+TA6)
5116
5117 fadd.d SINA3(%pc),%fp3 # A3+T(A5+TA7)
5118 fadd.x SINA2(%pc),%fp2 # A2+T(A4+TA6)
5119
5120 fmul.x %fp3,%fp1 # T(A3+T(A5+TA7))
5121
5122 fmul.x %fp0,%fp2 # S(A2+T(A4+TA6))
5123 fadd.x SINA1(%pc),%fp1 # A1+T(A3+T(A5+TA7))
5124 fmul.x X(%a6),%fp0 # R'*S
5125
5126 fadd.x %fp2,%fp1 # [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]
5127
5128 fmul.x %fp1,%fp0 # SIN(R')-R'
5129
5130 fmovm.x (%sp)+,&0x30 # restore fp2/fp3
5131
5132 fmov.l %d0,%fpcr # restore users round mode,prec
5133 fadd.x X(%a6),%fp0 # last inst - possible exception set
5134 bra t_inx2
5135
5136 #--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
5137 #--THEN WE RETURN SGN*COS(R). SGN*COS(R) IS COMPUTED BY
5138 #--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE
5139 #--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS
5140 #--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))])
5141 #--WHERE T=S*S.
5142 #--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION
5143 #--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2
5144 #--AND IS THEREFORE STORED AS SINGLE PRECISION.
5145 COSPOLY:
5146 fmovm.x &0x0c,-(%sp) # save fp2/fp3
5147
5148 fmul.x %fp0,%fp0 # FP0 IS S
5149
5150 fmov.d COSB8(%pc),%fp2
5151 fmov.d COSB7(%pc),%fp3
5152
5153 fmov.x %fp0,%fp1
5154 fmul.x %fp1,%fp1 # FP1 IS T
5155
5156 fmov.x %fp0,X(%a6) # X IS S
5157 ror.l &1,%d1
5158 and.l &0x80000000,%d1
5159 # ...LEAST SIG. BIT OF D0 IN SIGN POSITION
5160
5161 fmul.x %fp1,%fp2 # TB8
5162
5163 eor.l %d1,X(%a6) # X IS NOW S'= SGN*S
5164 and.l &0x80000000,%d1
5165
5166 fmul.x %fp1,%fp3 # TB7
5167
5168 or.l &0x3F800000,%d1 # D0 IS SGN IN SINGLE
5169 mov.l %d1,POSNEG1(%a6)
5170
5171 fadd.d COSB6(%pc),%fp2 # B6+TB8
5172 fadd.d COSB5(%pc),%fp3 # B5+TB7
5173
5174 fmul.x %fp1,%fp2 # T(B6+TB8)
5175 fmul.x %fp1,%fp3 # T(B5+TB7)
5176
5177 fadd.d COSB4(%pc),%fp2 # B4+T(B6+TB8)
5178 fadd.x COSB3(%pc),%fp3 # B3+T(B5+TB7)
5179
5180 fmul.x %fp1,%fp2 # T(B4+T(B6+TB8))
5181 fmul.x %fp3,%fp1 # T(B3+T(B5+TB7))
5182
5183 fadd.x COSB2(%pc),%fp2 # B2+T(B4+T(B6+TB8))
5184 fadd.s COSB1(%pc),%fp1 # B1+T(B3+T(B5+TB7))
5185
5186 fmul.x %fp2,%fp0 # S(B2+T(B4+T(B6+TB8)))
5187
5188 fadd.x %fp1,%fp0
5189
5190 fmul.x X(%a6),%fp0
5191
5192 fmovm.x (%sp)+,&0x30 # restore fp2/fp3
5193
5194 fmov.l %d0,%fpcr # restore users round mode,prec
5195 fadd.s POSNEG1(%a6),%fp0 # last inst - possible exception set
5196 bra t_inx2
5197
5198 ##############################################
5199
5200 # SINe: Big OR Small?
5201 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5202 #--IF |X| < 2**(-40), RETURN X OR 1.
5203 SINBORS:
5204 cmp.l %d1,&0x3FFF8000
5205 bgt.l SREDUCEX
5206
5207 SINSM:
5208 mov.l ADJN(%a6),%d1
5209 cmp.l %d1,&0
5210 bgt.b COSTINY
5211
5212 # here, the operation may underflow iff the precision is sgl or dbl.
5213 # extended denorms are handled through another entry point.
5214 SINTINY:
5215 # mov.w &0x0000,XDCARE(%a6) # JUST IN CASE
5216
5217 fmov.l %d0,%fpcr # restore users round mode,prec
5218 mov.b &FMOV_OP,%d1 # last inst is MOVE
5219 fmov.x X(%a6),%fp0 # last inst - possible exception set
5220 bra t_catch
5221
5222 COSTINY:
5223 fmov.s &0x3F800000,%fp0 # fp0 = 1.0
5224 fmov.l %d0,%fpcr # restore users round mode,prec
5225 fadd.s &0x80800000,%fp0 # last inst - possible exception set
5226 bra t_pinx2
5227
5228 ################################################
5229 global ssind
5230 #--SIN(X) = X FOR DENORMALIZED X
5231 ssind:
5232 bra t_extdnrm
5233
5234 ############################################
5235 global scosd
5236 #--COS(X) = 1 FOR DENORMALIZED X
5237 scosd:
5238 fmov.s &0x3F800000,%fp0 # fp0 = 1.0
5239 bra t_pinx2
5240
5241 ##################################################
5242
5243 global ssincos
5244 ssincos:
5245 #--SET ADJN TO 4
5246 mov.l &4,ADJN(%a6)
5247
5248 fmov.x (%a0),%fp0 # LOAD INPUT
5249 fmov.x %fp0,X(%a6)
5250
5251 mov.l (%a0),%d1
5252 mov.w 4(%a0),%d1
5253 and.l &0x7FFFFFFF,%d1 # COMPACTIFY X
5254
5255 cmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)?
5256 bge.b SCOK1
5257 bra.w SCSM
5258
5259 SCOK1:
5260 cmp.l %d1,&0x4004BC7E # |X| < 15 PI?
5261 blt.b SCMAIN
5262 bra.w SREDUCEX
5263
5264
5265 #--THIS IS THE USUAL CASE, |X| <= 15 PI.
5266 #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5267 SCMAIN:
5268 fmov.x %fp0,%fp1
5269
5270 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5271
5272 lea PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32
5273
5274 fmov.l %fp1,INT(%a6) # CONVERT TO INTEGER
5275
5276 mov.l INT(%a6),%d1
5277 asl.l &4,%d1
5278 add.l %d1,%a1 # ADDRESS OF N*PIBY2, IN Y1, Y2
5279
5280 fsub.x (%a1)+,%fp0 # X-Y1
5281 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2
5282
5283 SCCONT:
5284 #--continuation point from REDUCEX
5285
5286 mov.l INT(%a6),%d1
5287 ror.l &1,%d1
5288 cmp.l %d1,&0 # D0 < 0 IFF N IS ODD
5289 bge.w NEVEN
5290
5291 SNODD:
5292 #--REGISTERS SAVED SO FAR: D0, A0, FP2.
5293 fmovm.x &0x04,-(%sp) # save fp2
5294
5295 fmov.x %fp0,RPRIME(%a6)
5296 fmul.x %fp0,%fp0 # FP0 IS S = R*R
5297 fmov.d SINA7(%pc),%fp1 # A7
5298 fmov.d COSB8(%pc),%fp2 # B8
5299 fmul.x %fp0,%fp1 # SA7
5300 fmul.x %fp0,%fp2 # SB8
5301
5302 mov.l %d2,-(%sp)
5303 mov.l %d1,%d2
5304 ror.l &1,%d2
5305 and.l &0x80000000,%d2
5306 eor.l %d1,%d2
5307 and.l &0x80000000,%d2
5308
5309 fadd.d SINA6(%pc),%fp1 # A6+SA7
5310 fadd.d COSB7(%pc),%fp2 # B7+SB8
5311
5312 fmul.x %fp0,%fp1 # S(A6+SA7)
5313 eor.l %d2,RPRIME(%a6)
5314 mov.l (%sp)+,%d2
5315 fmul.x %fp0,%fp2 # S(B7+SB8)
5316 ror.l &1,%d1
5317 and.l &0x80000000,%d1
5318 mov.l &0x3F800000,POSNEG1(%a6)
5319 eor.l %d1,POSNEG1(%a6)
5320
5321 fadd.d SINA5(%pc),%fp1 # A5+S(A6+SA7)
5322 fadd.d COSB6(%pc),%fp2 # B6+S(B7+SB8)
5323
5324 fmul.x %fp0,%fp1 # S(A5+S(A6+SA7))
5325 fmul.x %fp0,%fp2 # S(B6+S(B7+SB8))
5326 fmov.x %fp0,SPRIME(%a6)
5327
5328 fadd.d SINA4(%pc),%fp1 # A4+S(A5+S(A6+SA7))
5329 eor.l %d1,SPRIME(%a6)
5330 fadd.d COSB5(%pc),%fp2 # B5+S(B6+S(B7+SB8))
5331
5332 fmul.x %fp0,%fp1 # S(A4+...)
5333 fmul.x %fp0,%fp2 # S(B5+...)
5334
5335 fadd.d SINA3(%pc),%fp1 # A3+S(A4+...)
5336 fadd.d COSB4(%pc),%fp2 # B4+S(B5+...)
5337
5338 fmul.x %fp0,%fp1 # S(A3+...)
5339 fmul.x %fp0,%fp2 # S(B4+...)
5340
5341 fadd.x SINA2(%pc),%fp1 # A2+S(A3+...)
5342 fadd.x COSB3(%pc),%fp2 # B3+S(B4+...)
5343
5344 fmul.x %fp0,%fp1 # S(A2+...)
5345 fmul.x %fp0,%fp2 # S(B3+...)
5346
5347 fadd.x SINA1(%pc),%fp1 # A1+S(A2+...)
5348 fadd.x COSB2(%pc),%fp2 # B2+S(B3+...)
5349
5350 fmul.x %fp0,%fp1 # S(A1+...)
5351 fmul.x %fp2,%fp0 # S(B2+...)
5352
5353 fmul.x RPRIME(%a6),%fp1 # R'S(A1+...)
5354 fadd.s COSB1(%pc),%fp0 # B1+S(B2...)
5355 fmul.x SPRIME(%a6),%fp0 # S'(B1+S(B2+...))
5356
5357 fmovm.x (%sp)+,&0x20 # restore fp2
5358
5359 fmov.l %d0,%fpcr
5360 fadd.x RPRIME(%a6),%fp1 # COS(X)
5361 bsr sto_cos # store cosine result
5362 fadd.s POSNEG1(%a6),%fp0 # SIN(X)
5363 bra t_inx2
5364
5365 NEVEN:
5366 #--REGISTERS SAVED SO FAR: FP2.
5367 fmovm.x &0x04,-(%sp) # save fp2
5368
5369 fmov.x %fp0,RPRIME(%a6)
5370 fmul.x %fp0,%fp0 # FP0 IS S = R*R
5371
5372 fmov.d COSB8(%pc),%fp1 # B8
5373 fmov.d SINA7(%pc),%fp2 # A7
5374
5375 fmul.x %fp0,%fp1 # SB8
5376 fmov.x %fp0,SPRIME(%a6)
5377 fmul.x %fp0,%fp2 # SA7
5378
5379 ror.l &1,%d1
5380 and.l &0x80000000,%d1
5381
5382 fadd.d COSB7(%pc),%fp1 # B7+SB8
5383 fadd.d SINA6(%pc),%fp2 # A6+SA7
5384
5385 eor.l %d1,RPRIME(%a6)
5386 eor.l %d1,SPRIME(%a6)
5387
5388 fmul.x %fp0,%fp1 # S(B7+SB8)
5389
5390 or.l &0x3F800000,%d1
5391 mov.l %d1,POSNEG1(%a6)
5392
5393 fmul.x %fp0,%fp2 # S(A6+SA7)
5394
5395 fadd.d COSB6(%pc),%fp1 # B6+S(B7+SB8)
5396 fadd.d SINA5(%pc),%fp2 # A5+S(A6+SA7)
5397
5398 fmul.x %fp0,%fp1 # S(B6+S(B7+SB8))
5399 fmul.x %fp0,%fp2 # S(A5+S(A6+SA7))
5400
5401 fadd.d COSB5(%pc),%fp1 # B5+S(B6+S(B7+SB8))
5402 fadd.d SINA4(%pc),%fp2 # A4+S(A5+S(A6+SA7))
5403
5404 fmul.x %fp0,%fp1 # S(B5+...)
5405 fmul.x %fp0,%fp2 # S(A4+...)
5406
5407 fadd.d COSB4(%pc),%fp1 # B4+S(B5+...)
5408 fadd.d SINA3(%pc),%fp2 # A3+S(A4+...)
5409
5410 fmul.x %fp0,%fp1 # S(B4+...)
5411 fmul.x %fp0,%fp2 # S(A3+...)
5412
5413 fadd.x COSB3(%pc),%fp1 # B3+S(B4+...)
5414 fadd.x SINA2(%pc),%fp2 # A2+S(A3+...)
5415
5416 fmul.x %fp0,%fp1 # S(B3+...)
5417 fmul.x %fp0,%fp2 # S(A2+...)
5418
5419 fadd.x COSB2(%pc),%fp1 # B2+S(B3+...)
5420 fadd.x SINA1(%pc),%fp2 # A1+S(A2+...)
5421
5422 fmul.x %fp0,%fp1 # S(B2+...)
5423 fmul.x %fp2,%fp0 # s(a1+...)
5424
5425
5426 fadd.s COSB1(%pc),%fp1 # B1+S(B2...)
5427 fmul.x RPRIME(%a6),%fp0 # R'S(A1+...)
5428 fmul.x SPRIME(%a6),%fp1 # S'(B1+S(B2+...))
5429
5430 fmovm.x (%sp)+,&0x20 # restore fp2
5431
5432 fmov.l %d0,%fpcr
5433 fadd.s POSNEG1(%a6),%fp1 # COS(X)
5434 bsr sto_cos # store cosine result
5435 fadd.x RPRIME(%a6),%fp0 # SIN(X)
5436 bra t_inx2
5437
5438 ################################################
5439
5440 SCBORS:
5441 cmp.l %d1,&0x3FFF8000
5442 bgt.w SREDUCEX
5443
5444 ################################################
5445
5446 SCSM:
5447 # mov.w &0x0000,XDCARE(%a6)
5448 fmov.s &0x3F800000,%fp1
5449
5450 fmov.l %d0,%fpcr
5451 fsub.s &0x00800000,%fp1
5452 bsr sto_cos # store cosine result
5453 fmov.l %fpcr,%d0 # d0 must have fpcr,too
5454 mov.b &FMOV_OP,%d1 # last inst is MOVE
5455 fmov.x X(%a6),%fp0
5456 bra t_catch
5457
5458 ##############################################
5459
5460 global ssincosd
5461 #--SIN AND COS OF X FOR DENORMALIZED X
5462 ssincosd:
5463 mov.l %d0,-(%sp) # save d0
5464 fmov.s &0x3F800000,%fp1
5465 bsr sto_cos # store cosine result
5466 mov.l (%sp)+,%d0 # restore d0
5467 bra t_extdnrm
5468
5469 ############################################
5470
5471 #--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
5472 #--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
5473 #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
5474 SREDUCEX:
5475 fmovm.x &0x3c,-(%sp) # save {fp2-fp5}
5476 mov.l %d2,-(%sp) # save d2
5477 fmov.s &0x00000000,%fp1 # fp1 = 0
5478
5479 #--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
5480 #--there is a danger of unwanted overflow in first LOOP iteration. In this
5481 #--case, reduce argument by one remainder step to make subsequent reduction
5482 #--safe.
5483 cmp.l %d1,&0x7ffeffff # is arg dangerously large?
5484 bne.b SLOOP # no
5485
5486 # yes; create 2**16383*PI/2
5487 mov.w &0x7ffe,FP_SCR0_EX(%a6)
5488 mov.l &0xc90fdaa2,FP_SCR0_HI(%a6)
5489 clr.l FP_SCR0_LO(%a6)
5490
5491 # create low half of 2**16383*PI/2 at FP_SCR1
5492 mov.w &0x7fdc,FP_SCR1_EX(%a6)
5493 mov.l &0x85a308d3,FP_SCR1_HI(%a6)
5494 clr.l FP_SCR1_LO(%a6)
5495
5496 ftest.x %fp0 # test sign of argument
5497 fblt.w sred_neg
5498
5499 or.b &0x80,FP_SCR0_EX(%a6) # positive arg
5500 or.b &0x80,FP_SCR1_EX(%a6)
5501 sred_neg:
5502 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact
5503 fmov.x %fp0,%fp1 # save high result in fp1
5504 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction
5505 fsub.x %fp0,%fp1 # determine low component of result
5506 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.
5507
5508 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5509 #--integer quotient will be stored in N
5510 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5511 SLOOP:
5512 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2
5513 mov.w INARG(%a6),%d1
5514 mov.l %d1,%a1 # save a copy of D0
5515 and.l &0x00007FFF,%d1
5516 sub.l &0x00003FFF,%d1 # d0 = K
5517 cmp.l %d1,&28
5518 ble.b SLASTLOOP
5519 SCONTLOOP:
5520 sub.l &27,%d1 # d0 = L := K-27
5521 mov.b &0,ENDFLAG(%a6)
5522 bra.b SWORK
5523 SLASTLOOP:
5524 clr.l %d1 # d0 = L := 0
5525 mov.b &1,ENDFLAG(%a6)
5526
5527 SWORK:
5528 #--FIND THE REMAINDER OF (R,r) W.R.T. 2**L * (PI/2). L IS SO CHOSEN
5529 #--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.
5530
5531 #--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
5532 #--2**L * (PIby2_1), 2**L * (PIby2_2)
5533
5534 mov.l &0x00003FFE,%d2 # BIASED EXP OF 2/PI
5535 sub.l %d1,%d2 # BIASED EXP OF 2**(-L)*(2/PI)
5536
5537 mov.l &0xA2F9836E,FP_SCR0_HI(%a6)
5538 mov.l &0x4E44152A,FP_SCR0_LO(%a6)
5539 mov.w %d2,FP_SCR0_EX(%a6) # FP_SCR0 = 2**(-L)*(2/PI)
5540
5541 fmov.x %fp0,%fp2
5542 fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI)
5543
5544 #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5545 #--FLOATING POINT FORMAT, THE TWO FMOVE'S FMOVE.L FP <--> N
5546 #--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
5547 #--(SIGN(INARG)*2**63 + FP2) - SIGN(INARG)*2**63 WILL GIVE
5548 #--US THE DESIRED VALUE IN FLOATING POINT.
5549 mov.l %a1,%d2
5550 swap %d2
5551 and.l &0x80000000,%d2
5552 or.l &0x5F000000,%d2 # d2 = SIGN(INARG)*2**63 IN SGL
5553 mov.l %d2,TWOTO63(%a6)
5554 fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDED
5555 fsub.s TWOTO63(%a6),%fp2 # fp2 = N
5556 # fint.x %fp2
5557
5558 #--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
5559 mov.l %d1,%d2 # d2 = L
5560
5561 add.l &0x00003FFF,%d2 # BIASED EXP OF 2**L * (PI/2)
5562 mov.w %d2,FP_SCR0_EX(%a6)
5563 mov.l &0xC90FDAA2,FP_SCR0_HI(%a6)
5564 clr.l FP_SCR0_LO(%a6) # FP_SCR0 = 2**(L) * Piby2_1
5565
5566 add.l &0x00003FDD,%d1
5567 mov.w %d1,FP_SCR1_EX(%a6)
5568 mov.l &0x85A308D3,FP_SCR1_HI(%a6)
5569 clr.l FP_SCR1_LO(%a6) # FP_SCR1 = 2**(L) * Piby2_2
5570
5571 mov.b ENDFLAG(%a6),%d1
5572
5573 #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
5574 #--P2 = 2**(L) * Piby2_2
5575 fmov.x %fp2,%fp4 # fp4 = N
5576 fmul.x FP_SCR0(%a6),%fp4 # fp4 = W = N*P1
5577 fmov.x %fp2,%fp5 # fp5 = N
5578 fmul.x FP_SCR1(%a6),%fp5 # fp5 = w = N*P2
5579 fmov.x %fp4,%fp3 # fp3 = W = N*P1
5580
5581 #--we want P+p = W+w but |p| <= half ulp of P
5582 #--Then, we need to compute A := R-P and a := r-p
5583 fadd.x %fp5,%fp3 # fp3 = P
5584 fsub.x %fp3,%fp4 # fp4 = W-P
5585
5586 fsub.x %fp3,%fp0 # fp0 = A := R - P
5587 fadd.x %fp5,%fp4 # fp4 = p = (W-P)+w
5588
5589 fmov.x %fp0,%fp3 # fp3 = A
5590 fsub.x %fp4,%fp1 # fp1 = a := r - p
5591
5592 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but
5593 #--|r| <= half ulp of R.
5594 fadd.x %fp1,%fp0 # fp0 = R := A+a
5595 #--No need to calculate r if this is the last loop
5596 cmp.b %d1,&0
5597 bgt.w SRESTORE
5598
5599 #--Need to calculate r
5600 fsub.x %fp0,%fp3 # fp3 = A-R
5601 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a
5602 bra.w SLOOP
5603
5604 SRESTORE:
5605 fmov.l %fp2,INT(%a6)
5606 mov.l (%sp)+,%d2 # restore d2
5607 fmovm.x (%sp)+,&0x3c # restore {fp2-fp5}
5608
5609 mov.l ADJN(%a6),%d1
5610 cmp.l %d1,&4
5611
5612 blt.w SINCONT
5613 bra.w SCCONT
5614
5615 #########################################################################
5616 # stan(): computes the tangent of a normalized input #
5617 # stand(): computes the tangent of a denormalized input #
5618 # #
5619 # INPUT *************************************************************** #
5620 # a0 = pointer to extended precision input #
5621 # d0 = round precision,mode #
5622 # #
5623 # OUTPUT ************************************************************** #
5624 # fp0 = tan(X) #
5625 # #
5626 # ACCURACY and MONOTONICITY ******************************************* #
5627 # The returned result is within 3 ulp in 64 significant bit, i.e. #
5628 # within 0.5001 ulp to 53 bits if the result is subsequently #
5629 # rounded to double precision. The result is provably monotonic #
5630 # in double precision. #
5631 # #
5632 # ALGORITHM *********************************************************** #
5633 # #
5634 # 1. If |X| >= 15Pi or |X| < 2**(-40), go to 6. #
5635 # #
5636 # 2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let #
5637 # k = N mod 2, so in particular, k = 0 or 1. #
5638 # #
5639 # 3. If k is odd, go to 5. #
5640 # #
5641 # 4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a #
5642 # rational function U/V where #
5643 # U = r + r*s*(P1 + s*(P2 + s*P3)), and #
5644 # V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r. #
5645 # Exit. #
5646 # #
5647 # 4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by #
5648 # a rational function U/V where #
5649 # U = r + r*s*(P1 + s*(P2 + s*P3)), and #
5650 # V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r, #
5651 # -Cot(r) = -V/U. Exit. #
5652 # #
5653 # 6. If |X| > 1, go to 8. #
5654 # #
5655 # 7. (|X|<2**(-40)) Tan(X) = X. Exit. #
5656 # #
5657 # 8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back #
5658 # to 2. #
5659 # #
5660 #########################################################################
5661
5662 TANQ4:
5663 long 0x3EA0B759,0xF50F8688
5664 TANP3:
5665 long 0xBEF2BAA5,0xA8924F04
5666
5667 TANQ3:
5668 long 0xBF346F59,0xB39BA65F,0x00000000,0x00000000
5669
5670 TANP2:
5671 long 0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000
5672
5673 TANQ2:
5674 long 0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000
5675
5676 TANP1:
5677 long 0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000
5678
5679 TANQ1:
5680 long 0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000
5681
5682 INVTWOPI:
5683 long 0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000
5684
5685 TWOPI1:
5686 long 0x40010000,0xC90FDAA2,0x00000000,0x00000000
5687 TWOPI2:
5688 long 0x3FDF0000,0x85A308D4,0x00000000,0x00000000
5689
5690 #--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING
5691 #--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT
5692 #--MOST 69 BITS LONG.
5693 # global PITBL
5694 PITBL:
5695 long 0xC0040000,0xC90FDAA2,0x2168C235,0x21800000
5696 long 0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000
5697 long 0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000
5698 long 0xC0040000,0xB6365E22,0xEE46F000,0x21480000
5699 long 0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000
5700 long 0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000
5701 long 0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000
5702 long 0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000
5703 long 0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000
5704 long 0xC0040000,0x90836524,0x88034B96,0x20B00000
5705 long 0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000
5706 long 0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000
5707 long 0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000
5708 long 0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000
5709 long 0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000
5710 long 0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000
5711 long 0xC0030000,0xC90FDAA2,0x2168C235,0x21000000
5712 long 0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000
5713 long 0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000
5714 long 0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000
5715 long 0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000
5716 long 0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000
5717 long 0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000
5718 long 0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000
5719 long 0xC0020000,0xC90FDAA2,0x2168C235,0x20800000
5720 long 0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000
5721 long 0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000
5722 long 0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000
5723 long 0xC0010000,0xC90FDAA2,0x2168C235,0x20000000
5724 long 0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000
5725 long 0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000
5726 long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000
5727 long 0x00000000,0x00000000,0x00000000,0x00000000
5728 long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000
5729 long 0x40000000,0xC90FDAA2,0x2168C235,0x9F800000
5730 long 0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000
5731 long 0x40010000,0xC90FDAA2,0x2168C235,0xA0000000
5732 long 0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000
5733 long 0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000
5734 long 0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000
5735 long 0x40020000,0xC90FDAA2,0x2168C235,0xA0800000
5736 long 0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000
5737 long 0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000
5738 long 0x40030000,0x8A3AE64F,0x76F80584,0x21080000
5739 long 0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000
5740 long 0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000
5741 long 0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000
5742 long 0x40030000,0xBC7EDCF7,0xFF523611,0x21680000
5743 long 0x40030000,0xC90FDAA2,0x2168C235,0xA1000000
5744 long 0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000
5745 long 0x40030000,0xE231D5F6,0x6595DA7B,0x21300000
5746 long 0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000
5747 long 0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000
5748 long 0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000
5749 long 0x40040000,0x8A3AE64F,0x76F80584,0x21880000
5750 long 0x40040000,0x90836524,0x88034B96,0xA0B00000
5751 long 0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000
5752 long 0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000
5753 long 0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000
5754 long 0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000
5755 long 0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000
5756 long 0x40040000,0xB6365E22,0xEE46F000,0xA1480000
5757 long 0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000
5758 long 0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000
5759 long 0x40040000,0xC90FDAA2,0x2168C235,0xA1800000
5760
5761 set INARG,FP_SCR0
5762
5763 set TWOTO63,L_SCR1
5764 set INT,L_SCR1
5765 set ENDFLAG,L_SCR2
5766
5767 global stan
5768 stan:
5769 fmov.x (%a0),%fp0 # LOAD INPUT
5770
5771 mov.l (%a0),%d1
5772 mov.w 4(%a0),%d1
5773 and.l &0x7FFFFFFF,%d1
5774
5775 cmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)?
5776 bge.b TANOK1
5777 bra.w TANSM
5778 TANOK1:
5779 cmp.l %d1,&0x4004BC7E # |X| < 15 PI?
5780 blt.b TANMAIN
5781 bra.w REDUCEX
5782
5783 TANMAIN:
5784 #--THIS IS THE USUAL CASE, |X| <= 15 PI.
5785 #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5786 fmov.x %fp0,%fp1
5787 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI
5788
5789 lea.l PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32
5790
5791 fmov.l %fp1,%d1 # CONVERT TO INTEGER
5792
5793 asl.l &4,%d1
5794 add.l %d1,%a1 # ADDRESS N*PIBY2 IN Y1, Y2
5795
5796 fsub.x (%a1)+,%fp0 # X-Y1
5797
5798 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2
5799
5800 ror.l &5,%d1
5801 and.l &0x80000000,%d1 # D0 WAS ODD IFF D0 < 0
5802
5803 TANCONT:
5804 fmovm.x &0x0c,-(%sp) # save fp2,fp3
5805
5806 cmp.l %d1,&0
5807 blt.w NODD
5808
5809 fmov.x %fp0,%fp1
5810 fmul.x %fp1,%fp1 # S = R*R
5811
5812 fmov.d TANQ4(%pc),%fp3
5813 fmov.d TANP3(%pc),%fp2
5814
5815 fmul.x %fp1,%fp3 # SQ4
5816 fmul.x %fp1,%fp2 # SP3
5817
5818 fadd.d TANQ3(%pc),%fp3 # Q3+SQ4
5819 fadd.x TANP2(%pc),%fp2 # P2+SP3
5820
5821 fmul.x %fp1,%fp3 # S(Q3+SQ4)
5822 fmul.x %fp1,%fp2 # S(P2+SP3)
5823
5824 fadd.x TANQ2(%pc),%fp3 # Q2+S(Q3+SQ4)
5825 fadd.x TANP1(%pc),%fp2 # P1+S(P2+SP3)
5826
5827 fmul.x %fp1,%fp3 # S(Q2+S(Q3+SQ4))
5828 fmul.x %fp1,%fp2 # S(P1+S(P2+SP3))
5829
5830 fadd.x TANQ1(%pc),%fp3 # Q1+S(Q2+S(Q3+SQ4))
5831 fmul.x %fp0,%fp2 # RS(P1+S(P2+SP3))
5832
5833 fmul.x %fp3,%fp1 # S(Q1+S(Q2+S(Q3+SQ4)))
5834
5835 fadd.x %fp2,%fp0 # R+RS(P1+S(P2+SP3))
5836
5837 fadd.s &0x3F800000,%fp1 # 1+S(Q1+...)
5838
5839 fmovm.x (%sp)+,&0x30 # restore fp2,fp3
5840
5841 fmov.l %d0,%fpcr # restore users round mode,prec
5842 fdiv.x %fp1,%fp0 # last inst - possible exception set
5843 bra t_inx2
5844
5845 NODD:
5846 fmov.x %fp0,%fp1
5847 fmul.x %fp0,%fp0 # S = R*R
5848
5849 fmov.d TANQ4(%pc),%fp3
5850 fmov.d TANP3(%pc),%fp2
5851
5852 fmul.x %fp0,%fp3 # SQ4
5853 fmul.x %fp0,%fp2 # SP3
5854
5855 fadd.d TANQ3(%pc),%fp3 # Q3+SQ4
5856 fadd.x TANP2(%pc),%fp2 # P2+SP3
5857
5858 fmul.x %fp0,%fp3 # S(Q3+SQ4)
5859 fmul.x %fp0,%fp2 # S(P2+SP3)
5860
5861 fadd.x TANQ2(%pc),%fp3 # Q2+S(Q3+SQ4)
5862 fadd.x TANP1(%pc),%fp2 # P1+S(P2+SP3)
5863
5864 fmul.x %fp0,%fp3 # S(Q2+S(Q3+SQ4))
5865 fmul.x %fp0,%fp2 # S(P1+S(P2+SP3))
5866
5867 fadd.x TANQ1(%pc),%fp3 # Q1+S(Q2+S(Q3+SQ4))
5868 fmul.x %fp1,%fp2 # RS(P1+S(P2+SP3))
5869
5870 fmul.x %fp3,%fp0 # S(Q1+S(Q2+S(Q3+SQ4)))
5871
5872 fadd.x %fp2,%fp1 # R+RS(P1+S(P2+SP3))
5873 fadd.s &0x3F800000,%fp0 # 1+S(Q1+...)
5874
5875 fmovm.x (%sp)+,&0x30 # restore fp2,fp3
5876
5877 fmov.x %fp1,-(%sp)
5878 eor.l &0x80000000,(%sp)
5879
5880 fmov.l %d0,%fpcr # restore users round mode,prec
5881 fdiv.x (%sp)+,%fp0 # last inst - possible exception set
5882 bra t_inx2
5883
5884 TANBORS:
5885 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5886 #--IF |X| < 2**(-40), RETURN X OR 1.
5887 cmp.l %d1,&0x3FFF8000
5888 bgt.b REDUCEX
5889
5890 TANSM:
5891 fmov.x %fp0,-(%sp)
5892 fmov.l %d0,%fpcr # restore users round mode,prec
5893 mov.b &FMOV_OP,%d1 # last inst is MOVE
5894 fmov.x (%sp)+,%fp0 # last inst - posibble exception set
5895 bra t_catch
5896
5897 global stand
5898 #--TAN(X) = X FOR DENORMALIZED X
5899 stand:
5900 bra t_extdnrm
5901
5902 #--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
5903 #--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
5904 #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
5905 REDUCEX:
5906 fmovm.x &0x3c,-(%sp) # save {fp2-fp5}
5907 mov.l %d2,-(%sp) # save d2
5908 fmov.s &0x00000000,%fp1 # fp1 = 0
5909
5910 #--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
5911 #--there is a danger of unwanted overflow in first LOOP iteration. In this
5912 #--case, reduce argument by one remainder step to make subsequent reduction
5913 #--safe.
5914 cmp.l %d1,&0x7ffeffff # is arg dangerously large?
5915 bne.b LOOP # no
5916
5917 # yes; create 2**16383*PI/2
5918 mov.w &0x7ffe,FP_SCR0_EX(%a6)
5919 mov.l &0xc90fdaa2,FP_SCR0_HI(%a6)
5920 clr.l FP_SCR0_LO(%a6)
5921
5922 # create low half of 2**16383*PI/2 at FP_SCR1
5923 mov.w &0x7fdc,FP_SCR1_EX(%a6)
5924 mov.l &0x85a308d3,FP_SCR1_HI(%a6)
5925 clr.l FP_SCR1_LO(%a6)
5926
5927 ftest.x %fp0 # test sign of argument
5928 fblt.w red_neg
5929
5930 or.b &0x80,FP_SCR0_EX(%a6) # positive arg
5931 or.b &0x80,FP_SCR1_EX(%a6)
5932 red_neg:
5933 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact
5934 fmov.x %fp0,%fp1 # save high result in fp1
5935 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction
5936 fsub.x %fp0,%fp1 # determine low component of result
5937 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument.
5938
5939 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5940 #--integer quotient will be stored in N
5941 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5942 LOOP:
5943 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2
5944 mov.w INARG(%a6),%d1
5945 mov.l %d1,%a1 # save a copy of D0
5946 and.l &0x00007FFF,%d1
5947 sub.l &0x00003FFF,%d1 # d0 = K
5948 cmp.l %d1,&28
5949 ble.b LASTLOOP
5950 CONTLOOP:
5951 sub.l &27,%d1 # d0 = L := K-27
5952 mov.b &0,ENDFLAG(%a6)
5953 bra.b WORK
5954 LASTLOOP:
5955 clr.l %d1 # d0 = L := 0
5956 mov.b &1,ENDFLAG(%a6)
5957
5958 WORK:
5959 #--FIND THE REMAINDER OF (R,r) W.R.T. 2**L * (PI/2). L IS SO CHOSEN
5960 #--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.
5961
5962 #--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
5963 #--2**L * (PIby2_1), 2**L * (PIby2_2)
5964
5965 mov.l &0x00003FFE,%d2 # BIASED EXP OF 2/PI
5966 sub.l %d1,%d2 # BIASED EXP OF 2**(-L)*(2/PI)
5967
5968 mov.l &0xA2F9836E,FP_SCR0_HI(%a6)
5969 mov.l &0x4E44152A,FP_SCR0_LO(%a6)
5970 mov.w %d2,FP_SCR0_EX(%a6) # FP_SCR0 = 2**(-L)*(2/PI)
5971
5972 fmov.x %fp0,%fp2
5973 fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI)
5974
5975 #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5976 #--FLOATING POINT FORMAT, THE TWO FMOVE'S FMOVE.L FP <--> N
5977 #--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
5978 #--(SIGN(INARG)*2**63 + FP2) - SIGN(INARG)*2**63 WILL GIVE
5979 #--US THE DESIRED VALUE IN FLOATING POINT.
5980 mov.l %a1,%d2
5981 swap %d2
5982 and.l &0x80000000,%d2
5983 or.l &0x5F000000,%d2 # d2 = SIGN(INARG)*2**63 IN SGL
5984 mov.l %d2,TWOTO63(%a6)
5985 fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDED
5986 fsub.s TWOTO63(%a6),%fp2 # fp2 = N
5987 # fintrz.x %fp2,%fp2
5988
5989 #--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
5990 mov.l %d1,%d2 # d2 = L
5991
5992 add.l &0x00003FFF,%d2 # BIASED EXP OF 2**L * (PI/2)
5993 mov.w %d2,FP_SCR0_EX(%a6)
5994 mov.l &0xC90FDAA2,FP_SCR0_HI(%a6)
5995 clr.l FP_SCR0_LO(%a6) # FP_SCR0 = 2**(L) * Piby2_1
5996
5997 add.l &0x00003FDD,%d1
5998 mov.w %d1,FP_SCR1_EX(%a6)
5999 mov.l &0x85A308D3,FP_SCR1_HI(%a6)
6000 clr.l FP_SCR1_LO(%a6) # FP_SCR1 = 2**(L) * Piby2_2
6001
6002 mov.b ENDFLAG(%a6),%d1
6003
6004 #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
6005 #--P2 = 2**(L) * Piby2_2
6006 fmov.x %fp2,%fp4 # fp4 = N
6007 fmul.x FP_SCR0(%a6),%fp4 # fp4 = W = N*P1
6008 fmov.x %fp2,%fp5 # fp5 = N
6009 fmul.x FP_SCR1(%a6),%fp5 # fp5 = w = N*P2
6010 fmov.x %fp4,%fp3 # fp3 = W = N*P1
6011
6012 #--we want P+p = W+w but |p| <= half ulp of P
6013 #--Then, we need to compute A := R-P and a := r-p
6014 fadd.x %fp5,%fp3 # fp3 = P
6015 fsub.x %fp3,%fp4 # fp4 = W-P
6016
6017 fsub.x %fp3,%fp0 # fp0 = A := R - P
6018 fadd.x %fp5,%fp4 # fp4 = p = (W-P)+w
6019
6020 fmov.x %fp0,%fp3 # fp3 = A
6021 fsub.x %fp4,%fp1 # fp1 = a := r - p
6022
6023 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but
6024 #--|r| <= half ulp of R.
6025 fadd.x %fp1,%fp0 # fp0 = R := A+a
6026 #--No need to calculate r if this is the last loop
6027 cmp.b %d1,&0
6028 bgt.w RESTORE
6029
6030 #--Need to calculate r
6031 fsub.x %fp0,%fp3 # fp3 = A-R
6032 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a
6033 bra.w LOOP
6034
6035 RESTORE:
6036 fmov.l %fp2,INT(%a6)
6037 mov.l (%sp)+,%d2 # restore d2
6038 fmovm.x (%sp)+,&0x3c # restore {fp2-fp5}
6039
6040 mov.l INT(%a6),%d1
6041 ror.l &1,%d1
6042
6043 bra.w TANCONT
6044
6045 #########################################################################
6046 # satan(): computes the arctangent of a normalized number #
6047 # satand(): computes the arctangent of a denormalized number #
6048 # #
6049 # INPUT *************************************************************** #
6050 # a0 = pointer to extended precision input #
6051 # d0 = round precision,mode #
6052 # #
6053 # OUTPUT ************************************************************** #
6054 # fp0 = arctan(X) #
6055 # #
6056 # ACCURACY and MONOTONICITY ******************************************* #
6057 # The returned result is within 2 ulps in 64 significant bit, #
6058 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6059 # rounded to double precision. The result is provably monotonic #
6060 # in double precision. #
6061 # #
6062 # ALGORITHM *********************************************************** #
6063 # Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5. #
6064 # #
6065 # Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x. #
6066 # Note that k = -4, -3,..., or 3. #
6067 # Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5 #
6068 # significant bits of X with a bit-1 attached at the 6-th #
6069 # bit position. Define u to be u = (X-F) / (1 + X*F). #
6070 # #
6071 # Step 3. Approximate arctan(u) by a polynomial poly. #
6072 # #
6073 # Step 4. Return arctan(F) + poly, arctan(F) is fetched from a #
6074 # table of values calculated beforehand. Exit. #
6075 # #
6076 # Step 5. If |X| >= 16, go to Step 7. #
6077 # #
6078 # Step 6. Approximate arctan(X) by an odd polynomial in X. Exit. #
6079 # #
6080 # Step 7. Define X' = -1/X. Approximate arctan(X') by an odd #
6081 # polynomial in X'. #
6082 # Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit. #
6083 # #
6084 #########################################################################
6085
6086 ATANA3: long 0xBFF6687E,0x314987D8
6087 ATANA2: long 0x4002AC69,0x34A26DB3
6088 ATANA1: long 0xBFC2476F,0x4E1DA28E
6089
6090 ATANB6: long 0x3FB34444,0x7F876989
6091 ATANB5: long 0xBFB744EE,0x7FAF45DB
6092 ATANB4: long 0x3FBC71C6,0x46940220
6093 ATANB3: long 0xBFC24924,0x921872F9
6094 ATANB2: long 0x3FC99999,0x99998FA9
6095 ATANB1: long 0xBFD55555,0x55555555
6096
6097 ATANC5: long 0xBFB70BF3,0x98539E6A
6098 ATANC4: long 0x3FBC7187,0x962D1D7D
6099 ATANC3: long 0xBFC24924,0x827107B8
6100 ATANC2: long 0x3FC99999,0x9996263E
6101 ATANC1: long 0xBFD55555,0x55555536
6102
6103 PPIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
6104 NPIBY2: long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000
6105
6106 PTINY: long 0x00010000,0x80000000,0x00000000,0x00000000
6107 NTINY: long 0x80010000,0x80000000,0x00000000,0x00000000
6108
6109 ATANTBL:
6110 long 0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000
6111 long 0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000
6112 long 0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000
6113 long 0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000
6114 long 0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000
6115 long 0x3FFB0000,0xAB98E943,0x62765619,0x00000000
6116 long 0x3FFB0000,0xB389E502,0xF9C59862,0x00000000
6117 long 0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000
6118 long 0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000
6119 long 0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000
6120 long 0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000
6121 long 0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000
6122 long 0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000
6123 long 0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000
6124 long 0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000
6125 long 0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000
6126 long 0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000
6127 long 0x3FFC0000,0x8B232A08,0x304282D8,0x00000000
6128 long 0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000
6129 long 0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000
6130 long 0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000
6131 long 0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000
6132 long 0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000
6133 long 0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000
6134 long 0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000
6135 long 0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000
6136 long 0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000
6137 long 0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000
6138 long 0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000
6139 long 0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000
6140 long 0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000
6141 long 0x3FFC0000,0xF7170A28,0xECC06666,0x00000000
6142 long 0x3FFD0000,0x812FD288,0x332DAD32,0x00000000
6143 long 0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000
6144 long 0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000
6145 long 0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000
6146 long 0x3FFD0000,0x9EB68949,0x3889A227,0x00000000
6147 long 0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000
6148 long 0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000
6149 long 0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000
6150 long 0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000
6151 long 0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000
6152 long 0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000
6153 long 0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000
6154 long 0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000
6155 long 0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000
6156 long 0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000
6157 long 0x3FFD0000,0xEA2D764F,0x64315989,0x00000000
6158 long 0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000
6159 long 0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000
6160 long 0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000
6161 long 0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000
6162 long 0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000
6163 long 0x3FFE0000,0x97731420,0x365E538C,0x00000000
6164 long 0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000
6165 long 0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000
6166 long 0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000
6167 long 0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000
6168 long 0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000
6169 long 0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000
6170 long 0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000
6171 long 0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000
6172 long 0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000
6173 long 0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000
6174 long 0x3FFE0000,0xCD000549,0xADEC7159,0x00000000
6175 long 0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000
6176 long 0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000
6177 long 0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000
6178 long 0x3FFE0000,0xE8771129,0xC4353259,0x00000000
6179 long 0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000
6180 long 0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000
6181 long 0x3FFE0000,0xF919039D,0x758B8D41,0x00000000
6182 long 0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000
6183 long 0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000
6184 long 0x3FFF0000,0x83889E35,0x49D108E1,0x00000000
6185 long 0x3FFF0000,0x859CFA76,0x511D724B,0x00000000
6186 long 0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000
6187 long 0x3FFF0000,0x89732FD1,0x9557641B,0x00000000
6188 long 0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000
6189 long 0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000
6190 long 0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000
6191 long 0x3FFF0000,0x922DA7D7,0x91888487,0x00000000
6192 long 0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000
6193 long 0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000
6194 long 0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000
6195 long 0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000
6196 long 0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000
6197 long 0x3FFF0000,0x9F100575,0x006CC571,0x00000000
6198 long 0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000
6199 long 0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000
6200 long 0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000
6201 long 0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000
6202 long 0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000
6203 long 0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000
6204 long 0x3FFF0000,0xA83A5153,0x0956168F,0x00000000
6205 long 0x3FFF0000,0xA93A2007,0x7539546E,0x00000000
6206 long 0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000
6207 long 0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000
6208 long 0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000
6209 long 0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000
6210 long 0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000
6211 long 0x3FFF0000,0xB1846515,0x0F71496A,0x00000000
6212 long 0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000
6213 long 0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000
6214 long 0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000
6215 long 0x3FFF0000,0xB525529D,0x562246BD,0x00000000
6216 long 0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000
6217 long 0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000
6218 long 0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000
6219 long 0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000
6220 long 0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000
6221 long 0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000
6222 long 0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000
6223 long 0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000
6224 long 0x3FFF0000,0xBB471285,0x7637E17D,0x00000000
6225 long 0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000
6226 long 0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000
6227 long 0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000
6228 long 0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000
6229 long 0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000
6230 long 0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000
6231 long 0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000
6232 long 0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000
6233 long 0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000
6234 long 0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000
6235 long 0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000
6236 long 0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000
6237 long 0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000
6238
6239 set X,FP_SCR0
6240 set XDCARE,X+2
6241 set XFRAC,X+4
6242 set XFRACLO,X+8
6243
6244 set ATANF,FP_SCR1
6245 set ATANFHI,ATANF+4
6246 set ATANFLO,ATANF+8
6247
6248 global satan
6249 #--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
6250 satan:
6251 fmov.x (%a0),%fp0 # LOAD INPUT
6252
6253 mov.l (%a0),%d1
6254 mov.w 4(%a0),%d1
6255 fmov.x %fp0,X(%a6)
6256 and.l &0x7FFFFFFF,%d1
6257
6258 cmp.l %d1,&0x3FFB8000 # |X| >= 1/16?
6259 bge.b ATANOK1
6260 bra.w ATANSM
6261
6262 ATANOK1:
6263 cmp.l %d1,&0x4002FFFF # |X| < 16 ?
6264 ble.b ATANMAIN
6265 bra.w ATANBIG
6266
6267 #--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE
6268 #--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ).
6269 #--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN
6270 #--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE
6271 #--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS
6272 #--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR
6273 #--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO
6274 #--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE
6275 #--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL
6276 #--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE
6277 #--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION
6278 #--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION
6279 #--WILL INVOLVE A VERY LONG POLYNOMIAL.
6280
6281 #--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS
6282 #--WE CHOSE F TO BE +-2^K * 1.BBBB1
6283 #--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE
6284 #--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE
6285 #--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS
6286 #-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).
6287
6288 ATANMAIN:
6289
6290 and.l &0xF8000000,XFRAC(%a6) # FIRST 5 BITS
6291 or.l &0x04000000,XFRAC(%a6) # SET 6-TH BIT TO 1
6292 mov.l &0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F
6293
6294 fmov.x %fp0,%fp1 # FP1 IS X
6295 fmul.x X(%a6),%fp1 # FP1 IS X*F, NOTE THAT X*F > 0
6296 fsub.x X(%a6),%fp0 # FP0 IS X-F
6297 fadd.s &0x3F800000,%fp1 # FP1 IS 1 + X*F
6298 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F)
6299
6300 #--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)
6301 #--CREATE ATAN(F) AND STORE IT IN ATANF, AND
6302 #--SAVE REGISTERS FP2.
6303
6304 mov.l %d2,-(%sp) # SAVE d2 TEMPORARILY
6305 mov.l %d1,%d2 # THE EXP AND 16 BITS OF X
6306 and.l &0x00007800,%d1 # 4 VARYING BITS OF F'S FRACTION
6307 and.l &0x7FFF0000,%d2 # EXPONENT OF F
6308 sub.l &0x3FFB0000,%d2 # K+4
6309 asr.l &1,%d2
6310 add.l %d2,%d1 # THE 7 BITS IDENTIFYING F
6311 asr.l &7,%d1 # INDEX INTO TBL OF ATAN(|F|)
6312 lea ATANTBL(%pc),%a1
6313 add.l %d1,%a1 # ADDRESS OF ATAN(|F|)
6314 mov.l (%a1)+,ATANF(%a6)
6315 mov.l (%a1)+,ATANFHI(%a6)
6316 mov.l (%a1)+,ATANFLO(%a6) # ATANF IS NOW ATAN(|F|)
6317 mov.l X(%a6),%d1 # LOAD SIGN AND EXPO. AGAIN
6318 and.l &0x80000000,%d1 # SIGN(F)
6319 or.l %d1,ATANF(%a6) # ATANF IS NOW SIGN(F)*ATAN(|F|)
6320 mov.l (%sp)+,%d2 # RESTORE d2
6321
6322 #--THAT'S ALL I HAVE TO DO FOR NOW,
6323 #--BUT ALAS, THE DIVIDE IS STILL CRANKING!
6324
6325 #--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
6326 #--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U
6327 #--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.
6328 #--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3))
6329 #--WHAT WE HAVE HERE IS MERELY A1 = A3, A2 = A1/A3, A3 = A2/A3.
6330 #--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT
6331 #--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCED
6332
6333 fmovm.x &0x04,-(%sp) # save fp2
6334
6335 fmov.x %fp0,%fp1
6336 fmul.x %fp1,%fp1
6337 fmov.d ATANA3(%pc),%fp2
6338 fadd.x %fp1,%fp2 # A3+V
6339 fmul.x %fp1,%fp2 # V*(A3+V)
6340 fmul.x %fp0,%fp1 # U*V
6341 fadd.d ATANA2(%pc),%fp2 # A2+V*(A3+V)
6342 fmul.d ATANA1(%pc),%fp1 # A1*U*V
6343 fmul.x %fp2,%fp1 # A1*U*V*(A2+V*(A3+V))
6344 fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASED
6345
6346 fmovm.x (%sp)+,&0x20 # restore fp2
6347
6348 fmov.l %d0,%fpcr # restore users rnd mode,prec
6349 fadd.x ATANF(%a6),%fp0 # ATAN(X)
6350 bra t_inx2
6351
6352 ATANBORS:
6353 #--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
6354 #--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
6355 cmp.l %d1,&0x3FFF8000
6356 bgt.w ATANBIG # I.E. |X| >= 16
6357
6358 ATANSM:
6359 #--|X| <= 1/16
6360 #--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
6361 #--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))
6362 #--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )
6363 #--WHERE Y = X*X, AND Z = Y*Y.
6364
6365 cmp.l %d1,&0x3FD78000
6366 blt.w ATANTINY
6367
6368 #--COMPUTE POLYNOMIAL
6369 fmovm.x &0x0c,-(%sp) # save fp2/fp3
6370
6371 fmul.x %fp0,%fp0 # FPO IS Y = X*X
6372
6373 fmov.x %fp0,%fp1
6374 fmul.x %fp1,%fp1 # FP1 IS Z = Y*Y
6375
6376 fmov.d ATANB6(%pc),%fp2
6377 fmov.d ATANB5(%pc),%fp3
6378
6379 fmul.x %fp1,%fp2 # Z*B6
6380 fmul.x %fp1,%fp3 # Z*B5
6381
6382 fadd.d ATANB4(%pc),%fp2 # B4+Z*B6
6383 fadd.d ATANB3(%pc),%fp3 # B3+Z*B5
6384
6385 fmul.x %fp1,%fp2 # Z*(B4+Z*B6)
6386 fmul.x %fp3,%fp1 # Z*(B3+Z*B5)
6387
6388 fadd.d ATANB2(%pc),%fp2 # B2+Z*(B4+Z*B6)
6389 fadd.d ATANB1(%pc),%fp1 # B1+Z*(B3+Z*B5)
6390
6391 fmul.x %fp0,%fp2 # Y*(B2+Z*(B4+Z*B6))
6392 fmul.x X(%a6),%fp0 # X*Y
6393
6394 fadd.x %fp2,%fp1 # [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]
6395
6396 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
6397
6398 fmovm.x (%sp)+,&0x30 # restore fp2/fp3
6399
6400 fmov.l %d0,%fpcr # restore users rnd mode,prec
6401 fadd.x X(%a6),%fp0
6402 bra t_inx2
6403
6404 ATANTINY:
6405 #--|X| < 2^(-40), ATAN(X) = X
6406
6407 fmov.l %d0,%fpcr # restore users rnd mode,prec
6408 mov.b &FMOV_OP,%d1 # last inst is MOVE
6409 fmov.x X(%a6),%fp0 # last inst - possible exception set
6410
6411 bra t_catch
6412
6413 ATANBIG:
6414 #--IF |X| > 2^(100), RETURN SIGN(X)*(PI/2 - TINY). OTHERWISE,
6415 #--RETURN SIGN(X)*PI/2 + ATAN(-1/X).
6416 cmp.l %d1,&0x40638000
6417 bgt.w ATANHUGE
6418
6419 #--APPROXIMATE ATAN(-1/X) BY
6420 #--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'
6421 #--THIS CAN BE RE-WRITTEN AS
6422 #--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.
6423
6424 fmovm.x &0x0c,-(%sp) # save fp2/fp3
6425
6426 fmov.s &0xBF800000,%fp1 # LOAD -1
6427 fdiv.x %fp0,%fp1 # FP1 IS -1/X
6428
6429 #--DIVIDE IS STILL CRANKING
6430
6431 fmov.x %fp1,%fp0 # FP0 IS X'
6432 fmul.x %fp0,%fp0 # FP0 IS Y = X'*X'
6433 fmov.x %fp1,X(%a6) # X IS REALLY X'
6434
6435 fmov.x %fp0,%fp1
6436 fmul.x %fp1,%fp1 # FP1 IS Z = Y*Y
6437
6438 fmov.d ATANC5(%pc),%fp3
6439 fmov.d ATANC4(%pc),%fp2
6440
6441 fmul.x %fp1,%fp3 # Z*C5
6442 fmul.x %fp1,%fp2 # Z*B4
6443
6444 fadd.d ATANC3(%pc),%fp3 # C3+Z*C5
6445 fadd.d ATANC2(%pc),%fp2 # C2+Z*C4
6446
6447 fmul.x %fp3,%fp1 # Z*(C3+Z*C5), FP3 RELEASED
6448 fmul.x %fp0,%fp2 # Y*(C2+Z*C4)
6449
6450 fadd.d ATANC1(%pc),%fp1 # C1+Z*(C3+Z*C5)
6451 fmul.x X(%a6),%fp0 # X'*Y
6452
6453 fadd.x %fp2,%fp1 # [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]
6454
6455 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)]
6456 # ... +[Y*(B2+Z*(B4+Z*B6))])
6457 fadd.x X(%a6),%fp0
6458
6459 fmovm.x (%sp)+,&0x30 # restore fp2/fp3
6460
6461 fmov.l %d0,%fpcr # restore users rnd mode,prec
6462 tst.b (%a0)
6463 bpl.b pos_big
6464
6465 neg_big:
6466 fadd.x NPIBY2(%pc),%fp0
6467 bra t_minx2
6468
6469 pos_big:
6470 fadd.x PPIBY2(%pc),%fp0
6471 bra t_pinx2
6472
6473 ATANHUGE:
6474 #--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINY
6475 tst.b (%a0)
6476 bpl.b pos_huge
6477
6478 neg_huge:
6479 fmov.x NPIBY2(%pc),%fp0
6480 fmov.l %d0,%fpcr
6481 fadd.x PTINY(%pc),%fp0
6482 bra t_minx2
6483
6484 pos_huge:
6485 fmov.x PPIBY2(%pc),%fp0
6486 fmov.l %d0,%fpcr
6487 fadd.x NTINY(%pc),%fp0
6488 bra t_pinx2
6489
6490 global satand
6491 #--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENT
6492 satand:
6493 bra t_extdnrm
6494
6495 #########################################################################
6496 # sasin(): computes the inverse sine of a normalized input #
6497 # sasind(): computes the inverse sine of a denormalized input #
6498 # #
6499 # INPUT *************************************************************** #
6500 # a0 = pointer to extended precision input #
6501 # d0 = round precision,mode #
6502 # #
6503 # OUTPUT ************************************************************** #
6504 # fp0 = arcsin(X) #
6505 # #
6506 # ACCURACY and MONOTONICITY ******************************************* #
6507 # The returned result is within 3 ulps in 64 significant bit, #
6508 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6509 # rounded to double precision. The result is provably monotonic #
6510 # in double precision. #
6511 # #
6512 # ALGORITHM *********************************************************** #
6513 # #
6514 # ASIN #
6515 # 1. If |X| >= 1, go to 3. #
6516 # #
6517 # 2. (|X| < 1) Calculate asin(X) by #
6518 # z := sqrt( [1-X][1+X] ) #
6519 # asin(X) = atan( x / z ). #
6520 # Exit. #
6521 # #
6522 # 3. If |X| > 1, go to 5. #
6523 # #
6524 # 4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.#
6525 # #
6526 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
6527 # Exit. #
6528 # #
6529 #########################################################################
6530
6531 global sasin
6532 sasin:
6533 fmov.x (%a0),%fp0 # LOAD INPUT
6534
6535 mov.l (%a0),%d1
6536 mov.w 4(%a0),%d1
6537 and.l &0x7FFFFFFF,%d1
6538 cmp.l %d1,&0x3FFF8000
6539 bge.b ASINBIG
6540
6541 # This catch is added here for the '060 QSP. Originally, the call to
6542 # satan() would handle this case by causing the exception which would
6543 # not be caught until gen_except(). Now, with the exceptions being
6544 # detected inside of satan(), the exception would have been handled there
6545 # instead of inside sasin() as expected.
6546 cmp.l %d1,&0x3FD78000
6547 blt.w ASINTINY
6548
6549 #--THIS IS THE USUAL CASE, |X| < 1
6550 #--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )
6551
6552 ASINMAIN:
6553 fmov.s &0x3F800000,%fp1
6554 fsub.x %fp0,%fp1 # 1-X
6555 fmovm.x &0x4,-(%sp) # {fp2}
6556 fmov.s &0x3F800000,%fp2
6557 fadd.x %fp0,%fp2 # 1+X
6558 fmul.x %fp2,%fp1 # (1+X)(1-X)
6559 fmovm.x (%sp)+,&0x20 # {fp2}
6560 fsqrt.x %fp1 # SQRT([1-X][1+X])
6561 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X])
6562 fmovm.x &0x01,-(%sp) # save X/SQRT(...)
6563 lea (%sp),%a0 # pass ptr to X/SQRT(...)
6564 bsr satan
6565 add.l &0xc,%sp # clear X/SQRT(...) from stack
6566 bra t_inx2
6567
6568 ASINBIG:
6569 fabs.x %fp0 # |X|
6570 fcmp.s %fp0,&0x3F800000
6571 fbgt t_operr # cause an operr exception
6572
6573 #--|X| = 1, ASIN(X) = +- PI/2.
6574 ASINONE:
6575 fmov.x PIBY2(%pc),%fp0
6576 mov.l (%a0),%d1
6577 and.l &0x80000000,%d1 # SIGN BIT OF X
6578 or.l &0x3F800000,%d1 # +-1 IN SGL FORMAT
6579 mov.l %d1,-(%sp) # push SIGN(X) IN SGL-FMT
6580 fmov.l %d0,%fpcr
6581 fmul.s (%sp)+,%fp0
6582 bra t_inx2
6583
6584 #--|X| < 2^(-40), ATAN(X) = X
6585 ASINTINY:
6586 fmov.l %d0,%fpcr # restore users rnd mode,prec
6587 mov.b &FMOV_OP,%d1 # last inst is MOVE
6588 fmov.x (%a0),%fp0 # last inst - possible exception
6589 bra t_catch
6590
6591 global sasind
6592 #--ASIN(X) = X FOR DENORMALIZED X
6593 sasind:
6594 bra t_extdnrm
6595
6596 #########################################################################
6597 # sacos(): computes the inverse cosine of a normalized input #
6598 # sacosd(): computes the inverse cosine of a denormalized input #
6599 # #
6600 # INPUT *************************************************************** #
6601 # a0 = pointer to extended precision input #
6602 # d0 = round precision,mode #
6603 # #
6604 # OUTPUT ************************************************************** #
6605 # fp0 = arccos(X) #
6606 # #
6607 # ACCURACY and MONOTONICITY ******************************************* #
6608 # The returned result is within 3 ulps in 64 significant bit, #
6609 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6610 # rounded to double precision. The result is provably monotonic #
6611 # in double precision. #
6612 # #
6613 # ALGORITHM *********************************************************** #
6614 # #
6615 # ACOS #
6616 # 1. If |X| >= 1, go to 3. #
6617 # #
6618 # 2. (|X| < 1) Calculate acos(X) by #
6619 # z := (1-X) / (1+X) #
6620 # acos(X) = 2 * atan( sqrt(z) ). #
6621 # Exit. #
6622 # #
6623 # 3. If |X| > 1, go to 5. #
6624 # #
6625 # 4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit. #
6626 # #
6627 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
6628 # Exit. #
6629 # #
6630 #########################################################################
6631
6632 global sacos
6633 sacos:
6634 fmov.x (%a0),%fp0 # LOAD INPUT
6635
6636 mov.l (%a0),%d1 # pack exp w/ upper 16 fraction
6637 mov.w 4(%a0),%d1
6638 and.l &0x7FFFFFFF,%d1
6639 cmp.l %d1,&0x3FFF8000
6640 bge.b ACOSBIG
6641
6642 #--THIS IS THE USUAL CASE, |X| < 1
6643 #--ACOS(X) = 2 * ATAN( SQRT( (1-X)/(1+X) ) )
6644
6645 ACOSMAIN:
6646 fmov.s &0x3F800000,%fp1
6647 fadd.x %fp0,%fp1 # 1+X
6648 fneg.x %fp0 # -X
6649 fadd.s &0x3F800000,%fp0 # 1-X
6650 fdiv.x %fp1,%fp0 # (1-X)/(1+X)
6651 fsqrt.x %fp0 # SQRT((1-X)/(1+X))
6652 mov.l %d0,-(%sp) # save original users fpcr
6653 clr.l %d0
6654 fmovm.x &0x01,-(%sp) # save SQRT(...) to stack
6655 lea (%sp),%a0 # pass ptr to sqrt
6656 bsr satan # ATAN(SQRT([1-X]/[1+X]))
6657 add.l &0xc,%sp # clear SQRT(...) from stack
6658
6659 fmov.l (%sp)+,%fpcr # restore users round prec,mode
6660 fadd.x %fp0,%fp0 # 2 * ATAN( STUFF )
6661 bra t_pinx2
6662
6663 ACOSBIG:
6664 fabs.x %fp0
6665 fcmp.s %fp0,&0x3F800000
6666 fbgt t_operr # cause an operr exception
6667
6668 #--|X| = 1, ACOS(X) = 0 OR PI
6669 tst.b (%a0) # is X positive or negative?
6670 bpl.b ACOSP1
6671
6672 #--X = -1
6673 #Returns PI and inexact exception
6674 ACOSM1:
6675 fmov.x PI(%pc),%fp0 # load PI
6676 fmov.l %d0,%fpcr # load round mode,prec
6677 fadd.s &0x00800000,%fp0 # add a small value
6678 bra t_pinx2
6679
6680 ACOSP1:
6681 bra ld_pzero # answer is positive zero
6682
6683 global sacosd
6684 #--ACOS(X) = PI/2 FOR DENORMALIZED X
6685 sacosd:
6686 fmov.l %d0,%fpcr # load user's rnd mode/prec
6687 fmov.x PIBY2(%pc),%fp0
6688 bra t_pinx2
6689
6690 #########################################################################
6691 # setox(): computes the exponential for a normalized input #
6692 # setoxd(): computes the exponential for a denormalized input #
6693 # setoxm1(): computes the exponential minus 1 for a normalized input #
6694 # setoxm1d(): computes the exponential minus 1 for a denormalized input #
6695 # #
6696 # INPUT *************************************************************** #
6697 # a0 = pointer to extended precision input #
6698 # d0 = round precision,mode #
6699 # #
6700 # OUTPUT ************************************************************** #
6701 # fp0 = exp(X) or exp(X)-1 #
6702 # #
6703 # ACCURACY and MONOTONICITY ******************************************* #
6704 # The returned result is within 0.85 ulps in 64 significant bit, #
6705 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6706 # rounded to double precision. The result is provably monotonic #
6707 # in double precision. #
6708 # #
6709 # ALGORITHM and IMPLEMENTATION **************************************** #
6710 # #
6711 # setoxd #
6712 # ------ #
6713 # Step 1. Set ans := 1.0 #
6714 # #
6715 # Step 2. Return ans := ans + sign(X)*2^(-126). Exit. #
6716 # Notes: This will always generate one exception -- inexact. #
6717 # #
6718 # #
6719 # setox #
6720 # ----- #
6721 # #
6722 # Step 1. Filter out extreme cases of input argument. #
6723 # 1.1 If |X| >= 2^(-65), go to Step 1.3. #
6724 # 1.2 Go to Step 7. #
6725 # 1.3 If |X| < 16380 log(2), go to Step 2. #
6726 # 1.4 Go to Step 8. #
6727 # Notes: The usual case should take the branches 1.1 -> 1.3 -> 2.#
6728 # To avoid the use of floating-point comparisons, a #
6729 # compact representation of |X| is used. This format is a #
6730 # 32-bit integer, the upper (more significant) 16 bits #
6731 # are the sign and biased exponent field of |X|; the #
6732 # lower 16 bits are the 16 most significant fraction #
6733 # (including the explicit bit) bits of |X|. Consequently, #
6734 # the comparisons in Steps 1.1 and 1.3 can be performed #
6735 # by integer comparison. Note also that the constant #
6736 # 16380 log(2) used in Step 1.3 is also in the compact #
6737 # form. Thus taking the branch to Step 2 guarantees #
6738 # |X| < 16380 log(2). There is no harm to have a small #
6739 # number of cases where |X| is less than, but close to, #
6740 # 16380 log(2) and the branch to Step 9 is taken. #
6741 # #
6742 # Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). #
6743 # 2.1 Set AdjFlag := 0 (indicates the branch 1.3 -> 2 #
6744 # was taken) #
6745 # 2.2 N := round-to-nearest-integer( X * 64/log2 ). #
6746 # 2.3 Calculate J = N mod 64; so J = 0,1,2,..., #
6747 # or 63. #
6748 # 2.4 Calculate M = (N - J)/64; so N = 64M + J. #
6749 # 2.5 Calculate the address of the stored value of #
6750 # 2^(J/64). #
6751 # 2.6 Create the value Scale = 2^M. #
6752 # Notes: The calculation in 2.2 is really performed by #
6753 # Z := X * constant #
6754 # N := round-to-nearest-integer(Z) #
6755 # where #
6756 # constant := single-precision( 64/log 2 ). #
6757 # #
6758 # Using a single-precision constant avoids memory #
6759 # access. Another effect of using a single-precision #
6760 # "constant" is that the calculated value Z is #
6761 # #
6762 # Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24). #
6763 # #
6764 # This error has to be considered later in Steps 3 and 4. #
6765 # #
6766 # Step 3. Calculate X - N*log2/64. #
6767 # 3.1 R := X + N*L1, #
6768 # where L1 := single-precision(-log2/64). #
6769 # 3.2 R := R + N*L2, #
6770 # L2 := extended-precision(-log2/64 - L1).#
6771 # Notes: a) The way L1 and L2 are chosen ensures L1+L2 #
6772 # approximate the value -log2/64 to 88 bits of accuracy. #
6773 # b) N*L1 is exact because N is no longer than 22 bits #
6774 # and L1 is no longer than 24 bits. #
6775 # c) The calculation X+N*L1 is also exact due to #
6776 # cancellation. Thus, R is practically X+N(L1+L2) to full #
6777 # 64 bits. #
6778 # d) It is important to estimate how large can |R| be #
6779 # after Step 3.2. #
6780 # #
6781 # N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24) #
6782 # X*64/log2 (1+eps) = N + f, |f| <= 0.5 #
6783 # X*64/log2 - N = f - eps*X 64/log2 #
6784 # X - N*log2/64 = f*log2/64 - eps*X #
6785 # #
6786 # #
6787 # Now |X| <= 16446 log2, thus #
6788 # #
6789 # |X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64 #
6790 # <= 0.57 log2/64. #
6791 # This bound will be used in Step 4. #
6792 # #
6793 # Step 4. Approximate exp(R)-1 by a polynomial #
6794 # p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5)))) #
6795 # Notes: a) In order to reduce memory access, the coefficients #
6796 # are made as "short" as possible: A1 (which is 1/2), A4 #
6797 # and A5 are single precision; A2 and A3 are double #
6798 # precision. #
6799 # b) Even with the restrictions above, #
6800 # |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062. #
6801 # Note that 0.0062 is slightly bigger than 0.57 log2/64. #
6802 # c) To fully use the pipeline, p is separated into #
6803 # two independent pieces of roughly equal complexities #
6804 # p = [ R + R*S*(A2 + S*A4) ] + #
6805 # [ S*(A1 + S*(A3 + S*A5)) ] #
6806 # where S = R*R. #
6807 # #
6808 # Step 5. Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by #
6809 # ans := T + ( T*p + t) #
6810 # where T and t are the stored values for 2^(J/64). #
6811 # Notes: 2^(J/64) is stored as T and t where T+t approximates #
6812 # 2^(J/64) to roughly 85 bits; T is in extended precision #
6813 # and t is in single precision. Note also that T is #
6814 # rounded to 62 bits so that the last two bits of T are #
6815 # zero. The reason for such a special form is that T-1, #
6816 # T-2, and T-8 will all be exact --- a property that will #
6817 # give much more accurate computation of the function #
6818 # EXPM1. #
6819 # #
6820 # Step 6. Reconstruction of exp(X) #
6821 # exp(X) = 2^M * 2^(J/64) * exp(R). #
6822 # 6.1 If AdjFlag = 0, go to 6.3 #
6823 # 6.2 ans := ans * AdjScale #
6824 # 6.3 Restore the user FPCR #
6825 # 6.4 Return ans := ans * Scale. Exit. #
6826 # Notes: If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R, #
6827 # |M| <= 16380, and Scale = 2^M. Moreover, exp(X) will #
6828 # neither overflow nor underflow. If AdjFlag = 1, that #
6829 # means that #
6830 # X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380. #
6831 # Hence, exp(X) may overflow or underflow or neither. #
6832 # When that is the case, AdjScale = 2^(M1) where M1 is #
6833 # approximately M. Thus 6.2 will never cause #
6834 # over/underflow. Possible exception in 6.4 is overflow #
6835 # or underflow. The inexact exception is not generated in #
6836 # 6.4. Although one can argue that the inexact flag #
6837 # should always be raised, to simulate that exception #
6838 # cost to much than the flag is worth in practical uses. #
6839 # #
6840 # Step 7. Return 1 + X. #
6841 # 7.1 ans := X #
6842 # 7.2 Restore user FPCR. #
6843 # 7.3 Return ans := 1 + ans. Exit #
6844 # Notes: For non-zero X, the inexact exception will always be #
6845 # raised by 7.3. That is the only exception raised by 7.3.#
6846 # Note also that we use the FMOVEM instruction to move X #
6847 # in Step 7.1 to avoid unnecessary trapping. (Although #
6848 # the FMOVEM may not seem relevant since X is normalized, #
6849 # the precaution will be useful in the library version of #
6850 # this code where the separate entry for denormalized #
6851 # inputs will be done away with.) #
6852 # #
6853 # Step 8. Handle exp(X) where |X| >= 16380log2. #
6854 # 8.1 If |X| > 16480 log2, go to Step 9. #
6855 # (mimic 2.2 - 2.6) #
6856 # 8.2 N := round-to-integer( X * 64/log2 ) #
6857 # 8.3 Calculate J = N mod 64, J = 0,1,...,63 #
6858 # 8.4 K := (N-J)/64, M1 := truncate(K/2), M = K-M1, #
6859 # AdjFlag := 1. #
6860 # 8.5 Calculate the address of the stored value #
6861 # 2^(J/64). #
6862 # 8.6 Create the values Scale = 2^M, AdjScale = 2^M1. #
6863 # 8.7 Go to Step 3. #
6864 # Notes: Refer to notes for 2.2 - 2.6. #
6865 # #
6866 # Step 9. Handle exp(X), |X| > 16480 log2. #
6867 # 9.1 If X < 0, go to 9.3 #
6868 # 9.2 ans := Huge, go to 9.4 #
6869 # 9.3 ans := Tiny. #
6870 # 9.4 Restore user FPCR. #
6871 # 9.5 Return ans := ans * ans. Exit. #
6872 # Notes: Exp(X) will surely overflow or underflow, depending on #
6873 # X's sign. "Huge" and "Tiny" are respectively large/tiny #
6874 # extended-precision numbers whose square over/underflow #
6875 # with an inexact result. Thus, 9.5 always raises the #
6876 # inexact together with either overflow or underflow. #
6877 # #
6878 # setoxm1d #
6879 # -------- #
6880 # #
6881 # Step 1. Set ans := 0 #
6882 # #
6883 # Step 2. Return ans := X + ans. Exit. #
6884 # Notes: This will return X with the appropriate rounding #
6885 # precision prescribed by the user FPCR. #
6886 # #
6887 # setoxm1 #
6888 # ------- #
6889 # #
6890 # Step 1. Check |X| #
6891 # 1.1 If |X| >= 1/4, go to Step 1.3. #
6892 # 1.2 Go to Step 7. #
6893 # 1.3 If |X| < 70 log(2), go to Step 2. #
6894 # 1.4 Go to Step 10. #
6895 # Notes: The usual case should take the branches 1.1 -> 1.3 -> 2.#
6896 # However, it is conceivable |X| can be small very often #
6897 # because EXPM1 is intended to evaluate exp(X)-1 #
6898 # accurately when |X| is small. For further details on #
6899 # the comparisons, see the notes on Step 1 of setox. #
6900 # #
6901 # Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). #
6902 # 2.1 N := round-to-nearest-integer( X * 64/log2 ). #
6903 # 2.2 Calculate J = N mod 64; so J = 0,1,2,..., #
6904 # or 63. #
6905 # 2.3 Calculate M = (N - J)/64; so N = 64M + J. #
6906 # 2.4 Calculate the address of the stored value of #
6907 # 2^(J/64). #
6908 # 2.5 Create the values Sc = 2^M and #
6909 # OnebySc := -2^(-M). #
6910 # Notes: See the notes on Step 2 of setox. #
6911 # #
6912 # Step 3. Calculate X - N*log2/64. #
6913 # 3.1 R := X + N*L1, #
6914 # where L1 := single-precision(-log2/64). #
6915 # 3.2 R := R + N*L2, #
6916 # L2 := extended-precision(-log2/64 - L1).#
6917 # Notes: Applying the analysis of Step 3 of setox in this case #
6918 # shows that |R| <= 0.0055 (note that |X| <= 70 log2 in #
6919 # this case). #
6920 # #
6921 # Step 4. Approximate exp(R)-1 by a polynomial #
6922 # p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6))))) #
6923 # Notes: a) In order to reduce memory access, the coefficients #
6924 # are made as "short" as possible: A1 (which is 1/2), A5 #
6925 # and A6 are single precision; A2, A3 and A4 are double #
6926 # precision. #
6927 # b) Even with the restriction above, #
6928 # |p - (exp(R)-1)| < |R| * 2^(-72.7) #
6929 # for all |R| <= 0.0055. #
6930 # c) To fully use the pipeline, p is separated into #
6931 # two independent pieces of roughly equal complexity #
6932 # p = [ R*S*(A2 + S*(A4 + S*A6)) ] + #
6933 # [ R + S*(A1 + S*(A3 + S*A5)) ] #
6934 # where S = R*R. #
6935 # #
6936 # Step 5. Compute 2^(J/64)*p by #
6937 # p := T*p #
6938 # where T and t are the stored values for 2^(J/64). #
6939 # Notes: 2^(J/64) is stored as T and t where T+t approximates #
6940 # 2^(J/64) to roughly 85 bits; T is in extended precision #
6941 # and t is in single precision. Note also that T is #
6942 # rounded to 62 bits so that the last two bits of T are #
6943 # zero. The reason for such a special form is that T-1, #
6944 # T-2, and T-8 will all be exact --- a property that will #
6945 # be exploited in Step 6 below. The total relative error #
6946 # in p is no bigger than 2^(-67.7) compared to the final #
6947 # result. #
6948 # #
6949 # Step 6. Reconstruction of exp(X)-1 #
6950 # exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ). #
6951 # 6.1 If M <= 63, go to Step 6.3. #
6952 # 6.2 ans := T + (p + (t + OnebySc)). Go to 6.6 #
6953 # 6.3 If M >= -3, go to 6.5. #
6954 # 6.4 ans := (T + (p + t)) + OnebySc. Go to 6.6 #
6955 # 6.5 ans := (T + OnebySc) + (p + t). #
6956 # 6.6 Restore user FPCR. #
6957 # 6.7 Return ans := Sc * ans. Exit. #
6958 # Notes: The various arrangements of the expressions give #
6959 # accurate evaluations. #
6960 # #
6961 # Step 7. exp(X)-1 for |X| < 1/4. #
6962 # 7.1 If |X| >= 2^(-65), go to Step 9. #
6963 # 7.2 Go to Step 8. #
6964 # #
6965 # Step 8. Calculate exp(X)-1, |X| < 2^(-65). #
6966 # 8.1 If |X| < 2^(-16312), goto 8.3 #
6967 # 8.2 Restore FPCR; return ans := X - 2^(-16382). #
6968 # Exit. #
6969 # 8.3 X := X * 2^(140). #
6970 # 8.4 Restore FPCR; ans := ans - 2^(-16382). #
6971 # Return ans := ans*2^(140). Exit #
6972 # Notes: The idea is to return "X - tiny" under the user #
6973 # precision and rounding modes. To avoid unnecessary #
6974 # inefficiency, we stay away from denormalized numbers #
6975 # the best we can. For |X| >= 2^(-16312), the #
6976 # straightforward 8.2 generates the inexact exception as #
6977 # the case warrants. #
6978 # #
6979 # Step 9. Calculate exp(X)-1, |X| < 1/4, by a polynomial #
6980 # p = X + X*X*(B1 + X*(B2 + ... + X*B12)) #
6981 # Notes: a) In order to reduce memory access, the coefficients #
6982 # are made as "short" as possible: B1 (which is 1/2), B9 #
6983 # to B12 are single precision; B3 to B8 are double #
6984 # precision; and B2 is double extended. #
6985 # b) Even with the restriction above, #
6986 # |p - (exp(X)-1)| < |X| 2^(-70.6) #
6987 # for all |X| <= 0.251. #
6988 # Note that 0.251 is slightly bigger than 1/4. #
6989 # c) To fully preserve accuracy, the polynomial is #
6990 # computed as #
6991 # X + ( S*B1 + Q ) where S = X*X and #
6992 # Q = X*S*(B2 + X*(B3 + ... + X*B12)) #
6993 # d) To fully use the pipeline, Q is separated into #
6994 # two independent pieces of roughly equal complexity #
6995 # Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] + #
6996 # [ S*S*(B3 + S*(B5 + ... + S*B11)) ] #
6997 # #
6998 # Step 10. Calculate exp(X)-1 for |X| >= 70 log 2. #
6999 # 10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all #
7000 # practical purposes. Therefore, go to Step 1 of setox. #
7001 # 10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical #
7002 # purposes. #
7003 # ans := -1 #
7004 # Restore user FPCR #
7005 # Return ans := ans + 2^(-126). Exit. #
7006 # Notes: 10.2 will always create an inexact and return -1 + tiny #
7007 # in the user rounding precision and mode. #
7008 # #
7009 #########################################################################
7010
7011 L2: long 0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000
7012
7013 EEXPA3: long 0x3FA55555,0x55554CC1
7014 EEXPA2: long 0x3FC55555,0x55554A54
7015
7016 EM1A4: long 0x3F811111,0x11174385
7017 EM1A3: long 0x3FA55555,0x55554F5A
7018
7019 EM1A2: long 0x3FC55555,0x55555555,0x00000000,0x00000000
7020
7021 EM1B8: long 0x3EC71DE3,0xA5774682
7022 EM1B7: long 0x3EFA01A0,0x19D7CB68
7023
7024 EM1B6: long 0x3F2A01A0,0x1A019DF3
7025 EM1B5: long 0x3F56C16C,0x16C170E2
7026
7027 EM1B4: long 0x3F811111,0x11111111
7028 EM1B3: long 0x3FA55555,0x55555555
7029
7030 EM1B2: long 0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB
7031 long 0x00000000
7032
7033 TWO140: long 0x48B00000,0x00000000
7034 TWON140:
7035 long 0x37300000,0x00000000
7036
7037 EEXPTBL:
7038 long 0x3FFF0000,0x80000000,0x00000000,0x00000000
7039 long 0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9B
7040 long 0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9
7041 long 0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369
7042 long 0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95C
7043 long 0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9F
7044 long 0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729
7045 long 0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AF
7046 long 0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCF
7047 long 0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DA
7048 long 0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051
7049 long 0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029
7050 long 0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494
7051 long 0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0
7052 long 0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457D
7053 long 0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537
7054 long 0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DD
7055 long 0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087
7056 long 0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818
7057 long 0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494D
7058 long 0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890
7059 long 0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691C
7060 long 0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05
7061 long 0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126
7062 long 0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140
7063 long 0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DA
7064 long 0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4A
7065 long 0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDC
7066 long 0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAC
7067 long 0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610
7068 long 0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90
7069 long 0x3FFF0000,0xB311C412,0xA9112488,0x201F678A
7070 long 0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13
7071 long 0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30
7072 long 0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CC
7073 long 0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6
7074 long 0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70
7075 long 0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518
7076 long 0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41
7077 long 0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137B
7078 long 0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568
7079 long 0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2E
7080 long 0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03
7081 long 0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907D
7082 long 0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4
7083 long 0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45C
7084 long 0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9
7085 long 0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21
7086 long 0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2F
7087 long 0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439F
7088 long 0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207
7089 long 0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175
7090 long 0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4B
7091 long 0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5
7092 long 0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47A
7093 long 0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22
7094 long 0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945
7095 long 0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5B
7096 long 0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3
7097 long 0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05
7098 long 0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19
7099 long 0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5
7100 long 0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22
7101 long 0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3A
7102
7103 set ADJFLAG,L_SCR2
7104 set SCALE,FP_SCR0
7105 set ADJSCALE,FP_SCR1
7106 set SC,FP_SCR0
7107 set ONEBYSC,FP_SCR1
7108
7109 global setox
7110 setox:
7111 #--entry point for EXP(X), here X is finite, non-zero, and not NaN's
7112
7113 #--Step 1.
7114 mov.l (%a0),%d1 # load part of input X
7115 and.l &0x7FFF0000,%d1 # biased expo. of X
7116 cmp.l %d1,&0x3FBE0000 # 2^(-65)
7117 bge.b EXPC1 # normal case
7118 bra EXPSM
7119
7120 EXPC1:
7121 #--The case |X| >= 2^(-65)
7122 mov.w 4(%a0),%d1 # expo. and partial sig. of |X|
7123 cmp.l %d1,&0x400CB167 # 16380 log2 trunc. 16 bits
7124 blt.b EXPMAIN # normal case
7125 bra EEXPBIG
7126
7127 EXPMAIN:
7128 #--Step 2.
7129 #--This is the normal branch: 2^(-65) <= |X| < 16380 log2.
7130 fmov.x (%a0),%fp0 # load input from (a0)
7131
7132 fmov.x %fp0,%fp1
7133 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X
7134 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}
7135 mov.l &0,ADJFLAG(%a6)
7136 fmov.l %fp0,%d1 # N = int( X * 64/log2 )
7137 lea EEXPTBL(%pc),%a1
7138 fmov.l %d1,%fp0 # convert to floating-format
7139
7140 mov.l %d1,L_SCR1(%a6) # save N temporarily
7141 and.l &0x3F,%d1 # D0 is J = N mod 64
7142 lsl.l &4,%d1
7143 add.l %d1,%a1 # address of 2^(J/64)
7144 mov.l L_SCR1(%a6),%d1
7145 asr.l &6,%d1 # D0 is M
7146 add.w &0x3FFF,%d1 # biased expo. of 2^(M)
7147 mov.w L2(%pc),L_SCR1(%a6) # prefetch L2, no need in CB
7148
7149 EXPCONT1:
7150 #--Step 3.
7151 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7152 #--a0 points to 2^(J/64), D0 is biased expo. of 2^(M)
7153 fmov.x %fp0,%fp2
7154 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64)
7155 fmul.x L2(%pc),%fp2 # N * L2, L1+L2 = -log2/64
7156 fadd.x %fp1,%fp0 # X + N*L1
7157 fadd.x %fp2,%fp0 # fp0 is R, reduced arg.
7158
7159 #--Step 4.
7160 #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7161 #-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))
7162 #--TO FULLY USE THE PIPELINE, WE COMPUTE S = R*R
7163 #--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))]
7164
7165 fmov.x %fp0,%fp1
7166 fmul.x %fp1,%fp1 # fp1 IS S = R*R
7167
7168 fmov.s &0x3AB60B70,%fp2 # fp2 IS A5
7169
7170 fmul.x %fp1,%fp2 # fp2 IS S*A5
7171 fmov.x %fp1,%fp3
7172 fmul.s &0x3C088895,%fp3 # fp3 IS S*A4
7173
7174 fadd.d EEXPA3(%pc),%fp2 # fp2 IS A3+S*A5
7175 fadd.d EEXPA2(%pc),%fp3 # fp3 IS A2+S*A4
7176
7177 fmul.x %fp1,%fp2 # fp2 IS S*(A3+S*A5)
7178 mov.w %d1,SCALE(%a6) # SCALE is 2^(M) in extended
7179 mov.l &0x80000000,SCALE+4(%a6)
7180 clr.l SCALE+8(%a6)
7181
7182 fmul.x %fp1,%fp3 # fp3 IS S*(A2+S*A4)
7183
7184 fadd.s &0x3F000000,%fp2 # fp2 IS A1+S*(A3+S*A5)
7185 fmul.x %fp0,%fp3 # fp3 IS R*S*(A2+S*A4)
7186
7187 fmul.x %fp1,%fp2 # fp2 IS S*(A1+S*(A3+S*A5))
7188 fadd.x %fp3,%fp0 # fp0 IS R+R*S*(A2+S*A4),
7189
7190 fmov.x (%a1)+,%fp1 # fp1 is lead. pt. of 2^(J/64)
7191 fadd.x %fp2,%fp0 # fp0 is EXP(R) - 1
7192
7193 #--Step 5
7194 #--final reconstruction process
7195 #--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) )
7196
7197 fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1)
7198 fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3}
7199 fadd.s (%a1),%fp0 # accurate 2^(J/64)
7200
7201 fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*...
7202 mov.l ADJFLAG(%a6),%d1
7203
7204 #--Step 6
7205 tst.l %d1
7206 beq.b NORMAL
7207 ADJUST:
7208 fmul.x ADJSCALE(%a6),%fp0
7209 NORMAL:
7210 fmov.l %d0,%fpcr # restore user FPCR
7211 mov.b &FMUL_OP,%d1 # last inst is MUL
7212 fmul.x SCALE(%a6),%fp0 # multiply 2^(M)
7213 bra t_catch
7214
7215 EXPSM:
7216 #--Step 7
7217 fmovm.x (%a0),&0x80 # load X
7218 fmov.l %d0,%fpcr
7219 fadd.s &0x3F800000,%fp0 # 1+X in user mode
7220 bra t_pinx2
7221
7222 EEXPBIG:
7223 #--Step 8
7224 cmp.l %d1,&0x400CB27C # 16480 log2
7225 bgt.b EXP2BIG
7226 #--Steps 8.2 -- 8.6
7227 fmov.x (%a0),%fp0 # load input from (a0)
7228
7229 fmov.x %fp0,%fp1
7230 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X
7231 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}
7232 mov.l &1,ADJFLAG(%a6)
7233 fmov.l %fp0,%d1 # N = int( X * 64/log2 )
7234 lea EEXPTBL(%pc),%a1
7235 fmov.l %d1,%fp0 # convert to floating-format
7236 mov.l %d1,L_SCR1(%a6) # save N temporarily
7237 and.l &0x3F,%d1 # D0 is J = N mod 64
7238 lsl.l &4,%d1
7239 add.l %d1,%a1 # address of 2^(J/64)
7240 mov.l L_SCR1(%a6),%d1
7241 asr.l &6,%d1 # D0 is K
7242 mov.l %d1,L_SCR1(%a6) # save K temporarily
7243 asr.l &1,%d1 # D0 is M1
7244 sub.l %d1,L_SCR1(%a6) # a1 is M
7245 add.w &0x3FFF,%d1 # biased expo. of 2^(M1)
7246 mov.w %d1,ADJSCALE(%a6) # ADJSCALE := 2^(M1)
7247 mov.l &0x80000000,ADJSCALE+4(%a6)
7248 clr.l ADJSCALE+8(%a6)
7249 mov.l L_SCR1(%a6),%d1 # D0 is M
7250 add.w &0x3FFF,%d1 # biased expo. of 2^(M)
7251 bra.w EXPCONT1 # go back to Step 3
7252
7253 EXP2BIG:
7254 #--Step 9
7255 tst.b (%a0) # is X positive or negative?
7256 bmi t_unfl2
7257 bra t_ovfl2
7258
7259 global setoxd
7260 setoxd:
7261 #--entry point for EXP(X), X is denormalized
7262 mov.l (%a0),-(%sp)
7263 andi.l &0x80000000,(%sp)
7264 ori.l &0x00800000,(%sp) # sign(X)*2^(-126)
7265
7266 fmov.s &0x3F800000,%fp0
7267
7268 fmov.l %d0,%fpcr
7269 fadd.s (%sp)+,%fp0
7270 bra t_pinx2
7271
7272 global setoxm1
7273 setoxm1:
7274 #--entry point for EXPM1(X), here X is finite, non-zero, non-NaN
7275
7276 #--Step 1.
7277 #--Step 1.1
7278 mov.l (%a0),%d1 # load part of input X
7279 and.l &0x7FFF0000,%d1 # biased expo. of X
7280 cmp.l %d1,&0x3FFD0000 # 1/4
7281 bge.b EM1CON1 # |X| >= 1/4
7282 bra EM1SM
7283
7284 EM1CON1:
7285 #--Step 1.3
7286 #--The case |X| >= 1/4
7287 mov.w 4(%a0),%d1 # expo. and partial sig. of |X|
7288 cmp.l %d1,&0x4004C215 # 70log2 rounded up to 16 bits
7289 ble.b EM1MAIN # 1/4 <= |X| <= 70log2
7290 bra EM1BIG
7291
7292 EM1MAIN:
7293 #--Step 2.
7294 #--This is the case: 1/4 <= |X| <= 70 log2.
7295 fmov.x (%a0),%fp0 # load input from (a0)
7296
7297 fmov.x %fp0,%fp1
7298 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X
7299 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}
7300 fmov.l %fp0,%d1 # N = int( X * 64/log2 )
7301 lea EEXPTBL(%pc),%a1
7302 fmov.l %d1,%fp0 # convert to floating-format
7303
7304 mov.l %d1,L_SCR1(%a6) # save N temporarily
7305 and.l &0x3F,%d1 # D0 is J = N mod 64
7306 lsl.l &4,%d1
7307 add.l %d1,%a1 # address of 2^(J/64)
7308 mov.l L_SCR1(%a6),%d1
7309 asr.l &6,%d1 # D0 is M
7310 mov.l %d1,L_SCR1(%a6) # save a copy of M
7311
7312 #--Step 3.
7313 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7314 #--a0 points to 2^(J/64), D0 and a1 both contain M
7315 fmov.x %fp0,%fp2
7316 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64)
7317 fmul.x L2(%pc),%fp2 # N * L2, L1+L2 = -log2/64
7318 fadd.x %fp1,%fp0 # X + N*L1
7319 fadd.x %fp2,%fp0 # fp0 is R, reduced arg.
7320 add.w &0x3FFF,%d1 # D0 is biased expo. of 2^M
7321
7322 #--Step 4.
7323 #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7324 #-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6)))))
7325 #--TO FULLY USE THE PIPELINE, WE COMPUTE S = R*R
7326 #--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))]
7327
7328 fmov.x %fp0,%fp1
7329 fmul.x %fp1,%fp1 # fp1 IS S = R*R
7330
7331 fmov.s &0x3950097B,%fp2 # fp2 IS a6
7332
7333 fmul.x %fp1,%fp2 # fp2 IS S*A6
7334 fmov.x %fp1,%fp3
7335 fmul.s &0x3AB60B6A,%fp3 # fp3 IS S*A5
7336
7337 fadd.d EM1A4(%pc),%fp2 # fp2 IS A4+S*A6
7338 fadd.d EM1A3(%pc),%fp3 # fp3 IS A3+S*A5
7339 mov.w %d1,SC(%a6) # SC is 2^(M) in extended
7340 mov.l &0x80000000,SC+4(%a6)
7341 clr.l SC+8(%a6)
7342
7343 fmul.x %fp1,%fp2 # fp2 IS S*(A4+S*A6)
7344 mov.l L_SCR1(%a6),%d1 # D0 is M
7345 neg.w %d1 # D0 is -M
7346 fmul.x %fp1,%fp3 # fp3 IS S*(A3+S*A5)
7347 add.w &0x3FFF,%d1 # biased expo. of 2^(-M)
7348 fadd.d EM1A2(%pc),%fp2 # fp2 IS A2+S*(A4+S*A6)
7349 fadd.s &0x3F000000,%fp3 # fp3 IS A1+S*(A3+S*A5)
7350
7351 fmul.x %fp1,%fp2 # fp2 IS S*(A2+S*(A4+S*A6))
7352 or.w &0x8000,%d1 # signed/expo. of -2^(-M)
7353 mov.w %d1,ONEBYSC(%a6) # OnebySc is -2^(-M)
7354 mov.l &0x80000000,ONEBYSC+4(%a6)
7355 clr.l ONEBYSC+8(%a6)
7356 fmul.x %fp3,%fp1 # fp1 IS S*(A1+S*(A3+S*A5))
7357
7358 fmul.x %fp0,%fp2 # fp2 IS R*S*(A2+S*(A4+S*A6))
7359 fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5))
7360
7361 fadd.x %fp2,%fp0 # fp0 IS EXP(R)-1
7362
7363 fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3}
7364
7365 #--Step 5
7366 #--Compute 2^(J/64)*p
7367
7368 fmul.x (%a1),%fp0 # 2^(J/64)*(Exp(R)-1)
7369
7370 #--Step 6
7371 #--Step 6.1
7372 mov.l L_SCR1(%a6),%d1 # retrieve M
7373 cmp.l %d1,&63
7374 ble.b MLE63
7375 #--Step 6.2 M >= 64
7376 fmov.s 12(%a1),%fp1 # fp1 is t
7377 fadd.x ONEBYSC(%a6),%fp1 # fp1 is t+OnebySc
7378 fadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 released
7379 fadd.x (%a1),%fp0 # T+(p+(t+OnebySc))
7380 bra EM1SCALE
7381 MLE63:
7382 #--Step 6.3 M <= 63
7383 cmp.l %d1,&-3
7384 bge.b MGEN3
7385 MLTN3:
7386 #--Step 6.4 M <= -4
7387 fadd.s 12(%a1),%fp0 # p+t
7388 fadd.x (%a1),%fp0 # T+(p+t)
7389 fadd.x ONEBYSC(%a6),%fp0 # OnebySc + (T+(p+t))
7390 bra EM1SCALE
7391 MGEN3:
7392 #--Step 6.5 -3 <= M <= 63
7393 fmov.x (%a1)+,%fp1 # fp1 is T
7394 fadd.s (%a1),%fp0 # fp0 is p+t
7395 fadd.x ONEBYSC(%a6),%fp1 # fp1 is T+OnebySc
7396 fadd.x %fp1,%fp0 # (T+OnebySc)+(p+t)
7397
7398 EM1SCALE:
7399 #--Step 6.6
7400 fmov.l %d0,%fpcr
7401 fmul.x SC(%a6),%fp0
7402 bra t_inx2
7403
7404 EM1SM:
7405 #--Step 7 |X| < 1/4.
7406 cmp.l %d1,&0x3FBE0000 # 2^(-65)
7407 bge.b EM1POLY
7408
7409 EM1TINY:
7410 #--Step 8 |X| < 2^(-65)
7411 cmp.l %d1,&0x00330000 # 2^(-16312)
7412 blt.b EM12TINY
7413 #--Step 8.2
7414 mov.l &0x80010000,SC(%a6) # SC is -2^(-16382)
7415 mov.l &0x80000000,SC+4(%a6)
7416 clr.l SC+8(%a6)
7417 fmov.x (%a0),%fp0
7418 fmov.l %d0,%fpcr
7419 mov.b &FADD_OP,%d1 # last inst is ADD
7420 fadd.x SC(%a6),%fp0
7421 bra t_catch
7422
7423 EM12TINY:
7424 #--Step 8.3
7425 fmov.x (%a0),%fp0
7426 fmul.d TWO140(%pc),%fp0
7427 mov.l &0x80010000,SC(%a6)
7428 mov.l &0x80000000,SC+4(%a6)
7429 clr.l SC+8(%a6)
7430 fadd.x SC(%a6),%fp0
7431 fmov.l %d0,%fpcr
7432 mov.b &FMUL_OP,%d1 # last inst is MUL
7433 fmul.d TWON140(%pc),%fp0
7434 bra t_catch
7435
7436 EM1POLY:
7437 #--Step 9 exp(X)-1 by a simple polynomial
7438 fmov.x (%a0),%fp0 # fp0 is X
7439 fmul.x %fp0,%fp0 # fp0 is S := X*X
7440 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3}
7441 fmov.s &0x2F30CAA8,%fp1 # fp1 is B12
7442 fmul.x %fp0,%fp1 # fp1 is S*B12
7443 fmov.s &0x310F8290,%fp2 # fp2 is B11
7444 fadd.s &0x32D73220,%fp1 # fp1 is B10+S*B12
7445
7446 fmul.x %fp0,%fp2 # fp2 is S*B11
7447 fmul.x %fp0,%fp1 # fp1 is S*(B10 + ...
7448
7449 fadd.s &0x3493F281,%fp2 # fp2 is B9+S*...
7450 fadd.d EM1B8(%pc),%fp1 # fp1 is B8+S*...
7451
7452 fmul.x %fp0,%fp2 # fp2 is S*(B9+...
7453 fmul.x %fp0,%fp1 # fp1 is S*(B8+...
7454
7455 fadd.d EM1B7(%pc),%fp2 # fp2 is B7+S*...
7456 fadd.d EM1B6(%pc),%fp1 # fp1 is B6+S*...
7457
7458 fmul.x %fp0,%fp2 # fp2 is S*(B7+...
7459 fmul.x %fp0,%fp1 # fp1 is S*(B6+...
7460
7461 fadd.d EM1B5(%pc),%fp2 # fp2 is B5+S*...
7462 fadd.d EM1B4(%pc),%fp1 # fp1 is B4+S*...
7463
7464 fmul.x %fp0,%fp2 # fp2 is S*(B5+...
7465 fmul.x %fp0,%fp1 # fp1 is S*(B4+...
7466
7467 fadd.d EM1B3(%pc),%fp2 # fp2 is B3+S*...
7468 fadd.x EM1B2(%pc),%fp1 # fp1 is B2+S*...
7469
7470 fmul.x %fp0,%fp2 # fp2 is S*(B3+...
7471 fmul.x %fp0,%fp1 # fp1 is S*(B2+...
7472
7473 fmul.x %fp0,%fp2 # fp2 is S*S*(B3+...)
7474 fmul.x (%a0),%fp1 # fp1 is X*S*(B2...
7475
7476 fmul.s &0x3F000000,%fp0 # fp0 is S*B1
7477 fadd.x %fp2,%fp1 # fp1 is Q
7478
7479 fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3}
7480
7481 fadd.x %fp1,%fp0 # fp0 is S*B1+Q
7482
7483 fmov.l %d0,%fpcr
7484 fadd.x (%a0),%fp0
7485 bra t_inx2
7486
7487 EM1BIG:
7488 #--Step 10 |X| > 70 log2
7489 mov.l (%a0),%d1
7490 cmp.l %d1,&0
7491 bgt.w EXPC1
7492 #--Step 10.2
7493 fmov.s &0xBF800000,%fp0 # fp0 is -1
7494 fmov.l %d0,%fpcr
7495 fadd.s &0x00800000,%fp0 # -1 + 2^(-126)
7496 bra t_minx2
7497
7498 global setoxm1d
7499 setoxm1d:
7500 #--entry point for EXPM1(X), here X is denormalized
7501 #--Step 0.
7502 bra t_extdnrm
7503
7504 #########################################################################
7505 # sgetexp(): returns the exponent portion of the input argument. #
7506 # The exponent bias is removed and the exponent value is #
7507 # returned as an extended precision number in fp0. #
7508 # sgetexpd(): handles denormalized numbers. #
7509 # #
7510 # sgetman(): extracts the mantissa of the input argument. The #
7511 # mantissa is converted to an extended precision number w/ #
7512 # an exponent of $3fff and is returned in fp0. The range of #
7513 # the result is [1.0 - 2.0). #
7514 # sgetmand(): handles denormalized numbers. #
7515 # #
7516 # INPUT *************************************************************** #
7517 # a0 = pointer to extended precision input #
7518 # #
7519 # OUTPUT ************************************************************** #
7520 # fp0 = exponent(X) or mantissa(X) #
7521 # #
7522 #########################################################################
7523
7524 global sgetexp
7525 sgetexp:
7526 mov.w SRC_EX(%a0),%d0 # get the exponent
7527 bclr &0xf,%d0 # clear the sign bit
7528 subi.w &0x3fff,%d0 # subtract off the bias
7529 fmov.w %d0,%fp0 # return exp in fp0
7530 blt.b sgetexpn # it's negative
7531 rts
7532
7533 sgetexpn:
7534 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
7535 rts
7536
7537 global sgetexpd
7538 sgetexpd:
7539 bsr.l norm # normalize
7540 neg.w %d0 # new exp = -(shft amt)
7541 subi.w &0x3fff,%d0 # subtract off the bias
7542 fmov.w %d0,%fp0 # return exp in fp0
7543 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
7544 rts
7545
7546 global sgetman
7547 sgetman:
7548 mov.w SRC_EX(%a0),%d0 # get the exp
7549 ori.w &0x7fff,%d0 # clear old exp
7550 bclr &0xe,%d0 # make it the new exp +-3fff
7551
7552 # here, we build the result in a tmp location so as not to disturb the input
7553 mov.l SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp loc
7554 mov.l SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp loc
7555 mov.w %d0,FP_SCR0_EX(%a6) # insert new exponent
7556 fmov.x FP_SCR0(%a6),%fp0 # put new value back in fp0
7557 bmi.b sgetmann # it's negative
7558 rts
7559
7560 sgetmann:
7561 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
7562 rts
7563
7564 #
7565 # For denormalized numbers, shift the mantissa until the j-bit = 1,
7566 # then load the exponent with +/1 $3fff.
7567 #
7568 global sgetmand
7569 sgetmand:
7570 bsr.l norm # normalize exponent
7571 bra.b sgetman
7572
7573 #########################################################################
7574 # scosh(): computes the hyperbolic cosine of a normalized input #
7575 # scoshd(): computes the hyperbolic cosine of a denormalized input #
7576 # #
7577 # INPUT *************************************************************** #
7578 # a0 = pointer to extended precision input #
7579 # d0 = round precision,mode #
7580 # #
7581 # OUTPUT ************************************************************** #
7582 # fp0 = cosh(X) #
7583 # #
7584 # ACCURACY and MONOTONICITY ******************************************* #
7585 # The returned result is within 3 ulps in 64 significant bit, #
7586 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7587 # rounded to double precision. The result is provably monotonic #
7588 # in double precision. #
7589 # #
7590 # ALGORITHM *********************************************************** #
7591 # #
7592 # COSH #
7593 # 1. If |X| > 16380 log2, go to 3. #
7594 # #
7595 # 2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae #
7596 # y = |X|, z = exp(Y), and #
7597 # cosh(X) = (1/2)*( z + 1/z ). #
7598 # Exit. #
7599 # #
7600 # 3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5. #
7601 # #
7602 # 4. (16380 log2 < |X| <= 16480 log2) #
7603 # cosh(X) = sign(X) * exp(|X|)/2. #
7604 # However, invoking exp(|X|) may cause premature #
7605 # overflow. Thus, we calculate sinh(X) as follows: #
7606 # Y := |X| #
7607 # Fact := 2**(16380) #
7608 # Y' := Y - 16381 log2 #
7609 # cosh(X) := Fact * exp(Y'). #
7610 # Exit. #
7611 # #
7612 # 5. (|X| > 16480 log2) sinh(X) must overflow. Return #
7613 # Huge*Huge to generate overflow and an infinity with #
7614 # the appropriate sign. Huge is the largest finite number #
7615 # in extended format. Exit. #
7616 # #
7617 #########################################################################
7618
7619 TWO16380:
7620 long 0x7FFB0000,0x80000000,0x00000000,0x00000000
7621
7622 global scosh
7623 scosh:
7624 fmov.x (%a0),%fp0 # LOAD INPUT
7625
7626 mov.l (%a0),%d1
7627 mov.w 4(%a0),%d1
7628 and.l &0x7FFFFFFF,%d1
7629 cmp.l %d1,&0x400CB167
7630 bgt.b COSHBIG
7631
7632 #--THIS IS THE USUAL CASE, |X| < 16380 LOG2
7633 #--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) )
7634
7635 fabs.x %fp0 # |X|
7636
7637 mov.l %d0,-(%sp)
7638 clr.l %d0
7639 fmovm.x &0x01,-(%sp) # save |X| to stack
7640 lea (%sp),%a0 # pass ptr to |X|
7641 bsr setox # FP0 IS EXP(|X|)
7642 add.l &0xc,%sp # erase |X| from stack
7643 fmul.s &0x3F000000,%fp0 # (1/2)EXP(|X|)
7644 mov.l (%sp)+,%d0
7645
7646 fmov.s &0x3E800000,%fp1 # (1/4)
7647 fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|))
7648
7649 fmov.l %d0,%fpcr
7650 mov.b &FADD_OP,%d1 # last inst is ADD
7651 fadd.x %fp1,%fp0
7652 bra t_catch
7653
7654 COSHBIG:
7655 cmp.l %d1,&0x400CB2B3
7656 bgt.b COSHHUGE
7657
7658 fabs.x %fp0
7659 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD)
7660 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE
7661
7662 mov.l %d0,-(%sp)
7663 clr.l %d0
7664 fmovm.x &0x01,-(%sp) # save fp0 to stack
7665 lea (%sp),%a0 # pass ptr to fp0
7666 bsr setox
7667 add.l &0xc,%sp # clear fp0 from stack
7668 mov.l (%sp)+,%d0
7669
7670 fmov.l %d0,%fpcr
7671 mov.b &FMUL_OP,%d1 # last inst is MUL
7672 fmul.x TWO16380(%pc),%fp0
7673 bra t_catch
7674
7675 COSHHUGE:
7676 bra t_ovfl2
7677
7678 global scoshd
7679 #--COSH(X) = 1 FOR DENORMALIZED X
7680 scoshd:
7681 fmov.s &0x3F800000,%fp0
7682
7683 fmov.l %d0,%fpcr
7684 fadd.s &0x00800000,%fp0
7685 bra t_pinx2
7686
7687 #########################################################################
7688 # ssinh(): computes the hyperbolic sine of a normalized input #
7689 # ssinhd(): computes the hyperbolic sine of a denormalized input #
7690 # #
7691 # INPUT *************************************************************** #
7692 # a0 = pointer to extended precision input #
7693 # d0 = round precision,mode #
7694 # #
7695 # OUTPUT ************************************************************** #
7696 # fp0 = sinh(X) #
7697 # #
7698 # ACCURACY and MONOTONICITY ******************************************* #
7699 # The returned result is within 3 ulps in 64 significant bit, #
7700 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7701 # rounded to double precision. The result is provably monotonic #
7702 # in double precision. #
7703 # #
7704 # ALGORITHM *********************************************************** #
7705 # #
7706 # SINH #
7707 # 1. If |X| > 16380 log2, go to 3. #
7708 # #
7709 # 2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula #
7710 # y = |X|, sgn = sign(X), and z = expm1(Y), #
7711 # sinh(X) = sgn*(1/2)*( z + z/(1+z) ). #
7712 # Exit. #
7713 # #
7714 # 3. If |X| > 16480 log2, go to 5. #
7715 # #
7716 # 4. (16380 log2 < |X| <= 16480 log2) #
7717 # sinh(X) = sign(X) * exp(|X|)/2. #
7718 # However, invoking exp(|X|) may cause premature overflow. #
7719 # Thus, we calculate sinh(X) as follows: #
7720 # Y := |X| #
7721 # sgn := sign(X) #
7722 # sgnFact := sgn * 2**(16380) #
7723 # Y' := Y - 16381 log2 #
7724 # sinh(X) := sgnFact * exp(Y'). #
7725 # Exit. #
7726 # #
7727 # 5. (|X| > 16480 log2) sinh(X) must overflow. Return #
7728 # sign(X)*Huge*Huge to generate overflow and an infinity with #
7729 # the appropriate sign. Huge is the largest finite number in #
7730 # extended format. Exit. #
7731 # #
7732 #########################################################################
7733
7734 global ssinh
7735 ssinh:
7736 fmov.x (%a0),%fp0 # LOAD INPUT
7737
7738 mov.l (%a0),%d1
7739 mov.w 4(%a0),%d1
7740 mov.l %d1,%a1 # save (compacted) operand
7741 and.l &0x7FFFFFFF,%d1
7742 cmp.l %d1,&0x400CB167
7743 bgt.b SINHBIG
7744
7745 #--THIS IS THE USUAL CASE, |X| < 16380 LOG2
7746 #--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) )
7747
7748 fabs.x %fp0 # Y = |X|
7749
7750 movm.l &0x8040,-(%sp) # {a1/d0}
7751 fmovm.x &0x01,-(%sp) # save Y on stack
7752 lea (%sp),%a0 # pass ptr to Y
7753 clr.l %d0
7754 bsr setoxm1 # FP0 IS Z = EXPM1(Y)
7755 add.l &0xc,%sp # clear Y from stack
7756 fmov.l &0,%fpcr
7757 movm.l (%sp)+,&0x0201 # {a1/d0}
7758
7759 fmov.x %fp0,%fp1
7760 fadd.s &0x3F800000,%fp1 # 1+Z
7761 fmov.x %fp0,-(%sp)
7762 fdiv.x %fp1,%fp0 # Z/(1+Z)
7763 mov.l %a1,%d1
7764 and.l &0x80000000,%d1
7765 or.l &0x3F000000,%d1
7766 fadd.x (%sp)+,%fp0
7767 mov.l %d1,-(%sp)
7768
7769 fmov.l %d0,%fpcr
7770 mov.b &FMUL_OP,%d1 # last inst is MUL
7771 fmul.s (%sp)+,%fp0 # last fp inst - possible exceptions set
7772 bra t_catch
7773
7774 SINHBIG:
7775 cmp.l %d1,&0x400CB2B3
7776 bgt t_ovfl
7777 fabs.x %fp0
7778 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD)
7779 mov.l &0,-(%sp)
7780 mov.l &0x80000000,-(%sp)
7781 mov.l %a1,%d1
7782 and.l &0x80000000,%d1
7783 or.l &0x7FFB0000,%d1
7784 mov.l %d1,-(%sp) # EXTENDED FMT
7785 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE
7786
7787 mov.l %d0,-(%sp)
7788 clr.l %d0
7789 fmovm.x &0x01,-(%sp) # save fp0 on stack
7790 lea (%sp),%a0 # pass ptr to fp0
7791 bsr setox
7792 add.l &0xc,%sp # clear fp0 from stack
7793
7794 mov.l (%sp)+,%d0
7795 fmov.l %d0,%fpcr
7796 mov.b &FMUL_OP,%d1 # last inst is MUL
7797 fmul.x (%sp)+,%fp0 # possible exception
7798 bra t_catch
7799
7800 global ssinhd
7801 #--SINH(X) = X FOR DENORMALIZED X
7802 ssinhd:
7803 bra t_extdnrm
7804
7805 #########################################################################
7806 # stanh(): computes the hyperbolic tangent of a normalized input #
7807 # stanhd(): computes the hyperbolic tangent of a denormalized input #
7808 # #
7809 # INPUT *************************************************************** #
7810 # a0 = pointer to extended precision input #
7811 # d0 = round precision,mode #
7812 # #
7813 # OUTPUT ************************************************************** #
7814 # fp0 = tanh(X) #
7815 # #
7816 # ACCURACY and MONOTONICITY ******************************************* #
7817 # The returned result is within 3 ulps in 64 significant bit, #
7818 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7819 # rounded to double precision. The result is provably monotonic #
7820 # in double precision. #
7821 # #
7822 # ALGORITHM *********************************************************** #
7823 # #
7824 # TANH #
7825 # 1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3. #
7826 # #
7827 # 2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by #
7828 # sgn := sign(X), y := 2|X|, z := expm1(Y), and #
7829 # tanh(X) = sgn*( z/(2+z) ). #
7830 # Exit. #
7831 # #
7832 # 3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1, #
7833 # go to 7. #
7834 # #
7835 # 4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6. #
7836 # #
7837 # 5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by #
7838 # sgn := sign(X), y := 2|X|, z := exp(Y), #
7839 # tanh(X) = sgn - [ sgn*2/(1+z) ]. #
7840 # Exit. #
7841 # #
7842 # 6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we #
7843 # calculate Tanh(X) by #
7844 # sgn := sign(X), Tiny := 2**(-126), #
7845 # tanh(X) := sgn - sgn*Tiny. #
7846 # Exit. #
7847 # #
7848 # 7. (|X| < 2**(-40)). Tanh(X) = X. Exit. #
7849 # #
7850 #########################################################################
7851
7852 set X,FP_SCR0
7853 set XFRAC,X+4
7854
7855 set SGN,L_SCR3
7856
7857 set V,FP_SCR0
7858
7859 global stanh
7860 stanh:
7861 fmov.x (%a0),%fp0 # LOAD INPUT
7862
7863 fmov.x %fp0,X(%a6)
7864 mov.l (%a0),%d1
7865 mov.w 4(%a0),%d1
7866 mov.l %d1,X(%a6)
7867 and.l &0x7FFFFFFF,%d1
7868 cmp.l %d1, &0x3fd78000 # is |X| < 2^(-40)?
7869 blt.w TANHBORS # yes
7870 cmp.l %d1, &0x3fffddce # is |X| > (5/2)LOG2?
7871 bgt.w TANHBORS # yes
7872
7873 #--THIS IS THE USUAL CASE
7874 #--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2).
7875
7876 mov.l X(%a6),%d1
7877 mov.l %d1,SGN(%a6)
7878 and.l &0x7FFF0000,%d1
7879 add.l &0x00010000,%d1 # EXPONENT OF 2|X|
7880 mov.l %d1,X(%a6)
7881 and.l &0x80000000,SGN(%a6)
7882 fmov.x X(%a6),%fp0 # FP0 IS Y = 2|X|
7883
7884 mov.l %d0,-(%sp)
7885 clr.l %d0
7886 fmovm.x &0x1,-(%sp) # save Y on stack
7887 lea (%sp),%a0 # pass ptr to Y
7888 bsr setoxm1 # FP0 IS Z = EXPM1(Y)
7889 add.l &0xc,%sp # clear Y from stack
7890 mov.l (%sp)+,%d0
7891
7892 fmov.x %fp0,%fp1
7893 fadd.s &0x40000000,%fp1 # Z+2
7894 mov.l SGN(%a6),%d1
7895 fmov.x %fp1,V(%a6)
7896 eor.l %d1,V(%a6)
7897
7898 fmov.l %d0,%fpcr # restore users round prec,mode
7899 fdiv.x V(%a6),%fp0
7900 bra t_inx2
7901
7902 TANHBORS:
7903 cmp.l %d1,&0x3FFF8000
7904 blt.w TANHSM
7905
7906 cmp.l %d1,&0x40048AA1
7907 bgt.w TANHHUGE
7908
7909 #-- (5/2) LOG2 < |X| < 50 LOG2,
7910 #--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X),
7911 #--TANH(X) = SGN - SGN*2/[EXP(Y)+1].
7912
7913 mov.l X(%a6),%d1
7914 mov.l %d1,SGN(%a6)
7915 and.l &0x7FFF0000,%d1
7916 add.l &0x00010000,%d1 # EXPO OF 2|X|
7917 mov.l %d1,X(%a6) # Y = 2|X|
7918 and.l &0x80000000,SGN(%a6)
7919 mov.l SGN(%a6),%d1
7920 fmov.x X(%a6),%fp0 # Y = 2|X|
7921
7922 mov.l %d0,-(%sp)
7923 clr.l %d0
7924 fmovm.x &0x01,-(%sp) # save Y on stack
7925 lea (%sp),%a0 # pass ptr to Y
7926 bsr setox # FP0 IS EXP(Y)
7927 add.l &0xc,%sp # clear Y from stack
7928 mov.l (%sp)+,%d0
7929 mov.l SGN(%a6),%d1
7930 fadd.s &0x3F800000,%fp0 # EXP(Y)+1
7931
7932 eor.l &0xC0000000,%d1 # -SIGN(X)*2
7933 fmov.s %d1,%fp1 # -SIGN(X)*2 IN SGL FMT
7934 fdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ]
7935
7936 mov.l SGN(%a6),%d1
7937 or.l &0x3F800000,%d1 # SGN
7938 fmov.s %d1,%fp0 # SGN IN SGL FMT
7939
7940 fmov.l %d0,%fpcr # restore users round prec,mode
7941 mov.b &FADD_OP,%d1 # last inst is ADD
7942 fadd.x %fp1,%fp0
7943 bra t_inx2
7944
7945 TANHSM:
7946 fmov.l %d0,%fpcr # restore users round prec,mode
7947 mov.b &FMOV_OP,%d1 # last inst is MOVE
7948 fmov.x X(%a6),%fp0 # last inst - possible exception set
7949 bra t_catch
7950
7951 #---RETURN SGN(X) - SGN(X)EPS
7952 TANHHUGE:
7953 mov.l X(%a6),%d1
7954 and.l &0x80000000,%d1
7955 or.l &0x3F800000,%d1
7956 fmov.s %d1,%fp0
7957 and.l &0x80000000,%d1
7958 eor.l &0x80800000,%d1 # -SIGN(X)*EPS
7959
7960 fmov.l %d0,%fpcr # restore users round prec,mode
7961 fadd.s %d1,%fp0
7962 bra t_inx2
7963
7964 global stanhd
7965 #--TANH(X) = X FOR DENORMALIZED X
7966 stanhd:
7967 bra t_extdnrm
7968
7969 #########################################################################
7970 # slogn(): computes the natural logarithm of a normalized input #
7971 # slognd(): computes the natural logarithm of a denormalized input #
7972 # slognp1(): computes the log(1+X) of a normalized input #
7973 # slognp1d(): computes the log(1+X) of a denormalized input #
7974 # #
7975 # INPUT *************************************************************** #
7976 # a0 = pointer to extended precision input #
7977 # d0 = round precision,mode #
7978 # #
7979 # OUTPUT ************************************************************** #
7980 # fp0 = log(X) or log(1+X) #
7981 # #
7982 # ACCURACY and MONOTONICITY ******************************************* #
7983 # The returned result is within 2 ulps in 64 significant bit, #
7984 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7985 # rounded to double precision. The result is provably monotonic #
7986 # in double precision. #
7987 # #
7988 # ALGORITHM *********************************************************** #
7989 # LOGN: #
7990 # Step 1. If |X-1| < 1/16, approximate log(X) by an odd #
7991 # polynomial in u, where u = 2(X-1)/(X+1). Otherwise, #
7992 # move on to Step 2. #
7993 # #
7994 # Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first #
7995 # seven significant bits of Y plus 2**(-7), i.e. #
7996 # F = 1.xxxxxx1 in base 2 where the six "x" match those #
7997 # of Y. Note that |Y-F| <= 2**(-7). #
7998 # #
7999 # Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a #
8000 # polynomial in u, log(1+u) = poly. #
8001 # #
8002 # Step 4. Reconstruct #
8003 # log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u) #
8004 # by k*log(2) + (log(F) + poly). The values of log(F) are #
8005 # calculated beforehand and stored in the program. #
8006 # #
8007 # lognp1: #
8008 # Step 1: If |X| < 1/16, approximate log(1+X) by an odd #
8009 # polynomial in u where u = 2X/(2+X). Otherwise, move on #
8010 # to Step 2. #
8011 # #
8012 # Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done #
8013 # in Step 2 of the algorithm for LOGN and compute #
8014 # log(1+X) as k*log(2) + log(F) + poly where poly #
8015 # approximates log(1+u), u = (Y-F)/F. #
8016 # #
8017 # Implementation Notes: #
8018 # Note 1. There are 64 different possible values for F, thus 64 #
8019 # log(F)'s need to be tabulated. Moreover, the values of #
8020 # 1/F are also tabulated so that the division in (Y-F)/F #
8021 # can be performed by a multiplication. #
8022 # #
8023 # Note 2. In Step 2 of lognp1, in order to preserved accuracy, #
8024 # the value Y-F has to be calculated carefully when #
8025 # 1/2 <= X < 3/2. #
8026 # #
8027 # Note 3. To fully exploit the pipeline, polynomials are usually #
8028 # separated into two parts evaluated independently before #
8029 # being added up. #
8030 # #
8031 #########################################################################
8032 LOGOF2:
8033 long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
8034
8035 one:
8036 long 0x3F800000
8037 zero:
8038 long 0x00000000
8039 infty:
8040 long 0x7F800000
8041 negone:
8042 long 0xBF800000
8043
8044 LOGA6:
8045 long 0x3FC2499A,0xB5E4040B
8046 LOGA5:
8047 long 0xBFC555B5,0x848CB7DB
8048
8049 LOGA4:
8050 long 0x3FC99999,0x987D8730
8051 LOGA3:
8052 long 0xBFCFFFFF,0xFF6F7E97
8053
8054 LOGA2:
8055 long 0x3FD55555,0x555555A4
8056 LOGA1:
8057 long 0xBFE00000,0x00000008
8058
8059 LOGB5:
8060 long 0x3F175496,0xADD7DAD6
8061 LOGB4:
8062 long 0x3F3C71C2,0xFE80C7E0
8063
8064 LOGB3:
8065 long 0x3F624924,0x928BCCFF
8066 LOGB2:
8067 long 0x3F899999,0x999995EC
8068
8069 LOGB1:
8070 long 0x3FB55555,0x55555555
8071 TWO:
8072 long 0x40000000,0x00000000
8073
8074 LTHOLD:
8075 long 0x3f990000,0x80000000,0x00000000,0x00000000
8076
8077 LOGTBL:
8078 long 0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000
8079 long 0x3FF70000,0xFF015358,0x833C47E2,0x00000000
8080 long 0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000
8081 long 0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000
8082 long 0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000
8083 long 0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000
8084 long 0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000
8085 long 0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000
8086 long 0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000
8087 long 0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000
8088 long 0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000
8089 long 0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000
8090 long 0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000
8091 long 0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000
8092 long 0x3FFE0000,0xE525982A,0xF70C880E,0x00000000
8093 long 0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000
8094 long 0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000
8095 long 0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000
8096 long 0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000
8097 long 0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000
8098 long 0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000
8099 long 0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000
8100 long 0x3FFE0000,0xD901B203,0x6406C80E,0x00000000
8101 long 0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000
8102 long 0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000
8103 long 0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000
8104 long 0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000
8105 long 0x3FFC0000,0xC3FD0329,0x06488481,0x00000000
8106 long 0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000
8107 long 0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000
8108 long 0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000
8109 long 0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000
8110 long 0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000
8111 long 0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000
8112 long 0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000
8113 long 0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000
8114 long 0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000
8115 long 0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000
8116 long 0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000
8117 long 0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000
8118 long 0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000
8119 long 0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000
8120 long 0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000
8121 long 0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000
8122 long 0x3FFE0000,0xBD691047,0x07661AA3,0x00000000
8123 long 0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000
8124 long 0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000
8125 long 0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000
8126 long 0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000
8127 long 0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000
8128 long 0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000
8129 long 0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000
8130 long 0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000
8131 long 0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000
8132 long 0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000
8133 long 0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000
8134 long 0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000
8135 long 0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000
8136 long 0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000
8137 long 0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000
8138 long 0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000
8139 long 0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000
8140 long 0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000
8141 long 0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000
8142 long 0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000
8143 long 0x3FFD0000,0xD2420487,0x2DD85160,0x00000000
8144 long 0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000
8145 long 0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000
8146 long 0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000
8147 long 0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000
8148 long 0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000
8149 long 0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000
8150 long 0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000
8151 long 0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000
8152 long 0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000
8153 long 0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000
8154 long 0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000
8155 long 0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000
8156 long 0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000
8157 long 0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000
8158 long 0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000
8159 long 0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000
8160 long 0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000
8161 long 0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000
8162 long 0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000
8163 long 0x3FFE0000,0x825EFCED,0x49369330,0x00000000
8164 long 0x3FFE0000,0x9868C809,0x868C8098,0x00000000
8165 long 0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000
8166 long 0x3FFE0000,0x97012E02,0x5C04B809,0x00000000
8167 long 0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000
8168 long 0x3FFE0000,0x95A02568,0x095A0257,0x00000000
8169 long 0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000
8170 long 0x3FFE0000,0x94458094,0x45809446,0x00000000
8171 long 0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000
8172 long 0x3FFE0000,0x92F11384,0x0497889C,0x00000000
8173 long 0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000
8174 long 0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000
8175 long 0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000
8176 long 0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000
8177 long 0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000
8178 long 0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000
8179 long 0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000
8180 long 0x3FFE0000,0x8DDA5202,0x37694809,0x00000000
8181 long 0x3FFE0000,0x9723A1B7,0x20134203,0x00000000
8182 long 0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000
8183 long 0x3FFE0000,0x995899C8,0x90EB8990,0x00000000
8184 long 0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000
8185 long 0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000
8186 long 0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000
8187 long 0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000
8188 long 0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000
8189 long 0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000
8190 long 0x3FFE0000,0x87F78087,0xF78087F8,0x00000000
8191 long 0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000
8192 long 0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000
8193 long 0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000
8194 long 0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000
8195 long 0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000
8196 long 0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000
8197 long 0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000
8198 long 0x3FFE0000,0x83993052,0x3FBE3368,0x00000000
8199 long 0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000
8200 long 0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000
8201 long 0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000
8202 long 0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000
8203 long 0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000
8204 long 0x3FFE0000,0x80808080,0x80808081,0x00000000
8205 long 0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000
8206
8207 set ADJK,L_SCR1
8208
8209 set X,FP_SCR0
8210 set XDCARE,X+2
8211 set XFRAC,X+4
8212
8213 set F,FP_SCR1
8214 set FFRAC,F+4
8215
8216 set KLOG2,FP_SCR0
8217
8218 set SAVEU,FP_SCR0
8219
8220 global slogn
8221 #--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S
8222 slogn:
8223 fmov.x (%a0),%fp0 # LOAD INPUT
8224 mov.l &0x00000000,ADJK(%a6)
8225
8226 LOGBGN:
8227 #--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
8228 #--A FINITE, NON-ZERO, NORMALIZED NUMBER.
8229
8230 mov.l (%a0),%d1
8231 mov.w 4(%a0),%d1
8232
8233 mov.l (%a0),X(%a6)
8234 mov.l 4(%a0),X+4(%a6)
8235 mov.l 8(%a0),X+8(%a6)
8236
8237 cmp.l %d1,&0 # CHECK IF X IS NEGATIVE
8238 blt.w LOGNEG # LOG OF NEGATIVE ARGUMENT IS INVALID
8239 # X IS POSITIVE, CHECK IF X IS NEAR 1
8240 cmp.l %d1,&0x3ffef07d # IS X < 15/16?
8241 blt.b LOGMAIN # YES
8242 cmp.l %d1,&0x3fff8841 # IS X > 17/16?
8243 ble.w LOGNEAR1 # NO
8244
8245 LOGMAIN:
8246 #--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1
8247
8248 #--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY.
8249 #--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.
8250 #--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y)
8251 #-- = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F).
8252 #--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING
8253 #--LOG(1+U) CAN BE VERY EFFICIENT.
8254 #--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO
8255 #--DIVISION IS NEEDED TO CALCULATE (Y-F)/F.
8256
8257 #--GET K, Y, F, AND ADDRESS OF 1/F.
8258 asr.l &8,%d1
8259 asr.l &8,%d1 # SHIFTED 16 BITS, BIASED EXPO. OF X
8260 sub.l &0x3FFF,%d1 # THIS IS K
8261 add.l ADJK(%a6),%d1 # ADJUST K, ORIGINAL INPUT MAY BE DENORM.
8262 lea LOGTBL(%pc),%a0 # BASE ADDRESS OF 1/F AND LOG(F)
8263 fmov.l %d1,%fp1 # CONVERT K TO FLOATING-POINT FORMAT
8264
8265 #--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F
8266 mov.l &0x3FFF0000,X(%a6) # X IS NOW Y, I.E. 2^(-K)*X
8267 mov.l XFRAC(%a6),FFRAC(%a6)
8268 and.l &0xFE000000,FFRAC(%a6) # FIRST 7 BITS OF Y
8269 or.l &0x01000000,FFRAC(%a6) # GET F: ATTACH A 1 AT THE EIGHTH BIT
8270 mov.l FFRAC(%a6),%d1 # READY TO GET ADDRESS OF 1/F
8271 and.l &0x7E000000,%d1
8272 asr.l &8,%d1
8273 asr.l &8,%d1
8274 asr.l &4,%d1 # SHIFTED 20, D0 IS THE DISPLACEMENT
8275 add.l %d1,%a0 # A0 IS THE ADDRESS FOR 1/F
8276
8277 fmov.x X(%a6),%fp0
8278 mov.l &0x3fff0000,F(%a6)
8279 clr.l F+8(%a6)
8280 fsub.x F(%a6),%fp0 # Y-F
8281 fmovm.x &0xc,-(%sp) # SAVE FP2-3 WHILE FP0 IS NOT READY
8282 #--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
8283 #--REGISTERS SAVED: FPCR, FP1, FP2
8284
8285 LP1CONT1:
8286 #--AN RE-ENTRY POINT FOR LOGNP1
8287 fmul.x (%a0),%fp0 # FP0 IS U = (Y-F)/F
8288 fmul.x LOGOF2(%pc),%fp1 # GET K*LOG2 WHILE FP0 IS NOT READY
8289 fmov.x %fp0,%fp2
8290 fmul.x %fp2,%fp2 # FP2 IS V=U*U
8291 fmov.x %fp1,KLOG2(%a6) # PUT K*LOG2 IN MEMEORY, FREE FP1
8292
8293 #--LOG(1+U) IS APPROXIMATED BY
8294 #--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS
8295 #--[U + V*(A1+V*(A3+V*A5))] + [U*V*(A2+V*(A4+V*A6))]
8296
8297 fmov.x %fp2,%fp3
8298 fmov.x %fp2,%fp1
8299
8300 fmul.d LOGA6(%pc),%fp1 # V*A6
8301 fmul.d LOGA5(%pc),%fp2 # V*A5
8302
8303 fadd.d LOGA4(%pc),%fp1 # A4+V*A6
8304 fadd.d LOGA3(%pc),%fp2 # A3+V*A5
8305
8306 fmul.x %fp3,%fp1 # V*(A4+V*A6)
8307 fmul.x %fp3,%fp2 # V*(A3+V*A5)
8308
8309 fadd.d LOGA2(%pc),%fp1 # A2+V*(A4+V*A6)
8310 fadd.d LOGA1(%pc),%fp2 # A1+V*(A3+V*A5)
8311
8312 fmul.x %fp3,%fp1 # V*(A2+V*(A4+V*A6))
8313 add.l &16,%a0 # ADDRESS OF LOG(F)
8314 fmul.x %fp3,%fp2 # V*(A1+V*(A3+V*A5))
8315
8316 fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6))
8317 fadd.x %fp2,%fp0 # U+V*(A1+V*(A3+V*A5))
8318
8319 fadd.x (%a0),%fp1 # LOG(F)+U*V*(A2+V*(A4+V*A6))
8320 fmovm.x (%sp)+,&0x30 # RESTORE FP2-3
8321 fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U)
8322
8323 fmov.l %d0,%fpcr
8324 fadd.x KLOG2(%a6),%fp0 # FINAL ADD
8325 bra t_inx2
8326
8327
8328 LOGNEAR1:
8329
8330 # if the input is exactly equal to one, then exit through ld_pzero.
8331 # if these 2 lines weren't here, the correct answer would be returned
8332 # but the INEX2 bit would be set.
8333 fcmp.b %fp0,&0x1 # is it equal to one?
8334 fbeq.l ld_pzero # yes
8335
8336 #--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
8337 fmov.x %fp0,%fp1
8338 fsub.s one(%pc),%fp1 # FP1 IS X-1
8339 fadd.s one(%pc),%fp0 # FP0 IS X+1
8340 fadd.x %fp1,%fp1 # FP1 IS 2(X-1)
8341 #--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
8342 #--IN U, U = 2(X-1)/(X+1) = FP1/FP0
8343
8344 LP1CONT2:
8345 #--THIS IS AN RE-ENTRY POINT FOR LOGNP1
8346 fdiv.x %fp0,%fp1 # FP1 IS U
8347 fmovm.x &0xc,-(%sp) # SAVE FP2-3
8348 #--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3
8349 #--LET V=U*U, W=V*V, CALCULATE
8350 #--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY
8351 #--U + U*V*( [B1 + W*(B3 + W*B5)] + [V*(B2 + W*B4)] )
8352 fmov.x %fp1,%fp0
8353 fmul.x %fp0,%fp0 # FP0 IS V
8354 fmov.x %fp1,SAVEU(%a6) # STORE U IN MEMORY, FREE FP1
8355 fmov.x %fp0,%fp1
8356 fmul.x %fp1,%fp1 # FP1 IS W
8357
8358 fmov.d LOGB5(%pc),%fp3
8359 fmov.d LOGB4(%pc),%fp2
8360
8361 fmul.x %fp1,%fp3 # W*B5
8362 fmul.x %fp1,%fp2 # W*B4
8363
8364 fadd.d LOGB3(%pc),%fp3 # B3+W*B5
8365 fadd.d LOGB2(%pc),%fp2 # B2+W*B4
8366
8367 fmul.x %fp3,%fp1 # W*(B3+W*B5), FP3 RELEASED
8368
8369 fmul.x %fp0,%fp2 # V*(B2+W*B4)
8370
8371 fadd.d LOGB1(%pc),%fp1 # B1+W*(B3+W*B5)
8372 fmul.x SAVEU(%a6),%fp0 # FP0 IS U*V
8373
8374 fadd.x %fp2,%fp1 # B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED
8375 fmovm.x (%sp)+,&0x30 # FP2-3 RESTORED
8376
8377 fmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
8378
8379 fmov.l %d0,%fpcr
8380 fadd.x SAVEU(%a6),%fp0
8381 bra t_inx2
8382
8383 #--REGISTERS SAVED FPCR. LOG(-VE) IS INVALID
8384 LOGNEG:
8385 bra t_operr
8386
8387 global slognd
8388 slognd:
8389 #--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
8390
8391 mov.l &-100,ADJK(%a6) # INPUT = 2^(ADJK) * FP0
8392
8393 #----normalize the input value by left shifting k bits (k to be determined
8394 #----below), adjusting exponent and storing -k to ADJK
8395 #----the value TWOTO100 is no longer needed.
8396 #----Note that this code assumes the denormalized input is NON-ZERO.
8397
8398 movm.l &0x3f00,-(%sp) # save some registers {d2-d7}
8399 mov.l (%a0),%d3 # D3 is exponent of smallest norm. #
8400 mov.l 4(%a0),%d4
8401 mov.l 8(%a0),%d5 # (D4,D5) is (Hi_X,Lo_X)
8402 clr.l %d2 # D2 used for holding K
8403
8404 tst.l %d4
8405 bne.b Hi_not0
8406
8407 Hi_0:
8408 mov.l %d5,%d4
8409 clr.l %d5
8410 mov.l &32,%d2
8411 clr.l %d6
8412 bfffo %d4{&0:&32},%d6
8413 lsl.l %d6,%d4
8414 add.l %d6,%d2 # (D3,D4,D5) is normalized
8415
8416 mov.l %d3,X(%a6)
8417 mov.l %d4,XFRAC(%a6)
8418 mov.l %d5,XFRAC+4(%a6)
8419 neg.l %d2
8420 mov.l %d2,ADJK(%a6)
8421 fmov.x X(%a6),%fp0
8422 movm.l (%sp)+,&0xfc # restore registers {d2-d7}
8423 lea X(%a6),%a0
8424 bra.w LOGBGN # begin regular log(X)
8425
8426 Hi_not0:
8427 clr.l %d6
8428 bfffo %d4{&0:&32},%d6 # find first 1
8429 mov.l %d6,%d2 # get k
8430 lsl.l %d6,%d4
8431 mov.l %d5,%d7 # a copy of D5
8432 lsl.l %d6,%d5
8433 neg.l %d6
8434 add.l &32,%d6
8435 lsr.l %d6,%d7
8436 or.l %d7,%d4 # (D3,D4,D5) normalized
8437
8438 mov.l %d3,X(%a6)
8439 mov.l %d4,XFRAC(%a6)
8440 mov.l %d5,XFRAC+4(%a6)
8441 neg.l %d2
8442 mov.l %d2,ADJK(%a6)
8443 fmov.x X(%a6),%fp0
8444 movm.l (%sp)+,&0xfc # restore registers {d2-d7}
8445 lea X(%a6),%a0
8446 bra.w LOGBGN # begin regular log(X)
8447
8448 global slognp1
8449 #--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S
8450 slognp1:
8451 fmov.x (%a0),%fp0 # LOAD INPUT
8452 fabs.x %fp0 # test magnitude
8453 fcmp.x %fp0,LTHOLD(%pc) # compare with min threshold
8454 fbgt.w LP1REAL # if greater, continue
8455 fmov.l %d0,%fpcr
8456 mov.b &FMOV_OP,%d1 # last inst is MOVE
8457 fmov.x (%a0),%fp0 # return signed argument
8458 bra t_catch
8459
8460 LP1REAL:
8461 fmov.x (%a0),%fp0 # LOAD INPUT
8462 mov.l &0x00000000,ADJK(%a6)
8463 fmov.x %fp0,%fp1 # FP1 IS INPUT Z
8464 fadd.s one(%pc),%fp0 # X := ROUND(1+Z)
8465 fmov.x %fp0,X(%a6)
8466 mov.w XFRAC(%a6),XDCARE(%a6)
8467 mov.l X(%a6),%d1
8468 cmp.l %d1,&0
8469 ble.w LP1NEG0 # LOG OF ZERO OR -VE
8470 cmp.l %d1,&0x3ffe8000 # IS BOUNDS [1/2,3/2]?
8471 blt.w LOGMAIN
8472 cmp.l %d1,&0x3fffc000
8473 bgt.w LOGMAIN
8474 #--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z,
8475 #--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE,
8476 #--SIMPLY INVOKE LOG(X) FOR LOG(1+Z).
8477
8478 LP1NEAR1:
8479 #--NEXT SEE IF EXP(-1/16) < X < EXP(1/16)
8480 cmp.l %d1,&0x3ffef07d
8481 blt.w LP1CARE
8482 cmp.l %d1,&0x3fff8841
8483 bgt.w LP1CARE
8484
8485 LP1ONE16:
8486 #--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2)
8487 #--WHERE U = 2Z/(2+Z) = 2Z/(1+X).
8488 fadd.x %fp1,%fp1 # FP1 IS 2Z
8489 fadd.s one(%pc),%fp0 # FP0 IS 1+X
8490 #--U = FP1/FP0
8491 bra.w LP1CONT2
8492
8493 LP1CARE:
8494 #--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE
8495 #--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST
8496 #--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2],
8497 #--THERE ARE ONLY TWO CASES.
8498 #--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z
8499 #--CASE 2: 1+Z > 1, THEN K = 0 AND Y-F = (1-F) + Z
8500 #--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
8501 #--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.
8502
8503 mov.l XFRAC(%a6),FFRAC(%a6)
8504 and.l &0xFE000000,FFRAC(%a6)
8505 or.l &0x01000000,FFRAC(%a6) # F OBTAINED
8506 cmp.l %d1,&0x3FFF8000 # SEE IF 1+Z > 1
8507 bge.b KISZERO
8508
8509 KISNEG1:
8510 fmov.s TWO(%pc),%fp0
8511 mov.l &0x3fff0000,F(%a6)
8512 clr.l F+8(%a6)
8513 fsub.x F(%a6),%fp0 # 2-F
8514 mov.l FFRAC(%a6),%d1
8515 and.l &0x7E000000,%d1
8516 asr.l &8,%d1
8517 asr.l &8,%d1
8518 asr.l &4,%d1 # D0 CONTAINS DISPLACEMENT FOR 1/F
8519 fadd.x %fp1,%fp1 # GET 2Z
8520 fmovm.x &0xc,-(%sp) # SAVE FP2 {%fp2/%fp3}
8521 fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Z
8522 lea LOGTBL(%pc),%a0 # A0 IS ADDRESS OF 1/F
8523 add.l %d1,%a0
8524 fmov.s negone(%pc),%fp1 # FP1 IS K = -1
8525 bra.w LP1CONT1
8526
8527 KISZERO:
8528 fmov.s one(%pc),%fp0
8529 mov.l &0x3fff0000,F(%a6)
8530 clr.l F+8(%a6)
8531 fsub.x F(%a6),%fp0 # 1-F
8532 mov.l FFRAC(%a6),%d1
8533 and.l &0x7E000000,%d1
8534 asr.l &8,%d1
8535 asr.l &8,%d1
8536 asr.l &4,%d1
8537 fadd.x %fp1,%fp0 # FP0 IS Y-F
8538 fmovm.x &0xc,-(%sp) # FP2 SAVED {%fp2/%fp3}
8539 lea LOGTBL(%pc),%a0
8540 add.l %d1,%a0 # A0 IS ADDRESS OF 1/F
8541 fmov.s zero(%pc),%fp1 # FP1 IS K = 0
8542 bra.w LP1CONT1
8543
8544 LP1NEG0:
8545 #--FPCR SAVED. D0 IS X IN COMPACT FORM.
8546 cmp.l %d1,&0
8547 blt.b LP1NEG
8548 LP1ZERO:
8549 fmov.s negone(%pc),%fp0
8550
8551 fmov.l %d0,%fpcr
8552 bra t_dz
8553
8554 LP1NEG:
8555 fmov.s zero(%pc),%fp0
8556
8557 fmov.l %d0,%fpcr
8558 bra t_operr
8559
8560 global slognp1d
8561 #--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT
8562 # Simply return the denorm
8563 slognp1d:
8564 bra t_extdnrm
8565
8566 #########################################################################
8567 # satanh(): computes the inverse hyperbolic tangent of a norm input #
8568 # satanhd(): computes the inverse hyperbolic tangent of a denorm input #
8569 # #
8570 # INPUT *************************************************************** #
8571 # a0 = pointer to extended precision input #
8572 # d0 = round precision,mode #
8573 # #
8574 # OUTPUT ************************************************************** #
8575 # fp0 = arctanh(X) #
8576 # #
8577 # ACCURACY and MONOTONICITY ******************************************* #
8578 # The returned result is within 3 ulps in 64 significant bit, #
8579 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
8580 # rounded to double precision. The result is provably monotonic #
8581 # in double precision. #
8582 # #
8583 # ALGORITHM *********************************************************** #
8584 # #
8585 # ATANH #
8586 # 1. If |X| >= 1, go to 3. #
8587 # #
8588 # 2. (|X| < 1) Calculate atanh(X) by #
8589 # sgn := sign(X) #
8590 # y := |X| #
8591 # z := 2y/(1-y) #
8592 # atanh(X) := sgn * (1/2) * logp1(z) #
8593 # Exit. #
8594 # #
8595 # 3. If |X| > 1, go to 5. #
8596 # #
8597 # 4. (|X| = 1) Generate infinity with an appropriate sign and #
8598 # divide-by-zero by #
8599 # sgn := sign(X) #
8600 # atan(X) := sgn / (+0). #
8601 # Exit. #
8602 # #
8603 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. #
8604 # Exit. #
8605 # #
8606 #########################################################################
8607
8608 global satanh
8609 satanh:
8610 mov.l (%a0),%d1
8611 mov.w 4(%a0),%d1
8612 and.l &0x7FFFFFFF,%d1
8613 cmp.l %d1,&0x3FFF8000
8614 bge.b ATANHBIG
8615
8616 #--THIS IS THE USUAL CASE, |X| < 1
8617 #--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z).
8618
8619 fabs.x (%a0),%fp0 # Y = |X|
8620 fmov.x %fp0,%fp1
8621 fneg.x %fp1 # -Y
8622 fadd.x %fp0,%fp0 # 2Y
8623 fadd.s &0x3F800000,%fp1 # 1-Y
8624 fdiv.x %fp1,%fp0 # 2Y/(1-Y)
8625 mov.l (%a0),%d1
8626 and.l &0x80000000,%d1
8627 or.l &0x3F000000,%d1 # SIGN(X)*HALF
8628 mov.l %d1,-(%sp)
8629
8630 mov.l %d0,-(%sp) # save rnd prec,mode
8631 clr.l %d0 # pass ext prec,RN
8632 fmovm.x &0x01,-(%sp) # save Z on stack
8633 lea (%sp),%a0 # pass ptr to Z
8634 bsr slognp1 # LOG1P(Z)
8635 add.l &0xc,%sp # clear Z from stack
8636
8637 mov.l (%sp)+,%d0 # fetch old prec,mode
8638 fmov.l %d0,%fpcr # load it
8639 mov.b &FMUL_OP,%d1 # last inst is MUL
8640 fmul.s (%sp)+,%fp0
8641 bra t_catch
8642
8643 ATANHBIG:
8644 fabs.x (%a0),%fp0 # |X|
8645 fcmp.s %fp0,&0x3F800000
8646 fbgt t_operr
8647 bra t_dz
8648
8649 global satanhd
8650 #--ATANH(X) = X FOR DENORMALIZED X
8651 satanhd:
8652 bra t_extdnrm
8653
8654 #########################################################################
8655 # slog10(): computes the base-10 logarithm of a normalized input #
8656 # slog10d(): computes the base-10 logarithm of a denormalized input #
8657 # slog2(): computes the base-2 logarithm of a normalized input #
8658 # slog2d(): computes the base-2 logarithm of a denormalized input #
8659 # #
8660 # INPUT *************************************************************** #
8661 # a0 = pointer to extended precision input #
8662 # d0 = round precision,mode #
8663 # #
8664 # OUTPUT ************************************************************** #
8665 # fp0 = log_10(X) or log_2(X) #
8666 # #
8667 # ACCURACY and MONOTONICITY ******************************************* #
8668 # The returned result is within 1.7 ulps in 64 significant bit, #
8669 # i.e. within 0.5003 ulp to 53 bits if the result is subsequently #
8670 # rounded to double precision. The result is provably monotonic #
8671 # in double precision. #
8672 # #
8673 # ALGORITHM *********************************************************** #
8674 # #
8675 # slog10d: #
8676 # #
8677 # Step 0. If X < 0, create a NaN and raise the invalid operation #
8678 # flag. Otherwise, save FPCR in D1; set FpCR to default. #
8679 # Notes: Default means round-to-nearest mode, no floating-point #
8680 # traps, and precision control = double extended. #
8681 # #
8682 # Step 1. Call slognd to obtain Y = log(X), the natural log of X. #
8683 # Notes: Even if X is denormalized, log(X) is always normalized. #
8684 # #
8685 # Step 2. Compute log_10(X) = log(X) * (1/log(10)). #
8686 # 2.1 Restore the user FPCR #
8687 # 2.2 Return ans := Y * INV_L10. #
8688 # #
8689 # slog10: #
8690 # #
8691 # Step 0. If X < 0, create a NaN and raise the invalid operation #
8692 # flag. Otherwise, save FPCR in D1; set FpCR to default. #
8693 # Notes: Default means round-to-nearest mode, no floating-point #
8694 # traps, and precision control = double extended. #
8695 # #
8696 # Step 1. Call sLogN to obtain Y = log(X), the natural log of X. #
8697 # #
8698 # Step 2. Compute log_10(X) = log(X) * (1/log(10)). #
8699 # 2.1 Restore the user FPCR #
8700 # 2.2 Return ans := Y * INV_L10. #
8701 # #
8702 # sLog2d: #
8703 # #
8704 # Step 0. If X < 0, create a NaN and raise the invalid operation #
8705 # flag. Otherwise, save FPCR in D1; set FpCR to default. #
8706 # Notes: Default means round-to-nearest mode, no floating-point #
8707 # traps, and precision control = double extended. #
8708 # #
8709 # Step 1. Call slognd to obtain Y = log(X), the natural log of X. #
8710 # Notes: Even if X is denormalized, log(X) is always normalized. #
8711 # #
8712 # Step 2. Compute log_10(X) = log(X) * (1/log(2)). #
8713 # 2.1 Restore the user FPCR #
8714 # 2.2 Return ans := Y * INV_L2. #
8715 # #
8716 # sLog2: #
8717 # #
8718 # Step 0. If X < 0, create a NaN and raise the invalid operation #
8719 # flag. Otherwise, save FPCR in D1; set FpCR to default. #
8720 # Notes: Default means round-to-nearest mode, no floating-point #
8721 # traps, and precision control = double extended. #
8722 # #
8723 # Step 1. If X is not an integer power of two, i.e., X != 2^k, #
8724 # go to Step 3. #
8725 # #
8726 # Step 2. Return k. #
8727 # 2.1 Get integer k, X = 2^k. #
8728 # 2.2 Restore the user FPCR. #
8729 # 2.3 Return ans := convert-to-double-extended(k). #
8730 # #
8731 # Step 3. Call sLogN to obtain Y = log(X), the natural log of X. #
8732 # #
8733 # Step 4. Compute log_2(X) = log(X) * (1/log(2)). #
8734 # 4.1 Restore the user FPCR #
8735 # 4.2 Return ans := Y * INV_L2. #
8736 # #
8737 #########################################################################
8738
8739 INV_L10:
8740 long 0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000
8741
8742 INV_L2:
8743 long 0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000
8744
8745 global slog10
8746 #--entry point for Log10(X), X is normalized
8747 slog10:
8748 fmov.b &0x1,%fp0
8749 fcmp.x %fp0,(%a0) # if operand == 1,
8750 fbeq.l ld_pzero # return an EXACT zero
8751
8752 mov.l (%a0),%d1
8753 blt.w invalid
8754 mov.l %d0,-(%sp)
8755 clr.l %d0
8756 bsr slogn # log(X), X normal.
8757 fmov.l (%sp)+,%fpcr
8758 fmul.x INV_L10(%pc),%fp0
8759 bra t_inx2
8760
8761 global slog10d
8762 #--entry point for Log10(X), X is denormalized
8763 slog10d:
8764 mov.l (%a0),%d1
8765 blt.w invalid
8766 mov.l %d0,-(%sp)
8767 clr.l %d0
8768 bsr slognd # log(X), X denorm.
8769 fmov.l (%sp)+,%fpcr
8770 fmul.x INV_L10(%pc),%fp0
8771 bra t_minx2
8772
8773 global slog2
8774 #--entry point for Log2(X), X is normalized
8775 slog2:
8776 mov.l (%a0),%d1
8777 blt.w invalid
8778
8779 mov.l 8(%a0),%d1
8780 bne.b continue # X is not 2^k
8781
8782 mov.l 4(%a0),%d1
8783 and.l &0x7FFFFFFF,%d1
8784 bne.b continue
8785
8786 #--X = 2^k.
8787 mov.w (%a0),%d1
8788 and.l &0x00007FFF,%d1
8789 sub.l &0x3FFF,%d1
8790 beq.l ld_pzero
8791 fmov.l %d0,%fpcr
8792 fmov.l %d1,%fp0
8793 bra t_inx2
8794
8795 continue:
8796 mov.l %d0,-(%sp)
8797 clr.l %d0
8798 bsr slogn # log(X), X normal.
8799 fmov.l (%sp)+,%fpcr
8800 fmul.x INV_L2(%pc),%fp0
8801 bra t_inx2
8802
8803 invalid:
8804 bra t_operr
8805
8806 global slog2d
8807 #--entry point for Log2(X), X is denormalized
8808 slog2d:
8809 mov.l (%a0),%d1
8810 blt.w invalid
8811 mov.l %d0,-(%sp)
8812 clr.l %d0
8813 bsr slognd # log(X), X denorm.
8814 fmov.l (%sp)+,%fpcr
8815 fmul.x INV_L2(%pc),%fp0
8816 bra t_minx2
8817
8818 #########################################################################
8819 # stwotox(): computes 2**X for a normalized input #
8820 # stwotoxd(): computes 2**X for a denormalized input #
8821 # stentox(): computes 10**X for a normalized input #
8822 # stentoxd(): computes 10**X for a denormalized input #
8823 # #
8824 # INPUT *************************************************************** #
8825 # a0 = pointer to extended precision input #
8826 # d0 = round precision,mode #
8827 # #
8828 # OUTPUT ************************************************************** #
8829 # fp0 = 2**X or 10**X #
8830 # #
8831 # ACCURACY and MONOTONICITY ******************************************* #
8832 # The returned result is within 2 ulps in 64 significant bit, #
8833 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
8834 # rounded to double precision. The result is provably monotonic #
8835 # in double precision. #
8836 # #
8837 # ALGORITHM *********************************************************** #
8838 # #
8839 # twotox #
8840 # 1. If |X| > 16480, go to ExpBig. #
8841 # #
8842 # 2. If |X| < 2**(-70), go to ExpSm. #
8843 # #
8844 # 3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore #
8845 # decompose N as #
8846 # N = 64(M + M') + j, j = 0,1,2,...,63. #
8847 # #
8848 # 4. Overwrite r := r * log2. Then #
8849 # 2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). #
8850 # Go to expr to compute that expression. #
8851 # #
8852 # tentox #
8853 # 1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig. #
8854 # #
8855 # 2. If |X| < 2**(-70), go to ExpSm. #
8856 # #
8857 # 3. Set y := X*log_2(10)*64 (base 2 log of 10). Set #
8858 # N := round-to-int(y). Decompose N as #
8859 # N = 64(M + M') + j, j = 0,1,2,...,63. #
8860 # #
8861 # 4. Define r as #
8862 # r := ((X - N*L1)-N*L2) * L10 #
8863 # where L1, L2 are the leading and trailing parts of #
8864 # log_10(2)/64 and L10 is the natural log of 10. Then #
8865 # 10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). #
8866 # Go to expr to compute that expression. #
8867 # #
8868 # expr #
8869 # 1. Fetch 2**(j/64) from table as Fact1 and Fact2. #
8870 # #
8871 # 2. Overwrite Fact1 and Fact2 by #
8872 # Fact1 := 2**(M) * Fact1 #
8873 # Fact2 := 2**(M) * Fact2 #
8874 # Thus Fact1 + Fact2 = 2**(M) * 2**(j/64). #
8875 # #
8876 # 3. Calculate P where 1 + P approximates exp(r): #
8877 # P = r + r*r*(A1+r*(A2+...+r*A5)). #
8878 # #
8879 # 4. Let AdjFact := 2**(M'). Return #
8880 # AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ). #
8881 # Exit. #
8882 # #
8883 # ExpBig #
8884 # 1. Generate overflow by Huge * Huge if X > 0; otherwise, #
8885 # generate underflow by Tiny * Tiny. #
8886 # #
8887 # ExpSm #
8888 # 1. Return 1 + X. #
8889 # #
8890 #########################################################################
8891
8892 L2TEN64:
8893 long 0x406A934F,0x0979A371 # 64LOG10/LOG2
8894 L10TWO1:
8895 long 0x3F734413,0x509F8000 # LOG2/64LOG10
8896
8897 L10TWO2:
8898 long 0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000
8899
8900 LOG10: long 0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000
8901
8902 LOG2: long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
8903
8904 EXPA5: long 0x3F56C16D,0x6F7BD0B2
8905 EXPA4: long 0x3F811112,0x302C712C
8906 EXPA3: long 0x3FA55555,0x55554CC1
8907 EXPA2: long 0x3FC55555,0x55554A54
8908 EXPA1: long 0x3FE00000,0x00000000,0x00000000,0x00000000
8909
8910 TEXPTBL:
8911 long 0x3FFF0000,0x80000000,0x00000000,0x3F738000
8912 long 0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CA
8913 long 0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9
8914 long 0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9
8915 long 0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DA
8916 long 0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85C
8917 long 0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1
8918 long 0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CA
8919 long 0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373
8920 long 0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670
8921 long 0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700
8922 long 0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0
8923 long 0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6D
8924 long 0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319
8925 long 0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2B
8926 long 0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5
8927 long 0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5A
8928 long 0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7B
8929 long 0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAF
8930 long 0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DA
8931 long 0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDD
8932 long 0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96E
8933 long 0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90B
8934 long 0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DB
8935 long 0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EB
8936 long 0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274
8937 long 0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83C
8938 long 0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00
8939 long 0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301
8940 long 0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367
8941 long 0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05F
8942 long 0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3C
8943 long 0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FB
8944 long 0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CB
8945 long 0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3C
8946 long 0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AA
8947 long 0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFD
8948 long 0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51
8949 long 0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88A
8950 long 0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2
8951 long 0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8AB
8952 long 0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17
8953 long 0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3C
8954 long 0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8
8955 long 0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53
8956 long 0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AE
8957 long 0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124
8958 long 0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243
8959 long 0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69A
8960 long 0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61
8961 long 0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610
8962 long 0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1
8963 long 0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12
8964 long 0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFE
8965 long 0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4
8966 long 0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22F
8967 long 0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4A
8968 long 0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01A
8969 long 0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAC
8970 long 0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3F
8971 long 0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73A
8972 long 0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795
8973 long 0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84B
8974 long 0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581
8975
8976 set INT,L_SCR1
8977
8978 set X,FP_SCR0
8979 set XDCARE,X+2
8980 set XFRAC,X+4
8981
8982 set ADJFACT,FP_SCR0
8983
8984 set FACT1,FP_SCR0
8985 set FACT1HI,FACT1+4
8986 set FACT1LOW,FACT1+8
8987
8988 set FACT2,FP_SCR1
8989 set FACT2HI,FACT2+4
8990 set FACT2LOW,FACT2+8
8991
8992 global stwotox
8993 #--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
8994 stwotox:
8995 fmovm.x (%a0),&0x80 # LOAD INPUT
8996
8997 mov.l (%a0),%d1
8998 mov.w 4(%a0),%d1
8999 fmov.x %fp0,X(%a6)
9000 and.l &0x7FFFFFFF,%d1
9001
9002 cmp.l %d1,&0x3FB98000 # |X| >= 2**(-70)?
9003 bge.b TWOOK1
9004 bra.w EXPBORS
9005
9006 TWOOK1:
9007 cmp.l %d1,&0x400D80C0 # |X| > 16480?
9008 ble.b TWOMAIN
9009 bra.w EXPBORS
9010
9011 TWOMAIN:
9012 #--USUAL CASE, 2^(-70) <= |X| <= 16480
9013
9014 fmov.x %fp0,%fp1
9015 fmul.s &0x42800000,%fp1 # 64 * X
9016 fmov.l %fp1,INT(%a6) # N = ROUND-TO-INT(64 X)
9017 mov.l %d2,-(%sp)
9018 lea TEXPTBL(%pc),%a1 # LOAD ADDRESS OF TABLE OF 2^(J/64)
9019 fmov.l INT(%a6),%fp1 # N --> FLOATING FMT
9020 mov.l INT(%a6),%d1
9021 mov.l %d1,%d2
9022 and.l &0x3F,%d1 # D0 IS J
9023 asl.l &4,%d1 # DISPLACEMENT FOR 2^(J/64)
9024 add.l %d1,%a1 # ADDRESS FOR 2^(J/64)
9025 asr.l &6,%d2 # d2 IS L, N = 64L + J
9026 mov.l %d2,%d1
9027 asr.l &1,%d1 # D0 IS M
9028 sub.l %d1,%d2 # d2 IS M', N = 64(M+M') + J
9029 add.l &0x3FFF,%d2
9030
9031 #--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
9032 #--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
9033 #--ADJFACT = 2^(M').
9034 #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9035
9036 fmovm.x &0x0c,-(%sp) # save fp2/fp3
9037
9038 fmul.s &0x3C800000,%fp1 # (1/64)*N
9039 mov.l (%a1)+,FACT1(%a6)
9040 mov.l (%a1)+,FACT1HI(%a6)
9041 mov.l (%a1)+,FACT1LOW(%a6)
9042 mov.w (%a1)+,FACT2(%a6)
9043
9044 fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X)
9045
9046 mov.w (%a1)+,FACT2HI(%a6)
9047 clr.w FACT2HI+2(%a6)
9048 clr.l FACT2LOW(%a6)
9049 add.w %d1,FACT1(%a6)
9050 fmul.x LOG2(%pc),%fp0 # FP0 IS R
9051 add.w %d1,FACT2(%a6)
9052
9053 bra.w expr
9054
9055 EXPBORS:
9056 #--FPCR, D0 SAVED
9057 cmp.l %d1,&0x3FFF8000
9058 bgt.b TEXPBIG
9059
9060 #--|X| IS SMALL, RETURN 1 + X
9061
9062 fmov.l %d0,%fpcr # restore users round prec,mode
9063 fadd.s &0x3F800000,%fp0 # RETURN 1 + X
9064 bra t_pinx2
9065
9066 TEXPBIG:
9067 #--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW
9068 #--REGISTERS SAVE SO FAR ARE FPCR AND D0
9069 mov.l X(%a6),%d1
9070 cmp.l %d1,&0
9071 blt.b EXPNEG
9072
9073 bra t_ovfl2 # t_ovfl expects positive value
9074
9075 EXPNEG:
9076 bra t_unfl2 # t_unfl expects positive value
9077
9078 global stwotoxd
9079 stwotoxd:
9080 #--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENT
9081
9082 fmov.l %d0,%fpcr # set user's rounding mode/precision
9083 fmov.s &0x3F800000,%fp0 # RETURN 1 + X
9084 mov.l (%a0),%d1
9085 or.l &0x00800001,%d1
9086 fadd.s %d1,%fp0
9087 bra t_pinx2
9088
9089 global stentox
9090 #--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
9091 stentox:
9092 fmovm.x (%a0),&0x80 # LOAD INPUT
9093
9094 mov.l (%a0),%d1
9095 mov.w 4(%a0),%d1
9096 fmov.x %fp0,X(%a6)
9097 and.l &0x7FFFFFFF,%d1
9098
9099 cmp.l %d1,&0x3FB98000 # |X| >= 2**(-70)?
9100 bge.b TENOK1
9101 bra.w EXPBORS
9102
9103 TENOK1:
9104 cmp.l %d1,&0x400B9B07 # |X| <= 16480*log2/log10 ?
9105 ble.b TENMAIN
9106 bra.w EXPBORS
9107
9108 TENMAIN:
9109 #--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10
9110
9111 fmov.x %fp0,%fp1
9112 fmul.d L2TEN64(%pc),%fp1 # X*64*LOG10/LOG2
9113 fmov.l %fp1,INT(%a6) # N=INT(X*64*LOG10/LOG2)
9114 mov.l %d2,-(%sp)
9115 lea TEXPTBL(%pc),%a1 # LOAD ADDRESS OF TABLE OF 2^(J/64)
9116 fmov.l INT(%a6),%fp1 # N --> FLOATING FMT
9117 mov.l INT(%a6),%d1
9118 mov.l %d1,%d2
9119 and.l &0x3F,%d1 # D0 IS J
9120 asl.l &4,%d1 # DISPLACEMENT FOR 2^(J/64)
9121 add.l %d1,%a1 # ADDRESS FOR 2^(J/64)
9122 asr.l &6,%d2 # d2 IS L, N = 64L + J
9123 mov.l %d2,%d1
9124 asr.l &1,%d1 # D0 IS M
9125 sub.l %d1,%d2 # d2 IS M', N = 64(M+M') + J
9126 add.l &0x3FFF,%d2
9127
9128 #--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
9129 #--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
9130 #--ADJFACT = 2^(M').
9131 #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9132 fmovm.x &0x0c,-(%sp) # save fp2/fp3
9133
9134 fmov.x %fp1,%fp2
9135
9136 fmul.d L10TWO1(%pc),%fp1 # N*(LOG2/64LOG10)_LEAD
9137 mov.l (%a1)+,FACT1(%a6)
9138
9139 fmul.x L10TWO2(%pc),%fp2 # N*(LOG2/64LOG10)_TRAIL
9140
9141 mov.l (%a1)+,FACT1HI(%a6)
9142 mov.l (%a1)+,FACT1LOW(%a6)
9143 fsub.x %fp1,%fp0 # X - N L_LEAD
9144 mov.w (%a1)+,FACT2(%a6)
9145
9146 fsub.x %fp2,%fp0 # X - N L_TRAIL
9147
9148 mov.w (%a1)+,FACT2HI(%a6)
9149 clr.w FACT2HI+2(%a6)
9150 clr.l FACT2LOW(%a6)
9151
9152 fmul.x LOG10(%pc),%fp0 # FP0 IS R
9153 add.w %d1,FACT1(%a6)
9154 add.w %d1,FACT2(%a6)
9155
9156 expr:
9157 #--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN.
9158 #--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64).
9159 #--FP0 IS R. THE FOLLOWING CODE COMPUTES
9160 #-- 2**(M'+M) * 2**(J/64) * EXP(R)
9161
9162 fmov.x %fp0,%fp1
9163 fmul.x %fp1,%fp1 # FP1 IS S = R*R
9164
9165 fmov.d EXPA5(%pc),%fp2 # FP2 IS A5
9166 fmov.d EXPA4(%pc),%fp3 # FP3 IS A4
9167
9168 fmul.x %fp1,%fp2 # FP2 IS S*A5
9169 fmul.x %fp1,%fp3 # FP3 IS S*A4
9170
9171 fadd.d EXPA3(%pc),%fp2 # FP2 IS A3+S*A5
9172 fadd.d EXPA2(%pc),%fp3 # FP3 IS A2+S*A4
9173
9174 fmul.x %fp1,%fp2 # FP2 IS S*(A3+S*A5)
9175 fmul.x %fp1,%fp3 # FP3 IS S*(A2+S*A4)
9176
9177 fadd.d EXPA1(%pc),%fp2 # FP2 IS A1+S*(A3+S*A5)
9178 fmul.x %fp0,%fp3 # FP3 IS R*S*(A2+S*A4)
9179
9180 fmul.x %fp1,%fp2 # FP2 IS S*(A1+S*(A3+S*A5))
9181 fadd.x %fp3,%fp0 # FP0 IS R+R*S*(A2+S*A4)
9182 fadd.x %fp2,%fp0 # FP0 IS EXP(R) - 1
9183
9184 fmovm.x (%sp)+,&0x30 # restore fp2/fp3
9185
9186 #--FINAL RECONSTRUCTION PROCESS
9187 #--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1) - (1 OR 0)
9188
9189 fmul.x FACT1(%a6),%fp0
9190 fadd.x FACT2(%a6),%fp0
9191 fadd.x FACT1(%a6),%fp0
9192
9193 fmov.l %d0,%fpcr # restore users round prec,mode
9194 mov.w %d2,ADJFACT(%a6) # INSERT EXPONENT
9195 mov.l (%sp)+,%d2
9196 mov.l &0x80000000,ADJFACT+4(%a6)
9197 clr.l ADJFACT+8(%a6)
9198 mov.b &FMUL_OP,%d1 # last inst is MUL
9199 fmul.x ADJFACT(%a6),%fp0 # FINAL ADJUSTMENT
9200 bra t_catch
9201
9202 global stentoxd
9203 stentoxd:
9204 #--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENT
9205
9206 fmov.l %d0,%fpcr # set user's rounding mode/precision
9207 fmov.s &0x3F800000,%fp0 # RETURN 1 + X
9208 mov.l (%a0),%d1
9209 or.l &0x00800001,%d1
9210 fadd.s %d1,%fp0
9211 bra t_pinx2
9212
9213 #########################################################################
9214 # sscale(): computes the destination operand scaled by the source #
9215 # operand. If the absoulute value of the source operand is #
9216 # >= 2^14, an overflow or underflow is returned. #
9217 # #
9218 # INPUT *************************************************************** #
9219 # a0 = pointer to double-extended source operand X #
9220 # a1 = pointer to double-extended destination operand Y #
9221 # #
9222 # OUTPUT ************************************************************** #
9223 # fp0 = scale(X,Y) #
9224 # #
9225 #########################################################################
9226
9227 set SIGN, L_SCR1
9228
9229 global sscale
9230 sscale:
9231 mov.l %d0,-(%sp) # store off ctrl bits for now
9232
9233 mov.w DST_EX(%a1),%d1 # get dst exponent
9234 smi.b SIGN(%a6) # use SIGN to hold dst sign
9235 andi.l &0x00007fff,%d1 # strip sign from dst exp
9236
9237 mov.w SRC_EX(%a0),%d0 # check src bounds
9238 andi.w &0x7fff,%d0 # clr src sign bit
9239 cmpi.w %d0,&0x3fff # is src ~ ZERO?
9240 blt.w src_small # yes
9241 cmpi.w %d0,&0x400c # no; is src too big?
9242 bgt.w src_out # yes
9243
9244 #
9245 # Source is within 2^14 range.
9246 #
9247 src_ok:
9248 fintrz.x SRC(%a0),%fp0 # calc int of src
9249 fmov.l %fp0,%d0 # int src to d0
9250 # don't want any accrued bits from the fintrz showing up later since
9251 # we may need to read the fpsr for the last fp op in t_catch2().
9252 fmov.l &0x0,%fpsr
9253
9254 tst.b DST_HI(%a1) # is dst denormalized?
9255 bmi.b sok_norm
9256
9257 # the dst is a DENORM. normalize the DENORM and add the adjustment to
9258 # the src value. then, jump to the norm part of the routine.
9259 sok_dnrm:
9260 mov.l %d0,-(%sp) # save src for now
9261
9262 mov.w DST_EX(%a1),FP_SCR0_EX(%a6) # make a copy
9263 mov.l DST_HI(%a1),FP_SCR0_HI(%a6)
9264 mov.l DST_LO(%a1),FP_SCR0_LO(%a6)
9265
9266 lea FP_SCR0(%a6),%a0 # pass ptr to DENORM
9267 bsr.l norm # normalize the DENORM
9268 neg.l %d0
9269 add.l (%sp)+,%d0 # add adjustment to src
9270
9271 fmovm.x FP_SCR0(%a6),&0x80 # load normalized DENORM
9272
9273 cmpi.w %d0,&-0x3fff # is the shft amt really low?
9274 bge.b sok_norm2 # thank goodness no
9275
9276 # the multiply factor that we're trying to create should be a denorm
9277 # for the multiply to work. therefore, we're going to actually do a
9278 # multiply with a denorm which will cause an unimplemented data type
9279 # exception to be put into the machine which will be caught and corrected
9280 # later. we don't do this with the DENORMs above because this method
9281 # is slower. but, don't fret, I don't see it being used much either.
9282 fmov.l (%sp)+,%fpcr # restore user fpcr
9283 mov.l &0x80000000,%d1 # load normalized mantissa
9284 subi.l &-0x3fff,%d0 # how many should we shift?
9285 neg.l %d0 # make it positive
9286 cmpi.b %d0,&0x20 # is it > 32?
9287 bge.b sok_dnrm_32 # yes
9288 lsr.l %d0,%d1 # no; bit stays in upper lw
9289 clr.l -(%sp) # insert zero low mantissa
9290 mov.l %d1,-(%sp) # insert new high mantissa
9291 clr.l -(%sp) # make zero exponent
9292 bra.b sok_norm_cont
9293 sok_dnrm_32:
9294 subi.b &0x20,%d0 # get shift count
9295 lsr.l %d0,%d1 # make low mantissa longword
9296 mov.l %d1,-(%sp) # insert new low mantissa
9297 clr.l -(%sp) # insert zero high mantissa
9298 clr.l -(%sp) # make zero exponent
9299 bra.b sok_norm_cont
9300
9301 # the src will force the dst to a DENORM value or worse. so, let's
9302 # create an fp multiply that will create the result.
9303 sok_norm:
9304 fmovm.x DST(%a1),&0x80 # load fp0 with normalized src
9305 sok_norm2:
9306 fmov.l (%sp)+,%fpcr # restore user fpcr
9307
9308 addi.w &0x3fff,%d0 # turn src amt into exp value
9309 swap %d0 # put exponent in high word
9310 clr.l -(%sp) # insert new exponent
9311 mov.l &0x80000000,-(%sp) # insert new high mantissa
9312 mov.l %d0,-(%sp) # insert new lo mantissa
9313
9314 sok_norm_cont:
9315 fmov.l %fpcr,%d0 # d0 needs fpcr for t_catch2
9316 mov.b &FMUL_OP,%d1 # last inst is MUL
9317 fmul.x (%sp)+,%fp0 # do the multiply
9318 bra t_catch2 # catch any exceptions
9319
9320 #
9321 # Source is outside of 2^14 range. Test the sign and branch
9322 # to the appropriate exception handler.
9323 #
9324 src_out:
9325 mov.l (%sp)+,%d0 # restore ctrl bits
9326 exg %a0,%a1 # swap src,dst ptrs
9327 tst.b SRC_EX(%a1) # is src negative?
9328 bmi t_unfl # yes; underflow
9329 bra t_ovfl_sc # no; overflow
9330
9331 #
9332 # The source input is below 1, so we check for denormalized numbers
9333 # and set unfl.
9334 #
9335 src_small:
9336 tst.b DST_HI(%a1) # is dst denormalized?
9337 bpl.b ssmall_done # yes
9338
9339 mov.l (%sp)+,%d0
9340 fmov.l %d0,%fpcr # no; load control bits
9341 mov.b &FMOV_OP,%d1 # last inst is MOVE
9342 fmov.x DST(%a1),%fp0 # simply return dest
9343 bra t_catch2
9344 ssmall_done:
9345 mov.l (%sp)+,%d0 # load control bits into d1
9346 mov.l %a1,%a0 # pass ptr to dst
9347 bra t_resdnrm
9348
9349 #########################################################################
9350 # smod(): computes the fp MOD of the input values X,Y. #
9351 # srem(): computes the fp (IEEE) REM of the input values X,Y. #
9352 # #
9353 # INPUT *************************************************************** #
9354 # a0 = pointer to extended precision input X #
9355 # a1 = pointer to extended precision input Y #
9356 # d0 = round precision,mode #
9357 # #
9358 # The input operands X and Y can be either normalized or #
9359 # denormalized. #
9360 # #
9361 # OUTPUT ************************************************************** #
9362 # fp0 = FREM(X,Y) or FMOD(X,Y) #
9363 # #
9364 # ALGORITHM *********************************************************** #
9365 # #
9366 # Step 1. Save and strip signs of X and Y: signX := sign(X), #
9367 # signY := sign(Y), X := |X|, Y := |Y|, #
9368 # signQ := signX EOR signY. Record whether MOD or REM #
9369 # is requested. #
9370 # #
9371 # Step 2. Set L := expo(X)-expo(Y), k := 0, Q := 0. #
9372 # If (L < 0) then #
9373 # R := X, go to Step 4. #
9374 # else #
9375 # R := 2^(-L)X, j := L. #
9376 # endif #
9377 # #
9378 # Step 3. Perform MOD(X,Y) #
9379 # 3.1 If R = Y, go to Step 9. #
9380 # 3.2 If R > Y, then { R := R - Y, Q := Q + 1} #
9381 # 3.3 If j = 0, go to Step 4. #
9382 # 3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to #
9383 # Step 3.1. #
9384 # #
9385 # Step 4. At this point, R = X - QY = MOD(X,Y). Set #
9386 # Last_Subtract := false (used in Step 7 below). If #
9387 # MOD is requested, go to Step 6. #
9388 # #
9389 # Step 5. R = MOD(X,Y), but REM(X,Y) is requested. #
9390 # 5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to #
9391 # Step 6. #
9392 # 5.2 If R > Y/2, then { set Last_Subtract := true, #
9393 # Q := Q + 1, Y := signY*Y }. Go to Step 6. #
9394 # 5.3 This is the tricky case of R = Y/2. If Q is odd, #
9395 # then { Q := Q + 1, signX := -signX }. #
9396 # #
9397 # Step 6. R := signX*R. #
9398 # #
9399 # Step 7. If Last_Subtract = true, R := R - Y. #
9400 # #
9401 # Step 8. Return signQ, last 7 bits of Q, and R as required. #
9402 # #
9403 # Step 9. At this point, R = 2^(-j)*X - Q Y = Y. Thus, #
9404 # X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1), #
9405 # R := 0. Return signQ, last 7 bits of Q, and R. #
9406 # #
9407 #########################################################################
9408
9409 set Mod_Flag,L_SCR3
9410 set Sc_Flag,L_SCR3+1
9411
9412 set SignY,L_SCR2
9413 set SignX,L_SCR2+2
9414 set SignQ,L_SCR3+2
9415
9416 set Y,FP_SCR0
9417 set Y_Hi,Y+4
9418 set Y_Lo,Y+8
9419
9420 set R,FP_SCR1
9421 set R_Hi,R+4
9422 set R_Lo,R+8
9423
9424 Scale:
9425 long 0x00010000,0x80000000,0x00000000,0x00000000
9426
9427 global smod
9428 smod:
9429 clr.b FPSR_QBYTE(%a6)
9430 mov.l %d0,-(%sp) # save ctrl bits
9431 clr.b Mod_Flag(%a6)
9432 bra.b Mod_Rem
9433
9434 global srem
9435 srem:
9436 clr.b FPSR_QBYTE(%a6)
9437 mov.l %d0,-(%sp) # save ctrl bits
9438 mov.b &0x1,Mod_Flag(%a6)
9439
9440 Mod_Rem:
9441 #..Save sign of X and Y
9442 movm.l &0x3f00,-(%sp) # save data registers
9443 mov.w SRC_EX(%a0),%d3
9444 mov.w %d3,SignY(%a6)
9445 and.l &0x00007FFF,%d3 # Y := |Y|
9446
9447 #
9448 mov.l SRC_HI(%a0),%d4
9449 mov.l SRC_LO(%a0),%d5 # (D3,D4,D5) is |Y|
9450
9451 tst.l %d3
9452 bne.b Y_Normal
9453
9454 mov.l &0x00003FFE,%d3 # $3FFD + 1
9455 tst.l %d4
9456 bne.b HiY_not0
9457
9458 HiY_0:
9459 mov.l %d5,%d4
9460 clr.l %d5
9461 sub.l &32,%d3
9462 clr.l %d6
9463 bfffo %d4{&0:&32},%d6
9464 lsl.l %d6,%d4
9465 sub.l %d6,%d3 # (D3,D4,D5) is normalized
9466 # ...with bias $7FFD
9467 bra.b Chk_X
9468
9469 HiY_not0:
9470 clr.l %d6
9471 bfffo %d4{&0:&32},%d6
9472 sub.l %d6,%d3
9473 lsl.l %d6,%d4
9474 mov.l %d5,%d7 # a copy of D5
9475 lsl.l %d6,%d5
9476 neg.l %d6
9477 add.l &32,%d6
9478 lsr.l %d6,%d7
9479 or.l %d7,%d4 # (D3,D4,D5) normalized
9480 # ...with bias $7FFD
9481 bra.b Chk_X
9482
9483 Y_Normal:
9484 add.l &0x00003FFE,%d3 # (D3,D4,D5) normalized
9485 # ...with bias $7FFD
9486
9487 Chk_X:
9488 mov.w DST_EX(%a1),%d0
9489 mov.w %d0,SignX(%a6)
9490 mov.w SignY(%a6),%d1
9491 eor.l %d0,%d1
9492 and.l &0x00008000,%d1
9493 mov.w %d1,SignQ(%a6) # sign(Q) obtained
9494 and.l &0x00007FFF,%d0
9495 mov.l DST_HI(%a1),%d1
9496 mov.l DST_LO(%a1),%d2 # (D0,D1,D2) is |X|
9497 tst.l %d0
9498 bne.b X_Normal
9499 mov.l &0x00003FFE,%d0
9500 tst.l %d1
9501 bne.b HiX_not0
9502
9503 HiX_0:
9504 mov.l %d2,%d1
9505 clr.l %d2
9506 sub.l &32,%d0
9507 clr.l %d6
9508 bfffo %d1{&0:&32},%d6
9509 lsl.l %d6,%d1
9510 sub.l %d6,%d0 # (D0,D1,D2) is normalized
9511 # ...with bias $7FFD
9512 bra.b Init
9513
9514 HiX_not0:
9515 clr.l %d6
9516 bfffo %d1{&0:&32},%d6
9517 sub.l %d6,%d0
9518 lsl.l %d6,%d1
9519 mov.l %d2,%d7 # a copy of D2
9520 lsl.l %d6,%d2
9521 neg.l %d6
9522 add.l &32,%d6
9523 lsr.l %d6,%d7
9524 or.l %d7,%d1 # (D0,D1,D2) normalized
9525 # ...with bias $7FFD
9526 bra.b Init
9527
9528 X_Normal:
9529 add.l &0x00003FFE,%d0 # (D0,D1,D2) normalized
9530 # ...with bias $7FFD
9531
9532 Init:
9533 #
9534 mov.l %d3,L_SCR1(%a6) # save biased exp(Y)
9535 mov.l %d0,-(%sp) # save biased exp(X)
9536 sub.l %d3,%d0 # L := expo(X)-expo(Y)
9537
9538 clr.l %d6 # D6 := carry <- 0
9539 clr.l %d3 # D3 is Q
9540 mov.l &0,%a1 # A1 is k; j+k=L, Q=0
9541
9542 #..(Carry,D1,D2) is R
9543 tst.l %d0
9544 bge.b Mod_Loop_pre
9545
9546 #..expo(X) < expo(Y). Thus X = mod(X,Y)
9547 #
9548 mov.l (%sp)+,%d0 # restore d0
9549 bra.w Get_Mod
9550
9551 Mod_Loop_pre:
9552 addq.l &0x4,%sp # erase exp(X)
9553 #..At this point R = 2^(-L)X; Q = 0; k = 0; and k+j = L
9554 Mod_Loop:
9555 tst.l %d6 # test carry bit
9556 bgt.b R_GT_Y
9557
9558 #..At this point carry = 0, R = (D1,D2), Y = (D4,D5)
9559 cmp.l %d1,%d4 # compare hi(R) and hi(Y)
9560 bne.b R_NE_Y
9561 cmp.l %d2,%d5 # compare lo(R) and lo(Y)
9562 bne.b R_NE_Y
9563
9564 #..At this point, R = Y
9565 bra.w Rem_is_0
9566
9567 R_NE_Y:
9568 #..use the borrow of the previous compare
9569 bcs.b R_LT_Y # borrow is set iff R < Y
9570
9571 R_GT_Y:
9572 #..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0
9573 #..and Y < (D1,D2) < 2Y. Either way, perform R - Y
9574 sub.l %d5,%d2 # lo(R) - lo(Y)
9575 subx.l %d4,%d1 # hi(R) - hi(Y)
9576 clr.l %d6 # clear carry
9577 addq.l &1,%d3 # Q := Q + 1
9578
9579 R_LT_Y:
9580 #..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0.
9581 tst.l %d0 # see if j = 0.
9582 beq.b PostLoop
9583
9584 add.l %d3,%d3 # Q := 2Q
9585 add.l %d2,%d2 # lo(R) = 2lo(R)
9586 roxl.l &1,%d1 # hi(R) = 2hi(R) + carry
9587 scs %d6 # set Carry if 2(R) overflows
9588 addq.l &1,%a1 # k := k+1
9589 subq.l &1,%d0 # j := j - 1
9590 #..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y.
9591
9592 bra.b Mod_Loop
9593
9594 PostLoop:
9595 #..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y.
9596
9597 #..normalize R.
9598 mov.l L_SCR1(%a6),%d0 # new biased expo of R
9599 tst.l %d1
9600 bne.b HiR_not0
9601
9602 HiR_0:
9603 mov.l %d2,%d1
9604 clr.l %d2
9605 sub.l &32,%d0
9606 clr.l %d6
9607 bfffo %d1{&0:&32},%d6
9608 lsl.l %d6,%d1
9609 sub.l %d6,%d0 # (D0,D1,D2) is normalized
9610 # ...with bias $7FFD
9611 bra.b Get_Mod
9612
9613 HiR_not0:
9614 clr.l %d6
9615 bfffo %d1{&0:&32},%d6
9616 bmi.b Get_Mod # already normalized
9617 sub.l %d6,%d0
9618 lsl.l %d6,%d1
9619 mov.l %d2,%d7 # a copy of D2
9620 lsl.l %d6,%d2
9621 neg.l %d6
9622 add.l &32,%d6
9623 lsr.l %d6,%d7
9624 or.l %d7,%d1 # (D0,D1,D2) normalized
9625
9626 #
9627 Get_Mod:
9628 cmp.l %d0,&0x000041FE
9629 bge.b No_Scale
9630 Do_Scale:
9631 mov.w %d0,R(%a6)
9632 mov.l %d1,R_Hi(%a6)
9633 mov.l %d2,R_Lo(%a6)
9634 mov.l L_SCR1(%a6),%d6
9635 mov.w %d6,Y(%a6)
9636 mov.l %d4,Y_Hi(%a6)
9637 mov.l %d5,Y_Lo(%a6)
9638 fmov.x R(%a6),%fp0 # no exception
9639 mov.b &1,Sc_Flag(%a6)
9640 bra.b ModOrRem
9641 No_Scale:
9642 mov.l %d1,R_Hi(%a6)
9643 mov.l %d2,R_Lo(%a6)
9644 sub.l &0x3FFE,%d0
9645 mov.w %d0,R(%a6)
9646 mov.l L_SCR1(%a6),%d6
9647 sub.l &0x3FFE,%d6
9648 mov.l %d6,L_SCR1(%a6)
9649 fmov.x R(%a6),%fp0
9650 mov.w %d6,Y(%a6)
9651 mov.l %d4,Y_Hi(%a6)
9652 mov.l %d5,Y_Lo(%a6)
9653 clr.b Sc_Flag(%a6)
9654
9655 #
9656 ModOrRem:
9657 tst.b Mod_Flag(%a6)
9658 beq.b Fix_Sign
9659
9660 mov.l L_SCR1(%a6),%d6 # new biased expo(Y)
9661 subq.l &1,%d6 # biased expo(Y/2)
9662 cmp.l %d0,%d6
9663 blt.b Fix_Sign
9664 bgt.b Last_Sub
9665
9666 cmp.l %d1,%d4
9667 bne.b Not_EQ
9668 cmp.l %d2,%d5
9669 bne.b Not_EQ
9670 bra.w Tie_Case
9671
9672 Not_EQ:
9673 bcs.b Fix_Sign
9674
9675 Last_Sub:
9676 #
9677 fsub.x Y(%a6),%fp0 # no exceptions
9678 addq.l &1,%d3 # Q := Q + 1
9679
9680 #
9681 Fix_Sign:
9682 #..Get sign of X
9683 mov.w SignX(%a6),%d6
9684 bge.b Get_Q
9685 fneg.x %fp0
9686
9687 #..Get Q
9688 #
9689 Get_Q:
9690 clr.l %d6
9691 mov.w SignQ(%a6),%d6 # D6 is sign(Q)
9692 mov.l &8,%d7
9693 lsr.l %d7,%d6
9694 and.l &0x0000007F,%d3 # 7 bits of Q
9695 or.l %d6,%d3 # sign and bits of Q
9696 # swap %d3
9697 # fmov.l %fpsr,%d6
9698 # and.l &0xFF00FFFF,%d6
9699 # or.l %d3,%d6
9700 # fmov.l %d6,%fpsr # put Q in fpsr
9701 mov.b %d3,FPSR_QBYTE(%a6) # put Q in fpsr
9702
9703 #
9704 Restore:
9705 movm.l (%sp)+,&0xfc # {%d2-%d7}
9706 mov.l (%sp)+,%d0
9707 fmov.l %d0,%fpcr
9708 tst.b Sc_Flag(%a6)
9709 beq.b Finish
9710 mov.b &FMUL_OP,%d1 # last inst is MUL
9711 fmul.x Scale(%pc),%fp0 # may cause underflow
9712 bra t_catch2
9713 # the '040 package did this apparently to see if the dst operand for the
9714 # preceding fmul was a denorm. but, it better not have been since the
9715 # algorithm just got done playing with fp0 and expected no exceptions
9716 # as a result. trust me...
9717 # bra t_avoid_unsupp # check for denorm as a
9718 # ;result of the scaling
9719
9720 Finish:
9721 mov.b &FMOV_OP,%d1 # last inst is MOVE
9722 fmov.x %fp0,%fp0 # capture exceptions & round
9723 bra t_catch2
9724
9725 Rem_is_0:
9726 #..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)
9727 addq.l &1,%d3
9728 cmp.l %d0,&8 # D0 is j
9729 bge.b Q_Big
9730
9731 lsl.l %d0,%d3
9732 bra.b Set_R_0
9733
9734 Q_Big:
9735 clr.l %d3
9736
9737 Set_R_0:
9738 fmov.s &0x00000000,%fp0
9739 clr.b Sc_Flag(%a6)
9740 bra.w Fix_Sign
9741
9742 Tie_Case:
9743 #..Check parity of Q
9744 mov.l %d3,%d6
9745 and.l &0x00000001,%d6
9746 tst.l %d6
9747 beq.w Fix_Sign # Q is even
9748
9749 #..Q is odd, Q := Q + 1, signX := -signX
9750 addq.l &1,%d3
9751 mov.w SignX(%a6),%d6
9752 eor.l &0x00008000,%d6
9753 mov.w %d6,SignX(%a6)
9754 bra.w Fix_Sign
9755
9756 #########################################################################
9757 # XDEF **************************************************************** #
9758 # tag(): return the optype of the input ext fp number #
9759 # #
9760 # This routine is used by the 060FPLSP. #
9761 # #
9762 # XREF **************************************************************** #
9763 # None #
9764 # #
9765 # INPUT *************************************************************** #
9766 # a0 = pointer to extended precision operand #
9767 # #
9768 # OUTPUT ************************************************************** #
9769 # d0 = value of type tag #
9770 # one of: NORM, INF, QNAN, SNAN, DENORM, ZERO #
9771 # #
9772 # ALGORITHM *********************************************************** #
9773 # Simply test the exponent, j-bit, and mantissa values to #
9774 # determine the type of operand. #
9775 # If it's an unnormalized zero, alter the operand and force it #
9776 # to be a normal zero. #
9777 # #
9778 #########################################################################
9779
9780 global tag
9781 tag:
9782 mov.w FTEMP_EX(%a0), %d0 # extract exponent
9783 andi.w &0x7fff, %d0 # strip off sign
9784 cmpi.w %d0, &0x7fff # is (EXP == MAX)?
9785 beq.b inf_or_nan_x
9786 not_inf_or_nan_x:
9787 btst &0x7,FTEMP_HI(%a0)
9788 beq.b not_norm_x
9789 is_norm_x:
9790 mov.b &NORM, %d0
9791 rts
9792 not_norm_x:
9793 tst.w %d0 # is exponent = 0?
9794 bne.b is_unnorm_x
9795 not_unnorm_x:
9796 tst.l FTEMP_HI(%a0)
9797 bne.b is_denorm_x
9798 tst.l FTEMP_LO(%a0)
9799 bne.b is_denorm_x
9800 is_zero_x:
9801 mov.b &ZERO, %d0
9802 rts
9803 is_denorm_x:
9804 mov.b &DENORM, %d0
9805 rts
9806 is_unnorm_x:
9807 bsr.l unnorm_fix # convert to norm,denorm,or zero
9808 rts
9809 is_unnorm_reg_x:
9810 mov.b &UNNORM, %d0
9811 rts
9812 inf_or_nan_x:
9813 tst.l FTEMP_LO(%a0)
9814 bne.b is_nan_x
9815 mov.l FTEMP_HI(%a0), %d0
9816 and.l &0x7fffffff, %d0 # msb is a don't care!
9817 bne.b is_nan_x
9818 is_inf_x:
9819 mov.b &INF, %d0
9820 rts
9821 is_nan_x:
9822 mov.b &QNAN, %d0
9823 rts
9824
9825 #############################################################
9826
9827 qnan: long 0x7fff0000, 0xffffffff, 0xffffffff
9828
9829 #########################################################################
9830 # XDEF **************************************************************** #
9831 # t_dz(): Handle 060FPLSP dz exception for "flogn" emulation. #
9832 # t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation. #
9833 # #
9834 # These rouitnes are used by the 060FPLSP package. #
9835 # #
9836 # XREF **************************************************************** #
9837 # None #
9838 # #
9839 # INPUT *************************************************************** #
9840 # a0 = pointer to extended precision source operand. #
9841 # #
9842 # OUTPUT ************************************************************** #
9843 # fp0 = default DZ result. #
9844 # #
9845 # ALGORITHM *********************************************************** #
9846 # Transcendental emulation for the 060FPLSP has detected that #
9847 # a DZ exception should occur for the instruction. If DZ is disabled, #
9848 # return the default result. #
9849 # If DZ is enabled, the dst operand should be returned unscathed #
9850 # in fp0 while fp1 is used to create a DZ exception so that the #
9851 # operating system can log that such an event occurred. #
9852 # #
9853 #########################################################################
9854
9855 global t_dz
9856 t_dz:
9857 tst.b SRC_EX(%a0) # check sign for neg or pos
9858 bpl.b dz_pinf # branch if pos sign
9859
9860 global t_dz2
9861 t_dz2:
9862 ori.l &dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZ
9863
9864 btst &dz_bit,FPCR_ENABLE(%a6)
9865 bne.b dz_minf_ena
9866
9867 # dz is disabled. return a -INF.
9868 fmov.s &0xff800000,%fp0 # return -INF
9869 rts
9870
9871 # dz is enabled. create a dz exception so the user can record it
9872 # but use fp1 instead. return the dst operand unscathed in fp0.
9873 dz_minf_ena:
9874 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed
9875 fmov.l USER_FPCR(%a6),%fpcr
9876 fmov.s &0xbf800000,%fp1 # load -1
9877 fdiv.s &0x00000000,%fp1 # -1 / 0
9878 rts
9879
9880 dz_pinf:
9881 ori.l &dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZ
9882
9883 btst &dz_bit,FPCR_ENABLE(%a6)
9884 bne.b dz_pinf_ena
9885
9886 # dz is disabled. return a +INF.
9887 fmov.s &0x7f800000,%fp0 # return +INF
9888 rts
9889
9890 # dz is enabled. create a dz exception so the user can record it
9891 # but use fp1 instead. return the dst operand unscathed in fp0.
9892 dz_pinf_ena:
9893 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed
9894 fmov.l USER_FPCR(%a6),%fpcr
9895 fmov.s &0x3f800000,%fp1 # load +1
9896 fdiv.s &0x00000000,%fp1 # +1 / 0
9897 rts
9898
9899 #########################################################################
9900 # XDEF **************************************************************** #
9901 # t_operr(): Handle 060FPLSP OPERR exception during emulation. #
9902 # #
9903 # This routine is used by the 060FPLSP package. #
9904 # #
9905 # XREF **************************************************************** #
9906 # None. #
9907 # #
9908 # INPUT *************************************************************** #
9909 # fp1 = source operand #
9910 # #
9911 # OUTPUT ************************************************************** #
9912 # fp0 = default result #
9913 # fp1 = unchanged #
9914 # #
9915 # ALGORITHM *********************************************************** #
9916 # An operand error should occur as the result of transcendental #
9917 # emulation in the 060FPLSP. If OPERR is disabled, just return a NAN #
9918 # in fp0. If OPERR is enabled, return the dst operand unscathed in fp0 #
9919 # and the source operand in fp1. Use fp2 to create an OPERR exception #
9920 # so that the operating system can log the event. #
9921 # #
9922 #########################################################################
9923
9924 global t_operr
9925 t_operr:
9926 ori.l &opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOP
9927
9928 btst &operr_bit,FPCR_ENABLE(%a6)
9929 bne.b operr_ena
9930
9931 # operr is disabled. return a QNAN in fp0
9932 fmovm.x qnan(%pc),&0x80 # return QNAN
9933 rts
9934
9935 # operr is enabled. create an operr exception so the user can record it
9936 # but use fp2 instead. return the dst operand unscathed in fp0.
9937 operr_ena:
9938 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed
9939 fmov.l USER_FPCR(%a6),%fpcr
9940 fmovm.x &0x04,-(%sp) # save fp2
9941 fmov.s &0x7f800000,%fp2 # load +INF
9942 fmul.s &0x00000000,%fp2 # +INF x 0
9943 fmovm.x (%sp)+,&0x20 # restore fp2
9944 rts
9945
9946 pls_huge:
9947 long 0x7ffe0000,0xffffffff,0xffffffff
9948 mns_huge:
9949 long 0xfffe0000,0xffffffff,0xffffffff
9950 pls_tiny:
9951 long 0x00000000,0x80000000,0x00000000
9952 mns_tiny:
9953 long 0x80000000,0x80000000,0x00000000
9954
9955 #########################################################################
9956 # XDEF **************************************************************** #
9957 # t_unfl(): Handle 060FPLSP underflow exception during emulation. #
9958 # t_unfl2(): Handle 060FPLSP underflow exception during #
9959 # emulation. result always positive. #
9960 # #
9961 # This routine is used by the 060FPLSP package. #
9962 # #
9963 # XREF **************************************************************** #
9964 # None. #
9965 # #
9966 # INPUT *************************************************************** #
9967 # a0 = pointer to extended precision source operand #
9968 # #
9969 # OUTPUT ************************************************************** #
9970 # fp0 = default underflow result #
9971 # #
9972 # ALGORITHM *********************************************************** #
9973 # An underflow should occur as the result of transcendental #
9974 # emulation in the 060FPLSP. Create an underflow by using "fmul" #
9975 # and two very small numbers of appropriate sign so that the operating #
9976 # system can log the event. #
9977 # #
9978 #########################################################################
9979
9980 global t_unfl
9981 t_unfl:
9982 tst.b SRC_EX(%a0)
9983 bpl.b unf_pos
9984
9985 global t_unfl2
9986 t_unfl2:
9987 ori.l &unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEX
9988
9989 fmov.l USER_FPCR(%a6),%fpcr
9990 fmovm.x mns_tiny(%pc),&0x80
9991 fmul.x pls_tiny(%pc),%fp0
9992
9993 fmov.l %fpsr,%d0
9994 rol.l &0x8,%d0
9995 mov.b %d0,FPSR_CC(%a6)
9996 rts
9997 unf_pos:
9998 ori.w &unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEX
9999
10000 fmov.l USER_FPCR(%a6),%fpcr
10001 fmovm.x pls_tiny(%pc),&0x80
10002 fmul.x %fp0,%fp0
10003
10004 fmov.l %fpsr,%d0
10005 rol.l &0x8,%d0
10006 mov.b %d0,FPSR_CC(%a6)
10007 rts
10008
10009 #########################################################################
10010 # XDEF **************************************************************** #
10011 # t_ovfl(): Handle 060FPLSP overflow exception during emulation. #
10012 # (monadic) #
10013 # t_ovfl2(): Handle 060FPLSP overflow exception during #
10014 # emulation. result always positive. (dyadic) #
10015 # t_ovfl_sc(): Handle 060FPLSP overflow exception during #
10016 # emulation for "fscale". #
10017 # #
10018 # This routine is used by the 060FPLSP package. #
10019 # #
10020 # XREF **************************************************************** #
10021 # None. #
10022 # #
10023 # INPUT *************************************************************** #
10024 # a0 = pointer to extended precision source operand #
10025 # #
10026 # OUTPUT ************************************************************** #
10027 # fp0 = default underflow result #
10028 # #
10029 # ALGORITHM *********************************************************** #
10030 # An overflow should occur as the result of transcendental #
10031 # emulation in the 060FPLSP. Create an overflow by using "fmul" #
10032 # and two very lareg numbers of appropriate sign so that the operating #
10033 # system can log the event. #
10034 # For t_ovfl_sc() we take special care not to lose the INEX2 bit. #
10035 # #
10036 #########################################################################
10037
10038 global t_ovfl_sc
10039 t_ovfl_sc:
10040 ori.l &ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEX
10041
10042 mov.b %d0,%d1 # fetch rnd prec,mode
10043 andi.b &0xc0,%d1 # extract prec
10044 beq.w ovfl_work
10045
10046 # dst op is a DENORM. we have to normalize the mantissa to see if the
10047 # result would be inexact for the given precision. make a copy of the
10048 # dst so we don't screw up the version passed to us.
10049 mov.w LOCAL_EX(%a0),FP_SCR0_EX(%a6)
10050 mov.l LOCAL_HI(%a0),FP_SCR0_HI(%a6)
10051 mov.l LOCAL_LO(%a0),FP_SCR0_LO(%a6)
10052 lea FP_SCR0(%a6),%a0 # pass ptr to FP_SCR0
10053 movm.l &0xc080,-(%sp) # save d0-d1/a0
10054 bsr.l norm # normalize mantissa
10055 movm.l (%sp)+,&0x0103 # restore d0-d1/a0
10056
10057 cmpi.b %d1,&0x40 # is precision sgl?
10058 bne.b ovfl_sc_dbl # no; dbl
10059 ovfl_sc_sgl:
10060 tst.l LOCAL_LO(%a0) # is lo lw of sgl set?
10061 bne.b ovfl_sc_inx # yes
10062 tst.b 3+LOCAL_HI(%a0) # is lo byte of hi lw set?
10063 bne.b ovfl_sc_inx # yes
10064 bra.w ovfl_work # don't set INEX2
10065 ovfl_sc_dbl:
10066 mov.l LOCAL_LO(%a0),%d1 # are any of lo 11 bits of
10067 andi.l &0x7ff,%d1 # dbl mantissa set?
10068 beq.w ovfl_work # no; don't set INEX2
10069 ovfl_sc_inx:
10070 ori.l &inex2_mask,USER_FPSR(%a6) # set INEX2
10071 bra.b ovfl_work # continue
10072
10073 global t_ovfl
10074 t_ovfl:
10075 ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
10076 ovfl_work:
10077 tst.b SRC_EX(%a0)
10078 bpl.b ovfl_p
10079 ovfl_m:
10080 fmov.l USER_FPCR(%a6),%fpcr
10081 fmovm.x mns_huge(%pc),&0x80
10082 fmul.x pls_huge(%pc),%fp0
10083
10084 fmov.l %fpsr,%d0
10085 rol.l &0x8,%d0
10086 ori.b &neg_mask,%d0
10087 mov.b %d0,FPSR_CC(%a6)
10088 rts
10089 ovfl_p:
10090 fmov.l USER_FPCR(%a6),%fpcr
10091 fmovm.x pls_huge(%pc),&0x80
10092 fmul.x pls_huge(%pc),%fp0
10093
10094 fmov.l %fpsr,%d0
10095 rol.l &0x8,%d0
10096 mov.b %d0,FPSR_CC(%a6)
10097 rts
10098
10099 global t_ovfl2
10100 t_ovfl2:
10101 ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
10102 fmov.l USER_FPCR(%a6),%fpcr
10103 fmovm.x pls_huge(%pc),&0x80
10104 fmul.x pls_huge(%pc),%fp0
10105
10106 fmov.l %fpsr,%d0
10107 rol.l &0x8,%d0
10108 mov.b %d0,FPSR_CC(%a6)
10109 rts
10110
10111 #########################################################################
10112 # XDEF **************************************************************** #
10113 # t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during #
10114 # emulation. #
10115 # t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during #
10116 # emulation. #
10117 # #
10118 # These routines are used by the 060FPLSP package. #
10119 # #
10120 # XREF **************************************************************** #
10121 # None. #
10122 # #
10123 # INPUT *************************************************************** #
10124 # fp0 = default underflow or overflow result #
10125 # #
10126 # OUTPUT ************************************************************** #
10127 # fp0 = default result #
10128 # #
10129 # ALGORITHM *********************************************************** #
10130 # If an overflow or underflow occurred during the last #
10131 # instruction of transcendental 060FPLSP emulation, then it has already #
10132 # occurred and has been logged. Now we need to see if an inexact #
10133 # exception should occur. #
10134 # #
10135 #########################################################################
10136
10137 global t_catch2
10138 t_catch2:
10139 fmov.l %fpsr,%d0
10140 or.l %d0,USER_FPSR(%a6)
10141 bra.b inx2_work
10142
10143 global t_catch
10144 t_catch:
10145 fmov.l %fpsr,%d0
10146 or.l %d0,USER_FPSR(%a6)
10147
10148 #########################################################################
10149 # XDEF **************************************************************** #
10150 # t_inx2(): Handle inexact 060FPLSP exception during emulation. #
10151 # t_pinx2(): Handle inexact 060FPLSP exception for "+" results. #
10152 # t_minx2(): Handle inexact 060FPLSP exception for "-" results. #
10153 # #
10154 # XREF **************************************************************** #
10155 # None. #
10156 # #
10157 # INPUT *************************************************************** #
10158 # fp0 = default result #
10159 # #
10160 # OUTPUT ************************************************************** #
10161 # fp0 = default result #
10162 # #
10163 # ALGORITHM *********************************************************** #
10164 # The last instruction of transcendental emulation for the #
10165 # 060FPLSP should be inexact. So, if inexact is enabled, then we create #
10166 # the event here by adding a large and very small number together #
10167 # so that the operating system can log the event. #
10168 # Must check, too, if the result was zero, in which case we just #
10169 # set the FPSR bits and return. #
10170 # #
10171 #########################################################################
10172
10173 global t_inx2
10174 t_inx2:
10175 fblt.w t_minx2
10176 fbeq.w inx2_zero
10177
10178 global t_pinx2
10179 t_pinx2:
10180 ori.w &inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX
10181 bra.b inx2_work
10182
10183 global t_minx2
10184 t_minx2:
10185 ori.l &inx2a_mask+neg_mask,USER_FPSR(%a6)
10186
10187 inx2_work:
10188 btst &inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?
10189 bne.b inx2_work_ena # yes
10190 rts
10191 inx2_work_ena:
10192 fmov.l USER_FPCR(%a6),%fpcr # insert user's exceptions
10193 fmov.s &0x3f800000,%fp1 # load +1
10194 fadd.x pls_tiny(%pc),%fp1 # cause exception
10195 rts
10196
10197 inx2_zero:
10198 mov.b &z_bmask,FPSR_CC(%a6)
10199 ori.w &inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEX
10200 rts
10201
10202 #########################################################################
10203 # XDEF **************************************************************** #
10204 # t_extdnrm(): Handle DENORM inputs in 060FPLSP. #
10205 # t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale". #
10206 # #
10207 # This routine is used by the 060FPLSP package. #
10208 # #
10209 # XREF **************************************************************** #
10210 # None. #
10211 # #
10212 # INPUT *************************************************************** #
10213 # a0 = pointer to extended precision input operand #
10214 # #
10215 # OUTPUT ************************************************************** #
10216 # fp0 = default result #
10217 # #
10218 # ALGORITHM *********************************************************** #
10219 # For all functions that have a denormalized input and that #
10220 # f(x)=x, this is the entry point. #
10221 # DENORM value is moved using "fmove" which triggers an exception #
10222 # if enabled so the operating system can log the event. #
10223 # #
10224 #########################################################################
10225
10226 global t_extdnrm
10227 t_extdnrm:
10228 fmov.l USER_FPCR(%a6),%fpcr
10229 fmov.x SRC_EX(%a0),%fp0
10230 fmov.l %fpsr,%d0
10231 ori.l &unfinx_mask,%d0
10232 or.l %d0,USER_FPSR(%a6)
10233 rts
10234
10235 global t_resdnrm
10236 t_resdnrm:
10237 fmov.l USER_FPCR(%a6),%fpcr
10238 fmov.x SRC_EX(%a0),%fp0
10239 fmov.l %fpsr,%d0
10240 or.l %d0,USER_FPSR(%a6)
10241 rts
10242
10243 ##########################################
10244
10245 #
10246 # sto_cos:
10247 # This is used by fsincos library emulation. The correct
10248 # values are already in fp0 and fp1 so we do nothing here.
10249 #
10250 global sto_cos
10251 sto_cos:
10252 rts
10253
10254 ##########################################
10255
10256 #
10257 # dst_qnan --- force result when destination is a NaN
10258 #
10259 global dst_qnan
10260 dst_qnan:
10261 fmov.x DST(%a1),%fp0
10262 tst.b DST_EX(%a1)
10263 bmi.b dst_qnan_m
10264 dst_qnan_p:
10265 mov.b &nan_bmask,FPSR_CC(%a6)
10266 rts
10267 dst_qnan_m:
10268 mov.b &nan_bmask+neg_bmask,FPSR_CC(%a6)
10269 rts
10270
10271 #
10272 # src_qnan --- force result when source is a NaN
10273 #
10274 global src_qnan
10275 src_qnan:
10276 fmov.x SRC(%a0),%fp0
10277 tst.b SRC_EX(%a0)
10278 bmi.b src_qnan_m
10279 src_qnan_p:
10280 mov.b &nan_bmask,FPSR_CC(%a6)
10281 rts
10282 src_qnan_m:
10283 mov.b &nan_bmask+neg_bmask,FPSR_CC(%a6)
10284 rts
10285
10286 ##########################################
10287
10288 #
10289 # Native instruction support
10290 #
10291 # Some systems may need entry points even for 68060 native
10292 # instructions. These routines are provided for
10293 # convenience.
10294 #
10295 global _fadds_
10296 _fadds_:
10297 fmov.l %fpcr,-(%sp) # save fpcr
10298 fmov.l &0x00000000,%fpcr # clear fpcr for load
10299 fmov.s 0x8(%sp),%fp0 # load sgl dst
10300 fmov.l (%sp)+,%fpcr # restore fpcr
10301 fadd.s 0x8(%sp),%fp0 # fadd w/ sgl src
10302 rts
10303
10304 global _faddd_
10305 _faddd_:
10306 fmov.l %fpcr,-(%sp) # save fpcr
10307 fmov.l &0x00000000,%fpcr # clear fpcr for load
10308 fmov.d 0x8(%sp),%fp0 # load dbl dst
10309 fmov.l (%sp)+,%fpcr # restore fpcr
10310 fadd.d 0xc(%sp),%fp0 # fadd w/ dbl src
10311 rts
10312
10313 global _faddx_
10314 _faddx_:
10315 fmovm.x 0x4(%sp),&0x80 # load ext dst
10316 fadd.x 0x10(%sp),%fp0 # fadd w/ ext src
10317 rts
10318
10319 global _fsubs_
10320 _fsubs_:
10321 fmov.l %fpcr,-(%sp) # save fpcr
10322 fmov.l &0x00000000,%fpcr # clear fpcr for load
10323 fmov.s 0x8(%sp),%fp0 # load sgl dst
10324 fmov.l (%sp)+,%fpcr # restore fpcr
10325 fsub.s 0x8(%sp),%fp0 # fsub w/ sgl src
10326 rts
10327
10328 global _fsubd_
10329 _fsubd_:
10330 fmov.l %fpcr,-(%sp) # save fpcr
10331 fmov.l &0x00000000,%fpcr # clear fpcr for load
10332 fmov.d 0x8(%sp),%fp0 # load dbl dst
10333 fmov.l (%sp)+,%fpcr # restore fpcr
10334 fsub.d 0xc(%sp),%fp0 # fsub w/ dbl src
10335 rts
10336
10337 global _fsubx_
10338 _fsubx_:
10339 fmovm.x 0x4(%sp),&0x80 # load ext dst
10340 fsub.x 0x10(%sp),%fp0 # fsub w/ ext src
10341 rts
10342
10343 global _fmuls_
10344 _fmuls_:
10345 fmov.l %fpcr,-(%sp) # save fpcr
10346 fmov.l &0x00000000,%fpcr # clear fpcr for load
10347 fmov.s 0x8(%sp),%fp0 # load sgl dst
10348 fmov.l (%sp)+,%fpcr # restore fpcr
10349 fmul.s 0x8(%sp),%fp0 # fmul w/ sgl src
10350 rts
10351
10352 global _fmuld_
10353 _fmuld_:
10354 fmov.l %fpcr,-(%sp) # save fpcr
10355 fmov.l &0x00000000,%fpcr # clear fpcr for load
10356 fmov.d 0x8(%sp),%fp0 # load dbl dst
10357 fmov.l (%sp)+,%fpcr # restore fpcr
10358 fmul.d 0xc(%sp),%fp0 # fmul w/ dbl src
10359 rts
10360
10361 global _fmulx_
10362 _fmulx_:
10363 fmovm.x 0x4(%sp),&0x80 # load ext dst
10364 fmul.x 0x10(%sp),%fp0 # fmul w/ ext src
10365 rts
10366
10367 global _fdivs_
10368 _fdivs_:
10369 fmov.l %fpcr,-(%sp) # save fpcr
10370 fmov.l &0x00000000,%fpcr # clear fpcr for load
10371 fmov.s 0x8(%sp),%fp0 # load sgl dst
10372 fmov.l (%sp)+,%fpcr # restore fpcr
10373 fdiv.s 0x8(%sp),%fp0 # fdiv w/ sgl src
10374 rts
10375
10376 global _fdivd_
10377 _fdivd_:
10378 fmov.l %fpcr,-(%sp) # save fpcr
10379 fmov.l &0x00000000,%fpcr # clear fpcr for load
10380 fmov.d 0x8(%sp),%fp0 # load dbl dst
10381 fmov.l (%sp)+,%fpcr # restore fpcr
10382 fdiv.d 0xc(%sp),%fp0 # fdiv w/ dbl src
10383 rts
10384
10385 global _fdivx_
10386 _fdivx_:
10387 fmovm.x 0x4(%sp),&0x80 # load ext dst
10388 fdiv.x 0x10(%sp),%fp0 # fdiv w/ ext src
10389 rts
10390
10391 global _fabss_
10392 _fabss_:
10393 fabs.s 0x4(%sp),%fp0 # fabs w/ sgl src
10394 rts
10395
10396 global _fabsd_
10397 _fabsd_:
10398 fabs.d 0x4(%sp),%fp0 # fabs w/ dbl src
10399 rts
10400
10401 global _fabsx_
10402 _fabsx_:
10403 fabs.x 0x4(%sp),%fp0 # fabs w/ ext src
10404 rts
10405
10406 global _fnegs_
10407 _fnegs_:
10408 fneg.s 0x4(%sp),%fp0 # fneg w/ sgl src
10409 rts
10410
10411 global _fnegd_
10412 _fnegd_:
10413 fneg.d 0x4(%sp),%fp0 # fneg w/ dbl src
10414 rts
10415
10416 global _fnegx_
10417 _fnegx_:
10418 fneg.x 0x4(%sp),%fp0 # fneg w/ ext src
10419 rts
10420
10421 global _fsqrts_
10422 _fsqrts_:
10423 fsqrt.s 0x4(%sp),%fp0 # fsqrt w/ sgl src
10424 rts
10425
10426 global _fsqrtd_
10427 _fsqrtd_:
10428 fsqrt.d 0x4(%sp),%fp0 # fsqrt w/ dbl src
10429 rts
10430
10431 global _fsqrtx_
10432 _fsqrtx_:
10433 fsqrt.x 0x4(%sp),%fp0 # fsqrt w/ ext src
10434 rts
10435
10436 global _fints_
10437 _fints_:
10438 fint.s 0x4(%sp),%fp0 # fint w/ sgl src
10439 rts
10440
10441 global _fintd_
10442 _fintd_:
10443 fint.d 0x4(%sp),%fp0 # fint w/ dbl src
10444 rts
10445
10446 global _fintx_
10447 _fintx_:
10448 fint.x 0x4(%sp),%fp0 # fint w/ ext src
10449 rts
10450
10451 global _fintrzs_
10452 _fintrzs_:
10453 fintrz.s 0x4(%sp),%fp0 # fintrz w/ sgl src
10454 rts
10455
10456 global _fintrzd_
10457 _fintrzd_:
10458 fintrz.d 0x4(%sp),%fp0 # fintrx w/ dbl src
10459 rts
10460
10461 global _fintrzx_
10462 _fintrzx_:
10463 fintrz.x 0x4(%sp),%fp0 # fintrz w/ ext src
10464 rts
10465
10466 ########################################################################
10467
10468 #########################################################################
10469 # src_zero(): Return signed zero according to sign of src operand. #
10470 #########################################################################
10471 global src_zero
10472 src_zero:
10473 tst.b SRC_EX(%a0) # get sign of src operand
10474 bmi.b ld_mzero # if neg, load neg zero
10475
10476 #
10477 # ld_pzero(): return a positive zero.
10478 #
10479 global ld_pzero
10480 ld_pzero:
10481 fmov.s &0x00000000,%fp0 # load +0
10482 mov.b &z_bmask,FPSR_CC(%a6) # set 'Z' ccode bit
10483 rts
10484
10485 # ld_mzero(): return a negative zero.
10486 global ld_mzero
10487 ld_mzero:
10488 fmov.s &0x80000000,%fp0 # load -0
10489 mov.b &neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bits
10490 rts
10491
10492 #########################################################################
10493 # dst_zero(): Return signed zero according to sign of dst operand. #
10494 #########################################################################
10495 global dst_zero
10496 dst_zero:
10497 tst.b DST_EX(%a1) # get sign of dst operand
10498 bmi.b ld_mzero # if neg, load neg zero
10499 bra.b ld_pzero # load positive zero
10500
10501 #########################################################################
10502 # src_inf(): Return signed inf according to sign of src operand. #
10503 #########################################################################
10504 global src_inf
10505 src_inf:
10506 tst.b SRC_EX(%a0) # get sign of src operand
10507 bmi.b ld_minf # if negative branch
10508
10509 #
10510 # ld_pinf(): return a positive infinity.
10511 #
10512 global ld_pinf
10513 ld_pinf:
10514 fmov.s &0x7f800000,%fp0 # load +INF
10515 mov.b &inf_bmask,FPSR_CC(%a6) # set 'INF' ccode bit
10516 rts
10517
10518 #
10519 # ld_minf():return a negative infinity.
10520 #
10521 global ld_minf
10522 ld_minf:
10523 fmov.s &0xff800000,%fp0 # load -INF
10524 mov.b &neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bits
10525 rts
10526
10527 #########################################################################
10528 # dst_inf(): Return signed inf according to sign of dst operand. #
10529 #########################################################################
10530 global dst_inf
10531 dst_inf:
10532 tst.b DST_EX(%a1) # get sign of dst operand
10533 bmi.b ld_minf # if negative branch
10534 bra.b ld_pinf
10535
10536 global szr_inf
10537 #################################################################
10538 # szr_inf(): Return +ZERO for a negative src operand or #
10539 # +INF for a positive src operand. #
10540 # Routine used for fetox, ftwotox, and ftentox. #
10541 #################################################################
10542 szr_inf:
10543 tst.b SRC_EX(%a0) # check sign of source
10544 bmi.b ld_pzero
10545 bra.b ld_pinf
10546
10547 #########################################################################
10548 # sopr_inf(): Return +INF for a positive src operand or #
10549 # jump to operand error routine for a negative src operand. #
10550 # Routine used for flogn, flognp1, flog10, and flog2. #
10551 #########################################################################
10552 global sopr_inf
10553 sopr_inf:
10554 tst.b SRC_EX(%a0) # check sign of source
10555 bmi.w t_operr
10556 bra.b ld_pinf
10557
10558 #################################################################
10559 # setoxm1i(): Return minus one for a negative src operand or #
10560 # positive infinity for a positive src operand. #
10561 # Routine used for fetoxm1. #
10562 #################################################################
10563 global setoxm1i
10564 setoxm1i:
10565 tst.b SRC_EX(%a0) # check sign of source
10566 bmi.b ld_mone
10567 bra.b ld_pinf
10568
10569 #########################################################################
10570 # src_one(): Return signed one according to sign of src operand. #
10571 #########################################################################
10572 global src_one
10573 src_one:
10574 tst.b SRC_EX(%a0) # check sign of source
10575 bmi.b ld_mone
10576
10577 #
10578 # ld_pone(): return positive one.
10579 #
10580 global ld_pone
10581 ld_pone:
10582 fmov.s &0x3f800000,%fp0 # load +1
10583 clr.b FPSR_CC(%a6)
10584 rts
10585
10586 #
10587 # ld_mone(): return negative one.
10588 #
10589 global ld_mone
10590 ld_mone:
10591 fmov.s &0xbf800000,%fp0 # load -1
10592 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
10593 rts
10594
10595 ppiby2: long 0x3fff0000, 0xc90fdaa2, 0x2168c235
10596 mpiby2: long 0xbfff0000, 0xc90fdaa2, 0x2168c235
10597
10598 #################################################################
10599 # spi_2(): Return signed PI/2 according to sign of src operand. #
10600 #################################################################
10601 global spi_2
10602 spi_2:
10603 tst.b SRC_EX(%a0) # check sign of source
10604 bmi.b ld_mpi2
10605
10606 #
10607 # ld_ppi2(): return positive PI/2.
10608 #
10609 global ld_ppi2
10610 ld_ppi2:
10611 fmov.l %d0,%fpcr
10612 fmov.x ppiby2(%pc),%fp0 # load +pi/2
10613 bra.w t_pinx2 # set INEX2
10614
10615 #
10616 # ld_mpi2(): return negative PI/2.
10617 #
10618 global ld_mpi2
10619 ld_mpi2:
10620 fmov.l %d0,%fpcr
10621 fmov.x mpiby2(%pc),%fp0 # load -pi/2
10622 bra.w t_minx2 # set INEX2
10623
10624 ####################################################
10625 # The following routines give support for fsincos. #
10626 ####################################################
10627
10628 #
10629 # ssincosz(): When the src operand is ZERO, store a one in the
10630 # cosine register and return a ZERO in fp0 w/ the same sign
10631 # as the src operand.
10632 #
10633 global ssincosz
10634 ssincosz:
10635 fmov.s &0x3f800000,%fp1
10636 tst.b SRC_EX(%a0) # test sign
10637 bpl.b sincoszp
10638 fmov.s &0x80000000,%fp0 # return sin result in fp0
10639 mov.b &z_bmask+neg_bmask,FPSR_CC(%a6)
10640 rts
10641 sincoszp:
10642 fmov.s &0x00000000,%fp0 # return sin result in fp0
10643 mov.b &z_bmask,FPSR_CC(%a6)
10644 rts
10645
10646 #
10647 # ssincosi(): When the src operand is INF, store a QNAN in the cosine
10648 # register and jump to the operand error routine for negative
10649 # src operands.
10650 #
10651 global ssincosi
10652 ssincosi:
10653 fmov.x qnan(%pc),%fp1 # load NAN
10654 bra.w t_operr
10655
10656 #
10657 # ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine
10658 # register and branch to the src QNAN routine.
10659 #
10660 global ssincosqnan
10661 ssincosqnan:
10662 fmov.x LOCAL_EX(%a0),%fp1
10663 bra.w src_qnan
10664
10665 ########################################################################
10666
10667 global smod_sdnrm
10668 global smod_snorm
10669 smod_sdnrm:
10670 smod_snorm:
10671 mov.b DTAG(%a6),%d1
10672 beq.l smod
10673 cmpi.b %d1,&ZERO
10674 beq.w smod_zro
10675 cmpi.b %d1,&INF
10676 beq.l t_operr
10677 cmpi.b %d1,&DENORM
10678 beq.l smod
10679 bra.l dst_qnan
10680
10681 global smod_szero
10682 smod_szero:
10683 mov.b DTAG(%a6),%d1
10684 beq.l t_operr
10685 cmpi.b %d1,&ZERO
10686 beq.l t_operr
10687 cmpi.b %d1,&INF
10688 beq.l t_operr
10689 cmpi.b %d1,&DENORM
10690 beq.l t_operr
10691 bra.l dst_qnan
10692
10693 global smod_sinf
10694 smod_sinf:
10695 mov.b DTAG(%a6),%d1
10696 beq.l smod_fpn
10697 cmpi.b %d1,&ZERO
10698 beq.l smod_zro
10699 cmpi.b %d1,&INF
10700 beq.l t_operr
10701 cmpi.b %d1,&DENORM
10702 beq.l smod_fpn
10703 bra.l dst_qnan
10704
10705 smod_zro:
10706 srem_zro:
10707 mov.b SRC_EX(%a0),%d1 # get src sign
10708 mov.b DST_EX(%a1),%d0 # get dst sign
10709 eor.b %d0,%d1 # get qbyte sign
10710 andi.b &0x80,%d1
10711 mov.b %d1,FPSR_QBYTE(%a6)
10712 tst.b %d0
10713 bpl.w ld_pzero
10714 bra.w ld_mzero
10715
10716 smod_fpn:
10717 srem_fpn:
10718 clr.b FPSR_QBYTE(%a6)
10719 mov.l %d0,-(%sp)
10720 mov.b SRC_EX(%a0),%d1 # get src sign
10721 mov.b DST_EX(%a1),%d0 # get dst sign
10722 eor.b %d0,%d1 # get qbyte sign
10723 andi.b &0x80,%d1
10724 mov.b %d1,FPSR_QBYTE(%a6)
10725 cmpi.b DTAG(%a6),&DENORM
10726 bne.b smod_nrm
10727 lea DST(%a1),%a0
10728 mov.l (%sp)+,%d0
10729 bra t_resdnrm
10730 smod_nrm:
10731 fmov.l (%sp)+,%fpcr
10732 fmov.x DST(%a1),%fp0
10733 tst.b DST_EX(%a1)
10734 bmi.b smod_nrm_neg
10735 rts
10736
10737 smod_nrm_neg:
10738 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' code
10739 rts
10740
10741 #########################################################################
10742 global srem_snorm
10743 global srem_sdnrm
10744 srem_sdnrm:
10745 srem_snorm:
10746 mov.b DTAG(%a6),%d1
10747 beq.l srem
10748 cmpi.b %d1,&ZERO
10749 beq.w srem_zro
10750 cmpi.b %d1,&INF
10751 beq.l t_operr
10752 cmpi.b %d1,&DENORM
10753 beq.l srem
10754 bra.l dst_qnan
10755
10756 global srem_szero
10757 srem_szero:
10758 mov.b DTAG(%a6),%d1
10759 beq.l t_operr
10760 cmpi.b %d1,&ZERO
10761 beq.l t_operr
10762 cmpi.b %d1,&INF
10763 beq.l t_operr
10764 cmpi.b %d1,&DENORM
10765 beq.l t_operr
10766 bra.l dst_qnan
10767
10768 global srem_sinf
10769 srem_sinf:
10770 mov.b DTAG(%a6),%d1
10771 beq.w srem_fpn
10772 cmpi.b %d1,&ZERO
10773 beq.w srem_zro
10774 cmpi.b %d1,&INF
10775 beq.l t_operr
10776 cmpi.b %d1,&DENORM
10777 beq.l srem_fpn
10778 bra.l dst_qnan
10779
10780 #########################################################################
10781
10782 global sscale_snorm
10783 global sscale_sdnrm
10784 sscale_snorm:
10785 sscale_sdnrm:
10786 mov.b DTAG(%a6),%d1
10787 beq.l sscale
10788 cmpi.b %d1,&ZERO
10789 beq.l dst_zero
10790 cmpi.b %d1,&INF
10791 beq.l dst_inf
10792 cmpi.b %d1,&DENORM
10793 beq.l sscale
10794 bra.l dst_qnan
10795
10796 global sscale_szero
10797 sscale_szero:
10798 mov.b DTAG(%a6),%d1
10799 beq.l sscale
10800 cmpi.b %d1,&ZERO
10801 beq.l dst_zero
10802 cmpi.b %d1,&INF
10803 beq.l dst_inf
10804 cmpi.b %d1,&DENORM
10805 beq.l sscale
10806 bra.l dst_qnan
10807
10808 global sscale_sinf
10809 sscale_sinf:
10810 mov.b DTAG(%a6),%d1
10811 beq.l t_operr
10812 cmpi.b %d1,&QNAN
10813 beq.l dst_qnan
10814 bra.l t_operr
10815
10816 ########################################################################
10817
10818 global sop_sqnan
10819 sop_sqnan:
10820 mov.b DTAG(%a6),%d1
10821 cmpi.b %d1,&QNAN
10822 beq.l dst_qnan
10823 bra.l src_qnan
10824
10825 #########################################################################
10826 # norm(): normalize the mantissa of an extended precision input. the #
10827 # input operand should not be normalized already. #
10828 # #
10829 # XDEF **************************************************************** #
10830 # norm() #
10831 # #
10832 # XREF **************************************************************** #
10833 # none #
10834 # #
10835 # INPUT *************************************************************** #
10836 # a0 = pointer fp extended precision operand to normalize #
10837 # #
10838 # OUTPUT ************************************************************** #
10839 # d0 = number of bit positions the mantissa was shifted #
10840 # a0 = the input operand's mantissa is normalized; the exponent #
10841 # is unchanged. #
10842 # #
10843 #########################################################################
10844 global norm
10845 norm:
10846 mov.l %d2, -(%sp) # create some temp regs
10847 mov.l %d3, -(%sp)
10848
10849 mov.l FTEMP_HI(%a0), %d0 # load hi(mantissa)
10850 mov.l FTEMP_LO(%a0), %d1 # load lo(mantissa)
10851
10852 bfffo %d0{&0:&32}, %d2 # how many places to shift?
10853 beq.b norm_lo # hi(man) is all zeroes!
10854
10855 norm_hi:
10856 lsl.l %d2, %d0 # left shift hi(man)
10857 bfextu %d1{&0:%d2}, %d3 # extract lo bits
10858
10859 or.l %d3, %d0 # create hi(man)
10860 lsl.l %d2, %d1 # create lo(man)
10861
10862 mov.l %d0, FTEMP_HI(%a0) # store new hi(man)
10863 mov.l %d1, FTEMP_LO(%a0) # store new lo(man)
10864
10865 mov.l %d2, %d0 # return shift amount
10866
10867 mov.l (%sp)+, %d3 # restore temp regs
10868 mov.l (%sp)+, %d2
10869
10870 rts
10871
10872 norm_lo:
10873 bfffo %d1{&0:&32}, %d2 # how many places to shift?
10874 lsl.l %d2, %d1 # shift lo(man)
10875 add.l &32, %d2 # add 32 to shft amount
10876
10877 mov.l %d1, FTEMP_HI(%a0) # store hi(man)
10878 clr.l FTEMP_LO(%a0) # lo(man) is now zero
10879
10880 mov.l %d2, %d0 # return shift amount
10881
10882 mov.l (%sp)+, %d3 # restore temp regs
10883 mov.l (%sp)+, %d2
10884
10885 rts
10886
10887 #########################################################################
10888 # unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO #
10889 # - returns corresponding optype tag #
10890 # #
10891 # XDEF **************************************************************** #
10892 # unnorm_fix() #
10893 # #
10894 # XREF **************************************************************** #
10895 # norm() - normalize the mantissa #
10896 # #
10897 # INPUT *************************************************************** #
10898 # a0 = pointer to unnormalized extended precision number #
10899 # #
10900 # OUTPUT ************************************************************** #
10901 # d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO #
10902 # a0 = input operand has been converted to a norm, denorm, or #
10903 # zero; both the exponent and mantissa are changed. #
10904 # #
10905 #########################################################################
10906
10907 global unnorm_fix
10908 unnorm_fix:
10909 bfffo FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed?
10910 bne.b unnorm_shift # hi(man) is not all zeroes
10911
10912 #
10913 # hi(man) is all zeroes so see if any bits in lo(man) are set
10914 #
10915 unnorm_chk_lo:
10916 bfffo FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?
10917 beq.w unnorm_zero # yes
10918
10919 add.w &32, %d0 # no; fix shift distance
10920
10921 #
10922 # d0 = # shifts needed for complete normalization
10923 #
10924 unnorm_shift:
10925 clr.l %d1 # clear top word
10926 mov.w FTEMP_EX(%a0), %d1 # extract exponent
10927 and.w &0x7fff, %d1 # strip off sgn
10928
10929 cmp.w %d0, %d1 # will denorm push exp < 0?
10930 bgt.b unnorm_nrm_zero # yes; denorm only until exp = 0
10931
10932 #
10933 # exponent would not go < 0. therefore, number stays normalized
10934 #
10935 sub.w %d0, %d1 # shift exponent value
10936 mov.w FTEMP_EX(%a0), %d0 # load old exponent
10937 and.w &0x8000, %d0 # save old sign
10938 or.w %d0, %d1 # {sgn,new exp}
10939 mov.w %d1, FTEMP_EX(%a0) # insert new exponent
10940
10941 bsr.l norm # normalize UNNORM
10942
10943 mov.b &NORM, %d0 # return new optype tag
10944 rts
10945
10946 #
10947 # exponent would go < 0, so only denormalize until exp = 0
10948 #
10949 unnorm_nrm_zero:
10950 cmp.b %d1, &32 # is exp <= 32?
10951 bgt.b unnorm_nrm_zero_lrg # no; go handle large exponent
10952
10953 bfextu FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man)
10954 mov.l %d0, FTEMP_HI(%a0) # save new hi(man)
10955
10956 mov.l FTEMP_LO(%a0), %d0 # fetch old lo(man)
10957 lsl.l %d1, %d0 # extract new lo(man)
10958 mov.l %d0, FTEMP_LO(%a0) # save new lo(man)
10959
10960 and.w &0x8000, FTEMP_EX(%a0) # set exp = 0
10961
10962 mov.b &DENORM, %d0 # return new optype tag
10963 rts
10964
10965 #
10966 # only mantissa bits set are in lo(man)
10967 #
10968 unnorm_nrm_zero_lrg:
10969 sub.w &32, %d1 # adjust shft amt by 32
10970
10971 mov.l FTEMP_LO(%a0), %d0 # fetch old lo(man)
10972 lsl.l %d1, %d0 # left shift lo(man)
10973
10974 mov.l %d0, FTEMP_HI(%a0) # store new hi(man)
10975 clr.l FTEMP_LO(%a0) # lo(man) = 0
10976
10977 and.w &0x8000, FTEMP_EX(%a0) # set exp = 0
10978
10979 mov.b &DENORM, %d0 # return new optype tag
10980 rts
10981
10982 #
10983 # whole mantissa is zero so this UNNORM is actually a zero
10984 #
10985 unnorm_zero:
10986 and.w &0x8000, FTEMP_EX(%a0) # force exponent to zero
10987
10988 mov.b &ZERO, %d0 # fix optype tag
10989 rts
Mirror of AROS' svn.