1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2 MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP 3 M68000 Hi-Performance Microprocessor Division 4 M68060 Software Package 5 Production Release P1.00 -- October 10, 1994 6 7 M68060 Software Package Copyright © 1993, 1994 Motorola Inc. All rights reserved. 8 9 THE SOFTWARE is provided on an "AS IS" basis and without warranty. 10 To the maximum extent permitted by applicable law, 11 MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, 12 INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE 13 and any warranty against infringement with regard to the SOFTWARE 14 (INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials. 15 16 To the maximum extent permitted by applicable law, 17 IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER 18 (INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, 19 BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) 20 ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE. 21 Motorola assumes no responsibility for the maintenance and support of the SOFTWARE. 22 23 You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE 24 so long as this entire notice is retained without alteration in any modified and/or 25 redistributed versions, and that such modified versions are clearly identified as such. 26 No licenses are granted by implication, estoppel or otherwise under any patents 27 or trademarks of Motorola, Inc. 28 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 29 # 30 # lfptop.s: 31 # This file is appended to the top of the 060ILSP package 32 # and contains the entry points into the package. The user, in 33 # effect, branches to one of the branch table entries located here. 34 # 35 36 bra.l _facoss_ 37 short 0x0000 38 bra.l _facosd_ 39 short 0x0000 40 bra.l _facosx_ 41 short 0x0000 42 43 bra.l _fasins_ 44 short 0x0000 45 bra.l _fasind_ 46 short 0x0000 47 bra.l _fasinx_ 48 short 0x0000 49 50 bra.l _fatans_ 51 short 0x0000 52 bra.l _fatand_ 53 short 0x0000 54 bra.l _fatanx_ 55 short 0x0000 56 57 bra.l _fatanhs_ 58 short 0x0000 59 bra.l _fatanhd_ 60 short 0x0000 61 bra.l _fatanhx_ 62 short 0x0000 63 64 bra.l _fcoss_ 65 short 0x0000 66 bra.l _fcosd_ 67 short 0x0000 68 bra.l _fcosx_ 69 short 0x0000 70 71 bra.l _fcoshs_ 72 short 0x0000 73 bra.l _fcoshd_ 74 short 0x0000 75 bra.l _fcoshx_ 76 short 0x0000 77 78 bra.l _fetoxs_ 79 short 0x0000 80 bra.l _fetoxd_ 81 short 0x0000 82 bra.l _fetoxx_ 83 short 0x0000 84 85 bra.l _fetoxm1s_ 86 short 0x0000 87 bra.l _fetoxm1d_ 88 short 0x0000 89 bra.l _fetoxm1x_ 90 short 0x0000 91 92 bra.l _fgetexps_ 93 short 0x0000 94 bra.l _fgetexpd_ 95 short 0x0000 96 bra.l _fgetexpx_ 97 short 0x0000 98 99 bra.l _fgetmans_ 100 short 0x0000 101 bra.l _fgetmand_ 102 short 0x0000 103 bra.l _fgetmanx_ 104 short 0x0000 105 106 bra.l _flog10s_ 107 short 0x0000 108 bra.l _flog10d_ 109 short 0x0000 110 bra.l _flog10x_ 111 short 0x0000 112 113 bra.l _flog2s_ 114 short 0x0000 115 bra.l _flog2d_ 116 short 0x0000 117 bra.l _flog2x_ 118 short 0x0000 119 120 bra.l _flogns_ 121 short 0x0000 122 bra.l _flognd_ 123 short 0x0000 124 bra.l _flognx_ 125 short 0x0000 126 127 bra.l _flognp1s_ 128 short 0x0000 129 bra.l _flognp1d_ 130 short 0x0000 131 bra.l _flognp1x_ 132 short 0x0000 133 134 bra.l _fmods_ 135 short 0x0000 136 bra.l _fmodd_ 137 short 0x0000 138 bra.l _fmodx_ 139 short 0x0000 140 141 bra.l _frems_ 142 short 0x0000 143 bra.l _fremd_ 144 short 0x0000 145 bra.l _fremx_ 146 short 0x0000 147 148 bra.l _fscales_ 149 short 0x0000 150 bra.l _fscaled_ 151 short 0x0000 152 bra.l _fscalex_ 153 short 0x0000 154 155 bra.l _fsins_ 156 short 0x0000 157 bra.l _fsind_ 158 short 0x0000 159 bra.l _fsinx_ 160 short 0x0000 161 162 bra.l _fsincoss_ 163 short 0x0000 164 bra.l _fsincosd_ 165 short 0x0000 166 bra.l _fsincosx_ 167 short 0x0000 168 169 bra.l _fsinhs_ 170 short 0x0000 171 bra.l _fsinhd_ 172 short 0x0000 173 bra.l _fsinhx_ 174 short 0x0000 175 176 bra.l _ftans_ 177 short 0x0000 178 bra.l _ftand_ 179 short 0x0000 180 bra.l _ftanx_ 181 short 0x0000 182 183 bra.l _ftanhs_ 184 short 0x0000 185 bra.l _ftanhd_ 186 short 0x0000 187 bra.l _ftanhx_ 188 short 0x0000 189 190 bra.l _ftentoxs_ 191 short 0x0000 192 bra.l _ftentoxd_ 193 short 0x0000 194 bra.l _ftentoxx_ 195 short 0x0000 196 197 bra.l _ftwotoxs_ 198 short 0x0000 199 bra.l _ftwotoxd_ 200 short 0x0000 201 bra.l _ftwotoxx_ 202 short 0x0000 203 204 bra.l _fabss_ 205 short 0x0000 206 bra.l _fabsd_ 207 short 0x0000 208 bra.l _fabsx_ 209 short 0x0000 210 211 bra.l _fadds_ 212 short 0x0000 213 bra.l _faddd_ 214 short 0x0000 215 bra.l _faddx_ 216 short 0x0000 217 218 bra.l _fdivs_ 219 short 0x0000 220 bra.l _fdivd_ 221 short 0x0000 222 bra.l _fdivx_ 223 short 0x0000 224 225 bra.l _fints_ 226 short 0x0000 227 bra.l _fintd_ 228 short 0x0000 229 bra.l _fintx_ 230 short 0x0000 231 232 bra.l _fintrzs_ 233 short 0x0000 234 bra.l _fintrzd_ 235 short 0x0000 236 bra.l _fintrzx_ 237 short 0x0000 238 239 bra.l _fmuls_ 240 short 0x0000 241 bra.l _fmuld_ 242 short 0x0000 243 bra.l _fmulx_ 244 short 0x0000 245 246 bra.l _fnegs_ 247 short 0x0000 248 bra.l _fnegd_ 249 short 0x0000 250 bra.l _fnegx_ 251 short 0x0000 252 253 bra.l _fsqrts_ 254 short 0x0000 255 bra.l _fsqrtd_ 256 short 0x0000 257 bra.l _fsqrtx_ 258 short 0x0000 259 260 bra.l _fsubs_ 261 short 0x0000 262 bra.l _fsubd_ 263 short 0x0000 264 bra.l _fsubx_ 265 short 0x0000 266 267 # leave room for future possible additions 268 align 0x400 269 270 # 271 # This file contains a set of define statements for constants 272 # in order to promote readability within the corecode itself. 273 # 274 275 set LOCAL_SIZE, 192 # stack frame size(bytes) 276 set LV, -LOCAL_SIZE # stack offset 277 278 set EXC_SR, 0x4 # stack status register 279 set EXC_PC, 0x6 # stack pc 280 set EXC_VOFF, 0xa # stacked vector offset 281 set EXC_EA, 0xc # stacked <ea> 282 283 set EXC_FP, 0x0 # frame pointer 284 285 set EXC_AREGS, -68 # offset of all address regs 286 set EXC_DREGS, -100 # offset of all data regs 287 set EXC_FPREGS, -36 # offset of all fp regs 288 289 set EXC_A7, EXC_AREGS+(7*4) # offset of saved a7 290 set OLD_A7, EXC_AREGS+(6*4) # extra copy of saved a7 291 set EXC_A6, EXC_AREGS+(6*4) # offset of saved a6 292 set EXC_A5, EXC_AREGS+(5*4) 293 set EXC_A4, EXC_AREGS+(4*4) 294 set EXC_A3, EXC_AREGS+(3*4) 295 set EXC_A2, EXC_AREGS+(2*4) 296 set EXC_A1, EXC_AREGS+(1*4) 297 set EXC_A0, EXC_AREGS+(0*4) 298 set EXC_D7, EXC_DREGS+(7*4) 299 set EXC_D6, EXC_DREGS+(6*4) 300 set EXC_D5, EXC_DREGS+(5*4) 301 set EXC_D4, EXC_DREGS+(4*4) 302 set EXC_D3, EXC_DREGS+(3*4) 303 set EXC_D2, EXC_DREGS+(2*4) 304 set EXC_D1, EXC_DREGS+(1*4) 305 set EXC_D0, EXC_DREGS+(0*4) 306 307 set EXC_FP0, EXC_FPREGS+(0*12) # offset of saved fp0 308 set EXC_FP1, EXC_FPREGS+(1*12) # offset of saved fp1 309 set EXC_FP2, EXC_FPREGS+(2*12) # offset of saved fp2 (not used) 310 311 set FP_SCR1, LV+80 # fp scratch 1 312 set FP_SCR1_EX, FP_SCR1+0 313 set FP_SCR1_SGN, FP_SCR1+2 314 set FP_SCR1_HI, FP_SCR1+4 315 set FP_SCR1_LO, FP_SCR1+8 316 317 set FP_SCR0, LV+68 # fp scratch 0 318 set FP_SCR0_EX, FP_SCR0+0 319 set FP_SCR0_SGN, FP_SCR0+2 320 set FP_SCR0_HI, FP_SCR0+4 321 set FP_SCR0_LO, FP_SCR0+8 322 323 set FP_DST, LV+56 # fp destination operand 324 set FP_DST_EX, FP_DST+0 325 set FP_DST_SGN, FP_DST+2 326 set FP_DST_HI, FP_DST+4 327 set FP_DST_LO, FP_DST+8 328 329 set FP_SRC, LV+44 # fp source operand 330 set FP_SRC_EX, FP_SRC+0 331 set FP_SRC_SGN, FP_SRC+2 332 set FP_SRC_HI, FP_SRC+4 333 set FP_SRC_LO, FP_SRC+8 334 335 set USER_FPIAR, LV+40 # FP instr address register 336 337 set USER_FPSR, LV+36 # FP status register 338 set FPSR_CC, USER_FPSR+0 # FPSR condition codes 339 set FPSR_QBYTE, USER_FPSR+1 # FPSR qoutient byte 340 set FPSR_EXCEPT, USER_FPSR+2 # FPSR exception status byte 341 set FPSR_AEXCEPT, USER_FPSR+3 # FPSR accrued exception byte 342 343 set USER_FPCR, LV+32 # FP control register 344 set FPCR_ENABLE, USER_FPCR+2 # FPCR exception enable 345 set FPCR_MODE, USER_FPCR+3 # FPCR rounding mode control 346 347 set L_SCR3, LV+28 # integer scratch 3 348 set L_SCR2, LV+24 # integer scratch 2 349 set L_SCR1, LV+20 # integer scratch 1 350 351 set STORE_FLG, LV+19 # flag: operand store (ie. not fcmp/ftst) 352 353 set EXC_TEMP2, LV+24 # temporary space 354 set EXC_TEMP, LV+16 # temporary space 355 356 set DTAG, LV+15 # destination operand type 357 set STAG, LV+14 # source operand type 358 359 set SPCOND_FLG, LV+10 # flag: special case (see below) 360 361 set EXC_CC, LV+8 # saved condition codes 362 set EXC_EXTWPTR, LV+4 # saved current PC (active) 363 set EXC_EXTWORD, LV+2 # saved extension word 364 set EXC_CMDREG, LV+2 # saved extension word 365 set EXC_OPWORD, LV+0 # saved operation word 366 367 ################################ 368 369 # Helpful macros 370 371 set FTEMP, 0 # offsets within an 372 set FTEMP_EX, 0 # extended precision 373 set FTEMP_SGN, 2 # value saved in memory. 374 set FTEMP_HI, 4 375 set FTEMP_LO, 8 376 set FTEMP_GRS, 12 377 378 set LOCAL, 0 # offsets within an 379 set LOCAL_EX, 0 # extended precision 380 set LOCAL_SGN, 2 # value saved in memory. 381 set LOCAL_HI, 4 382 set LOCAL_LO, 8 383 set LOCAL_GRS, 12 384 385 set DST, 0 # offsets within an 386 set DST_EX, 0 # extended precision 387 set DST_HI, 4 # value saved in memory. 388 set DST_LO, 8 389 390 set SRC, 0 # offsets within an 391 set SRC_EX, 0 # extended precision 392 set SRC_HI, 4 # value saved in memory. 393 set SRC_LO, 8 394 395 set SGL_LO, 0x3f81 # min sgl prec exponent 396 set SGL_HI, 0x407e # max sgl prec exponent 397 set DBL_LO, 0x3c01 # min dbl prec exponent 398 set DBL_HI, 0x43fe # max dbl prec exponent 399 set EXT_LO, 0x0 # min ext prec exponent 400 set EXT_HI, 0x7ffe # max ext prec exponent 401 402 set EXT_BIAS, 0x3fff # extended precision bias 403 set SGL_BIAS, 0x007f # single precision bias 404 set DBL_BIAS, 0x03ff # double precision bias 405 406 set NORM, 0x00 # operand type for STAG/DTAG 407 set ZERO, 0x01 # operand type for STAG/DTAG 408 set INF, 0x02 # operand type for STAG/DTAG 409 set QNAN, 0x03 # operand type for STAG/DTAG 410 set DENORM, 0x04 # operand type for STAG/DTAG 411 set SNAN, 0x05 # operand type for STAG/DTAG 412 set UNNORM, 0x06 # operand type for STAG/DTAG 413 414 ################## 415 # FPSR/FPCR bits # 416 ################## 417 set neg_bit, 0x3 # negative result 418 set z_bit, 0x2 # zero result 419 set inf_bit, 0x1 # infinite result 420 set nan_bit, 0x0 # NAN result 421 422 set q_sn_bit, 0x7 # sign bit of quotient byte 423 424 set bsun_bit, 7 # branch on unordered 425 set snan_bit, 6 # signalling NAN 426 set operr_bit, 5 # operand error 427 set ovfl_bit, 4 # overflow 428 set unfl_bit, 3 # underflow 429 set dz_bit, 2 # divide by zero 430 set inex2_bit, 1 # inexact result 2 431 set inex1_bit, 0 # inexact result 1 432 433 set aiop_bit, 7 # accrued inexact operation bit 434 set aovfl_bit, 6 # accrued overflow bit 435 set aunfl_bit, 5 # accrued underflow bit 436 set adz_bit, 4 # accrued dz bit 437 set ainex_bit, 3 # accrued inexact bit 438 439 ############################# 440 # FPSR individual bit masks # 441 ############################# 442 set neg_mask, 0x08000000 # negative bit mask (lw) 443 set inf_mask, 0x02000000 # infinity bit mask (lw) 444 set z_mask, 0x04000000 # zero bit mask (lw) 445 set nan_mask, 0x01000000 # nan bit mask (lw) 446 447 set neg_bmask, 0x08 # negative bit mask (byte) 448 set inf_bmask, 0x02 # infinity bit mask (byte) 449 set z_bmask, 0x04 # zero bit mask (byte) 450 set nan_bmask, 0x01 # nan bit mask (byte) 451 452 set bsun_mask, 0x00008000 # bsun exception mask 453 set snan_mask, 0x00004000 # snan exception mask 454 set operr_mask, 0x00002000 # operr exception mask 455 set ovfl_mask, 0x00001000 # overflow exception mask 456 set unfl_mask, 0x00000800 # underflow exception mask 457 set dz_mask, 0x00000400 # dz exception mask 458 set inex2_mask, 0x00000200 # inex2 exception mask 459 set inex1_mask, 0x00000100 # inex1 exception mask 460 461 set aiop_mask, 0x00000080 # accrued illegal operation 462 set aovfl_mask, 0x00000040 # accrued overflow 463 set aunfl_mask, 0x00000020 # accrued underflow 464 set adz_mask, 0x00000010 # accrued divide by zero 465 set ainex_mask, 0x00000008 # accrued inexact 466 467 ###################################### 468 # FPSR combinations used in the FPSP # 469 ###################################### 470 set dzinf_mask, inf_mask+dz_mask+adz_mask 471 set opnan_mask, nan_mask+operr_mask+aiop_mask 472 set nzi_mask, 0x01ffffff #clears N, Z, and I 473 set unfinx_mask, unfl_mask+inex2_mask+aunfl_mask+ainex_mask 474 set unf2inx_mask, unfl_mask+inex2_mask+ainex_mask 475 set ovfinx_mask, ovfl_mask+inex2_mask+aovfl_mask+ainex_mask 476 set inx1a_mask, inex1_mask+ainex_mask 477 set inx2a_mask, inex2_mask+ainex_mask 478 set snaniop_mask, nan_mask+snan_mask+aiop_mask 479 set snaniop2_mask, snan_mask+aiop_mask 480 set naniop_mask, nan_mask+aiop_mask 481 set neginf_mask, neg_mask+inf_mask 482 set infaiop_mask, inf_mask+aiop_mask 483 set negz_mask, neg_mask+z_mask 484 set opaop_mask, operr_mask+aiop_mask 485 set unfl_inx_mask, unfl_mask+aunfl_mask+ainex_mask 486 set ovfl_inx_mask, ovfl_mask+aovfl_mask+ainex_mask 487 488 ######### 489 # misc. # 490 ######### 491 set rnd_stky_bit, 29 # stky bit pos in longword 492 493 set sign_bit, 0x7 # sign bit 494 set signan_bit, 0x6 # signalling nan bit 495 496 set sgl_thresh, 0x3f81 # minimum sgl exponent 497 set dbl_thresh, 0x3c01 # minimum dbl exponent 498 499 set x_mode, 0x0 # extended precision 500 set s_mode, 0x4 # single precision 501 set d_mode, 0x8 # double precision 502 503 set rn_mode, 0x0 # round-to-nearest 504 set rz_mode, 0x1 # round-to-zero 505 set rm_mode, 0x2 # round-tp-minus-infinity 506 set rp_mode, 0x3 # round-to-plus-infinity 507 508 set mantissalen, 64 # length of mantissa in bits 509 510 set BYTE, 1 # len(byte) == 1 byte 511 set WORD, 2 # len(word) == 2 bytes 512 set LONG, 4 # len(longword) == 2 bytes 513 514 set BSUN_VEC, 0xc0 # bsun vector offset 515 set INEX_VEC, 0xc4 # inexact vector offset 516 set DZ_VEC, 0xc8 # dz vector offset 517 set UNFL_VEC, 0xcc # unfl vector offset 518 set OPERR_VEC, 0xd0 # operr vector offset 519 set OVFL_VEC, 0xd4 # ovfl vector offset 520 set SNAN_VEC, 0xd8 # snan vector offset 521 522 ########################### 523 # SPecial CONDition FLaGs # 524 ########################### 525 set ftrapcc_flg, 0x01 # flag bit: ftrapcc exception 526 set fbsun_flg, 0x02 # flag bit: bsun exception 527 set mia7_flg, 0x04 # flag bit: (a7)+ <ea> 528 set mda7_flg, 0x08 # flag bit: -(a7) <ea> 529 set fmovm_flg, 0x40 # flag bit: fmovm instruction 530 set immed_flg, 0x80 # flag bit: &<data> <ea> 531 532 set ftrapcc_bit, 0x0 533 set fbsun_bit, 0x1 534 set mia7_bit, 0x2 535 set mda7_bit, 0x3 536 set immed_bit, 0x7 537 538 ################################## 539 # TRANSCENDENTAL "LAST-OP" FLAGS # 540 ################################## 541 set FMUL_OP, 0x0 # fmul instr performed last 542 set FDIV_OP, 0x1 # fdiv performed last 543 set FADD_OP, 0x2 # fadd performed last 544 set FMOV_OP, 0x3 # fmov performed last 545 546 ############# 547 # CONSTANTS # 548 ############# 549 T1: long 0x40C62D38,0xD3D64634 # 16381 LOG2 LEAD 550 T2: long 0x3D6F90AE,0xB1E75CC7 # 16381 LOG2 TRAIL 551 552 PI: long 0x40000000,0xC90FDAA2,0x2168C235,0x00000000 553 PIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000 554 555 TWOBYPI: 556 long 0x3FE45F30,0x6DC9C883 557 558 ######################################################################### 559 # MONADIC TEMPLATE # 560 ######################################################################### 561 global _fsins_ 562 _fsins_: 563 link %a6,&-LOCAL_SIZE 564 565 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 566 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 567 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 568 569 fmov.l &0x0,%fpcr # zero FPCR 570 571 # 572 # copy, convert, and tag input argument 573 # 574 fmov.s 0x8(%a6),%fp0 # load sgl input 575 fmov.x %fp0,FP_SRC(%a6) 576 lea FP_SRC(%a6),%a0 577 bsr.l tag # fetch operand type 578 mov.b %d0,STAG(%a6) 579 mov.b %d0,%d1 580 581 andi.l &0x00ff00ff,USER_FPSR(%a6) 582 583 clr.l %d0 584 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 585 586 tst.b %d1 587 bne.b _L0_2s 588 bsr.l ssin # operand is a NORM 589 bra.b _L0_6s 590 _L0_2s: 591 cmpi.b %d1,&ZERO # is operand a ZERO? 592 bne.b _L0_3s # no 593 bsr.l src_zero # yes 594 bra.b _L0_6s 595 _L0_3s: 596 cmpi.b %d1,&INF # is operand an INF? 597 bne.b _L0_4s # no 598 bsr.l t_operr # yes 599 bra.b _L0_6s 600 _L0_4s: 601 cmpi.b %d1,&QNAN # is operand a QNAN? 602 bne.b _L0_5s # no 603 bsr.l src_qnan # yes 604 bra.b _L0_6s 605 _L0_5s: 606 bsr.l ssind # operand is a DENORM 607 _L0_6s: 608 609 # 610 # Result is now in FP0 611 # 612 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 613 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 614 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 615 unlk %a6 616 rts 617 618 global _fsind_ 619 _fsind_: 620 link %a6,&-LOCAL_SIZE 621 622 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 623 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 624 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 625 626 fmov.l &0x0,%fpcr # zero FPCR 627 628 # 629 # copy, convert, and tag input argument 630 # 631 fmov.d 0x8(%a6),%fp0 # load dbl input 632 fmov.x %fp0,FP_SRC(%a6) 633 lea FP_SRC(%a6),%a0 634 bsr.l tag # fetch operand type 635 mov.b %d0,STAG(%a6) 636 mov.b %d0,%d1 637 638 andi.l &0x00ff00ff,USER_FPSR(%a6) 639 640 clr.l %d0 641 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 642 643 mov.b %d1,STAG(%a6) 644 tst.b %d1 645 bne.b _L0_2d 646 bsr.l ssin # operand is a NORM 647 bra.b _L0_6d 648 _L0_2d: 649 cmpi.b %d1,&ZERO # is operand a ZERO? 650 bne.b _L0_3d # no 651 bsr.l src_zero # yes 652 bra.b _L0_6d 653 _L0_3d: 654 cmpi.b %d1,&INF # is operand an INF? 655 bne.b _L0_4d # no 656 bsr.l t_operr # yes 657 bra.b _L0_6d 658 _L0_4d: 659 cmpi.b %d1,&QNAN # is operand a QNAN? 660 bne.b _L0_5d # no 661 bsr.l src_qnan # yes 662 bra.b _L0_6d 663 _L0_5d: 664 bsr.l ssind # operand is a DENORM 665 _L0_6d: 666 667 # 668 # Result is now in FP0 669 # 670 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 671 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 672 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 673 unlk %a6 674 rts 675 676 global _fsinx_ 677 _fsinx_: 678 link %a6,&-LOCAL_SIZE 679 680 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 681 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 682 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 683 684 fmov.l &0x0,%fpcr # zero FPCR 685 686 # 687 # copy, convert, and tag input argument 688 # 689 lea FP_SRC(%a6),%a0 690 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 691 mov.l 0x8+0x4(%a6),0x4(%a0) 692 mov.l 0x8+0x8(%a6),0x8(%a0) 693 bsr.l tag # fetch operand type 694 mov.b %d0,STAG(%a6) 695 mov.b %d0,%d1 696 697 andi.l &0x00ff00ff,USER_FPSR(%a6) 698 699 clr.l %d0 700 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 701 702 tst.b %d1 703 bne.b _L0_2x 704 bsr.l ssin # operand is a NORM 705 bra.b _L0_6x 706 _L0_2x: 707 cmpi.b %d1,&ZERO # is operand a ZERO? 708 bne.b _L0_3x # no 709 bsr.l src_zero # yes 710 bra.b _L0_6x 711 _L0_3x: 712 cmpi.b %d1,&INF # is operand an INF? 713 bne.b _L0_4x # no 714 bsr.l t_operr # yes 715 bra.b _L0_6x 716 _L0_4x: 717 cmpi.b %d1,&QNAN # is operand a QNAN? 718 bne.b _L0_5x # no 719 bsr.l src_qnan # yes 720 bra.b _L0_6x 721 _L0_5x: 722 bsr.l ssind # operand is a DENORM 723 _L0_6x: 724 725 # 726 # Result is now in FP0 727 # 728 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 729 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 730 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 731 unlk %a6 732 rts 733 734 735 ######################################################################### 736 # MONADIC TEMPLATE # 737 ######################################################################### 738 global _fcoss_ 739 _fcoss_: 740 link %a6,&-LOCAL_SIZE 741 742 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 743 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 744 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 745 746 fmov.l &0x0,%fpcr # zero FPCR 747 748 # 749 # copy, convert, and tag input argument 750 # 751 fmov.s 0x8(%a6),%fp0 # load sgl input 752 fmov.x %fp0,FP_SRC(%a6) 753 lea FP_SRC(%a6),%a0 754 bsr.l tag # fetch operand type 755 mov.b %d0,STAG(%a6) 756 mov.b %d0,%d1 757 758 andi.l &0x00ff00ff,USER_FPSR(%a6) 759 760 clr.l %d0 761 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 762 763 tst.b %d1 764 bne.b _L1_2s 765 bsr.l scos # operand is a NORM 766 bra.b _L1_6s 767 _L1_2s: 768 cmpi.b %d1,&ZERO # is operand a ZERO? 769 bne.b _L1_3s # no 770 bsr.l ld_pone # yes 771 bra.b _L1_6s 772 _L1_3s: 773 cmpi.b %d1,&INF # is operand an INF? 774 bne.b _L1_4s # no 775 bsr.l t_operr # yes 776 bra.b _L1_6s 777 _L1_4s: 778 cmpi.b %d1,&QNAN # is operand a QNAN? 779 bne.b _L1_5s # no 780 bsr.l src_qnan # yes 781 bra.b _L1_6s 782 _L1_5s: 783 bsr.l scosd # operand is a DENORM 784 _L1_6s: 785 786 # 787 # Result is now in FP0 788 # 789 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 790 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 791 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 792 unlk %a6 793 rts 794 795 global _fcosd_ 796 _fcosd_: 797 link %a6,&-LOCAL_SIZE 798 799 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 800 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 801 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 802 803 fmov.l &0x0,%fpcr # zero FPCR 804 805 # 806 # copy, convert, and tag input argument 807 # 808 fmov.d 0x8(%a6),%fp0 # load dbl input 809 fmov.x %fp0,FP_SRC(%a6) 810 lea FP_SRC(%a6),%a0 811 bsr.l tag # fetch operand type 812 mov.b %d0,STAG(%a6) 813 mov.b %d0,%d1 814 815 andi.l &0x00ff00ff,USER_FPSR(%a6) 816 817 clr.l %d0 818 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 819 820 mov.b %d1,STAG(%a6) 821 tst.b %d1 822 bne.b _L1_2d 823 bsr.l scos # operand is a NORM 824 bra.b _L1_6d 825 _L1_2d: 826 cmpi.b %d1,&ZERO # is operand a ZERO? 827 bne.b _L1_3d # no 828 bsr.l ld_pone # yes 829 bra.b _L1_6d 830 _L1_3d: 831 cmpi.b %d1,&INF # is operand an INF? 832 bne.b _L1_4d # no 833 bsr.l t_operr # yes 834 bra.b _L1_6d 835 _L1_4d: 836 cmpi.b %d1,&QNAN # is operand a QNAN? 837 bne.b _L1_5d # no 838 bsr.l src_qnan # yes 839 bra.b _L1_6d 840 _L1_5d: 841 bsr.l scosd # operand is a DENORM 842 _L1_6d: 843 844 # 845 # Result is now in FP0 846 # 847 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 848 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 849 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 850 unlk %a6 851 rts 852 853 global _fcosx_ 854 _fcosx_: 855 link %a6,&-LOCAL_SIZE 856 857 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 858 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 859 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 860 861 fmov.l &0x0,%fpcr # zero FPCR 862 863 # 864 # copy, convert, and tag input argument 865 # 866 lea FP_SRC(%a6),%a0 867 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 868 mov.l 0x8+0x4(%a6),0x4(%a0) 869 mov.l 0x8+0x8(%a6),0x8(%a0) 870 bsr.l tag # fetch operand type 871 mov.b %d0,STAG(%a6) 872 mov.b %d0,%d1 873 874 andi.l &0x00ff00ff,USER_FPSR(%a6) 875 876 clr.l %d0 877 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 878 879 tst.b %d1 880 bne.b _L1_2x 881 bsr.l scos # operand is a NORM 882 bra.b _L1_6x 883 _L1_2x: 884 cmpi.b %d1,&ZERO # is operand a ZERO? 885 bne.b _L1_3x # no 886 bsr.l ld_pone # yes 887 bra.b _L1_6x 888 _L1_3x: 889 cmpi.b %d1,&INF # is operand an INF? 890 bne.b _L1_4x # no 891 bsr.l t_operr # yes 892 bra.b _L1_6x 893 _L1_4x: 894 cmpi.b %d1,&QNAN # is operand a QNAN? 895 bne.b _L1_5x # no 896 bsr.l src_qnan # yes 897 bra.b _L1_6x 898 _L1_5x: 899 bsr.l scosd # operand is a DENORM 900 _L1_6x: 901 902 # 903 # Result is now in FP0 904 # 905 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 906 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 907 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 908 unlk %a6 909 rts 910 911 912 ######################################################################### 913 # MONADIC TEMPLATE # 914 ######################################################################### 915 global _fsinhs_ 916 _fsinhs_: 917 link %a6,&-LOCAL_SIZE 918 919 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 920 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 921 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 922 923 fmov.l &0x0,%fpcr # zero FPCR 924 925 # 926 # copy, convert, and tag input argument 927 # 928 fmov.s 0x8(%a6),%fp0 # load sgl input 929 fmov.x %fp0,FP_SRC(%a6) 930 lea FP_SRC(%a6),%a0 931 bsr.l tag # fetch operand type 932 mov.b %d0,STAG(%a6) 933 mov.b %d0,%d1 934 935 andi.l &0x00ff00ff,USER_FPSR(%a6) 936 937 clr.l %d0 938 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 939 940 tst.b %d1 941 bne.b _L2_2s 942 bsr.l ssinh # operand is a NORM 943 bra.b _L2_6s 944 _L2_2s: 945 cmpi.b %d1,&ZERO # is operand a ZERO? 946 bne.b _L2_3s # no 947 bsr.l src_zero # yes 948 bra.b _L2_6s 949 _L2_3s: 950 cmpi.b %d1,&INF # is operand an INF? 951 bne.b _L2_4s # no 952 bsr.l src_inf # yes 953 bra.b _L2_6s 954 _L2_4s: 955 cmpi.b %d1,&QNAN # is operand a QNAN? 956 bne.b _L2_5s # no 957 bsr.l src_qnan # yes 958 bra.b _L2_6s 959 _L2_5s: 960 bsr.l ssinhd # operand is a DENORM 961 _L2_6s: 962 963 # 964 # Result is now in FP0 965 # 966 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 967 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 968 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 969 unlk %a6 970 rts 971 972 global _fsinhd_ 973 _fsinhd_: 974 link %a6,&-LOCAL_SIZE 975 976 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 977 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 978 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 979 980 fmov.l &0x0,%fpcr # zero FPCR 981 982 # 983 # copy, convert, and tag input argument 984 # 985 fmov.d 0x8(%a6),%fp0 # load dbl input 986 fmov.x %fp0,FP_SRC(%a6) 987 lea FP_SRC(%a6),%a0 988 bsr.l tag # fetch operand type 989 mov.b %d0,STAG(%a6) 990 mov.b %d0,%d1 991 992 andi.l &0x00ff00ff,USER_FPSR(%a6) 993 994 clr.l %d0 995 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 996 997 mov.b %d1,STAG(%a6) 998 tst.b %d1 999 bne.b _L2_2d 1000 bsr.l ssinh # operand is a NORM 1001 bra.b _L2_6d 1002 _L2_2d: 1003 cmpi.b %d1,&ZERO # is operand a ZERO? 1004 bne.b _L2_3d # no 1005 bsr.l src_zero # yes 1006 bra.b _L2_6d 1007 _L2_3d: 1008 cmpi.b %d1,&INF # is operand an INF? 1009 bne.b _L2_4d # no 1010 bsr.l src_inf # yes 1011 bra.b _L2_6d 1012 _L2_4d: 1013 cmpi.b %d1,&QNAN # is operand a QNAN? 1014 bne.b _L2_5d # no 1015 bsr.l src_qnan # yes 1016 bra.b _L2_6d 1017 _L2_5d: 1018 bsr.l ssinhd # operand is a DENORM 1019 _L2_6d: 1020 1021 # 1022 # Result is now in FP0 1023 # 1024 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1025 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1026 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1027 unlk %a6 1028 rts 1029 1030 global _fsinhx_ 1031 _fsinhx_: 1032 link %a6,&-LOCAL_SIZE 1033 1034 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1035 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1036 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1037 1038 fmov.l &0x0,%fpcr # zero FPCR 1039 1040 # 1041 # copy, convert, and tag input argument 1042 # 1043 lea FP_SRC(%a6),%a0 1044 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 1045 mov.l 0x8+0x4(%a6),0x4(%a0) 1046 mov.l 0x8+0x8(%a6),0x8(%a0) 1047 bsr.l tag # fetch operand type 1048 mov.b %d0,STAG(%a6) 1049 mov.b %d0,%d1 1050 1051 andi.l &0x00ff00ff,USER_FPSR(%a6) 1052 1053 clr.l %d0 1054 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1055 1056 tst.b %d1 1057 bne.b _L2_2x 1058 bsr.l ssinh # operand is a NORM 1059 bra.b _L2_6x 1060 _L2_2x: 1061 cmpi.b %d1,&ZERO # is operand a ZERO? 1062 bne.b _L2_3x # no 1063 bsr.l src_zero # yes 1064 bra.b _L2_6x 1065 _L2_3x: 1066 cmpi.b %d1,&INF # is operand an INF? 1067 bne.b _L2_4x # no 1068 bsr.l src_inf # yes 1069 bra.b _L2_6x 1070 _L2_4x: 1071 cmpi.b %d1,&QNAN # is operand a QNAN? 1072 bne.b _L2_5x # no 1073 bsr.l src_qnan # yes 1074 bra.b _L2_6x 1075 _L2_5x: 1076 bsr.l ssinhd # operand is a DENORM 1077 _L2_6x: 1078 1079 # 1080 # Result is now in FP0 1081 # 1082 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1083 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1084 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1085 unlk %a6 1086 rts 1087 1088 1089 ######################################################################### 1090 # MONADIC TEMPLATE # 1091 ######################################################################### 1092 global _flognp1s_ 1093 _flognp1s_: 1094 link %a6,&-LOCAL_SIZE 1095 1096 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1097 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1098 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1099 1100 fmov.l &0x0,%fpcr # zero FPCR 1101 1102 # 1103 # copy, convert, and tag input argument 1104 # 1105 fmov.s 0x8(%a6),%fp0 # load sgl input 1106 fmov.x %fp0,FP_SRC(%a6) 1107 lea FP_SRC(%a6),%a0 1108 bsr.l tag # fetch operand type 1109 mov.b %d0,STAG(%a6) 1110 mov.b %d0,%d1 1111 1112 andi.l &0x00ff00ff,USER_FPSR(%a6) 1113 1114 clr.l %d0 1115 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1116 1117 tst.b %d1 1118 bne.b _L3_2s 1119 bsr.l slognp1 # operand is a NORM 1120 bra.b _L3_6s 1121 _L3_2s: 1122 cmpi.b %d1,&ZERO # is operand a ZERO? 1123 bne.b _L3_3s # no 1124 bsr.l src_zero # yes 1125 bra.b _L3_6s 1126 _L3_3s: 1127 cmpi.b %d1,&INF # is operand an INF? 1128 bne.b _L3_4s # no 1129 bsr.l sopr_inf # yes 1130 bra.b _L3_6s 1131 _L3_4s: 1132 cmpi.b %d1,&QNAN # is operand a QNAN? 1133 bne.b _L3_5s # no 1134 bsr.l src_qnan # yes 1135 bra.b _L3_6s 1136 _L3_5s: 1137 bsr.l slognp1d # operand is a DENORM 1138 _L3_6s: 1139 1140 # 1141 # Result is now in FP0 1142 # 1143 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1144 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1145 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1146 unlk %a6 1147 rts 1148 1149 global _flognp1d_ 1150 _flognp1d_: 1151 link %a6,&-LOCAL_SIZE 1152 1153 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1154 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1155 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1156 1157 fmov.l &0x0,%fpcr # zero FPCR 1158 1159 # 1160 # copy, convert, and tag input argument 1161 # 1162 fmov.d 0x8(%a6),%fp0 # load dbl input 1163 fmov.x %fp0,FP_SRC(%a6) 1164 lea FP_SRC(%a6),%a0 1165 bsr.l tag # fetch operand type 1166 mov.b %d0,STAG(%a6) 1167 mov.b %d0,%d1 1168 1169 andi.l &0x00ff00ff,USER_FPSR(%a6) 1170 1171 clr.l %d0 1172 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1173 1174 mov.b %d1,STAG(%a6) 1175 tst.b %d1 1176 bne.b _L3_2d 1177 bsr.l slognp1 # operand is a NORM 1178 bra.b _L3_6d 1179 _L3_2d: 1180 cmpi.b %d1,&ZERO # is operand a ZERO? 1181 bne.b _L3_3d # no 1182 bsr.l src_zero # yes 1183 bra.b _L3_6d 1184 _L3_3d: 1185 cmpi.b %d1,&INF # is operand an INF? 1186 bne.b _L3_4d # no 1187 bsr.l sopr_inf # yes 1188 bra.b _L3_6d 1189 _L3_4d: 1190 cmpi.b %d1,&QNAN # is operand a QNAN? 1191 bne.b _L3_5d # no 1192 bsr.l src_qnan # yes 1193 bra.b _L3_6d 1194 _L3_5d: 1195 bsr.l slognp1d # operand is a DENORM 1196 _L3_6d: 1197 1198 # 1199 # Result is now in FP0 1200 # 1201 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1202 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1203 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1204 unlk %a6 1205 rts 1206 1207 global _flognp1x_ 1208 _flognp1x_: 1209 link %a6,&-LOCAL_SIZE 1210 1211 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1212 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1213 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1214 1215 fmov.l &0x0,%fpcr # zero FPCR 1216 1217 # 1218 # copy, convert, and tag input argument 1219 # 1220 lea FP_SRC(%a6),%a0 1221 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 1222 mov.l 0x8+0x4(%a6),0x4(%a0) 1223 mov.l 0x8+0x8(%a6),0x8(%a0) 1224 bsr.l tag # fetch operand type 1225 mov.b %d0,STAG(%a6) 1226 mov.b %d0,%d1 1227 1228 andi.l &0x00ff00ff,USER_FPSR(%a6) 1229 1230 clr.l %d0 1231 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1232 1233 tst.b %d1 1234 bne.b _L3_2x 1235 bsr.l slognp1 # operand is a NORM 1236 bra.b _L3_6x 1237 _L3_2x: 1238 cmpi.b %d1,&ZERO # is operand a ZERO? 1239 bne.b _L3_3x # no 1240 bsr.l src_zero # yes 1241 bra.b _L3_6x 1242 _L3_3x: 1243 cmpi.b %d1,&INF # is operand an INF? 1244 bne.b _L3_4x # no 1245 bsr.l sopr_inf # yes 1246 bra.b _L3_6x 1247 _L3_4x: 1248 cmpi.b %d1,&QNAN # is operand a QNAN? 1249 bne.b _L3_5x # no 1250 bsr.l src_qnan # yes 1251 bra.b _L3_6x 1252 _L3_5x: 1253 bsr.l slognp1d # operand is a DENORM 1254 _L3_6x: 1255 1256 # 1257 # Result is now in FP0 1258 # 1259 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1260 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1261 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1262 unlk %a6 1263 rts 1264 1265 1266 ######################################################################### 1267 # MONADIC TEMPLATE # 1268 ######################################################################### 1269 global _fetoxm1s_ 1270 _fetoxm1s_: 1271 link %a6,&-LOCAL_SIZE 1272 1273 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1274 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1275 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1276 1277 fmov.l &0x0,%fpcr # zero FPCR 1278 1279 # 1280 # copy, convert, and tag input argument 1281 # 1282 fmov.s 0x8(%a6),%fp0 # load sgl input 1283 fmov.x %fp0,FP_SRC(%a6) 1284 lea FP_SRC(%a6),%a0 1285 bsr.l tag # fetch operand type 1286 mov.b %d0,STAG(%a6) 1287 mov.b %d0,%d1 1288 1289 andi.l &0x00ff00ff,USER_FPSR(%a6) 1290 1291 clr.l %d0 1292 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1293 1294 tst.b %d1 1295 bne.b _L4_2s 1296 bsr.l setoxm1 # operand is a NORM 1297 bra.b _L4_6s 1298 _L4_2s: 1299 cmpi.b %d1,&ZERO # is operand a ZERO? 1300 bne.b _L4_3s # no 1301 bsr.l src_zero # yes 1302 bra.b _L4_6s 1303 _L4_3s: 1304 cmpi.b %d1,&INF # is operand an INF? 1305 bne.b _L4_4s # no 1306 bsr.l setoxm1i # yes 1307 bra.b _L4_6s 1308 _L4_4s: 1309 cmpi.b %d1,&QNAN # is operand a QNAN? 1310 bne.b _L4_5s # no 1311 bsr.l src_qnan # yes 1312 bra.b _L4_6s 1313 _L4_5s: 1314 bsr.l setoxm1d # operand is a DENORM 1315 _L4_6s: 1316 1317 # 1318 # Result is now in FP0 1319 # 1320 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1321 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1322 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1323 unlk %a6 1324 rts 1325 1326 global _fetoxm1d_ 1327 _fetoxm1d_: 1328 link %a6,&-LOCAL_SIZE 1329 1330 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1331 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1332 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1333 1334 fmov.l &0x0,%fpcr # zero FPCR 1335 1336 # 1337 # copy, convert, and tag input argument 1338 # 1339 fmov.d 0x8(%a6),%fp0 # load dbl input 1340 fmov.x %fp0,FP_SRC(%a6) 1341 lea FP_SRC(%a6),%a0 1342 bsr.l tag # fetch operand type 1343 mov.b %d0,STAG(%a6) 1344 mov.b %d0,%d1 1345 1346 andi.l &0x00ff00ff,USER_FPSR(%a6) 1347 1348 clr.l %d0 1349 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1350 1351 mov.b %d1,STAG(%a6) 1352 tst.b %d1 1353 bne.b _L4_2d 1354 bsr.l setoxm1 # operand is a NORM 1355 bra.b _L4_6d 1356 _L4_2d: 1357 cmpi.b %d1,&ZERO # is operand a ZERO? 1358 bne.b _L4_3d # no 1359 bsr.l src_zero # yes 1360 bra.b _L4_6d 1361 _L4_3d: 1362 cmpi.b %d1,&INF # is operand an INF? 1363 bne.b _L4_4d # no 1364 bsr.l setoxm1i # yes 1365 bra.b _L4_6d 1366 _L4_4d: 1367 cmpi.b %d1,&QNAN # is operand a QNAN? 1368 bne.b _L4_5d # no 1369 bsr.l src_qnan # yes 1370 bra.b _L4_6d 1371 _L4_5d: 1372 bsr.l setoxm1d # operand is a DENORM 1373 _L4_6d: 1374 1375 # 1376 # Result is now in FP0 1377 # 1378 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1379 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1380 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1381 unlk %a6 1382 rts 1383 1384 global _fetoxm1x_ 1385 _fetoxm1x_: 1386 link %a6,&-LOCAL_SIZE 1387 1388 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1389 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1390 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1391 1392 fmov.l &0x0,%fpcr # zero FPCR 1393 1394 # 1395 # copy, convert, and tag input argument 1396 # 1397 lea FP_SRC(%a6),%a0 1398 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 1399 mov.l 0x8+0x4(%a6),0x4(%a0) 1400 mov.l 0x8+0x8(%a6),0x8(%a0) 1401 bsr.l tag # fetch operand type 1402 mov.b %d0,STAG(%a6) 1403 mov.b %d0,%d1 1404 1405 andi.l &0x00ff00ff,USER_FPSR(%a6) 1406 1407 clr.l %d0 1408 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1409 1410 tst.b %d1 1411 bne.b _L4_2x 1412 bsr.l setoxm1 # operand is a NORM 1413 bra.b _L4_6x 1414 _L4_2x: 1415 cmpi.b %d1,&ZERO # is operand a ZERO? 1416 bne.b _L4_3x # no 1417 bsr.l src_zero # yes 1418 bra.b _L4_6x 1419 _L4_3x: 1420 cmpi.b %d1,&INF # is operand an INF? 1421 bne.b _L4_4x # no 1422 bsr.l setoxm1i # yes 1423 bra.b _L4_6x 1424 _L4_4x: 1425 cmpi.b %d1,&QNAN # is operand a QNAN? 1426 bne.b _L4_5x # no 1427 bsr.l src_qnan # yes 1428 bra.b _L4_6x 1429 _L4_5x: 1430 bsr.l setoxm1d # operand is a DENORM 1431 _L4_6x: 1432 1433 # 1434 # Result is now in FP0 1435 # 1436 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1437 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1438 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1439 unlk %a6 1440 rts 1441 1442 1443 ######################################################################### 1444 # MONADIC TEMPLATE # 1445 ######################################################################### 1446 global _ftanhs_ 1447 _ftanhs_: 1448 link %a6,&-LOCAL_SIZE 1449 1450 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1451 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1452 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1453 1454 fmov.l &0x0,%fpcr # zero FPCR 1455 1456 # 1457 # copy, convert, and tag input argument 1458 # 1459 fmov.s 0x8(%a6),%fp0 # load sgl input 1460 fmov.x %fp0,FP_SRC(%a6) 1461 lea FP_SRC(%a6),%a0 1462 bsr.l tag # fetch operand type 1463 mov.b %d0,STAG(%a6) 1464 mov.b %d0,%d1 1465 1466 andi.l &0x00ff00ff,USER_FPSR(%a6) 1467 1468 clr.l %d0 1469 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1470 1471 tst.b %d1 1472 bne.b _L5_2s 1473 bsr.l stanh # operand is a NORM 1474 bra.b _L5_6s 1475 _L5_2s: 1476 cmpi.b %d1,&ZERO # is operand a ZERO? 1477 bne.b _L5_3s # no 1478 bsr.l src_zero # yes 1479 bra.b _L5_6s 1480 _L5_3s: 1481 cmpi.b %d1,&INF # is operand an INF? 1482 bne.b _L5_4s # no 1483 bsr.l src_one # yes 1484 bra.b _L5_6s 1485 _L5_4s: 1486 cmpi.b %d1,&QNAN # is operand a QNAN? 1487 bne.b _L5_5s # no 1488 bsr.l src_qnan # yes 1489 bra.b _L5_6s 1490 _L5_5s: 1491 bsr.l stanhd # operand is a DENORM 1492 _L5_6s: 1493 1494 # 1495 # Result is now in FP0 1496 # 1497 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1498 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1499 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1500 unlk %a6 1501 rts 1502 1503 global _ftanhd_ 1504 _ftanhd_: 1505 link %a6,&-LOCAL_SIZE 1506 1507 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1508 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1509 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1510 1511 fmov.l &0x0,%fpcr # zero FPCR 1512 1513 # 1514 # copy, convert, and tag input argument 1515 # 1516 fmov.d 0x8(%a6),%fp0 # load dbl input 1517 fmov.x %fp0,FP_SRC(%a6) 1518 lea FP_SRC(%a6),%a0 1519 bsr.l tag # fetch operand type 1520 mov.b %d0,STAG(%a6) 1521 mov.b %d0,%d1 1522 1523 andi.l &0x00ff00ff,USER_FPSR(%a6) 1524 1525 clr.l %d0 1526 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1527 1528 mov.b %d1,STAG(%a6) 1529 tst.b %d1 1530 bne.b _L5_2d 1531 bsr.l stanh # operand is a NORM 1532 bra.b _L5_6d 1533 _L5_2d: 1534 cmpi.b %d1,&ZERO # is operand a ZERO? 1535 bne.b _L5_3d # no 1536 bsr.l src_zero # yes 1537 bra.b _L5_6d 1538 _L5_3d: 1539 cmpi.b %d1,&INF # is operand an INF? 1540 bne.b _L5_4d # no 1541 bsr.l src_one # yes 1542 bra.b _L5_6d 1543 _L5_4d: 1544 cmpi.b %d1,&QNAN # is operand a QNAN? 1545 bne.b _L5_5d # no 1546 bsr.l src_qnan # yes 1547 bra.b _L5_6d 1548 _L5_5d: 1549 bsr.l stanhd # operand is a DENORM 1550 _L5_6d: 1551 1552 # 1553 # Result is now in FP0 1554 # 1555 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1556 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1557 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1558 unlk %a6 1559 rts 1560 1561 global _ftanhx_ 1562 _ftanhx_: 1563 link %a6,&-LOCAL_SIZE 1564 1565 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1566 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1567 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1568 1569 fmov.l &0x0,%fpcr # zero FPCR 1570 1571 # 1572 # copy, convert, and tag input argument 1573 # 1574 lea FP_SRC(%a6),%a0 1575 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 1576 mov.l 0x8+0x4(%a6),0x4(%a0) 1577 mov.l 0x8+0x8(%a6),0x8(%a0) 1578 bsr.l tag # fetch operand type 1579 mov.b %d0,STAG(%a6) 1580 mov.b %d0,%d1 1581 1582 andi.l &0x00ff00ff,USER_FPSR(%a6) 1583 1584 clr.l %d0 1585 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1586 1587 tst.b %d1 1588 bne.b _L5_2x 1589 bsr.l stanh # operand is a NORM 1590 bra.b _L5_6x 1591 _L5_2x: 1592 cmpi.b %d1,&ZERO # is operand a ZERO? 1593 bne.b _L5_3x # no 1594 bsr.l src_zero # yes 1595 bra.b _L5_6x 1596 _L5_3x: 1597 cmpi.b %d1,&INF # is operand an INF? 1598 bne.b _L5_4x # no 1599 bsr.l src_one # yes 1600 bra.b _L5_6x 1601 _L5_4x: 1602 cmpi.b %d1,&QNAN # is operand a QNAN? 1603 bne.b _L5_5x # no 1604 bsr.l src_qnan # yes 1605 bra.b _L5_6x 1606 _L5_5x: 1607 bsr.l stanhd # operand is a DENORM 1608 _L5_6x: 1609 1610 # 1611 # Result is now in FP0 1612 # 1613 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1614 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1615 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1616 unlk %a6 1617 rts 1618 1619 1620 ######################################################################### 1621 # MONADIC TEMPLATE # 1622 ######################################################################### 1623 global _fatans_ 1624 _fatans_: 1625 link %a6,&-LOCAL_SIZE 1626 1627 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1628 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1629 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1630 1631 fmov.l &0x0,%fpcr # zero FPCR 1632 1633 # 1634 # copy, convert, and tag input argument 1635 # 1636 fmov.s 0x8(%a6),%fp0 # load sgl input 1637 fmov.x %fp0,FP_SRC(%a6) 1638 lea FP_SRC(%a6),%a0 1639 bsr.l tag # fetch operand type 1640 mov.b %d0,STAG(%a6) 1641 mov.b %d0,%d1 1642 1643 andi.l &0x00ff00ff,USER_FPSR(%a6) 1644 1645 clr.l %d0 1646 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1647 1648 tst.b %d1 1649 bne.b _L6_2s 1650 bsr.l satan # operand is a NORM 1651 bra.b _L6_6s 1652 _L6_2s: 1653 cmpi.b %d1,&ZERO # is operand a ZERO? 1654 bne.b _L6_3s # no 1655 bsr.l src_zero # yes 1656 bra.b _L6_6s 1657 _L6_3s: 1658 cmpi.b %d1,&INF # is operand an INF? 1659 bne.b _L6_4s # no 1660 bsr.l spi_2 # yes 1661 bra.b _L6_6s 1662 _L6_4s: 1663 cmpi.b %d1,&QNAN # is operand a QNAN? 1664 bne.b _L6_5s # no 1665 bsr.l src_qnan # yes 1666 bra.b _L6_6s 1667 _L6_5s: 1668 bsr.l satand # operand is a DENORM 1669 _L6_6s: 1670 1671 # 1672 # Result is now in FP0 1673 # 1674 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1675 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1676 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1677 unlk %a6 1678 rts 1679 1680 global _fatand_ 1681 _fatand_: 1682 link %a6,&-LOCAL_SIZE 1683 1684 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1685 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1686 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1687 1688 fmov.l &0x0,%fpcr # zero FPCR 1689 1690 # 1691 # copy, convert, and tag input argument 1692 # 1693 fmov.d 0x8(%a6),%fp0 # load dbl input 1694 fmov.x %fp0,FP_SRC(%a6) 1695 lea FP_SRC(%a6),%a0 1696 bsr.l tag # fetch operand type 1697 mov.b %d0,STAG(%a6) 1698 mov.b %d0,%d1 1699 1700 andi.l &0x00ff00ff,USER_FPSR(%a6) 1701 1702 clr.l %d0 1703 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1704 1705 mov.b %d1,STAG(%a6) 1706 tst.b %d1 1707 bne.b _L6_2d 1708 bsr.l satan # operand is a NORM 1709 bra.b _L6_6d 1710 _L6_2d: 1711 cmpi.b %d1,&ZERO # is operand a ZERO? 1712 bne.b _L6_3d # no 1713 bsr.l src_zero # yes 1714 bra.b _L6_6d 1715 _L6_3d: 1716 cmpi.b %d1,&INF # is operand an INF? 1717 bne.b _L6_4d # no 1718 bsr.l spi_2 # yes 1719 bra.b _L6_6d 1720 _L6_4d: 1721 cmpi.b %d1,&QNAN # is operand a QNAN? 1722 bne.b _L6_5d # no 1723 bsr.l src_qnan # yes 1724 bra.b _L6_6d 1725 _L6_5d: 1726 bsr.l satand # operand is a DENORM 1727 _L6_6d: 1728 1729 # 1730 # Result is now in FP0 1731 # 1732 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1733 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1734 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1735 unlk %a6 1736 rts 1737 1738 global _fatanx_ 1739 _fatanx_: 1740 link %a6,&-LOCAL_SIZE 1741 1742 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1743 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1744 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1745 1746 fmov.l &0x0,%fpcr # zero FPCR 1747 1748 # 1749 # copy, convert, and tag input argument 1750 # 1751 lea FP_SRC(%a6),%a0 1752 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 1753 mov.l 0x8+0x4(%a6),0x4(%a0) 1754 mov.l 0x8+0x8(%a6),0x8(%a0) 1755 bsr.l tag # fetch operand type 1756 mov.b %d0,STAG(%a6) 1757 mov.b %d0,%d1 1758 1759 andi.l &0x00ff00ff,USER_FPSR(%a6) 1760 1761 clr.l %d0 1762 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1763 1764 tst.b %d1 1765 bne.b _L6_2x 1766 bsr.l satan # operand is a NORM 1767 bra.b _L6_6x 1768 _L6_2x: 1769 cmpi.b %d1,&ZERO # is operand a ZERO? 1770 bne.b _L6_3x # no 1771 bsr.l src_zero # yes 1772 bra.b _L6_6x 1773 _L6_3x: 1774 cmpi.b %d1,&INF # is operand an INF? 1775 bne.b _L6_4x # no 1776 bsr.l spi_2 # yes 1777 bra.b _L6_6x 1778 _L6_4x: 1779 cmpi.b %d1,&QNAN # is operand a QNAN? 1780 bne.b _L6_5x # no 1781 bsr.l src_qnan # yes 1782 bra.b _L6_6x 1783 _L6_5x: 1784 bsr.l satand # operand is a DENORM 1785 _L6_6x: 1786 1787 # 1788 # Result is now in FP0 1789 # 1790 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1791 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1792 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1793 unlk %a6 1794 rts 1795 1796 1797 ######################################################################### 1798 # MONADIC TEMPLATE # 1799 ######################################################################### 1800 global _fasins_ 1801 _fasins_: 1802 link %a6,&-LOCAL_SIZE 1803 1804 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1805 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1806 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1807 1808 fmov.l &0x0,%fpcr # zero FPCR 1809 1810 # 1811 # copy, convert, and tag input argument 1812 # 1813 fmov.s 0x8(%a6),%fp0 # load sgl input 1814 fmov.x %fp0,FP_SRC(%a6) 1815 lea FP_SRC(%a6),%a0 1816 bsr.l tag # fetch operand type 1817 mov.b %d0,STAG(%a6) 1818 mov.b %d0,%d1 1819 1820 andi.l &0x00ff00ff,USER_FPSR(%a6) 1821 1822 clr.l %d0 1823 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1824 1825 tst.b %d1 1826 bne.b _L7_2s 1827 bsr.l sasin # operand is a NORM 1828 bra.b _L7_6s 1829 _L7_2s: 1830 cmpi.b %d1,&ZERO # is operand a ZERO? 1831 bne.b _L7_3s # no 1832 bsr.l src_zero # yes 1833 bra.b _L7_6s 1834 _L7_3s: 1835 cmpi.b %d1,&INF # is operand an INF? 1836 bne.b _L7_4s # no 1837 bsr.l t_operr # yes 1838 bra.b _L7_6s 1839 _L7_4s: 1840 cmpi.b %d1,&QNAN # is operand a QNAN? 1841 bne.b _L7_5s # no 1842 bsr.l src_qnan # yes 1843 bra.b _L7_6s 1844 _L7_5s: 1845 bsr.l sasind # operand is a DENORM 1846 _L7_6s: 1847 1848 # 1849 # Result is now in FP0 1850 # 1851 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1852 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1853 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1854 unlk %a6 1855 rts 1856 1857 global _fasind_ 1858 _fasind_: 1859 link %a6,&-LOCAL_SIZE 1860 1861 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1862 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1863 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1864 1865 fmov.l &0x0,%fpcr # zero FPCR 1866 1867 # 1868 # copy, convert, and tag input argument 1869 # 1870 fmov.d 0x8(%a6),%fp0 # load dbl input 1871 fmov.x %fp0,FP_SRC(%a6) 1872 lea FP_SRC(%a6),%a0 1873 bsr.l tag # fetch operand type 1874 mov.b %d0,STAG(%a6) 1875 mov.b %d0,%d1 1876 1877 andi.l &0x00ff00ff,USER_FPSR(%a6) 1878 1879 clr.l %d0 1880 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1881 1882 mov.b %d1,STAG(%a6) 1883 tst.b %d1 1884 bne.b _L7_2d 1885 bsr.l sasin # operand is a NORM 1886 bra.b _L7_6d 1887 _L7_2d: 1888 cmpi.b %d1,&ZERO # is operand a ZERO? 1889 bne.b _L7_3d # no 1890 bsr.l src_zero # yes 1891 bra.b _L7_6d 1892 _L7_3d: 1893 cmpi.b %d1,&INF # is operand an INF? 1894 bne.b _L7_4d # no 1895 bsr.l t_operr # yes 1896 bra.b _L7_6d 1897 _L7_4d: 1898 cmpi.b %d1,&QNAN # is operand a QNAN? 1899 bne.b _L7_5d # no 1900 bsr.l src_qnan # yes 1901 bra.b _L7_6d 1902 _L7_5d: 1903 bsr.l sasind # operand is a DENORM 1904 _L7_6d: 1905 1906 # 1907 # Result is now in FP0 1908 # 1909 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1910 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1911 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1912 unlk %a6 1913 rts 1914 1915 global _fasinx_ 1916 _fasinx_: 1917 link %a6,&-LOCAL_SIZE 1918 1919 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1920 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1921 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1922 1923 fmov.l &0x0,%fpcr # zero FPCR 1924 1925 # 1926 # copy, convert, and tag input argument 1927 # 1928 lea FP_SRC(%a6),%a0 1929 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 1930 mov.l 0x8+0x4(%a6),0x4(%a0) 1931 mov.l 0x8+0x8(%a6),0x8(%a0) 1932 bsr.l tag # fetch operand type 1933 mov.b %d0,STAG(%a6) 1934 mov.b %d0,%d1 1935 1936 andi.l &0x00ff00ff,USER_FPSR(%a6) 1937 1938 clr.l %d0 1939 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 1940 1941 tst.b %d1 1942 bne.b _L7_2x 1943 bsr.l sasin # operand is a NORM 1944 bra.b _L7_6x 1945 _L7_2x: 1946 cmpi.b %d1,&ZERO # is operand a ZERO? 1947 bne.b _L7_3x # no 1948 bsr.l src_zero # yes 1949 bra.b _L7_6x 1950 _L7_3x: 1951 cmpi.b %d1,&INF # is operand an INF? 1952 bne.b _L7_4x # no 1953 bsr.l t_operr # yes 1954 bra.b _L7_6x 1955 _L7_4x: 1956 cmpi.b %d1,&QNAN # is operand a QNAN? 1957 bne.b _L7_5x # no 1958 bsr.l src_qnan # yes 1959 bra.b _L7_6x 1960 _L7_5x: 1961 bsr.l sasind # operand is a DENORM 1962 _L7_6x: 1963 1964 # 1965 # Result is now in FP0 1966 # 1967 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 1968 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 1969 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 1970 unlk %a6 1971 rts 1972 1973 1974 ######################################################################### 1975 # MONADIC TEMPLATE # 1976 ######################################################################### 1977 global _fatanhs_ 1978 _fatanhs_: 1979 link %a6,&-LOCAL_SIZE 1980 1981 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 1982 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 1983 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 1984 1985 fmov.l &0x0,%fpcr # zero FPCR 1986 1987 # 1988 # copy, convert, and tag input argument 1989 # 1990 fmov.s 0x8(%a6),%fp0 # load sgl input 1991 fmov.x %fp0,FP_SRC(%a6) 1992 lea FP_SRC(%a6),%a0 1993 bsr.l tag # fetch operand type 1994 mov.b %d0,STAG(%a6) 1995 mov.b %d0,%d1 1996 1997 andi.l &0x00ff00ff,USER_FPSR(%a6) 1998 1999 clr.l %d0 2000 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2001 2002 tst.b %d1 2003 bne.b _L8_2s 2004 bsr.l satanh # operand is a NORM 2005 bra.b _L8_6s 2006 _L8_2s: 2007 cmpi.b %d1,&ZERO # is operand a ZERO? 2008 bne.b _L8_3s # no 2009 bsr.l src_zero # yes 2010 bra.b _L8_6s 2011 _L8_3s: 2012 cmpi.b %d1,&INF # is operand an INF? 2013 bne.b _L8_4s # no 2014 bsr.l t_operr # yes 2015 bra.b _L8_6s 2016 _L8_4s: 2017 cmpi.b %d1,&QNAN # is operand a QNAN? 2018 bne.b _L8_5s # no 2019 bsr.l src_qnan # yes 2020 bra.b _L8_6s 2021 _L8_5s: 2022 bsr.l satanhd # operand is a DENORM 2023 _L8_6s: 2024 2025 # 2026 # Result is now in FP0 2027 # 2028 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2029 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2030 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2031 unlk %a6 2032 rts 2033 2034 global _fatanhd_ 2035 _fatanhd_: 2036 link %a6,&-LOCAL_SIZE 2037 2038 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2039 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2040 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2041 2042 fmov.l &0x0,%fpcr # zero FPCR 2043 2044 # 2045 # copy, convert, and tag input argument 2046 # 2047 fmov.d 0x8(%a6),%fp0 # load dbl input 2048 fmov.x %fp0,FP_SRC(%a6) 2049 lea FP_SRC(%a6),%a0 2050 bsr.l tag # fetch operand type 2051 mov.b %d0,STAG(%a6) 2052 mov.b %d0,%d1 2053 2054 andi.l &0x00ff00ff,USER_FPSR(%a6) 2055 2056 clr.l %d0 2057 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2058 2059 mov.b %d1,STAG(%a6) 2060 tst.b %d1 2061 bne.b _L8_2d 2062 bsr.l satanh # operand is a NORM 2063 bra.b _L8_6d 2064 _L8_2d: 2065 cmpi.b %d1,&ZERO # is operand a ZERO? 2066 bne.b _L8_3d # no 2067 bsr.l src_zero # yes 2068 bra.b _L8_6d 2069 _L8_3d: 2070 cmpi.b %d1,&INF # is operand an INF? 2071 bne.b _L8_4d # no 2072 bsr.l t_operr # yes 2073 bra.b _L8_6d 2074 _L8_4d: 2075 cmpi.b %d1,&QNAN # is operand a QNAN? 2076 bne.b _L8_5d # no 2077 bsr.l src_qnan # yes 2078 bra.b _L8_6d 2079 _L8_5d: 2080 bsr.l satanhd # operand is a DENORM 2081 _L8_6d: 2082 2083 # 2084 # Result is now in FP0 2085 # 2086 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2087 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2088 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2089 unlk %a6 2090 rts 2091 2092 global _fatanhx_ 2093 _fatanhx_: 2094 link %a6,&-LOCAL_SIZE 2095 2096 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2097 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2098 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2099 2100 fmov.l &0x0,%fpcr # zero FPCR 2101 2102 # 2103 # copy, convert, and tag input argument 2104 # 2105 lea FP_SRC(%a6),%a0 2106 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 2107 mov.l 0x8+0x4(%a6),0x4(%a0) 2108 mov.l 0x8+0x8(%a6),0x8(%a0) 2109 bsr.l tag # fetch operand type 2110 mov.b %d0,STAG(%a6) 2111 mov.b %d0,%d1 2112 2113 andi.l &0x00ff00ff,USER_FPSR(%a6) 2114 2115 clr.l %d0 2116 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2117 2118 tst.b %d1 2119 bne.b _L8_2x 2120 bsr.l satanh # operand is a NORM 2121 bra.b _L8_6x 2122 _L8_2x: 2123 cmpi.b %d1,&ZERO # is operand a ZERO? 2124 bne.b _L8_3x # no 2125 bsr.l src_zero # yes 2126 bra.b _L8_6x 2127 _L8_3x: 2128 cmpi.b %d1,&INF # is operand an INF? 2129 bne.b _L8_4x # no 2130 bsr.l t_operr # yes 2131 bra.b _L8_6x 2132 _L8_4x: 2133 cmpi.b %d1,&QNAN # is operand a QNAN? 2134 bne.b _L8_5x # no 2135 bsr.l src_qnan # yes 2136 bra.b _L8_6x 2137 _L8_5x: 2138 bsr.l satanhd # operand is a DENORM 2139 _L8_6x: 2140 2141 # 2142 # Result is now in FP0 2143 # 2144 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2145 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2146 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2147 unlk %a6 2148 rts 2149 2150 2151 ######################################################################### 2152 # MONADIC TEMPLATE # 2153 ######################################################################### 2154 global _ftans_ 2155 _ftans_: 2156 link %a6,&-LOCAL_SIZE 2157 2158 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2159 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2160 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2161 2162 fmov.l &0x0,%fpcr # zero FPCR 2163 2164 # 2165 # copy, convert, and tag input argument 2166 # 2167 fmov.s 0x8(%a6),%fp0 # load sgl input 2168 fmov.x %fp0,FP_SRC(%a6) 2169 lea FP_SRC(%a6),%a0 2170 bsr.l tag # fetch operand type 2171 mov.b %d0,STAG(%a6) 2172 mov.b %d0,%d1 2173 2174 andi.l &0x00ff00ff,USER_FPSR(%a6) 2175 2176 clr.l %d0 2177 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2178 2179 tst.b %d1 2180 bne.b _L9_2s 2181 bsr.l stan # operand is a NORM 2182 bra.b _L9_6s 2183 _L9_2s: 2184 cmpi.b %d1,&ZERO # is operand a ZERO? 2185 bne.b _L9_3s # no 2186 bsr.l src_zero # yes 2187 bra.b _L9_6s 2188 _L9_3s: 2189 cmpi.b %d1,&INF # is operand an INF? 2190 bne.b _L9_4s # no 2191 bsr.l t_operr # yes 2192 bra.b _L9_6s 2193 _L9_4s: 2194 cmpi.b %d1,&QNAN # is operand a QNAN? 2195 bne.b _L9_5s # no 2196 bsr.l src_qnan # yes 2197 bra.b _L9_6s 2198 _L9_5s: 2199 bsr.l stand # operand is a DENORM 2200 _L9_6s: 2201 2202 # 2203 # Result is now in FP0 2204 # 2205 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2206 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2207 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2208 unlk %a6 2209 rts 2210 2211 global _ftand_ 2212 _ftand_: 2213 link %a6,&-LOCAL_SIZE 2214 2215 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2216 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2217 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2218 2219 fmov.l &0x0,%fpcr # zero FPCR 2220 2221 # 2222 # copy, convert, and tag input argument 2223 # 2224 fmov.d 0x8(%a6),%fp0 # load dbl input 2225 fmov.x %fp0,FP_SRC(%a6) 2226 lea FP_SRC(%a6),%a0 2227 bsr.l tag # fetch operand type 2228 mov.b %d0,STAG(%a6) 2229 mov.b %d0,%d1 2230 2231 andi.l &0x00ff00ff,USER_FPSR(%a6) 2232 2233 clr.l %d0 2234 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2235 2236 mov.b %d1,STAG(%a6) 2237 tst.b %d1 2238 bne.b _L9_2d 2239 bsr.l stan # operand is a NORM 2240 bra.b _L9_6d 2241 _L9_2d: 2242 cmpi.b %d1,&ZERO # is operand a ZERO? 2243 bne.b _L9_3d # no 2244 bsr.l src_zero # yes 2245 bra.b _L9_6d 2246 _L9_3d: 2247 cmpi.b %d1,&INF # is operand an INF? 2248 bne.b _L9_4d # no 2249 bsr.l t_operr # yes 2250 bra.b _L9_6d 2251 _L9_4d: 2252 cmpi.b %d1,&QNAN # is operand a QNAN? 2253 bne.b _L9_5d # no 2254 bsr.l src_qnan # yes 2255 bra.b _L9_6d 2256 _L9_5d: 2257 bsr.l stand # operand is a DENORM 2258 _L9_6d: 2259 2260 # 2261 # Result is now in FP0 2262 # 2263 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2264 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2265 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2266 unlk %a6 2267 rts 2268 2269 global _ftanx_ 2270 _ftanx_: 2271 link %a6,&-LOCAL_SIZE 2272 2273 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2274 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2275 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2276 2277 fmov.l &0x0,%fpcr # zero FPCR 2278 2279 # 2280 # copy, convert, and tag input argument 2281 # 2282 lea FP_SRC(%a6),%a0 2283 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 2284 mov.l 0x8+0x4(%a6),0x4(%a0) 2285 mov.l 0x8+0x8(%a6),0x8(%a0) 2286 bsr.l tag # fetch operand type 2287 mov.b %d0,STAG(%a6) 2288 mov.b %d0,%d1 2289 2290 andi.l &0x00ff00ff,USER_FPSR(%a6) 2291 2292 clr.l %d0 2293 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2294 2295 tst.b %d1 2296 bne.b _L9_2x 2297 bsr.l stan # operand is a NORM 2298 bra.b _L9_6x 2299 _L9_2x: 2300 cmpi.b %d1,&ZERO # is operand a ZERO? 2301 bne.b _L9_3x # no 2302 bsr.l src_zero # yes 2303 bra.b _L9_6x 2304 _L9_3x: 2305 cmpi.b %d1,&INF # is operand an INF? 2306 bne.b _L9_4x # no 2307 bsr.l t_operr # yes 2308 bra.b _L9_6x 2309 _L9_4x: 2310 cmpi.b %d1,&QNAN # is operand a QNAN? 2311 bne.b _L9_5x # no 2312 bsr.l src_qnan # yes 2313 bra.b _L9_6x 2314 _L9_5x: 2315 bsr.l stand # operand is a DENORM 2316 _L9_6x: 2317 2318 # 2319 # Result is now in FP0 2320 # 2321 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2322 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2323 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2324 unlk %a6 2325 rts 2326 2327 2328 ######################################################################### 2329 # MONADIC TEMPLATE # 2330 ######################################################################### 2331 global _fetoxs_ 2332 _fetoxs_: 2333 link %a6,&-LOCAL_SIZE 2334 2335 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2336 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2337 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2338 2339 fmov.l &0x0,%fpcr # zero FPCR 2340 2341 # 2342 # copy, convert, and tag input argument 2343 # 2344 fmov.s 0x8(%a6),%fp0 # load sgl input 2345 fmov.x %fp0,FP_SRC(%a6) 2346 lea FP_SRC(%a6),%a0 2347 bsr.l tag # fetch operand type 2348 mov.b %d0,STAG(%a6) 2349 mov.b %d0,%d1 2350 2351 andi.l &0x00ff00ff,USER_FPSR(%a6) 2352 2353 clr.l %d0 2354 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2355 2356 tst.b %d1 2357 bne.b _L10_2s 2358 bsr.l setox # operand is a NORM 2359 bra.b _L10_6s 2360 _L10_2s: 2361 cmpi.b %d1,&ZERO # is operand a ZERO? 2362 bne.b _L10_3s # no 2363 bsr.l ld_pone # yes 2364 bra.b _L10_6s 2365 _L10_3s: 2366 cmpi.b %d1,&INF # is operand an INF? 2367 bne.b _L10_4s # no 2368 bsr.l szr_inf # yes 2369 bra.b _L10_6s 2370 _L10_4s: 2371 cmpi.b %d1,&QNAN # is operand a QNAN? 2372 bne.b _L10_5s # no 2373 bsr.l src_qnan # yes 2374 bra.b _L10_6s 2375 _L10_5s: 2376 bsr.l setoxd # operand is a DENORM 2377 _L10_6s: 2378 2379 # 2380 # Result is now in FP0 2381 # 2382 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2383 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2384 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2385 unlk %a6 2386 rts 2387 2388 global _fetoxd_ 2389 _fetoxd_: 2390 link %a6,&-LOCAL_SIZE 2391 2392 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2393 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2394 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2395 2396 fmov.l &0x0,%fpcr # zero FPCR 2397 2398 # 2399 # copy, convert, and tag input argument 2400 # 2401 fmov.d 0x8(%a6),%fp0 # load dbl input 2402 fmov.x %fp0,FP_SRC(%a6) 2403 lea FP_SRC(%a6),%a0 2404 bsr.l tag # fetch operand type 2405 mov.b %d0,STAG(%a6) 2406 mov.b %d0,%d1 2407 2408 andi.l &0x00ff00ff,USER_FPSR(%a6) 2409 2410 clr.l %d0 2411 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2412 2413 mov.b %d1,STAG(%a6) 2414 tst.b %d1 2415 bne.b _L10_2d 2416 bsr.l setox # operand is a NORM 2417 bra.b _L10_6d 2418 _L10_2d: 2419 cmpi.b %d1,&ZERO # is operand a ZERO? 2420 bne.b _L10_3d # no 2421 bsr.l ld_pone # yes 2422 bra.b _L10_6d 2423 _L10_3d: 2424 cmpi.b %d1,&INF # is operand an INF? 2425 bne.b _L10_4d # no 2426 bsr.l szr_inf # yes 2427 bra.b _L10_6d 2428 _L10_4d: 2429 cmpi.b %d1,&QNAN # is operand a QNAN? 2430 bne.b _L10_5d # no 2431 bsr.l src_qnan # yes 2432 bra.b _L10_6d 2433 _L10_5d: 2434 bsr.l setoxd # operand is a DENORM 2435 _L10_6d: 2436 2437 # 2438 # Result is now in FP0 2439 # 2440 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2441 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2442 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2443 unlk %a6 2444 rts 2445 2446 global _fetoxx_ 2447 _fetoxx_: 2448 link %a6,&-LOCAL_SIZE 2449 2450 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2451 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2452 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2453 2454 fmov.l &0x0,%fpcr # zero FPCR 2455 2456 # 2457 # copy, convert, and tag input argument 2458 # 2459 lea FP_SRC(%a6),%a0 2460 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 2461 mov.l 0x8+0x4(%a6),0x4(%a0) 2462 mov.l 0x8+0x8(%a6),0x8(%a0) 2463 bsr.l tag # fetch operand type 2464 mov.b %d0,STAG(%a6) 2465 mov.b %d0,%d1 2466 2467 andi.l &0x00ff00ff,USER_FPSR(%a6) 2468 2469 clr.l %d0 2470 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2471 2472 tst.b %d1 2473 bne.b _L10_2x 2474 bsr.l setox # operand is a NORM 2475 bra.b _L10_6x 2476 _L10_2x: 2477 cmpi.b %d1,&ZERO # is operand a ZERO? 2478 bne.b _L10_3x # no 2479 bsr.l ld_pone # yes 2480 bra.b _L10_6x 2481 _L10_3x: 2482 cmpi.b %d1,&INF # is operand an INF? 2483 bne.b _L10_4x # no 2484 bsr.l szr_inf # yes 2485 bra.b _L10_6x 2486 _L10_4x: 2487 cmpi.b %d1,&QNAN # is operand a QNAN? 2488 bne.b _L10_5x # no 2489 bsr.l src_qnan # yes 2490 bra.b _L10_6x 2491 _L10_5x: 2492 bsr.l setoxd # operand is a DENORM 2493 _L10_6x: 2494 2495 # 2496 # Result is now in FP0 2497 # 2498 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2499 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2500 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2501 unlk %a6 2502 rts 2503 2504 2505 ######################################################################### 2506 # MONADIC TEMPLATE # 2507 ######################################################################### 2508 global _ftwotoxs_ 2509 _ftwotoxs_: 2510 link %a6,&-LOCAL_SIZE 2511 2512 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2513 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2514 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2515 2516 fmov.l &0x0,%fpcr # zero FPCR 2517 2518 # 2519 # copy, convert, and tag input argument 2520 # 2521 fmov.s 0x8(%a6),%fp0 # load sgl input 2522 fmov.x %fp0,FP_SRC(%a6) 2523 lea FP_SRC(%a6),%a0 2524 bsr.l tag # fetch operand type 2525 mov.b %d0,STAG(%a6) 2526 mov.b %d0,%d1 2527 2528 andi.l &0x00ff00ff,USER_FPSR(%a6) 2529 2530 clr.l %d0 2531 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2532 2533 tst.b %d1 2534 bne.b _L11_2s 2535 bsr.l stwotox # operand is a NORM 2536 bra.b _L11_6s 2537 _L11_2s: 2538 cmpi.b %d1,&ZERO # is operand a ZERO? 2539 bne.b _L11_3s # no 2540 bsr.l ld_pone # yes 2541 bra.b _L11_6s 2542 _L11_3s: 2543 cmpi.b %d1,&INF # is operand an INF? 2544 bne.b _L11_4s # no 2545 bsr.l szr_inf # yes 2546 bra.b _L11_6s 2547 _L11_4s: 2548 cmpi.b %d1,&QNAN # is operand a QNAN? 2549 bne.b _L11_5s # no 2550 bsr.l src_qnan # yes 2551 bra.b _L11_6s 2552 _L11_5s: 2553 bsr.l stwotoxd # operand is a DENORM 2554 _L11_6s: 2555 2556 # 2557 # Result is now in FP0 2558 # 2559 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2560 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2561 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2562 unlk %a6 2563 rts 2564 2565 global _ftwotoxd_ 2566 _ftwotoxd_: 2567 link %a6,&-LOCAL_SIZE 2568 2569 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2570 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2571 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2572 2573 fmov.l &0x0,%fpcr # zero FPCR 2574 2575 # 2576 # copy, convert, and tag input argument 2577 # 2578 fmov.d 0x8(%a6),%fp0 # load dbl input 2579 fmov.x %fp0,FP_SRC(%a6) 2580 lea FP_SRC(%a6),%a0 2581 bsr.l tag # fetch operand type 2582 mov.b %d0,STAG(%a6) 2583 mov.b %d0,%d1 2584 2585 andi.l &0x00ff00ff,USER_FPSR(%a6) 2586 2587 clr.l %d0 2588 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2589 2590 mov.b %d1,STAG(%a6) 2591 tst.b %d1 2592 bne.b _L11_2d 2593 bsr.l stwotox # operand is a NORM 2594 bra.b _L11_6d 2595 _L11_2d: 2596 cmpi.b %d1,&ZERO # is operand a ZERO? 2597 bne.b _L11_3d # no 2598 bsr.l ld_pone # yes 2599 bra.b _L11_6d 2600 _L11_3d: 2601 cmpi.b %d1,&INF # is operand an INF? 2602 bne.b _L11_4d # no 2603 bsr.l szr_inf # yes 2604 bra.b _L11_6d 2605 _L11_4d: 2606 cmpi.b %d1,&QNAN # is operand a QNAN? 2607 bne.b _L11_5d # no 2608 bsr.l src_qnan # yes 2609 bra.b _L11_6d 2610 _L11_5d: 2611 bsr.l stwotoxd # operand is a DENORM 2612 _L11_6d: 2613 2614 # 2615 # Result is now in FP0 2616 # 2617 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2618 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2619 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2620 unlk %a6 2621 rts 2622 2623 global _ftwotoxx_ 2624 _ftwotoxx_: 2625 link %a6,&-LOCAL_SIZE 2626 2627 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2628 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2629 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2630 2631 fmov.l &0x0,%fpcr # zero FPCR 2632 2633 # 2634 # copy, convert, and tag input argument 2635 # 2636 lea FP_SRC(%a6),%a0 2637 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 2638 mov.l 0x8+0x4(%a6),0x4(%a0) 2639 mov.l 0x8+0x8(%a6),0x8(%a0) 2640 bsr.l tag # fetch operand type 2641 mov.b %d0,STAG(%a6) 2642 mov.b %d0,%d1 2643 2644 andi.l &0x00ff00ff,USER_FPSR(%a6) 2645 2646 clr.l %d0 2647 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2648 2649 tst.b %d1 2650 bne.b _L11_2x 2651 bsr.l stwotox # operand is a NORM 2652 bra.b _L11_6x 2653 _L11_2x: 2654 cmpi.b %d1,&ZERO # is operand a ZERO? 2655 bne.b _L11_3x # no 2656 bsr.l ld_pone # yes 2657 bra.b _L11_6x 2658 _L11_3x: 2659 cmpi.b %d1,&INF # is operand an INF? 2660 bne.b _L11_4x # no 2661 bsr.l szr_inf # yes 2662 bra.b _L11_6x 2663 _L11_4x: 2664 cmpi.b %d1,&QNAN # is operand a QNAN? 2665 bne.b _L11_5x # no 2666 bsr.l src_qnan # yes 2667 bra.b _L11_6x 2668 _L11_5x: 2669 bsr.l stwotoxd # operand is a DENORM 2670 _L11_6x: 2671 2672 # 2673 # Result is now in FP0 2674 # 2675 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2676 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2677 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2678 unlk %a6 2679 rts 2680 2681 2682 ######################################################################### 2683 # MONADIC TEMPLATE # 2684 ######################################################################### 2685 global _ftentoxs_ 2686 _ftentoxs_: 2687 link %a6,&-LOCAL_SIZE 2688 2689 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2690 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2691 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2692 2693 fmov.l &0x0,%fpcr # zero FPCR 2694 2695 # 2696 # copy, convert, and tag input argument 2697 # 2698 fmov.s 0x8(%a6),%fp0 # load sgl input 2699 fmov.x %fp0,FP_SRC(%a6) 2700 lea FP_SRC(%a6),%a0 2701 bsr.l tag # fetch operand type 2702 mov.b %d0,STAG(%a6) 2703 mov.b %d0,%d1 2704 2705 andi.l &0x00ff00ff,USER_FPSR(%a6) 2706 2707 clr.l %d0 2708 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2709 2710 tst.b %d1 2711 bne.b _L12_2s 2712 bsr.l stentox # operand is a NORM 2713 bra.b _L12_6s 2714 _L12_2s: 2715 cmpi.b %d1,&ZERO # is operand a ZERO? 2716 bne.b _L12_3s # no 2717 bsr.l ld_pone # yes 2718 bra.b _L12_6s 2719 _L12_3s: 2720 cmpi.b %d1,&INF # is operand an INF? 2721 bne.b _L12_4s # no 2722 bsr.l szr_inf # yes 2723 bra.b _L12_6s 2724 _L12_4s: 2725 cmpi.b %d1,&QNAN # is operand a QNAN? 2726 bne.b _L12_5s # no 2727 bsr.l src_qnan # yes 2728 bra.b _L12_6s 2729 _L12_5s: 2730 bsr.l stentoxd # operand is a DENORM 2731 _L12_6s: 2732 2733 # 2734 # Result is now in FP0 2735 # 2736 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2737 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2738 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2739 unlk %a6 2740 rts 2741 2742 global _ftentoxd_ 2743 _ftentoxd_: 2744 link %a6,&-LOCAL_SIZE 2745 2746 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2747 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2748 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2749 2750 fmov.l &0x0,%fpcr # zero FPCR 2751 2752 # 2753 # copy, convert, and tag input argument 2754 # 2755 fmov.d 0x8(%a6),%fp0 # load dbl input 2756 fmov.x %fp0,FP_SRC(%a6) 2757 lea FP_SRC(%a6),%a0 2758 bsr.l tag # fetch operand type 2759 mov.b %d0,STAG(%a6) 2760 mov.b %d0,%d1 2761 2762 andi.l &0x00ff00ff,USER_FPSR(%a6) 2763 2764 clr.l %d0 2765 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2766 2767 mov.b %d1,STAG(%a6) 2768 tst.b %d1 2769 bne.b _L12_2d 2770 bsr.l stentox # operand is a NORM 2771 bra.b _L12_6d 2772 _L12_2d: 2773 cmpi.b %d1,&ZERO # is operand a ZERO? 2774 bne.b _L12_3d # no 2775 bsr.l ld_pone # yes 2776 bra.b _L12_6d 2777 _L12_3d: 2778 cmpi.b %d1,&INF # is operand an INF? 2779 bne.b _L12_4d # no 2780 bsr.l szr_inf # yes 2781 bra.b _L12_6d 2782 _L12_4d: 2783 cmpi.b %d1,&QNAN # is operand a QNAN? 2784 bne.b _L12_5d # no 2785 bsr.l src_qnan # yes 2786 bra.b _L12_6d 2787 _L12_5d: 2788 bsr.l stentoxd # operand is a DENORM 2789 _L12_6d: 2790 2791 # 2792 # Result is now in FP0 2793 # 2794 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2795 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2796 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2797 unlk %a6 2798 rts 2799 2800 global _ftentoxx_ 2801 _ftentoxx_: 2802 link %a6,&-LOCAL_SIZE 2803 2804 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2805 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2806 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2807 2808 fmov.l &0x0,%fpcr # zero FPCR 2809 2810 # 2811 # copy, convert, and tag input argument 2812 # 2813 lea FP_SRC(%a6),%a0 2814 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 2815 mov.l 0x8+0x4(%a6),0x4(%a0) 2816 mov.l 0x8+0x8(%a6),0x8(%a0) 2817 bsr.l tag # fetch operand type 2818 mov.b %d0,STAG(%a6) 2819 mov.b %d0,%d1 2820 2821 andi.l &0x00ff00ff,USER_FPSR(%a6) 2822 2823 clr.l %d0 2824 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2825 2826 tst.b %d1 2827 bne.b _L12_2x 2828 bsr.l stentox # operand is a NORM 2829 bra.b _L12_6x 2830 _L12_2x: 2831 cmpi.b %d1,&ZERO # is operand a ZERO? 2832 bne.b _L12_3x # no 2833 bsr.l ld_pone # yes 2834 bra.b _L12_6x 2835 _L12_3x: 2836 cmpi.b %d1,&INF # is operand an INF? 2837 bne.b _L12_4x # no 2838 bsr.l szr_inf # yes 2839 bra.b _L12_6x 2840 _L12_4x: 2841 cmpi.b %d1,&QNAN # is operand a QNAN? 2842 bne.b _L12_5x # no 2843 bsr.l src_qnan # yes 2844 bra.b _L12_6x 2845 _L12_5x: 2846 bsr.l stentoxd # operand is a DENORM 2847 _L12_6x: 2848 2849 # 2850 # Result is now in FP0 2851 # 2852 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2853 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2854 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2855 unlk %a6 2856 rts 2857 2858 2859 ######################################################################### 2860 # MONADIC TEMPLATE # 2861 ######################################################################### 2862 global _flogns_ 2863 _flogns_: 2864 link %a6,&-LOCAL_SIZE 2865 2866 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2867 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2868 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2869 2870 fmov.l &0x0,%fpcr # zero FPCR 2871 2872 # 2873 # copy, convert, and tag input argument 2874 # 2875 fmov.s 0x8(%a6),%fp0 # load sgl input 2876 fmov.x %fp0,FP_SRC(%a6) 2877 lea FP_SRC(%a6),%a0 2878 bsr.l tag # fetch operand type 2879 mov.b %d0,STAG(%a6) 2880 mov.b %d0,%d1 2881 2882 andi.l &0x00ff00ff,USER_FPSR(%a6) 2883 2884 clr.l %d0 2885 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2886 2887 tst.b %d1 2888 bne.b _L13_2s 2889 bsr.l slogn # operand is a NORM 2890 bra.b _L13_6s 2891 _L13_2s: 2892 cmpi.b %d1,&ZERO # is operand a ZERO? 2893 bne.b _L13_3s # no 2894 bsr.l t_dz2 # yes 2895 bra.b _L13_6s 2896 _L13_3s: 2897 cmpi.b %d1,&INF # is operand an INF? 2898 bne.b _L13_4s # no 2899 bsr.l sopr_inf # yes 2900 bra.b _L13_6s 2901 _L13_4s: 2902 cmpi.b %d1,&QNAN # is operand a QNAN? 2903 bne.b _L13_5s # no 2904 bsr.l src_qnan # yes 2905 bra.b _L13_6s 2906 _L13_5s: 2907 bsr.l slognd # operand is a DENORM 2908 _L13_6s: 2909 2910 # 2911 # Result is now in FP0 2912 # 2913 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2914 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2915 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2916 unlk %a6 2917 rts 2918 2919 global _flognd_ 2920 _flognd_: 2921 link %a6,&-LOCAL_SIZE 2922 2923 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2924 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2925 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2926 2927 fmov.l &0x0,%fpcr # zero FPCR 2928 2929 # 2930 # copy, convert, and tag input argument 2931 # 2932 fmov.d 0x8(%a6),%fp0 # load dbl input 2933 fmov.x %fp0,FP_SRC(%a6) 2934 lea FP_SRC(%a6),%a0 2935 bsr.l tag # fetch operand type 2936 mov.b %d0,STAG(%a6) 2937 mov.b %d0,%d1 2938 2939 andi.l &0x00ff00ff,USER_FPSR(%a6) 2940 2941 clr.l %d0 2942 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 2943 2944 mov.b %d1,STAG(%a6) 2945 tst.b %d1 2946 bne.b _L13_2d 2947 bsr.l slogn # operand is a NORM 2948 bra.b _L13_6d 2949 _L13_2d: 2950 cmpi.b %d1,&ZERO # is operand a ZERO? 2951 bne.b _L13_3d # no 2952 bsr.l t_dz2 # yes 2953 bra.b _L13_6d 2954 _L13_3d: 2955 cmpi.b %d1,&INF # is operand an INF? 2956 bne.b _L13_4d # no 2957 bsr.l sopr_inf # yes 2958 bra.b _L13_6d 2959 _L13_4d: 2960 cmpi.b %d1,&QNAN # is operand a QNAN? 2961 bne.b _L13_5d # no 2962 bsr.l src_qnan # yes 2963 bra.b _L13_6d 2964 _L13_5d: 2965 bsr.l slognd # operand is a DENORM 2966 _L13_6d: 2967 2968 # 2969 # Result is now in FP0 2970 # 2971 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 2972 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 2973 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 2974 unlk %a6 2975 rts 2976 2977 global _flognx_ 2978 _flognx_: 2979 link %a6,&-LOCAL_SIZE 2980 2981 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 2982 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 2983 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 2984 2985 fmov.l &0x0,%fpcr # zero FPCR 2986 2987 # 2988 # copy, convert, and tag input argument 2989 # 2990 lea FP_SRC(%a6),%a0 2991 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 2992 mov.l 0x8+0x4(%a6),0x4(%a0) 2993 mov.l 0x8+0x8(%a6),0x8(%a0) 2994 bsr.l tag # fetch operand type 2995 mov.b %d0,STAG(%a6) 2996 mov.b %d0,%d1 2997 2998 andi.l &0x00ff00ff,USER_FPSR(%a6) 2999 3000 clr.l %d0 3001 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3002 3003 tst.b %d1 3004 bne.b _L13_2x 3005 bsr.l slogn # operand is a NORM 3006 bra.b _L13_6x 3007 _L13_2x: 3008 cmpi.b %d1,&ZERO # is operand a ZERO? 3009 bne.b _L13_3x # no 3010 bsr.l t_dz2 # yes 3011 bra.b _L13_6x 3012 _L13_3x: 3013 cmpi.b %d1,&INF # is operand an INF? 3014 bne.b _L13_4x # no 3015 bsr.l sopr_inf # yes 3016 bra.b _L13_6x 3017 _L13_4x: 3018 cmpi.b %d1,&QNAN # is operand a QNAN? 3019 bne.b _L13_5x # no 3020 bsr.l src_qnan # yes 3021 bra.b _L13_6x 3022 _L13_5x: 3023 bsr.l slognd # operand is a DENORM 3024 _L13_6x: 3025 3026 # 3027 # Result is now in FP0 3028 # 3029 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3030 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3031 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3032 unlk %a6 3033 rts 3034 3035 3036 ######################################################################### 3037 # MONADIC TEMPLATE # 3038 ######################################################################### 3039 global _flog10s_ 3040 _flog10s_: 3041 link %a6,&-LOCAL_SIZE 3042 3043 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3044 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3045 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3046 3047 fmov.l &0x0,%fpcr # zero FPCR 3048 3049 # 3050 # copy, convert, and tag input argument 3051 # 3052 fmov.s 0x8(%a6),%fp0 # load sgl input 3053 fmov.x %fp0,FP_SRC(%a6) 3054 lea FP_SRC(%a6),%a0 3055 bsr.l tag # fetch operand type 3056 mov.b %d0,STAG(%a6) 3057 mov.b %d0,%d1 3058 3059 andi.l &0x00ff00ff,USER_FPSR(%a6) 3060 3061 clr.l %d0 3062 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3063 3064 tst.b %d1 3065 bne.b _L14_2s 3066 bsr.l slog10 # operand is a NORM 3067 bra.b _L14_6s 3068 _L14_2s: 3069 cmpi.b %d1,&ZERO # is operand a ZERO? 3070 bne.b _L14_3s # no 3071 bsr.l t_dz2 # yes 3072 bra.b _L14_6s 3073 _L14_3s: 3074 cmpi.b %d1,&INF # is operand an INF? 3075 bne.b _L14_4s # no 3076 bsr.l sopr_inf # yes 3077 bra.b _L14_6s 3078 _L14_4s: 3079 cmpi.b %d1,&QNAN # is operand a QNAN? 3080 bne.b _L14_5s # no 3081 bsr.l src_qnan # yes 3082 bra.b _L14_6s 3083 _L14_5s: 3084 bsr.l slog10d # operand is a DENORM 3085 _L14_6s: 3086 3087 # 3088 # Result is now in FP0 3089 # 3090 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3091 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3092 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3093 unlk %a6 3094 rts 3095 3096 global _flog10d_ 3097 _flog10d_: 3098 link %a6,&-LOCAL_SIZE 3099 3100 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3101 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3102 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3103 3104 fmov.l &0x0,%fpcr # zero FPCR 3105 3106 # 3107 # copy, convert, and tag input argument 3108 # 3109 fmov.d 0x8(%a6),%fp0 # load dbl input 3110 fmov.x %fp0,FP_SRC(%a6) 3111 lea FP_SRC(%a6),%a0 3112 bsr.l tag # fetch operand type 3113 mov.b %d0,STAG(%a6) 3114 mov.b %d0,%d1 3115 3116 andi.l &0x00ff00ff,USER_FPSR(%a6) 3117 3118 clr.l %d0 3119 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3120 3121 mov.b %d1,STAG(%a6) 3122 tst.b %d1 3123 bne.b _L14_2d 3124 bsr.l slog10 # operand is a NORM 3125 bra.b _L14_6d 3126 _L14_2d: 3127 cmpi.b %d1,&ZERO # is operand a ZERO? 3128 bne.b _L14_3d # no 3129 bsr.l t_dz2 # yes 3130 bra.b _L14_6d 3131 _L14_3d: 3132 cmpi.b %d1,&INF # is operand an INF? 3133 bne.b _L14_4d # no 3134 bsr.l sopr_inf # yes 3135 bra.b _L14_6d 3136 _L14_4d: 3137 cmpi.b %d1,&QNAN # is operand a QNAN? 3138 bne.b _L14_5d # no 3139 bsr.l src_qnan # yes 3140 bra.b _L14_6d 3141 _L14_5d: 3142 bsr.l slog10d # operand is a DENORM 3143 _L14_6d: 3144 3145 # 3146 # Result is now in FP0 3147 # 3148 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3149 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3150 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3151 unlk %a6 3152 rts 3153 3154 global _flog10x_ 3155 _flog10x_: 3156 link %a6,&-LOCAL_SIZE 3157 3158 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3159 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3160 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3161 3162 fmov.l &0x0,%fpcr # zero FPCR 3163 3164 # 3165 # copy, convert, and tag input argument 3166 # 3167 lea FP_SRC(%a6),%a0 3168 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 3169 mov.l 0x8+0x4(%a6),0x4(%a0) 3170 mov.l 0x8+0x8(%a6),0x8(%a0) 3171 bsr.l tag # fetch operand type 3172 mov.b %d0,STAG(%a6) 3173 mov.b %d0,%d1 3174 3175 andi.l &0x00ff00ff,USER_FPSR(%a6) 3176 3177 clr.l %d0 3178 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3179 3180 tst.b %d1 3181 bne.b _L14_2x 3182 bsr.l slog10 # operand is a NORM 3183 bra.b _L14_6x 3184 _L14_2x: 3185 cmpi.b %d1,&ZERO # is operand a ZERO? 3186 bne.b _L14_3x # no 3187 bsr.l t_dz2 # yes 3188 bra.b _L14_6x 3189 _L14_3x: 3190 cmpi.b %d1,&INF # is operand an INF? 3191 bne.b _L14_4x # no 3192 bsr.l sopr_inf # yes 3193 bra.b _L14_6x 3194 _L14_4x: 3195 cmpi.b %d1,&QNAN # is operand a QNAN? 3196 bne.b _L14_5x # no 3197 bsr.l src_qnan # yes 3198 bra.b _L14_6x 3199 _L14_5x: 3200 bsr.l slog10d # operand is a DENORM 3201 _L14_6x: 3202 3203 # 3204 # Result is now in FP0 3205 # 3206 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3207 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3208 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3209 unlk %a6 3210 rts 3211 3212 3213 ######################################################################### 3214 # MONADIC TEMPLATE # 3215 ######################################################################### 3216 global _flog2s_ 3217 _flog2s_: 3218 link %a6,&-LOCAL_SIZE 3219 3220 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3221 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3222 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3223 3224 fmov.l &0x0,%fpcr # zero FPCR 3225 3226 # 3227 # copy, convert, and tag input argument 3228 # 3229 fmov.s 0x8(%a6),%fp0 # load sgl input 3230 fmov.x %fp0,FP_SRC(%a6) 3231 lea FP_SRC(%a6),%a0 3232 bsr.l tag # fetch operand type 3233 mov.b %d0,STAG(%a6) 3234 mov.b %d0,%d1 3235 3236 andi.l &0x00ff00ff,USER_FPSR(%a6) 3237 3238 clr.l %d0 3239 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3240 3241 tst.b %d1 3242 bne.b _L15_2s 3243 bsr.l slog2 # operand is a NORM 3244 bra.b _L15_6s 3245 _L15_2s: 3246 cmpi.b %d1,&ZERO # is operand a ZERO? 3247 bne.b _L15_3s # no 3248 bsr.l t_dz2 # yes 3249 bra.b _L15_6s 3250 _L15_3s: 3251 cmpi.b %d1,&INF # is operand an INF? 3252 bne.b _L15_4s # no 3253 bsr.l sopr_inf # yes 3254 bra.b _L15_6s 3255 _L15_4s: 3256 cmpi.b %d1,&QNAN # is operand a QNAN? 3257 bne.b _L15_5s # no 3258 bsr.l src_qnan # yes 3259 bra.b _L15_6s 3260 _L15_5s: 3261 bsr.l slog2d # operand is a DENORM 3262 _L15_6s: 3263 3264 # 3265 # Result is now in FP0 3266 # 3267 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3268 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3269 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3270 unlk %a6 3271 rts 3272 3273 global _flog2d_ 3274 _flog2d_: 3275 link %a6,&-LOCAL_SIZE 3276 3277 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3278 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3279 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3280 3281 fmov.l &0x0,%fpcr # zero FPCR 3282 3283 # 3284 # copy, convert, and tag input argument 3285 # 3286 fmov.d 0x8(%a6),%fp0 # load dbl input 3287 fmov.x %fp0,FP_SRC(%a6) 3288 lea FP_SRC(%a6),%a0 3289 bsr.l tag # fetch operand type 3290 mov.b %d0,STAG(%a6) 3291 mov.b %d0,%d1 3292 3293 andi.l &0x00ff00ff,USER_FPSR(%a6) 3294 3295 clr.l %d0 3296 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3297 3298 mov.b %d1,STAG(%a6) 3299 tst.b %d1 3300 bne.b _L15_2d 3301 bsr.l slog2 # operand is a NORM 3302 bra.b _L15_6d 3303 _L15_2d: 3304 cmpi.b %d1,&ZERO # is operand a ZERO? 3305 bne.b _L15_3d # no 3306 bsr.l t_dz2 # yes 3307 bra.b _L15_6d 3308 _L15_3d: 3309 cmpi.b %d1,&INF # is operand an INF? 3310 bne.b _L15_4d # no 3311 bsr.l sopr_inf # yes 3312 bra.b _L15_6d 3313 _L15_4d: 3314 cmpi.b %d1,&QNAN # is operand a QNAN? 3315 bne.b _L15_5d # no 3316 bsr.l src_qnan # yes 3317 bra.b _L15_6d 3318 _L15_5d: 3319 bsr.l slog2d # operand is a DENORM 3320 _L15_6d: 3321 3322 # 3323 # Result is now in FP0 3324 # 3325 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3326 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3327 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3328 unlk %a6 3329 rts 3330 3331 global _flog2x_ 3332 _flog2x_: 3333 link %a6,&-LOCAL_SIZE 3334 3335 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3336 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3337 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3338 3339 fmov.l &0x0,%fpcr # zero FPCR 3340 3341 # 3342 # copy, convert, and tag input argument 3343 # 3344 lea FP_SRC(%a6),%a0 3345 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 3346 mov.l 0x8+0x4(%a6),0x4(%a0) 3347 mov.l 0x8+0x8(%a6),0x8(%a0) 3348 bsr.l tag # fetch operand type 3349 mov.b %d0,STAG(%a6) 3350 mov.b %d0,%d1 3351 3352 andi.l &0x00ff00ff,USER_FPSR(%a6) 3353 3354 clr.l %d0 3355 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3356 3357 tst.b %d1 3358 bne.b _L15_2x 3359 bsr.l slog2 # operand is a NORM 3360 bra.b _L15_6x 3361 _L15_2x: 3362 cmpi.b %d1,&ZERO # is operand a ZERO? 3363 bne.b _L15_3x # no 3364 bsr.l t_dz2 # yes 3365 bra.b _L15_6x 3366 _L15_3x: 3367 cmpi.b %d1,&INF # is operand an INF? 3368 bne.b _L15_4x # no 3369 bsr.l sopr_inf # yes 3370 bra.b _L15_6x 3371 _L15_4x: 3372 cmpi.b %d1,&QNAN # is operand a QNAN? 3373 bne.b _L15_5x # no 3374 bsr.l src_qnan # yes 3375 bra.b _L15_6x 3376 _L15_5x: 3377 bsr.l slog2d # operand is a DENORM 3378 _L15_6x: 3379 3380 # 3381 # Result is now in FP0 3382 # 3383 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3384 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3385 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3386 unlk %a6 3387 rts 3388 3389 3390 ######################################################################### 3391 # MONADIC TEMPLATE # 3392 ######################################################################### 3393 global _fcoshs_ 3394 _fcoshs_: 3395 link %a6,&-LOCAL_SIZE 3396 3397 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3398 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3399 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3400 3401 fmov.l &0x0,%fpcr # zero FPCR 3402 3403 # 3404 # copy, convert, and tag input argument 3405 # 3406 fmov.s 0x8(%a6),%fp0 # load sgl input 3407 fmov.x %fp0,FP_SRC(%a6) 3408 lea FP_SRC(%a6),%a0 3409 bsr.l tag # fetch operand type 3410 mov.b %d0,STAG(%a6) 3411 mov.b %d0,%d1 3412 3413 andi.l &0x00ff00ff,USER_FPSR(%a6) 3414 3415 clr.l %d0 3416 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3417 3418 tst.b %d1 3419 bne.b _L16_2s 3420 bsr.l scosh # operand is a NORM 3421 bra.b _L16_6s 3422 _L16_2s: 3423 cmpi.b %d1,&ZERO # is operand a ZERO? 3424 bne.b _L16_3s # no 3425 bsr.l ld_pone # yes 3426 bra.b _L16_6s 3427 _L16_3s: 3428 cmpi.b %d1,&INF # is operand an INF? 3429 bne.b _L16_4s # no 3430 bsr.l ld_pinf # yes 3431 bra.b _L16_6s 3432 _L16_4s: 3433 cmpi.b %d1,&QNAN # is operand a QNAN? 3434 bne.b _L16_5s # no 3435 bsr.l src_qnan # yes 3436 bra.b _L16_6s 3437 _L16_5s: 3438 bsr.l scoshd # operand is a DENORM 3439 _L16_6s: 3440 3441 # 3442 # Result is now in FP0 3443 # 3444 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3445 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3446 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3447 unlk %a6 3448 rts 3449 3450 global _fcoshd_ 3451 _fcoshd_: 3452 link %a6,&-LOCAL_SIZE 3453 3454 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3455 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3456 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3457 3458 fmov.l &0x0,%fpcr # zero FPCR 3459 3460 # 3461 # copy, convert, and tag input argument 3462 # 3463 fmov.d 0x8(%a6),%fp0 # load dbl input 3464 fmov.x %fp0,FP_SRC(%a6) 3465 lea FP_SRC(%a6),%a0 3466 bsr.l tag # fetch operand type 3467 mov.b %d0,STAG(%a6) 3468 mov.b %d0,%d1 3469 3470 andi.l &0x00ff00ff,USER_FPSR(%a6) 3471 3472 clr.l %d0 3473 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3474 3475 mov.b %d1,STAG(%a6) 3476 tst.b %d1 3477 bne.b _L16_2d 3478 bsr.l scosh # operand is a NORM 3479 bra.b _L16_6d 3480 _L16_2d: 3481 cmpi.b %d1,&ZERO # is operand a ZERO? 3482 bne.b _L16_3d # no 3483 bsr.l ld_pone # yes 3484 bra.b _L16_6d 3485 _L16_3d: 3486 cmpi.b %d1,&INF # is operand an INF? 3487 bne.b _L16_4d # no 3488 bsr.l ld_pinf # yes 3489 bra.b _L16_6d 3490 _L16_4d: 3491 cmpi.b %d1,&QNAN # is operand a QNAN? 3492 bne.b _L16_5d # no 3493 bsr.l src_qnan # yes 3494 bra.b _L16_6d 3495 _L16_5d: 3496 bsr.l scoshd # operand is a DENORM 3497 _L16_6d: 3498 3499 # 3500 # Result is now in FP0 3501 # 3502 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3503 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3504 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3505 unlk %a6 3506 rts 3507 3508 global _fcoshx_ 3509 _fcoshx_: 3510 link %a6,&-LOCAL_SIZE 3511 3512 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3513 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3514 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3515 3516 fmov.l &0x0,%fpcr # zero FPCR 3517 3518 # 3519 # copy, convert, and tag input argument 3520 # 3521 lea FP_SRC(%a6),%a0 3522 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 3523 mov.l 0x8+0x4(%a6),0x4(%a0) 3524 mov.l 0x8+0x8(%a6),0x8(%a0) 3525 bsr.l tag # fetch operand type 3526 mov.b %d0,STAG(%a6) 3527 mov.b %d0,%d1 3528 3529 andi.l &0x00ff00ff,USER_FPSR(%a6) 3530 3531 clr.l %d0 3532 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3533 3534 tst.b %d1 3535 bne.b _L16_2x 3536 bsr.l scosh # operand is a NORM 3537 bra.b _L16_6x 3538 _L16_2x: 3539 cmpi.b %d1,&ZERO # is operand a ZERO? 3540 bne.b _L16_3x # no 3541 bsr.l ld_pone # yes 3542 bra.b _L16_6x 3543 _L16_3x: 3544 cmpi.b %d1,&INF # is operand an INF? 3545 bne.b _L16_4x # no 3546 bsr.l ld_pinf # yes 3547 bra.b _L16_6x 3548 _L16_4x: 3549 cmpi.b %d1,&QNAN # is operand a QNAN? 3550 bne.b _L16_5x # no 3551 bsr.l src_qnan # yes 3552 bra.b _L16_6x 3553 _L16_5x: 3554 bsr.l scoshd # operand is a DENORM 3555 _L16_6x: 3556 3557 # 3558 # Result is now in FP0 3559 # 3560 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3561 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3562 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3563 unlk %a6 3564 rts 3565 3566 3567 ######################################################################### 3568 # MONADIC TEMPLATE # 3569 ######################################################################### 3570 global _facoss_ 3571 _facoss_: 3572 link %a6,&-LOCAL_SIZE 3573 3574 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3575 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3576 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3577 3578 fmov.l &0x0,%fpcr # zero FPCR 3579 3580 # 3581 # copy, convert, and tag input argument 3582 # 3583 fmov.s 0x8(%a6),%fp0 # load sgl input 3584 fmov.x %fp0,FP_SRC(%a6) 3585 lea FP_SRC(%a6),%a0 3586 bsr.l tag # fetch operand type 3587 mov.b %d0,STAG(%a6) 3588 mov.b %d0,%d1 3589 3590 andi.l &0x00ff00ff,USER_FPSR(%a6) 3591 3592 clr.l %d0 3593 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3594 3595 tst.b %d1 3596 bne.b _L17_2s 3597 bsr.l sacos # operand is a NORM 3598 bra.b _L17_6s 3599 _L17_2s: 3600 cmpi.b %d1,&ZERO # is operand a ZERO? 3601 bne.b _L17_3s # no 3602 bsr.l ld_ppi2 # yes 3603 bra.b _L17_6s 3604 _L17_3s: 3605 cmpi.b %d1,&INF # is operand an INF? 3606 bne.b _L17_4s # no 3607 bsr.l t_operr # yes 3608 bra.b _L17_6s 3609 _L17_4s: 3610 cmpi.b %d1,&QNAN # is operand a QNAN? 3611 bne.b _L17_5s # no 3612 bsr.l src_qnan # yes 3613 bra.b _L17_6s 3614 _L17_5s: 3615 bsr.l sacosd # operand is a DENORM 3616 _L17_6s: 3617 3618 # 3619 # Result is now in FP0 3620 # 3621 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3622 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3623 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3624 unlk %a6 3625 rts 3626 3627 global _facosd_ 3628 _facosd_: 3629 link %a6,&-LOCAL_SIZE 3630 3631 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3632 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3633 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3634 3635 fmov.l &0x0,%fpcr # zero FPCR 3636 3637 # 3638 # copy, convert, and tag input argument 3639 # 3640 fmov.d 0x8(%a6),%fp0 # load dbl input 3641 fmov.x %fp0,FP_SRC(%a6) 3642 lea FP_SRC(%a6),%a0 3643 bsr.l tag # fetch operand type 3644 mov.b %d0,STAG(%a6) 3645 mov.b %d0,%d1 3646 3647 andi.l &0x00ff00ff,USER_FPSR(%a6) 3648 3649 clr.l %d0 3650 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3651 3652 mov.b %d1,STAG(%a6) 3653 tst.b %d1 3654 bne.b _L17_2d 3655 bsr.l sacos # operand is a NORM 3656 bra.b _L17_6d 3657 _L17_2d: 3658 cmpi.b %d1,&ZERO # is operand a ZERO? 3659 bne.b _L17_3d # no 3660 bsr.l ld_ppi2 # yes 3661 bra.b _L17_6d 3662 _L17_3d: 3663 cmpi.b %d1,&INF # is operand an INF? 3664 bne.b _L17_4d # no 3665 bsr.l t_operr # yes 3666 bra.b _L17_6d 3667 _L17_4d: 3668 cmpi.b %d1,&QNAN # is operand a QNAN? 3669 bne.b _L17_5d # no 3670 bsr.l src_qnan # yes 3671 bra.b _L17_6d 3672 _L17_5d: 3673 bsr.l sacosd # operand is a DENORM 3674 _L17_6d: 3675 3676 # 3677 # Result is now in FP0 3678 # 3679 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3680 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3681 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3682 unlk %a6 3683 rts 3684 3685 global _facosx_ 3686 _facosx_: 3687 link %a6,&-LOCAL_SIZE 3688 3689 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3690 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3691 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3692 3693 fmov.l &0x0,%fpcr # zero FPCR 3694 3695 # 3696 # copy, convert, and tag input argument 3697 # 3698 lea FP_SRC(%a6),%a0 3699 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 3700 mov.l 0x8+0x4(%a6),0x4(%a0) 3701 mov.l 0x8+0x8(%a6),0x8(%a0) 3702 bsr.l tag # fetch operand type 3703 mov.b %d0,STAG(%a6) 3704 mov.b %d0,%d1 3705 3706 andi.l &0x00ff00ff,USER_FPSR(%a6) 3707 3708 clr.l %d0 3709 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3710 3711 tst.b %d1 3712 bne.b _L17_2x 3713 bsr.l sacos # operand is a NORM 3714 bra.b _L17_6x 3715 _L17_2x: 3716 cmpi.b %d1,&ZERO # is operand a ZERO? 3717 bne.b _L17_3x # no 3718 bsr.l ld_ppi2 # yes 3719 bra.b _L17_6x 3720 _L17_3x: 3721 cmpi.b %d1,&INF # is operand an INF? 3722 bne.b _L17_4x # no 3723 bsr.l t_operr # yes 3724 bra.b _L17_6x 3725 _L17_4x: 3726 cmpi.b %d1,&QNAN # is operand a QNAN? 3727 bne.b _L17_5x # no 3728 bsr.l src_qnan # yes 3729 bra.b _L17_6x 3730 _L17_5x: 3731 bsr.l sacosd # operand is a DENORM 3732 _L17_6x: 3733 3734 # 3735 # Result is now in FP0 3736 # 3737 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3738 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3739 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3740 unlk %a6 3741 rts 3742 3743 3744 ######################################################################### 3745 # MONADIC TEMPLATE # 3746 ######################################################################### 3747 global _fgetexps_ 3748 _fgetexps_: 3749 link %a6,&-LOCAL_SIZE 3750 3751 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3752 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3753 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3754 3755 fmov.l &0x0,%fpcr # zero FPCR 3756 3757 # 3758 # copy, convert, and tag input argument 3759 # 3760 fmov.s 0x8(%a6),%fp0 # load sgl input 3761 fmov.x %fp0,FP_SRC(%a6) 3762 lea FP_SRC(%a6),%a0 3763 bsr.l tag # fetch operand type 3764 mov.b %d0,STAG(%a6) 3765 mov.b %d0,%d1 3766 3767 andi.l &0x00ff00ff,USER_FPSR(%a6) 3768 3769 clr.l %d0 3770 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3771 3772 tst.b %d1 3773 bne.b _L18_2s 3774 bsr.l sgetexp # operand is a NORM 3775 bra.b _L18_6s 3776 _L18_2s: 3777 cmpi.b %d1,&ZERO # is operand a ZERO? 3778 bne.b _L18_3s # no 3779 bsr.l src_zero # yes 3780 bra.b _L18_6s 3781 _L18_3s: 3782 cmpi.b %d1,&INF # is operand an INF? 3783 bne.b _L18_4s # no 3784 bsr.l t_operr # yes 3785 bra.b _L18_6s 3786 _L18_4s: 3787 cmpi.b %d1,&QNAN # is operand a QNAN? 3788 bne.b _L18_5s # no 3789 bsr.l src_qnan # yes 3790 bra.b _L18_6s 3791 _L18_5s: 3792 bsr.l sgetexpd # operand is a DENORM 3793 _L18_6s: 3794 3795 # 3796 # Result is now in FP0 3797 # 3798 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3799 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3800 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3801 unlk %a6 3802 rts 3803 3804 global _fgetexpd_ 3805 _fgetexpd_: 3806 link %a6,&-LOCAL_SIZE 3807 3808 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3809 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3810 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3811 3812 fmov.l &0x0,%fpcr # zero FPCR 3813 3814 # 3815 # copy, convert, and tag input argument 3816 # 3817 fmov.d 0x8(%a6),%fp0 # load dbl input 3818 fmov.x %fp0,FP_SRC(%a6) 3819 lea FP_SRC(%a6),%a0 3820 bsr.l tag # fetch operand type 3821 mov.b %d0,STAG(%a6) 3822 mov.b %d0,%d1 3823 3824 andi.l &0x00ff00ff,USER_FPSR(%a6) 3825 3826 clr.l %d0 3827 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3828 3829 mov.b %d1,STAG(%a6) 3830 tst.b %d1 3831 bne.b _L18_2d 3832 bsr.l sgetexp # operand is a NORM 3833 bra.b _L18_6d 3834 _L18_2d: 3835 cmpi.b %d1,&ZERO # is operand a ZERO? 3836 bne.b _L18_3d # no 3837 bsr.l src_zero # yes 3838 bra.b _L18_6d 3839 _L18_3d: 3840 cmpi.b %d1,&INF # is operand an INF? 3841 bne.b _L18_4d # no 3842 bsr.l t_operr # yes 3843 bra.b _L18_6d 3844 _L18_4d: 3845 cmpi.b %d1,&QNAN # is operand a QNAN? 3846 bne.b _L18_5d # no 3847 bsr.l src_qnan # yes 3848 bra.b _L18_6d 3849 _L18_5d: 3850 bsr.l sgetexpd # operand is a DENORM 3851 _L18_6d: 3852 3853 # 3854 # Result is now in FP0 3855 # 3856 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3857 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3858 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3859 unlk %a6 3860 rts 3861 3862 global _fgetexpx_ 3863 _fgetexpx_: 3864 link %a6,&-LOCAL_SIZE 3865 3866 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3867 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3868 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3869 3870 fmov.l &0x0,%fpcr # zero FPCR 3871 3872 # 3873 # copy, convert, and tag input argument 3874 # 3875 lea FP_SRC(%a6),%a0 3876 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 3877 mov.l 0x8+0x4(%a6),0x4(%a0) 3878 mov.l 0x8+0x8(%a6),0x8(%a0) 3879 bsr.l tag # fetch operand type 3880 mov.b %d0,STAG(%a6) 3881 mov.b %d0,%d1 3882 3883 andi.l &0x00ff00ff,USER_FPSR(%a6) 3884 3885 clr.l %d0 3886 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3887 3888 tst.b %d1 3889 bne.b _L18_2x 3890 bsr.l sgetexp # operand is a NORM 3891 bra.b _L18_6x 3892 _L18_2x: 3893 cmpi.b %d1,&ZERO # is operand a ZERO? 3894 bne.b _L18_3x # no 3895 bsr.l src_zero # yes 3896 bra.b _L18_6x 3897 _L18_3x: 3898 cmpi.b %d1,&INF # is operand an INF? 3899 bne.b _L18_4x # no 3900 bsr.l t_operr # yes 3901 bra.b _L18_6x 3902 _L18_4x: 3903 cmpi.b %d1,&QNAN # is operand a QNAN? 3904 bne.b _L18_5x # no 3905 bsr.l src_qnan # yes 3906 bra.b _L18_6x 3907 _L18_5x: 3908 bsr.l sgetexpd # operand is a DENORM 3909 _L18_6x: 3910 3911 # 3912 # Result is now in FP0 3913 # 3914 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3915 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3916 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3917 unlk %a6 3918 rts 3919 3920 3921 ######################################################################### 3922 # MONADIC TEMPLATE # 3923 ######################################################################### 3924 global _fgetmans_ 3925 _fgetmans_: 3926 link %a6,&-LOCAL_SIZE 3927 3928 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3929 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3930 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3931 3932 fmov.l &0x0,%fpcr # zero FPCR 3933 3934 # 3935 # copy, convert, and tag input argument 3936 # 3937 fmov.s 0x8(%a6),%fp0 # load sgl input 3938 fmov.x %fp0,FP_SRC(%a6) 3939 lea FP_SRC(%a6),%a0 3940 bsr.l tag # fetch operand type 3941 mov.b %d0,STAG(%a6) 3942 mov.b %d0,%d1 3943 3944 andi.l &0x00ff00ff,USER_FPSR(%a6) 3945 3946 clr.l %d0 3947 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 3948 3949 tst.b %d1 3950 bne.b _L19_2s 3951 bsr.l sgetman # operand is a NORM 3952 bra.b _L19_6s 3953 _L19_2s: 3954 cmpi.b %d1,&ZERO # is operand a ZERO? 3955 bne.b _L19_3s # no 3956 bsr.l src_zero # yes 3957 bra.b _L19_6s 3958 _L19_3s: 3959 cmpi.b %d1,&INF # is operand an INF? 3960 bne.b _L19_4s # no 3961 bsr.l t_operr # yes 3962 bra.b _L19_6s 3963 _L19_4s: 3964 cmpi.b %d1,&QNAN # is operand a QNAN? 3965 bne.b _L19_5s # no 3966 bsr.l src_qnan # yes 3967 bra.b _L19_6s 3968 _L19_5s: 3969 bsr.l sgetmand # operand is a DENORM 3970 _L19_6s: 3971 3972 # 3973 # Result is now in FP0 3974 # 3975 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 3976 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 3977 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 3978 unlk %a6 3979 rts 3980 3981 global _fgetmand_ 3982 _fgetmand_: 3983 link %a6,&-LOCAL_SIZE 3984 3985 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 3986 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 3987 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 3988 3989 fmov.l &0x0,%fpcr # zero FPCR 3990 3991 # 3992 # copy, convert, and tag input argument 3993 # 3994 fmov.d 0x8(%a6),%fp0 # load dbl input 3995 fmov.x %fp0,FP_SRC(%a6) 3996 lea FP_SRC(%a6),%a0 3997 bsr.l tag # fetch operand type 3998 mov.b %d0,STAG(%a6) 3999 mov.b %d0,%d1 4000 4001 andi.l &0x00ff00ff,USER_FPSR(%a6) 4002 4003 clr.l %d0 4004 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4005 4006 mov.b %d1,STAG(%a6) 4007 tst.b %d1 4008 bne.b _L19_2d 4009 bsr.l sgetman # operand is a NORM 4010 bra.b _L19_6d 4011 _L19_2d: 4012 cmpi.b %d1,&ZERO # is operand a ZERO? 4013 bne.b _L19_3d # no 4014 bsr.l src_zero # yes 4015 bra.b _L19_6d 4016 _L19_3d: 4017 cmpi.b %d1,&INF # is operand an INF? 4018 bne.b _L19_4d # no 4019 bsr.l t_operr # yes 4020 bra.b _L19_6d 4021 _L19_4d: 4022 cmpi.b %d1,&QNAN # is operand a QNAN? 4023 bne.b _L19_5d # no 4024 bsr.l src_qnan # yes 4025 bra.b _L19_6d 4026 _L19_5d: 4027 bsr.l sgetmand # operand is a DENORM 4028 _L19_6d: 4029 4030 # 4031 # Result is now in FP0 4032 # 4033 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4034 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4035 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4036 unlk %a6 4037 rts 4038 4039 global _fgetmanx_ 4040 _fgetmanx_: 4041 link %a6,&-LOCAL_SIZE 4042 4043 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4044 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4045 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4046 4047 fmov.l &0x0,%fpcr # zero FPCR 4048 4049 # 4050 # copy, convert, and tag input argument 4051 # 4052 lea FP_SRC(%a6),%a0 4053 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 4054 mov.l 0x8+0x4(%a6),0x4(%a0) 4055 mov.l 0x8+0x8(%a6),0x8(%a0) 4056 bsr.l tag # fetch operand type 4057 mov.b %d0,STAG(%a6) 4058 mov.b %d0,%d1 4059 4060 andi.l &0x00ff00ff,USER_FPSR(%a6) 4061 4062 clr.l %d0 4063 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4064 4065 tst.b %d1 4066 bne.b _L19_2x 4067 bsr.l sgetman # operand is a NORM 4068 bra.b _L19_6x 4069 _L19_2x: 4070 cmpi.b %d1,&ZERO # is operand a ZERO? 4071 bne.b _L19_3x # no 4072 bsr.l src_zero # yes 4073 bra.b _L19_6x 4074 _L19_3x: 4075 cmpi.b %d1,&INF # is operand an INF? 4076 bne.b _L19_4x # no 4077 bsr.l t_operr # yes 4078 bra.b _L19_6x 4079 _L19_4x: 4080 cmpi.b %d1,&QNAN # is operand a QNAN? 4081 bne.b _L19_5x # no 4082 bsr.l src_qnan # yes 4083 bra.b _L19_6x 4084 _L19_5x: 4085 bsr.l sgetmand # operand is a DENORM 4086 _L19_6x: 4087 4088 # 4089 # Result is now in FP0 4090 # 4091 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4092 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4093 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4094 unlk %a6 4095 rts 4096 4097 4098 ######################################################################### 4099 # MONADIC TEMPLATE # 4100 ######################################################################### 4101 global _fsincoss_ 4102 _fsincoss_: 4103 link %a6,&-LOCAL_SIZE 4104 4105 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4106 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4107 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4108 4109 fmov.l &0x0,%fpcr # zero FPCR 4110 4111 # 4112 # copy, convert, and tag input argument 4113 # 4114 fmov.s 0x8(%a6),%fp0 # load sgl input 4115 fmov.x %fp0,FP_SRC(%a6) 4116 lea FP_SRC(%a6),%a0 4117 bsr.l tag # fetch operand type 4118 mov.b %d0,STAG(%a6) 4119 mov.b %d0,%d1 4120 4121 andi.l &0x00ff00ff,USER_FPSR(%a6) 4122 4123 clr.l %d0 4124 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4125 4126 tst.b %d1 4127 bne.b _L20_2s 4128 bsr.l ssincos # operand is a NORM 4129 bra.b _L20_6s 4130 _L20_2s: 4131 cmpi.b %d1,&ZERO # is operand a ZERO? 4132 bne.b _L20_3s # no 4133 bsr.l ssincosz # yes 4134 bra.b _L20_6s 4135 _L20_3s: 4136 cmpi.b %d1,&INF # is operand an INF? 4137 bne.b _L20_4s # no 4138 bsr.l ssincosi # yes 4139 bra.b _L20_6s 4140 _L20_4s: 4141 cmpi.b %d1,&QNAN # is operand a QNAN? 4142 bne.b _L20_5s # no 4143 bsr.l ssincosqnan # yes 4144 bra.b _L20_6s 4145 _L20_5s: 4146 bsr.l ssincosd # operand is a DENORM 4147 _L20_6s: 4148 4149 # 4150 # Result is now in FP0 4151 # 4152 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4153 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4154 fmovm.x &0x03,-(%sp) # store off fp0/fp1 4155 fmovm.x (%sp)+,&0x40 # fp0 now in fp1 4156 fmovm.x (%sp)+,&0x80 # fp1 now in fp0 4157 unlk %a6 4158 rts 4159 4160 global _fsincosd_ 4161 _fsincosd_: 4162 link %a6,&-LOCAL_SIZE 4163 4164 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4165 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4166 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4167 4168 fmov.l &0x0,%fpcr # zero FPCR 4169 4170 # 4171 # copy, convert, and tag input argument 4172 # 4173 fmov.d 0x8(%a6),%fp0 # load dbl input 4174 fmov.x %fp0,FP_SRC(%a6) 4175 lea FP_SRC(%a6),%a0 4176 bsr.l tag # fetch operand type 4177 mov.b %d0,STAG(%a6) 4178 mov.b %d0,%d1 4179 4180 andi.l &0x00ff00ff,USER_FPSR(%a6) 4181 4182 clr.l %d0 4183 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4184 4185 mov.b %d1,STAG(%a6) 4186 tst.b %d1 4187 bne.b _L20_2d 4188 bsr.l ssincos # operand is a NORM 4189 bra.b _L20_6d 4190 _L20_2d: 4191 cmpi.b %d1,&ZERO # is operand a ZERO? 4192 bne.b _L20_3d # no 4193 bsr.l ssincosz # yes 4194 bra.b _L20_6d 4195 _L20_3d: 4196 cmpi.b %d1,&INF # is operand an INF? 4197 bne.b _L20_4d # no 4198 bsr.l ssincosi # yes 4199 bra.b _L20_6d 4200 _L20_4d: 4201 cmpi.b %d1,&QNAN # is operand a QNAN? 4202 bne.b _L20_5d # no 4203 bsr.l ssincosqnan # yes 4204 bra.b _L20_6d 4205 _L20_5d: 4206 bsr.l ssincosd # operand is a DENORM 4207 _L20_6d: 4208 4209 # 4210 # Result is now in FP0 4211 # 4212 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4213 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4214 fmovm.x &0x03,-(%sp) # store off fp0/fp1 4215 fmovm.x (%sp)+,&0x40 # fp0 now in fp1 4216 fmovm.x (%sp)+,&0x80 # fp1 now in fp0 4217 unlk %a6 4218 rts 4219 4220 global _fsincosx_ 4221 _fsincosx_: 4222 link %a6,&-LOCAL_SIZE 4223 4224 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4225 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4226 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4227 4228 fmov.l &0x0,%fpcr # zero FPCR 4229 4230 # 4231 # copy, convert, and tag input argument 4232 # 4233 lea FP_SRC(%a6),%a0 4234 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext input 4235 mov.l 0x8+0x4(%a6),0x4(%a0) 4236 mov.l 0x8+0x8(%a6),0x8(%a0) 4237 bsr.l tag # fetch operand type 4238 mov.b %d0,STAG(%a6) 4239 mov.b %d0,%d1 4240 4241 andi.l &0x00ff00ff,USER_FPSR(%a6) 4242 4243 clr.l %d0 4244 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4245 4246 tst.b %d1 4247 bne.b _L20_2x 4248 bsr.l ssincos # operand is a NORM 4249 bra.b _L20_6x 4250 _L20_2x: 4251 cmpi.b %d1,&ZERO # is operand a ZERO? 4252 bne.b _L20_3x # no 4253 bsr.l ssincosz # yes 4254 bra.b _L20_6x 4255 _L20_3x: 4256 cmpi.b %d1,&INF # is operand an INF? 4257 bne.b _L20_4x # no 4258 bsr.l ssincosi # yes 4259 bra.b _L20_6x 4260 _L20_4x: 4261 cmpi.b %d1,&QNAN # is operand a QNAN? 4262 bne.b _L20_5x # no 4263 bsr.l ssincosqnan # yes 4264 bra.b _L20_6x 4265 _L20_5x: 4266 bsr.l ssincosd # operand is a DENORM 4267 _L20_6x: 4268 4269 # 4270 # Result is now in FP0 4271 # 4272 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4273 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4274 fmovm.x &0x03,-(%sp) # store off fp0/fp1 4275 fmovm.x (%sp)+,&0x40 # fp0 now in fp1 4276 fmovm.x (%sp)+,&0x80 # fp1 now in fp0 4277 unlk %a6 4278 rts 4279 4280 4281 ######################################################################### 4282 # DYADIC TEMPLATE # 4283 ######################################################################### 4284 global _frems_ 4285 _frems_: 4286 link %a6,&-LOCAL_SIZE 4287 4288 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4289 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4290 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4291 4292 fmov.l &0x0,%fpcr # zero FPCR 4293 4294 # 4295 # copy, convert, and tag input argument 4296 # 4297 fmov.s 0x8(%a6),%fp0 # load sgl dst 4298 fmov.x %fp0,FP_DST(%a6) 4299 lea FP_DST(%a6),%a0 4300 bsr.l tag # fetch operand type 4301 mov.b %d0,DTAG(%a6) 4302 4303 fmov.s 0xc(%a6),%fp0 # load sgl src 4304 fmov.x %fp0,FP_SRC(%a6) 4305 lea FP_SRC(%a6),%a0 4306 bsr.l tag # fetch operand type 4307 mov.b %d0,STAG(%a6) 4308 mov.l %d0,%d1 4309 4310 andi.l &0x00ff00ff,USER_FPSR(%a6) 4311 4312 clr.l %d0 4313 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4314 4315 lea FP_SRC(%a6),%a0 # pass ptr to src 4316 lea FP_DST(%a6),%a1 # pass ptr to dst 4317 4318 tst.b %d1 4319 bne.b _L21_2s 4320 bsr.l srem_snorm # operand is a NORM 4321 bra.b _L21_6s 4322 _L21_2s: 4323 cmpi.b %d1,&ZERO # is operand a ZERO? 4324 bne.b _L21_3s # no 4325 bsr.l srem_szero # yes 4326 bra.b _L21_6s 4327 _L21_3s: 4328 cmpi.b %d1,&INF # is operand an INF? 4329 bne.b _L21_4s # no 4330 bsr.l srem_sinf # yes 4331 bra.b _L21_6s 4332 _L21_4s: 4333 cmpi.b %d1,&QNAN # is operand a QNAN? 4334 bne.b _L21_5s # no 4335 bsr.l sop_sqnan # yes 4336 bra.b _L21_6s 4337 _L21_5s: 4338 bsr.l srem_sdnrm # operand is a DENORM 4339 _L21_6s: 4340 4341 # 4342 # Result is now in FP0 4343 # 4344 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4345 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4346 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4347 unlk %a6 4348 rts 4349 4350 global _fremd_ 4351 _fremd_: 4352 link %a6,&-LOCAL_SIZE 4353 4354 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4355 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4356 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4357 4358 fmov.l &0x0,%fpcr # zero FPCR 4359 4360 # 4361 # copy, convert, and tag input argument 4362 # 4363 fmov.d 0x8(%a6),%fp0 # load dbl dst 4364 fmov.x %fp0,FP_DST(%a6) 4365 lea FP_DST(%a6),%a0 4366 bsr.l tag # fetch operand type 4367 mov.b %d0,DTAG(%a6) 4368 4369 fmov.d 0x10(%a6),%fp0 # load dbl src 4370 fmov.x %fp0,FP_SRC(%a6) 4371 lea FP_SRC(%a6),%a0 4372 bsr.l tag # fetch operand type 4373 mov.b %d0,STAG(%a6) 4374 mov.l %d0,%d1 4375 4376 andi.l &0x00ff00ff,USER_FPSR(%a6) 4377 4378 clr.l %d0 4379 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4380 4381 lea FP_SRC(%a6),%a0 # pass ptr to src 4382 lea FP_DST(%a6),%a1 # pass ptr to dst 4383 4384 tst.b %d1 4385 bne.b _L21_2d 4386 bsr.l srem_snorm # operand is a NORM 4387 bra.b _L21_6d 4388 _L21_2d: 4389 cmpi.b %d1,&ZERO # is operand a ZERO? 4390 bne.b _L21_3d # no 4391 bsr.l srem_szero # yes 4392 bra.b _L21_6d 4393 _L21_3d: 4394 cmpi.b %d1,&INF # is operand an INF? 4395 bne.b _L21_4d # no 4396 bsr.l srem_sinf # yes 4397 bra.b _L21_6d 4398 _L21_4d: 4399 cmpi.b %d1,&QNAN # is operand a QNAN? 4400 bne.b _L21_5d # no 4401 bsr.l sop_sqnan # yes 4402 bra.b _L21_6d 4403 _L21_5d: 4404 bsr.l srem_sdnrm # operand is a DENORM 4405 _L21_6d: 4406 4407 # 4408 # Result is now in FP0 4409 # 4410 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4411 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4412 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4413 unlk %a6 4414 rts 4415 4416 global _fremx_ 4417 _fremx_: 4418 link %a6,&-LOCAL_SIZE 4419 4420 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4421 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4422 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4423 4424 fmov.l &0x0,%fpcr # zero FPCR 4425 4426 # 4427 # copy, convert, and tag input argument 4428 # 4429 lea FP_DST(%a6),%a0 4430 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dst 4431 mov.l 0x8+0x4(%a6),0x4(%a0) 4432 mov.l 0x8+0x8(%a6),0x8(%a0) 4433 bsr.l tag # fetch operand type 4434 mov.b %d0,DTAG(%a6) 4435 4436 lea FP_SRC(%a6),%a0 4437 mov.l 0x14+0x0(%a6),0x0(%a0) # load ext src 4438 mov.l 0x14+0x4(%a6),0x4(%a0) 4439 mov.l 0x14+0x8(%a6),0x8(%a0) 4440 bsr.l tag # fetch operand type 4441 mov.b %d0,STAG(%a6) 4442 mov.l %d0,%d1 4443 4444 andi.l &0x00ff00ff,USER_FPSR(%a6) 4445 4446 clr.l %d0 4447 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4448 4449 lea FP_SRC(%a6),%a0 # pass ptr to src 4450 lea FP_DST(%a6),%a1 # pass ptr to dst 4451 4452 tst.b %d1 4453 bne.b _L21_2x 4454 bsr.l srem_snorm # operand is a NORM 4455 bra.b _L21_6x 4456 _L21_2x: 4457 cmpi.b %d1,&ZERO # is operand a ZERO? 4458 bne.b _L21_3x # no 4459 bsr.l srem_szero # yes 4460 bra.b _L21_6x 4461 _L21_3x: 4462 cmpi.b %d1,&INF # is operand an INF? 4463 bne.b _L21_4x # no 4464 bsr.l srem_sinf # yes 4465 bra.b _L21_6x 4466 _L21_4x: 4467 cmpi.b %d1,&QNAN # is operand a QNAN? 4468 bne.b _L21_5x # no 4469 bsr.l sop_sqnan # yes 4470 bra.b _L21_6x 4471 _L21_5x: 4472 bsr.l srem_sdnrm # operand is a DENORM 4473 _L21_6x: 4474 4475 # 4476 # Result is now in FP0 4477 # 4478 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4479 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4480 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4481 unlk %a6 4482 rts 4483 4484 4485 ######################################################################### 4486 # DYADIC TEMPLATE # 4487 ######################################################################### 4488 global _fmods_ 4489 _fmods_: 4490 link %a6,&-LOCAL_SIZE 4491 4492 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4493 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4494 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4495 4496 fmov.l &0x0,%fpcr # zero FPCR 4497 4498 # 4499 # copy, convert, and tag input argument 4500 # 4501 fmov.s 0x8(%a6),%fp0 # load sgl dst 4502 fmov.x %fp0,FP_DST(%a6) 4503 lea FP_DST(%a6),%a0 4504 bsr.l tag # fetch operand type 4505 mov.b %d0,DTAG(%a6) 4506 4507 fmov.s 0xc(%a6),%fp0 # load sgl src 4508 fmov.x %fp0,FP_SRC(%a6) 4509 lea FP_SRC(%a6),%a0 4510 bsr.l tag # fetch operand type 4511 mov.b %d0,STAG(%a6) 4512 mov.l %d0,%d1 4513 4514 andi.l &0x00ff00ff,USER_FPSR(%a6) 4515 4516 clr.l %d0 4517 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4518 4519 lea FP_SRC(%a6),%a0 # pass ptr to src 4520 lea FP_DST(%a6),%a1 # pass ptr to dst 4521 4522 tst.b %d1 4523 bne.b _L22_2s 4524 bsr.l smod_snorm # operand is a NORM 4525 bra.b _L22_6s 4526 _L22_2s: 4527 cmpi.b %d1,&ZERO # is operand a ZERO? 4528 bne.b _L22_3s # no 4529 bsr.l smod_szero # yes 4530 bra.b _L22_6s 4531 _L22_3s: 4532 cmpi.b %d1,&INF # is operand an INF? 4533 bne.b _L22_4s # no 4534 bsr.l smod_sinf # yes 4535 bra.b _L22_6s 4536 _L22_4s: 4537 cmpi.b %d1,&QNAN # is operand a QNAN? 4538 bne.b _L22_5s # no 4539 bsr.l sop_sqnan # yes 4540 bra.b _L22_6s 4541 _L22_5s: 4542 bsr.l smod_sdnrm # operand is a DENORM 4543 _L22_6s: 4544 4545 # 4546 # Result is now in FP0 4547 # 4548 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4549 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4550 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4551 unlk %a6 4552 rts 4553 4554 global _fmodd_ 4555 _fmodd_: 4556 link %a6,&-LOCAL_SIZE 4557 4558 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4559 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4560 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4561 4562 fmov.l &0x0,%fpcr # zero FPCR 4563 4564 # 4565 # copy, convert, and tag input argument 4566 # 4567 fmov.d 0x8(%a6),%fp0 # load dbl dst 4568 fmov.x %fp0,FP_DST(%a6) 4569 lea FP_DST(%a6),%a0 4570 bsr.l tag # fetch operand type 4571 mov.b %d0,DTAG(%a6) 4572 4573 fmov.d 0x10(%a6),%fp0 # load dbl src 4574 fmov.x %fp0,FP_SRC(%a6) 4575 lea FP_SRC(%a6),%a0 4576 bsr.l tag # fetch operand type 4577 mov.b %d0,STAG(%a6) 4578 mov.l %d0,%d1 4579 4580 andi.l &0x00ff00ff,USER_FPSR(%a6) 4581 4582 clr.l %d0 4583 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4584 4585 lea FP_SRC(%a6),%a0 # pass ptr to src 4586 lea FP_DST(%a6),%a1 # pass ptr to dst 4587 4588 tst.b %d1 4589 bne.b _L22_2d 4590 bsr.l smod_snorm # operand is a NORM 4591 bra.b _L22_6d 4592 _L22_2d: 4593 cmpi.b %d1,&ZERO # is operand a ZERO? 4594 bne.b _L22_3d # no 4595 bsr.l smod_szero # yes 4596 bra.b _L22_6d 4597 _L22_3d: 4598 cmpi.b %d1,&INF # is operand an INF? 4599 bne.b _L22_4d # no 4600 bsr.l smod_sinf # yes 4601 bra.b _L22_6d 4602 _L22_4d: 4603 cmpi.b %d1,&QNAN # is operand a QNAN? 4604 bne.b _L22_5d # no 4605 bsr.l sop_sqnan # yes 4606 bra.b _L22_6d 4607 _L22_5d: 4608 bsr.l smod_sdnrm # operand is a DENORM 4609 _L22_6d: 4610 4611 # 4612 # Result is now in FP0 4613 # 4614 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4615 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4616 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4617 unlk %a6 4618 rts 4619 4620 global _fmodx_ 4621 _fmodx_: 4622 link %a6,&-LOCAL_SIZE 4623 4624 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4625 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4626 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4627 4628 fmov.l &0x0,%fpcr # zero FPCR 4629 4630 # 4631 # copy, convert, and tag input argument 4632 # 4633 lea FP_DST(%a6),%a0 4634 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dst 4635 mov.l 0x8+0x4(%a6),0x4(%a0) 4636 mov.l 0x8+0x8(%a6),0x8(%a0) 4637 bsr.l tag # fetch operand type 4638 mov.b %d0,DTAG(%a6) 4639 4640 lea FP_SRC(%a6),%a0 4641 mov.l 0x14+0x0(%a6),0x0(%a0) # load ext src 4642 mov.l 0x14+0x4(%a6),0x4(%a0) 4643 mov.l 0x14+0x8(%a6),0x8(%a0) 4644 bsr.l tag # fetch operand type 4645 mov.b %d0,STAG(%a6) 4646 mov.l %d0,%d1 4647 4648 andi.l &0x00ff00ff,USER_FPSR(%a6) 4649 4650 clr.l %d0 4651 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4652 4653 lea FP_SRC(%a6),%a0 # pass ptr to src 4654 lea FP_DST(%a6),%a1 # pass ptr to dst 4655 4656 tst.b %d1 4657 bne.b _L22_2x 4658 bsr.l smod_snorm # operand is a NORM 4659 bra.b _L22_6x 4660 _L22_2x: 4661 cmpi.b %d1,&ZERO # is operand a ZERO? 4662 bne.b _L22_3x # no 4663 bsr.l smod_szero # yes 4664 bra.b _L22_6x 4665 _L22_3x: 4666 cmpi.b %d1,&INF # is operand an INF? 4667 bne.b _L22_4x # no 4668 bsr.l smod_sinf # yes 4669 bra.b _L22_6x 4670 _L22_4x: 4671 cmpi.b %d1,&QNAN # is operand a QNAN? 4672 bne.b _L22_5x # no 4673 bsr.l sop_sqnan # yes 4674 bra.b _L22_6x 4675 _L22_5x: 4676 bsr.l smod_sdnrm # operand is a DENORM 4677 _L22_6x: 4678 4679 # 4680 # Result is now in FP0 4681 # 4682 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4683 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4684 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4685 unlk %a6 4686 rts 4687 4688 4689 ######################################################################### 4690 # DYADIC TEMPLATE # 4691 ######################################################################### 4692 global _fscales_ 4693 _fscales_: 4694 link %a6,&-LOCAL_SIZE 4695 4696 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4697 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4698 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4699 4700 fmov.l &0x0,%fpcr # zero FPCR 4701 4702 # 4703 # copy, convert, and tag input argument 4704 # 4705 fmov.s 0x8(%a6),%fp0 # load sgl dst 4706 fmov.x %fp0,FP_DST(%a6) 4707 lea FP_DST(%a6),%a0 4708 bsr.l tag # fetch operand type 4709 mov.b %d0,DTAG(%a6) 4710 4711 fmov.s 0xc(%a6),%fp0 # load sgl src 4712 fmov.x %fp0,FP_SRC(%a6) 4713 lea FP_SRC(%a6),%a0 4714 bsr.l tag # fetch operand type 4715 mov.b %d0,STAG(%a6) 4716 mov.l %d0,%d1 4717 4718 andi.l &0x00ff00ff,USER_FPSR(%a6) 4719 4720 clr.l %d0 4721 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4722 4723 lea FP_SRC(%a6),%a0 # pass ptr to src 4724 lea FP_DST(%a6),%a1 # pass ptr to dst 4725 4726 tst.b %d1 4727 bne.b _L23_2s 4728 bsr.l sscale_snorm # operand is a NORM 4729 bra.b _L23_6s 4730 _L23_2s: 4731 cmpi.b %d1,&ZERO # is operand a ZERO? 4732 bne.b _L23_3s # no 4733 bsr.l sscale_szero # yes 4734 bra.b _L23_6s 4735 _L23_3s: 4736 cmpi.b %d1,&INF # is operand an INF? 4737 bne.b _L23_4s # no 4738 bsr.l sscale_sinf # yes 4739 bra.b _L23_6s 4740 _L23_4s: 4741 cmpi.b %d1,&QNAN # is operand a QNAN? 4742 bne.b _L23_5s # no 4743 bsr.l sop_sqnan # yes 4744 bra.b _L23_6s 4745 _L23_5s: 4746 bsr.l sscale_sdnrm # operand is a DENORM 4747 _L23_6s: 4748 4749 # 4750 # Result is now in FP0 4751 # 4752 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4753 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4754 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4755 unlk %a6 4756 rts 4757 4758 global _fscaled_ 4759 _fscaled_: 4760 link %a6,&-LOCAL_SIZE 4761 4762 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4763 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4764 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4765 4766 fmov.l &0x0,%fpcr # zero FPCR 4767 4768 # 4769 # copy, convert, and tag input argument 4770 # 4771 fmov.d 0x8(%a6),%fp0 # load dbl dst 4772 fmov.x %fp0,FP_DST(%a6) 4773 lea FP_DST(%a6),%a0 4774 bsr.l tag # fetch operand type 4775 mov.b %d0,DTAG(%a6) 4776 4777 fmov.d 0x10(%a6),%fp0 # load dbl src 4778 fmov.x %fp0,FP_SRC(%a6) 4779 lea FP_SRC(%a6),%a0 4780 bsr.l tag # fetch operand type 4781 mov.b %d0,STAG(%a6) 4782 mov.l %d0,%d1 4783 4784 andi.l &0x00ff00ff,USER_FPSR(%a6) 4785 4786 clr.l %d0 4787 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4788 4789 lea FP_SRC(%a6),%a0 # pass ptr to src 4790 lea FP_DST(%a6),%a1 # pass ptr to dst 4791 4792 tst.b %d1 4793 bne.b _L23_2d 4794 bsr.l sscale_snorm # operand is a NORM 4795 bra.b _L23_6d 4796 _L23_2d: 4797 cmpi.b %d1,&ZERO # is operand a ZERO? 4798 bne.b _L23_3d # no 4799 bsr.l sscale_szero # yes 4800 bra.b _L23_6d 4801 _L23_3d: 4802 cmpi.b %d1,&INF # is operand an INF? 4803 bne.b _L23_4d # no 4804 bsr.l sscale_sinf # yes 4805 bra.b _L23_6d 4806 _L23_4d: 4807 cmpi.b %d1,&QNAN # is operand a QNAN? 4808 bne.b _L23_5d # no 4809 bsr.l sop_sqnan # yes 4810 bra.b _L23_6d 4811 _L23_5d: 4812 bsr.l sscale_sdnrm # operand is a DENORM 4813 _L23_6d: 4814 4815 # 4816 # Result is now in FP0 4817 # 4818 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4819 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4820 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4821 unlk %a6 4822 rts 4823 4824 global _fscalex_ 4825 _fscalex_: 4826 link %a6,&-LOCAL_SIZE 4827 4828 movm.l &0x0303,EXC_DREGS(%a6) # save d0-d1/a0-a1 4829 fmovm.l %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs 4830 fmovm.x &0xc0,EXC_FP0(%a6) # save fp0/fp1 4831 4832 fmov.l &0x0,%fpcr # zero FPCR 4833 4834 # 4835 # copy, convert, and tag input argument 4836 # 4837 lea FP_DST(%a6),%a0 4838 mov.l 0x8+0x0(%a6),0x0(%a0) # load ext dst 4839 mov.l 0x8+0x4(%a6),0x4(%a0) 4840 mov.l 0x8+0x8(%a6),0x8(%a0) 4841 bsr.l tag # fetch operand type 4842 mov.b %d0,DTAG(%a6) 4843 4844 lea FP_SRC(%a6),%a0 4845 mov.l 0x14+0x0(%a6),0x0(%a0) # load ext src 4846 mov.l 0x14+0x4(%a6),0x4(%a0) 4847 mov.l 0x14+0x8(%a6),0x8(%a0) 4848 bsr.l tag # fetch operand type 4849 mov.b %d0,STAG(%a6) 4850 mov.l %d0,%d1 4851 4852 andi.l &0x00ff00ff,USER_FPSR(%a6) 4853 4854 clr.l %d0 4855 mov.b FPCR_MODE(%a6),%d0 # pass rnd mode,prec 4856 4857 lea FP_SRC(%a6),%a0 # pass ptr to src 4858 lea FP_DST(%a6),%a1 # pass ptr to dst 4859 4860 tst.b %d1 4861 bne.b _L23_2x 4862 bsr.l sscale_snorm # operand is a NORM 4863 bra.b _L23_6x 4864 _L23_2x: 4865 cmpi.b %d1,&ZERO # is operand a ZERO? 4866 bne.b _L23_3x # no 4867 bsr.l sscale_szero # yes 4868 bra.b _L23_6x 4869 _L23_3x: 4870 cmpi.b %d1,&INF # is operand an INF? 4871 bne.b _L23_4x # no 4872 bsr.l sscale_sinf # yes 4873 bra.b _L23_6x 4874 _L23_4x: 4875 cmpi.b %d1,&QNAN # is operand a QNAN? 4876 bne.b _L23_5x # no 4877 bsr.l sop_sqnan # yes 4878 bra.b _L23_6x 4879 _L23_5x: 4880 bsr.l sscale_sdnrm # operand is a DENORM 4881 _L23_6x: 4882 4883 # 4884 # Result is now in FP0 4885 # 4886 movm.l EXC_DREGS(%a6),&0x0303 # restore d0-d1/a0-a1 4887 fmovm.l USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs 4888 fmovm.x EXC_FP1(%a6),&0x40 # restore fp1 4889 unlk %a6 4890 rts 4891 4892 4893 ######################################################################### 4894 # ssin(): computes the sine of a normalized input # 4895 # ssind(): computes the sine of a denormalized input # 4896 # scos(): computes the cosine of a normalized input # 4897 # scosd(): computes the cosine of a denormalized input # 4898 # ssincos(): computes the sine and cosine of a normalized input # 4899 # ssincosd(): computes the sine and cosine of a denormalized input # 4900 # # 4901 # INPUT *************************************************************** # 4902 # a0 = pointer to extended precision input # 4903 # d0 = round precision,mode # 4904 # # 4905 # OUTPUT ************************************************************** # 4906 # fp0 = sin(X) or cos(X) # 4907 # # 4908 # For ssincos(X): # 4909 # fp0 = sin(X) # 4910 # fp1 = cos(X) # 4911 # # 4912 # ACCURACY and MONOTONICITY ******************************************* # 4913 # The returned result is within 1 ulp in 64 significant bit, i.e. # 4914 # within 0.5001 ulp to 53 bits if the result is subsequently # 4915 # rounded to double precision. The result is provably monotonic # 4916 # in double precision. # 4917 # # 4918 # ALGORITHM *********************************************************** # 4919 # # 4920 # SIN and COS: # 4921 # 1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1. # 4922 # # 4923 # 2. If |X| >= 15Pi or |X| < 2**(-40), go to 7. # 4924 # # 4925 # 3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let # 4926 # k = N mod 4, so in particular, k = 0,1,2,or 3. # 4927 # Overwrite k by k := k + AdjN. # 4928 # # 4929 # 4. If k is even, go to 6. # 4930 # # 4931 # 5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j. # 4932 # Return sgn*cos(r) where cos(r) is approximated by an # 4933 # even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)), # 4934 # s = r*r. # 4935 # Exit. # 4936 # # 4937 # 6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r) # 4938 # where sin(r) is approximated by an odd polynomial in r # 4939 # r + r*s*(A1+s*(A2+ ... + s*A7)), s = r*r. # 4940 # Exit. # 4941 # # 4942 # 7. If |X| > 1, go to 9. # 4943 # # 4944 # 8. (|X|<2**(-40)) If SIN is invoked, return X; # 4945 # otherwise return 1. # 4946 # # 4947 # 9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, # 4948 # go back to 3. # 4949 # # 4950 # SINCOS: # 4951 # 1. If |X| >= 15Pi or |X| < 2**(-40), go to 6. # 4952 # # 4953 # 2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let # 4954 # k = N mod 4, so in particular, k = 0,1,2,or 3. # 4955 # # 4956 # 3. If k is even, go to 5. # 4957 # # 4958 # 4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie. # 4959 # j1 exclusive or with the l.s.b. of k. # 4960 # sgn1 := (-1)**j1, sgn2 := (-1)**j2. # 4961 # SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where # 4962 # sin(r) and cos(r) are computed as odd and even # 4963 # polynomials in r, respectively. Exit # 4964 # # 4965 # 5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1. # 4966 # SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where # 4967 # sin(r) and cos(r) are computed as odd and even # 4968 # polynomials in r, respectively. Exit # 4969 # # 4970 # 6. If |X| > 1, go to 8. # 4971 # # 4972 # 7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit. # 4973 # # 4974 # 8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, # 4975 # go back to 2. # 4976 # # 4977 ######################################################################### 4978 4979 SINA7: long 0xBD6AAA77,0xCCC994F5 4980 SINA6: long 0x3DE61209,0x7AAE8DA1 4981 SINA5: long 0xBE5AE645,0x2A118AE4 4982 SINA4: long 0x3EC71DE3,0xA5341531 4983 SINA3: long 0xBF2A01A0,0x1A018B59,0x00000000,0x00000000 4984 SINA2: long 0x3FF80000,0x88888888,0x888859AF,0x00000000 4985 SINA1: long 0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000 4986 4987 COSB8: long 0x3D2AC4D0,0xD6011EE3 4988 COSB7: long 0xBDA9396F,0x9F45AC19 4989 COSB6: long 0x3E21EED9,0x0612C972 4990 COSB5: long 0xBE927E4F,0xB79D9FCF 4991 COSB4: long 0x3EFA01A0,0x1A01D423,0x00000000,0x00000000 4992 COSB3: long 0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000 4993 COSB2: long 0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E 4994 COSB1: long 0xBF000000 4995 4996 set INARG,FP_SCR0 4997 4998 set X,FP_SCR0 4999 # set XDCARE,X+2 5000 set XFRAC,X+4 5001 5002 set RPRIME,FP_SCR0 5003 set SPRIME,FP_SCR1 5004 5005 set POSNEG1,L_SCR1 5006 set TWOTO63,L_SCR1 5007 5008 set ENDFLAG,L_SCR2 5009 set INT,L_SCR2 5010 5011 set ADJN,L_SCR3 5012 5013 ############################################ 5014 global ssin 5015 ssin: 5016 mov.l &0,ADJN(%a6) # yes; SET ADJN TO 0 5017 bra.b SINBGN 5018 5019 ############################################ 5020 global scos 5021 scos: 5022 mov.l &1,ADJN(%a6) # yes; SET ADJN TO 1 5023 5024 ############################################ 5025 SINBGN: 5026 #--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE 5027 5028 fmov.x (%a0),%fp0 # LOAD INPUT 5029 fmov.x %fp0,X(%a6) # save input at X 5030 5031 # "COMPACTIFY" X 5032 mov.l (%a0),%d1 # put exp in hi word 5033 mov.w 4(%a0),%d1 # fetch hi(man) 5034 and.l &0x7FFFFFFF,%d1 # strip sign 5035 5036 cmpi.l %d1,&0x3FD78000 # is |X| >= 2**(-40)? 5037 bge.b SOK1 # no 5038 bra.w SINSM # yes; input is very small 5039 5040 SOK1: 5041 cmp.l %d1,&0x4004BC7E # is |X| < 15 PI? 5042 blt.b SINMAIN # no 5043 bra.w SREDUCEX # yes; input is very large 5044 5045 #--THIS IS THE USUAL CASE, |X| <= 15 PI. 5046 #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP. 5047 SINMAIN: 5048 fmov.x %fp0,%fp1 5049 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI 5050 5051 lea PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32 5052 5053 fmov.l %fp1,INT(%a6) # CONVERT TO INTEGER 5054 5055 mov.l INT(%a6),%d1 # make a copy of N 5056 asl.l &4,%d1 # N *= 16 5057 add.l %d1,%a1 # tbl_addr = a1 + (N*16) 5058 5059 # A1 IS THE ADDRESS OF N*PIBY2 5060 # ...WHICH IS IN TWO PIECES Y1 & Y2 5061 fsub.x (%a1)+,%fp0 # X-Y1 5062 fsub.s (%a1),%fp0 # fp0 = R = (X-Y1)-Y2 5063 5064 SINCONT: 5065 #--continuation from REDUCEX 5066 5067 #--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDED 5068 mov.l INT(%a6),%d1 5069 add.l ADJN(%a6),%d1 # SEE IF D0 IS ODD OR EVEN 5070 ror.l &1,%d1 # D0 WAS ODD IFF D0 IS NEGATIVE 5071 cmp.l %d1,&0 5072 blt.w COSPOLY 5073 5074 #--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J. 5075 #--THEN WE RETURN SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY 5076 #--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE 5077 #--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS 5078 #--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))]) 5079 #--WHERE T=S*S. 5080 #--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION 5081 #--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT. 5082 SINPOLY: 5083 fmovm.x &0x0c,-(%sp) # save fp2/fp3 5084 5085 fmov.x %fp0,X(%a6) # X IS R 5086 fmul.x %fp0,%fp0 # FP0 IS S 5087 5088 fmov.d SINA7(%pc),%fp3 5089 fmov.d SINA6(%pc),%fp2 5090 5091 fmov.x %fp0,%fp1 5092 fmul.x %fp1,%fp1 # FP1 IS T 5093 5094 ror.l &1,%d1 5095 and.l &0x80000000,%d1 5096 # ...LEAST SIG. BIT OF D0 IN SIGN POSITION 5097 eor.l %d1,X(%a6) # X IS NOW R'= SGN*R 5098 5099 fmul.x %fp1,%fp3 # TA7 5100 fmul.x %fp1,%fp2 # TA6 5101 5102 fadd.d SINA5(%pc),%fp3 # A5+TA7 5103 fadd.d SINA4(%pc),%fp2 # A4+TA6 5104 5105 fmul.x %fp1,%fp3 # T(A5+TA7) 5106 fmul.x %fp1,%fp2 # T(A4+TA6) 5107 5108 fadd.d SINA3(%pc),%fp3 # A3+T(A5+TA7) 5109 fadd.x SINA2(%pc),%fp2 # A2+T(A4+TA6) 5110 5111 fmul.x %fp3,%fp1 # T(A3+T(A5+TA7)) 5112 5113 fmul.x %fp0,%fp2 # S(A2+T(A4+TA6)) 5114 fadd.x SINA1(%pc),%fp1 # A1+T(A3+T(A5+TA7)) 5115 fmul.x X(%a6),%fp0 # R'*S 5116 5117 fadd.x %fp2,%fp1 # [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))] 5118 5119 fmul.x %fp1,%fp0 # SIN(R')-R' 5120 5121 fmovm.x (%sp)+,&0x30 # restore fp2/fp3 5122 5123 fmov.l %d0,%fpcr # restore users round mode,prec 5124 fadd.x X(%a6),%fp0 # last inst - possible exception set 5125 bra t_inx2 5126 5127 #--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J. 5128 #--THEN WE RETURN SGN*COS(R). SGN*COS(R) IS COMPUTED BY 5129 #--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE 5130 #--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS 5131 #--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))]) 5132 #--WHERE T=S*S. 5133 #--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION 5134 #--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2 5135 #--AND IS THEREFORE STORED AS SINGLE PRECISION. 5136 COSPOLY: 5137 fmovm.x &0x0c,-(%sp) # save fp2/fp3 5138 5139 fmul.x %fp0,%fp0 # FP0 IS S 5140 5141 fmov.d COSB8(%pc),%fp2 5142 fmov.d COSB7(%pc),%fp3 5143 5144 fmov.x %fp0,%fp1 5145 fmul.x %fp1,%fp1 # FP1 IS T 5146 5147 fmov.x %fp0,X(%a6) # X IS S 5148 ror.l &1,%d1 5149 and.l &0x80000000,%d1 5150 # ...LEAST SIG. BIT OF D0 IN SIGN POSITION 5151 5152 fmul.x %fp1,%fp2 # TB8 5153 5154 eor.l %d1,X(%a6) # X IS NOW S'= SGN*S 5155 and.l &0x80000000,%d1 5156 5157 fmul.x %fp1,%fp3 # TB7 5158 5159 or.l &0x3F800000,%d1 # D0 IS SGN IN SINGLE 5160 mov.l %d1,POSNEG1(%a6) 5161 5162 fadd.d COSB6(%pc),%fp2 # B6+TB8 5163 fadd.d COSB5(%pc),%fp3 # B5+TB7 5164 5165 fmul.x %fp1,%fp2 # T(B6+TB8) 5166 fmul.x %fp1,%fp3 # T(B5+TB7) 5167 5168 fadd.d COSB4(%pc),%fp2 # B4+T(B6+TB8) 5169 fadd.x COSB3(%pc),%fp3 # B3+T(B5+TB7) 5170 5171 fmul.x %fp1,%fp2 # T(B4+T(B6+TB8)) 5172 fmul.x %fp3,%fp1 # T(B3+T(B5+TB7)) 5173 5174 fadd.x COSB2(%pc),%fp2 # B2+T(B4+T(B6+TB8)) 5175 fadd.s COSB1(%pc),%fp1 # B1+T(B3+T(B5+TB7)) 5176 5177 fmul.x %fp2,%fp0 # S(B2+T(B4+T(B6+TB8))) 5178 5179 fadd.x %fp1,%fp0 5180 5181 fmul.x X(%a6),%fp0 5182 5183 fmovm.x (%sp)+,&0x30 # restore fp2/fp3 5184 5185 fmov.l %d0,%fpcr # restore users round mode,prec 5186 fadd.s POSNEG1(%a6),%fp0 # last inst - possible exception set 5187 bra t_inx2 5188 5189 ############################################## 5190 5191 # SINe: Big OR Small? 5192 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION. 5193 #--IF |X| < 2**(-40), RETURN X OR 1. 5194 SINBORS: 5195 cmp.l %d1,&0x3FFF8000 5196 bgt.l SREDUCEX 5197 5198 SINSM: 5199 mov.l ADJN(%a6),%d1 5200 cmp.l %d1,&0 5201 bgt.b COSTINY 5202 5203 # here, the operation may underflow iff the precision is sgl or dbl. 5204 # extended denorms are handled through another entry point. 5205 SINTINY: 5206 # mov.w &0x0000,XDCARE(%a6) # JUST IN CASE 5207 5208 fmov.l %d0,%fpcr # restore users round mode,prec 5209 mov.b &FMOV_OP,%d1 # last inst is MOVE 5210 fmov.x X(%a6),%fp0 # last inst - possible exception set 5211 bra t_catch 5212 5213 COSTINY: 5214 fmov.s &0x3F800000,%fp0 # fp0 = 1.0 5215 fmov.l %d0,%fpcr # restore users round mode,prec 5216 fadd.s &0x80800000,%fp0 # last inst - possible exception set 5217 bra t_pinx2 5218 5219 ################################################ 5220 global ssind 5221 #--SIN(X) = X FOR DENORMALIZED X 5222 ssind: 5223 bra t_extdnrm 5224 5225 ############################################ 5226 global scosd 5227 #--COS(X) = 1 FOR DENORMALIZED X 5228 scosd: 5229 fmov.s &0x3F800000,%fp0 # fp0 = 1.0 5230 bra t_pinx2 5231 5232 ################################################## 5233 5234 global ssincos 5235 ssincos: 5236 #--SET ADJN TO 4 5237 mov.l &4,ADJN(%a6) 5238 5239 fmov.x (%a0),%fp0 # LOAD INPUT 5240 fmov.x %fp0,X(%a6) 5241 5242 mov.l (%a0),%d1 5243 mov.w 4(%a0),%d1 5244 and.l &0x7FFFFFFF,%d1 # COMPACTIFY X 5245 5246 cmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)? 5247 bge.b SCOK1 5248 bra.w SCSM 5249 5250 SCOK1: 5251 cmp.l %d1,&0x4004BC7E # |X| < 15 PI? 5252 blt.b SCMAIN 5253 bra.w SREDUCEX 5254 5255 5256 #--THIS IS THE USUAL CASE, |X| <= 15 PI. 5257 #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP. 5258 SCMAIN: 5259 fmov.x %fp0,%fp1 5260 5261 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI 5262 5263 lea PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32 5264 5265 fmov.l %fp1,INT(%a6) # CONVERT TO INTEGER 5266 5267 mov.l INT(%a6),%d1 5268 asl.l &4,%d1 5269 add.l %d1,%a1 # ADDRESS OF N*PIBY2, IN Y1, Y2 5270 5271 fsub.x (%a1)+,%fp0 # X-Y1 5272 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2 5273 5274 SCCONT: 5275 #--continuation point from REDUCEX 5276 5277 mov.l INT(%a6),%d1 5278 ror.l &1,%d1 5279 cmp.l %d1,&0 # D0 < 0 IFF N IS ODD 5280 bge.w NEVEN 5281 5282 SNODD: 5283 #--REGISTERS SAVED SO FAR: D0, A0, FP2. 5284 fmovm.x &0x04,-(%sp) # save fp2 5285 5286 fmov.x %fp0,RPRIME(%a6) 5287 fmul.x %fp0,%fp0 # FP0 IS S = R*R 5288 fmov.d SINA7(%pc),%fp1 # A7 5289 fmov.d COSB8(%pc),%fp2 # B8 5290 fmul.x %fp0,%fp1 # SA7 5291 fmul.x %fp0,%fp2 # SB8 5292 5293 mov.l %d2,-(%sp) 5294 mov.l %d1,%d2 5295 ror.l &1,%d2 5296 and.l &0x80000000,%d2 5297 eor.l %d1,%d2 5298 and.l &0x80000000,%d2 5299 5300 fadd.d SINA6(%pc),%fp1 # A6+SA7 5301 fadd.d COSB7(%pc),%fp2 # B7+SB8 5302 5303 fmul.x %fp0,%fp1 # S(A6+SA7) 5304 eor.l %d2,RPRIME(%a6) 5305 mov.l (%sp)+,%d2 5306 fmul.x %fp0,%fp2 # S(B7+SB8) 5307 ror.l &1,%d1 5308 and.l &0x80000000,%d1 5309 mov.l &0x3F800000,POSNEG1(%a6) 5310 eor.l %d1,POSNEG1(%a6) 5311 5312 fadd.d SINA5(%pc),%fp1 # A5+S(A6+SA7) 5313 fadd.d COSB6(%pc),%fp2 # B6+S(B7+SB8) 5314 5315 fmul.x %fp0,%fp1 # S(A5+S(A6+SA7)) 5316 fmul.x %fp0,%fp2 # S(B6+S(B7+SB8)) 5317 fmov.x %fp0,SPRIME(%a6) 5318 5319 fadd.d SINA4(%pc),%fp1 # A4+S(A5+S(A6+SA7)) 5320 eor.l %d1,SPRIME(%a6) 5321 fadd.d COSB5(%pc),%fp2 # B5+S(B6+S(B7+SB8)) 5322 5323 fmul.x %fp0,%fp1 # S(A4+...) 5324 fmul.x %fp0,%fp2 # S(B5+...) 5325 5326 fadd.d SINA3(%pc),%fp1 # A3+S(A4+...) 5327 fadd.d COSB4(%pc),%fp2 # B4+S(B5+...) 5328 5329 fmul.x %fp0,%fp1 # S(A3+...) 5330 fmul.x %fp0,%fp2 # S(B4+...) 5331 5332 fadd.x SINA2(%pc),%fp1 # A2+S(A3+...) 5333 fadd.x COSB3(%pc),%fp2 # B3+S(B4+...) 5334 5335 fmul.x %fp0,%fp1 # S(A2+...) 5336 fmul.x %fp0,%fp2 # S(B3+...) 5337 5338 fadd.x SINA1(%pc),%fp1 # A1+S(A2+...) 5339 fadd.x COSB2(%pc),%fp2 # B2+S(B3+...) 5340 5341 fmul.x %fp0,%fp1 # S(A1+...) 5342 fmul.x %fp2,%fp0 # S(B2+...) 5343 5344 fmul.x RPRIME(%a6),%fp1 # R'S(A1+...) 5345 fadd.s COSB1(%pc),%fp0 # B1+S(B2...) 5346 fmul.x SPRIME(%a6),%fp0 # S'(B1+S(B2+...)) 5347 5348 fmovm.x (%sp)+,&0x20 # restore fp2 5349 5350 fmov.l %d0,%fpcr 5351 fadd.x RPRIME(%a6),%fp1 # COS(X) 5352 bsr sto_cos # store cosine result 5353 fadd.s POSNEG1(%a6),%fp0 # SIN(X) 5354 bra t_inx2 5355 5356 NEVEN: 5357 #--REGISTERS SAVED SO FAR: FP2. 5358 fmovm.x &0x04,-(%sp) # save fp2 5359 5360 fmov.x %fp0,RPRIME(%a6) 5361 fmul.x %fp0,%fp0 # FP0 IS S = R*R 5362 5363 fmov.d COSB8(%pc),%fp1 # B8 5364 fmov.d SINA7(%pc),%fp2 # A7 5365 5366 fmul.x %fp0,%fp1 # SB8 5367 fmov.x %fp0,SPRIME(%a6) 5368 fmul.x %fp0,%fp2 # SA7 5369 5370 ror.l &1,%d1 5371 and.l &0x80000000,%d1 5372 5373 fadd.d COSB7(%pc),%fp1 # B7+SB8 5374 fadd.d SINA6(%pc),%fp2 # A6+SA7 5375 5376 eor.l %d1,RPRIME(%a6) 5377 eor.l %d1,SPRIME(%a6) 5378 5379 fmul.x %fp0,%fp1 # S(B7+SB8) 5380 5381 or.l &0x3F800000,%d1 5382 mov.l %d1,POSNEG1(%a6) 5383 5384 fmul.x %fp0,%fp2 # S(A6+SA7) 5385 5386 fadd.d COSB6(%pc),%fp1 # B6+S(B7+SB8) 5387 fadd.d SINA5(%pc),%fp2 # A5+S(A6+SA7) 5388 5389 fmul.x %fp0,%fp1 # S(B6+S(B7+SB8)) 5390 fmul.x %fp0,%fp2 # S(A5+S(A6+SA7)) 5391 5392 fadd.d COSB5(%pc),%fp1 # B5+S(B6+S(B7+SB8)) 5393 fadd.d SINA4(%pc),%fp2 # A4+S(A5+S(A6+SA7)) 5394 5395 fmul.x %fp0,%fp1 # S(B5+...) 5396 fmul.x %fp0,%fp2 # S(A4+...) 5397 5398 fadd.d COSB4(%pc),%fp1 # B4+S(B5+...) 5399 fadd.d SINA3(%pc),%fp2 # A3+S(A4+...) 5400 5401 fmul.x %fp0,%fp1 # S(B4+...) 5402 fmul.x %fp0,%fp2 # S(A3+...) 5403 5404 fadd.x COSB3(%pc),%fp1 # B3+S(B4+...) 5405 fadd.x SINA2(%pc),%fp2 # A2+S(A3+...) 5406 5407 fmul.x %fp0,%fp1 # S(B3+...) 5408 fmul.x %fp0,%fp2 # S(A2+...) 5409 5410 fadd.x COSB2(%pc),%fp1 # B2+S(B3+...) 5411 fadd.x SINA1(%pc),%fp2 # A1+S(A2+...) 5412 5413 fmul.x %fp0,%fp1 # S(B2+...) 5414 fmul.x %fp2,%fp0 # s(a1+...) 5415 5416 5417 fadd.s COSB1(%pc),%fp1 # B1+S(B2...) 5418 fmul.x RPRIME(%a6),%fp0 # R'S(A1+...) 5419 fmul.x SPRIME(%a6),%fp1 # S'(B1+S(B2+...)) 5420 5421 fmovm.x (%sp)+,&0x20 # restore fp2 5422 5423 fmov.l %d0,%fpcr 5424 fadd.s POSNEG1(%a6),%fp1 # COS(X) 5425 bsr sto_cos # store cosine result 5426 fadd.x RPRIME(%a6),%fp0 # SIN(X) 5427 bra t_inx2 5428 5429 ################################################ 5430 5431 SCBORS: 5432 cmp.l %d1,&0x3FFF8000 5433 bgt.w SREDUCEX 5434 5435 ################################################ 5436 5437 SCSM: 5438 # mov.w &0x0000,XDCARE(%a6) 5439 fmov.s &0x3F800000,%fp1 5440 5441 fmov.l %d0,%fpcr 5442 fsub.s &0x00800000,%fp1 5443 bsr sto_cos # store cosine result 5444 fmov.l %fpcr,%d0 # d0 must have fpcr,too 5445 mov.b &FMOV_OP,%d1 # last inst is MOVE 5446 fmov.x X(%a6),%fp0 5447 bra t_catch 5448 5449 ############################################## 5450 5451 global ssincosd 5452 #--SIN AND COS OF X FOR DENORMALIZED X 5453 ssincosd: 5454 mov.l %d0,-(%sp) # save d0 5455 fmov.s &0x3F800000,%fp1 5456 bsr sto_cos # store cosine result 5457 mov.l (%sp)+,%d0 # restore d0 5458 bra t_extdnrm 5459 5460 ############################################ 5461 5462 #--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW. 5463 #--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING 5464 #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE. 5465 SREDUCEX: 5466 fmovm.x &0x3c,-(%sp) # save {fp2-fp5} 5467 mov.l %d2,-(%sp) # save d2 5468 fmov.s &0x00000000,%fp1 # fp1 = 0 5469 5470 #--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that 5471 #--there is a danger of unwanted overflow in first LOOP iteration. In this 5472 #--case, reduce argument by one remainder step to make subsequent reduction 5473 #--safe. 5474 cmp.l %d1,&0x7ffeffff # is arg dangerously large? 5475 bne.b SLOOP # no 5476 5477 # yes; create 2**16383*PI/2 5478 mov.w &0x7ffe,FP_SCR0_EX(%a6) 5479 mov.l &0xc90fdaa2,FP_SCR0_HI(%a6) 5480 clr.l FP_SCR0_LO(%a6) 5481 5482 # create low half of 2**16383*PI/2 at FP_SCR1 5483 mov.w &0x7fdc,FP_SCR1_EX(%a6) 5484 mov.l &0x85a308d3,FP_SCR1_HI(%a6) 5485 clr.l FP_SCR1_LO(%a6) 5486 5487 ftest.x %fp0 # test sign of argument 5488 fblt.w sred_neg 5489 5490 or.b &0x80,FP_SCR0_EX(%a6) # positive arg 5491 or.b &0x80,FP_SCR1_EX(%a6) 5492 sred_neg: 5493 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact 5494 fmov.x %fp0,%fp1 # save high result in fp1 5495 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction 5496 fsub.x %fp0,%fp1 # determine low component of result 5497 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument. 5498 5499 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4. 5500 #--integer quotient will be stored in N 5501 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1) 5502 SLOOP: 5503 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2 5504 mov.w INARG(%a6),%d1 5505 mov.l %d1,%a1 # save a copy of D0 5506 and.l &0x00007FFF,%d1 5507 sub.l &0x00003FFF,%d1 # d0 = K 5508 cmp.l %d1,&28 5509 ble.b SLASTLOOP 5510 SCONTLOOP: 5511 sub.l &27,%d1 # d0 = L := K-27 5512 mov.b &0,ENDFLAG(%a6) 5513 bra.b SWORK 5514 SLASTLOOP: 5515 clr.l %d1 # d0 = L := 0 5516 mov.b &1,ENDFLAG(%a6) 5517 5518 SWORK: 5519 #--FIND THE REMAINDER OF (R,r) W.R.T. 2**L * (PI/2). L IS SO CHOSEN 5520 #--THAT INT( X * (2/PI) / 2**(L) ) < 2**29. 5521 5522 #--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63), 5523 #--2**L * (PIby2_1), 2**L * (PIby2_2) 5524 5525 mov.l &0x00003FFE,%d2 # BIASED EXP OF 2/PI 5526 sub.l %d1,%d2 # BIASED EXP OF 2**(-L)*(2/PI) 5527 5528 mov.l &0xA2F9836E,FP_SCR0_HI(%a6) 5529 mov.l &0x4E44152A,FP_SCR0_LO(%a6) 5530 mov.w %d2,FP_SCR0_EX(%a6) # FP_SCR0 = 2**(-L)*(2/PI) 5531 5532 fmov.x %fp0,%fp2 5533 fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI) 5534 5535 #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN 5536 #--FLOATING POINT FORMAT, THE TWO FMOVE'S FMOVE.L FP <--> N 5537 #--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT 5538 #--(SIGN(INARG)*2**63 + FP2) - SIGN(INARG)*2**63 WILL GIVE 5539 #--US THE DESIRED VALUE IN FLOATING POINT. 5540 mov.l %a1,%d2 5541 swap %d2 5542 and.l &0x80000000,%d2 5543 or.l &0x5F000000,%d2 # d2 = SIGN(INARG)*2**63 IN SGL 5544 mov.l %d2,TWOTO63(%a6) 5545 fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDED 5546 fsub.s TWOTO63(%a6),%fp2 # fp2 = N 5547 # fint.x %fp2 5548 5549 #--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2 5550 mov.l %d1,%d2 # d2 = L 5551 5552 add.l &0x00003FFF,%d2 # BIASED EXP OF 2**L * (PI/2) 5553 mov.w %d2,FP_SCR0_EX(%a6) 5554 mov.l &0xC90FDAA2,FP_SCR0_HI(%a6) 5555 clr.l FP_SCR0_LO(%a6) # FP_SCR0 = 2**(L) * Piby2_1 5556 5557 add.l &0x00003FDD,%d1 5558 mov.w %d1,FP_SCR1_EX(%a6) 5559 mov.l &0x85A308D3,FP_SCR1_HI(%a6) 5560 clr.l FP_SCR1_LO(%a6) # FP_SCR1 = 2**(L) * Piby2_2 5561 5562 mov.b ENDFLAG(%a6),%d1 5563 5564 #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and 5565 #--P2 = 2**(L) * Piby2_2 5566 fmov.x %fp2,%fp4 # fp4 = N 5567 fmul.x FP_SCR0(%a6),%fp4 # fp4 = W = N*P1 5568 fmov.x %fp2,%fp5 # fp5 = N 5569 fmul.x FP_SCR1(%a6),%fp5 # fp5 = w = N*P2 5570 fmov.x %fp4,%fp3 # fp3 = W = N*P1 5571 5572 #--we want P+p = W+w but |p| <= half ulp of P 5573 #--Then, we need to compute A := R-P and a := r-p 5574 fadd.x %fp5,%fp3 # fp3 = P 5575 fsub.x %fp3,%fp4 # fp4 = W-P 5576 5577 fsub.x %fp3,%fp0 # fp0 = A := R - P 5578 fadd.x %fp5,%fp4 # fp4 = p = (W-P)+w 5579 5580 fmov.x %fp0,%fp3 # fp3 = A 5581 fsub.x %fp4,%fp1 # fp1 = a := r - p 5582 5583 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but 5584 #--|r| <= half ulp of R. 5585 fadd.x %fp1,%fp0 # fp0 = R := A+a 5586 #--No need to calculate r if this is the last loop 5587 cmp.b %d1,&0 5588 bgt.w SRESTORE 5589 5590 #--Need to calculate r 5591 fsub.x %fp0,%fp3 # fp3 = A-R 5592 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a 5593 bra.w SLOOP 5594 5595 SRESTORE: 5596 fmov.l %fp2,INT(%a6) 5597 mov.l (%sp)+,%d2 # restore d2 5598 fmovm.x (%sp)+,&0x3c # restore {fp2-fp5} 5599 5600 mov.l ADJN(%a6),%d1 5601 cmp.l %d1,&4 5602 5603 blt.w SINCONT 5604 bra.w SCCONT 5605 5606 ######################################################################### 5607 # stan(): computes the tangent of a normalized input # 5608 # stand(): computes the tangent of a denormalized input # 5609 # # 5610 # INPUT *************************************************************** # 5611 # a0 = pointer to extended precision input # 5612 # d0 = round precision,mode # 5613 # # 5614 # OUTPUT ************************************************************** # 5615 # fp0 = tan(X) # 5616 # # 5617 # ACCURACY and MONOTONICITY ******************************************* # 5618 # The returned result is within 3 ulp in 64 significant bit, i.e. # 5619 # within 0.5001 ulp to 53 bits if the result is subsequently # 5620 # rounded to double precision. The result is provably monotonic # 5621 # in double precision. # 5622 # # 5623 # ALGORITHM *********************************************************** # 5624 # # 5625 # 1. If |X| >= 15Pi or |X| < 2**(-40), go to 6. # 5626 # # 5627 # 2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let # 5628 # k = N mod 2, so in particular, k = 0 or 1. # 5629 # # 5630 # 3. If k is odd, go to 5. # 5631 # # 5632 # 4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a # 5633 # rational function U/V where # 5634 # U = r + r*s*(P1 + s*(P2 + s*P3)), and # 5635 # V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r. # 5636 # Exit. # 5637 # # 5638 # 4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by # 5639 # a rational function U/V where # 5640 # U = r + r*s*(P1 + s*(P2 + s*P3)), and # 5641 # V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r, # 5642 # -Cot(r) = -V/U. Exit. # 5643 # # 5644 # 6. If |X| > 1, go to 8. # 5645 # # 5646 # 7. (|X|<2**(-40)) Tan(X) = X. Exit. # 5647 # # 5648 # 8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back # 5649 # to 2. # 5650 # # 5651 ######################################################################### 5652 5653 TANQ4: 5654 long 0x3EA0B759,0xF50F8688 5655 TANP3: 5656 long 0xBEF2BAA5,0xA8924F04 5657 5658 TANQ3: 5659 long 0xBF346F59,0xB39BA65F,0x00000000,0x00000000 5660 5661 TANP2: 5662 long 0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000 5663 5664 TANQ2: 5665 long 0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000 5666 5667 TANP1: 5668 long 0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000 5669 5670 TANQ1: 5671 long 0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000 5672 5673 INVTWOPI: 5674 long 0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000 5675 5676 TWOPI1: 5677 long 0x40010000,0xC90FDAA2,0x00000000,0x00000000 5678 TWOPI2: 5679 long 0x3FDF0000,0x85A308D4,0x00000000,0x00000000 5680 5681 #--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING 5682 #--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT 5683 #--MOST 69 BITS LONG. 5684 # global PITBL 5685 PITBL: 5686 long 0xC0040000,0xC90FDAA2,0x2168C235,0x21800000 5687 long 0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000 5688 long 0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000 5689 long 0xC0040000,0xB6365E22,0xEE46F000,0x21480000 5690 long 0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000 5691 long 0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000 5692 long 0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000 5693 long 0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000 5694 long 0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000 5695 long 0xC0040000,0x90836524,0x88034B96,0x20B00000 5696 long 0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000 5697 long 0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000 5698 long 0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000 5699 long 0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000 5700 long 0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000 5701 long 0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000 5702 long 0xC0030000,0xC90FDAA2,0x2168C235,0x21000000 5703 long 0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000 5704 long 0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000 5705 long 0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000 5706 long 0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000 5707 long 0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000 5708 long 0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000 5709 long 0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000 5710 long 0xC0020000,0xC90FDAA2,0x2168C235,0x20800000 5711 long 0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000 5712 long 0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000 5713 long 0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000 5714 long 0xC0010000,0xC90FDAA2,0x2168C235,0x20000000 5715 long 0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000 5716 long 0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000 5717 long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000 5718 long 0x00000000,0x00000000,0x00000000,0x00000000 5719 long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000 5720 long 0x40000000,0xC90FDAA2,0x2168C235,0x9F800000 5721 long 0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000 5722 long 0x40010000,0xC90FDAA2,0x2168C235,0xA0000000 5723 long 0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000 5724 long 0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000 5725 long 0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000 5726 long 0x40020000,0xC90FDAA2,0x2168C235,0xA0800000 5727 long 0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000 5728 long 0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000 5729 long 0x40030000,0x8A3AE64F,0x76F80584,0x21080000 5730 long 0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000 5731 long 0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000 5732 long 0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000 5733 long 0x40030000,0xBC7EDCF7,0xFF523611,0x21680000 5734 long 0x40030000,0xC90FDAA2,0x2168C235,0xA1000000 5735 long 0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000 5736 long 0x40030000,0xE231D5F6,0x6595DA7B,0x21300000 5737 long 0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000 5738 long 0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000 5739 long 0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000 5740 long 0x40040000,0x8A3AE64F,0x76F80584,0x21880000 5741 long 0x40040000,0x90836524,0x88034B96,0xA0B00000 5742 long 0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000 5743 long 0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000 5744 long 0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000 5745 long 0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000 5746 long 0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000 5747 long 0x40040000,0xB6365E22,0xEE46F000,0xA1480000 5748 long 0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000 5749 long 0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000 5750 long 0x40040000,0xC90FDAA2,0x2168C235,0xA1800000 5751 5752 set INARG,FP_SCR0 5753 5754 set TWOTO63,L_SCR1 5755 set INT,L_SCR1 5756 set ENDFLAG,L_SCR2 5757 5758 global stan 5759 stan: 5760 fmov.x (%a0),%fp0 # LOAD INPUT 5761 5762 mov.l (%a0),%d1 5763 mov.w 4(%a0),%d1 5764 and.l &0x7FFFFFFF,%d1 5765 5766 cmp.l %d1,&0x3FD78000 # |X| >= 2**(-40)? 5767 bge.b TANOK1 5768 bra.w TANSM 5769 TANOK1: 5770 cmp.l %d1,&0x4004BC7E # |X| < 15 PI? 5771 blt.b TANMAIN 5772 bra.w REDUCEX 5773 5774 TANMAIN: 5775 #--THIS IS THE USUAL CASE, |X| <= 15 PI. 5776 #--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP. 5777 fmov.x %fp0,%fp1 5778 fmul.d TWOBYPI(%pc),%fp1 # X*2/PI 5779 5780 lea.l PITBL+0x200(%pc),%a1 # TABLE OF N*PI/2, N = -32,...,32 5781 5782 fmov.l %fp1,%d1 # CONVERT TO INTEGER 5783 5784 asl.l &4,%d1 5785 add.l %d1,%a1 # ADDRESS N*PIBY2 IN Y1, Y2 5786 5787 fsub.x (%a1)+,%fp0 # X-Y1 5788 5789 fsub.s (%a1),%fp0 # FP0 IS R = (X-Y1)-Y2 5790 5791 ror.l &5,%d1 5792 and.l &0x80000000,%d1 # D0 WAS ODD IFF D0 < 0 5793 5794 TANCONT: 5795 fmovm.x &0x0c,-(%sp) # save fp2,fp3 5796 5797 cmp.l %d1,&0 5798 blt.w NODD 5799 5800 fmov.x %fp0,%fp1 5801 fmul.x %fp1,%fp1 # S = R*R 5802 5803 fmov.d TANQ4(%pc),%fp3 5804 fmov.d TANP3(%pc),%fp2 5805 5806 fmul.x %fp1,%fp3 # SQ4 5807 fmul.x %fp1,%fp2 # SP3 5808 5809 fadd.d TANQ3(%pc),%fp3 # Q3+SQ4 5810 fadd.x TANP2(%pc),%fp2 # P2+SP3 5811 5812 fmul.x %fp1,%fp3 # S(Q3+SQ4) 5813 fmul.x %fp1,%fp2 # S(P2+SP3) 5814 5815 fadd.x TANQ2(%pc),%fp3 # Q2+S(Q3+SQ4) 5816 fadd.x TANP1(%pc),%fp2 # P1+S(P2+SP3) 5817 5818 fmul.x %fp1,%fp3 # S(Q2+S(Q3+SQ4)) 5819 fmul.x %fp1,%fp2 # S(P1+S(P2+SP3)) 5820 5821 fadd.x TANQ1(%pc),%fp3 # Q1+S(Q2+S(Q3+SQ4)) 5822 fmul.x %fp0,%fp2 # RS(P1+S(P2+SP3)) 5823 5824 fmul.x %fp3,%fp1 # S(Q1+S(Q2+S(Q3+SQ4))) 5825 5826 fadd.x %fp2,%fp0 # R+RS(P1+S(P2+SP3)) 5827 5828 fadd.s &0x3F800000,%fp1 # 1+S(Q1+...) 5829 5830 fmovm.x (%sp)+,&0x30 # restore fp2,fp3 5831 5832 fmov.l %d0,%fpcr # restore users round mode,prec 5833 fdiv.x %fp1,%fp0 # last inst - possible exception set 5834 bra t_inx2 5835 5836 NODD: 5837 fmov.x %fp0,%fp1 5838 fmul.x %fp0,%fp0 # S = R*R 5839 5840 fmov.d TANQ4(%pc),%fp3 5841 fmov.d TANP3(%pc),%fp2 5842 5843 fmul.x %fp0,%fp3 # SQ4 5844 fmul.x %fp0,%fp2 # SP3 5845 5846 fadd.d TANQ3(%pc),%fp3 # Q3+SQ4 5847 fadd.x TANP2(%pc),%fp2 # P2+SP3 5848 5849 fmul.x %fp0,%fp3 # S(Q3+SQ4) 5850 fmul.x %fp0,%fp2 # S(P2+SP3) 5851 5852 fadd.x TANQ2(%pc),%fp3 # Q2+S(Q3+SQ4) 5853 fadd.x TANP1(%pc),%fp2 # P1+S(P2+SP3) 5854 5855 fmul.x %fp0,%fp3 # S(Q2+S(Q3+SQ4)) 5856 fmul.x %fp0,%fp2 # S(P1+S(P2+SP3)) 5857 5858 fadd.x TANQ1(%pc),%fp3 # Q1+S(Q2+S(Q3+SQ4)) 5859 fmul.x %fp1,%fp2 # RS(P1+S(P2+SP3)) 5860 5861 fmul.x %fp3,%fp0 # S(Q1+S(Q2+S(Q3+SQ4))) 5862 5863 fadd.x %fp2,%fp1 # R+RS(P1+S(P2+SP3)) 5864 fadd.s &0x3F800000,%fp0 # 1+S(Q1+...) 5865 5866 fmovm.x (%sp)+,&0x30 # restore fp2,fp3 5867 5868 fmov.x %fp1,-(%sp) 5869 eor.l &0x80000000,(%sp) 5870 5871 fmov.l %d0,%fpcr # restore users round mode,prec 5872 fdiv.x (%sp)+,%fp0 # last inst - possible exception set 5873 bra t_inx2 5874 5875 TANBORS: 5876 #--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION. 5877 #--IF |X| < 2**(-40), RETURN X OR 1. 5878 cmp.l %d1,&0x3FFF8000 5879 bgt.b REDUCEX 5880 5881 TANSM: 5882 fmov.x %fp0,-(%sp) 5883 fmov.l %d0,%fpcr # restore users round mode,prec 5884 mov.b &FMOV_OP,%d1 # last inst is MOVE 5885 fmov.x (%sp)+,%fp0 # last inst - posibble exception set 5886 bra t_catch 5887 5888 global stand 5889 #--TAN(X) = X FOR DENORMALIZED X 5890 stand: 5891 bra t_extdnrm 5892 5893 #--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW. 5894 #--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING 5895 #--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE. 5896 REDUCEX: 5897 fmovm.x &0x3c,-(%sp) # save {fp2-fp5} 5898 mov.l %d2,-(%sp) # save d2 5899 fmov.s &0x00000000,%fp1 # fp1 = 0 5900 5901 #--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that 5902 #--there is a danger of unwanted overflow in first LOOP iteration. In this 5903 #--case, reduce argument by one remainder step to make subsequent reduction 5904 #--safe. 5905 cmp.l %d1,&0x7ffeffff # is arg dangerously large? 5906 bne.b LOOP # no 5907 5908 # yes; create 2**16383*PI/2 5909 mov.w &0x7ffe,FP_SCR0_EX(%a6) 5910 mov.l &0xc90fdaa2,FP_SCR0_HI(%a6) 5911 clr.l FP_SCR0_LO(%a6) 5912 5913 # create low half of 2**16383*PI/2 at FP_SCR1 5914 mov.w &0x7fdc,FP_SCR1_EX(%a6) 5915 mov.l &0x85a308d3,FP_SCR1_HI(%a6) 5916 clr.l FP_SCR1_LO(%a6) 5917 5918 ftest.x %fp0 # test sign of argument 5919 fblt.w red_neg 5920 5921 or.b &0x80,FP_SCR0_EX(%a6) # positive arg 5922 or.b &0x80,FP_SCR1_EX(%a6) 5923 red_neg: 5924 fadd.x FP_SCR0(%a6),%fp0 # high part of reduction is exact 5925 fmov.x %fp0,%fp1 # save high result in fp1 5926 fadd.x FP_SCR1(%a6),%fp0 # low part of reduction 5927 fsub.x %fp0,%fp1 # determine low component of result 5928 fadd.x FP_SCR1(%a6),%fp1 # fp0/fp1 are reduced argument. 5929 5930 #--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4. 5931 #--integer quotient will be stored in N 5932 #--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1) 5933 LOOP: 5934 fmov.x %fp0,INARG(%a6) # +-2**K * F, 1 <= F < 2 5935 mov.w INARG(%a6),%d1 5936 mov.l %d1,%a1 # save a copy of D0 5937 and.l &0x00007FFF,%d1 5938 sub.l &0x00003FFF,%d1 # d0 = K 5939 cmp.l %d1,&28 5940 ble.b LASTLOOP 5941 CONTLOOP: 5942 sub.l &27,%d1 # d0 = L := K-27 5943 mov.b &0,ENDFLAG(%a6) 5944 bra.b WORK 5945 LASTLOOP: 5946 clr.l %d1 # d0 = L := 0 5947 mov.b &1,ENDFLAG(%a6) 5948 5949 WORK: 5950 #--FIND THE REMAINDER OF (R,r) W.R.T. 2**L * (PI/2). L IS SO CHOSEN 5951 #--THAT INT( X * (2/PI) / 2**(L) ) < 2**29. 5952 5953 #--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63), 5954 #--2**L * (PIby2_1), 2**L * (PIby2_2) 5955 5956 mov.l &0x00003FFE,%d2 # BIASED EXP OF 2/PI 5957 sub.l %d1,%d2 # BIASED EXP OF 2**(-L)*(2/PI) 5958 5959 mov.l &0xA2F9836E,FP_SCR0_HI(%a6) 5960 mov.l &0x4E44152A,FP_SCR0_LO(%a6) 5961 mov.w %d2,FP_SCR0_EX(%a6) # FP_SCR0 = 2**(-L)*(2/PI) 5962 5963 fmov.x %fp0,%fp2 5964 fmul.x FP_SCR0(%a6),%fp2 # fp2 = X * 2**(-L)*(2/PI) 5965 5966 #--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN 5967 #--FLOATING POINT FORMAT, THE TWO FMOVE'S FMOVE.L FP <--> N 5968 #--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT 5969 #--(SIGN(INARG)*2**63 + FP2) - SIGN(INARG)*2**63 WILL GIVE 5970 #--US THE DESIRED VALUE IN FLOATING POINT. 5971 mov.l %a1,%d2 5972 swap %d2 5973 and.l &0x80000000,%d2 5974 or.l &0x5F000000,%d2 # d2 = SIGN(INARG)*2**63 IN SGL 5975 mov.l %d2,TWOTO63(%a6) 5976 fadd.s TWOTO63(%a6),%fp2 # THE FRACTIONAL PART OF FP1 IS ROUNDED 5977 fsub.s TWOTO63(%a6),%fp2 # fp2 = N 5978 # fintrz.x %fp2,%fp2 5979 5980 #--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2 5981 mov.l %d1,%d2 # d2 = L 5982 5983 add.l &0x00003FFF,%d2 # BIASED EXP OF 2**L * (PI/2) 5984 mov.w %d2,FP_SCR0_EX(%a6) 5985 mov.l &0xC90FDAA2,FP_SCR0_HI(%a6) 5986 clr.l FP_SCR0_LO(%a6) # FP_SCR0 = 2**(L) * Piby2_1 5987 5988 add.l &0x00003FDD,%d1 5989 mov.w %d1,FP_SCR1_EX(%a6) 5990 mov.l &0x85A308D3,FP_SCR1_HI(%a6) 5991 clr.l FP_SCR1_LO(%a6) # FP_SCR1 = 2**(L) * Piby2_2 5992 5993 mov.b ENDFLAG(%a6),%d1 5994 5995 #--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and 5996 #--P2 = 2**(L) * Piby2_2 5997 fmov.x %fp2,%fp4 # fp4 = N 5998 fmul.x FP_SCR0(%a6),%fp4 # fp4 = W = N*P1 5999 fmov.x %fp2,%fp5 # fp5 = N 6000 fmul.x FP_SCR1(%a6),%fp5 # fp5 = w = N*P2 6001 fmov.x %fp4,%fp3 # fp3 = W = N*P1 6002 6003 #--we want P+p = W+w but |p| <= half ulp of P 6004 #--Then, we need to compute A := R-P and a := r-p 6005 fadd.x %fp5,%fp3 # fp3 = P 6006 fsub.x %fp3,%fp4 # fp4 = W-P 6007 6008 fsub.x %fp3,%fp0 # fp0 = A := R - P 6009 fadd.x %fp5,%fp4 # fp4 = p = (W-P)+w 6010 6011 fmov.x %fp0,%fp3 # fp3 = A 6012 fsub.x %fp4,%fp1 # fp1 = a := r - p 6013 6014 #--Now we need to normalize (A,a) to "new (R,r)" where R+r = A+a but 6015 #--|r| <= half ulp of R. 6016 fadd.x %fp1,%fp0 # fp0 = R := A+a 6017 #--No need to calculate r if this is the last loop 6018 cmp.b %d1,&0 6019 bgt.w RESTORE 6020 6021 #--Need to calculate r 6022 fsub.x %fp0,%fp3 # fp3 = A-R 6023 fadd.x %fp3,%fp1 # fp1 = r := (A-R)+a 6024 bra.w LOOP 6025 6026 RESTORE: 6027 fmov.l %fp2,INT(%a6) 6028 mov.l (%sp)+,%d2 # restore d2 6029 fmovm.x (%sp)+,&0x3c # restore {fp2-fp5} 6030 6031 mov.l INT(%a6),%d1 6032 ror.l &1,%d1 6033 6034 bra.w TANCONT 6035 6036 ######################################################################### 6037 # satan(): computes the arctangent of a normalized number # 6038 # satand(): computes the arctangent of a denormalized number # 6039 # # 6040 # INPUT *************************************************************** # 6041 # a0 = pointer to extended precision input # 6042 # d0 = round precision,mode # 6043 # # 6044 # OUTPUT ************************************************************** # 6045 # fp0 = arctan(X) # 6046 # # 6047 # ACCURACY and MONOTONICITY ******************************************* # 6048 # The returned result is within 2 ulps in 64 significant bit, # 6049 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 6050 # rounded to double precision. The result is provably monotonic # 6051 # in double precision. # 6052 # # 6053 # ALGORITHM *********************************************************** # 6054 # Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5. # 6055 # # 6056 # Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x. # 6057 # Note that k = -4, -3,..., or 3. # 6058 # Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5 # 6059 # significant bits of X with a bit-1 attached at the 6-th # 6060 # bit position. Define u to be u = (X-F) / (1 + X*F). # 6061 # # 6062 # Step 3. Approximate arctan(u) by a polynomial poly. # 6063 # # 6064 # Step 4. Return arctan(F) + poly, arctan(F) is fetched from a # 6065 # table of values calculated beforehand. Exit. # 6066 # # 6067 # Step 5. If |X| >= 16, go to Step 7. # 6068 # # 6069 # Step 6. Approximate arctan(X) by an odd polynomial in X. Exit. # 6070 # # 6071 # Step 7. Define X' = -1/X. Approximate arctan(X') by an odd # 6072 # polynomial in X'. # 6073 # Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit. # 6074 # # 6075 ######################################################################### 6076 6077 ATANA3: long 0xBFF6687E,0x314987D8 6078 ATANA2: long 0x4002AC69,0x34A26DB3 6079 ATANA1: long 0xBFC2476F,0x4E1DA28E 6080 6081 ATANB6: long 0x3FB34444,0x7F876989 6082 ATANB5: long 0xBFB744EE,0x7FAF45DB 6083 ATANB4: long 0x3FBC71C6,0x46940220 6084 ATANB3: long 0xBFC24924,0x921872F9 6085 ATANB2: long 0x3FC99999,0x99998FA9 6086 ATANB1: long 0xBFD55555,0x55555555 6087 6088 ATANC5: long 0xBFB70BF3,0x98539E6A 6089 ATANC4: long 0x3FBC7187,0x962D1D7D 6090 ATANC3: long 0xBFC24924,0x827107B8 6091 ATANC2: long 0x3FC99999,0x9996263E 6092 ATANC1: long 0xBFD55555,0x55555536 6093 6094 PPIBY2: long 0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000 6095 NPIBY2: long 0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000 6096 6097 PTINY: long 0x00010000,0x80000000,0x00000000,0x00000000 6098 NTINY: long 0x80010000,0x80000000,0x00000000,0x00000000 6099 6100 ATANTBL: 6101 long 0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000 6102 long 0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000 6103 long 0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000 6104 long 0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000 6105 long 0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000 6106 long 0x3FFB0000,0xAB98E943,0x62765619,0x00000000 6107 long 0x3FFB0000,0xB389E502,0xF9C59862,0x00000000 6108 long 0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000 6109 long 0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000 6110 long 0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000 6111 long 0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000 6112 long 0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000 6113 long 0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000 6114 long 0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000 6115 long 0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000 6116 long 0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000 6117 long 0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000 6118 long 0x3FFC0000,0x8B232A08,0x304282D8,0x00000000 6119 long 0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000 6120 long 0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000 6121 long 0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000 6122 long 0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000 6123 long 0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000 6124 long 0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000 6125 long 0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000 6126 long 0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000 6127 long 0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000 6128 long 0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000 6129 long 0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000 6130 long 0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000 6131 long 0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000 6132 long 0x3FFC0000,0xF7170A28,0xECC06666,0x00000000 6133 long 0x3FFD0000,0x812FD288,0x332DAD32,0x00000000 6134 long 0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000 6135 long 0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000 6136 long 0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000 6137 long 0x3FFD0000,0x9EB68949,0x3889A227,0x00000000 6138 long 0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000 6139 long 0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000 6140 long 0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000 6141 long 0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000 6142 long 0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000 6143 long 0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000 6144 long 0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000 6145 long 0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000 6146 long 0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000 6147 long 0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000 6148 long 0x3FFD0000,0xEA2D764F,0x64315989,0x00000000 6149 long 0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000 6150 long 0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000 6151 long 0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000 6152 long 0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000 6153 long 0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000 6154 long 0x3FFE0000,0x97731420,0x365E538C,0x00000000 6155 long 0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000 6156 long 0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000 6157 long 0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000 6158 long 0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000 6159 long 0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000 6160 long 0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000 6161 long 0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000 6162 long 0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000 6163 long 0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000 6164 long 0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000 6165 long 0x3FFE0000,0xCD000549,0xADEC7159,0x00000000 6166 long 0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000 6167 long 0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000 6168 long 0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000 6169 long 0x3FFE0000,0xE8771129,0xC4353259,0x00000000 6170 long 0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000 6171 long 0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000 6172 long 0x3FFE0000,0xF919039D,0x758B8D41,0x00000000 6173 long 0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000 6174 long 0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000 6175 long 0x3FFF0000,0x83889E35,0x49D108E1,0x00000000 6176 long 0x3FFF0000,0x859CFA76,0x511D724B,0x00000000 6177 long 0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000 6178 long 0x3FFF0000,0x89732FD1,0x9557641B,0x00000000 6179 long 0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000 6180 long 0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000 6181 long 0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000 6182 long 0x3FFF0000,0x922DA7D7,0x91888487,0x00000000 6183 long 0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000 6184 long 0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000 6185 long 0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000 6186 long 0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000 6187 long 0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000 6188 long 0x3FFF0000,0x9F100575,0x006CC571,0x00000000 6189 long 0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000 6190 long 0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000 6191 long 0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000 6192 long 0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000 6193 long 0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000 6194 long 0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000 6195 long 0x3FFF0000,0xA83A5153,0x0956168F,0x00000000 6196 long 0x3FFF0000,0xA93A2007,0x7539546E,0x00000000 6197 long 0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000 6198 long 0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000 6199 long 0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000 6200 long 0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000 6201 long 0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000 6202 long 0x3FFF0000,0xB1846515,0x0F71496A,0x00000000 6203 long 0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000 6204 long 0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000 6205 long 0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000 6206 long 0x3FFF0000,0xB525529D,0x562246BD,0x00000000 6207 long 0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000 6208 long 0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000 6209 long 0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000 6210 long 0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000 6211 long 0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000 6212 long 0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000 6213 long 0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000 6214 long 0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000 6215 long 0x3FFF0000,0xBB471285,0x7637E17D,0x00000000 6216 long 0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000 6217 long 0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000 6218 long 0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000 6219 long 0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000 6220 long 0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000 6221 long 0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000 6222 long 0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000 6223 long 0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000 6224 long 0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000 6225 long 0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000 6226 long 0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000 6227 long 0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000 6228 long 0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000 6229 6230 set X,FP_SCR0 6231 set XDCARE,X+2 6232 set XFRAC,X+4 6233 set XFRACLO,X+8 6234 6235 set ATANF,FP_SCR1 6236 set ATANFHI,ATANF+4 6237 set ATANFLO,ATANF+8 6238 6239 global satan 6240 #--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S 6241 satan: 6242 fmov.x (%a0),%fp0 # LOAD INPUT 6243 6244 mov.l (%a0),%d1 6245 mov.w 4(%a0),%d1 6246 fmov.x %fp0,X(%a6) 6247 and.l &0x7FFFFFFF,%d1 6248 6249 cmp.l %d1,&0x3FFB8000 # |X| >= 1/16? 6250 bge.b ATANOK1 6251 bra.w ATANSM 6252 6253 ATANOK1: 6254 cmp.l %d1,&0x4002FFFF # |X| < 16 ? 6255 ble.b ATANMAIN 6256 bra.w ATANBIG 6257 6258 #--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE 6259 #--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ). 6260 #--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN 6261 #--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE 6262 #--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS 6263 #--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR 6264 #--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO 6265 #--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE 6266 #--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL 6267 #--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE 6268 #--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION 6269 #--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION 6270 #--WILL INVOLVE A VERY LONG POLYNOMIAL. 6271 6272 #--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS 6273 #--WE CHOSE F TO BE +-2^K * 1.BBBB1 6274 #--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE 6275 #--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE 6276 #--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS 6277 #-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|). 6278 6279 ATANMAIN: 6280 6281 and.l &0xF8000000,XFRAC(%a6) # FIRST 5 BITS 6282 or.l &0x04000000,XFRAC(%a6) # SET 6-TH BIT TO 1 6283 mov.l &0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F 6284 6285 fmov.x %fp0,%fp1 # FP1 IS X 6286 fmul.x X(%a6),%fp1 # FP1 IS X*F, NOTE THAT X*F > 0 6287 fsub.x X(%a6),%fp0 # FP0 IS X-F 6288 fadd.s &0x3F800000,%fp1 # FP1 IS 1 + X*F 6289 fdiv.x %fp1,%fp0 # FP0 IS U = (X-F)/(1+X*F) 6290 6291 #--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|) 6292 #--CREATE ATAN(F) AND STORE IT IN ATANF, AND 6293 #--SAVE REGISTERS FP2. 6294 6295 mov.l %d2,-(%sp) # SAVE d2 TEMPORARILY 6296 mov.l %d1,%d2 # THE EXP AND 16 BITS OF X 6297 and.l &0x00007800,%d1 # 4 VARYING BITS OF F'S FRACTION 6298 and.l &0x7FFF0000,%d2 # EXPONENT OF F 6299 sub.l &0x3FFB0000,%d2 # K+4 6300 asr.l &1,%d2 6301 add.l %d2,%d1 # THE 7 BITS IDENTIFYING F 6302 asr.l &7,%d1 # INDEX INTO TBL OF ATAN(|F|) 6303 lea ATANTBL(%pc),%a1 6304 add.l %d1,%a1 # ADDRESS OF ATAN(|F|) 6305 mov.l (%a1)+,ATANF(%a6) 6306 mov.l (%a1)+,ATANFHI(%a6) 6307 mov.l (%a1)+,ATANFLO(%a6) # ATANF IS NOW ATAN(|F|) 6308 mov.l X(%a6),%d1 # LOAD SIGN AND EXPO. AGAIN 6309 and.l &0x80000000,%d1 # SIGN(F) 6310 or.l %d1,ATANF(%a6) # ATANF IS NOW SIGN(F)*ATAN(|F|) 6311 mov.l (%sp)+,%d2 # RESTORE d2 6312 6313 #--THAT'S ALL I HAVE TO DO FOR NOW, 6314 #--BUT ALAS, THE DIVIDE IS STILL CRANKING! 6315 6316 #--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS 6317 #--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U 6318 #--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT. 6319 #--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3)) 6320 #--WHAT WE HAVE HERE IS MERELY A1 = A3, A2 = A1/A3, A3 = A2/A3. 6321 #--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT 6322 #--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCED 6323 6324 fmovm.x &0x04,-(%sp) # save fp2 6325 6326 fmov.x %fp0,%fp1 6327 fmul.x %fp1,%fp1 6328 fmov.d ATANA3(%pc),%fp2 6329 fadd.x %fp1,%fp2 # A3+V 6330 fmul.x %fp1,%fp2 # V*(A3+V) 6331 fmul.x %fp0,%fp1 # U*V 6332 fadd.d ATANA2(%pc),%fp2 # A2+V*(A3+V) 6333 fmul.d ATANA1(%pc),%fp1 # A1*U*V 6334 fmul.x %fp2,%fp1 # A1*U*V*(A2+V*(A3+V)) 6335 fadd.x %fp1,%fp0 # ATAN(U), FP1 RELEASED 6336 6337 fmovm.x (%sp)+,&0x20 # restore fp2 6338 6339 fmov.l %d0,%fpcr # restore users rnd mode,prec 6340 fadd.x ATANF(%a6),%fp0 # ATAN(X) 6341 bra t_inx2 6342 6343 ATANBORS: 6344 #--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED. 6345 #--FP0 IS X AND |X| <= 1/16 OR |X| >= 16. 6346 cmp.l %d1,&0x3FFF8000 6347 bgt.w ATANBIG # I.E. |X| >= 16 6348 6349 ATANSM: 6350 #--|X| <= 1/16 6351 #--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE 6352 #--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6))))) 6353 #--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] ) 6354 #--WHERE Y = X*X, AND Z = Y*Y. 6355 6356 cmp.l %d1,&0x3FD78000 6357 blt.w ATANTINY 6358 6359 #--COMPUTE POLYNOMIAL 6360 fmovm.x &0x0c,-(%sp) # save fp2/fp3 6361 6362 fmul.x %fp0,%fp0 # FPO IS Y = X*X 6363 6364 fmov.x %fp0,%fp1 6365 fmul.x %fp1,%fp1 # FP1 IS Z = Y*Y 6366 6367 fmov.d ATANB6(%pc),%fp2 6368 fmov.d ATANB5(%pc),%fp3 6369 6370 fmul.x %fp1,%fp2 # Z*B6 6371 fmul.x %fp1,%fp3 # Z*B5 6372 6373 fadd.d ATANB4(%pc),%fp2 # B4+Z*B6 6374 fadd.d ATANB3(%pc),%fp3 # B3+Z*B5 6375 6376 fmul.x %fp1,%fp2 # Z*(B4+Z*B6) 6377 fmul.x %fp3,%fp1 # Z*(B3+Z*B5) 6378 6379 fadd.d ATANB2(%pc),%fp2 # B2+Z*(B4+Z*B6) 6380 fadd.d ATANB1(%pc),%fp1 # B1+Z*(B3+Z*B5) 6381 6382 fmul.x %fp0,%fp2 # Y*(B2+Z*(B4+Z*B6)) 6383 fmul.x X(%a6),%fp0 # X*Y 6384 6385 fadd.x %fp2,%fp1 # [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))] 6386 6387 fmul.x %fp1,%fp0 # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]) 6388 6389 fmovm.x (%sp)+,&0x30 # restore fp2/fp3 6390 6391 fmov.l %d0,%fpcr # restore users rnd mode,prec 6392 fadd.x X(%a6),%fp0 6393 bra t_inx2 6394 6395 ATANTINY: 6396 #--|X| < 2^(-40), ATAN(X) = X 6397 6398 fmov.l %d0,%fpcr # restore users rnd mode,prec 6399 mov.b &FMOV_OP,%d1 # last inst is MOVE 6400 fmov.x X(%a6),%fp0 # last inst - possible exception set 6401 6402 bra t_catch 6403 6404 ATANBIG: 6405 #--IF |X| > 2^(100), RETURN SIGN(X)*(PI/2 - TINY). OTHERWISE, 6406 #--RETURN SIGN(X)*PI/2 + ATAN(-1/X). 6407 cmp.l %d1,&0x40638000 6408 bgt.w ATANHUGE 6409 6410 #--APPROXIMATE ATAN(-1/X) BY 6411 #--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X' 6412 #--THIS CAN BE RE-WRITTEN AS 6413 #--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y. 6414 6415 fmovm.x &0x0c,-(%sp) # save fp2/fp3 6416 6417 fmov.s &0xBF800000,%fp1 # LOAD -1 6418 fdiv.x %fp0,%fp1 # FP1 IS -1/X 6419 6420 #--DIVIDE IS STILL CRANKING 6421 6422 fmov.x %fp1,%fp0 # FP0 IS X' 6423 fmul.x %fp0,%fp0 # FP0 IS Y = X'*X' 6424 fmov.x %fp1,X(%a6) # X IS REALLY X' 6425 6426 fmov.x %fp0,%fp1 6427 fmul.x %fp1,%fp1 # FP1 IS Z = Y*Y 6428 6429 fmov.d ATANC5(%pc),%fp3 6430 fmov.d ATANC4(%pc),%fp2 6431 6432 fmul.x %fp1,%fp3 # Z*C5 6433 fmul.x %fp1,%fp2 # Z*B4 6434 6435 fadd.d ATANC3(%pc),%fp3 # C3+Z*C5 6436 fadd.d ATANC2(%pc),%fp2 # C2+Z*C4 6437 6438 fmul.x %fp3,%fp1 # Z*(C3+Z*C5), FP3 RELEASED 6439 fmul.x %fp0,%fp2 # Y*(C2+Z*C4) 6440 6441 fadd.d ATANC1(%pc),%fp1 # C1+Z*(C3+Z*C5) 6442 fmul.x X(%a6),%fp0 # X'*Y 6443 6444 fadd.x %fp2,%fp1 # [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)] 6445 6446 fmul.x %fp1,%fp0 # X'*Y*([B1+Z*(B3+Z*B5)] 6447 # ... +[Y*(B2+Z*(B4+Z*B6))]) 6448 fadd.x X(%a6),%fp0 6449 6450 fmovm.x (%sp)+,&0x30 # restore fp2/fp3 6451 6452 fmov.l %d0,%fpcr # restore users rnd mode,prec 6453 tst.b (%a0) 6454 bpl.b pos_big 6455 6456 neg_big: 6457 fadd.x NPIBY2(%pc),%fp0 6458 bra t_minx2 6459 6460 pos_big: 6461 fadd.x PPIBY2(%pc),%fp0 6462 bra t_pinx2 6463 6464 ATANHUGE: 6465 #--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINY 6466 tst.b (%a0) 6467 bpl.b pos_huge 6468 6469 neg_huge: 6470 fmov.x NPIBY2(%pc),%fp0 6471 fmov.l %d0,%fpcr 6472 fadd.x PTINY(%pc),%fp0 6473 bra t_minx2 6474 6475 pos_huge: 6476 fmov.x PPIBY2(%pc),%fp0 6477 fmov.l %d0,%fpcr 6478 fadd.x NTINY(%pc),%fp0 6479 bra t_pinx2 6480 6481 global satand 6482 #--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENT 6483 satand: 6484 bra t_extdnrm 6485 6486 ######################################################################### 6487 # sasin(): computes the inverse sine of a normalized input # 6488 # sasind(): computes the inverse sine of a denormalized input # 6489 # # 6490 # INPUT *************************************************************** # 6491 # a0 = pointer to extended precision input # 6492 # d0 = round precision,mode # 6493 # # 6494 # OUTPUT ************************************************************** # 6495 # fp0 = arcsin(X) # 6496 # # 6497 # ACCURACY and MONOTONICITY ******************************************* # 6498 # The returned result is within 3 ulps in 64 significant bit, # 6499 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 6500 # rounded to double precision. The result is provably monotonic # 6501 # in double precision. # 6502 # # 6503 # ALGORITHM *********************************************************** # 6504 # # 6505 # ASIN # 6506 # 1. If |X| >= 1, go to 3. # 6507 # # 6508 # 2. (|X| < 1) Calculate asin(X) by # 6509 # z := sqrt( [1-X][1+X] ) # 6510 # asin(X) = atan( x / z ). # 6511 # Exit. # 6512 # # 6513 # 3. If |X| > 1, go to 5. # 6514 # # 6515 # 4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.# 6516 # # 6517 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. # 6518 # Exit. # 6519 # # 6520 ######################################################################### 6521 6522 global sasin 6523 sasin: 6524 fmov.x (%a0),%fp0 # LOAD INPUT 6525 6526 mov.l (%a0),%d1 6527 mov.w 4(%a0),%d1 6528 and.l &0x7FFFFFFF,%d1 6529 cmp.l %d1,&0x3FFF8000 6530 bge.b ASINBIG 6531 6532 # This catch is added here for the '060 QSP. Originally, the call to 6533 # satan() would handle this case by causing the exception which would 6534 # not be caught until gen_except(). Now, with the exceptions being 6535 # detected inside of satan(), the exception would have been handled there 6536 # instead of inside sasin() as expected. 6537 cmp.l %d1,&0x3FD78000 6538 blt.w ASINTINY 6539 6540 #--THIS IS THE USUAL CASE, |X| < 1 6541 #--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) ) 6542 6543 ASINMAIN: 6544 fmov.s &0x3F800000,%fp1 6545 fsub.x %fp0,%fp1 # 1-X 6546 fmovm.x &0x4,-(%sp) # {fp2} 6547 fmov.s &0x3F800000,%fp2 6548 fadd.x %fp0,%fp2 # 1+X 6549 fmul.x %fp2,%fp1 # (1+X)(1-X) 6550 fmovm.x (%sp)+,&0x20 # {fp2} 6551 fsqrt.x %fp1 # SQRT([1-X][1+X]) 6552 fdiv.x %fp1,%fp0 # X/SQRT([1-X][1+X]) 6553 fmovm.x &0x01,-(%sp) # save X/SQRT(...) 6554 lea (%sp),%a0 # pass ptr to X/SQRT(...) 6555 bsr satan 6556 add.l &0xc,%sp # clear X/SQRT(...) from stack 6557 bra t_inx2 6558 6559 ASINBIG: 6560 fabs.x %fp0 # |X| 6561 fcmp.s %fp0,&0x3F800000 6562 fbgt t_operr # cause an operr exception 6563 6564 #--|X| = 1, ASIN(X) = +- PI/2. 6565 ASINONE: 6566 fmov.x PIBY2(%pc),%fp0 6567 mov.l (%a0),%d1 6568 and.l &0x80000000,%d1 # SIGN BIT OF X 6569 or.l &0x3F800000,%d1 # +-1 IN SGL FORMAT 6570 mov.l %d1,-(%sp) # push SIGN(X) IN SGL-FMT 6571 fmov.l %d0,%fpcr 6572 fmul.s (%sp)+,%fp0 6573 bra t_inx2 6574 6575 #--|X| < 2^(-40), ATAN(X) = X 6576 ASINTINY: 6577 fmov.l %d0,%fpcr # restore users rnd mode,prec 6578 mov.b &FMOV_OP,%d1 # last inst is MOVE 6579 fmov.x (%a0),%fp0 # last inst - possible exception 6580 bra t_catch 6581 6582 global sasind 6583 #--ASIN(X) = X FOR DENORMALIZED X 6584 sasind: 6585 bra t_extdnrm 6586 6587 ######################################################################### 6588 # sacos(): computes the inverse cosine of a normalized input # 6589 # sacosd(): computes the inverse cosine of a denormalized input # 6590 # # 6591 # INPUT *************************************************************** # 6592 # a0 = pointer to extended precision input # 6593 # d0 = round precision,mode # 6594 # # 6595 # OUTPUT ************************************************************** # 6596 # fp0 = arccos(X) # 6597 # # 6598 # ACCURACY and MONOTONICITY ******************************************* # 6599 # The returned result is within 3 ulps in 64 significant bit, # 6600 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 6601 # rounded to double precision. The result is provably monotonic # 6602 # in double precision. # 6603 # # 6604 # ALGORITHM *********************************************************** # 6605 # # 6606 # ACOS # 6607 # 1. If |X| >= 1, go to 3. # 6608 # # 6609 # 2. (|X| < 1) Calculate acos(X) by # 6610 # z := (1-X) / (1+X) # 6611 # acos(X) = 2 * atan( sqrt(z) ). # 6612 # Exit. # 6613 # # 6614 # 3. If |X| > 1, go to 5. # 6615 # # 6616 # 4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit. # 6617 # # 6618 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. # 6619 # Exit. # 6620 # # 6621 ######################################################################### 6622 6623 global sacos 6624 sacos: 6625 fmov.x (%a0),%fp0 # LOAD INPUT 6626 6627 mov.l (%a0),%d1 # pack exp w/ upper 16 fraction 6628 mov.w 4(%a0),%d1 6629 and.l &0x7FFFFFFF,%d1 6630 cmp.l %d1,&0x3FFF8000 6631 bge.b ACOSBIG 6632 6633 #--THIS IS THE USUAL CASE, |X| < 1 6634 #--ACOS(X) = 2 * ATAN( SQRT( (1-X)/(1+X) ) ) 6635 6636 ACOSMAIN: 6637 fmov.s &0x3F800000,%fp1 6638 fadd.x %fp0,%fp1 # 1+X 6639 fneg.x %fp0 # -X 6640 fadd.s &0x3F800000,%fp0 # 1-X 6641 fdiv.x %fp1,%fp0 # (1-X)/(1+X) 6642 fsqrt.x %fp0 # SQRT((1-X)/(1+X)) 6643 mov.l %d0,-(%sp) # save original users fpcr 6644 clr.l %d0 6645 fmovm.x &0x01,-(%sp) # save SQRT(...) to stack 6646 lea (%sp),%a0 # pass ptr to sqrt 6647 bsr satan # ATAN(SQRT([1-X]/[1+X])) 6648 add.l &0xc,%sp # clear SQRT(...) from stack 6649 6650 fmov.l (%sp)+,%fpcr # restore users round prec,mode 6651 fadd.x %fp0,%fp0 # 2 * ATAN( STUFF ) 6652 bra t_pinx2 6653 6654 ACOSBIG: 6655 fabs.x %fp0 6656 fcmp.s %fp0,&0x3F800000 6657 fbgt t_operr # cause an operr exception 6658 6659 #--|X| = 1, ACOS(X) = 0 OR PI 6660 tst.b (%a0) # is X positive or negative? 6661 bpl.b ACOSP1 6662 6663 #--X = -1 6664 #Returns PI and inexact exception 6665 ACOSM1: 6666 fmov.x PI(%pc),%fp0 # load PI 6667 fmov.l %d0,%fpcr # load round mode,prec 6668 fadd.s &0x00800000,%fp0 # add a small value 6669 bra t_pinx2 6670 6671 ACOSP1: 6672 bra ld_pzero # answer is positive zero 6673 6674 global sacosd 6675 #--ACOS(X) = PI/2 FOR DENORMALIZED X 6676 sacosd: 6677 fmov.l %d0,%fpcr # load user's rnd mode/prec 6678 fmov.x PIBY2(%pc),%fp0 6679 bra t_pinx2 6680 6681 ######################################################################### 6682 # setox(): computes the exponential for a normalized input # 6683 # setoxd(): computes the exponential for a denormalized input # 6684 # setoxm1(): computes the exponential minus 1 for a normalized input # 6685 # setoxm1d(): computes the exponential minus 1 for a denormalized input # 6686 # # 6687 # INPUT *************************************************************** # 6688 # a0 = pointer to extended precision input # 6689 # d0 = round precision,mode # 6690 # # 6691 # OUTPUT ************************************************************** # 6692 # fp0 = exp(X) or exp(X)-1 # 6693 # # 6694 # ACCURACY and MONOTONICITY ******************************************* # 6695 # The returned result is within 0.85 ulps in 64 significant bit, # 6696 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 6697 # rounded to double precision. The result is provably monotonic # 6698 # in double precision. # 6699 # # 6700 # ALGORITHM and IMPLEMENTATION **************************************** # 6701 # # 6702 # setoxd # 6703 # ------ # 6704 # Step 1. Set ans := 1.0 # 6705 # # 6706 # Step 2. Return ans := ans + sign(X)*2^(-126). Exit. # 6707 # Notes: This will always generate one exception -- inexact. # 6708 # # 6709 # # 6710 # setox # 6711 # ----- # 6712 # # 6713 # Step 1. Filter out extreme cases of input argument. # 6714 # 1.1 If |X| >= 2^(-65), go to Step 1.3. # 6715 # 1.2 Go to Step 7. # 6716 # 1.3 If |X| < 16380 log(2), go to Step 2. # 6717 # 1.4 Go to Step 8. # 6718 # Notes: The usual case should take the branches 1.1 -> 1.3 -> 2.# 6719 # To avoid the use of floating-point comparisons, a # 6720 # compact representation of |X| is used. This format is a # 6721 # 32-bit integer, the upper (more significant) 16 bits # 6722 # are the sign and biased exponent field of |X|; the # 6723 # lower 16 bits are the 16 most significant fraction # 6724 # (including the explicit bit) bits of |X|. Consequently, # 6725 # the comparisons in Steps 1.1 and 1.3 can be performed # 6726 # by integer comparison. Note also that the constant # 6727 # 16380 log(2) used in Step 1.3 is also in the compact # 6728 # form. Thus taking the branch to Step 2 guarantees # 6729 # |X| < 16380 log(2). There is no harm to have a small # 6730 # number of cases where |X| is less than, but close to, # 6731 # 16380 log(2) and the branch to Step 9 is taken. # 6732 # # 6733 # Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). # 6734 # 2.1 Set AdjFlag := 0 (indicates the branch 1.3 -> 2 # 6735 # was taken) # 6736 # 2.2 N := round-to-nearest-integer( X * 64/log2 ). # 6737 # 2.3 Calculate J = N mod 64; so J = 0,1,2,..., # 6738 # or 63. # 6739 # 2.4 Calculate M = (N - J)/64; so N = 64M + J. # 6740 # 2.5 Calculate the address of the stored value of # 6741 # 2^(J/64). # 6742 # 2.6 Create the value Scale = 2^M. # 6743 # Notes: The calculation in 2.2 is really performed by # 6744 # Z := X * constant # 6745 # N := round-to-nearest-integer(Z) # 6746 # where # 6747 # constant := single-precision( 64/log 2 ). # 6748 # # 6749 # Using a single-precision constant avoids memory # 6750 # access. Another effect of using a single-precision # 6751 # "constant" is that the calculated value Z is # 6752 # # 6753 # Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24). # 6754 # # 6755 # This error has to be considered later in Steps 3 and 4. # 6756 # # 6757 # Step 3. Calculate X - N*log2/64. # 6758 # 3.1 R := X + N*L1, # 6759 # where L1 := single-precision(-log2/64). # 6760 # 3.2 R := R + N*L2, # 6761 # L2 := extended-precision(-log2/64 - L1).# 6762 # Notes: a) The way L1 and L2 are chosen ensures L1+L2 # 6763 # approximate the value -log2/64 to 88 bits of accuracy. # 6764 # b) N*L1 is exact because N is no longer than 22 bits # 6765 # and L1 is no longer than 24 bits. # 6766 # c) The calculation X+N*L1 is also exact due to # 6767 # cancellation. Thus, R is practically X+N(L1+L2) to full # 6768 # 64 bits. # 6769 # d) It is important to estimate how large can |R| be # 6770 # after Step 3.2. # 6771 # # 6772 # N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24) # 6773 # X*64/log2 (1+eps) = N + f, |f| <= 0.5 # 6774 # X*64/log2 - N = f - eps*X 64/log2 # 6775 # X - N*log2/64 = f*log2/64 - eps*X # 6776 # # 6777 # # 6778 # Now |X| <= 16446 log2, thus # 6779 # # 6780 # |X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64 # 6781 # <= 0.57 log2/64. # 6782 # This bound will be used in Step 4. # 6783 # # 6784 # Step 4. Approximate exp(R)-1 by a polynomial # 6785 # p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5)))) # 6786 # Notes: a) In order to reduce memory access, the coefficients # 6787 # are made as "short" as possible: A1 (which is 1/2), A4 # 6788 # and A5 are single precision; A2 and A3 are double # 6789 # precision. # 6790 # b) Even with the restrictions above, # 6791 # |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062. # 6792 # Note that 0.0062 is slightly bigger than 0.57 log2/64. # 6793 # c) To fully utilize the pipeline, p is separated into # 6794 # two independent pieces of roughly equal complexities # 6795 # p = [ R + R*S*(A2 + S*A4) ] + # 6796 # [ S*(A1 + S*(A3 + S*A5)) ] # 6797 # where S = R*R. # 6798 # # 6799 # Step 5. Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by # 6800 # ans := T + ( T*p + t) # 6801 # where T and t are the stored values for 2^(J/64). # 6802 # Notes: 2^(J/64) is stored as T and t where T+t approximates # 6803 # 2^(J/64) to roughly 85 bits; T is in extended precision # 6804 # and t is in single precision. Note also that T is # 6805 # rounded to 62 bits so that the last two bits of T are # 6806 # zero. The reason for such a special form is that T-1, # 6807 # T-2, and T-8 will all be exact --- a property that will # 6808 # give much more accurate computation of the function # 6809 # EXPM1. # 6810 # # 6811 # Step 6. Reconstruction of exp(X) # 6812 # exp(X) = 2^M * 2^(J/64) * exp(R). # 6813 # 6.1 If AdjFlag = 0, go to 6.3 # 6814 # 6.2 ans := ans * AdjScale # 6815 # 6.3 Restore the user FPCR # 6816 # 6.4 Return ans := ans * Scale. Exit. # 6817 # Notes: If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R, # 6818 # |M| <= 16380, and Scale = 2^M. Moreover, exp(X) will # 6819 # neither overflow nor underflow. If AdjFlag = 1, that # 6820 # means that # 6821 # X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380. # 6822 # Hence, exp(X) may overflow or underflow or neither. # 6823 # When that is the case, AdjScale = 2^(M1) where M1 is # 6824 # approximately M. Thus 6.2 will never cause # 6825 # over/underflow. Possible exception in 6.4 is overflow # 6826 # or underflow. The inexact exception is not generated in # 6827 # 6.4. Although one can argue that the inexact flag # 6828 # should always be raised, to simulate that exception # 6829 # cost to much than the flag is worth in practical uses. # 6830 # # 6831 # Step 7. Return 1 + X. # 6832 # 7.1 ans := X # 6833 # 7.2 Restore user FPCR. # 6834 # 7.3 Return ans := 1 + ans. Exit # 6835 # Notes: For non-zero X, the inexact exception will always be # 6836 # raised by 7.3. That is the only exception raised by 7.3.# 6837 # Note also that we use the FMOVEM instruction to move X # 6838 # in Step 7.1 to avoid unnecessary trapping. (Although # 6839 # the FMOVEM may not seem relevant since X is normalized, # 6840 # the precaution will be useful in the library version of # 6841 # this code where the separate entry for denormalized # 6842 # inputs will be done away with.) # 6843 # # 6844 # Step 8. Handle exp(X) where |X| >= 16380log2. # 6845 # 8.1 If |X| > 16480 log2, go to Step 9. # 6846 # (mimic 2.2 - 2.6) # 6847 # 8.2 N := round-to-integer( X * 64/log2 ) # 6848 # 8.3 Calculate J = N mod 64, J = 0,1,...,63 # 6849 # 8.4 K := (N-J)/64, M1 := truncate(K/2), M = K-M1, # 6850 # AdjFlag := 1. # 6851 # 8.5 Calculate the address of the stored value # 6852 # 2^(J/64). # 6853 # 8.6 Create the values Scale = 2^M, AdjScale = 2^M1. # 6854 # 8.7 Go to Step 3. # 6855 # Notes: Refer to notes for 2.2 - 2.6. # 6856 # # 6857 # Step 9. Handle exp(X), |X| > 16480 log2. # 6858 # 9.1 If X < 0, go to 9.3 # 6859 # 9.2 ans := Huge, go to 9.4 # 6860 # 9.3 ans := Tiny. # 6861 # 9.4 Restore user FPCR. # 6862 # 9.5 Return ans := ans * ans. Exit. # 6863 # Notes: Exp(X) will surely overflow or underflow, depending on # 6864 # X's sign. "Huge" and "Tiny" are respectively large/tiny # 6865 # extended-precision numbers whose square over/underflow # 6866 # with an inexact result. Thus, 9.5 always raises the # 6867 # inexact together with either overflow or underflow. # 6868 # # 6869 # setoxm1d # 6870 # -------- # 6871 # # 6872 # Step 1. Set ans := 0 # 6873 # # 6874 # Step 2. Return ans := X + ans. Exit. # 6875 # Notes: This will return X with the appropriate rounding # 6876 # precision prescribed by the user FPCR. # 6877 # # 6878 # setoxm1 # 6879 # ------- # 6880 # # 6881 # Step 1. Check |X| # 6882 # 1.1 If |X| >= 1/4, go to Step 1.3. # 6883 # 1.2 Go to Step 7. # 6884 # 1.3 If |X| < 70 log(2), go to Step 2. # 6885 # 1.4 Go to Step 10. # 6886 # Notes: The usual case should take the branches 1.1 -> 1.3 -> 2.# 6887 # However, it is conceivable |X| can be small very often # 6888 # because EXPM1 is intended to evaluate exp(X)-1 # 6889 # accurately when |X| is small. For further details on # 6890 # the comparisons, see the notes on Step 1 of setox. # 6891 # # 6892 # Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ). # 6893 # 2.1 N := round-to-nearest-integer( X * 64/log2 ). # 6894 # 2.2 Calculate J = N mod 64; so J = 0,1,2,..., # 6895 # or 63. # 6896 # 2.3 Calculate M = (N - J)/64; so N = 64M + J. # 6897 # 2.4 Calculate the address of the stored value of # 6898 # 2^(J/64). # 6899 # 2.5 Create the values Sc = 2^M and # 6900 # OnebySc := -2^(-M). # 6901 # Notes: See the notes on Step 2 of setox. # 6902 # # 6903 # Step 3. Calculate X - N*log2/64. # 6904 # 3.1 R := X + N*L1, # 6905 # where L1 := single-precision(-log2/64). # 6906 # 3.2 R := R + N*L2, # 6907 # L2 := extended-precision(-log2/64 - L1).# 6908 # Notes: Applying the analysis of Step 3 of setox in this case # 6909 # shows that |R| <= 0.0055 (note that |X| <= 70 log2 in # 6910 # this case). # 6911 # # 6912 # Step 4. Approximate exp(R)-1 by a polynomial # 6913 # p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6))))) # 6914 # Notes: a) In order to reduce memory access, the coefficients # 6915 # are made as "short" as possible: A1 (which is 1/2), A5 # 6916 # and A6 are single precision; A2, A3 and A4 are double # 6917 # precision. # 6918 # b) Even with the restriction above, # 6919 # |p - (exp(R)-1)| < |R| * 2^(-72.7) # 6920 # for all |R| <= 0.0055. # 6921 # c) To fully utilize the pipeline, p is separated into # 6922 # two independent pieces of roughly equal complexity # 6923 # p = [ R*S*(A2 + S*(A4 + S*A6)) ] + # 6924 # [ R + S*(A1 + S*(A3 + S*A5)) ] # 6925 # where S = R*R. # 6926 # # 6927 # Step 5. Compute 2^(J/64)*p by # 6928 # p := T*p # 6929 # where T and t are the stored values for 2^(J/64). # 6930 # Notes: 2^(J/64) is stored as T and t where T+t approximates # 6931 # 2^(J/64) to roughly 85 bits; T is in extended precision # 6932 # and t is in single precision. Note also that T is # 6933 # rounded to 62 bits so that the last two bits of T are # 6934 # zero. The reason for such a special form is that T-1, # 6935 # T-2, and T-8 will all be exact --- a property that will # 6936 # be exploited in Step 6 below. The total relative error # 6937 # in p is no bigger than 2^(-67.7) compared to the final # 6938 # result. # 6939 # # 6940 # Step 6. Reconstruction of exp(X)-1 # 6941 # exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ). # 6942 # 6.1 If M <= 63, go to Step 6.3. # 6943 # 6.2 ans := T + (p + (t + OnebySc)). Go to 6.6 # 6944 # 6.3 If M >= -3, go to 6.5. # 6945 # 6.4 ans := (T + (p + t)) + OnebySc. Go to 6.6 # 6946 # 6.5 ans := (T + OnebySc) + (p + t). # 6947 # 6.6 Restore user FPCR. # 6948 # 6.7 Return ans := Sc * ans. Exit. # 6949 # Notes: The various arrangements of the expressions give # 6950 # accurate evaluations. # 6951 # # 6952 # Step 7. exp(X)-1 for |X| < 1/4. # 6953 # 7.1 If |X| >= 2^(-65), go to Step 9. # 6954 # 7.2 Go to Step 8. # 6955 # # 6956 # Step 8. Calculate exp(X)-1, |X| < 2^(-65). # 6957 # 8.1 If |X| < 2^(-16312), goto 8.3 # 6958 # 8.2 Restore FPCR; return ans := X - 2^(-16382). # 6959 # Exit. # 6960 # 8.3 X := X * 2^(140). # 6961 # 8.4 Restore FPCR; ans := ans - 2^(-16382). # 6962 # Return ans := ans*2^(140). Exit # 6963 # Notes: The idea is to return "X - tiny" under the user # 6964 # precision and rounding modes. To avoid unnecessary # 6965 # inefficiency, we stay away from denormalized numbers # 6966 # the best we can. For |X| >= 2^(-16312), the # 6967 # straightforward 8.2 generates the inexact exception as # 6968 # the case warrants. # 6969 # # 6970 # Step 9. Calculate exp(X)-1, |X| < 1/4, by a polynomial # 6971 # p = X + X*X*(B1 + X*(B2 + ... + X*B12)) # 6972 # Notes: a) In order to reduce memory access, the coefficients # 6973 # are made as "short" as possible: B1 (which is 1/2), B9 # 6974 # to B12 are single precision; B3 to B8 are double # 6975 # precision; and B2 is double extended. # 6976 # b) Even with the restriction above, # 6977 # |p - (exp(X)-1)| < |X| 2^(-70.6) # 6978 # for all |X| <= 0.251. # 6979 # Note that 0.251 is slightly bigger than 1/4. # 6980 # c) To fully preserve accuracy, the polynomial is # 6981 # computed as # 6982 # X + ( S*B1 + Q ) where S = X*X and # 6983 # Q = X*S*(B2 + X*(B3 + ... + X*B12)) # 6984 # d) To fully utilize the pipeline, Q is separated into # 6985 # two independent pieces of roughly equal complexity # 6986 # Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] + # 6987 # [ S*S*(B3 + S*(B5 + ... + S*B11)) ] # 6988 # # 6989 # Step 10. Calculate exp(X)-1 for |X| >= 70 log 2. # 6990 # 10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all # 6991 # practical purposes. Therefore, go to Step 1 of setox. # 6992 # 10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical # 6993 # purposes. # 6994 # ans := -1 # 6995 # Restore user FPCR # 6996 # Return ans := ans + 2^(-126). Exit. # 6997 # Notes: 10.2 will always create an inexact and return -1 + tiny # 6998 # in the user rounding precision and mode. # 6999 # # 7000 ######################################################################### 7001 7002 L2: long 0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000 7003 7004 EEXPA3: long 0x3FA55555,0x55554CC1 7005 EEXPA2: long 0x3FC55555,0x55554A54 7006 7007 EM1A4: long 0x3F811111,0x11174385 7008 EM1A3: long 0x3FA55555,0x55554F5A 7009 7010 EM1A2: long 0x3FC55555,0x55555555,0x00000000,0x00000000 7011 7012 EM1B8: long 0x3EC71DE3,0xA5774682 7013 EM1B7: long 0x3EFA01A0,0x19D7CB68 7014 7015 EM1B6: long 0x3F2A01A0,0x1A019DF3 7016 EM1B5: long 0x3F56C16C,0x16C170E2 7017 7018 EM1B4: long 0x3F811111,0x11111111 7019 EM1B3: long 0x3FA55555,0x55555555 7020 7021 EM1B2: long 0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB 7022 long 0x00000000 7023 7024 TWO140: long 0x48B00000,0x00000000 7025 TWON140: 7026 long 0x37300000,0x00000000 7027 7028 EEXPTBL: 7029 long 0x3FFF0000,0x80000000,0x00000000,0x00000000 7030 long 0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9B 7031 long 0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9 7032 long 0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369 7033 long 0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95C 7034 long 0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9F 7035 long 0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729 7036 long 0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AF 7037 long 0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCF 7038 long 0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DA 7039 long 0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051 7040 long 0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029 7041 long 0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494 7042 long 0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0 7043 long 0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457D 7044 long 0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537 7045 long 0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DD 7046 long 0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087 7047 long 0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818 7048 long 0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494D 7049 long 0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890 7050 long 0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691C 7051 long 0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05 7052 long 0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126 7053 long 0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140 7054 long 0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DA 7055 long 0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4A 7056 long 0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDC 7057 long 0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAC 7058 long 0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610 7059 long 0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90 7060 long 0x3FFF0000,0xB311C412,0xA9112488,0x201F678A 7061 long 0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13 7062 long 0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30 7063 long 0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CC 7064 long 0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6 7065 long 0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70 7066 long 0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518 7067 long 0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41 7068 long 0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137B 7069 long 0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568 7070 long 0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2E 7071 long 0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03 7072 long 0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907D 7073 long 0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4 7074 long 0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45C 7075 long 0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9 7076 long 0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21 7077 long 0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2F 7078 long 0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439F 7079 long 0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207 7080 long 0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175 7081 long 0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4B 7082 long 0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5 7083 long 0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47A 7084 long 0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22 7085 long 0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945 7086 long 0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5B 7087 long 0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3 7088 long 0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05 7089 long 0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19 7090 long 0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5 7091 long 0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22 7092 long 0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3A 7093 7094 set ADJFLAG,L_SCR2 7095 set SCALE,FP_SCR0 7096 set ADJSCALE,FP_SCR1 7097 set SC,FP_SCR0 7098 set ONEBYSC,FP_SCR1 7099 7100 global setox 7101 setox: 7102 #--entry point for EXP(X), here X is finite, non-zero, and not NaN's 7103 7104 #--Step 1. 7105 mov.l (%a0),%d1 # load part of input X 7106 and.l &0x7FFF0000,%d1 # biased expo. of X 7107 cmp.l %d1,&0x3FBE0000 # 2^(-65) 7108 bge.b EXPC1 # normal case 7109 bra EXPSM 7110 7111 EXPC1: 7112 #--The case |X| >= 2^(-65) 7113 mov.w 4(%a0),%d1 # expo. and partial sig. of |X| 7114 cmp.l %d1,&0x400CB167 # 16380 log2 trunc. 16 bits 7115 blt.b EXPMAIN # normal case 7116 bra EEXPBIG 7117 7118 EXPMAIN: 7119 #--Step 2. 7120 #--This is the normal branch: 2^(-65) <= |X| < 16380 log2. 7121 fmov.x (%a0),%fp0 # load input from (a0) 7122 7123 fmov.x %fp0,%fp1 7124 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7125 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3} 7126 mov.l &0,ADJFLAG(%a6) 7127 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7128 lea EEXPTBL(%pc),%a1 7129 fmov.l %d1,%fp0 # convert to floating-format 7130 7131 mov.l %d1,L_SCR1(%a6) # save N temporarily 7132 and.l &0x3F,%d1 # D0 is J = N mod 64 7133 lsl.l &4,%d1 7134 add.l %d1,%a1 # address of 2^(J/64) 7135 mov.l L_SCR1(%a6),%d1 7136 asr.l &6,%d1 # D0 is M 7137 add.w &0x3FFF,%d1 # biased expo. of 2^(M) 7138 mov.w L2(%pc),L_SCR1(%a6) # prefetch L2, no need in CB 7139 7140 EXPCONT1: 7141 #--Step 3. 7142 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 7143 #--a0 points to 2^(J/64), D0 is biased expo. of 2^(M) 7144 fmov.x %fp0,%fp2 7145 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64) 7146 fmul.x L2(%pc),%fp2 # N * L2, L1+L2 = -log2/64 7147 fadd.x %fp1,%fp0 # X + N*L1 7148 fadd.x %fp2,%fp0 # fp0 is R, reduced arg. 7149 7150 #--Step 4. 7151 #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL 7152 #-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5)))) 7153 #--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R 7154 #--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))] 7155 7156 fmov.x %fp0,%fp1 7157 fmul.x %fp1,%fp1 # fp1 IS S = R*R 7158 7159 fmov.s &0x3AB60B70,%fp2 # fp2 IS A5 7160 7161 fmul.x %fp1,%fp2 # fp2 IS S*A5 7162 fmov.x %fp1,%fp3 7163 fmul.s &0x3C088895,%fp3 # fp3 IS S*A4 7164 7165 fadd.d EEXPA3(%pc),%fp2 # fp2 IS A3+S*A5 7166 fadd.d EEXPA2(%pc),%fp3 # fp3 IS A2+S*A4 7167 7168 fmul.x %fp1,%fp2 # fp2 IS S*(A3+S*A5) 7169 mov.w %d1,SCALE(%a6) # SCALE is 2^(M) in extended 7170 mov.l &0x80000000,SCALE+4(%a6) 7171 clr.l SCALE+8(%a6) 7172 7173 fmul.x %fp1,%fp3 # fp3 IS S*(A2+S*A4) 7174 7175 fadd.s &0x3F000000,%fp2 # fp2 IS A1+S*(A3+S*A5) 7176 fmul.x %fp0,%fp3 # fp3 IS R*S*(A2+S*A4) 7177 7178 fmul.x %fp1,%fp2 # fp2 IS S*(A1+S*(A3+S*A5)) 7179 fadd.x %fp3,%fp0 # fp0 IS R+R*S*(A2+S*A4), 7180 7181 fmov.x (%a1)+,%fp1 # fp1 is lead. pt. of 2^(J/64) 7182 fadd.x %fp2,%fp0 # fp0 is EXP(R) - 1 7183 7184 #--Step 5 7185 #--final reconstruction process 7186 #--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) ) 7187 7188 fmul.x %fp1,%fp0 # 2^(J/64)*(Exp(R)-1) 7189 fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3} 7190 fadd.s (%a1),%fp0 # accurate 2^(J/64) 7191 7192 fadd.x %fp1,%fp0 # 2^(J/64) + 2^(J/64)*... 7193 mov.l ADJFLAG(%a6),%d1 7194 7195 #--Step 6 7196 tst.l %d1 7197 beq.b NORMAL 7198 ADJUST: 7199 fmul.x ADJSCALE(%a6),%fp0 7200 NORMAL: 7201 fmov.l %d0,%fpcr # restore user FPCR 7202 mov.b &FMUL_OP,%d1 # last inst is MUL 7203 fmul.x SCALE(%a6),%fp0 # multiply 2^(M) 7204 bra t_catch 7205 7206 EXPSM: 7207 #--Step 7 7208 fmovm.x (%a0),&0x80 # load X 7209 fmov.l %d0,%fpcr 7210 fadd.s &0x3F800000,%fp0 # 1+X in user mode 7211 bra t_pinx2 7212 7213 EEXPBIG: 7214 #--Step 8 7215 cmp.l %d1,&0x400CB27C # 16480 log2 7216 bgt.b EXP2BIG 7217 #--Steps 8.2 -- 8.6 7218 fmov.x (%a0),%fp0 # load input from (a0) 7219 7220 fmov.x %fp0,%fp1 7221 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7222 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3} 7223 mov.l &1,ADJFLAG(%a6) 7224 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7225 lea EEXPTBL(%pc),%a1 7226 fmov.l %d1,%fp0 # convert to floating-format 7227 mov.l %d1,L_SCR1(%a6) # save N temporarily 7228 and.l &0x3F,%d1 # D0 is J = N mod 64 7229 lsl.l &4,%d1 7230 add.l %d1,%a1 # address of 2^(J/64) 7231 mov.l L_SCR1(%a6),%d1 7232 asr.l &6,%d1 # D0 is K 7233 mov.l %d1,L_SCR1(%a6) # save K temporarily 7234 asr.l &1,%d1 # D0 is M1 7235 sub.l %d1,L_SCR1(%a6) # a1 is M 7236 add.w &0x3FFF,%d1 # biased expo. of 2^(M1) 7237 mov.w %d1,ADJSCALE(%a6) # ADJSCALE := 2^(M1) 7238 mov.l &0x80000000,ADJSCALE+4(%a6) 7239 clr.l ADJSCALE+8(%a6) 7240 mov.l L_SCR1(%a6),%d1 # D0 is M 7241 add.w &0x3FFF,%d1 # biased expo. of 2^(M) 7242 bra.w EXPCONT1 # go back to Step 3 7243 7244 EXP2BIG: 7245 #--Step 9 7246 tst.b (%a0) # is X positive or negative? 7247 bmi t_unfl2 7248 bra t_ovfl2 7249 7250 global setoxd 7251 setoxd: 7252 #--entry point for EXP(X), X is denormalized 7253 mov.l (%a0),-(%sp) 7254 andi.l &0x80000000,(%sp) 7255 ori.l &0x00800000,(%sp) # sign(X)*2^(-126) 7256 7257 fmov.s &0x3F800000,%fp0 7258 7259 fmov.l %d0,%fpcr 7260 fadd.s (%sp)+,%fp0 7261 bra t_pinx2 7262 7263 global setoxm1 7264 setoxm1: 7265 #--entry point for EXPM1(X), here X is finite, non-zero, non-NaN 7266 7267 #--Step 1. 7268 #--Step 1.1 7269 mov.l (%a0),%d1 # load part of input X 7270 and.l &0x7FFF0000,%d1 # biased expo. of X 7271 cmp.l %d1,&0x3FFD0000 # 1/4 7272 bge.b EM1CON1 # |X| >= 1/4 7273 bra EM1SM 7274 7275 EM1CON1: 7276 #--Step 1.3 7277 #--The case |X| >= 1/4 7278 mov.w 4(%a0),%d1 # expo. and partial sig. of |X| 7279 cmp.l %d1,&0x4004C215 # 70log2 rounded up to 16 bits 7280 ble.b EM1MAIN # 1/4 <= |X| <= 70log2 7281 bra EM1BIG 7282 7283 EM1MAIN: 7284 #--Step 2. 7285 #--This is the case: 1/4 <= |X| <= 70 log2. 7286 fmov.x (%a0),%fp0 # load input from (a0) 7287 7288 fmov.x %fp0,%fp1 7289 fmul.s &0x42B8AA3B,%fp0 # 64/log2 * X 7290 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3} 7291 fmov.l %fp0,%d1 # N = int( X * 64/log2 ) 7292 lea EEXPTBL(%pc),%a1 7293 fmov.l %d1,%fp0 # convert to floating-format 7294 7295 mov.l %d1,L_SCR1(%a6) # save N temporarily 7296 and.l &0x3F,%d1 # D0 is J = N mod 64 7297 lsl.l &4,%d1 7298 add.l %d1,%a1 # address of 2^(J/64) 7299 mov.l L_SCR1(%a6),%d1 7300 asr.l &6,%d1 # D0 is M 7301 mov.l %d1,L_SCR1(%a6) # save a copy of M 7302 7303 #--Step 3. 7304 #--fp1,fp2 saved on the stack. fp0 is N, fp1 is X, 7305 #--a0 points to 2^(J/64), D0 and a1 both contain M 7306 fmov.x %fp0,%fp2 7307 fmul.s &0xBC317218,%fp0 # N * L1, L1 = lead(-log2/64) 7308 fmul.x L2(%pc),%fp2 # N * L2, L1+L2 = -log2/64 7309 fadd.x %fp1,%fp0 # X + N*L1 7310 fadd.x %fp2,%fp0 # fp0 is R, reduced arg. 7311 add.w &0x3FFF,%d1 # D0 is biased expo. of 2^M 7312 7313 #--Step 4. 7314 #--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL 7315 #-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6))))) 7316 #--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R 7317 #--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))] 7318 7319 fmov.x %fp0,%fp1 7320 fmul.x %fp1,%fp1 # fp1 IS S = R*R 7321 7322 fmov.s &0x3950097B,%fp2 # fp2 IS a6 7323 7324 fmul.x %fp1,%fp2 # fp2 IS S*A6 7325 fmov.x %fp1,%fp3 7326 fmul.s &0x3AB60B6A,%fp3 # fp3 IS S*A5 7327 7328 fadd.d EM1A4(%pc),%fp2 # fp2 IS A4+S*A6 7329 fadd.d EM1A3(%pc),%fp3 # fp3 IS A3+S*A5 7330 mov.w %d1,SC(%a6) # SC is 2^(M) in extended 7331 mov.l &0x80000000,SC+4(%a6) 7332 clr.l SC+8(%a6) 7333 7334 fmul.x %fp1,%fp2 # fp2 IS S*(A4+S*A6) 7335 mov.l L_SCR1(%a6),%d1 # D0 is M 7336 neg.w %d1 # D0 is -M 7337 fmul.x %fp1,%fp3 # fp3 IS S*(A3+S*A5) 7338 add.w &0x3FFF,%d1 # biased expo. of 2^(-M) 7339 fadd.d EM1A2(%pc),%fp2 # fp2 IS A2+S*(A4+S*A6) 7340 fadd.s &0x3F000000,%fp3 # fp3 IS A1+S*(A3+S*A5) 7341 7342 fmul.x %fp1,%fp2 # fp2 IS S*(A2+S*(A4+S*A6)) 7343 or.w &0x8000,%d1 # signed/expo. of -2^(-M) 7344 mov.w %d1,ONEBYSC(%a6) # OnebySc is -2^(-M) 7345 mov.l &0x80000000,ONEBYSC+4(%a6) 7346 clr.l ONEBYSC+8(%a6) 7347 fmul.x %fp3,%fp1 # fp1 IS S*(A1+S*(A3+S*A5)) 7348 7349 fmul.x %fp0,%fp2 # fp2 IS R*S*(A2+S*(A4+S*A6)) 7350 fadd.x %fp1,%fp0 # fp0 IS R+S*(A1+S*(A3+S*A5)) 7351 7352 fadd.x %fp2,%fp0 # fp0 IS EXP(R)-1 7353 7354 fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3} 7355 7356 #--Step 5 7357 #--Compute 2^(J/64)*p 7358 7359 fmul.x (%a1),%fp0 # 2^(J/64)*(Exp(R)-1) 7360 7361 #--Step 6 7362 #--Step 6.1 7363 mov.l L_SCR1(%a6),%d1 # retrieve M 7364 cmp.l %d1,&63 7365 ble.b MLE63 7366 #--Step 6.2 M >= 64 7367 fmov.s 12(%a1),%fp1 # fp1 is t 7368 fadd.x ONEBYSC(%a6),%fp1 # fp1 is t+OnebySc 7369 fadd.x %fp1,%fp0 # p+(t+OnebySc), fp1 released 7370 fadd.x (%a1),%fp0 # T+(p+(t+OnebySc)) 7371 bra EM1SCALE 7372 MLE63: 7373 #--Step 6.3 M <= 63 7374 cmp.l %d1,&-3 7375 bge.b MGEN3 7376 MLTN3: 7377 #--Step 6.4 M <= -4 7378 fadd.s 12(%a1),%fp0 # p+t 7379 fadd.x (%a1),%fp0 # T+(p+t) 7380 fadd.x ONEBYSC(%a6),%fp0 # OnebySc + (T+(p+t)) 7381 bra EM1SCALE 7382 MGEN3: 7383 #--Step 6.5 -3 <= M <= 63 7384 fmov.x (%a1)+,%fp1 # fp1 is T 7385 fadd.s (%a1),%fp0 # fp0 is p+t 7386 fadd.x ONEBYSC(%a6),%fp1 # fp1 is T+OnebySc 7387 fadd.x %fp1,%fp0 # (T+OnebySc)+(p+t) 7388 7389 EM1SCALE: 7390 #--Step 6.6 7391 fmov.l %d0,%fpcr 7392 fmul.x SC(%a6),%fp0 7393 bra t_inx2 7394 7395 EM1SM: 7396 #--Step 7 |X| < 1/4. 7397 cmp.l %d1,&0x3FBE0000 # 2^(-65) 7398 bge.b EM1POLY 7399 7400 EM1TINY: 7401 #--Step 8 |X| < 2^(-65) 7402 cmp.l %d1,&0x00330000 # 2^(-16312) 7403 blt.b EM12TINY 7404 #--Step 8.2 7405 mov.l &0x80010000,SC(%a6) # SC is -2^(-16382) 7406 mov.l &0x80000000,SC+4(%a6) 7407 clr.l SC+8(%a6) 7408 fmov.x (%a0),%fp0 7409 fmov.l %d0,%fpcr 7410 mov.b &FADD_OP,%d1 # last inst is ADD 7411 fadd.x SC(%a6),%fp0 7412 bra t_catch 7413 7414 EM12TINY: 7415 #--Step 8.3 7416 fmov.x (%a0),%fp0 7417 fmul.d TWO140(%pc),%fp0 7418 mov.l &0x80010000,SC(%a6) 7419 mov.l &0x80000000,SC+4(%a6) 7420 clr.l SC+8(%a6) 7421 fadd.x SC(%a6),%fp0 7422 fmov.l %d0,%fpcr 7423 mov.b &FMUL_OP,%d1 # last inst is MUL 7424 fmul.d TWON140(%pc),%fp0 7425 bra t_catch 7426 7427 EM1POLY: 7428 #--Step 9 exp(X)-1 by a simple polynomial 7429 fmov.x (%a0),%fp0 # fp0 is X 7430 fmul.x %fp0,%fp0 # fp0 is S := X*X 7431 fmovm.x &0xc,-(%sp) # save fp2 {%fp2/%fp3} 7432 fmov.s &0x2F30CAA8,%fp1 # fp1 is B12 7433 fmul.x %fp0,%fp1 # fp1 is S*B12 7434 fmov.s &0x310F8290,%fp2 # fp2 is B11 7435 fadd.s &0x32D73220,%fp1 # fp1 is B10+S*B12 7436 7437 fmul.x %fp0,%fp2 # fp2 is S*B11 7438 fmul.x %fp0,%fp1 # fp1 is S*(B10 + ... 7439 7440 fadd.s &0x3493F281,%fp2 # fp2 is B9+S*... 7441 fadd.d EM1B8(%pc),%fp1 # fp1 is B8+S*... 7442 7443 fmul.x %fp0,%fp2 # fp2 is S*(B9+... 7444 fmul.x %fp0,%fp1 # fp1 is S*(B8+... 7445 7446 fadd.d EM1B7(%pc),%fp2 # fp2 is B7+S*... 7447 fadd.d EM1B6(%pc),%fp1 # fp1 is B6+S*... 7448 7449 fmul.x %fp0,%fp2 # fp2 is S*(B7+... 7450 fmul.x %fp0,%fp1 # fp1 is S*(B6+... 7451 7452 fadd.d EM1B5(%pc),%fp2 # fp2 is B5+S*... 7453 fadd.d EM1B4(%pc),%fp1 # fp1 is B4+S*... 7454 7455 fmul.x %fp0,%fp2 # fp2 is S*(B5+... 7456 fmul.x %fp0,%fp1 # fp1 is S*(B4+... 7457 7458 fadd.d EM1B3(%pc),%fp2 # fp2 is B3+S*... 7459 fadd.x EM1B2(%pc),%fp1 # fp1 is B2+S*... 7460 7461 fmul.x %fp0,%fp2 # fp2 is S*(B3+... 7462 fmul.x %fp0,%fp1 # fp1 is S*(B2+... 7463 7464 fmul.x %fp0,%fp2 # fp2 is S*S*(B3+...) 7465 fmul.x (%a0),%fp1 # fp1 is X*S*(B2... 7466 7467 fmul.s &0x3F000000,%fp0 # fp0 is S*B1 7468 fadd.x %fp2,%fp1 # fp1 is Q 7469 7470 fmovm.x (%sp)+,&0x30 # fp2 restored {%fp2/%fp3} 7471 7472 fadd.x %fp1,%fp0 # fp0 is S*B1+Q 7473 7474 fmov.l %d0,%fpcr 7475 fadd.x (%a0),%fp0 7476 bra t_inx2 7477 7478 EM1BIG: 7479 #--Step 10 |X| > 70 log2 7480 mov.l (%a0),%d1 7481 cmp.l %d1,&0 7482 bgt.w EXPC1 7483 #--Step 10.2 7484 fmov.s &0xBF800000,%fp0 # fp0 is -1 7485 fmov.l %d0,%fpcr 7486 fadd.s &0x00800000,%fp0 # -1 + 2^(-126) 7487 bra t_minx2 7488 7489 global setoxm1d 7490 setoxm1d: 7491 #--entry point for EXPM1(X), here X is denormalized 7492 #--Step 0. 7493 bra t_extdnrm 7494 7495 ######################################################################### 7496 # sgetexp(): returns the exponent portion of the input argument. # 7497 # The exponent bias is removed and the exponent value is # 7498 # returned as an extended precision number in fp0. # 7499 # sgetexpd(): handles denormalized numbers. # 7500 # # 7501 # sgetman(): extracts the mantissa of the input argument. The # 7502 # mantissa is converted to an extended precision number w/ # 7503 # an exponent of $3fff and is returned in fp0. The range of # 7504 # the result is [1.0 - 2.0). # 7505 # sgetmand(): handles denormalized numbers. # 7506 # # 7507 # INPUT *************************************************************** # 7508 # a0 = pointer to extended precision input # 7509 # # 7510 # OUTPUT ************************************************************** # 7511 # fp0 = exponent(X) or mantissa(X) # 7512 # # 7513 ######################################################################### 7514 7515 global sgetexp 7516 sgetexp: 7517 mov.w SRC_EX(%a0),%d0 # get the exponent 7518 bclr &0xf,%d0 # clear the sign bit 7519 subi.w &0x3fff,%d0 # subtract off the bias 7520 fmov.w %d0,%fp0 # return exp in fp0 7521 blt.b sgetexpn # it's negative 7522 rts 7523 7524 sgetexpn: 7525 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit 7526 rts 7527 7528 global sgetexpd 7529 sgetexpd: 7530 bsr.l norm # normalize 7531 neg.w %d0 # new exp = -(shft amt) 7532 subi.w &0x3fff,%d0 # subtract off the bias 7533 fmov.w %d0,%fp0 # return exp in fp0 7534 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit 7535 rts 7536 7537 global sgetman 7538 sgetman: 7539 mov.w SRC_EX(%a0),%d0 # get the exp 7540 ori.w &0x7fff,%d0 # clear old exp 7541 bclr &0xe,%d0 # make it the new exp +-3fff 7542 7543 # here, we build the result in a tmp location so as not to disturb the input 7544 mov.l SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp loc 7545 mov.l SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp loc 7546 mov.w %d0,FP_SCR0_EX(%a6) # insert new exponent 7547 fmov.x FP_SCR0(%a6),%fp0 # put new value back in fp0 7548 bmi.b sgetmann # it's negative 7549 rts 7550 7551 sgetmann: 7552 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit 7553 rts 7554 7555 # 7556 # For denormalized numbers, shift the mantissa until the j-bit = 1, 7557 # then load the exponent with +/1 $3fff. 7558 # 7559 global sgetmand 7560 sgetmand: 7561 bsr.l norm # normalize exponent 7562 bra.b sgetman 7563 7564 ######################################################################### 7565 # scosh(): computes the hyperbolic cosine of a normalized input # 7566 # scoshd(): computes the hyperbolic cosine of a denormalized input # 7567 # # 7568 # INPUT *************************************************************** # 7569 # a0 = pointer to extended precision input # 7570 # d0 = round precision,mode # 7571 # # 7572 # OUTPUT ************************************************************** # 7573 # fp0 = cosh(X) # 7574 # # 7575 # ACCURACY and MONOTONICITY ******************************************* # 7576 # The returned result is within 3 ulps in 64 significant bit, # 7577 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 7578 # rounded to double precision. The result is provably monotonic # 7579 # in double precision. # 7580 # # 7581 # ALGORITHM *********************************************************** # 7582 # # 7583 # COSH # 7584 # 1. If |X| > 16380 log2, go to 3. # 7585 # # 7586 # 2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae # 7587 # y = |X|, z = exp(Y), and # 7588 # cosh(X) = (1/2)*( z + 1/z ). # 7589 # Exit. # 7590 # # 7591 # 3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5. # 7592 # # 7593 # 4. (16380 log2 < |X| <= 16480 log2) # 7594 # cosh(X) = sign(X) * exp(|X|)/2. # 7595 # However, invoking exp(|X|) may cause premature # 7596 # overflow. Thus, we calculate sinh(X) as follows: # 7597 # Y := |X| # 7598 # Fact := 2**(16380) # 7599 # Y' := Y - 16381 log2 # 7600 # cosh(X) := Fact * exp(Y'). # 7601 # Exit. # 7602 # # 7603 # 5. (|X| > 16480 log2) sinh(X) must overflow. Return # 7604 # Huge*Huge to generate overflow and an infinity with # 7605 # the appropriate sign. Huge is the largest finite number # 7606 # in extended format. Exit. # 7607 # # 7608 ######################################################################### 7609 7610 TWO16380: 7611 long 0x7FFB0000,0x80000000,0x00000000,0x00000000 7612 7613 global scosh 7614 scosh: 7615 fmov.x (%a0),%fp0 # LOAD INPUT 7616 7617 mov.l (%a0),%d1 7618 mov.w 4(%a0),%d1 7619 and.l &0x7FFFFFFF,%d1 7620 cmp.l %d1,&0x400CB167 7621 bgt.b COSHBIG 7622 7623 #--THIS IS THE USUAL CASE, |X| < 16380 LOG2 7624 #--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) ) 7625 7626 fabs.x %fp0 # |X| 7627 7628 mov.l %d0,-(%sp) 7629 clr.l %d0 7630 fmovm.x &0x01,-(%sp) # save |X| to stack 7631 lea (%sp),%a0 # pass ptr to |X| 7632 bsr setox # FP0 IS EXP(|X|) 7633 add.l &0xc,%sp # erase |X| from stack 7634 fmul.s &0x3F000000,%fp0 # (1/2)EXP(|X|) 7635 mov.l (%sp)+,%d0 7636 7637 fmov.s &0x3E800000,%fp1 # (1/4) 7638 fdiv.x %fp0,%fp1 # 1/(2 EXP(|X|)) 7639 7640 fmov.l %d0,%fpcr 7641 mov.b &FADD_OP,%d1 # last inst is ADD 7642 fadd.x %fp1,%fp0 7643 bra t_catch 7644 7645 COSHBIG: 7646 cmp.l %d1,&0x400CB2B3 7647 bgt.b COSHHUGE 7648 7649 fabs.x %fp0 7650 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD) 7651 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE 7652 7653 mov.l %d0,-(%sp) 7654 clr.l %d0 7655 fmovm.x &0x01,-(%sp) # save fp0 to stack 7656 lea (%sp),%a0 # pass ptr to fp0 7657 bsr setox 7658 add.l &0xc,%sp # clear fp0 from stack 7659 mov.l (%sp)+,%d0 7660 7661 fmov.l %d0,%fpcr 7662 mov.b &FMUL_OP,%d1 # last inst is MUL 7663 fmul.x TWO16380(%pc),%fp0 7664 bra t_catch 7665 7666 COSHHUGE: 7667 bra t_ovfl2 7668 7669 global scoshd 7670 #--COSH(X) = 1 FOR DENORMALIZED X 7671 scoshd: 7672 fmov.s &0x3F800000,%fp0 7673 7674 fmov.l %d0,%fpcr 7675 fadd.s &0x00800000,%fp0 7676 bra t_pinx2 7677 7678 ######################################################################### 7679 # ssinh(): computes the hyperbolic sine of a normalized input # 7680 # ssinhd(): computes the hyperbolic sine of a denormalized input # 7681 # # 7682 # INPUT *************************************************************** # 7683 # a0 = pointer to extended precision input # 7684 # d0 = round precision,mode # 7685 # # 7686 # OUTPUT ************************************************************** # 7687 # fp0 = sinh(X) # 7688 # # 7689 # ACCURACY and MONOTONICITY ******************************************* # 7690 # The returned result is within 3 ulps in 64 significant bit, # 7691 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 7692 # rounded to double precision. The result is provably monotonic # 7693 # in double precision. # 7694 # # 7695 # ALGORITHM *********************************************************** # 7696 # # 7697 # SINH # 7698 # 1. If |X| > 16380 log2, go to 3. # 7699 # # 7700 # 2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula # 7701 # y = |X|, sgn = sign(X), and z = expm1(Y), # 7702 # sinh(X) = sgn*(1/2)*( z + z/(1+z) ). # 7703 # Exit. # 7704 # # 7705 # 3. If |X| > 16480 log2, go to 5. # 7706 # # 7707 # 4. (16380 log2 < |X| <= 16480 log2) # 7708 # sinh(X) = sign(X) * exp(|X|)/2. # 7709 # However, invoking exp(|X|) may cause premature overflow. # 7710 # Thus, we calculate sinh(X) as follows: # 7711 # Y := |X| # 7712 # sgn := sign(X) # 7713 # sgnFact := sgn * 2**(16380) # 7714 # Y' := Y - 16381 log2 # 7715 # sinh(X) := sgnFact * exp(Y'). # 7716 # Exit. # 7717 # # 7718 # 5. (|X| > 16480 log2) sinh(X) must overflow. Return # 7719 # sign(X)*Huge*Huge to generate overflow and an infinity with # 7720 # the appropriate sign. Huge is the largest finite number in # 7721 # extended format. Exit. # 7722 # # 7723 ######################################################################### 7724 7725 global ssinh 7726 ssinh: 7727 fmov.x (%a0),%fp0 # LOAD INPUT 7728 7729 mov.l (%a0),%d1 7730 mov.w 4(%a0),%d1 7731 mov.l %d1,%a1 # save (compacted) operand 7732 and.l &0x7FFFFFFF,%d1 7733 cmp.l %d1,&0x400CB167 7734 bgt.b SINHBIG 7735 7736 #--THIS IS THE USUAL CASE, |X| < 16380 LOG2 7737 #--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) ) 7738 7739 fabs.x %fp0 # Y = |X| 7740 7741 movm.l &0x8040,-(%sp) # {a1/d0} 7742 fmovm.x &0x01,-(%sp) # save Y on stack 7743 lea (%sp),%a0 # pass ptr to Y 7744 clr.l %d0 7745 bsr setoxm1 # FP0 IS Z = EXPM1(Y) 7746 add.l &0xc,%sp # clear Y from stack 7747 fmov.l &0,%fpcr 7748 movm.l (%sp)+,&0x0201 # {a1/d0} 7749 7750 fmov.x %fp0,%fp1 7751 fadd.s &0x3F800000,%fp1 # 1+Z 7752 fmov.x %fp0,-(%sp) 7753 fdiv.x %fp1,%fp0 # Z/(1+Z) 7754 mov.l %a1,%d1 7755 and.l &0x80000000,%d1 7756 or.l &0x3F000000,%d1 7757 fadd.x (%sp)+,%fp0 7758 mov.l %d1,-(%sp) 7759 7760 fmov.l %d0,%fpcr 7761 mov.b &FMUL_OP,%d1 # last inst is MUL 7762 fmul.s (%sp)+,%fp0 # last fp inst - possible exceptions set 7763 bra t_catch 7764 7765 SINHBIG: 7766 cmp.l %d1,&0x400CB2B3 7767 bgt t_ovfl 7768 fabs.x %fp0 7769 fsub.d T1(%pc),%fp0 # (|X|-16381LOG2_LEAD) 7770 mov.l &0,-(%sp) 7771 mov.l &0x80000000,-(%sp) 7772 mov.l %a1,%d1 7773 and.l &0x80000000,%d1 7774 or.l &0x7FFB0000,%d1 7775 mov.l %d1,-(%sp) # EXTENDED FMT 7776 fsub.d T2(%pc),%fp0 # |X| - 16381 LOG2, ACCURATE 7777 7778 mov.l %d0,-(%sp) 7779 clr.l %d0 7780 fmovm.x &0x01,-(%sp) # save fp0 on stack 7781 lea (%sp),%a0 # pass ptr to fp0 7782 bsr setox 7783 add.l &0xc,%sp # clear fp0 from stack 7784 7785 mov.l (%sp)+,%d0 7786 fmov.l %d0,%fpcr 7787 mov.b &FMUL_OP,%d1 # last inst is MUL 7788 fmul.x (%sp)+,%fp0 # possible exception 7789 bra t_catch 7790 7791 global ssinhd 7792 #--SINH(X) = X FOR DENORMALIZED X 7793 ssinhd: 7794 bra t_extdnrm 7795 7796 ######################################################################### 7797 # stanh(): computes the hyperbolic tangent of a normalized input # 7798 # stanhd(): computes the hyperbolic tangent of a denormalized input # 7799 # # 7800 # INPUT *************************************************************** # 7801 # a0 = pointer to extended precision input # 7802 # d0 = round precision,mode # 7803 # # 7804 # OUTPUT ************************************************************** # 7805 # fp0 = tanh(X) # 7806 # # 7807 # ACCURACY and MONOTONICITY ******************************************* # 7808 # The returned result is within 3 ulps in 64 significant bit, # 7809 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 7810 # rounded to double precision. The result is provably monotonic # 7811 # in double precision. # 7812 # # 7813 # ALGORITHM *********************************************************** # 7814 # # 7815 # TANH # 7816 # 1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3. # 7817 # # 7818 # 2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by # 7819 # sgn := sign(X), y := 2|X|, z := expm1(Y), and # 7820 # tanh(X) = sgn*( z/(2+z) ). # 7821 # Exit. # 7822 # # 7823 # 3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1, # 7824 # go to 7. # 7825 # # 7826 # 4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6. # 7827 # # 7828 # 5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by # 7829 # sgn := sign(X), y := 2|X|, z := exp(Y), # 7830 # tanh(X) = sgn - [ sgn*2/(1+z) ]. # 7831 # Exit. # 7832 # # 7833 # 6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we # 7834 # calculate Tanh(X) by # 7835 # sgn := sign(X), Tiny := 2**(-126), # 7836 # tanh(X) := sgn - sgn*Tiny. # 7837 # Exit. # 7838 # # 7839 # 7. (|X| < 2**(-40)). Tanh(X) = X. Exit. # 7840 # # 7841 ######################################################################### 7842 7843 set X,FP_SCR0 7844 set XFRAC,X+4 7845 7846 set SGN,L_SCR3 7847 7848 set V,FP_SCR0 7849 7850 global stanh 7851 stanh: 7852 fmov.x (%a0),%fp0 # LOAD INPUT 7853 7854 fmov.x %fp0,X(%a6) 7855 mov.l (%a0),%d1 7856 mov.w 4(%a0),%d1 7857 mov.l %d1,X(%a6) 7858 and.l &0x7FFFFFFF,%d1 7859 cmp.l %d1, &0x3fd78000 # is |X| < 2^(-40)? 7860 blt.w TANHBORS # yes 7861 cmp.l %d1, &0x3fffddce # is |X| > (5/2)LOG2? 7862 bgt.w TANHBORS # yes 7863 7864 #--THIS IS THE USUAL CASE 7865 #--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2). 7866 7867 mov.l X(%a6),%d1 7868 mov.l %d1,SGN(%a6) 7869 and.l &0x7FFF0000,%d1 7870 add.l &0x00010000,%d1 # EXPONENT OF 2|X| 7871 mov.l %d1,X(%a6) 7872 and.l &0x80000000,SGN(%a6) 7873 fmov.x X(%a6),%fp0 # FP0 IS Y = 2|X| 7874 7875 mov.l %d0,-(%sp) 7876 clr.l %d0 7877 fmovm.x &0x1,-(%sp) # save Y on stack 7878 lea (%sp),%a0 # pass ptr to Y 7879 bsr setoxm1 # FP0 IS Z = EXPM1(Y) 7880 add.l &0xc,%sp # clear Y from stack 7881 mov.l (%sp)+,%d0 7882 7883 fmov.x %fp0,%fp1 7884 fadd.s &0x40000000,%fp1 # Z+2 7885 mov.l SGN(%a6),%d1 7886 fmov.x %fp1,V(%a6) 7887 eor.l %d1,V(%a6) 7888 7889 fmov.l %d0,%fpcr # restore users round prec,mode 7890 fdiv.x V(%a6),%fp0 7891 bra t_inx2 7892 7893 TANHBORS: 7894 cmp.l %d1,&0x3FFF8000 7895 blt.w TANHSM 7896 7897 cmp.l %d1,&0x40048AA1 7898 bgt.w TANHHUGE 7899 7900 #-- (5/2) LOG2 < |X| < 50 LOG2, 7901 #--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X), 7902 #--TANH(X) = SGN - SGN*2/[EXP(Y)+1]. 7903 7904 mov.l X(%a6),%d1 7905 mov.l %d1,SGN(%a6) 7906 and.l &0x7FFF0000,%d1 7907 add.l &0x00010000,%d1 # EXPO OF 2|X| 7908 mov.l %d1,X(%a6) # Y = 2|X| 7909 and.l &0x80000000,SGN(%a6) 7910 mov.l SGN(%a6),%d1 7911 fmov.x X(%a6),%fp0 # Y = 2|X| 7912 7913 mov.l %d0,-(%sp) 7914 clr.l %d0 7915 fmovm.x &0x01,-(%sp) # save Y on stack 7916 lea (%sp),%a0 # pass ptr to Y 7917 bsr setox # FP0 IS EXP(Y) 7918 add.l &0xc,%sp # clear Y from stack 7919 mov.l (%sp)+,%d0 7920 mov.l SGN(%a6),%d1 7921 fadd.s &0x3F800000,%fp0 # EXP(Y)+1 7922 7923 eor.l &0xC0000000,%d1 # -SIGN(X)*2 7924 fmov.s %d1,%fp1 # -SIGN(X)*2 IN SGL FMT 7925 fdiv.x %fp0,%fp1 # -SIGN(X)2 / [EXP(Y)+1 ] 7926 7927 mov.l SGN(%a6),%d1 7928 or.l &0x3F800000,%d1 # SGN 7929 fmov.s %d1,%fp0 # SGN IN SGL FMT 7930 7931 fmov.l %d0,%fpcr # restore users round prec,mode 7932 mov.b &FADD_OP,%d1 # last inst is ADD 7933 fadd.x %fp1,%fp0 7934 bra t_inx2 7935 7936 TANHSM: 7937 fmov.l %d0,%fpcr # restore users round prec,mode 7938 mov.b &FMOV_OP,%d1 # last inst is MOVE 7939 fmov.x X(%a6),%fp0 # last inst - possible exception set 7940 bra t_catch 7941 7942 #---RETURN SGN(X) - SGN(X)EPS 7943 TANHHUGE: 7944 mov.l X(%a6),%d1 7945 and.l &0x80000000,%d1 7946 or.l &0x3F800000,%d1 7947 fmov.s %d1,%fp0 7948 and.l &0x80000000,%d1 7949 eor.l &0x80800000,%d1 # -SIGN(X)*EPS 7950 7951 fmov.l %d0,%fpcr # restore users round prec,mode 7952 fadd.s %d1,%fp0 7953 bra t_inx2 7954 7955 global stanhd 7956 #--TANH(X) = X FOR DENORMALIZED X 7957 stanhd: 7958 bra t_extdnrm 7959 7960 ######################################################################### 7961 # slogn(): computes the natural logarithm of a normalized input # 7962 # slognd(): computes the natural logarithm of a denormalized input # 7963 # slognp1(): computes the log(1+X) of a normalized input # 7964 # slognp1d(): computes the log(1+X) of a denormalized input # 7965 # # 7966 # INPUT *************************************************************** # 7967 # a0 = pointer to extended precision input # 7968 # d0 = round precision,mode # 7969 # # 7970 # OUTPUT ************************************************************** # 7971 # fp0 = log(X) or log(1+X) # 7972 # # 7973 # ACCURACY and MONOTONICITY ******************************************* # 7974 # The returned result is within 2 ulps in 64 significant bit, # 7975 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 7976 # rounded to double precision. The result is provably monotonic # 7977 # in double precision. # 7978 # # 7979 # ALGORITHM *********************************************************** # 7980 # LOGN: # 7981 # Step 1. If |X-1| < 1/16, approximate log(X) by an odd # 7982 # polynomial in u, where u = 2(X-1)/(X+1). Otherwise, # 7983 # move on to Step 2. # 7984 # # 7985 # Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first # 7986 # seven significant bits of Y plus 2**(-7), i.e. # 7987 # F = 1.xxxxxx1 in base 2 where the six "x" match those # 7988 # of Y. Note that |Y-F| <= 2**(-7). # 7989 # # 7990 # Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a # 7991 # polynomial in u, log(1+u) = poly. # 7992 # # 7993 # Step 4. Reconstruct # 7994 # log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u) # 7995 # by k*log(2) + (log(F) + poly). The values of log(F) are # 7996 # calculated beforehand and stored in the program. # 7997 # # 7998 # lognp1: # 7999 # Step 1: If |X| < 1/16, approximate log(1+X) by an odd # 8000 # polynomial in u where u = 2X/(2+X). Otherwise, move on # 8001 # to Step 2. # 8002 # # 8003 # Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done # 8004 # in Step 2 of the algorithm for LOGN and compute # 8005 # log(1+X) as k*log(2) + log(F) + poly where poly # 8006 # approximates log(1+u), u = (Y-F)/F. # 8007 # # 8008 # Implementation Notes: # 8009 # Note 1. There are 64 different possible values for F, thus 64 # 8010 # log(F)'s need to be tabulated. Moreover, the values of # 8011 # 1/F are also tabulated so that the division in (Y-F)/F # 8012 # can be performed by a multiplication. # 8013 # # 8014 # Note 2. In Step 2 of lognp1, in order to preserved accuracy, # 8015 # the value Y-F has to be calculated carefully when # 8016 # 1/2 <= X < 3/2. # 8017 # # 8018 # Note 3. To fully exploit the pipeline, polynomials are usually # 8019 # separated into two parts evaluated independently before # 8020 # being added up. # 8021 # # 8022 ######################################################################### 8023 LOGOF2: 8024 long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000 8025 8026 one: 8027 long 0x3F800000 8028 zero: 8029 long 0x00000000 8030 infty: 8031 long 0x7F800000 8032 negone: 8033 long 0xBF800000 8034 8035 LOGA6: 8036 long 0x3FC2499A,0xB5E4040B 8037 LOGA5: 8038 long 0xBFC555B5,0x848CB7DB 8039 8040 LOGA4: 8041 long 0x3FC99999,0x987D8730 8042 LOGA3: 8043 long 0xBFCFFFFF,0xFF6F7E97 8044 8045 LOGA2: 8046 long 0x3FD55555,0x555555A4 8047 LOGA1: 8048 long 0xBFE00000,0x00000008 8049 8050 LOGB5: 8051 long 0x3F175496,0xADD7DAD6 8052 LOGB4: 8053 long 0x3F3C71C2,0xFE80C7E0 8054 8055 LOGB3: 8056 long 0x3F624924,0x928BCCFF 8057 LOGB2: 8058 long 0x3F899999,0x999995EC 8059 8060 LOGB1: 8061 long 0x3FB55555,0x55555555 8062 TWO: 8063 long 0x40000000,0x00000000 8064 8065 LTHOLD: 8066 long 0x3f990000,0x80000000,0x00000000,0x00000000 8067 8068 LOGTBL: 8069 long 0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000 8070 long 0x3FF70000,0xFF015358,0x833C47E2,0x00000000 8071 long 0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000 8072 long 0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000 8073 long 0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000 8074 long 0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000 8075 long 0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000 8076 long 0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000 8077 long 0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000 8078 long 0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000 8079 long 0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000 8080 long 0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000 8081 long 0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000 8082 long 0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000 8083 long 0x3FFE0000,0xE525982A,0xF70C880E,0x00000000 8084 long 0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000 8085 long 0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000 8086 long 0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000 8087 long 0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000 8088 long 0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000 8089 long 0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000 8090 long 0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000 8091 long 0x3FFE0000,0xD901B203,0x6406C80E,0x00000000 8092 long 0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000 8093 long 0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000 8094 long 0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000 8095 long 0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000 8096 long 0x3FFC0000,0xC3FD0329,0x06488481,0x00000000 8097 long 0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000 8098 long 0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000 8099 long 0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000 8100 long 0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000 8101 long 0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000 8102 long 0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000 8103 long 0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000 8104 long 0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000 8105 long 0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000 8106 long 0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000 8107 long 0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000 8108 long 0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000 8109 long 0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000 8110 long 0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000 8111 long 0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000 8112 long 0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000 8113 long 0x3FFE0000,0xBD691047,0x07661AA3,0x00000000 8114 long 0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000 8115 long 0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000 8116 long 0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000 8117 long 0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000 8118 long 0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000 8119 long 0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000 8120 long 0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000 8121 long 0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000 8122 long 0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000 8123 long 0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000 8124 long 0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000 8125 long 0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000 8126 long 0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000 8127 long 0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000 8128 long 0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000 8129 long 0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000 8130 long 0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000 8131 long 0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000 8132 long 0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000 8133 long 0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000 8134 long 0x3FFD0000,0xD2420487,0x2DD85160,0x00000000 8135 long 0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000 8136 long 0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000 8137 long 0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000 8138 long 0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000 8139 long 0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000 8140 long 0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000 8141 long 0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000 8142 long 0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000 8143 long 0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000 8144 long 0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000 8145 long 0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000 8146 long 0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000 8147 long 0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000 8148 long 0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000 8149 long 0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000 8150 long 0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000 8151 long 0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000 8152 long 0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000 8153 long 0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000 8154 long 0x3FFE0000,0x825EFCED,0x49369330,0x00000000 8155 long 0x3FFE0000,0x9868C809,0x868C8098,0x00000000 8156 long 0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000 8157 long 0x3FFE0000,0x97012E02,0x5C04B809,0x00000000 8158 long 0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000 8159 long 0x3FFE0000,0x95A02568,0x095A0257,0x00000000 8160 long 0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000 8161 long 0x3FFE0000,0x94458094,0x45809446,0x00000000 8162 long 0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000 8163 long 0x3FFE0000,0x92F11384,0x0497889C,0x00000000 8164 long 0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000 8165 long 0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000 8166 long 0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000 8167 long 0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000 8168 long 0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000 8169 long 0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000 8170 long 0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000 8171 long 0x3FFE0000,0x8DDA5202,0x37694809,0x00000000 8172 long 0x3FFE0000,0x9723A1B7,0x20134203,0x00000000 8173 long 0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000 8174 long 0x3FFE0000,0x995899C8,0x90EB8990,0x00000000 8175 long 0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000 8176 long 0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000 8177 long 0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000 8178 long 0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000 8179 long 0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000 8180 long 0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000 8181 long 0x3FFE0000,0x87F78087,0xF78087F8,0x00000000 8182 long 0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000 8183 long 0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000 8184 long 0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000 8185 long 0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000 8186 long 0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000 8187 long 0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000 8188 long 0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000 8189 long 0x3FFE0000,0x83993052,0x3FBE3368,0x00000000 8190 long 0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000 8191 long 0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000 8192 long 0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000 8193 long 0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000 8194 long 0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000 8195 long 0x3FFE0000,0x80808080,0x80808081,0x00000000 8196 long 0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000 8197 8198 set ADJK,L_SCR1 8199 8200 set X,FP_SCR0 8201 set XDCARE,X+2 8202 set XFRAC,X+4 8203 8204 set F,FP_SCR1 8205 set FFRAC,F+4 8206 8207 set KLOG2,FP_SCR0 8208 8209 set SAVEU,FP_SCR0 8210 8211 global slogn 8212 #--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S 8213 slogn: 8214 fmov.x (%a0),%fp0 # LOAD INPUT 8215 mov.l &0x00000000,ADJK(%a6) 8216 8217 LOGBGN: 8218 #--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS 8219 #--A FINITE, NON-ZERO, NORMALIZED NUMBER. 8220 8221 mov.l (%a0),%d1 8222 mov.w 4(%a0),%d1 8223 8224 mov.l (%a0),X(%a6) 8225 mov.l 4(%a0),X+4(%a6) 8226 mov.l 8(%a0),X+8(%a6) 8227 8228 cmp.l %d1,&0 # CHECK IF X IS NEGATIVE 8229 blt.w LOGNEG # LOG OF NEGATIVE ARGUMENT IS INVALID 8230 # X IS POSITIVE, CHECK IF X IS NEAR 1 8231 cmp.l %d1,&0x3ffef07d # IS X < 15/16? 8232 blt.b LOGMAIN # YES 8233 cmp.l %d1,&0x3fff8841 # IS X > 17/16? 8234 ble.w LOGNEAR1 # NO 8235 8236 LOGMAIN: 8237 #--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1 8238 8239 #--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY. 8240 #--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1. 8241 #--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y) 8242 #-- = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F). 8243 #--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING 8244 #--LOG(1+U) CAN BE VERY EFFICIENT. 8245 #--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO 8246 #--DIVISION IS NEEDED TO CALCULATE (Y-F)/F. 8247 8248 #--GET K, Y, F, AND ADDRESS OF 1/F. 8249 asr.l &8,%d1 8250 asr.l &8,%d1 # SHIFTED 16 BITS, BIASED EXPO. OF X 8251 sub.l &0x3FFF,%d1 # THIS IS K 8252 add.l ADJK(%a6),%d1 # ADJUST K, ORIGINAL INPUT MAY BE DENORM. 8253 lea LOGTBL(%pc),%a0 # BASE ADDRESS OF 1/F AND LOG(F) 8254 fmov.l %d1,%fp1 # CONVERT K TO FLOATING-POINT FORMAT 8255 8256 #--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F 8257 mov.l &0x3FFF0000,X(%a6) # X IS NOW Y, I.E. 2^(-K)*X 8258 mov.l XFRAC(%a6),FFRAC(%a6) 8259 and.l &0xFE000000,FFRAC(%a6) # FIRST 7 BITS OF Y 8260 or.l &0x01000000,FFRAC(%a6) # GET F: ATTACH A 1 AT THE EIGHTH BIT 8261 mov.l FFRAC(%a6),%d1 # READY TO GET ADDRESS OF 1/F 8262 and.l &0x7E000000,%d1 8263 asr.l &8,%d1 8264 asr.l &8,%d1 8265 asr.l &4,%d1 # SHIFTED 20, D0 IS THE DISPLACEMENT 8266 add.l %d1,%a0 # A0 IS THE ADDRESS FOR 1/F 8267 8268 fmov.x X(%a6),%fp0 8269 mov.l &0x3fff0000,F(%a6) 8270 clr.l F+8(%a6) 8271 fsub.x F(%a6),%fp0 # Y-F 8272 fmovm.x &0xc,-(%sp) # SAVE FP2-3 WHILE FP0 IS NOT READY 8273 #--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K 8274 #--REGISTERS SAVED: FPCR, FP1, FP2 8275 8276 LP1CONT1: 8277 #--AN RE-ENTRY POINT FOR LOGNP1 8278 fmul.x (%a0),%fp0 # FP0 IS U = (Y-F)/F 8279 fmul.x LOGOF2(%pc),%fp1 # GET K*LOG2 WHILE FP0 IS NOT READY 8280 fmov.x %fp0,%fp2 8281 fmul.x %fp2,%fp2 # FP2 IS V=U*U 8282 fmov.x %fp1,KLOG2(%a6) # PUT K*LOG2 IN MEMEORY, FREE FP1 8283 8284 #--LOG(1+U) IS APPROXIMATED BY 8285 #--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS 8286 #--[U + V*(A1+V*(A3+V*A5))] + [U*V*(A2+V*(A4+V*A6))] 8287 8288 fmov.x %fp2,%fp3 8289 fmov.x %fp2,%fp1 8290 8291 fmul.d LOGA6(%pc),%fp1 # V*A6 8292 fmul.d LOGA5(%pc),%fp2 # V*A5 8293 8294 fadd.d LOGA4(%pc),%fp1 # A4+V*A6 8295 fadd.d LOGA3(%pc),%fp2 # A3+V*A5 8296 8297 fmul.x %fp3,%fp1 # V*(A4+V*A6) 8298 fmul.x %fp3,%fp2 # V*(A3+V*A5) 8299 8300 fadd.d LOGA2(%pc),%fp1 # A2+V*(A4+V*A6) 8301 fadd.d LOGA1(%pc),%fp2 # A1+V*(A3+V*A5) 8302 8303 fmul.x %fp3,%fp1 # V*(A2+V*(A4+V*A6)) 8304 add.l &16,%a0 # ADDRESS OF LOG(F) 8305 fmul.x %fp3,%fp2 # V*(A1+V*(A3+V*A5)) 8306 8307 fmul.x %fp0,%fp1 # U*V*(A2+V*(A4+V*A6)) 8308 fadd.x %fp2,%fp0 # U+V*(A1+V*(A3+V*A5)) 8309 8310 fadd.x (%a0),%fp1 # LOG(F)+U*V*(A2+V*(A4+V*A6)) 8311 fmovm.x (%sp)+,&0x30 # RESTORE FP2-3 8312 fadd.x %fp1,%fp0 # FP0 IS LOG(F) + LOG(1+U) 8313 8314 fmov.l %d0,%fpcr 8315 fadd.x KLOG2(%a6),%fp0 # FINAL ADD 8316 bra t_inx2 8317 8318 8319 LOGNEAR1: 8320 8321 # if the input is exactly equal to one, then exit through ld_pzero. 8322 # if these 2 lines weren't here, the correct answer would be returned 8323 # but the INEX2 bit would be set. 8324 fcmp.b %fp0,&0x1 # is it equal to one? 8325 fbeq.l ld_pzero # yes 8326 8327 #--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT. 8328 fmov.x %fp0,%fp1 8329 fsub.s one(%pc),%fp1 # FP1 IS X-1 8330 fadd.s one(%pc),%fp0 # FP0 IS X+1 8331 fadd.x %fp1,%fp1 # FP1 IS 2(X-1) 8332 #--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL 8333 #--IN U, U = 2(X-1)/(X+1) = FP1/FP0 8334 8335 LP1CONT2: 8336 #--THIS IS AN RE-ENTRY POINT FOR LOGNP1 8337 fdiv.x %fp0,%fp1 # FP1 IS U 8338 fmovm.x &0xc,-(%sp) # SAVE FP2-3 8339 #--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3 8340 #--LET V=U*U, W=V*V, CALCULATE 8341 #--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY 8342 #--U + U*V*( [B1 + W*(B3 + W*B5)] + [V*(B2 + W*B4)] ) 8343 fmov.x %fp1,%fp0 8344 fmul.x %fp0,%fp0 # FP0 IS V 8345 fmov.x %fp1,SAVEU(%a6) # STORE U IN MEMORY, FREE FP1 8346 fmov.x %fp0,%fp1 8347 fmul.x %fp1,%fp1 # FP1 IS W 8348 8349 fmov.d LOGB5(%pc),%fp3 8350 fmov.d LOGB4(%pc),%fp2 8351 8352 fmul.x %fp1,%fp3 # W*B5 8353 fmul.x %fp1,%fp2 # W*B4 8354 8355 fadd.d LOGB3(%pc),%fp3 # B3+W*B5 8356 fadd.d LOGB2(%pc),%fp2 # B2+W*B4 8357 8358 fmul.x %fp3,%fp1 # W*(B3+W*B5), FP3 RELEASED 8359 8360 fmul.x %fp0,%fp2 # V*(B2+W*B4) 8361 8362 fadd.d LOGB1(%pc),%fp1 # B1+W*(B3+W*B5) 8363 fmul.x SAVEU(%a6),%fp0 # FP0 IS U*V 8364 8365 fadd.x %fp2,%fp1 # B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED 8366 fmovm.x (%sp)+,&0x30 # FP2-3 RESTORED 8367 8368 fmul.x %fp1,%fp0 # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] ) 8369 8370 fmov.l %d0,%fpcr 8371 fadd.x SAVEU(%a6),%fp0 8372 bra t_inx2 8373 8374 #--REGISTERS SAVED FPCR. LOG(-VE) IS INVALID 8375 LOGNEG: 8376 bra t_operr 8377 8378 global slognd 8379 slognd: 8380 #--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT 8381 8382 mov.l &-100,ADJK(%a6) # INPUT = 2^(ADJK) * FP0 8383 8384 #----normalize the input value by left shifting k bits (k to be determined 8385 #----below), adjusting exponent and storing -k to ADJK 8386 #----the value TWOTO100 is no longer needed. 8387 #----Note that this code assumes the denormalized input is NON-ZERO. 8388 8389 movm.l &0x3f00,-(%sp) # save some registers {d2-d7} 8390 mov.l (%a0),%d3 # D3 is exponent of smallest norm. # 8391 mov.l 4(%a0),%d4 8392 mov.l 8(%a0),%d5 # (D4,D5) is (Hi_X,Lo_X) 8393 clr.l %d2 # D2 used for holding K 8394 8395 tst.l %d4 8396 bne.b Hi_not0 8397 8398 Hi_0: 8399 mov.l %d5,%d4 8400 clr.l %d5 8401 mov.l &32,%d2 8402 clr.l %d6 8403 bfffo %d4{&0:&32},%d6 8404 lsl.l %d6,%d4 8405 add.l %d6,%d2 # (D3,D4,D5) is normalized 8406 8407 mov.l %d3,X(%a6) 8408 mov.l %d4,XFRAC(%a6) 8409 mov.l %d5,XFRAC+4(%a6) 8410 neg.l %d2 8411 mov.l %d2,ADJK(%a6) 8412 fmov.x X(%a6),%fp0 8413 movm.l (%sp)+,&0xfc # restore registers {d2-d7} 8414 lea X(%a6),%a0 8415 bra.w LOGBGN # begin regular log(X) 8416 8417 Hi_not0: 8418 clr.l %d6 8419 bfffo %d4{&0:&32},%d6 # find first 1 8420 mov.l %d6,%d2 # get k 8421 lsl.l %d6,%d4 8422 mov.l %d5,%d7 # a copy of D5 8423 lsl.l %d6,%d5 8424 neg.l %d6 8425 add.l &32,%d6 8426 lsr.l %d6,%d7 8427 or.l %d7,%d4 # (D3,D4,D5) normalized 8428 8429 mov.l %d3,X(%a6) 8430 mov.l %d4,XFRAC(%a6) 8431 mov.l %d5,XFRAC+4(%a6) 8432 neg.l %d2 8433 mov.l %d2,ADJK(%a6) 8434 fmov.x X(%a6),%fp0 8435 movm.l (%sp)+,&0xfc # restore registers {d2-d7} 8436 lea X(%a6),%a0 8437 bra.w LOGBGN # begin regular log(X) 8438 8439 global slognp1 8440 #--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S 8441 slognp1: 8442 fmov.x (%a0),%fp0 # LOAD INPUT 8443 fabs.x %fp0 # test magnitude 8444 fcmp.x %fp0,LTHOLD(%pc) # compare with min threshold 8445 fbgt.w LP1REAL # if greater, continue 8446 fmov.l %d0,%fpcr 8447 mov.b &FMOV_OP,%d1 # last inst is MOVE 8448 fmov.x (%a0),%fp0 # return signed argument 8449 bra t_catch 8450 8451 LP1REAL: 8452 fmov.x (%a0),%fp0 # LOAD INPUT 8453 mov.l &0x00000000,ADJK(%a6) 8454 fmov.x %fp0,%fp1 # FP1 IS INPUT Z 8455 fadd.s one(%pc),%fp0 # X := ROUND(1+Z) 8456 fmov.x %fp0,X(%a6) 8457 mov.w XFRAC(%a6),XDCARE(%a6) 8458 mov.l X(%a6),%d1 8459 cmp.l %d1,&0 8460 ble.w LP1NEG0 # LOG OF ZERO OR -VE 8461 cmp.l %d1,&0x3ffe8000 # IS BOUNDS [1/2,3/2]? 8462 blt.w LOGMAIN 8463 cmp.l %d1,&0x3fffc000 8464 bgt.w LOGMAIN 8465 #--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z, 8466 #--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE, 8467 #--SIMPLY INVOKE LOG(X) FOR LOG(1+Z). 8468 8469 LP1NEAR1: 8470 #--NEXT SEE IF EXP(-1/16) < X < EXP(1/16) 8471 cmp.l %d1,&0x3ffef07d 8472 blt.w LP1CARE 8473 cmp.l %d1,&0x3fff8841 8474 bgt.w LP1CARE 8475 8476 LP1ONE16: 8477 #--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2) 8478 #--WHERE U = 2Z/(2+Z) = 2Z/(1+X). 8479 fadd.x %fp1,%fp1 # FP1 IS 2Z 8480 fadd.s one(%pc),%fp0 # FP0 IS 1+X 8481 #--U = FP1/FP0 8482 bra.w LP1CONT2 8483 8484 LP1CARE: 8485 #--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE 8486 #--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST 8487 #--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2], 8488 #--THERE ARE ONLY TWO CASES. 8489 #--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z 8490 #--CASE 2: 1+Z > 1, THEN K = 0 AND Y-F = (1-F) + Z 8491 #--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF 8492 #--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED. 8493 8494 mov.l XFRAC(%a6),FFRAC(%a6) 8495 and.l &0xFE000000,FFRAC(%a6) 8496 or.l &0x01000000,FFRAC(%a6) # F OBTAINED 8497 cmp.l %d1,&0x3FFF8000 # SEE IF 1+Z > 1 8498 bge.b KISZERO 8499 8500 KISNEG1: 8501 fmov.s TWO(%pc),%fp0 8502 mov.l &0x3fff0000,F(%a6) 8503 clr.l F+8(%a6) 8504 fsub.x F(%a6),%fp0 # 2-F 8505 mov.l FFRAC(%a6),%d1 8506 and.l &0x7E000000,%d1 8507 asr.l &8,%d1 8508 asr.l &8,%d1 8509 asr.l &4,%d1 # D0 CONTAINS DISPLACEMENT FOR 1/F 8510 fadd.x %fp1,%fp1 # GET 2Z 8511 fmovm.x &0xc,-(%sp) # SAVE FP2 {%fp2/%fp3} 8512 fadd.x %fp1,%fp0 # FP0 IS Y-F = (2-F)+2Z 8513 lea LOGTBL(%pc),%a0 # A0 IS ADDRESS OF 1/F 8514 add.l %d1,%a0 8515 fmov.s negone(%pc),%fp1 # FP1 IS K = -1 8516 bra.w LP1CONT1 8517 8518 KISZERO: 8519 fmov.s one(%pc),%fp0 8520 mov.l &0x3fff0000,F(%a6) 8521 clr.l F+8(%a6) 8522 fsub.x F(%a6),%fp0 # 1-F 8523 mov.l FFRAC(%a6),%d1 8524 and.l &0x7E000000,%d1 8525 asr.l &8,%d1 8526 asr.l &8,%d1 8527 asr.l &4,%d1 8528 fadd.x %fp1,%fp0 # FP0 IS Y-F 8529 fmovm.x &0xc,-(%sp) # FP2 SAVED {%fp2/%fp3} 8530 lea LOGTBL(%pc),%a0 8531 add.l %d1,%a0 # A0 IS ADDRESS OF 1/F 8532 fmov.s zero(%pc),%fp1 # FP1 IS K = 0 8533 bra.w LP1CONT1 8534 8535 LP1NEG0: 8536 #--FPCR SAVED. D0 IS X IN COMPACT FORM. 8537 cmp.l %d1,&0 8538 blt.b LP1NEG 8539 LP1ZERO: 8540 fmov.s negone(%pc),%fp0 8541 8542 fmov.l %d0,%fpcr 8543 bra t_dz 8544 8545 LP1NEG: 8546 fmov.s zero(%pc),%fp0 8547 8548 fmov.l %d0,%fpcr 8549 bra t_operr 8550 8551 global slognp1d 8552 #--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT 8553 # Simply return the denorm 8554 slognp1d: 8555 bra t_extdnrm 8556 8557 ######################################################################### 8558 # satanh(): computes the inverse hyperbolic tangent of a norm input # 8559 # satanhd(): computes the inverse hyperbolic tangent of a denorm input # 8560 # # 8561 # INPUT *************************************************************** # 8562 # a0 = pointer to extended precision input # 8563 # d0 = round precision,mode # 8564 # # 8565 # OUTPUT ************************************************************** # 8566 # fp0 = arctanh(X) # 8567 # # 8568 # ACCURACY and MONOTONICITY ******************************************* # 8569 # The returned result is within 3 ulps in 64 significant bit, # 8570 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 8571 # rounded to double precision. The result is provably monotonic # 8572 # in double precision. # 8573 # # 8574 # ALGORITHM *********************************************************** # 8575 # # 8576 # ATANH # 8577 # 1. If |X| >= 1, go to 3. # 8578 # # 8579 # 2. (|X| < 1) Calculate atanh(X) by # 8580 # sgn := sign(X) # 8581 # y := |X| # 8582 # z := 2y/(1-y) # 8583 # atanh(X) := sgn * (1/2) * logp1(z) # 8584 # Exit. # 8585 # # 8586 # 3. If |X| > 1, go to 5. # 8587 # # 8588 # 4. (|X| = 1) Generate infinity with an appropriate sign and # 8589 # divide-by-zero by # 8590 # sgn := sign(X) # 8591 # atan(X) := sgn / (+0). # 8592 # Exit. # 8593 # # 8594 # 5. (|X| > 1) Generate an invalid operation by 0 * infinity. # 8595 # Exit. # 8596 # # 8597 ######################################################################### 8598 8599 global satanh 8600 satanh: 8601 mov.l (%a0),%d1 8602 mov.w 4(%a0),%d1 8603 and.l &0x7FFFFFFF,%d1 8604 cmp.l %d1,&0x3FFF8000 8605 bge.b ATANHBIG 8606 8607 #--THIS IS THE USUAL CASE, |X| < 1 8608 #--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z). 8609 8610 fabs.x (%a0),%fp0 # Y = |X| 8611 fmov.x %fp0,%fp1 8612 fneg.x %fp1 # -Y 8613 fadd.x %fp0,%fp0 # 2Y 8614 fadd.s &0x3F800000,%fp1 # 1-Y 8615 fdiv.x %fp1,%fp0 # 2Y/(1-Y) 8616 mov.l (%a0),%d1 8617 and.l &0x80000000,%d1 8618 or.l &0x3F000000,%d1 # SIGN(X)*HALF 8619 mov.l %d1,-(%sp) 8620 8621 mov.l %d0,-(%sp) # save rnd prec,mode 8622 clr.l %d0 # pass ext prec,RN 8623 fmovm.x &0x01,-(%sp) # save Z on stack 8624 lea (%sp),%a0 # pass ptr to Z 8625 bsr slognp1 # LOG1P(Z) 8626 add.l &0xc,%sp # clear Z from stack 8627 8628 mov.l (%sp)+,%d0 # fetch old prec,mode 8629 fmov.l %d0,%fpcr # load it 8630 mov.b &FMUL_OP,%d1 # last inst is MUL 8631 fmul.s (%sp)+,%fp0 8632 bra t_catch 8633 8634 ATANHBIG: 8635 fabs.x (%a0),%fp0 # |X| 8636 fcmp.s %fp0,&0x3F800000 8637 fbgt t_operr 8638 bra t_dz 8639 8640 global satanhd 8641 #--ATANH(X) = X FOR DENORMALIZED X 8642 satanhd: 8643 bra t_extdnrm 8644 8645 ######################################################################### 8646 # slog10(): computes the base-10 logarithm of a normalized input # 8647 # slog10d(): computes the base-10 logarithm of a denormalized input # 8648 # slog2(): computes the base-2 logarithm of a normalized input # 8649 # slog2d(): computes the base-2 logarithm of a denormalized input # 8650 # # 8651 # INPUT *************************************************************** # 8652 # a0 = pointer to extended precision input # 8653 # d0 = round precision,mode # 8654 # # 8655 # OUTPUT ************************************************************** # 8656 # fp0 = log_10(X) or log_2(X) # 8657 # # 8658 # ACCURACY and MONOTONICITY ******************************************* # 8659 # The returned result is within 1.7 ulps in 64 significant bit, # 8660 # i.e. within 0.5003 ulp to 53 bits if the result is subsequently # 8661 # rounded to double precision. The result is provably monotonic # 8662 # in double precision. # 8663 # # 8664 # ALGORITHM *********************************************************** # 8665 # # 8666 # slog10d: # 8667 # # 8668 # Step 0. If X < 0, create a NaN and raise the invalid operation # 8669 # flag. Otherwise, save FPCR in D1; set FpCR to default. # 8670 # Notes: Default means round-to-nearest mode, no floating-point # 8671 # traps, and precision control = double extended. # 8672 # # 8673 # Step 1. Call slognd to obtain Y = log(X), the natural log of X. # 8674 # Notes: Even if X is denormalized, log(X) is always normalized. # 8675 # # 8676 # Step 2. Compute log_10(X) = log(X) * (1/log(10)). # 8677 # 2.1 Restore the user FPCR # 8678 # 2.2 Return ans := Y * INV_L10. # 8679 # # 8680 # slog10: # 8681 # # 8682 # Step 0. If X < 0, create a NaN and raise the invalid operation # 8683 # flag. Otherwise, save FPCR in D1; set FpCR to default. # 8684 # Notes: Default means round-to-nearest mode, no floating-point # 8685 # traps, and precision control = double extended. # 8686 # # 8687 # Step 1. Call sLogN to obtain Y = log(X), the natural log of X. # 8688 # # 8689 # Step 2. Compute log_10(X) = log(X) * (1/log(10)). # 8690 # 2.1 Restore the user FPCR # 8691 # 2.2 Return ans := Y * INV_L10. # 8692 # # 8693 # sLog2d: # 8694 # # 8695 # Step 0. If X < 0, create a NaN and raise the invalid operation # 8696 # flag. Otherwise, save FPCR in D1; set FpCR to default. # 8697 # Notes: Default means round-to-nearest mode, no floating-point # 8698 # traps, and precision control = double extended. # 8699 # # 8700 # Step 1. Call slognd to obtain Y = log(X), the natural log of X. # 8701 # Notes: Even if X is denormalized, log(X) is always normalized. # 8702 # # 8703 # Step 2. Compute log_10(X) = log(X) * (1/log(2)). # 8704 # 2.1 Restore the user FPCR # 8705 # 2.2 Return ans := Y * INV_L2. # 8706 # # 8707 # sLog2: # 8708 # # 8709 # Step 0. If X < 0, create a NaN and raise the invalid operation # 8710 # flag. Otherwise, save FPCR in D1; set FpCR to default. # 8711 # Notes: Default means round-to-nearest mode, no floating-point # 8712 # traps, and precision control = double extended. # 8713 # # 8714 # Step 1. If X is not an integer power of two, i.e., X != 2^k, # 8715 # go to Step 3. # 8716 # # 8717 # Step 2. Return k. # 8718 # 2.1 Get integer k, X = 2^k. # 8719 # 2.2 Restore the user FPCR. # 8720 # 2.3 Return ans := convert-to-double-extended(k). # 8721 # # 8722 # Step 3. Call sLogN to obtain Y = log(X), the natural log of X. # 8723 # # 8724 # Step 4. Compute log_2(X) = log(X) * (1/log(2)). # 8725 # 4.1 Restore the user FPCR # 8726 # 4.2 Return ans := Y * INV_L2. # 8727 # # 8728 ######################################################################### 8729 8730 INV_L10: 8731 long 0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000 8732 8733 INV_L2: 8734 long 0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000 8735 8736 global slog10 8737 #--entry point for Log10(X), X is normalized 8738 slog10: 8739 fmov.b &0x1,%fp0 8740 fcmp.x %fp0,(%a0) # if operand == 1, 8741 fbeq.l ld_pzero # return an EXACT zero 8742 8743 mov.l (%a0),%d1 8744 blt.w invalid 8745 mov.l %d0,-(%sp) 8746 clr.l %d0 8747 bsr slogn # log(X), X normal. 8748 fmov.l (%sp)+,%fpcr 8749 fmul.x INV_L10(%pc),%fp0 8750 bra t_inx2 8751 8752 global slog10d 8753 #--entry point for Log10(X), X is denormalized 8754 slog10d: 8755 mov.l (%a0),%d1 8756 blt.w invalid 8757 mov.l %d0,-(%sp) 8758 clr.l %d0 8759 bsr slognd # log(X), X denorm. 8760 fmov.l (%sp)+,%fpcr 8761 fmul.x INV_L10(%pc),%fp0 8762 bra t_minx2 8763 8764 global slog2 8765 #--entry point for Log2(X), X is normalized 8766 slog2: 8767 mov.l (%a0),%d1 8768 blt.w invalid 8769 8770 mov.l 8(%a0),%d1 8771 bne.b continue # X is not 2^k 8772 8773 mov.l 4(%a0),%d1 8774 and.l &0x7FFFFFFF,%d1 8775 bne.b continue 8776 8777 #--X = 2^k. 8778 mov.w (%a0),%d1 8779 and.l &0x00007FFF,%d1 8780 sub.l &0x3FFF,%d1 8781 beq.l ld_pzero 8782 fmov.l %d0,%fpcr 8783 fmov.l %d1,%fp0 8784 bra t_inx2 8785 8786 continue: 8787 mov.l %d0,-(%sp) 8788 clr.l %d0 8789 bsr slogn # log(X), X normal. 8790 fmov.l (%sp)+,%fpcr 8791 fmul.x INV_L2(%pc),%fp0 8792 bra t_inx2 8793 8794 invalid: 8795 bra t_operr 8796 8797 global slog2d 8798 #--entry point for Log2(X), X is denormalized 8799 slog2d: 8800 mov.l (%a0),%d1 8801 blt.w invalid 8802 mov.l %d0,-(%sp) 8803 clr.l %d0 8804 bsr slognd # log(X), X denorm. 8805 fmov.l (%sp)+,%fpcr 8806 fmul.x INV_L2(%pc),%fp0 8807 bra t_minx2 8808 8809 ######################################################################### 8810 # stwotox(): computes 2**X for a normalized input # 8811 # stwotoxd(): computes 2**X for a denormalized input # 8812 # stentox(): computes 10**X for a normalized input # 8813 # stentoxd(): computes 10**X for a denormalized input # 8814 # # 8815 # INPUT *************************************************************** # 8816 # a0 = pointer to extended precision input # 8817 # d0 = round precision,mode # 8818 # # 8819 # OUTPUT ************************************************************** # 8820 # fp0 = 2**X or 10**X # 8821 # # 8822 # ACCURACY and MONOTONICITY ******************************************* # 8823 # The returned result is within 2 ulps in 64 significant bit, # 8824 # i.e. within 0.5001 ulp to 53 bits if the result is subsequently # 8825 # rounded to double precision. The result is provably monotonic # 8826 # in double precision. # 8827 # # 8828 # ALGORITHM *********************************************************** # 8829 # # 8830 # twotox # 8831 # 1. If |X| > 16480, go to ExpBig. # 8832 # # 8833 # 2. If |X| < 2**(-70), go to ExpSm. # 8834 # # 8835 # 3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore # 8836 # decompose N as # 8837 # N = 64(M + M') + j, j = 0,1,2,...,63. # 8838 # # 8839 # 4. Overwrite r := r * log2. Then # 8840 # 2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). # 8841 # Go to expr to compute that expression. # 8842 # # 8843 # tentox # 8844 # 1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig. # 8845 # # 8846 # 2. If |X| < 2**(-70), go to ExpSm. # 8847 # # 8848 # 3. Set y := X*log_2(10)*64 (base 2 log of 10). Set # 8849 # N := round-to-int(y). Decompose N as # 8850 # N = 64(M + M') + j, j = 0,1,2,...,63. # 8851 # # 8852 # 4. Define r as # 8853 # r := ((X - N*L1)-N*L2) * L10 # 8854 # where L1, L2 are the leading and trailing parts of # 8855 # log_10(2)/64 and L10 is the natural log of 10. Then # 8856 # 10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r). # 8857 # Go to expr to compute that expression. # 8858 # # 8859 # expr # 8860 # 1. Fetch 2**(j/64) from table as Fact1 and Fact2. # 8861 # # 8862 # 2. Overwrite Fact1 and Fact2 by # 8863 # Fact1 := 2**(M) * Fact1 # 8864 # Fact2 := 2**(M) * Fact2 # 8865 # Thus Fact1 + Fact2 = 2**(M) * 2**(j/64). # 8866 # # 8867 # 3. Calculate P where 1 + P approximates exp(r): # 8868 # P = r + r*r*(A1+r*(A2+...+r*A5)). # 8869 # # 8870 # 4. Let AdjFact := 2**(M'). Return # 8871 # AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ). # 8872 # Exit. # 8873 # # 8874 # ExpBig # 8875 # 1. Generate overflow by Huge * Huge if X > 0; otherwise, # 8876 # generate underflow by Tiny * Tiny. # 8877 # # 8878 # ExpSm # 8879 # 1. Return 1 + X. # 8880 # # 8881 ######################################################################### 8882 8883 L2TEN64: 8884 long 0x406A934F,0x0979A371 # 64LOG10/LOG2 8885 L10TWO1: 8886 long 0x3F734413,0x509F8000 # LOG2/64LOG10 8887 8888 L10TWO2: 8889 long 0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000 8890 8891 LOG10: long 0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000 8892 8893 LOG2: long 0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000 8894 8895 EXPA5: long 0x3F56C16D,0x6F7BD0B2 8896 EXPA4: long 0x3F811112,0x302C712C 8897 EXPA3: long 0x3FA55555,0x55554CC1 8898 EXPA2: long 0x3FC55555,0x55554A54 8899 EXPA1: long 0x3FE00000,0x00000000,0x00000000,0x00000000 8900 8901 TEXPTBL: 8902 long 0x3FFF0000,0x80000000,0x00000000,0x3F738000 8903 long 0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CA 8904 long 0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9 8905 long 0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9 8906 long 0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DA 8907 long 0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85C 8908 long 0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1 8909 long 0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CA 8910 long 0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373 8911 long 0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670 8912 long 0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700 8913 long 0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0 8914 long 0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6D 8915 long 0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319 8916 long 0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2B 8917 long 0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5 8918 long 0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5A 8919 long 0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7B 8920 long 0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAF 8921 long 0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DA 8922 long 0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDD 8923 long 0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96E 8924 long 0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90B 8925 long 0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DB 8926 long 0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EB 8927 long 0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274 8928 long 0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83C 8929 long 0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00 8930 long 0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301 8931 long 0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367 8932 long 0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05F 8933 long 0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3C 8934 long 0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FB 8935 long 0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CB 8936 long 0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3C 8937 long 0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AA 8938 long 0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFD 8939 long 0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51 8940 long 0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88A 8941 long 0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2 8942 long 0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8AB 8943 long 0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17 8944 long 0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3C 8945 long 0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8 8946 long 0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53 8947 long 0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AE 8948 long 0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124 8949 long 0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243 8950 long 0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69A 8951 long 0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61 8952 long 0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610 8953 long 0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1 8954 long 0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12 8955 long 0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFE 8956 long 0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4 8957 long 0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22F 8958 long 0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4A 8959 long 0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01A 8960 long 0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAC 8961 long 0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3F 8962 long 0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73A 8963 long 0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795 8964 long 0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84B 8965 long 0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581 8966 8967 set INT,L_SCR1 8968 8969 set X,FP_SCR0 8970 set XDCARE,X+2 8971 set XFRAC,X+4 8972 8973 set ADJFACT,FP_SCR0 8974 8975 set FACT1,FP_SCR0 8976 set FACT1HI,FACT1+4 8977 set FACT1LOW,FACT1+8 8978 8979 set FACT2,FP_SCR1 8980 set FACT2HI,FACT2+4 8981 set FACT2LOW,FACT2+8 8982 8983 global stwotox 8984 #--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S 8985 stwotox: 8986 fmovm.x (%a0),&0x80 # LOAD INPUT 8987 8988 mov.l (%a0),%d1 8989 mov.w 4(%a0),%d1 8990 fmov.x %fp0,X(%a6) 8991 and.l &0x7FFFFFFF,%d1 8992 8993 cmp.l %d1,&0x3FB98000 # |X| >= 2**(-70)? 8994 bge.b TWOOK1 8995 bra.w EXPBORS 8996 8997 TWOOK1: 8998 cmp.l %d1,&0x400D80C0 # |X| > 16480? 8999 ble.b TWOMAIN 9000 bra.w EXPBORS 9001 9002 TWOMAIN: 9003 #--USUAL CASE, 2^(-70) <= |X| <= 16480 9004 9005 fmov.x %fp0,%fp1 9006 fmul.s &0x42800000,%fp1 # 64 * X 9007 fmov.l %fp1,INT(%a6) # N = ROUND-TO-INT(64 X) 9008 mov.l %d2,-(%sp) 9009 lea TEXPTBL(%pc),%a1 # LOAD ADDRESS OF TABLE OF 2^(J/64) 9010 fmov.l INT(%a6),%fp1 # N --> FLOATING FMT 9011 mov.l INT(%a6),%d1 9012 mov.l %d1,%d2 9013 and.l &0x3F,%d1 # D0 IS J 9014 asl.l &4,%d1 # DISPLACEMENT FOR 2^(J/64) 9015 add.l %d1,%a1 # ADDRESS FOR 2^(J/64) 9016 asr.l &6,%d2 # d2 IS L, N = 64L + J 9017 mov.l %d2,%d1 9018 asr.l &1,%d1 # D0 IS M 9019 sub.l %d1,%d2 # d2 IS M', N = 64(M+M') + J 9020 add.l &0x3FFF,%d2 9021 9022 #--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64), 9023 #--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN. 9024 #--ADJFACT = 2^(M'). 9025 #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2. 9026 9027 fmovm.x &0x0c,-(%sp) # save fp2/fp3 9028 9029 fmul.s &0x3C800000,%fp1 # (1/64)*N 9030 mov.l (%a1)+,FACT1(%a6) 9031 mov.l (%a1)+,FACT1HI(%a6) 9032 mov.l (%a1)+,FACT1LOW(%a6) 9033 mov.w (%a1)+,FACT2(%a6) 9034 9035 fsub.x %fp1,%fp0 # X - (1/64)*INT(64 X) 9036 9037 mov.w (%a1)+,FACT2HI(%a6) 9038 clr.w FACT2HI+2(%a6) 9039 clr.l FACT2LOW(%a6) 9040 add.w %d1,FACT1(%a6) 9041 fmul.x LOG2(%pc),%fp0 # FP0 IS R 9042 add.w %d1,FACT2(%a6) 9043 9044 bra.w expr 9045 9046 EXPBORS: 9047 #--FPCR, D0 SAVED 9048 cmp.l %d1,&0x3FFF8000 9049 bgt.b TEXPBIG 9050 9051 #--|X| IS SMALL, RETURN 1 + X 9052 9053 fmov.l %d0,%fpcr # restore users round prec,mode 9054 fadd.s &0x3F800000,%fp0 # RETURN 1 + X 9055 bra t_pinx2 9056 9057 TEXPBIG: 9058 #--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW 9059 #--REGISTERS SAVE SO FAR ARE FPCR AND D0 9060 mov.l X(%a6),%d1 9061 cmp.l %d1,&0 9062 blt.b EXPNEG 9063 9064 bra t_ovfl2 # t_ovfl expects positive value 9065 9066 EXPNEG: 9067 bra t_unfl2 # t_unfl expects positive value 9068 9069 global stwotoxd 9070 stwotoxd: 9071 #--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENT 9072 9073 fmov.l %d0,%fpcr # set user's rounding mode/precision 9074 fmov.s &0x3F800000,%fp0 # RETURN 1 + X 9075 mov.l (%a0),%d1 9076 or.l &0x00800001,%d1 9077 fadd.s %d1,%fp0 9078 bra t_pinx2 9079 9080 global stentox 9081 #--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S 9082 stentox: 9083 fmovm.x (%a0),&0x80 # LOAD INPUT 9084 9085 mov.l (%a0),%d1 9086 mov.w 4(%a0),%d1 9087 fmov.x %fp0,X(%a6) 9088 and.l &0x7FFFFFFF,%d1 9089 9090 cmp.l %d1,&0x3FB98000 # |X| >= 2**(-70)? 9091 bge.b TENOK1 9092 bra.w EXPBORS 9093 9094 TENOK1: 9095 cmp.l %d1,&0x400B9B07 # |X| <= 16480*log2/log10 ? 9096 ble.b TENMAIN 9097 bra.w EXPBORS 9098 9099 TENMAIN: 9100 #--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10 9101 9102 fmov.x %fp0,%fp1 9103 fmul.d L2TEN64(%pc),%fp1 # X*64*LOG10/LOG2 9104 fmov.l %fp1,INT(%a6) # N=INT(X*64*LOG10/LOG2) 9105 mov.l %d2,-(%sp) 9106 lea TEXPTBL(%pc),%a1 # LOAD ADDRESS OF TABLE OF 2^(J/64) 9107 fmov.l INT(%a6),%fp1 # N --> FLOATING FMT 9108 mov.l INT(%a6),%d1 9109 mov.l %d1,%d2 9110 and.l &0x3F,%d1 # D0 IS J 9111 asl.l &4,%d1 # DISPLACEMENT FOR 2^(J/64) 9112 add.l %d1,%a1 # ADDRESS FOR 2^(J/64) 9113 asr.l &6,%d2 # d2 IS L, N = 64L + J 9114 mov.l %d2,%d1 9115 asr.l &1,%d1 # D0 IS M 9116 sub.l %d1,%d2 # d2 IS M', N = 64(M+M') + J 9117 add.l &0x3FFF,%d2 9118 9119 #--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64), 9120 #--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN. 9121 #--ADJFACT = 2^(M'). 9122 #--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2. 9123 fmovm.x &0x0c,-(%sp) # save fp2/fp3 9124 9125 fmov.x %fp1,%fp2 9126 9127 fmul.d L10TWO1(%pc),%fp1 # N*(LOG2/64LOG10)_LEAD 9128 mov.l (%a1)+,FACT1(%a6) 9129 9130 fmul.x L10TWO2(%pc),%fp2 # N*(LOG2/64LOG10)_TRAIL 9131 9132 mov.l (%a1)+,FACT1HI(%a6) 9133 mov.l (%a1)+,FACT1LOW(%a6) 9134 fsub.x %fp1,%fp0 # X - N L_LEAD 9135 mov.w (%a1)+,FACT2(%a6) 9136 9137 fsub.x %fp2,%fp0 # X - N L_TRAIL 9138 9139 mov.w (%a1)+,FACT2HI(%a6) 9140 clr.w FACT2HI+2(%a6) 9141 clr.l FACT2LOW(%a6) 9142 9143 fmul.x LOG10(%pc),%fp0 # FP0 IS R 9144 add.w %d1,FACT1(%a6) 9145 add.w %d1,FACT2(%a6) 9146 9147 expr: 9148 #--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN. 9149 #--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64). 9150 #--FP0 IS R. THE FOLLOWING CODE COMPUTES 9151 #-- 2**(M'+M) * 2**(J/64) * EXP(R) 9152 9153 fmov.x %fp0,%fp1 9154 fmul.x %fp1,%fp1 # FP1 IS S = R*R 9155 9156 fmov.d EXPA5(%pc),%fp2 # FP2 IS A5 9157 fmov.d EXPA4(%pc),%fp3 # FP3 IS A4 9158 9159 fmul.x %fp1,%fp2 # FP2 IS S*A5 9160 fmul.x %fp1,%fp3 # FP3 IS S*A4 9161 9162 fadd.d EXPA3(%pc),%fp2 # FP2 IS A3+S*A5 9163 fadd.d EXPA2(%pc),%fp3 # FP3 IS A2+S*A4 9164 9165 fmul.x %fp1,%fp2 # FP2 IS S*(A3+S*A5) 9166 fmul.x %fp1,%fp3 # FP3 IS S*(A2+S*A4) 9167 9168 fadd.d EXPA1(%pc),%fp2 # FP2 IS A1+S*(A3+S*A5) 9169 fmul.x %fp0,%fp3 # FP3 IS R*S*(A2+S*A4) 9170 9171 fmul.x %fp1,%fp2 # FP2 IS S*(A1+S*(A3+S*A5)) 9172 fadd.x %fp3,%fp0 # FP0 IS R+R*S*(A2+S*A4) 9173 fadd.x %fp2,%fp0 # FP0 IS EXP(R) - 1 9174 9175 fmovm.x (%sp)+,&0x30 # restore fp2/fp3 9176 9177 #--FINAL RECONSTRUCTION PROCESS 9178 #--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1) - (1 OR 0) 9179 9180 fmul.x FACT1(%a6),%fp0 9181 fadd.x FACT2(%a6),%fp0 9182 fadd.x FACT1(%a6),%fp0 9183 9184 fmov.l %d0,%fpcr # restore users round prec,mode 9185 mov.w %d2,ADJFACT(%a6) # INSERT EXPONENT 9186 mov.l (%sp)+,%d2 9187 mov.l &0x80000000,ADJFACT+4(%a6) 9188 clr.l ADJFACT+8(%a6) 9189 mov.b &FMUL_OP,%d1 # last inst is MUL 9190 fmul.x ADJFACT(%a6),%fp0 # FINAL ADJUSTMENT 9191 bra t_catch 9192 9193 global stentoxd 9194 stentoxd: 9195 #--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENT 9196 9197 fmov.l %d0,%fpcr # set user's rounding mode/precision 9198 fmov.s &0x3F800000,%fp0 # RETURN 1 + X 9199 mov.l (%a0),%d1 9200 or.l &0x00800001,%d1 9201 fadd.s %d1,%fp0 9202 bra t_pinx2 9203 9204 ######################################################################### 9205 # sscale(): computes the destination operand scaled by the source # 9206 # operand. If the absoulute value of the source operand is # 9207 # >= 2^14, an overflow or underflow is returned. # 9208 # # 9209 # INPUT *************************************************************** # 9210 # a0 = pointer to double-extended source operand X # 9211 # a1 = pointer to double-extended destination operand Y # 9212 # # 9213 # OUTPUT ************************************************************** # 9214 # fp0 = scale(X,Y) # 9215 # # 9216 ######################################################################### 9217 9218 set SIGN, L_SCR1 9219 9220 global sscale 9221 sscale: 9222 mov.l %d0,-(%sp) # store off ctrl bits for now 9223 9224 mov.w DST_EX(%a1),%d1 # get dst exponent 9225 smi.b SIGN(%a6) # use SIGN to hold dst sign 9226 andi.l &0x00007fff,%d1 # strip sign from dst exp 9227 9228 mov.w SRC_EX(%a0),%d0 # check src bounds 9229 andi.w &0x7fff,%d0 # clr src sign bit 9230 cmpi.w %d0,&0x3fff # is src ~ ZERO? 9231 blt.w src_small # yes 9232 cmpi.w %d0,&0x400c # no; is src too big? 9233 bgt.w src_out # yes 9234 9235 # 9236 # Source is within 2^14 range. 9237 # 9238 src_ok: 9239 fintrz.x SRC(%a0),%fp0 # calc int of src 9240 fmov.l %fp0,%d0 # int src to d0 9241 # don't want any accrued bits from the fintrz showing up later since 9242 # we may need to read the fpsr for the last fp op in t_catch2(). 9243 fmov.l &0x0,%fpsr 9244 9245 tst.b DST_HI(%a1) # is dst denormalized? 9246 bmi.b sok_norm 9247 9248 # the dst is a DENORM. normalize the DENORM and add the adjustment to 9249 # the src value. then, jump to the norm part of the routine. 9250 sok_dnrm: 9251 mov.l %d0,-(%sp) # save src for now 9252 9253 mov.w DST_EX(%a1),FP_SCR0_EX(%a6) # make a copy 9254 mov.l DST_HI(%a1),FP_SCR0_HI(%a6) 9255 mov.l DST_LO(%a1),FP_SCR0_LO(%a6) 9256 9257 lea FP_SCR0(%a6),%a0 # pass ptr to DENORM 9258 bsr.l norm # normalize the DENORM 9259 neg.l %d0 9260 add.l (%sp)+,%d0 # add adjustment to src 9261 9262 fmovm.x FP_SCR0(%a6),&0x80 # load normalized DENORM 9263 9264 cmpi.w %d0,&-0x3fff # is the shft amt really low? 9265 bge.b sok_norm2 # thank goodness no 9266 9267 # the multiply factor that we're trying to create should be a denorm 9268 # for the multiply to work. therefore, we're going to actually do a 9269 # multiply with a denorm which will cause an unimplemented data type 9270 # exception to be put into the machine which will be caught and corrected 9271 # later. we don't do this with the DENORMs above because this method 9272 # is slower. but, don't fret, I don't see it being used much either. 9273 fmov.l (%sp)+,%fpcr # restore user fpcr 9274 mov.l &0x80000000,%d1 # load normalized mantissa 9275 subi.l &-0x3fff,%d0 # how many should we shift? 9276 neg.l %d0 # make it positive 9277 cmpi.b %d0,&0x20 # is it > 32? 9278 bge.b sok_dnrm_32 # yes 9279 lsr.l %d0,%d1 # no; bit stays in upper lw 9280 clr.l -(%sp) # insert zero low mantissa 9281 mov.l %d1,-(%sp) # insert new high mantissa 9282 clr.l -(%sp) # make zero exponent 9283 bra.b sok_norm_cont 9284 sok_dnrm_32: 9285 subi.b &0x20,%d0 # get shift count 9286 lsr.l %d0,%d1 # make low mantissa longword 9287 mov.l %d1,-(%sp) # insert new low mantissa 9288 clr.l -(%sp) # insert zero high mantissa 9289 clr.l -(%sp) # make zero exponent 9290 bra.b sok_norm_cont 9291 9292 # the src will force the dst to a DENORM value or worse. so, let's 9293 # create an fp multiply that will create the result. 9294 sok_norm: 9295 fmovm.x DST(%a1),&0x80 # load fp0 with normalized src 9296 sok_norm2: 9297 fmov.l (%sp)+,%fpcr # restore user fpcr 9298 9299 addi.w &0x3fff,%d0 # turn src amt into exp value 9300 swap %d0 # put exponent in high word 9301 clr.l -(%sp) # insert new exponent 9302 mov.l &0x80000000,-(%sp) # insert new high mantissa 9303 mov.l %d0,-(%sp) # insert new lo mantissa 9304 9305 sok_norm_cont: 9306 fmov.l %fpcr,%d0 # d0 needs fpcr for t_catch2 9307 mov.b &FMUL_OP,%d1 # last inst is MUL 9308 fmul.x (%sp)+,%fp0 # do the multiply 9309 bra t_catch2 # catch any exceptions 9310 9311 # 9312 # Source is outside of 2^14 range. Test the sign and branch 9313 # to the appropriate exception handler. 9314 # 9315 src_out: 9316 mov.l (%sp)+,%d0 # restore ctrl bits 9317 exg %a0,%a1 # swap src,dst ptrs 9318 tst.b SRC_EX(%a1) # is src negative? 9319 bmi t_unfl # yes; underflow 9320 bra t_ovfl_sc # no; overflow 9321 9322 # 9323 # The source input is below 1, so we check for denormalized numbers 9324 # and set unfl. 9325 # 9326 src_small: 9327 tst.b DST_HI(%a1) # is dst denormalized? 9328 bpl.b ssmall_done # yes 9329 9330 mov.l (%sp)+,%d0 9331 fmov.l %d0,%fpcr # no; load control bits 9332 mov.b &FMOV_OP,%d1 # last inst is MOVE 9333 fmov.x DST(%a1),%fp0 # simply return dest 9334 bra t_catch2 9335 ssmall_done: 9336 mov.l (%sp)+,%d0 # load control bits into d1 9337 mov.l %a1,%a0 # pass ptr to dst 9338 bra t_resdnrm 9339 9340 ######################################################################### 9341 # smod(): computes the fp MOD of the input values X,Y. # 9342 # srem(): computes the fp (IEEE) REM of the input values X,Y. # 9343 # # 9344 # INPUT *************************************************************** # 9345 # a0 = pointer to extended precision input X # 9346 # a1 = pointer to extended precision input Y # 9347 # d0 = round precision,mode # 9348 # # 9349 # The input operands X and Y can be either normalized or # 9350 # denormalized. # 9351 # # 9352 # OUTPUT ************************************************************** # 9353 # fp0 = FREM(X,Y) or FMOD(X,Y) # 9354 # # 9355 # ALGORITHM *********************************************************** # 9356 # # 9357 # Step 1. Save and strip signs of X and Y: signX := sign(X), # 9358 # signY := sign(Y), X := |X|, Y := |Y|, # 9359 # signQ := signX EOR signY. Record whether MOD or REM # 9360 # is requested. # 9361 # # 9362 # Step 2. Set L := expo(X)-expo(Y), k := 0, Q := 0. # 9363 # If (L < 0) then # 9364 # R := X, go to Step 4. # 9365 # else # 9366 # R := 2^(-L)X, j := L. # 9367 # endif # 9368 # # 9369 # Step 3. Perform MOD(X,Y) # 9370 # 3.1 If R = Y, go to Step 9. # 9371 # 3.2 If R > Y, then { R := R - Y, Q := Q + 1} # 9372 # 3.3 If j = 0, go to Step 4. # 9373 # 3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to # 9374 # Step 3.1. # 9375 # # 9376 # Step 4. At this point, R = X - QY = MOD(X,Y). Set # 9377 # Last_Subtract := false (used in Step 7 below). If # 9378 # MOD is requested, go to Step 6. # 9379 # # 9380 # Step 5. R = MOD(X,Y), but REM(X,Y) is requested. # 9381 # 5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to # 9382 # Step 6. # 9383 # 5.2 If R > Y/2, then { set Last_Subtract := true, # 9384 # Q := Q + 1, Y := signY*Y }. Go to Step 6. # 9385 # 5.3 This is the tricky case of R = Y/2. If Q is odd, # 9386 # then { Q := Q + 1, signX := -signX }. # 9387 # # 9388 # Step 6. R := signX*R. # 9389 # # 9390 # Step 7. If Last_Subtract = true, R := R - Y. # 9391 # # 9392 # Step 8. Return signQ, last 7 bits of Q, and R as required. # 9393 # # 9394 # Step 9. At this point, R = 2^(-j)*X - Q Y = Y. Thus, # 9395 # X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1), # 9396 # R := 0. Return signQ, last 7 bits of Q, and R. # 9397 # # 9398 ######################################################################### 9399 9400 set Mod_Flag,L_SCR3 9401 set Sc_Flag,L_SCR3+1 9402 9403 set SignY,L_SCR2 9404 set SignX,L_SCR2+2 9405 set SignQ,L_SCR3+2 9406 9407 set Y,FP_SCR0 9408 set Y_Hi,Y+4 9409 set Y_Lo,Y+8 9410 9411 set R,FP_SCR1 9412 set R_Hi,R+4 9413 set R_Lo,R+8 9414 9415 Scale: 9416 long 0x00010000,0x80000000,0x00000000,0x00000000 9417 9418 global smod 9419 smod: 9420 clr.b FPSR_QBYTE(%a6) 9421 mov.l %d0,-(%sp) # save ctrl bits 9422 clr.b Mod_Flag(%a6) 9423 bra.b Mod_Rem 9424 9425 global srem 9426 srem: 9427 clr.b FPSR_QBYTE(%a6) 9428 mov.l %d0,-(%sp) # save ctrl bits 9429 mov.b &0x1,Mod_Flag(%a6) 9430 9431 Mod_Rem: 9432 #..Save sign of X and Y 9433 movm.l &0x3f00,-(%sp) # save data registers 9434 mov.w SRC_EX(%a0),%d3 9435 mov.w %d3,SignY(%a6) 9436 and.l &0x00007FFF,%d3 # Y := |Y| 9437 9438 # 9439 mov.l SRC_HI(%a0),%d4 9440 mov.l SRC_LO(%a0),%d5 # (D3,D4,D5) is |Y| 9441 9442 tst.l %d3 9443 bne.b Y_Normal 9444 9445 mov.l &0x00003FFE,%d3 # $3FFD + 1 9446 tst.l %d4 9447 bne.b HiY_not0 9448 9449 HiY_0: 9450 mov.l %d5,%d4 9451 clr.l %d5 9452 sub.l &32,%d3 9453 clr.l %d6 9454 bfffo %d4{&0:&32},%d6 9455 lsl.l %d6,%d4 9456 sub.l %d6,%d3 # (D3,D4,D5) is normalized 9457 # ...with bias $7FFD 9458 bra.b Chk_X 9459 9460 HiY_not0: 9461 clr.l %d6 9462 bfffo %d4{&0:&32},%d6 9463 sub.l %d6,%d3 9464 lsl.l %d6,%d4 9465 mov.l %d5,%d7 # a copy of D5 9466 lsl.l %d6,%d5 9467 neg.l %d6 9468 add.l &32,%d6 9469 lsr.l %d6,%d7 9470 or.l %d7,%d4 # (D3,D4,D5) normalized 9471 # ...with bias $7FFD 9472 bra.b Chk_X 9473 9474 Y_Normal: 9475 add.l &0x00003FFE,%d3 # (D3,D4,D5) normalized 9476 # ...with bias $7FFD 9477 9478 Chk_X: 9479 mov.w DST_EX(%a1),%d0 9480 mov.w %d0,SignX(%a6) 9481 mov.w SignY(%a6),%d1 9482 eor.l %d0,%d1 9483 and.l &0x00008000,%d1 9484 mov.w %d1,SignQ(%a6) # sign(Q) obtained 9485 and.l &0x00007FFF,%d0 9486 mov.l DST_HI(%a1),%d1 9487 mov.l DST_LO(%a1),%d2 # (D0,D1,D2) is |X| 9488 tst.l %d0 9489 bne.b X_Normal 9490 mov.l &0x00003FFE,%d0 9491 tst.l %d1 9492 bne.b HiX_not0 9493 9494 HiX_0: 9495 mov.l %d2,%d1 9496 clr.l %d2 9497 sub.l &32,%d0 9498 clr.l %d6 9499 bfffo %d1{&0:&32},%d6 9500 lsl.l %d6,%d1 9501 sub.l %d6,%d0 # (D0,D1,D2) is normalized 9502 # ...with bias $7FFD 9503 bra.b Init 9504 9505 HiX_not0: 9506 clr.l %d6 9507 bfffo %d1{&0:&32},%d6 9508 sub.l %d6,%d0 9509 lsl.l %d6,%d1 9510 mov.l %d2,%d7 # a copy of D2 9511 lsl.l %d6,%d2 9512 neg.l %d6 9513 add.l &32,%d6 9514 lsr.l %d6,%d7 9515 or.l %d7,%d1 # (D0,D1,D2) normalized 9516 # ...with bias $7FFD 9517 bra.b Init 9518 9519 X_Normal: 9520 add.l &0x00003FFE,%d0 # (D0,D1,D2) normalized 9521 # ...with bias $7FFD 9522 9523 Init: 9524 # 9525 mov.l %d3,L_SCR1(%a6) # save biased exp(Y) 9526 mov.l %d0,-(%sp) # save biased exp(X) 9527 sub.l %d3,%d0 # L := expo(X)-expo(Y) 9528 9529 clr.l %d6 # D6 := carry <- 0 9530 clr.l %d3 # D3 is Q 9531 mov.l &0,%a1 # A1 is k; j+k=L, Q=0 9532 9533 #..(Carry,D1,D2) is R 9534 tst.l %d0 9535 bge.b Mod_Loop_pre 9536 9537 #..expo(X) < expo(Y). Thus X = mod(X,Y) 9538 # 9539 mov.l (%sp)+,%d0 # restore d0 9540 bra.w Get_Mod 9541 9542 Mod_Loop_pre: 9543 addq.l &0x4,%sp # erase exp(X) 9544 #..At this point R = 2^(-L)X; Q = 0; k = 0; and k+j = L 9545 Mod_Loop: 9546 tst.l %d6 # test carry bit 9547 bgt.b R_GT_Y 9548 9549 #..At this point carry = 0, R = (D1,D2), Y = (D4,D5) 9550 cmp.l %d1,%d4 # compare hi(R) and hi(Y) 9551 bne.b R_NE_Y 9552 cmp.l %d2,%d5 # compare lo(R) and lo(Y) 9553 bne.b R_NE_Y 9554 9555 #..At this point, R = Y 9556 bra.w Rem_is_0 9557 9558 R_NE_Y: 9559 #..use the borrow of the previous compare 9560 bcs.b R_LT_Y # borrow is set iff R < Y 9561 9562 R_GT_Y: 9563 #..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0 9564 #..and Y < (D1,D2) < 2Y. Either way, perform R - Y 9565 sub.l %d5,%d2 # lo(R) - lo(Y) 9566 subx.l %d4,%d1 # hi(R) - hi(Y) 9567 clr.l %d6 # clear carry 9568 addq.l &1,%d3 # Q := Q + 1 9569 9570 R_LT_Y: 9571 #..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0. 9572 tst.l %d0 # see if j = 0. 9573 beq.b PostLoop 9574 9575 add.l %d3,%d3 # Q := 2Q 9576 add.l %d2,%d2 # lo(R) = 2lo(R) 9577 roxl.l &1,%d1 # hi(R) = 2hi(R) + carry 9578 scs %d6 # set Carry if 2(R) overflows 9579 addq.l &1,%a1 # k := k+1 9580 subq.l &1,%d0 # j := j - 1 9581 #..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y. 9582 9583 bra.b Mod_Loop 9584 9585 PostLoop: 9586 #..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y. 9587 9588 #..normalize R. 9589 mov.l L_SCR1(%a6),%d0 # new biased expo of R 9590 tst.l %d1 9591 bne.b HiR_not0 9592 9593 HiR_0: 9594 mov.l %d2,%d1 9595 clr.l %d2 9596 sub.l &32,%d0 9597 clr.l %d6 9598 bfffo %d1{&0:&32},%d6 9599 lsl.l %d6,%d1 9600 sub.l %d6,%d0 # (D0,D1,D2) is normalized 9601 # ...with bias $7FFD 9602 bra.b Get_Mod 9603 9604 HiR_not0: 9605 clr.l %d6 9606 bfffo %d1{&0:&32},%d6 9607 bmi.b Get_Mod # already normalized 9608 sub.l %d6,%d0 9609 lsl.l %d6,%d1 9610 mov.l %d2,%d7 # a copy of D2 9611 lsl.l %d6,%d2 9612 neg.l %d6 9613 add.l &32,%d6 9614 lsr.l %d6,%d7 9615 or.l %d7,%d1 # (D0,D1,D2) normalized 9616 9617 # 9618 Get_Mod: 9619 cmp.l %d0,&0x000041FE 9620 bge.b No_Scale 9621 Do_Scale: 9622 mov.w %d0,R(%a6) 9623 mov.l %d1,R_Hi(%a6) 9624 mov.l %d2,R_Lo(%a6) 9625 mov.l L_SCR1(%a6),%d6 9626 mov.w %d6,Y(%a6) 9627 mov.l %d4,Y_Hi(%a6) 9628 mov.l %d5,Y_Lo(%a6) 9629 fmov.x R(%a6),%fp0 # no exception 9630 mov.b &1,Sc_Flag(%a6) 9631 bra.b ModOrRem 9632 No_Scale: 9633 mov.l %d1,R_Hi(%a6) 9634 mov.l %d2,R_Lo(%a6) 9635 sub.l &0x3FFE,%d0 9636 mov.w %d0,R(%a6) 9637 mov.l L_SCR1(%a6),%d6 9638 sub.l &0x3FFE,%d6 9639 mov.l %d6,L_SCR1(%a6) 9640 fmov.x R(%a6),%fp0 9641 mov.w %d6,Y(%a6) 9642 mov.l %d4,Y_Hi(%a6) 9643 mov.l %d5,Y_Lo(%a6) 9644 clr.b Sc_Flag(%a6) 9645 9646 # 9647 ModOrRem: 9648 tst.b Mod_Flag(%a6) 9649 beq.b Fix_Sign 9650 9651 mov.l L_SCR1(%a6),%d6 # new biased expo(Y) 9652 subq.l &1,%d6 # biased expo(Y/2) 9653 cmp.l %d0,%d6 9654 blt.b Fix_Sign 9655 bgt.b Last_Sub 9656 9657 cmp.l %d1,%d4 9658 bne.b Not_EQ 9659 cmp.l %d2,%d5 9660 bne.b Not_EQ 9661 bra.w Tie_Case 9662 9663 Not_EQ: 9664 bcs.b Fix_Sign 9665 9666 Last_Sub: 9667 # 9668 fsub.x Y(%a6),%fp0 # no exceptions 9669 addq.l &1,%d3 # Q := Q + 1 9670 9671 # 9672 Fix_Sign: 9673 #..Get sign of X 9674 mov.w SignX(%a6),%d6 9675 bge.b Get_Q 9676 fneg.x %fp0 9677 9678 #..Get Q 9679 # 9680 Get_Q: 9681 clr.l %d6 9682 mov.w SignQ(%a6),%d6 # D6 is sign(Q) 9683 mov.l &8,%d7 9684 lsr.l %d7,%d6 9685 and.l &0x0000007F,%d3 # 7 bits of Q 9686 or.l %d6,%d3 # sign and bits of Q 9687 # swap %d3 9688 # fmov.l %fpsr,%d6 9689 # and.l &0xFF00FFFF,%d6 9690 # or.l %d3,%d6 9691 # fmov.l %d6,%fpsr # put Q in fpsr 9692 mov.b %d3,FPSR_QBYTE(%a6) # put Q in fpsr 9693 9694 # 9695 Restore: 9696 movm.l (%sp)+,&0xfc # {%d2-%d7} 9697 mov.l (%sp)+,%d0 9698 fmov.l %d0,%fpcr 9699 tst.b Sc_Flag(%a6) 9700 beq.b Finish 9701 mov.b &FMUL_OP,%d1 # last inst is MUL 9702 fmul.x Scale(%pc),%fp0 # may cause underflow 9703 bra t_catch2 9704 # the '040 package did this apparently to see if the dst operand for the 9705 # preceding fmul was a denorm. but, it better not have been since the 9706 # algorithm just got done playing with fp0 and expected no exceptions 9707 # as a result. trust me... 9708 # bra t_avoid_unsupp # check for denorm as a 9709 # ;result of the scaling 9710 9711 Finish: 9712 mov.b &FMOV_OP,%d1 # last inst is MOVE 9713 fmov.x %fp0,%fp0 # capture exceptions & round 9714 bra t_catch2 9715 9716 Rem_is_0: 9717 #..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1) 9718 addq.l &1,%d3 9719 cmp.l %d0,&8 # D0 is j 9720 bge.b Q_Big 9721 9722 lsl.l %d0,%d3 9723 bra.b Set_R_0 9724 9725 Q_Big: 9726 clr.l %d3 9727 9728 Set_R_0: 9729 fmov.s &0x00000000,%fp0 9730 clr.b Sc_Flag(%a6) 9731 bra.w Fix_Sign 9732 9733 Tie_Case: 9734 #..Check parity of Q 9735 mov.l %d3,%d6 9736 and.l &0x00000001,%d6 9737 tst.l %d6 9738 beq.w Fix_Sign # Q is even 9739 9740 #..Q is odd, Q := Q + 1, signX := -signX 9741 addq.l &1,%d3 9742 mov.w SignX(%a6),%d6 9743 eor.l &0x00008000,%d6 9744 mov.w %d6,SignX(%a6) 9745 bra.w Fix_Sign 9746 9747 ######################################################################### 9748 # XDEF **************************************************************** # 9749 # tag(): return the optype of the input ext fp number # 9750 # # 9751 # This routine is used by the 060FPLSP. # 9752 # # 9753 # XREF **************************************************************** # 9754 # None # 9755 # # 9756 # INPUT *************************************************************** # 9757 # a0 = pointer to extended precision operand # 9758 # # 9759 # OUTPUT ************************************************************** # 9760 # d0 = value of type tag # 9761 # one of: NORM, INF, QNAN, SNAN, DENORM, ZERO # 9762 # # 9763 # ALGORITHM *********************************************************** # 9764 # Simply test the exponent, j-bit, and mantissa values to # 9765 # determine the type of operand. # 9766 # If it's an unnormalized zero, alter the operand and force it # 9767 # to be a normal zero. # 9768 # # 9769 ######################################################################### 9770 9771 global tag 9772 tag: 9773 mov.w FTEMP_EX(%a0), %d0 # extract exponent 9774 andi.w &0x7fff, %d0 # strip off sign 9775 cmpi.w %d0, &0x7fff # is (EXP == MAX)? 9776 beq.b inf_or_nan_x 9777 not_inf_or_nan_x: 9778 btst &0x7,FTEMP_HI(%a0) 9779 beq.b not_norm_x 9780 is_norm_x: 9781 mov.b &NORM, %d0 9782 rts 9783 not_norm_x: 9784 tst.w %d0 # is exponent = 0? 9785 bne.b is_unnorm_x 9786 not_unnorm_x: 9787 tst.l FTEMP_HI(%a0) 9788 bne.b is_denorm_x 9789 tst.l FTEMP_LO(%a0) 9790 bne.b is_denorm_x 9791 is_zero_x: 9792 mov.b &ZERO, %d0 9793 rts 9794 is_denorm_x: 9795 mov.b &DENORM, %d0 9796 rts 9797 is_unnorm_x: 9798 bsr.l unnorm_fix # convert to norm,denorm,or zero 9799 rts 9800 is_unnorm_reg_x: 9801 mov.b &UNNORM, %d0 9802 rts 9803 inf_or_nan_x: 9804 tst.l FTEMP_LO(%a0) 9805 bne.b is_nan_x 9806 mov.l FTEMP_HI(%a0), %d0 9807 and.l &0x7fffffff, %d0 # msb is a don't care! 9808 bne.b is_nan_x 9809 is_inf_x: 9810 mov.b &INF, %d0 9811 rts 9812 is_nan_x: 9813 mov.b &QNAN, %d0 9814 rts 9815 9816 ############################################################# 9817 9818 qnan: long 0x7fff0000, 0xffffffff, 0xffffffff 9819 9820 ######################################################################### 9821 # XDEF **************************************************************** # 9822 # t_dz(): Handle 060FPLSP dz exception for "flogn" emulation. # 9823 # t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation. # 9824 # # 9825 # These rouitnes are used by the 060FPLSP package. # 9826 # # 9827 # XREF **************************************************************** # 9828 # None # 9829 # # 9830 # INPUT *************************************************************** # 9831 # a0 = pointer to extended precision source operand. # 9832 # # 9833 # OUTPUT ************************************************************** # 9834 # fp0 = default DZ result. # 9835 # # 9836 # ALGORITHM *********************************************************** # 9837 # Transcendental emulation for the 060FPLSP has detected that # 9838 # a DZ exception should occur for the instruction. If DZ is disabled, # 9839 # return the default result. # 9840 # If DZ is enabled, the dst operand should be returned unscathed # 9841 # in fp0 while fp1 is used to create a DZ exception so that the # 9842 # operating system can log that such an event occurred. # 9843 # # 9844 ######################################################################### 9845 9846 global t_dz 9847 t_dz: 9848 tst.b SRC_EX(%a0) # check sign for neg or pos 9849 bpl.b dz_pinf # branch if pos sign 9850 9851 global t_dz2 9852 t_dz2: 9853 ori.l &dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZ 9854 9855 btst &dz_bit,FPCR_ENABLE(%a6) 9856 bne.b dz_minf_ena 9857 9858 # dz is disabled. return a -INF. 9859 fmov.s &0xff800000,%fp0 # return -INF 9860 rts 9861 9862 # dz is enabled. create a dz exception so the user can record it 9863 # but use fp1 instead. return the dst operand unscathed in fp0. 9864 dz_minf_ena: 9865 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed 9866 fmov.l USER_FPCR(%a6),%fpcr 9867 fmov.s &0xbf800000,%fp1 # load -1 9868 fdiv.s &0x00000000,%fp1 # -1 / 0 9869 rts 9870 9871 dz_pinf: 9872 ori.l &dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZ 9873 9874 btst &dz_bit,FPCR_ENABLE(%a6) 9875 bne.b dz_pinf_ena 9876 9877 # dz is disabled. return a +INF. 9878 fmov.s &0x7f800000,%fp0 # return +INF 9879 rts 9880 9881 # dz is enabled. create a dz exception so the user can record it 9882 # but use fp1 instead. return the dst operand unscathed in fp0. 9883 dz_pinf_ena: 9884 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed 9885 fmov.l USER_FPCR(%a6),%fpcr 9886 fmov.s &0x3f800000,%fp1 # load +1 9887 fdiv.s &0x00000000,%fp1 # +1 / 0 9888 rts 9889 9890 ######################################################################### 9891 # XDEF **************************************************************** # 9892 # t_operr(): Handle 060FPLSP OPERR exception during emulation. # 9893 # # 9894 # This routine is used by the 060FPLSP package. # 9895 # # 9896 # XREF **************************************************************** # 9897 # None. # 9898 # # 9899 # INPUT *************************************************************** # 9900 # fp1 = source operand # 9901 # # 9902 # OUTPUT ************************************************************** # 9903 # fp0 = default result # 9904 # fp1 = unchanged # 9905 # # 9906 # ALGORITHM *********************************************************** # 9907 # An operand error should occur as the result of transcendental # 9908 # emulation in the 060FPLSP. If OPERR is disabled, just return a NAN # 9909 # in fp0. If OPERR is enabled, return the dst operand unscathed in fp0 # 9910 # and the source operand in fp1. Use fp2 to create an OPERR exception # 9911 # so that the operating system can log the event. # 9912 # # 9913 ######################################################################### 9914 9915 global t_operr 9916 t_operr: 9917 ori.l &opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOP 9918 9919 btst &operr_bit,FPCR_ENABLE(%a6) 9920 bne.b operr_ena 9921 9922 # operr is disabled. return a QNAN in fp0 9923 fmovm.x qnan(%pc),&0x80 # return QNAN 9924 rts 9925 9926 # operr is enabled. create an operr exception so the user can record it 9927 # but use fp2 instead. return the dst operand unscathed in fp0. 9928 operr_ena: 9929 fmovm.x EXC_FP0(%a6),&0x80 # return fp0 unscathed 9930 fmov.l USER_FPCR(%a6),%fpcr 9931 fmovm.x &0x04,-(%sp) # save fp2 9932 fmov.s &0x7f800000,%fp2 # load +INF 9933 fmul.s &0x00000000,%fp2 # +INF x 0 9934 fmovm.x (%sp)+,&0x20 # restore fp2 9935 rts 9936 9937 pls_huge: 9938 long 0x7ffe0000,0xffffffff,0xffffffff 9939 mns_huge: 9940 long 0xfffe0000,0xffffffff,0xffffffff 9941 pls_tiny: 9942 long 0x00000000,0x80000000,0x00000000 9943 mns_tiny: 9944 long 0x80000000,0x80000000,0x00000000 9945 9946 ######################################################################### 9947 # XDEF **************************************************************** # 9948 # t_unfl(): Handle 060FPLSP underflow exception during emulation. # 9949 # t_unfl2(): Handle 060FPLSP underflow exception during # 9950 # emulation. result always positive. # 9951 # # 9952 # This routine is used by the 060FPLSP package. # 9953 # # 9954 # XREF **************************************************************** # 9955 # None. # 9956 # # 9957 # INPUT *************************************************************** # 9958 # a0 = pointer to extended precision source operand # 9959 # # 9960 # OUTPUT ************************************************************** # 9961 # fp0 = default underflow result # 9962 # # 9963 # ALGORITHM *********************************************************** # 9964 # An underflow should occur as the result of transcendental # 9965 # emulation in the 060FPLSP. Create an underflow by using "fmul" # 9966 # and two very small numbers of appropriate sign so the operating # 9967 # system can log the event. # 9968 # # 9969 ######################################################################### 9970 9971 global t_unfl 9972 t_unfl: 9973 tst.b SRC_EX(%a0) 9974 bpl.b unf_pos 9975 9976 global t_unfl2 9977 t_unfl2: 9978 ori.l &unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEX 9979 9980 fmov.l USER_FPCR(%a6),%fpcr 9981 fmovm.x mns_tiny(%pc),&0x80 9982 fmul.x pls_tiny(%pc),%fp0 9983 9984 fmov.l %fpsr,%d0 9985 rol.l &0x8,%d0 9986 mov.b %d0,FPSR_CC(%a6) 9987 rts 9988 unf_pos: 9989 ori.w &unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEX 9990 9991 fmov.l USER_FPCR(%a6),%fpcr 9992 fmovm.x pls_tiny(%pc),&0x80 9993 fmul.x %fp0,%fp0 9994 9995 fmov.l %fpsr,%d0 9996 rol.l &0x8,%d0 9997 mov.b %d0,FPSR_CC(%a6) 9998 rts 9999 10000 ######################################################################### 10001 # XDEF **************************************************************** # 10002 # t_ovfl(): Handle 060FPLSP overflow exception during emulation. # 10003 # (monadic) # 10004 # t_ovfl2(): Handle 060FPLSP overflow exception during # 10005 # emulation. result always positive. (dyadic) # 10006 # t_ovfl_sc(): Handle 060FPLSP overflow exception during # 10007 # emulation for "fscale". # 10008 # # 10009 # This routine is used by the 060FPLSP package. # 10010 # # 10011 # XREF **************************************************************** # 10012 # None. # 10013 # # 10014 # INPUT *************************************************************** # 10015 # a0 = pointer to extended precision source operand # 10016 # # 10017 # OUTPUT ************************************************************** # 10018 # fp0 = default underflow result # 10019 # # 10020 # ALGORITHM *********************************************************** # 10021 # An overflow should occur as the result of transcendental # 10022 # emulation in the 060FPLSP. Create an overflow by using "fmul" # 10023 # and two very lareg numbers of appropriate sign so the operating # 10024 # system can log the event. # 10025 # For t_ovfl_sc() we take special care not to lose the INEX2 bit. # 10026 # # 10027 ######################################################################### 10028 10029 global t_ovfl_sc 10030 t_ovfl_sc: 10031 ori.l &ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEX 10032 10033 mov.b %d0,%d1 # fetch rnd prec,mode 10034 andi.b &0xc0,%d1 # extract prec 10035 beq.w ovfl_work 10036 10037 # dst op is a DENORM. we have to normalize the mantissa to see if the 10038 # result would be inexact for the given precision. make a copy of the 10039 # dst so we don't screw up the version passed to us. 10040 mov.w LOCAL_EX(%a0),FP_SCR0_EX(%a6) 10041 mov.l LOCAL_HI(%a0),FP_SCR0_HI(%a6) 10042 mov.l LOCAL_LO(%a0),FP_SCR0_LO(%a6) 10043 lea FP_SCR0(%a6),%a0 # pass ptr to FP_SCR0 10044 movm.l &0xc080,-(%sp) # save d0-d1/a0 10045 bsr.l norm # normalize mantissa 10046 movm.l (%sp)+,&0x0103 # restore d0-d1/a0 10047 10048 cmpi.b %d1,&0x40 # is precision sgl? 10049 bne.b ovfl_sc_dbl # no; dbl 10050 ovfl_sc_sgl: 10051 tst.l LOCAL_LO(%a0) # is lo lw of sgl set? 10052 bne.b ovfl_sc_inx # yes 10053 tst.b 3+LOCAL_HI(%a0) # is lo byte of hi lw set? 10054 bne.b ovfl_sc_inx # yes 10055 bra.w ovfl_work # don't set INEX2 10056 ovfl_sc_dbl: 10057 mov.l LOCAL_LO(%a0),%d1 # are any of lo 11 bits of 10058 andi.l &0x7ff,%d1 # dbl mantissa set? 10059 beq.w ovfl_work # no; don't set INEX2 10060 ovfl_sc_inx: 10061 ori.l &inex2_mask,USER_FPSR(%a6) # set INEX2 10062 bra.b ovfl_work # continue 10063 10064 global t_ovfl 10065 t_ovfl: 10066 ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX 10067 ovfl_work: 10068 tst.b SRC_EX(%a0) 10069 bpl.b ovfl_p 10070 ovfl_m: 10071 fmov.l USER_FPCR(%a6),%fpcr 10072 fmovm.x mns_huge(%pc),&0x80 10073 fmul.x pls_huge(%pc),%fp0 10074 10075 fmov.l %fpsr,%d0 10076 rol.l &0x8,%d0 10077 ori.b &neg_mask,%d0 10078 mov.b %d0,FPSR_CC(%a6) 10079 rts 10080 ovfl_p: 10081 fmov.l USER_FPCR(%a6),%fpcr 10082 fmovm.x pls_huge(%pc),&0x80 10083 fmul.x pls_huge(%pc),%fp0 10084 10085 fmov.l %fpsr,%d0 10086 rol.l &0x8,%d0 10087 mov.b %d0,FPSR_CC(%a6) 10088 rts 10089 10090 global t_ovfl2 10091 t_ovfl2: 10092 ori.w &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX 10093 fmov.l USER_FPCR(%a6),%fpcr 10094 fmovm.x pls_huge(%pc),&0x80 10095 fmul.x pls_huge(%pc),%fp0 10096 10097 fmov.l %fpsr,%d0 10098 rol.l &0x8,%d0 10099 mov.b %d0,FPSR_CC(%a6) 10100 rts 10101 10102 ######################################################################### 10103 # XDEF **************************************************************** # 10104 # t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during # 10105 # emulation. # 10106 # t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during # 10107 # emulation. # 10108 # # 10109 # These routines are used by the 060FPLSP package. # 10110 # # 10111 # XREF **************************************************************** # 10112 # None. # 10113 # # 10114 # INPUT *************************************************************** # 10115 # fp0 = default underflow or overflow result # 10116 # # 10117 # OUTPUT ************************************************************** # 10118 # fp0 = default result # 10119 # # 10120 # ALGORITHM *********************************************************** # 10121 # If an overflow or underflow occurred during the last # 10122 # instruction of transcendental 060FPLSP emulation, then it has already # 10123 # occurred and has been logged. Now we need to see if an inexact # 10124 # exception should occur. # 10125 # # 10126 ######################################################################### 10127 10128 global t_catch2 10129 t_catch2: 10130 fmov.l %fpsr,%d0 10131 or.l %d0,USER_FPSR(%a6) 10132 bra.b inx2_work 10133 10134 global t_catch 10135 t_catch: 10136 fmov.l %fpsr,%d0 10137 or.l %d0,USER_FPSR(%a6) 10138 10139 ######################################################################### 10140 # XDEF **************************************************************** # 10141 # t_inx2(): Handle inexact 060FPLSP exception during emulation. # 10142 # t_pinx2(): Handle inexact 060FPLSP exception for "+" results. # 10143 # t_minx2(): Handle inexact 060FPLSP exception for "-" results. # 10144 # # 10145 # XREF **************************************************************** # 10146 # None. # 10147 # # 10148 # INPUT *************************************************************** # 10149 # fp0 = default result # 10150 # # 10151 # OUTPUT ************************************************************** # 10152 # fp0 = default result # 10153 # # 10154 # ALGORITHM *********************************************************** # 10155 # The last instruction of transcendental emulation for the # 10156 # 060FPLSP should be inexact. So, if inexact is enabled, then we create # 10157 # the event here by adding a large and very small number together # 10158 # so that the operating system can log the event. # 10159 # Must check, too, if the result was zero, in which case we just # 10160 # set the FPSR bits and return. # 10161 # # 10162 ######################################################################### 10163 10164 global t_inx2 10165 t_inx2: 10166 fblt.w t_minx2 10167 fbeq.w inx2_zero 10168 10169 global t_pinx2 10170 t_pinx2: 10171 ori.w &inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX 10172 bra.b inx2_work 10173 10174 global t_minx2 10175 t_minx2: 10176 ori.l &inx2a_mask+neg_mask,USER_FPSR(%a6) 10177 10178 inx2_work: 10179 btst &inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled? 10180 bne.b inx2_work_ena # yes 10181 rts 10182 inx2_work_ena: 10183 fmov.l USER_FPCR(%a6),%fpcr # insert user's exceptions 10184 fmov.s &0x3f800000,%fp1 # load +1 10185 fadd.x pls_tiny(%pc),%fp1 # cause exception 10186 rts 10187 10188 inx2_zero: 10189 mov.b &z_bmask,FPSR_CC(%a6) 10190 ori.w &inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEX 10191 rts 10192 10193 ######################################################################### 10194 # XDEF **************************************************************** # 10195 # t_extdnrm(): Handle DENORM inputs in 060FPLSP. # 10196 # t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale". # 10197 # # 10198 # This routine is used by the 060FPLSP package. # 10199 # # 10200 # XREF **************************************************************** # 10201 # None. # 10202 # # 10203 # INPUT *************************************************************** # 10204 # a0 = pointer to extended precision input operand # 10205 # # 10206 # OUTPUT ************************************************************** # 10207 # fp0 = default result # 10208 # # 10209 # ALGORITHM *********************************************************** # 10210 # For all functions that have a denormalized input and that # 10211 # f(x)=x, this is the entry point. # 10212 # DENORM value is moved using "fmove" which triggers an exception # 10213 # if enabled so the operating system can log the event. # 10214 # # 10215 ######################################################################### 10216 10217 global t_extdnrm 10218 t_extdnrm: 10219 fmov.l USER_FPCR(%a6),%fpcr 10220 fmov.x SRC_EX(%a0),%fp0 10221 fmov.l %fpsr,%d0 10222 ori.l &unfinx_mask,%d0 10223 or.l %d0,USER_FPSR(%a6) 10224 rts 10225 10226 global t_resdnrm 10227 t_resdnrm: 10228 fmov.l USER_FPCR(%a6),%fpcr 10229 fmov.x SRC_EX(%a0),%fp0 10230 fmov.l %fpsr,%d0 10231 or.l %d0,USER_FPSR(%a6) 10232 rts 10233 10234 ########################################## 10235 10236 # 10237 # sto_cos: 10238 # This is used by fsincos library emulation. The correct 10239 # values are already in fp0 and fp1 so we do nothing here. 10240 # 10241 global sto_cos 10242 sto_cos: 10243 rts 10244 10245 ########################################## 10246 10247 # 10248 # dst_qnan --- force result when destination is a NaN 10249 # 10250 global dst_qnan 10251 dst_qnan: 10252 fmov.x DST(%a1),%fp0 10253 tst.b DST_EX(%a1) 10254 bmi.b dst_qnan_m 10255 dst_qnan_p: 10256 mov.b &nan_bmask,FPSR_CC(%a6) 10257 rts 10258 dst_qnan_m: 10259 mov.b &nan_bmask+neg_bmask,FPSR_CC(%a6) 10260 rts 10261 10262 # 10263 # src_qnan --- force result when source is a NaN 10264 # 10265 global src_qnan 10266 src_qnan: 10267 fmov.x SRC(%a0),%fp0 10268 tst.b SRC_EX(%a0) 10269 bmi.b src_qnan_m 10270 src_qnan_p: 10271 mov.b &nan_bmask,FPSR_CC(%a6) 10272 rts 10273 src_qnan_m: 10274 mov.b &nan_bmask+neg_bmask,FPSR_CC(%a6) 10275 rts 10276 10277 ########################################## 10278 10279 # 10280 # Native instruction support 10281 # 10282 # Some systems may need entry points even for 68060 native 10283 # instructions. These routines are provided for 10284 # convenience. 10285 # 10286 global _fadds_ 10287 _fadds_: 10288 fmov.l %fpcr,-(%sp) # save fpcr 10289 fmov.l &0x00000000,%fpcr # clear fpcr for load 10290 fmov.s 0x8(%sp),%fp0 # load sgl dst 10291 fmov.l (%sp)+,%fpcr # restore fpcr 10292 fadd.s 0x8(%sp),%fp0 # fadd w/ sgl src 10293 rts 10294 10295 global _faddd_ 10296 _faddd_: 10297 fmov.l %fpcr,-(%sp) # save fpcr 10298 fmov.l &0x00000000,%fpcr # clear fpcr for load 10299 fmov.d 0x8(%sp),%fp0 # load dbl dst 10300 fmov.l (%sp)+,%fpcr # restore fpcr 10301 fadd.d 0xc(%sp),%fp0 # fadd w/ dbl src 10302 rts 10303 10304 global _faddx_ 10305 _faddx_: 10306 fmovm.x 0x4(%sp),&0x80 # load ext dst 10307 fadd.x 0x10(%sp),%fp0 # fadd w/ ext src 10308 rts 10309 10310 global _fsubs_ 10311 _fsubs_: 10312 fmov.l %fpcr,-(%sp) # save fpcr 10313 fmov.l &0x00000000,%fpcr # clear fpcr for load 10314 fmov.s 0x8(%sp),%fp0 # load sgl dst 10315 fmov.l (%sp)+,%fpcr # restore fpcr 10316 fsub.s 0x8(%sp),%fp0 # fsub w/ sgl src 10317 rts 10318 10319 global _fsubd_ 10320 _fsubd_: 10321 fmov.l %fpcr,-(%sp) # save fpcr 10322 fmov.l &0x00000000,%fpcr # clear fpcr for load 10323 fmov.d 0x8(%sp),%fp0 # load dbl dst 10324 fmov.l (%sp)+,%fpcr # restore fpcr 10325 fsub.d 0xc(%sp),%fp0 # fsub w/ dbl src 10326 rts 10327 10328 global _fsubx_ 10329 _fsubx_: 10330 fmovm.x 0x4(%sp),&0x80 # load ext dst 10331 fsub.x 0x10(%sp),%fp0 # fsub w/ ext src 10332 rts 10333 10334 global _fmuls_ 10335 _fmuls_: 10336 fmov.l %fpcr,-(%sp) # save fpcr 10337 fmov.l &0x00000000,%fpcr # clear fpcr for load 10338 fmov.s 0x8(%sp),%fp0 # load sgl dst 10339 fmov.l (%sp)+,%fpcr # restore fpcr 10340 fmul.s 0x8(%sp),%fp0 # fmul w/ sgl src 10341 rts 10342 10343 global _fmuld_ 10344 _fmuld_: 10345 fmov.l %fpcr,-(%sp) # save fpcr 10346 fmov.l &0x00000000,%fpcr # clear fpcr for load 10347 fmov.d 0x8(%sp),%fp0 # load dbl dst 10348 fmov.l (%sp)+,%fpcr # restore fpcr 10349 fmul.d 0xc(%sp),%fp0 # fmul w/ dbl src 10350 rts 10351 10352 global _fmulx_ 10353 _fmulx_: 10354 fmovm.x 0x4(%sp),&0x80 # load ext dst 10355 fmul.x 0x10(%sp),%fp0 # fmul w/ ext src 10356 rts 10357 10358 global _fdivs_ 10359 _fdivs_: 10360 fmov.l %fpcr,-(%sp) # save fpcr 10361 fmov.l &0x00000000,%fpcr # clear fpcr for load 10362 fmov.s 0x8(%sp),%fp0 # load sgl dst 10363 fmov.l (%sp)+,%fpcr # restore fpcr 10364 fdiv.s 0x8(%sp),%fp0 # fdiv w/ sgl src 10365 rts 10366 10367 global _fdivd_ 10368 _fdivd_: 10369 fmov.l %fpcr,-(%sp) # save fpcr 10370 fmov.l &0x00000000,%fpcr # clear fpcr for load 10371 fmov.d 0x8(%sp),%fp0 # load dbl dst 10372 fmov.l (%sp)+,%fpcr # restore fpcr 10373 fdiv.d 0xc(%sp),%fp0 # fdiv w/ dbl src 10374 rts 10375 10376 global _fdivx_ 10377 _fdivx_: 10378 fmovm.x 0x4(%sp),&0x80 # load ext dst 10379 fdiv.x 0x10(%sp),%fp0 # fdiv w/ ext src 10380 rts 10381 10382 global _fabss_ 10383 _fabss_: 10384 fabs.s 0x4(%sp),%fp0 # fabs w/ sgl src 10385 rts 10386 10387 global _fabsd_ 10388 _fabsd_: 10389 fabs.d 0x4(%sp),%fp0 # fabs w/ dbl src 10390 rts 10391 10392 global _fabsx_ 10393 _fabsx_: 10394 fabs.x 0x4(%sp),%fp0 # fabs w/ ext src 10395 rts 10396 10397 global _fnegs_ 10398 _fnegs_: 10399 fneg.s 0x4(%sp),%fp0 # fneg w/ sgl src 10400 rts 10401 10402 global _fnegd_ 10403 _fnegd_: 10404 fneg.d 0x4(%sp),%fp0 # fneg w/ dbl src 10405 rts 10406 10407 global _fnegx_ 10408 _fnegx_: 10409 fneg.x 0x4(%sp),%fp0 # fneg w/ ext src 10410 rts 10411 10412 global _fsqrts_ 10413 _fsqrts_: 10414 fsqrt.s 0x4(%sp),%fp0 # fsqrt w/ sgl src 10415 rts 10416 10417 global _fsqrtd_ 10418 _fsqrtd_: 10419 fsqrt.d 0x4(%sp),%fp0 # fsqrt w/ dbl src 10420 rts 10421 10422 global _fsqrtx_ 10423 _fsqrtx_: 10424 fsqrt.x 0x4(%sp),%fp0 # fsqrt w/ ext src 10425 rts 10426 10427 global _fints_ 10428 _fints_: 10429 fint.s 0x4(%sp),%fp0 # fint w/ sgl src 10430 rts 10431 10432 global _fintd_ 10433 _fintd_: 10434 fint.d 0x4(%sp),%fp0 # fint w/ dbl src 10435 rts 10436 10437 global _fintx_ 10438 _fintx_: 10439 fint.x 0x4(%sp),%fp0 # fint w/ ext src 10440 rts 10441 10442 global _fintrzs_ 10443 _fintrzs_: 10444 fintrz.s 0x4(%sp),%fp0 # fintrz w/ sgl src 10445 rts 10446 10447 global _fintrzd_ 10448 _fintrzd_: 10449 fintrz.d 0x4(%sp),%fp0 # fintrx w/ dbl src 10450 rts 10451 10452 global _fintrzx_ 10453 _fintrzx_: 10454 fintrz.x 0x4(%sp),%fp0 # fintrz w/ ext src 10455 rts 10456 10457 ######################################################################## 10458 10459 ######################################################################### 10460 # src_zero(): Return signed zero according to sign of src operand. # 10461 ######################################################################### 10462 global src_zero 10463 src_zero: 10464 tst.b SRC_EX(%a0) # get sign of src operand 10465 bmi.b ld_mzero # if neg, load neg zero 10466 10467 # 10468 # ld_pzero(): return a positive zero. 10469 # 10470 global ld_pzero 10471 ld_pzero: 10472 fmov.s &0x00000000,%fp0 # load +0 10473 mov.b &z_bmask,FPSR_CC(%a6) # set 'Z' ccode bit 10474 rts 10475 10476 # ld_mzero(): return a negative zero. 10477 global ld_mzero 10478 ld_mzero: 10479 fmov.s &0x80000000,%fp0 # load -0 10480 mov.b &neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bits 10481 rts 10482 10483 ######################################################################### 10484 # dst_zero(): Return signed zero according to sign of dst operand. # 10485 ######################################################################### 10486 global dst_zero 10487 dst_zero: 10488 tst.b DST_EX(%a1) # get sign of dst operand 10489 bmi.b ld_mzero # if neg, load neg zero 10490 bra.b ld_pzero # load positive zero 10491 10492 ######################################################################### 10493 # src_inf(): Return signed inf according to sign of src operand. # 10494 ######################################################################### 10495 global src_inf 10496 src_inf: 10497 tst.b SRC_EX(%a0) # get sign of src operand 10498 bmi.b ld_minf # if negative branch 10499 10500 # 10501 # ld_pinf(): return a positive infinity. 10502 # 10503 global ld_pinf 10504 ld_pinf: 10505 fmov.s &0x7f800000,%fp0 # load +INF 10506 mov.b &inf_bmask,FPSR_CC(%a6) # set 'INF' ccode bit 10507 rts 10508 10509 # 10510 # ld_minf():return a negative infinity. 10511 # 10512 global ld_minf 10513 ld_minf: 10514 fmov.s &0xff800000,%fp0 # load -INF 10515 mov.b &neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bits 10516 rts 10517 10518 ######################################################################### 10519 # dst_inf(): Return signed inf according to sign of dst operand. # 10520 ######################################################################### 10521 global dst_inf 10522 dst_inf: 10523 tst.b DST_EX(%a1) # get sign of dst operand 10524 bmi.b ld_minf # if negative branch 10525 bra.b ld_pinf 10526 10527 global szr_inf 10528 ################################################################# 10529 # szr_inf(): Return +ZERO for a negative src operand or # 10530 # +INF for a positive src operand. # 10531 # Routine used for fetox, ftwotox, and ftentox. # 10532 ################################################################# 10533 szr_inf: 10534 tst.b SRC_EX(%a0) # check sign of source 10535 bmi.b ld_pzero 10536 bra.b ld_pinf 10537 10538 ######################################################################### 10539 # sopr_inf(): Return +INF for a positive src operand or # 10540 # jump to operand error routine for a negative src operand. # 10541 # Routine used for flogn, flognp1, flog10, and flog2. # 10542 ######################################################################### 10543 global sopr_inf 10544 sopr_inf: 10545 tst.b SRC_EX(%a0) # check sign of source 10546 bmi.w t_operr 10547 bra.b ld_pinf 10548 10549 ################################################################# 10550 # setoxm1i(): Return minus one for a negative src operand or # 10551 # positive infinity for a positive src operand. # 10552 # Routine used for fetoxm1. # 10553 ################################################################# 10554 global setoxm1i 10555 setoxm1i: 10556 tst.b SRC_EX(%a0) # check sign of source 10557 bmi.b ld_mone 10558 bra.b ld_pinf 10559 10560 ######################################################################### 10561 # src_one(): Return signed one according to sign of src operand. # 10562 ######################################################################### 10563 global src_one 10564 src_one: 10565 tst.b SRC_EX(%a0) # check sign of source 10566 bmi.b ld_mone 10567 10568 # 10569 # ld_pone(): return positive one. 10570 # 10571 global ld_pone 10572 ld_pone: 10573 fmov.s &0x3f800000,%fp0 # load +1 10574 clr.b FPSR_CC(%a6) 10575 rts 10576 10577 # 10578 # ld_mone(): return negative one. 10579 # 10580 global ld_mone 10581 ld_mone: 10582 fmov.s &0xbf800000,%fp0 # load -1 10583 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit 10584 rts 10585 10586 ppiby2: long 0x3fff0000, 0xc90fdaa2, 0x2168c235 10587 mpiby2: long 0xbfff0000, 0xc90fdaa2, 0x2168c235 10588 10589 ################################################################# 10590 # spi_2(): Return signed PI/2 according to sign of src operand. # 10591 ################################################################# 10592 global spi_2 10593 spi_2: 10594 tst.b SRC_EX(%a0) # check sign of source 10595 bmi.b ld_mpi2 10596 10597 # 10598 # ld_ppi2(): return positive PI/2. 10599 # 10600 global ld_ppi2 10601 ld_ppi2: 10602 fmov.l %d0,%fpcr 10603 fmov.x ppiby2(%pc),%fp0 # load +pi/2 10604 bra.w t_pinx2 # set INEX2 10605 10606 # 10607 # ld_mpi2(): return negative PI/2. 10608 # 10609 global ld_mpi2 10610 ld_mpi2: 10611 fmov.l %d0,%fpcr 10612 fmov.x mpiby2(%pc),%fp0 # load -pi/2 10613 bra.w t_minx2 # set INEX2 10614 10615 #################################################### 10616 # The following routines give support for fsincos. # 10617 #################################################### 10618 10619 # 10620 # ssincosz(): When the src operand is ZERO, store a one in the 10621 # cosine register and return a ZERO in fp0 w/ the same sign 10622 # as the src operand. 10623 # 10624 global ssincosz 10625 ssincosz: 10626 fmov.s &0x3f800000,%fp1 10627 tst.b SRC_EX(%a0) # test sign 10628 bpl.b sincoszp 10629 fmov.s &0x80000000,%fp0 # return sin result in fp0 10630 mov.b &z_bmask+neg_bmask,FPSR_CC(%a6) 10631 rts 10632 sincoszp: 10633 fmov.s &0x00000000,%fp0 # return sin result in fp0 10634 mov.b &z_bmask,FPSR_CC(%a6) 10635 rts 10636 10637 # 10638 # ssincosi(): When the src operand is INF, store a QNAN in the cosine 10639 # register and jump to the operand error routine for negative 10640 # src operands. 10641 # 10642 global ssincosi 10643 ssincosi: 10644 fmov.x qnan(%pc),%fp1 # load NAN 10645 bra.w t_operr 10646 10647 # 10648 # ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine 10649 # register and branch to the src QNAN routine. 10650 # 10651 global ssincosqnan 10652 ssincosqnan: 10653 fmov.x LOCAL_EX(%a0),%fp1 10654 bra.w src_qnan 10655 10656 ######################################################################## 10657 10658 global smod_sdnrm 10659 global smod_snorm 10660 smod_sdnrm: 10661 smod_snorm: 10662 mov.b DTAG(%a6),%d1 10663 beq.l smod 10664 cmpi.b %d1,&ZERO 10665 beq.w smod_zro 10666 cmpi.b %d1,&INF 10667 beq.l t_operr 10668 cmpi.b %d1,&DENORM 10669 beq.l smod 10670 bra.l dst_qnan 10671 10672 global smod_szero 10673 smod_szero: 10674 mov.b DTAG(%a6),%d1 10675 beq.l t_operr 10676 cmpi.b %d1,&ZERO 10677 beq.l t_operr 10678 cmpi.b %d1,&INF 10679 beq.l t_operr 10680 cmpi.b %d1,&DENORM 10681 beq.l t_operr 10682 bra.l dst_qnan 10683 10684 global smod_sinf 10685 smod_sinf: 10686 mov.b DTAG(%a6),%d1 10687 beq.l smod_fpn 10688 cmpi.b %d1,&ZERO 10689 beq.l smod_zro 10690 cmpi.b %d1,&INF 10691 beq.l t_operr 10692 cmpi.b %d1,&DENORM 10693 beq.l smod_fpn 10694 bra.l dst_qnan 10695 10696 smod_zro: 10697 srem_zro: 10698 mov.b SRC_EX(%a0),%d1 # get src sign 10699 mov.b DST_EX(%a1),%d0 # get dst sign 10700 eor.b %d0,%d1 # get qbyte sign 10701 andi.b &0x80,%d1 10702 mov.b %d1,FPSR_QBYTE(%a6) 10703 tst.b %d0 10704 bpl.w ld_pzero 10705 bra.w ld_mzero 10706 10707 smod_fpn: 10708 srem_fpn: 10709 clr.b FPSR_QBYTE(%a6) 10710 mov.l %d0,-(%sp) 10711 mov.b SRC_EX(%a0),%d1 # get src sign 10712 mov.b DST_EX(%a1),%d0 # get dst sign 10713 eor.b %d0,%d1 # get qbyte sign 10714 andi.b &0x80,%d1 10715 mov.b %d1,FPSR_QBYTE(%a6) 10716 cmpi.b DTAG(%a6),&DENORM 10717 bne.b smod_nrm 10718 lea DST(%a1),%a0 10719 mov.l (%sp)+,%d0 10720 bra t_resdnrm 10721 smod_nrm: 10722 fmov.l (%sp)+,%fpcr 10723 fmov.x DST(%a1),%fp0 10724 tst.b DST_EX(%a1) 10725 bmi.b smod_nrm_neg 10726 rts 10727 10728 smod_nrm_neg: 10729 mov.b &neg_bmask,FPSR_CC(%a6) # set 'N' code 10730 rts 10731 10732 ######################################################################### 10733 global srem_snorm 10734 global srem_sdnrm 10735 srem_sdnrm: 10736 srem_snorm: 10737 mov.b DTAG(%a6),%d1 10738 beq.l srem 10739 cmpi.b %d1,&ZERO 10740 beq.w srem_zro 10741 cmpi.b %d1,&INF 10742 beq.l t_operr 10743 cmpi.b %d1,&DENORM 10744 beq.l srem 10745 bra.l dst_qnan 10746 10747 global srem_szero 10748 srem_szero: 10749 mov.b DTAG(%a6),%d1 10750 beq.l t_operr 10751 cmpi.b %d1,&ZERO 10752 beq.l t_operr 10753 cmpi.b %d1,&INF 10754 beq.l t_operr 10755 cmpi.b %d1,&DENORM 10756 beq.l t_operr 10757 bra.l dst_qnan 10758 10759 global srem_sinf 10760 srem_sinf: 10761 mov.b DTAG(%a6),%d1 10762 beq.w srem_fpn 10763 cmpi.b %d1,&ZERO 10764 beq.w srem_zro 10765 cmpi.b %d1,&INF 10766 beq.l t_operr 10767 cmpi.b %d1,&DENORM 10768 beq.l srem_fpn 10769 bra.l dst_qnan 10770 10771 ######################################################################### 10772 10773 global sscale_snorm 10774 global sscale_sdnrm 10775 sscale_snorm: 10776 sscale_sdnrm: 10777 mov.b DTAG(%a6),%d1 10778 beq.l sscale 10779 cmpi.b %d1,&ZERO 10780 beq.l dst_zero 10781 cmpi.b %d1,&INF 10782 beq.l dst_inf 10783 cmpi.b %d1,&DENORM 10784 beq.l sscale 10785 bra.l dst_qnan 10786 10787 global sscale_szero 10788 sscale_szero: 10789 mov.b DTAG(%a6),%d1 10790 beq.l sscale 10791 cmpi.b %d1,&ZERO 10792 beq.l dst_zero 10793 cmpi.b %d1,&INF 10794 beq.l dst_inf 10795 cmpi.b %d1,&DENORM 10796 beq.l sscale 10797 bra.l dst_qnan 10798 10799 global sscale_sinf 10800 sscale_sinf: 10801 mov.b DTAG(%a6),%d1 10802 beq.l t_operr 10803 cmpi.b %d1,&QNAN 10804 beq.l dst_qnan 10805 bra.l t_operr 10806 10807 ######################################################################## 10808 10809 global sop_sqnan 10810 sop_sqnan: 10811 mov.b DTAG(%a6),%d1 10812 cmpi.b %d1,&QNAN 10813 beq.l dst_qnan 10814 bra.l src_qnan 10815 10816 ######################################################################### 10817 # norm(): normalize the mantissa of an extended precision input. the # 10818 # input operand should not be normalized already. # 10819 # # 10820 # XDEF **************************************************************** # 10821 # norm() # 10822 # # 10823 # XREF **************************************************************** # 10824 # none # 10825 # # 10826 # INPUT *************************************************************** # 10827 # a0 = pointer fp extended precision operand to normalize # 10828 # # 10829 # OUTPUT ************************************************************** # 10830 # d0 = number of bit positions the mantissa was shifted # 10831 # a0 = the input operand's mantissa is normalized; the exponent # 10832 # is unchanged. # 10833 # # 10834 ######################################################################### 10835 global norm 10836 norm: 10837 mov.l %d2, -(%sp) # create some temp regs 10838 mov.l %d3, -(%sp) 10839 10840 mov.l FTEMP_HI(%a0), %d0 # load hi(mantissa) 10841 mov.l FTEMP_LO(%a0), %d1 # load lo(mantissa) 10842 10843 bfffo %d0{&0:&32}, %d2 # how many places to shift? 10844 beq.b norm_lo # hi(man) is all zeroes! 10845 10846 norm_hi: 10847 lsl.l %d2, %d0 # left shift hi(man) 10848 bfextu %d1{&0:%d2}, %d3 # extract lo bits 10849 10850 or.l %d3, %d0 # create hi(man) 10851 lsl.l %d2, %d1 # create lo(man) 10852 10853 mov.l %d0, FTEMP_HI(%a0) # store new hi(man) 10854 mov.l %d1, FTEMP_LO(%a0) # store new lo(man) 10855 10856 mov.l %d2, %d0 # return shift amount 10857 10858 mov.l (%sp)+, %d3 # restore temp regs 10859 mov.l (%sp)+, %d2 10860 10861 rts 10862 10863 norm_lo: 10864 bfffo %d1{&0:&32}, %d2 # how many places to shift? 10865 lsl.l %d2, %d1 # shift lo(man) 10866 add.l &32, %d2 # add 32 to shft amount 10867 10868 mov.l %d1, FTEMP_HI(%a0) # store hi(man) 10869 clr.l FTEMP_LO(%a0) # lo(man) is now zero 10870 10871 mov.l %d2, %d0 # return shift amount 10872 10873 mov.l (%sp)+, %d3 # restore temp regs 10874 mov.l (%sp)+, %d2 10875 10876 rts 10877 10878 ######################################################################### 10879 # unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO # 10880 # - returns corresponding optype tag # 10881 # # 10882 # XDEF **************************************************************** # 10883 # unnorm_fix() # 10884 # # 10885 # XREF **************************************************************** # 10886 # norm() - normalize the mantissa # 10887 # # 10888 # INPUT *************************************************************** # 10889 # a0 = pointer to unnormalized extended precision number # 10890 # # 10891 # OUTPUT ************************************************************** # 10892 # d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO # 10893 # a0 = input operand has been converted to a norm, denorm, or # 10894 # zero; both the exponent and mantissa are changed. # 10895 # # 10896 ######################################################################### 10897 10898 global unnorm_fix 10899 unnorm_fix: 10900 bfffo FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed? 10901 bne.b unnorm_shift # hi(man) is not all zeroes 10902 10903 # 10904 # hi(man) is all zeroes so see if any bits in lo(man) are set 10905 # 10906 unnorm_chk_lo: 10907 bfffo FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero? 10908 beq.w unnorm_zero # yes 10909 10910 add.w &32, %d0 # no; fix shift distance 10911 10912 # 10913 # d0 = # shifts needed for complete normalization 10914 # 10915 unnorm_shift: 10916 clr.l %d1 # clear top word 10917 mov.w FTEMP_EX(%a0), %d1 # extract exponent 10918 and.w &0x7fff, %d1 # strip off sgn 10919 10920 cmp.w %d0, %d1 # will denorm push exp < 0? 10921 bgt.b unnorm_nrm_zero # yes; denorm only until exp = 0 10922 10923 # 10924 # exponent would not go < 0. therefore, number stays normalized 10925 # 10926 sub.w %d0, %d1 # shift exponent value 10927 mov.w FTEMP_EX(%a0), %d0 # load old exponent 10928 and.w &0x8000, %d0 # save old sign 10929 or.w %d0, %d1 # {sgn,new exp} 10930 mov.w %d1, FTEMP_EX(%a0) # insert new exponent 10931 10932 bsr.l norm # normalize UNNORM 10933 10934 mov.b &NORM, %d0 # return new optype tag 10935 rts 10936 10937 # 10938 # exponent would go < 0, so only denormalize until exp = 0 10939 # 10940 unnorm_nrm_zero: 10941 cmp.b %d1, &32 # is exp <= 32? 10942 bgt.b unnorm_nrm_zero_lrg # no; go handle large exponent 10943 10944 bfextu FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man) 10945 mov.l %d0, FTEMP_HI(%a0) # save new hi(man) 10946 10947 mov.l FTEMP_LO(%a0), %d0 # fetch old lo(man) 10948 lsl.l %d1, %d0 # extract new lo(man) 10949 mov.l %d0, FTEMP_LO(%a0) # save new lo(man) 10950 10951 and.w &0x8000, FTEMP_EX(%a0) # set exp = 0 10952 10953 mov.b &DENORM, %d0 # return new optype tag 10954 rts 10955 10956 # 10957 # only mantissa bits set are in lo(man) 10958 # 10959 unnorm_nrm_zero_lrg: 10960 sub.w &32, %d1 # adjust shft amt by 32 10961 10962 mov.l FTEMP_LO(%a0), %d0 # fetch old lo(man) 10963 lsl.l %d1, %d0 # left shift lo(man) 10964 10965 mov.l %d0, FTEMP_HI(%a0) # store new hi(man) 10966 clr.l FTEMP_LO(%a0) # lo(man) = 0 10967 10968 and.w &0x8000, FTEMP_EX(%a0) # set exp = 0 10969 10970 mov.b &DENORM, %d0 # return new optype tag 10971 rts 10972 10973 # 10974 # whole mantissa is zero so this UNNORM is actually a zero 10975 # 10976 unnorm_zero: 10977 and.w &0x8000, FTEMP_EX(%a0) # force exponent to zero 10978 10979 mov.b &ZERO, %d0 # fix optype tag 10980 rts 10981