LXR linux/arch/m68k/ifpsp060/src/fplsp.S

   1~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   2MOTOROLA MICROPROCESSOR & MEMORY TECHNOLOGY GROUP
   3M68000 Hi-Performance Microprocessor Division
   4M68060 Software Package
   5Production Release P1.00 -- October 10, 1994
   6
   7M68060 Software Package Copyright © 1993, 1994 Motorola Inc.  All rights reserved.
   8
   9THE SOFTWARE is provided on an "AS IS" basis and without warranty.
  10To the maximum extent permitted by applicable law,
  11MOTOROLA DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED,
  12INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  13and any warranty against infringement with regard to the SOFTWARE
  14(INCLUDING ANY MODIFIED VERSIONS THEREOF) and any accompanying written materials.
  15
  16To the maximum extent permitted by applicable law,
  17IN NO EVENT SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER
  18(INCLUDING WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
  19BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS)
  20ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE.
  21Motorola assumes no responsibility for the maintenance and support of the SOFTWARE.
  22
  23You are hereby granted a copyright license to use, modify, and distribute the SOFTWARE
  24so long as this entire notice is retained without alteration in any modified and/or
  25redistributed versions, and that such modified versions are clearly identified as such.
  26No licenses are granted by implication, estoppel or otherwise under any patents
  27or trademarks of Motorola, Inc.
  28~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  29#
  30# lfptop.s:
  31#       This file is appended to the top of the 060ILSP package
  32# and contains the entry points into the package. The user, in
  33# effect, branches to one of the branch table entries located here.
  34#
  35
  36        bra.l   _facoss_
  37        short   0x0000
  38        bra.l   _facosd_
  39        short   0x0000
  40        bra.l   _facosx_
  41        short   0x0000
  42
  43        bra.l   _fasins_
  44        short   0x0000
  45        bra.l   _fasind_
  46        short   0x0000
  47        bra.l   _fasinx_
  48        short   0x0000
  49
  50        bra.l   _fatans_
  51        short   0x0000
  52        bra.l   _fatand_
  53        short   0x0000
  54        bra.l   _fatanx_
  55        short   0x0000
  56
  57        bra.l   _fatanhs_
  58        short   0x0000
  59        bra.l   _fatanhd_
  60        short   0x0000
  61        bra.l   _fatanhx_
  62        short   0x0000
  63
  64        bra.l   _fcoss_
  65        short   0x0000
  66        bra.l   _fcosd_
  67        short   0x0000
  68        bra.l   _fcosx_
  69        short   0x0000
  70
  71        bra.l   _fcoshs_
  72        short   0x0000
  73        bra.l   _fcoshd_
  74        short   0x0000
  75        bra.l   _fcoshx_
  76        short   0x0000
  77
  78        bra.l   _fetoxs_
  79        short   0x0000
  80        bra.l   _fetoxd_
  81        short   0x0000
  82        bra.l   _fetoxx_
  83        short   0x0000
  84
  85        bra.l   _fetoxm1s_
  86        short   0x0000
  87        bra.l   _fetoxm1d_
  88        short   0x0000
  89        bra.l   _fetoxm1x_
  90        short   0x0000
  91
  92        bra.l   _fgetexps_
  93        short   0x0000
  94        bra.l   _fgetexpd_
  95        short   0x0000
  96        bra.l   _fgetexpx_
  97        short   0x0000
  98
  99        bra.l   _fgetmans_
 100        short   0x0000
 101        bra.l   _fgetmand_
 102        short   0x0000
 103        bra.l   _fgetmanx_
 104        short   0x0000
 105
 106        bra.l   _flog10s_
 107        short   0x0000
 108        bra.l   _flog10d_
 109        short   0x0000
 110        bra.l   _flog10x_
 111        short   0x0000
 112
 113        bra.l   _flog2s_
 114        short   0x0000
 115        bra.l   _flog2d_
 116        short   0x0000
 117        bra.l   _flog2x_
 118        short   0x0000
 119
 120        bra.l   _flogns_
 121        short   0x0000
 122        bra.l   _flognd_
 123        short   0x0000
 124        bra.l   _flognx_
 125        short   0x0000
 126
 127        bra.l   _flognp1s_
 128        short   0x0000
 129        bra.l   _flognp1d_
 130        short   0x0000
 131        bra.l   _flognp1x_
 132        short   0x0000
 133
 134        bra.l   _fmods_
 135        short   0x0000
 136        bra.l   _fmodd_
 137        short   0x0000
 138        bra.l   _fmodx_
 139        short   0x0000
 140
 141        bra.l   _frems_
 142        short   0x0000
 143        bra.l   _fremd_
 144        short   0x0000
 145        bra.l   _fremx_
 146        short   0x0000
 147
 148        bra.l   _fscales_
 149        short   0x0000
 150        bra.l   _fscaled_
 151        short   0x0000
 152        bra.l   _fscalex_
 153        short   0x0000
 154
 155        bra.l   _fsins_
 156        short   0x0000
 157        bra.l   _fsind_
 158        short   0x0000
 159        bra.l   _fsinx_
 160        short   0x0000
 161
 162        bra.l   _fsincoss_
 163        short   0x0000
 164        bra.l   _fsincosd_
 165        short   0x0000
 166        bra.l   _fsincosx_
 167        short   0x0000
 168
 169        bra.l   _fsinhs_
 170        short   0x0000
 171        bra.l   _fsinhd_
 172        short   0x0000
 173        bra.l   _fsinhx_
 174        short   0x0000
 175
 176        bra.l   _ftans_
 177        short   0x0000
 178        bra.l   _ftand_
 179        short   0x0000
 180        bra.l   _ftanx_
 181        short   0x0000
 182
 183        bra.l   _ftanhs_
 184        short   0x0000
 185        bra.l   _ftanhd_
 186        short   0x0000
 187        bra.l   _ftanhx_
 188        short   0x0000
 189
 190        bra.l   _ftentoxs_
 191        short   0x0000
 192        bra.l   _ftentoxd_
 193        short   0x0000
 194        bra.l   _ftentoxx_
 195        short   0x0000
 196
 197        bra.l   _ftwotoxs_
 198        short   0x0000
 199        bra.l   _ftwotoxd_
 200        short   0x0000
 201        bra.l   _ftwotoxx_
 202        short   0x0000
 203
 204        bra.l   _fabss_
 205        short   0x0000
 206        bra.l   _fabsd_
 207        short   0x0000
 208        bra.l   _fabsx_
 209        short   0x0000
 210
 211        bra.l   _fadds_
 212        short   0x0000
 213        bra.l   _faddd_
 214        short   0x0000
 215        bra.l   _faddx_
 216        short   0x0000
 217
 218        bra.l   _fdivs_
 219        short   0x0000
 220        bra.l   _fdivd_
 221        short   0x0000
 222        bra.l   _fdivx_
 223        short   0x0000
 224
 225        bra.l   _fints_
 226        short   0x0000
 227        bra.l   _fintd_
 228        short   0x0000
 229        bra.l   _fintx_
 230        short   0x0000
 231
 232        bra.l   _fintrzs_
 233        short   0x0000
 234        bra.l   _fintrzd_
 235        short   0x0000
 236        bra.l   _fintrzx_
 237        short   0x0000
 238
 239        bra.l   _fmuls_
 240        short   0x0000
 241        bra.l   _fmuld_
 242        short   0x0000
 243        bra.l   _fmulx_
 244        short   0x0000
 245
 246        bra.l   _fnegs_
 247        short   0x0000
 248        bra.l   _fnegd_
 249        short   0x0000
 250        bra.l   _fnegx_
 251        short   0x0000
 252
 253        bra.l   _fsqrts_
 254        short   0x0000
 255        bra.l   _fsqrtd_
 256        short   0x0000
 257        bra.l   _fsqrtx_
 258        short   0x0000
 259
 260        bra.l   _fsubs_
 261        short   0x0000
 262        bra.l   _fsubd_
 263        short   0x0000
 264        bra.l   _fsubx_
 265        short   0x0000
 266
 267# leave room for future possible additions
 268        align   0x400
 269
 270#
 271# This file contains a set of define statements for constants
 272# in order to promote readability within the corecode itself.
 273#
 274
 275set LOCAL_SIZE,         192                     # stack frame size(bytes)
 276set LV,                 -LOCAL_SIZE             # stack offset
 277
 278set EXC_SR,             0x4                     # stack status register
 279set EXC_PC,             0x6                     # stack pc
 280set EXC_VOFF,           0xa                     # stacked vector offset
 281set EXC_EA,             0xc                     # stacked <ea>
 282
 283set EXC_FP,             0x0                     # frame pointer
 284
 285set EXC_AREGS,          -68                     # offset of all address regs
 286set EXC_DREGS,          -100                    # offset of all data regs
 287set EXC_FPREGS,         -36                     # offset of all fp regs
 288
 289set EXC_A7,             EXC_AREGS+(7*4)         # offset of saved a7
 290set OLD_A7,             EXC_AREGS+(6*4)         # extra copy of saved a7
 291set EXC_A6,             EXC_AREGS+(6*4)         # offset of saved a6
 292set EXC_A5,             EXC_AREGS+(5*4)
 293set EXC_A4,             EXC_AREGS+(4*4)
 294set EXC_A3,             EXC_AREGS+(3*4)
 295set EXC_A2,             EXC_AREGS+(2*4)
 296set EXC_A1,             EXC_AREGS+(1*4)
 297set EXC_A0,             EXC_AREGS+(0*4)
 298set EXC_D7,             EXC_DREGS+(7*4)
 299set EXC_D6,             EXC_DREGS+(6*4)
 300set EXC_D5,             EXC_DREGS+(5*4)
 301set EXC_D4,             EXC_DREGS+(4*4)
 302set EXC_D3,             EXC_DREGS+(3*4)
 303set EXC_D2,             EXC_DREGS+(2*4)
 304set EXC_D1,             EXC_DREGS+(1*4)
 305set EXC_D0,             EXC_DREGS+(0*4)
 306
 307set EXC_FP0,            EXC_FPREGS+(0*12)       # offset of saved fp0
 308set EXC_FP1,            EXC_FPREGS+(1*12)       # offset of saved fp1
 309set EXC_FP2,            EXC_FPREGS+(2*12)       # offset of saved fp2 (not used)
 310
 311set FP_SCR1,            LV+80                   # fp scratch 1
 312set FP_SCR1_EX,         FP_SCR1+0
 313set FP_SCR1_SGN,        FP_SCR1+2
 314set FP_SCR1_HI,         FP_SCR1+4
 315set FP_SCR1_LO,         FP_SCR1+8
 316
 317set FP_SCR0,            LV+68                   # fp scratch 0
 318set FP_SCR0_EX,         FP_SCR0+0
 319set FP_SCR0_SGN,        FP_SCR0+2
 320set FP_SCR0_HI,         FP_SCR0+4
 321set FP_SCR0_LO,         FP_SCR0+8
 322
 323set FP_DST,             LV+56                   # fp destination operand
 324set FP_DST_EX,          FP_DST+0
 325set FP_DST_SGN,         FP_DST+2
 326set FP_DST_HI,          FP_DST+4
 327set FP_DST_LO,          FP_DST+8
 328
 329set FP_SRC,             LV+44                   # fp source operand
 330set FP_SRC_EX,          FP_SRC+0
 331set FP_SRC_SGN,         FP_SRC+2
 332set FP_SRC_HI,          FP_SRC+4
 333set FP_SRC_LO,          FP_SRC+8
 334
 335set USER_FPIAR,         LV+40                   # FP instr address register
 336
 337set USER_FPSR,          LV+36                   # FP status register
 338set FPSR_CC,            USER_FPSR+0             # FPSR condition codes
 339set FPSR_QBYTE,         USER_FPSR+1             # FPSR qoutient byte
 340set FPSR_EXCEPT,        USER_FPSR+2             # FPSR exception status byte
 341set FPSR_AEXCEPT,       USER_FPSR+3             # FPSR accrued exception byte
 342
 343set USER_FPCR,          LV+32                   # FP control register
 344set FPCR_ENABLE,        USER_FPCR+2             # FPCR exception enable
 345set FPCR_MODE,          USER_FPCR+3             # FPCR rounding mode control
 346
 347set L_SCR3,             LV+28                   # integer scratch 3
 348set L_SCR2,             LV+24                   # integer scratch 2
 349set L_SCR1,             LV+20                   # integer scratch 1
 350
 351set STORE_FLG,          LV+19                   # flag: operand store (ie. not fcmp/ftst)
 352
 353set EXC_TEMP2,          LV+24                   # temporary space
 354set EXC_TEMP,           LV+16                   # temporary space
 355
 356set DTAG,               LV+15                   # destination operand type
 357set STAG,               LV+14                   # source operand type
 358
 359set SPCOND_FLG,         LV+10                   # flag: special case (see below)
 360
 361set EXC_CC,             LV+8                    # saved condition codes
 362set EXC_EXTWPTR,        LV+4                    # saved current PC (active)
 363set EXC_EXTWORD,        LV+2                    # saved extension word
 364set EXC_CMDREG,         LV+2                    # saved extension word
 365set EXC_OPWORD,         LV+0                    # saved operation word
 366
 367################################
 368
 369# Helpful macros
 370
 371set FTEMP,              0                       # offsets within an
 372set FTEMP_EX,           0                       # extended precision
 373set FTEMP_SGN,          2                       # value saved in memory.
 374set FTEMP_HI,           4
 375set FTEMP_LO,           8
 376set FTEMP_GRS,          12
 377
 378set LOCAL,              0                       # offsets within an
 379set LOCAL_EX,           0                       # extended precision
 380set LOCAL_SGN,          2                       # value saved in memory.
 381set LOCAL_HI,           4
 382set LOCAL_LO,           8
 383set LOCAL_GRS,          12
 384
 385set DST,                0                       # offsets within an
 386set DST_EX,             0                       # extended precision
 387set DST_HI,             4                       # value saved in memory.
 388set DST_LO,             8
 389
 390set SRC,                0                       # offsets within an
 391set SRC_EX,             0                       # extended precision
 392set SRC_HI,             4                       # value saved in memory.
 393set SRC_LO,             8
 394
 395set SGL_LO,             0x3f81                  # min sgl prec exponent
 396set SGL_HI,             0x407e                  # max sgl prec exponent
 397set DBL_LO,             0x3c01                  # min dbl prec exponent
 398set DBL_HI,             0x43fe                  # max dbl prec exponent
 399set EXT_LO,             0x0                     # min ext prec exponent
 400set EXT_HI,             0x7ffe                  # max ext prec exponent
 401
 402set EXT_BIAS,           0x3fff                  # extended precision bias
 403set SGL_BIAS,           0x007f                  # single precision bias
 404set DBL_BIAS,           0x03ff                  # double precision bias
 405
 406set NORM,               0x00                    # operand type for STAG/DTAG
 407set ZERO,               0x01                    # operand type for STAG/DTAG
 408set INF,                0x02                    # operand type for STAG/DTAG
 409set QNAN,               0x03                    # operand type for STAG/DTAG
 410set DENORM,             0x04                    # operand type for STAG/DTAG
 411set SNAN,               0x05                    # operand type for STAG/DTAG
 412set UNNORM,             0x06                    # operand type for STAG/DTAG
 413
 414##################
 415# FPSR/FPCR bits #
 416##################
 417set neg_bit,            0x3                     # negative result
 418set z_bit,              0x2                     # zero result
 419set inf_bit,            0x1                     # infinite result
 420set nan_bit,            0x0                     # NAN result
 421
 422set q_sn_bit,           0x7                     # sign bit of quotient byte
 423
 424set bsun_bit,           7                       # branch on unordered
 425set snan_bit,           6                       # signalling NAN
 426set operr_bit,          5                       # operand error
 427set ovfl_bit,           4                       # overflow
 428set unfl_bit,           3                       # underflow
 429set dz_bit,             2                       # divide by zero
 430set inex2_bit,          1                       # inexact result 2
 431set inex1_bit,          0                       # inexact result 1
 432
 433set aiop_bit,           7                       # accrued inexact operation bit
 434set aovfl_bit,          6                       # accrued overflow bit
 435set aunfl_bit,          5                       # accrued underflow bit
 436set adz_bit,            4                       # accrued dz bit
 437set ainex_bit,          3                       # accrued inexact bit
 438
 439#############################
 440# FPSR individual bit masks #
 441#############################
 442set neg_mask,           0x08000000              # negative bit mask (lw)
 443set inf_mask,           0x02000000              # infinity bit mask (lw)
 444set z_mask,             0x04000000              # zero bit mask (lw)
 445set nan_mask,           0x01000000              # nan bit mask (lw)
 446
 447set neg_bmask,          0x08                    # negative bit mask (byte)
 448set inf_bmask,          0x02                    # infinity bit mask (byte)
 449set z_bmask,            0x04                    # zero bit mask (byte)
 450set nan_bmask,          0x01                    # nan bit mask (byte)
 451
 452set bsun_mask,          0x00008000              # bsun exception mask
 453set snan_mask,          0x00004000              # snan exception mask
 454set operr_mask,         0x00002000              # operr exception mask
 455set ovfl_mask,          0x00001000              # overflow exception mask
 456set unfl_mask,          0x00000800              # underflow exception mask
 457set dz_mask,            0x00000400              # dz exception mask
 458set inex2_mask,         0x00000200              # inex2 exception mask
 459set inex1_mask,         0x00000100              # inex1 exception mask
 460
 461set aiop_mask,          0x00000080              # accrued illegal operation
 462set aovfl_mask,         0x00000040              # accrued overflow
 463set aunfl_mask,         0x00000020              # accrued underflow
 464set adz_mask,           0x00000010              # accrued divide by zero
 465set ainex_mask,         0x00000008              # accrued inexact
 466
 467######################################
 468# FPSR combinations used in the FPSP #
 469######################################
 470set dzinf_mask,         inf_mask+dz_mask+adz_mask
 471set opnan_mask,         nan_mask+operr_mask+aiop_mask
 472set nzi_mask,           0x01ffffff              #clears N, Z, and I
 473set unfinx_mask,        unfl_mask+inex2_mask+aunfl_mask+ainex_mask
 474set unf2inx_mask,       unfl_mask+inex2_mask+ainex_mask
 475set ovfinx_mask,        ovfl_mask+inex2_mask+aovfl_mask+ainex_mask
 476set inx1a_mask,         inex1_mask+ainex_mask
 477set inx2a_mask,         inex2_mask+ainex_mask
 478set snaniop_mask,       nan_mask+snan_mask+aiop_mask
 479set snaniop2_mask,      snan_mask+aiop_mask
 480set naniop_mask,        nan_mask+aiop_mask
 481set neginf_mask,        neg_mask+inf_mask
 482set infaiop_mask,       inf_mask+aiop_mask
 483set negz_mask,          neg_mask+z_mask
 484set opaop_mask,         operr_mask+aiop_mask
 485set unfl_inx_mask,      unfl_mask+aunfl_mask+ainex_mask
 486set ovfl_inx_mask,      ovfl_mask+aovfl_mask+ainex_mask
 487
 488#########
 489# misc. #
 490#########
 491set rnd_stky_bit,       29                      # stky bit pos in longword
 492
 493set sign_bit,           0x7                     # sign bit
 494set signan_bit,         0x6                     # signalling nan bit
 495
 496set sgl_thresh,         0x3f81                  # minimum sgl exponent
 497set dbl_thresh,         0x3c01                  # minimum dbl exponent
 498
 499set x_mode,             0x0                     # extended precision
 500set s_mode,             0x4                     # single precision
 501set d_mode,             0x8                     # double precision
 502
 503set rn_mode,            0x0                     # round-to-nearest
 504set rz_mode,            0x1                     # round-to-zero
 505set rm_mode,            0x2                     # round-tp-minus-infinity
 506set rp_mode,            0x3                     # round-to-plus-infinity
 507
 508set mantissalen,        64                      # length of mantissa in bits
 509
 510set BYTE,               1                       # len(byte) == 1 byte
 511set WORD,               2                       # len(word) == 2 bytes
 512set LONG,               4                       # len(longword) == 2 bytes
 513
 514set BSUN_VEC,           0xc0                    # bsun    vector offset
 515set INEX_VEC,           0xc4                    # inexact vector offset
 516set DZ_VEC,             0xc8                    # dz      vector offset
 517set UNFL_VEC,           0xcc                    # unfl    vector offset
 518set OPERR_VEC,          0xd0                    # operr   vector offset
 519set OVFL_VEC,           0xd4                    # ovfl    vector offset
 520set SNAN_VEC,           0xd8                    # snan    vector offset
 521
 522###########################
 523# SPecial CONDition FLaGs #
 524###########################
 525set ftrapcc_flg,        0x01                    # flag bit: ftrapcc exception
 526set fbsun_flg,          0x02                    # flag bit: bsun exception
 527set mia7_flg,           0x04                    # flag bit: (a7)+ <ea>
 528set mda7_flg,           0x08                    # flag bit: -(a7) <ea>
 529set fmovm_flg,          0x40                    # flag bit: fmovm instruction
 530set immed_flg,          0x80                    # flag bit: &<data> <ea>
 531
 532set ftrapcc_bit,        0x0
 533set fbsun_bit,          0x1
 534set mia7_bit,           0x2
 535set mda7_bit,           0x3
 536set immed_bit,          0x7
 537
 538##################################
 539# TRANSCENDENTAL "LAST-OP" FLAGS #
 540##################################
 541set FMUL_OP,            0x0                     # fmul instr performed last
 542set FDIV_OP,            0x1                     # fdiv performed last
 543set FADD_OP,            0x2                     # fadd performed last
 544set FMOV_OP,            0x3                     # fmov performed last
 545
 546#############
 547# CONSTANTS #
 548#############
 549T1:     long            0x40C62D38,0xD3D64634   # 16381 LOG2 LEAD
 550T2:     long            0x3D6F90AE,0xB1E75CC7   # 16381 LOG2 TRAIL
 551
 552PI:     long            0x40000000,0xC90FDAA2,0x2168C235,0x00000000
 553PIBY2:  long            0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
 554
 555TWOBYPI:
 556        long            0x3FE45F30,0x6DC9C883
 557
 558#########################################################################
 559# MONADIC TEMPLATE                                                      #
 560#########################################################################
 561        global          _fsins_
 562_fsins_:
 563        link            %a6,&-LOCAL_SIZE
 564
 565        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 566        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 567        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 568
 569        fmov.l          &0x0,%fpcr              # zero FPCR
 570
 571#
 572#       copy, convert, and tag input argument
 573#
 574        fmov.s          0x8(%a6),%fp0           # load sgl input
 575        fmov.x          %fp0,FP_SRC(%a6)
 576        lea             FP_SRC(%a6),%a0
 577        bsr.l           tag                     # fetch operand type
 578        mov.b           %d0,STAG(%a6)
 579        mov.b           %d0,%d1
 580
 581        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 582
 583        clr.l           %d0
 584        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 585
 586        tst.b           %d1
 587        bne.b           _L0_2s
 588        bsr.l           ssin                    # operand is a NORM
 589        bra.b           _L0_6s
 590_L0_2s:
 591        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 592        bne.b           _L0_3s                  # no
 593        bsr.l           src_zero                        # yes
 594        bra.b           _L0_6s
 595_L0_3s:
 596        cmpi.b          %d1,&INF                # is operand an INF?
 597        bne.b           _L0_4s                  # no
 598        bsr.l           t_operr                 # yes
 599        bra.b           _L0_6s
 600_L0_4s:
 601        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 602        bne.b           _L0_5s                  # no
 603        bsr.l           src_qnan                        # yes
 604        bra.b           _L0_6s
 605_L0_5s:
 606        bsr.l           ssind                   # operand is a DENORM
 607_L0_6s:
 608
 609#
 610#       Result is now in FP0
 611#
 612        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 613        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 614        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 615        unlk            %a6
 616        rts
 617
 618        global          _fsind_
 619_fsind_:
 620        link            %a6,&-LOCAL_SIZE
 621
 622        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 623        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 624        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 625
 626        fmov.l          &0x0,%fpcr              # zero FPCR
 627
 628#
 629#       copy, convert, and tag input argument
 630#
 631        fmov.d          0x8(%a6),%fp0           # load dbl input
 632        fmov.x          %fp0,FP_SRC(%a6)
 633        lea             FP_SRC(%a6),%a0
 634        bsr.l           tag                     # fetch operand type
 635        mov.b           %d0,STAG(%a6)
 636        mov.b           %d0,%d1
 637
 638        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 639
 640        clr.l           %d0
 641        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 642
 643        mov.b           %d1,STAG(%a6)
 644        tst.b           %d1
 645        bne.b           _L0_2d
 646        bsr.l           ssin                    # operand is a NORM
 647        bra.b           _L0_6d
 648_L0_2d:
 649        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 650        bne.b           _L0_3d                  # no
 651        bsr.l           src_zero                        # yes
 652        bra.b           _L0_6d
 653_L0_3d:
 654        cmpi.b          %d1,&INF                # is operand an INF?
 655        bne.b           _L0_4d                  # no
 656        bsr.l           t_operr                 # yes
 657        bra.b           _L0_6d
 658_L0_4d:
 659        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 660        bne.b           _L0_5d                  # no
 661        bsr.l           src_qnan                        # yes
 662        bra.b           _L0_6d
 663_L0_5d:
 664        bsr.l           ssind                   # operand is a DENORM
 665_L0_6d:
 666
 667#
 668#       Result is now in FP0
 669#
 670        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 671        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 672        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 673        unlk            %a6
 674        rts
 675
 676        global          _fsinx_
 677_fsinx_:
 678        link            %a6,&-LOCAL_SIZE
 679
 680        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 681        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 682        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 683
 684        fmov.l          &0x0,%fpcr              # zero FPCR
 685
 686#
 687#       copy, convert, and tag input argument
 688#
 689        lea             FP_SRC(%a6),%a0
 690        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
 691        mov.l           0x8+0x4(%a6),0x4(%a0)
 692        mov.l           0x8+0x8(%a6),0x8(%a0)
 693        bsr.l           tag                     # fetch operand type
 694        mov.b           %d0,STAG(%a6)
 695        mov.b           %d0,%d1
 696
 697        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 698
 699        clr.l           %d0
 700        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 701
 702        tst.b           %d1
 703        bne.b           _L0_2x
 704        bsr.l           ssin                    # operand is a NORM
 705        bra.b           _L0_6x
 706_L0_2x:
 707        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 708        bne.b           _L0_3x                  # no
 709        bsr.l           src_zero                        # yes
 710        bra.b           _L0_6x
 711_L0_3x:
 712        cmpi.b          %d1,&INF                # is operand an INF?
 713        bne.b           _L0_4x                  # no
 714        bsr.l           t_operr                 # yes
 715        bra.b           _L0_6x
 716_L0_4x:
 717        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 718        bne.b           _L0_5x                  # no
 719        bsr.l           src_qnan                        # yes
 720        bra.b           _L0_6x
 721_L0_5x:
 722        bsr.l           ssind                   # operand is a DENORM
 723_L0_6x:
 724
 725#
 726#       Result is now in FP0
 727#
 728        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 729        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 730        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 731        unlk            %a6
 732        rts
 733
 734
 735#########################################################################
 736# MONADIC TEMPLATE                                                      #
 737#########################################################################
 738        global          _fcoss_
 739_fcoss_:
 740        link            %a6,&-LOCAL_SIZE
 741
 742        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 743        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 744        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 745
 746        fmov.l          &0x0,%fpcr              # zero FPCR
 747
 748#
 749#       copy, convert, and tag input argument
 750#
 751        fmov.s          0x8(%a6),%fp0           # load sgl input
 752        fmov.x          %fp0,FP_SRC(%a6)
 753        lea             FP_SRC(%a6),%a0
 754        bsr.l           tag                     # fetch operand type
 755        mov.b           %d0,STAG(%a6)
 756        mov.b           %d0,%d1
 757
 758        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 759
 760        clr.l           %d0
 761        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 762
 763        tst.b           %d1
 764        bne.b           _L1_2s
 765        bsr.l           scos                    # operand is a NORM
 766        bra.b           _L1_6s
 767_L1_2s:
 768        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 769        bne.b           _L1_3s                  # no
 770        bsr.l           ld_pone                 # yes
 771        bra.b           _L1_6s
 772_L1_3s:
 773        cmpi.b          %d1,&INF                # is operand an INF?
 774        bne.b           _L1_4s                  # no
 775        bsr.l           t_operr                 # yes
 776        bra.b           _L1_6s
 777_L1_4s:
 778        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 779        bne.b           _L1_5s                  # no
 780        bsr.l           src_qnan                        # yes
 781        bra.b           _L1_6s
 782_L1_5s:
 783        bsr.l           scosd                   # operand is a DENORM
 784_L1_6s:
 785
 786#
 787#       Result is now in FP0
 788#
 789        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 790        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 791        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 792        unlk            %a6
 793        rts
 794
 795        global          _fcosd_
 796_fcosd_:
 797        link            %a6,&-LOCAL_SIZE
 798
 799        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 800        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 801        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 802
 803        fmov.l          &0x0,%fpcr              # zero FPCR
 804
 805#
 806#       copy, convert, and tag input argument
 807#
 808        fmov.d          0x8(%a6),%fp0           # load dbl input
 809        fmov.x          %fp0,FP_SRC(%a6)
 810        lea             FP_SRC(%a6),%a0
 811        bsr.l           tag                     # fetch operand type
 812        mov.b           %d0,STAG(%a6)
 813        mov.b           %d0,%d1
 814
 815        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 816
 817        clr.l           %d0
 818        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 819
 820        mov.b           %d1,STAG(%a6)
 821        tst.b           %d1
 822        bne.b           _L1_2d
 823        bsr.l           scos                    # operand is a NORM
 824        bra.b           _L1_6d
 825_L1_2d:
 826        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 827        bne.b           _L1_3d                  # no
 828        bsr.l           ld_pone                 # yes
 829        bra.b           _L1_6d
 830_L1_3d:
 831        cmpi.b          %d1,&INF                # is operand an INF?
 832        bne.b           _L1_4d                  # no
 833        bsr.l           t_operr                 # yes
 834        bra.b           _L1_6d
 835_L1_4d:
 836        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 837        bne.b           _L1_5d                  # no
 838        bsr.l           src_qnan                        # yes
 839        bra.b           _L1_6d
 840_L1_5d:
 841        bsr.l           scosd                   # operand is a DENORM
 842_L1_6d:
 843
 844#
 845#       Result is now in FP0
 846#
 847        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 848        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 849        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 850        unlk            %a6
 851        rts
 852
 853        global          _fcosx_
 854_fcosx_:
 855        link            %a6,&-LOCAL_SIZE
 856
 857        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 858        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 859        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 860
 861        fmov.l          &0x0,%fpcr              # zero FPCR
 862
 863#
 864#       copy, convert, and tag input argument
 865#
 866        lea             FP_SRC(%a6),%a0
 867        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
 868        mov.l           0x8+0x4(%a6),0x4(%a0)
 869        mov.l           0x8+0x8(%a6),0x8(%a0)
 870        bsr.l           tag                     # fetch operand type
 871        mov.b           %d0,STAG(%a6)
 872        mov.b           %d0,%d1
 873
 874        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 875
 876        clr.l           %d0
 877        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 878
 879        tst.b           %d1
 880        bne.b           _L1_2x
 881        bsr.l           scos                    # operand is a NORM
 882        bra.b           _L1_6x
 883_L1_2x:
 884        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 885        bne.b           _L1_3x                  # no
 886        bsr.l           ld_pone                 # yes
 887        bra.b           _L1_6x
 888_L1_3x:
 889        cmpi.b          %d1,&INF                # is operand an INF?
 890        bne.b           _L1_4x                  # no
 891        bsr.l           t_operr                 # yes
 892        bra.b           _L1_6x
 893_L1_4x:
 894        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 895        bne.b           _L1_5x                  # no
 896        bsr.l           src_qnan                        # yes
 897        bra.b           _L1_6x
 898_L1_5x:
 899        bsr.l           scosd                   # operand is a DENORM
 900_L1_6x:
 901
 902#
 903#       Result is now in FP0
 904#
 905        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 906        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 907        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 908        unlk            %a6
 909        rts
 910
 911
 912#########################################################################
 913# MONADIC TEMPLATE                                                      #
 914#########################################################################
 915        global          _fsinhs_
 916_fsinhs_:
 917        link            %a6,&-LOCAL_SIZE
 918
 919        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 920        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 921        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 922
 923        fmov.l          &0x0,%fpcr              # zero FPCR
 924
 925#
 926#       copy, convert, and tag input argument
 927#
 928        fmov.s          0x8(%a6),%fp0           # load sgl input
 929        fmov.x          %fp0,FP_SRC(%a6)
 930        lea             FP_SRC(%a6),%a0
 931        bsr.l           tag                     # fetch operand type
 932        mov.b           %d0,STAG(%a6)
 933        mov.b           %d0,%d1
 934
 935        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 936
 937        clr.l           %d0
 938        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 939
 940        tst.b           %d1
 941        bne.b           _L2_2s
 942        bsr.l           ssinh                   # operand is a NORM
 943        bra.b           _L2_6s
 944_L2_2s:
 945        cmpi.b          %d1,&ZERO               # is operand a ZERO?
 946        bne.b           _L2_3s                  # no
 947        bsr.l           src_zero                        # yes
 948        bra.b           _L2_6s
 949_L2_3s:
 950        cmpi.b          %d1,&INF                # is operand an INF?
 951        bne.b           _L2_4s                  # no
 952        bsr.l           src_inf                 # yes
 953        bra.b           _L2_6s
 954_L2_4s:
 955        cmpi.b          %d1,&QNAN               # is operand a QNAN?
 956        bne.b           _L2_5s                  # no
 957        bsr.l           src_qnan                        # yes
 958        bra.b           _L2_6s
 959_L2_5s:
 960        bsr.l           ssinhd                  # operand is a DENORM
 961_L2_6s:
 962
 963#
 964#       Result is now in FP0
 965#
 966        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
 967        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
 968        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
 969        unlk            %a6
 970        rts
 971
 972        global          _fsinhd_
 973_fsinhd_:
 974        link            %a6,&-LOCAL_SIZE
 975
 976        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
 977        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
 978        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
 979
 980        fmov.l          &0x0,%fpcr              # zero FPCR
 981
 982#
 983#       copy, convert, and tag input argument
 984#
 985        fmov.d          0x8(%a6),%fp0           # load dbl input
 986        fmov.x          %fp0,FP_SRC(%a6)
 987        lea             FP_SRC(%a6),%a0
 988        bsr.l           tag                     # fetch operand type
 989        mov.b           %d0,STAG(%a6)
 990        mov.b           %d0,%d1
 991
 992        andi.l          &0x00ff00ff,USER_FPSR(%a6)
 993
 994        clr.l           %d0
 995        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
 996
 997        mov.b           %d1,STAG(%a6)
 998        tst.b           %d1
 999        bne.b           _L2_2d
1000        bsr.l           ssinh                   # operand is a NORM

1001        bra.b           _L2_6d
1002_L2_2d:
1003        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1004        bne.b           _L2_3d                  # no
1005        bsr.l           src_zero                        # yes
1006        bra.b           _L2_6d
1007_L2_3d:
1008        cmpi.b          %d1,&INF                # is operand an INF?
1009        bne.b           _L2_4d                  # no
1010        bsr.l           src_inf                 # yes
1011        bra.b           _L2_6d
1012_L2_4d:
1013        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1014        bne.b           _L2_5d                  # no
1015        bsr.l           src_qnan                        # yes
1016        bra.b           _L2_6d
1017_L2_5d:
1018        bsr.l           ssinhd                  # operand is a DENORM
1019_L2_6d:
1020
1021#
1022#       Result is now in FP0
1023#
1024        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1025        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1026        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1027        unlk            %a6
1028        rts
1029
1030        global          _fsinhx_
1031_fsinhx_:
1032        link            %a6,&-LOCAL_SIZE
1033
1034        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1035        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1036        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1037
1038        fmov.l          &0x0,%fpcr              # zero FPCR
1039
1040#
1041#       copy, convert, and tag input argument
1042#
1043        lea             FP_SRC(%a6),%a0
1044        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
1045        mov.l           0x8+0x4(%a6),0x4(%a0)
1046        mov.l           0x8+0x8(%a6),0x8(%a0)
1047        bsr.l           tag                     # fetch operand type
1048        mov.b           %d0,STAG(%a6)
1049        mov.b           %d0,%d1
1050
1051        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1052
1053        clr.l           %d0
1054        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1055
1056        tst.b           %d1
1057        bne.b           _L2_2x
1058        bsr.l           ssinh                   # operand is a NORM
1059        bra.b           _L2_6x
1060_L2_2x:
1061        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1062        bne.b           _L2_3x                  # no
1063        bsr.l           src_zero                        # yes
1064        bra.b           _L2_6x
1065_L2_3x:
1066        cmpi.b          %d1,&INF                # is operand an INF?
1067        bne.b           _L2_4x                  # no
1068        bsr.l           src_inf                 # yes
1069        bra.b           _L2_6x
1070_L2_4x:
1071        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1072        bne.b           _L2_5x                  # no
1073        bsr.l           src_qnan                        # yes
1074        bra.b           _L2_6x
1075_L2_5x:
1076        bsr.l           ssinhd                  # operand is a DENORM
1077_L2_6x:
1078
1079#
1080#       Result is now in FP0
1081#
1082        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1083        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1084        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1085        unlk            %a6
1086        rts
1087
1088
1089#########################################################################
1090# MONADIC TEMPLATE                                                      #
1091#########################################################################
1092        global          _flognp1s_
1093_flognp1s_:
1094        link            %a6,&-LOCAL_SIZE
1095
1096        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1097        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1098        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1099
1100        fmov.l          &0x0,%fpcr              # zero FPCR
1101
1102#
1103#       copy, convert, and tag input argument
1104#
1105        fmov.s          0x8(%a6),%fp0           # load sgl input
1106        fmov.x          %fp0,FP_SRC(%a6)
1107        lea             FP_SRC(%a6),%a0
1108        bsr.l           tag                     # fetch operand type
1109        mov.b           %d0,STAG(%a6)
1110        mov.b           %d0,%d1
1111
1112        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1113
1114        clr.l           %d0
1115        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1116
1117        tst.b           %d1
1118        bne.b           _L3_2s
1119        bsr.l           slognp1                 # operand is a NORM
1120        bra.b           _L3_6s
1121_L3_2s:
1122        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1123        bne.b           _L3_3s                  # no
1124        bsr.l           src_zero                        # yes
1125        bra.b           _L3_6s
1126_L3_3s:
1127        cmpi.b          %d1,&INF                # is operand an INF?
1128        bne.b           _L3_4s                  # no
1129        bsr.l           sopr_inf                        # yes
1130        bra.b           _L3_6s
1131_L3_4s:
1132        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1133        bne.b           _L3_5s                  # no
1134        bsr.l           src_qnan                        # yes
1135        bra.b           _L3_6s
1136_L3_5s:
1137        bsr.l           slognp1d                        # operand is a DENORM
1138_L3_6s:
1139
1140#
1141#       Result is now in FP0
1142#
1143        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1144        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1145        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1146        unlk            %a6
1147        rts
1148
1149        global          _flognp1d_
1150_flognp1d_:
1151        link            %a6,&-LOCAL_SIZE
1152
1153        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1154        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1155        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1156
1157        fmov.l          &0x0,%fpcr              # zero FPCR
1158
1159#
1160#       copy, convert, and tag input argument
1161#
1162        fmov.d          0x8(%a6),%fp0           # load dbl input
1163        fmov.x          %fp0,FP_SRC(%a6)
1164        lea             FP_SRC(%a6),%a0
1165        bsr.l           tag                     # fetch operand type
1166        mov.b           %d0,STAG(%a6)
1167        mov.b           %d0,%d1
1168
1169        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1170
1171        clr.l           %d0
1172        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1173
1174        mov.b           %d1,STAG(%a6)
1175        tst.b           %d1
1176        bne.b           _L3_2d
1177        bsr.l           slognp1                 # operand is a NORM
1178        bra.b           _L3_6d
1179_L3_2d:
1180        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1181        bne.b           _L3_3d                  # no
1182        bsr.l           src_zero                        # yes
1183        bra.b           _L3_6d
1184_L3_3d:
1185        cmpi.b          %d1,&INF                # is operand an INF?
1186        bne.b           _L3_4d                  # no
1187        bsr.l           sopr_inf                        # yes
1188        bra.b           _L3_6d
1189_L3_4d:
1190        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1191        bne.b           _L3_5d                  # no
1192        bsr.l           src_qnan                        # yes
1193        bra.b           _L3_6d
1194_L3_5d:
1195        bsr.l           slognp1d                        # operand is a DENORM
1196_L3_6d:
1197
1198#
1199#       Result is now in FP0
1200#
1201        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1202        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1203        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1204        unlk            %a6
1205        rts
1206
1207        global          _flognp1x_
1208_flognp1x_:
1209        link            %a6,&-LOCAL_SIZE
1210
1211        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1212        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1213        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1214
1215        fmov.l          &0x0,%fpcr              # zero FPCR
1216
1217#
1218#       copy, convert, and tag input argument
1219#
1220        lea             FP_SRC(%a6),%a0
1221        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
1222        mov.l           0x8+0x4(%a6),0x4(%a0)
1223        mov.l           0x8+0x8(%a6),0x8(%a0)
1224        bsr.l           tag                     # fetch operand type
1225        mov.b           %d0,STAG(%a6)
1226        mov.b           %d0,%d1
1227
1228        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1229
1230        clr.l           %d0
1231        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1232
1233        tst.b           %d1
1234        bne.b           _L3_2x
1235        bsr.l           slognp1                 # operand is a NORM
1236        bra.b           _L3_6x
1237_L3_2x:
1238        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1239        bne.b           _L3_3x                  # no
1240        bsr.l           src_zero                        # yes
1241        bra.b           _L3_6x
1242_L3_3x:
1243        cmpi.b          %d1,&INF                # is operand an INF?
1244        bne.b           _L3_4x                  # no
1245        bsr.l           sopr_inf                        # yes
1246        bra.b           _L3_6x
1247_L3_4x:
1248        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1249        bne.b           _L3_5x                  # no
1250        bsr.l           src_qnan                        # yes
1251        bra.b           _L3_6x
1252_L3_5x:
1253        bsr.l           slognp1d                        # operand is a DENORM
1254_L3_6x:
1255
1256#
1257#       Result is now in FP0
1258#
1259        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1260        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1261        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1262        unlk            %a6
1263        rts
1264
1265
1266#########################################################################
1267# MONADIC TEMPLATE                                                      #
1268#########################################################################
1269        global          _fetoxm1s_
1270_fetoxm1s_:
1271        link            %a6,&-LOCAL_SIZE
1272
1273        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1274        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1275        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1276
1277        fmov.l          &0x0,%fpcr              # zero FPCR
1278
1279#
1280#       copy, convert, and tag input argument
1281#
1282        fmov.s          0x8(%a6),%fp0           # load sgl input
1283        fmov.x          %fp0,FP_SRC(%a6)
1284        lea             FP_SRC(%a6),%a0
1285        bsr.l           tag                     # fetch operand type
1286        mov.b           %d0,STAG(%a6)
1287        mov.b           %d0,%d1
1288
1289        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1290
1291        clr.l           %d0
1292        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1293
1294        tst.b           %d1
1295        bne.b           _L4_2s
1296        bsr.l           setoxm1                 # operand is a NORM
1297        bra.b           _L4_6s
1298_L4_2s:
1299        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1300        bne.b           _L4_3s                  # no
1301        bsr.l           src_zero                        # yes
1302        bra.b           _L4_6s
1303_L4_3s:
1304        cmpi.b          %d1,&INF                # is operand an INF?
1305        bne.b           _L4_4s                  # no
1306        bsr.l           setoxm1i                        # yes
1307        bra.b           _L4_6s
1308_L4_4s:
1309        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1310        bne.b           _L4_5s                  # no
1311        bsr.l           src_qnan                        # yes
1312        bra.b           _L4_6s
1313_L4_5s:
1314        bsr.l           setoxm1d                        # operand is a DENORM
1315_L4_6s:
1316
1317#
1318#       Result is now in FP0
1319#
1320        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1321        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1322        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1323        unlk            %a6
1324        rts
1325
1326        global          _fetoxm1d_
1327_fetoxm1d_:
1328        link            %a6,&-LOCAL_SIZE
1329
1330        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1331        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1332        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1333
1334        fmov.l          &0x0,%fpcr              # zero FPCR
1335
1336#
1337#       copy, convert, and tag input argument
1338#
1339        fmov.d          0x8(%a6),%fp0           # load dbl input
1340        fmov.x          %fp0,FP_SRC(%a6)
1341        lea             FP_SRC(%a6),%a0
1342        bsr.l           tag                     # fetch operand type
1343        mov.b           %d0,STAG(%a6)
1344        mov.b           %d0,%d1
1345
1346        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1347
1348        clr.l           %d0
1349        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1350
1351        mov.b           %d1,STAG(%a6)
1352        tst.b           %d1
1353        bne.b           _L4_2d
1354        bsr.l           setoxm1                 # operand is a NORM
1355        bra.b           _L4_6d
1356_L4_2d:
1357        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1358        bne.b           _L4_3d                  # no
1359        bsr.l           src_zero                        # yes
1360        bra.b           _L4_6d
1361_L4_3d:
1362        cmpi.b          %d1,&INF                # is operand an INF?
1363        bne.b           _L4_4d                  # no
1364        bsr.l           setoxm1i                        # yes
1365        bra.b           _L4_6d
1366_L4_4d:
1367        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1368        bne.b           _L4_5d                  # no
1369        bsr.l           src_qnan                        # yes
1370        bra.b           _L4_6d
1371_L4_5d:
1372        bsr.l           setoxm1d                        # operand is a DENORM
1373_L4_6d:
1374
1375#
1376#       Result is now in FP0
1377#
1378        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1379        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1380        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1381        unlk            %a6
1382        rts
1383
1384        global          _fetoxm1x_
1385_fetoxm1x_:
1386        link            %a6,&-LOCAL_SIZE
1387
1388        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1389        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1390        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1391
1392        fmov.l          &0x0,%fpcr              # zero FPCR
1393
1394#
1395#       copy, convert, and tag input argument
1396#
1397        lea             FP_SRC(%a6),%a0
1398        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
1399        mov.l           0x8+0x4(%a6),0x4(%a0)
1400        mov.l           0x8+0x8(%a6),0x8(%a0)
1401        bsr.l           tag                     # fetch operand type
1402        mov.b           %d0,STAG(%a6)
1403        mov.b           %d0,%d1
1404
1405        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1406
1407        clr.l           %d0
1408        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1409
1410        tst.b           %d1
1411        bne.b           _L4_2x
1412        bsr.l           setoxm1                 # operand is a NORM
1413        bra.b           _L4_6x
1414_L4_2x:
1415        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1416        bne.b           _L4_3x                  # no
1417        bsr.l           src_zero                        # yes
1418        bra.b           _L4_6x
1419_L4_3x:
1420        cmpi.b          %d1,&INF                # is operand an INF?
1421        bne.b           _L4_4x                  # no
1422        bsr.l           setoxm1i                        # yes
1423        bra.b           _L4_6x
1424_L4_4x:
1425        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1426        bne.b           _L4_5x                  # no
1427        bsr.l           src_qnan                        # yes
1428        bra.b           _L4_6x
1429_L4_5x:
1430        bsr.l           setoxm1d                        # operand is a DENORM
1431_L4_6x:
1432
1433#
1434#       Result is now in FP0
1435#
1436        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1437        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1438        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1439        unlk            %a6
1440        rts
1441
1442
1443#########################################################################
1444# MONADIC TEMPLATE                                                      #
1445#########################################################################
1446        global          _ftanhs_
1447_ftanhs_:
1448        link            %a6,&-LOCAL_SIZE
1449
1450        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1451        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1452        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1453
1454        fmov.l          &0x0,%fpcr              # zero FPCR
1455
1456#
1457#       copy, convert, and tag input argument
1458#
1459        fmov.s          0x8(%a6),%fp0           # load sgl input
1460        fmov.x          %fp0,FP_SRC(%a6)
1461        lea             FP_SRC(%a6),%a0
1462        bsr.l           tag                     # fetch operand type
1463        mov.b           %d0,STAG(%a6)
1464        mov.b           %d0,%d1
1465
1466        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1467
1468        clr.l           %d0
1469        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1470
1471        tst.b           %d1
1472        bne.b           _L5_2s
1473        bsr.l           stanh                   # operand is a NORM
1474        bra.b           _L5_6s
1475_L5_2s:
1476        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1477        bne.b           _L5_3s                  # no
1478        bsr.l           src_zero                        # yes
1479        bra.b           _L5_6s
1480_L5_3s:
1481        cmpi.b          %d1,&INF                # is operand an INF?
1482        bne.b           _L5_4s                  # no
1483        bsr.l           src_one                 # yes
1484        bra.b           _L5_6s
1485_L5_4s:
1486        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1487        bne.b           _L5_5s                  # no
1488        bsr.l           src_qnan                        # yes
1489        bra.b           _L5_6s
1490_L5_5s:
1491        bsr.l           stanhd                  # operand is a DENORM
1492_L5_6s:
1493
1494#
1495#       Result is now in FP0
1496#
1497        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1498        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1499        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1500        unlk            %a6
1501        rts
1502
1503        global          _ftanhd_
1504_ftanhd_:
1505        link            %a6,&-LOCAL_SIZE
1506
1507        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1508        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1509        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1510
1511        fmov.l          &0x0,%fpcr              # zero FPCR
1512
1513#
1514#       copy, convert, and tag input argument
1515#
1516        fmov.d          0x8(%a6),%fp0           # load dbl input
1517        fmov.x          %fp0,FP_SRC(%a6)
1518        lea             FP_SRC(%a6),%a0
1519        bsr.l           tag                     # fetch operand type
1520        mov.b           %d0,STAG(%a6)
1521        mov.b           %d0,%d1
1522
1523        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1524
1525        clr.l           %d0
1526        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1527
1528        mov.b           %d1,STAG(%a6)
1529        tst.b           %d1
1530        bne.b           _L5_2d
1531        bsr.l           stanh                   # operand is a NORM
1532        bra.b           _L5_6d
1533_L5_2d:
1534        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1535        bne.b           _L5_3d                  # no
1536        bsr.l           src_zero                        # yes
1537        bra.b           _L5_6d
1538_L5_3d:
1539        cmpi.b          %d1,&INF                # is operand an INF?
1540        bne.b           _L5_4d                  # no
1541        bsr.l           src_one                 # yes
1542        bra.b           _L5_6d
1543_L5_4d:
1544        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1545        bne.b           _L5_5d                  # no
1546        bsr.l           src_qnan                        # yes
1547        bra.b           _L5_6d
1548_L5_5d:
1549        bsr.l           stanhd                  # operand is a DENORM
1550_L5_6d:
1551
1552#
1553#       Result is now in FP0
1554#
1555        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1556        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1557        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1558        unlk            %a6
1559        rts
1560
1561        global          _ftanhx_
1562_ftanhx_:
1563        link            %a6,&-LOCAL_SIZE
1564
1565        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1566        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1567        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1568
1569        fmov.l          &0x0,%fpcr              # zero FPCR
1570
1571#
1572#       copy, convert, and tag input argument
1573#
1574        lea             FP_SRC(%a6),%a0
1575        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
1576        mov.l           0x8+0x4(%a6),0x4(%a0)
1577        mov.l           0x8+0x8(%a6),0x8(%a0)
1578        bsr.l           tag                     # fetch operand type
1579        mov.b           %d0,STAG(%a6)
1580        mov.b           %d0,%d1
1581
1582        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1583
1584        clr.l           %d0
1585        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1586
1587        tst.b           %d1
1588        bne.b           _L5_2x
1589        bsr.l           stanh                   # operand is a NORM
1590        bra.b           _L5_6x
1591_L5_2x:
1592        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1593        bne.b           _L5_3x                  # no
1594        bsr.l           src_zero                        # yes
1595        bra.b           _L5_6x
1596_L5_3x:
1597        cmpi.b          %d1,&INF                # is operand an INF?
1598        bne.b           _L5_4x                  # no
1599        bsr.l           src_one                 # yes
1600        bra.b           _L5_6x
1601_L5_4x:
1602        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1603        bne.b           _L5_5x                  # no
1604        bsr.l           src_qnan                        # yes
1605        bra.b           _L5_6x
1606_L5_5x:
1607        bsr.l           stanhd                  # operand is a DENORM
1608_L5_6x:
1609
1610#
1611#       Result is now in FP0
1612#
1613        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1614        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1615        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1616        unlk            %a6
1617        rts
1618
1619
1620#########################################################################
1621# MONADIC TEMPLATE                                                      #
1622#########################################################################
1623        global          _fatans_
1624_fatans_:
1625        link            %a6,&-LOCAL_SIZE
1626
1627        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1628        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1629        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1630
1631        fmov.l          &0x0,%fpcr              # zero FPCR
1632
1633#
1634#       copy, convert, and tag input argument
1635#
1636        fmov.s          0x8(%a6),%fp0           # load sgl input
1637        fmov.x          %fp0,FP_SRC(%a6)
1638        lea             FP_SRC(%a6),%a0
1639        bsr.l           tag                     # fetch operand type
1640        mov.b           %d0,STAG(%a6)
1641        mov.b           %d0,%d1
1642
1643        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1644
1645        clr.l           %d0
1646        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1647
1648        tst.b           %d1
1649        bne.b           _L6_2s
1650        bsr.l           satan                   # operand is a NORM
1651        bra.b           _L6_6s
1652_L6_2s:
1653        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1654        bne.b           _L6_3s                  # no
1655        bsr.l           src_zero                        # yes
1656        bra.b           _L6_6s
1657_L6_3s:
1658        cmpi.b          %d1,&INF                # is operand an INF?
1659        bne.b           _L6_4s                  # no
1660        bsr.l           spi_2                   # yes
1661        bra.b           _L6_6s
1662_L6_4s:
1663        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1664        bne.b           _L6_5s                  # no
1665        bsr.l           src_qnan                        # yes
1666        bra.b           _L6_6s
1667_L6_5s:
1668        bsr.l           satand                  # operand is a DENORM
1669_L6_6s:
1670
1671#
1672#       Result is now in FP0
1673#
1674        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1675        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1676        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1677        unlk            %a6
1678        rts
1679
1680        global          _fatand_
1681_fatand_:
1682        link            %a6,&-LOCAL_SIZE
1683
1684        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1685        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1686        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1687
1688        fmov.l          &0x0,%fpcr              # zero FPCR
1689
1690#
1691#       copy, convert, and tag input argument
1692#
1693        fmov.d          0x8(%a6),%fp0           # load dbl input
1694        fmov.x          %fp0,FP_SRC(%a6)
1695        lea             FP_SRC(%a6),%a0
1696        bsr.l           tag                     # fetch operand type
1697        mov.b           %d0,STAG(%a6)
1698        mov.b           %d0,%d1
1699
1700        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1701
1702        clr.l           %d0
1703        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1704
1705        mov.b           %d1,STAG(%a6)
1706        tst.b           %d1
1707        bne.b           _L6_2d
1708        bsr.l           satan                   # operand is a NORM
1709        bra.b           _L6_6d
1710_L6_2d:
1711        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1712        bne.b           _L6_3d                  # no
1713        bsr.l           src_zero                        # yes
1714        bra.b           _L6_6d
1715_L6_3d:
1716        cmpi.b          %d1,&INF                # is operand an INF?
1717        bne.b           _L6_4d                  # no
1718        bsr.l           spi_2                   # yes
1719        bra.b           _L6_6d
1720_L6_4d:
1721        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1722        bne.b           _L6_5d                  # no
1723        bsr.l           src_qnan                        # yes
1724        bra.b           _L6_6d
1725_L6_5d:
1726        bsr.l           satand                  # operand is a DENORM
1727_L6_6d:
1728
1729#
1730#       Result is now in FP0
1731#
1732        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1733        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1734        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1735        unlk            %a6
1736        rts
1737
1738        global          _fatanx_
1739_fatanx_:
1740        link            %a6,&-LOCAL_SIZE
1741
1742        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1743        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1744        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1745
1746        fmov.l          &0x0,%fpcr              # zero FPCR
1747
1748#
1749#       copy, convert, and tag input argument
1750#
1751        lea             FP_SRC(%a6),%a0
1752        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
1753        mov.l           0x8+0x4(%a6),0x4(%a0)
1754        mov.l           0x8+0x8(%a6),0x8(%a0)
1755        bsr.l           tag                     # fetch operand type
1756        mov.b           %d0,STAG(%a6)
1757        mov.b           %d0,%d1
1758
1759        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1760
1761        clr.l           %d0
1762        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1763
1764        tst.b           %d1
1765        bne.b           _L6_2x
1766        bsr.l           satan                   # operand is a NORM
1767        bra.b           _L6_6x
1768_L6_2x:
1769        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1770        bne.b           _L6_3x                  # no
1771        bsr.l           src_zero                        # yes
1772        bra.b           _L6_6x
1773_L6_3x:
1774        cmpi.b          %d1,&INF                # is operand an INF?
1775        bne.b           _L6_4x                  # no
1776        bsr.l           spi_2                   # yes
1777        bra.b           _L6_6x
1778_L6_4x:
1779        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1780        bne.b           _L6_5x                  # no
1781        bsr.l           src_qnan                        # yes
1782        bra.b           _L6_6x
1783_L6_5x:
1784        bsr.l           satand                  # operand is a DENORM
1785_L6_6x:
1786
1787#
1788#       Result is now in FP0
1789#
1790        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1791        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1792        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1793        unlk            %a6
1794        rts
1795
1796
1797#########################################################################
1798# MONADIC TEMPLATE                                                      #
1799#########################################################################
1800        global          _fasins_
1801_fasins_:
1802        link            %a6,&-LOCAL_SIZE
1803
1804        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1805        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1806        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1807
1808        fmov.l          &0x0,%fpcr              # zero FPCR
1809
1810#
1811#       copy, convert, and tag input argument
1812#
1813        fmov.s          0x8(%a6),%fp0           # load sgl input
1814        fmov.x          %fp0,FP_SRC(%a6)
1815        lea             FP_SRC(%a6),%a0
1816        bsr.l           tag                     # fetch operand type
1817        mov.b           %d0,STAG(%a6)
1818        mov.b           %d0,%d1
1819
1820        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1821
1822        clr.l           %d0
1823        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1824
1825        tst.b           %d1
1826        bne.b           _L7_2s
1827        bsr.l           sasin                   # operand is a NORM
1828        bra.b           _L7_6s
1829_L7_2s:
1830        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1831        bne.b           _L7_3s                  # no
1832        bsr.l           src_zero                        # yes
1833        bra.b           _L7_6s
1834_L7_3s:
1835        cmpi.b          %d1,&INF                # is operand an INF?
1836        bne.b           _L7_4s                  # no
1837        bsr.l           t_operr                 # yes
1838        bra.b           _L7_6s
1839_L7_4s:
1840        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1841        bne.b           _L7_5s                  # no
1842        bsr.l           src_qnan                        # yes
1843        bra.b           _L7_6s
1844_L7_5s:
1845        bsr.l           sasind                  # operand is a DENORM
1846_L7_6s:
1847
1848#
1849#       Result is now in FP0
1850#
1851        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1852        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1853        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1854        unlk            %a6
1855        rts
1856
1857        global          _fasind_
1858_fasind_:
1859        link            %a6,&-LOCAL_SIZE
1860
1861        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1862        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1863        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1864
1865        fmov.l          &0x0,%fpcr              # zero FPCR
1866
1867#
1868#       copy, convert, and tag input argument
1869#
1870        fmov.d          0x8(%a6),%fp0           # load dbl input
1871        fmov.x          %fp0,FP_SRC(%a6)
1872        lea             FP_SRC(%a6),%a0
1873        bsr.l           tag                     # fetch operand type
1874        mov.b           %d0,STAG(%a6)
1875        mov.b           %d0,%d1
1876
1877        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1878
1879        clr.l           %d0
1880        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1881
1882        mov.b           %d1,STAG(%a6)
1883        tst.b           %d1
1884        bne.b           _L7_2d
1885        bsr.l           sasin                   # operand is a NORM
1886        bra.b           _L7_6d
1887_L7_2d:
1888        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1889        bne.b           _L7_3d                  # no
1890        bsr.l           src_zero                        # yes
1891        bra.b           _L7_6d
1892_L7_3d:
1893        cmpi.b          %d1,&INF                # is operand an INF?
1894        bne.b           _L7_4d                  # no
1895        bsr.l           t_operr                 # yes
1896        bra.b           _L7_6d
1897_L7_4d:
1898        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1899        bne.b           _L7_5d                  # no
1900        bsr.l           src_qnan                        # yes
1901        bra.b           _L7_6d
1902_L7_5d:
1903        bsr.l           sasind                  # operand is a DENORM
1904_L7_6d:
1905
1906#
1907#       Result is now in FP0
1908#
1909        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1910        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1911        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1912        unlk            %a6
1913        rts
1914
1915        global          _fasinx_
1916_fasinx_:
1917        link            %a6,&-LOCAL_SIZE
1918
1919        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1920        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1921        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1922
1923        fmov.l          &0x0,%fpcr              # zero FPCR
1924
1925#
1926#       copy, convert, and tag input argument
1927#
1928        lea             FP_SRC(%a6),%a0
1929        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
1930        mov.l           0x8+0x4(%a6),0x4(%a0)
1931        mov.l           0x8+0x8(%a6),0x8(%a0)
1932        bsr.l           tag                     # fetch operand type
1933        mov.b           %d0,STAG(%a6)
1934        mov.b           %d0,%d1
1935
1936        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1937
1938        clr.l           %d0
1939        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
1940
1941        tst.b           %d1
1942        bne.b           _L7_2x
1943        bsr.l           sasin                   # operand is a NORM
1944        bra.b           _L7_6x
1945_L7_2x:
1946        cmpi.b          %d1,&ZERO               # is operand a ZERO?
1947        bne.b           _L7_3x                  # no
1948        bsr.l           src_zero                        # yes
1949        bra.b           _L7_6x
1950_L7_3x:
1951        cmpi.b          %d1,&INF                # is operand an INF?
1952        bne.b           _L7_4x                  # no
1953        bsr.l           t_operr                 # yes
1954        bra.b           _L7_6x
1955_L7_4x:
1956        cmpi.b          %d1,&QNAN               # is operand a QNAN?
1957        bne.b           _L7_5x                  # no
1958        bsr.l           src_qnan                        # yes
1959        bra.b           _L7_6x
1960_L7_5x:
1961        bsr.l           sasind                  # operand is a DENORM
1962_L7_6x:
1963
1964#
1965#       Result is now in FP0
1966#
1967        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
1968        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
1969        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
1970        unlk            %a6
1971        rts
1972
1973
1974#########################################################################
1975# MONADIC TEMPLATE                                                      #
1976#########################################################################
1977        global          _fatanhs_
1978_fatanhs_:
1979        link            %a6,&-LOCAL_SIZE
1980
1981        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
1982        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
1983        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
1984
1985        fmov.l          &0x0,%fpcr              # zero FPCR
1986
1987#
1988#       copy, convert, and tag input argument
1989#
1990        fmov.s          0x8(%a6),%fp0           # load sgl input
1991        fmov.x          %fp0,FP_SRC(%a6)
1992        lea             FP_SRC(%a6),%a0
1993        bsr.l           tag                     # fetch operand type
1994        mov.b           %d0,STAG(%a6)
1995        mov.b           %d0,%d1
1996
1997        andi.l          &0x00ff00ff,USER_FPSR(%a6)
1998
1999        clr.l           %d0
2000        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec

2001
2002        tst.b           %d1
2003        bne.b           _L8_2s
2004        bsr.l           satanh                  # operand is a NORM
2005        bra.b           _L8_6s
2006_L8_2s:
2007        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2008        bne.b           _L8_3s                  # no
2009        bsr.l           src_zero                        # yes
2010        bra.b           _L8_6s
2011_L8_3s:
2012        cmpi.b          %d1,&INF                # is operand an INF?
2013        bne.b           _L8_4s                  # no
2014        bsr.l           t_operr                 # yes
2015        bra.b           _L8_6s
2016_L8_4s:
2017        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2018        bne.b           _L8_5s                  # no
2019        bsr.l           src_qnan                        # yes
2020        bra.b           _L8_6s
2021_L8_5s:
2022        bsr.l           satanhd                 # operand is a DENORM
2023_L8_6s:
2024
2025#
2026#       Result is now in FP0
2027#
2028        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2029        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2030        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2031        unlk            %a6
2032        rts
2033
2034        global          _fatanhd_
2035_fatanhd_:
2036        link            %a6,&-LOCAL_SIZE
2037
2038        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2039        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2040        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2041
2042        fmov.l          &0x0,%fpcr              # zero FPCR
2043
2044#
2045#       copy, convert, and tag input argument
2046#
2047        fmov.d          0x8(%a6),%fp0           # load dbl input
2048        fmov.x          %fp0,FP_SRC(%a6)
2049        lea             FP_SRC(%a6),%a0
2050        bsr.l           tag                     # fetch operand type
2051        mov.b           %d0,STAG(%a6)
2052        mov.b           %d0,%d1
2053
2054        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2055
2056        clr.l           %d0
2057        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2058
2059        mov.b           %d1,STAG(%a6)
2060        tst.b           %d1
2061        bne.b           _L8_2d
2062        bsr.l           satanh                  # operand is a NORM
2063        bra.b           _L8_6d
2064_L8_2d:
2065        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2066        bne.b           _L8_3d                  # no
2067        bsr.l           src_zero                        # yes
2068        bra.b           _L8_6d
2069_L8_3d:
2070        cmpi.b          %d1,&INF                # is operand an INF?
2071        bne.b           _L8_4d                  # no
2072        bsr.l           t_operr                 # yes
2073        bra.b           _L8_6d
2074_L8_4d:
2075        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2076        bne.b           _L8_5d                  # no
2077        bsr.l           src_qnan                        # yes
2078        bra.b           _L8_6d
2079_L8_5d:
2080        bsr.l           satanhd                 # operand is a DENORM
2081_L8_6d:
2082
2083#
2084#       Result is now in FP0
2085#
2086        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2087        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2088        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2089        unlk            %a6
2090        rts
2091
2092        global          _fatanhx_
2093_fatanhx_:
2094        link            %a6,&-LOCAL_SIZE
2095
2096        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2097        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2098        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2099
2100        fmov.l          &0x0,%fpcr              # zero FPCR
2101
2102#
2103#       copy, convert, and tag input argument
2104#
2105        lea             FP_SRC(%a6),%a0
2106        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
2107        mov.l           0x8+0x4(%a6),0x4(%a0)
2108        mov.l           0x8+0x8(%a6),0x8(%a0)
2109        bsr.l           tag                     # fetch operand type
2110        mov.b           %d0,STAG(%a6)
2111        mov.b           %d0,%d1
2112
2113        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2114
2115        clr.l           %d0
2116        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2117
2118        tst.b           %d1
2119        bne.b           _L8_2x
2120        bsr.l           satanh                  # operand is a NORM
2121        bra.b           _L8_6x
2122_L8_2x:
2123        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2124        bne.b           _L8_3x                  # no
2125        bsr.l           src_zero                        # yes
2126        bra.b           _L8_6x
2127_L8_3x:
2128        cmpi.b          %d1,&INF                # is operand an INF?
2129        bne.b           _L8_4x                  # no
2130        bsr.l           t_operr                 # yes
2131        bra.b           _L8_6x
2132_L8_4x:
2133        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2134        bne.b           _L8_5x                  # no
2135        bsr.l           src_qnan                        # yes
2136        bra.b           _L8_6x
2137_L8_5x:
2138        bsr.l           satanhd                 # operand is a DENORM
2139_L8_6x:
2140
2141#
2142#       Result is now in FP0
2143#
2144        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2145        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2146        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2147        unlk            %a6
2148        rts
2149
2150
2151#########################################################################
2152# MONADIC TEMPLATE                                                      #
2153#########################################################################
2154        global          _ftans_
2155_ftans_:
2156        link            %a6,&-LOCAL_SIZE
2157
2158        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2159        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2160        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2161
2162        fmov.l          &0x0,%fpcr              # zero FPCR
2163
2164#
2165#       copy, convert, and tag input argument
2166#
2167        fmov.s          0x8(%a6),%fp0           # load sgl input
2168        fmov.x          %fp0,FP_SRC(%a6)
2169        lea             FP_SRC(%a6),%a0
2170        bsr.l           tag                     # fetch operand type
2171        mov.b           %d0,STAG(%a6)
2172        mov.b           %d0,%d1
2173
2174        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2175
2176        clr.l           %d0
2177        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2178
2179        tst.b           %d1
2180        bne.b           _L9_2s
2181        bsr.l           stan                    # operand is a NORM
2182        bra.b           _L9_6s
2183_L9_2s:
2184        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2185        bne.b           _L9_3s                  # no
2186        bsr.l           src_zero                        # yes
2187        bra.b           _L9_6s
2188_L9_3s:
2189        cmpi.b          %d1,&INF                # is operand an INF?
2190        bne.b           _L9_4s                  # no
2191        bsr.l           t_operr                 # yes
2192        bra.b           _L9_6s
2193_L9_4s:
2194        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2195        bne.b           _L9_5s                  # no
2196        bsr.l           src_qnan                        # yes
2197        bra.b           _L9_6s
2198_L9_5s:
2199        bsr.l           stand                   # operand is a DENORM
2200_L9_6s:
2201
2202#
2203#       Result is now in FP0
2204#
2205        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2206        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2207        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2208        unlk            %a6
2209        rts
2210
2211        global          _ftand_
2212_ftand_:
2213        link            %a6,&-LOCAL_SIZE
2214
2215        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2216        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2217        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2218
2219        fmov.l          &0x0,%fpcr              # zero FPCR
2220
2221#
2222#       copy, convert, and tag input argument
2223#
2224        fmov.d          0x8(%a6),%fp0           # load dbl input
2225        fmov.x          %fp0,FP_SRC(%a6)
2226        lea             FP_SRC(%a6),%a0
2227        bsr.l           tag                     # fetch operand type
2228        mov.b           %d0,STAG(%a6)
2229        mov.b           %d0,%d1
2230
2231        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2232
2233        clr.l           %d0
2234        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2235
2236        mov.b           %d1,STAG(%a6)
2237        tst.b           %d1
2238        bne.b           _L9_2d
2239        bsr.l           stan                    # operand is a NORM
2240        bra.b           _L9_6d
2241_L9_2d:
2242        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2243        bne.b           _L9_3d                  # no
2244        bsr.l           src_zero                        # yes
2245        bra.b           _L9_6d
2246_L9_3d:
2247        cmpi.b          %d1,&INF                # is operand an INF?
2248        bne.b           _L9_4d                  # no
2249        bsr.l           t_operr                 # yes
2250        bra.b           _L9_6d
2251_L9_4d:
2252        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2253        bne.b           _L9_5d                  # no
2254        bsr.l           src_qnan                        # yes
2255        bra.b           _L9_6d
2256_L9_5d:
2257        bsr.l           stand                   # operand is a DENORM
2258_L9_6d:
2259
2260#
2261#       Result is now in FP0
2262#
2263        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2264        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2265        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2266        unlk            %a6
2267        rts
2268
2269        global          _ftanx_
2270_ftanx_:
2271        link            %a6,&-LOCAL_SIZE
2272
2273        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2274        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2275        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2276
2277        fmov.l          &0x0,%fpcr              # zero FPCR
2278
2279#
2280#       copy, convert, and tag input argument
2281#
2282        lea             FP_SRC(%a6),%a0
2283        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
2284        mov.l           0x8+0x4(%a6),0x4(%a0)
2285        mov.l           0x8+0x8(%a6),0x8(%a0)
2286        bsr.l           tag                     # fetch operand type
2287        mov.b           %d0,STAG(%a6)
2288        mov.b           %d0,%d1
2289
2290        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2291
2292        clr.l           %d0
2293        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2294
2295        tst.b           %d1
2296        bne.b           _L9_2x
2297        bsr.l           stan                    # operand is a NORM
2298        bra.b           _L9_6x
2299_L9_2x:
2300        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2301        bne.b           _L9_3x                  # no
2302        bsr.l           src_zero                        # yes
2303        bra.b           _L9_6x
2304_L9_3x:
2305        cmpi.b          %d1,&INF                # is operand an INF?
2306        bne.b           _L9_4x                  # no
2307        bsr.l           t_operr                 # yes
2308        bra.b           _L9_6x
2309_L9_4x:
2310        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2311        bne.b           _L9_5x                  # no
2312        bsr.l           src_qnan                        # yes
2313        bra.b           _L9_6x
2314_L9_5x:
2315        bsr.l           stand                   # operand is a DENORM
2316_L9_6x:
2317
2318#
2319#       Result is now in FP0
2320#
2321        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2322        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2323        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2324        unlk            %a6
2325        rts
2326
2327
2328#########################################################################
2329# MONADIC TEMPLATE                                                      #
2330#########################################################################
2331        global          _fetoxs_
2332_fetoxs_:
2333        link            %a6,&-LOCAL_SIZE
2334
2335        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2336        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2337        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2338
2339        fmov.l          &0x0,%fpcr              # zero FPCR
2340
2341#
2342#       copy, convert, and tag input argument
2343#
2344        fmov.s          0x8(%a6),%fp0           # load sgl input
2345        fmov.x          %fp0,FP_SRC(%a6)
2346        lea             FP_SRC(%a6),%a0
2347        bsr.l           tag                     # fetch operand type
2348        mov.b           %d0,STAG(%a6)
2349        mov.b           %d0,%d1
2350
2351        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2352
2353        clr.l           %d0
2354        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2355
2356        tst.b           %d1
2357        bne.b           _L10_2s
2358        bsr.l           setox                   # operand is a NORM
2359        bra.b           _L10_6s
2360_L10_2s:
2361        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2362        bne.b           _L10_3s                 # no
2363        bsr.l           ld_pone                 # yes
2364        bra.b           _L10_6s
2365_L10_3s:
2366        cmpi.b          %d1,&INF                # is operand an INF?
2367        bne.b           _L10_4s                 # no
2368        bsr.l           szr_inf                 # yes
2369        bra.b           _L10_6s
2370_L10_4s:
2371        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2372        bne.b           _L10_5s                 # no
2373        bsr.l           src_qnan                        # yes
2374        bra.b           _L10_6s
2375_L10_5s:
2376        bsr.l           setoxd                  # operand is a DENORM
2377_L10_6s:
2378
2379#
2380#       Result is now in FP0
2381#
2382        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2383        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2384        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2385        unlk            %a6
2386        rts
2387
2388        global          _fetoxd_
2389_fetoxd_:
2390        link            %a6,&-LOCAL_SIZE
2391
2392        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2393        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2394        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2395
2396        fmov.l          &0x0,%fpcr              # zero FPCR
2397
2398#
2399#       copy, convert, and tag input argument
2400#
2401        fmov.d          0x8(%a6),%fp0           # load dbl input
2402        fmov.x          %fp0,FP_SRC(%a6)
2403        lea             FP_SRC(%a6),%a0
2404        bsr.l           tag                     # fetch operand type
2405        mov.b           %d0,STAG(%a6)
2406        mov.b           %d0,%d1
2407
2408        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2409
2410        clr.l           %d0
2411        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2412
2413        mov.b           %d1,STAG(%a6)
2414        tst.b           %d1
2415        bne.b           _L10_2d
2416        bsr.l           setox                   # operand is a NORM
2417        bra.b           _L10_6d
2418_L10_2d:
2419        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2420        bne.b           _L10_3d                 # no
2421        bsr.l           ld_pone                 # yes
2422        bra.b           _L10_6d
2423_L10_3d:
2424        cmpi.b          %d1,&INF                # is operand an INF?
2425        bne.b           _L10_4d                 # no
2426        bsr.l           szr_inf                 # yes
2427        bra.b           _L10_6d
2428_L10_4d:
2429        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2430        bne.b           _L10_5d                 # no
2431        bsr.l           src_qnan                        # yes
2432        bra.b           _L10_6d
2433_L10_5d:
2434        bsr.l           setoxd                  # operand is a DENORM
2435_L10_6d:
2436
2437#
2438#       Result is now in FP0
2439#
2440        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2441        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2442        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2443        unlk            %a6
2444        rts
2445
2446        global          _fetoxx_
2447_fetoxx_:
2448        link            %a6,&-LOCAL_SIZE
2449
2450        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2451        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2452        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2453
2454        fmov.l          &0x0,%fpcr              # zero FPCR
2455
2456#
2457#       copy, convert, and tag input argument
2458#
2459        lea             FP_SRC(%a6),%a0
2460        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
2461        mov.l           0x8+0x4(%a6),0x4(%a0)
2462        mov.l           0x8+0x8(%a6),0x8(%a0)
2463        bsr.l           tag                     # fetch operand type
2464        mov.b           %d0,STAG(%a6)
2465        mov.b           %d0,%d1
2466
2467        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2468
2469        clr.l           %d0
2470        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2471
2472        tst.b           %d1
2473        bne.b           _L10_2x
2474        bsr.l           setox                   # operand is a NORM
2475        bra.b           _L10_6x
2476_L10_2x:
2477        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2478        bne.b           _L10_3x                 # no
2479        bsr.l           ld_pone                 # yes
2480        bra.b           _L10_6x
2481_L10_3x:
2482        cmpi.b          %d1,&INF                # is operand an INF?
2483        bne.b           _L10_4x                 # no
2484        bsr.l           szr_inf                 # yes
2485        bra.b           _L10_6x
2486_L10_4x:
2487        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2488        bne.b           _L10_5x                 # no
2489        bsr.l           src_qnan                        # yes
2490        bra.b           _L10_6x
2491_L10_5x:
2492        bsr.l           setoxd                  # operand is a DENORM
2493_L10_6x:
2494
2495#
2496#       Result is now in FP0
2497#
2498        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2499        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2500        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2501        unlk            %a6
2502        rts
2503
2504
2505#########################################################################
2506# MONADIC TEMPLATE                                                      #
2507#########################################################################
2508        global          _ftwotoxs_
2509_ftwotoxs_:
2510        link            %a6,&-LOCAL_SIZE
2511
2512        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2513        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2514        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2515
2516        fmov.l          &0x0,%fpcr              # zero FPCR
2517
2518#
2519#       copy, convert, and tag input argument
2520#
2521        fmov.s          0x8(%a6),%fp0           # load sgl input
2522        fmov.x          %fp0,FP_SRC(%a6)
2523        lea             FP_SRC(%a6),%a0
2524        bsr.l           tag                     # fetch operand type
2525        mov.b           %d0,STAG(%a6)
2526        mov.b           %d0,%d1
2527
2528        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2529
2530        clr.l           %d0
2531        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2532
2533        tst.b           %d1
2534        bne.b           _L11_2s
2535        bsr.l           stwotox                 # operand is a NORM
2536        bra.b           _L11_6s
2537_L11_2s:
2538        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2539        bne.b           _L11_3s                 # no
2540        bsr.l           ld_pone                 # yes
2541        bra.b           _L11_6s
2542_L11_3s:
2543        cmpi.b          %d1,&INF                # is operand an INF?
2544        bne.b           _L11_4s                 # no
2545        bsr.l           szr_inf                 # yes
2546        bra.b           _L11_6s
2547_L11_4s:
2548        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2549        bne.b           _L11_5s                 # no
2550        bsr.l           src_qnan                        # yes
2551        bra.b           _L11_6s
2552_L11_5s:
2553        bsr.l           stwotoxd                        # operand is a DENORM
2554_L11_6s:
2555
2556#
2557#       Result is now in FP0
2558#
2559        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2560        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2561        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2562        unlk            %a6
2563        rts
2564
2565        global          _ftwotoxd_
2566_ftwotoxd_:
2567        link            %a6,&-LOCAL_SIZE
2568
2569        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2570        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2571        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2572
2573        fmov.l          &0x0,%fpcr              # zero FPCR
2574
2575#
2576#       copy, convert, and tag input argument
2577#
2578        fmov.d          0x8(%a6),%fp0           # load dbl input
2579        fmov.x          %fp0,FP_SRC(%a6)
2580        lea             FP_SRC(%a6),%a0
2581        bsr.l           tag                     # fetch operand type
2582        mov.b           %d0,STAG(%a6)
2583        mov.b           %d0,%d1
2584
2585        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2586
2587        clr.l           %d0
2588        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2589
2590        mov.b           %d1,STAG(%a6)
2591        tst.b           %d1
2592        bne.b           _L11_2d
2593        bsr.l           stwotox                 # operand is a NORM
2594        bra.b           _L11_6d
2595_L11_2d:
2596        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2597        bne.b           _L11_3d                 # no
2598        bsr.l           ld_pone                 # yes
2599        bra.b           _L11_6d
2600_L11_3d:
2601        cmpi.b          %d1,&INF                # is operand an INF?
2602        bne.b           _L11_4d                 # no
2603        bsr.l           szr_inf                 # yes
2604        bra.b           _L11_6d
2605_L11_4d:
2606        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2607        bne.b           _L11_5d                 # no
2608        bsr.l           src_qnan                        # yes
2609        bra.b           _L11_6d
2610_L11_5d:
2611        bsr.l           stwotoxd                        # operand is a DENORM
2612_L11_6d:
2613
2614#
2615#       Result is now in FP0
2616#
2617        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2618        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2619        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2620        unlk            %a6
2621        rts
2622
2623        global          _ftwotoxx_
2624_ftwotoxx_:
2625        link            %a6,&-LOCAL_SIZE
2626
2627        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2628        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2629        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2630
2631        fmov.l          &0x0,%fpcr              # zero FPCR
2632
2633#
2634#       copy, convert, and tag input argument
2635#
2636        lea             FP_SRC(%a6),%a0
2637        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
2638        mov.l           0x8+0x4(%a6),0x4(%a0)
2639        mov.l           0x8+0x8(%a6),0x8(%a0)
2640        bsr.l           tag                     # fetch operand type
2641        mov.b           %d0,STAG(%a6)
2642        mov.b           %d0,%d1
2643
2644        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2645
2646        clr.l           %d0
2647        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2648
2649        tst.b           %d1
2650        bne.b           _L11_2x
2651        bsr.l           stwotox                 # operand is a NORM
2652        bra.b           _L11_6x
2653_L11_2x:
2654        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2655        bne.b           _L11_3x                 # no
2656        bsr.l           ld_pone                 # yes
2657        bra.b           _L11_6x
2658_L11_3x:
2659        cmpi.b          %d1,&INF                # is operand an INF?
2660        bne.b           _L11_4x                 # no
2661        bsr.l           szr_inf                 # yes
2662        bra.b           _L11_6x
2663_L11_4x:
2664        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2665        bne.b           _L11_5x                 # no
2666        bsr.l           src_qnan                        # yes
2667        bra.b           _L11_6x
2668_L11_5x:
2669        bsr.l           stwotoxd                        # operand is a DENORM
2670_L11_6x:
2671
2672#
2673#       Result is now in FP0
2674#
2675        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2676        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2677        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2678        unlk            %a6
2679        rts
2680
2681
2682#########################################################################
2683# MONADIC TEMPLATE                                                      #
2684#########################################################################
2685        global          _ftentoxs_
2686_ftentoxs_:
2687        link            %a6,&-LOCAL_SIZE
2688
2689        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2690        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2691        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2692
2693        fmov.l          &0x0,%fpcr              # zero FPCR
2694
2695#
2696#       copy, convert, and tag input argument
2697#
2698        fmov.s          0x8(%a6),%fp0           # load sgl input
2699        fmov.x          %fp0,FP_SRC(%a6)
2700        lea             FP_SRC(%a6),%a0
2701        bsr.l           tag                     # fetch operand type
2702        mov.b           %d0,STAG(%a6)
2703        mov.b           %d0,%d1
2704
2705        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2706
2707        clr.l           %d0
2708        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2709
2710        tst.b           %d1
2711        bne.b           _L12_2s
2712        bsr.l           stentox                 # operand is a NORM
2713        bra.b           _L12_6s
2714_L12_2s:
2715        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2716        bne.b           _L12_3s                 # no
2717        bsr.l           ld_pone                 # yes
2718        bra.b           _L12_6s
2719_L12_3s:
2720        cmpi.b          %d1,&INF                # is operand an INF?
2721        bne.b           _L12_4s                 # no
2722        bsr.l           szr_inf                 # yes
2723        bra.b           _L12_6s
2724_L12_4s:
2725        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2726        bne.b           _L12_5s                 # no
2727        bsr.l           src_qnan                        # yes
2728        bra.b           _L12_6s
2729_L12_5s:
2730        bsr.l           stentoxd                        # operand is a DENORM
2731_L12_6s:
2732
2733#
2734#       Result is now in FP0
2735#
2736        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2737        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2738        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2739        unlk            %a6
2740        rts
2741
2742        global          _ftentoxd_
2743_ftentoxd_:
2744        link            %a6,&-LOCAL_SIZE
2745
2746        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2747        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2748        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2749
2750        fmov.l          &0x0,%fpcr              # zero FPCR
2751
2752#
2753#       copy, convert, and tag input argument
2754#
2755        fmov.d          0x8(%a6),%fp0           # load dbl input
2756        fmov.x          %fp0,FP_SRC(%a6)
2757        lea             FP_SRC(%a6),%a0
2758        bsr.l           tag                     # fetch operand type
2759        mov.b           %d0,STAG(%a6)
2760        mov.b           %d0,%d1
2761
2762        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2763
2764        clr.l           %d0
2765        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2766
2767        mov.b           %d1,STAG(%a6)
2768        tst.b           %d1
2769        bne.b           _L12_2d
2770        bsr.l           stentox                 # operand is a NORM
2771        bra.b           _L12_6d
2772_L12_2d:
2773        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2774        bne.b           _L12_3d                 # no
2775        bsr.l           ld_pone                 # yes
2776        bra.b           _L12_6d
2777_L12_3d:
2778        cmpi.b          %d1,&INF                # is operand an INF?
2779        bne.b           _L12_4d                 # no
2780        bsr.l           szr_inf                 # yes
2781        bra.b           _L12_6d
2782_L12_4d:
2783        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2784        bne.b           _L12_5d                 # no
2785        bsr.l           src_qnan                        # yes
2786        bra.b           _L12_6d
2787_L12_5d:
2788        bsr.l           stentoxd                        # operand is a DENORM
2789_L12_6d:
2790
2791#
2792#       Result is now in FP0
2793#
2794        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2795        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2796        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2797        unlk            %a6
2798        rts
2799
2800        global          _ftentoxx_
2801_ftentoxx_:
2802        link            %a6,&-LOCAL_SIZE
2803
2804        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2805        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2806        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2807
2808        fmov.l          &0x0,%fpcr              # zero FPCR
2809
2810#
2811#       copy, convert, and tag input argument
2812#
2813        lea             FP_SRC(%a6),%a0
2814        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
2815        mov.l           0x8+0x4(%a6),0x4(%a0)
2816        mov.l           0x8+0x8(%a6),0x8(%a0)
2817        bsr.l           tag                     # fetch operand type
2818        mov.b           %d0,STAG(%a6)
2819        mov.b           %d0,%d1
2820
2821        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2822
2823        clr.l           %d0
2824        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2825
2826        tst.b           %d1
2827        bne.b           _L12_2x
2828        bsr.l           stentox                 # operand is a NORM
2829        bra.b           _L12_6x
2830_L12_2x:
2831        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2832        bne.b           _L12_3x                 # no
2833        bsr.l           ld_pone                 # yes
2834        bra.b           _L12_6x
2835_L12_3x:
2836        cmpi.b          %d1,&INF                # is operand an INF?
2837        bne.b           _L12_4x                 # no
2838        bsr.l           szr_inf                 # yes
2839        bra.b           _L12_6x
2840_L12_4x:
2841        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2842        bne.b           _L12_5x                 # no
2843        bsr.l           src_qnan                        # yes
2844        bra.b           _L12_6x
2845_L12_5x:
2846        bsr.l           stentoxd                        # operand is a DENORM
2847_L12_6x:
2848
2849#
2850#       Result is now in FP0
2851#
2852        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2853        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2854        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2855        unlk            %a6
2856        rts
2857
2858
2859#########################################################################
2860# MONADIC TEMPLATE                                                      #
2861#########################################################################
2862        global          _flogns_
2863_flogns_:
2864        link            %a6,&-LOCAL_SIZE
2865
2866        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2867        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2868        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2869
2870        fmov.l          &0x0,%fpcr              # zero FPCR
2871
2872#
2873#       copy, convert, and tag input argument
2874#
2875        fmov.s          0x8(%a6),%fp0           # load sgl input
2876        fmov.x          %fp0,FP_SRC(%a6)
2877        lea             FP_SRC(%a6),%a0
2878        bsr.l           tag                     # fetch operand type
2879        mov.b           %d0,STAG(%a6)
2880        mov.b           %d0,%d1
2881
2882        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2883
2884        clr.l           %d0
2885        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2886
2887        tst.b           %d1
2888        bne.b           _L13_2s
2889        bsr.l           slogn                   # operand is a NORM
2890        bra.b           _L13_6s
2891_L13_2s:
2892        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2893        bne.b           _L13_3s                 # no
2894        bsr.l           t_dz2                   # yes
2895        bra.b           _L13_6s
2896_L13_3s:
2897        cmpi.b          %d1,&INF                # is operand an INF?
2898        bne.b           _L13_4s                 # no
2899        bsr.l           sopr_inf                        # yes
2900        bra.b           _L13_6s
2901_L13_4s:
2902        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2903        bne.b           _L13_5s                 # no
2904        bsr.l           src_qnan                        # yes
2905        bra.b           _L13_6s
2906_L13_5s:
2907        bsr.l           slognd                  # operand is a DENORM
2908_L13_6s:
2909
2910#
2911#       Result is now in FP0
2912#
2913        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2914        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2915        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2916        unlk            %a6
2917        rts
2918
2919        global          _flognd_
2920_flognd_:
2921        link            %a6,&-LOCAL_SIZE
2922
2923        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2924        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2925        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2926
2927        fmov.l          &0x0,%fpcr              # zero FPCR
2928
2929#
2930#       copy, convert, and tag input argument
2931#
2932        fmov.d          0x8(%a6),%fp0           # load dbl input
2933        fmov.x          %fp0,FP_SRC(%a6)
2934        lea             FP_SRC(%a6),%a0
2935        bsr.l           tag                     # fetch operand type
2936        mov.b           %d0,STAG(%a6)
2937        mov.b           %d0,%d1
2938
2939        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2940
2941        clr.l           %d0
2942        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
2943
2944        mov.b           %d1,STAG(%a6)
2945        tst.b           %d1
2946        bne.b           _L13_2d
2947        bsr.l           slogn                   # operand is a NORM
2948        bra.b           _L13_6d
2949_L13_2d:
2950        cmpi.b          %d1,&ZERO               # is operand a ZERO?
2951        bne.b           _L13_3d                 # no
2952        bsr.l           t_dz2                   # yes
2953        bra.b           _L13_6d
2954_L13_3d:
2955        cmpi.b          %d1,&INF                # is operand an INF?
2956        bne.b           _L13_4d                 # no
2957        bsr.l           sopr_inf                        # yes
2958        bra.b           _L13_6d
2959_L13_4d:
2960        cmpi.b          %d1,&QNAN               # is operand a QNAN?
2961        bne.b           _L13_5d                 # no
2962        bsr.l           src_qnan                        # yes
2963        bra.b           _L13_6d
2964_L13_5d:
2965        bsr.l           slognd                  # operand is a DENORM
2966_L13_6d:
2967
2968#
2969#       Result is now in FP0
2970#
2971        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
2972        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
2973        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
2974        unlk            %a6
2975        rts
2976
2977        global          _flognx_
2978_flognx_:
2979        link            %a6,&-LOCAL_SIZE
2980
2981        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
2982        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
2983        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
2984
2985        fmov.l          &0x0,%fpcr              # zero FPCR
2986
2987#
2988#       copy, convert, and tag input argument
2989#
2990        lea             FP_SRC(%a6),%a0
2991        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
2992        mov.l           0x8+0x4(%a6),0x4(%a0)
2993        mov.l           0x8+0x8(%a6),0x8(%a0)
2994        bsr.l           tag                     # fetch operand type
2995        mov.b           %d0,STAG(%a6)
2996        mov.b           %d0,%d1
2997
2998        andi.l          &0x00ff00ff,USER_FPSR(%a6)
2999
3000        clr.l           %d0

3001        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3002
3003        tst.b           %d1
3004        bne.b           _L13_2x
3005        bsr.l           slogn                   # operand is a NORM
3006        bra.b           _L13_6x
3007_L13_2x:
3008        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3009        bne.b           _L13_3x                 # no
3010        bsr.l           t_dz2                   # yes
3011        bra.b           _L13_6x
3012_L13_3x:
3013        cmpi.b          %d1,&INF                # is operand an INF?
3014        bne.b           _L13_4x                 # no
3015        bsr.l           sopr_inf                        # yes
3016        bra.b           _L13_6x
3017_L13_4x:
3018        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3019        bne.b           _L13_5x                 # no
3020        bsr.l           src_qnan                        # yes
3021        bra.b           _L13_6x
3022_L13_5x:
3023        bsr.l           slognd                  # operand is a DENORM
3024_L13_6x:
3025
3026#
3027#       Result is now in FP0
3028#
3029        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3030        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3031        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3032        unlk            %a6
3033        rts
3034
3035
3036#########################################################################
3037# MONADIC TEMPLATE                                                      #
3038#########################################################################
3039        global          _flog10s_
3040_flog10s_:
3041        link            %a6,&-LOCAL_SIZE
3042
3043        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3044        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3045        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3046
3047        fmov.l          &0x0,%fpcr              # zero FPCR
3048
3049#
3050#       copy, convert, and tag input argument
3051#
3052        fmov.s          0x8(%a6),%fp0           # load sgl input
3053        fmov.x          %fp0,FP_SRC(%a6)
3054        lea             FP_SRC(%a6),%a0
3055        bsr.l           tag                     # fetch operand type
3056        mov.b           %d0,STAG(%a6)
3057        mov.b           %d0,%d1
3058
3059        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3060
3061        clr.l           %d0
3062        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3063
3064        tst.b           %d1
3065        bne.b           _L14_2s
3066        bsr.l           slog10                  # operand is a NORM
3067        bra.b           _L14_6s
3068_L14_2s:
3069        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3070        bne.b           _L14_3s                 # no
3071        bsr.l           t_dz2                   # yes
3072        bra.b           _L14_6s
3073_L14_3s:
3074        cmpi.b          %d1,&INF                # is operand an INF?
3075        bne.b           _L14_4s                 # no
3076        bsr.l           sopr_inf                        # yes
3077        bra.b           _L14_6s
3078_L14_4s:
3079        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3080        bne.b           _L14_5s                 # no
3081        bsr.l           src_qnan                        # yes
3082        bra.b           _L14_6s
3083_L14_5s:
3084        bsr.l           slog10d                 # operand is a DENORM
3085_L14_6s:
3086
3087#
3088#       Result is now in FP0
3089#
3090        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3091        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3092        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3093        unlk            %a6
3094        rts
3095
3096        global          _flog10d_
3097_flog10d_:
3098        link            %a6,&-LOCAL_SIZE
3099
3100        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3101        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3102        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3103
3104        fmov.l          &0x0,%fpcr              # zero FPCR
3105
3106#
3107#       copy, convert, and tag input argument
3108#
3109        fmov.d          0x8(%a6),%fp0           # load dbl input
3110        fmov.x          %fp0,FP_SRC(%a6)
3111        lea             FP_SRC(%a6),%a0
3112        bsr.l           tag                     # fetch operand type
3113        mov.b           %d0,STAG(%a6)
3114        mov.b           %d0,%d1
3115
3116        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3117
3118        clr.l           %d0
3119        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3120
3121        mov.b           %d1,STAG(%a6)
3122        tst.b           %d1
3123        bne.b           _L14_2d
3124        bsr.l           slog10                  # operand is a NORM
3125        bra.b           _L14_6d
3126_L14_2d:
3127        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3128        bne.b           _L14_3d                 # no
3129        bsr.l           t_dz2                   # yes
3130        bra.b           _L14_6d
3131_L14_3d:
3132        cmpi.b          %d1,&INF                # is operand an INF?
3133        bne.b           _L14_4d                 # no
3134        bsr.l           sopr_inf                        # yes
3135        bra.b           _L14_6d
3136_L14_4d:
3137        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3138        bne.b           _L14_5d                 # no
3139        bsr.l           src_qnan                        # yes
3140        bra.b           _L14_6d
3141_L14_5d:
3142        bsr.l           slog10d                 # operand is a DENORM
3143_L14_6d:
3144
3145#
3146#       Result is now in FP0
3147#
3148        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3149        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3150        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3151        unlk            %a6
3152        rts
3153
3154        global          _flog10x_
3155_flog10x_:
3156        link            %a6,&-LOCAL_SIZE
3157
3158        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3159        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3160        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3161
3162        fmov.l          &0x0,%fpcr              # zero FPCR
3163
3164#
3165#       copy, convert, and tag input argument
3166#
3167        lea             FP_SRC(%a6),%a0
3168        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
3169        mov.l           0x8+0x4(%a6),0x4(%a0)
3170        mov.l           0x8+0x8(%a6),0x8(%a0)
3171        bsr.l           tag                     # fetch operand type
3172        mov.b           %d0,STAG(%a6)
3173        mov.b           %d0,%d1
3174
3175        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3176
3177        clr.l           %d0
3178        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3179
3180        tst.b           %d1
3181        bne.b           _L14_2x
3182        bsr.l           slog10                  # operand is a NORM
3183        bra.b           _L14_6x
3184_L14_2x:
3185        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3186        bne.b           _L14_3x                 # no
3187        bsr.l           t_dz2                   # yes
3188        bra.b           _L14_6x
3189_L14_3x:
3190        cmpi.b          %d1,&INF                # is operand an INF?
3191        bne.b           _L14_4x                 # no
3192        bsr.l           sopr_inf                        # yes
3193        bra.b           _L14_6x
3194_L14_4x:
3195        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3196        bne.b           _L14_5x                 # no
3197        bsr.l           src_qnan                        # yes
3198        bra.b           _L14_6x
3199_L14_5x:
3200        bsr.l           slog10d                 # operand is a DENORM
3201_L14_6x:
3202
3203#
3204#       Result is now in FP0
3205#
3206        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3207        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3208        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3209        unlk            %a6
3210        rts
3211
3212
3213#########################################################################
3214# MONADIC TEMPLATE                                                      #
3215#########################################################################
3216        global          _flog2s_
3217_flog2s_:
3218        link            %a6,&-LOCAL_SIZE
3219
3220        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3221        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3222        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3223
3224        fmov.l          &0x0,%fpcr              # zero FPCR
3225
3226#
3227#       copy, convert, and tag input argument
3228#
3229        fmov.s          0x8(%a6),%fp0           # load sgl input
3230        fmov.x          %fp0,FP_SRC(%a6)
3231        lea             FP_SRC(%a6),%a0
3232        bsr.l           tag                     # fetch operand type
3233        mov.b           %d0,STAG(%a6)
3234        mov.b           %d0,%d1
3235
3236        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3237
3238        clr.l           %d0
3239        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3240
3241        tst.b           %d1
3242        bne.b           _L15_2s
3243        bsr.l           slog2                   # operand is a NORM
3244        bra.b           _L15_6s
3245_L15_2s:
3246        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3247        bne.b           _L15_3s                 # no
3248        bsr.l           t_dz2                   # yes
3249        bra.b           _L15_6s
3250_L15_3s:
3251        cmpi.b          %d1,&INF                # is operand an INF?
3252        bne.b           _L15_4s                 # no
3253        bsr.l           sopr_inf                        # yes
3254        bra.b           _L15_6s
3255_L15_4s:
3256        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3257        bne.b           _L15_5s                 # no
3258        bsr.l           src_qnan                        # yes
3259        bra.b           _L15_6s
3260_L15_5s:
3261        bsr.l           slog2d                  # operand is a DENORM
3262_L15_6s:
3263
3264#
3265#       Result is now in FP0
3266#
3267        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3268        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3269        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3270        unlk            %a6
3271        rts
3272
3273        global          _flog2d_
3274_flog2d_:
3275        link            %a6,&-LOCAL_SIZE
3276
3277        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3278        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3279        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3280
3281        fmov.l          &0x0,%fpcr              # zero FPCR
3282
3283#
3284#       copy, convert, and tag input argument
3285#
3286        fmov.d          0x8(%a6),%fp0           # load dbl input
3287        fmov.x          %fp0,FP_SRC(%a6)
3288        lea             FP_SRC(%a6),%a0
3289        bsr.l           tag                     # fetch operand type
3290        mov.b           %d0,STAG(%a6)
3291        mov.b           %d0,%d1
3292
3293        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3294
3295        clr.l           %d0
3296        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3297
3298        mov.b           %d1,STAG(%a6)
3299        tst.b           %d1
3300        bne.b           _L15_2d
3301        bsr.l           slog2                   # operand is a NORM
3302        bra.b           _L15_6d
3303_L15_2d:
3304        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3305        bne.b           _L15_3d                 # no
3306        bsr.l           t_dz2                   # yes
3307        bra.b           _L15_6d
3308_L15_3d:
3309        cmpi.b          %d1,&INF                # is operand an INF?
3310        bne.b           _L15_4d                 # no
3311        bsr.l           sopr_inf                        # yes
3312        bra.b           _L15_6d
3313_L15_4d:
3314        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3315        bne.b           _L15_5d                 # no
3316        bsr.l           src_qnan                        # yes
3317        bra.b           _L15_6d
3318_L15_5d:
3319        bsr.l           slog2d                  # operand is a DENORM
3320_L15_6d:
3321
3322#
3323#       Result is now in FP0
3324#
3325        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3326        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3327        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3328        unlk            %a6
3329        rts
3330
3331        global          _flog2x_
3332_flog2x_:
3333        link            %a6,&-LOCAL_SIZE
3334
3335        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3336        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3337        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3338
3339        fmov.l          &0x0,%fpcr              # zero FPCR
3340
3341#
3342#       copy, convert, and tag input argument
3343#
3344        lea             FP_SRC(%a6),%a0
3345        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
3346        mov.l           0x8+0x4(%a6),0x4(%a0)
3347        mov.l           0x8+0x8(%a6),0x8(%a0)
3348        bsr.l           tag                     # fetch operand type
3349        mov.b           %d0,STAG(%a6)
3350        mov.b           %d0,%d1
3351
3352        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3353
3354        clr.l           %d0
3355        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3356
3357        tst.b           %d1
3358        bne.b           _L15_2x
3359        bsr.l           slog2                   # operand is a NORM
3360        bra.b           _L15_6x
3361_L15_2x:
3362        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3363        bne.b           _L15_3x                 # no
3364        bsr.l           t_dz2                   # yes
3365        bra.b           _L15_6x
3366_L15_3x:
3367        cmpi.b          %d1,&INF                # is operand an INF?
3368        bne.b           _L15_4x                 # no
3369        bsr.l           sopr_inf                        # yes
3370        bra.b           _L15_6x
3371_L15_4x:
3372        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3373        bne.b           _L15_5x                 # no
3374        bsr.l           src_qnan                        # yes
3375        bra.b           _L15_6x
3376_L15_5x:
3377        bsr.l           slog2d                  # operand is a DENORM
3378_L15_6x:
3379
3380#
3381#       Result is now in FP0
3382#
3383        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3384        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3385        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3386        unlk            %a6
3387        rts
3388
3389
3390#########################################################################
3391# MONADIC TEMPLATE                                                      #
3392#########################################################################
3393        global          _fcoshs_
3394_fcoshs_:
3395        link            %a6,&-LOCAL_SIZE
3396
3397        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3398        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3399        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3400
3401        fmov.l          &0x0,%fpcr              # zero FPCR
3402
3403#
3404#       copy, convert, and tag input argument
3405#
3406        fmov.s          0x8(%a6),%fp0           # load sgl input
3407        fmov.x          %fp0,FP_SRC(%a6)
3408        lea             FP_SRC(%a6),%a0
3409        bsr.l           tag                     # fetch operand type
3410        mov.b           %d0,STAG(%a6)
3411        mov.b           %d0,%d1
3412
3413        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3414
3415        clr.l           %d0
3416        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3417
3418        tst.b           %d1
3419        bne.b           _L16_2s
3420        bsr.l           scosh                   # operand is a NORM
3421        bra.b           _L16_6s
3422_L16_2s:
3423        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3424        bne.b           _L16_3s                 # no
3425        bsr.l           ld_pone                 # yes
3426        bra.b           _L16_6s
3427_L16_3s:
3428        cmpi.b          %d1,&INF                # is operand an INF?
3429        bne.b           _L16_4s                 # no
3430        bsr.l           ld_pinf                 # yes
3431        bra.b           _L16_6s
3432_L16_4s:
3433        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3434        bne.b           _L16_5s                 # no
3435        bsr.l           src_qnan                        # yes
3436        bra.b           _L16_6s
3437_L16_5s:
3438        bsr.l           scoshd                  # operand is a DENORM
3439_L16_6s:
3440
3441#
3442#       Result is now in FP0
3443#
3444        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3445        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3446        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3447        unlk            %a6
3448        rts
3449
3450        global          _fcoshd_
3451_fcoshd_:
3452        link            %a6,&-LOCAL_SIZE
3453
3454        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3455        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3456        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3457
3458        fmov.l          &0x0,%fpcr              # zero FPCR
3459
3460#
3461#       copy, convert, and tag input argument
3462#
3463        fmov.d          0x8(%a6),%fp0           # load dbl input
3464        fmov.x          %fp0,FP_SRC(%a6)
3465        lea             FP_SRC(%a6),%a0
3466        bsr.l           tag                     # fetch operand type
3467        mov.b           %d0,STAG(%a6)
3468        mov.b           %d0,%d1
3469
3470        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3471
3472        clr.l           %d0
3473        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3474
3475        mov.b           %d1,STAG(%a6)
3476        tst.b           %d1
3477        bne.b           _L16_2d
3478        bsr.l           scosh                   # operand is a NORM
3479        bra.b           _L16_6d
3480_L16_2d:
3481        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3482        bne.b           _L16_3d                 # no
3483        bsr.l           ld_pone                 # yes
3484        bra.b           _L16_6d
3485_L16_3d:
3486        cmpi.b          %d1,&INF                # is operand an INF?
3487        bne.b           _L16_4d                 # no
3488        bsr.l           ld_pinf                 # yes
3489        bra.b           _L16_6d
3490_L16_4d:
3491        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3492        bne.b           _L16_5d                 # no
3493        bsr.l           src_qnan                        # yes
3494        bra.b           _L16_6d
3495_L16_5d:
3496        bsr.l           scoshd                  # operand is a DENORM
3497_L16_6d:
3498
3499#
3500#       Result is now in FP0
3501#
3502        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3503        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3504        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3505        unlk            %a6
3506        rts
3507
3508        global          _fcoshx_
3509_fcoshx_:
3510        link            %a6,&-LOCAL_SIZE
3511
3512        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3513        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3514        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3515
3516        fmov.l          &0x0,%fpcr              # zero FPCR
3517
3518#
3519#       copy, convert, and tag input argument
3520#
3521        lea             FP_SRC(%a6),%a0
3522        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
3523        mov.l           0x8+0x4(%a6),0x4(%a0)
3524        mov.l           0x8+0x8(%a6),0x8(%a0)
3525        bsr.l           tag                     # fetch operand type
3526        mov.b           %d0,STAG(%a6)
3527        mov.b           %d0,%d1
3528
3529        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3530
3531        clr.l           %d0
3532        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3533
3534        tst.b           %d1
3535        bne.b           _L16_2x
3536        bsr.l           scosh                   # operand is a NORM
3537        bra.b           _L16_6x
3538_L16_2x:
3539        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3540        bne.b           _L16_3x                 # no
3541        bsr.l           ld_pone                 # yes
3542        bra.b           _L16_6x
3543_L16_3x:
3544        cmpi.b          %d1,&INF                # is operand an INF?
3545        bne.b           _L16_4x                 # no
3546        bsr.l           ld_pinf                 # yes
3547        bra.b           _L16_6x
3548_L16_4x:
3549        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3550        bne.b           _L16_5x                 # no
3551        bsr.l           src_qnan                        # yes
3552        bra.b           _L16_6x
3553_L16_5x:
3554        bsr.l           scoshd                  # operand is a DENORM
3555_L16_6x:
3556
3557#
3558#       Result is now in FP0
3559#
3560        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3561        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3562        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3563        unlk            %a6
3564        rts
3565
3566
3567#########################################################################
3568# MONADIC TEMPLATE                                                      #
3569#########################################################################
3570        global          _facoss_
3571_facoss_:
3572        link            %a6,&-LOCAL_SIZE
3573
3574        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3575        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3576        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3577
3578        fmov.l          &0x0,%fpcr              # zero FPCR
3579
3580#
3581#       copy, convert, and tag input argument
3582#
3583        fmov.s          0x8(%a6),%fp0           # load sgl input
3584        fmov.x          %fp0,FP_SRC(%a6)
3585        lea             FP_SRC(%a6),%a0
3586        bsr.l           tag                     # fetch operand type
3587        mov.b           %d0,STAG(%a6)
3588        mov.b           %d0,%d1
3589
3590        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3591
3592        clr.l           %d0
3593        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3594
3595        tst.b           %d1
3596        bne.b           _L17_2s
3597        bsr.l           sacos                   # operand is a NORM
3598        bra.b           _L17_6s
3599_L17_2s:
3600        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3601        bne.b           _L17_3s                 # no
3602        bsr.l           ld_ppi2                 # yes
3603        bra.b           _L17_6s
3604_L17_3s:
3605        cmpi.b          %d1,&INF                # is operand an INF?
3606        bne.b           _L17_4s                 # no
3607        bsr.l           t_operr                 # yes
3608        bra.b           _L17_6s
3609_L17_4s:
3610        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3611        bne.b           _L17_5s                 # no
3612        bsr.l           src_qnan                        # yes
3613        bra.b           _L17_6s
3614_L17_5s:
3615        bsr.l           sacosd                  # operand is a DENORM
3616_L17_6s:
3617
3618#
3619#       Result is now in FP0
3620#
3621        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3622        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3623        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3624        unlk            %a6
3625        rts
3626
3627        global          _facosd_
3628_facosd_:
3629        link            %a6,&-LOCAL_SIZE
3630
3631        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3632        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3633        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3634
3635        fmov.l          &0x0,%fpcr              # zero FPCR
3636
3637#
3638#       copy, convert, and tag input argument
3639#
3640        fmov.d          0x8(%a6),%fp0           # load dbl input
3641        fmov.x          %fp0,FP_SRC(%a6)
3642        lea             FP_SRC(%a6),%a0
3643        bsr.l           tag                     # fetch operand type
3644        mov.b           %d0,STAG(%a6)
3645        mov.b           %d0,%d1
3646
3647        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3648
3649        clr.l           %d0
3650        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3651
3652        mov.b           %d1,STAG(%a6)
3653        tst.b           %d1
3654        bne.b           _L17_2d
3655        bsr.l           sacos                   # operand is a NORM
3656        bra.b           _L17_6d
3657_L17_2d:
3658        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3659        bne.b           _L17_3d                 # no
3660        bsr.l           ld_ppi2                 # yes
3661        bra.b           _L17_6d
3662_L17_3d:
3663        cmpi.b          %d1,&INF                # is operand an INF?
3664        bne.b           _L17_4d                 # no
3665        bsr.l           t_operr                 # yes
3666        bra.b           _L17_6d
3667_L17_4d:
3668        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3669        bne.b           _L17_5d                 # no
3670        bsr.l           src_qnan                        # yes
3671        bra.b           _L17_6d
3672_L17_5d:
3673        bsr.l           sacosd                  # operand is a DENORM
3674_L17_6d:
3675
3676#
3677#       Result is now in FP0
3678#
3679        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3680        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3681        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3682        unlk            %a6
3683        rts
3684
3685        global          _facosx_
3686_facosx_:
3687        link            %a6,&-LOCAL_SIZE
3688
3689        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3690        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3691        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3692
3693        fmov.l          &0x0,%fpcr              # zero FPCR
3694
3695#
3696#       copy, convert, and tag input argument
3697#
3698        lea             FP_SRC(%a6),%a0
3699        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
3700        mov.l           0x8+0x4(%a6),0x4(%a0)
3701        mov.l           0x8+0x8(%a6),0x8(%a0)
3702        bsr.l           tag                     # fetch operand type
3703        mov.b           %d0,STAG(%a6)
3704        mov.b           %d0,%d1
3705
3706        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3707
3708        clr.l           %d0
3709        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3710
3711        tst.b           %d1
3712        bne.b           _L17_2x
3713        bsr.l           sacos                   # operand is a NORM
3714        bra.b           _L17_6x
3715_L17_2x:
3716        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3717        bne.b           _L17_3x                 # no
3718        bsr.l           ld_ppi2                 # yes
3719        bra.b           _L17_6x
3720_L17_3x:
3721        cmpi.b          %d1,&INF                # is operand an INF?
3722        bne.b           _L17_4x                 # no
3723        bsr.l           t_operr                 # yes
3724        bra.b           _L17_6x
3725_L17_4x:
3726        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3727        bne.b           _L17_5x                 # no
3728        bsr.l           src_qnan                        # yes
3729        bra.b           _L17_6x
3730_L17_5x:
3731        bsr.l           sacosd                  # operand is a DENORM
3732_L17_6x:
3733
3734#
3735#       Result is now in FP0
3736#
3737        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3738        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3739        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3740        unlk            %a6
3741        rts
3742
3743
3744#########################################################################
3745# MONADIC TEMPLATE                                                      #
3746#########################################################################
3747        global          _fgetexps_
3748_fgetexps_:
3749        link            %a6,&-LOCAL_SIZE
3750
3751        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3752        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3753        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3754
3755        fmov.l          &0x0,%fpcr              # zero FPCR
3756
3757#
3758#       copy, convert, and tag input argument
3759#
3760        fmov.s          0x8(%a6),%fp0           # load sgl input
3761        fmov.x          %fp0,FP_SRC(%a6)
3762        lea             FP_SRC(%a6),%a0
3763        bsr.l           tag                     # fetch operand type
3764        mov.b           %d0,STAG(%a6)
3765        mov.b           %d0,%d1
3766
3767        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3768
3769        clr.l           %d0
3770        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3771
3772        tst.b           %d1
3773        bne.b           _L18_2s
3774        bsr.l           sgetexp                 # operand is a NORM
3775        bra.b           _L18_6s
3776_L18_2s:
3777        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3778        bne.b           _L18_3s                 # no
3779        bsr.l           src_zero                        # yes
3780        bra.b           _L18_6s
3781_L18_3s:
3782        cmpi.b          %d1,&INF                # is operand an INF?
3783        bne.b           _L18_4s                 # no
3784        bsr.l           t_operr                 # yes
3785        bra.b           _L18_6s
3786_L18_4s:
3787        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3788        bne.b           _L18_5s                 # no
3789        bsr.l           src_qnan                        # yes
3790        bra.b           _L18_6s
3791_L18_5s:
3792        bsr.l           sgetexpd                        # operand is a DENORM
3793_L18_6s:
3794
3795#
3796#       Result is now in FP0
3797#
3798        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3799        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3800        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3801        unlk            %a6
3802        rts
3803
3804        global          _fgetexpd_
3805_fgetexpd_:
3806        link            %a6,&-LOCAL_SIZE
3807
3808        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3809        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3810        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3811
3812        fmov.l          &0x0,%fpcr              # zero FPCR
3813
3814#
3815#       copy, convert, and tag input argument
3816#
3817        fmov.d          0x8(%a6),%fp0           # load dbl input
3818        fmov.x          %fp0,FP_SRC(%a6)
3819        lea             FP_SRC(%a6),%a0
3820        bsr.l           tag                     # fetch operand type
3821        mov.b           %d0,STAG(%a6)
3822        mov.b           %d0,%d1
3823
3824        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3825
3826        clr.l           %d0
3827        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3828
3829        mov.b           %d1,STAG(%a6)
3830        tst.b           %d1
3831        bne.b           _L18_2d
3832        bsr.l           sgetexp                 # operand is a NORM
3833        bra.b           _L18_6d
3834_L18_2d:
3835        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3836        bne.b           _L18_3d                 # no
3837        bsr.l           src_zero                        # yes
3838        bra.b           _L18_6d
3839_L18_3d:
3840        cmpi.b          %d1,&INF                # is operand an INF?
3841        bne.b           _L18_4d                 # no
3842        bsr.l           t_operr                 # yes
3843        bra.b           _L18_6d
3844_L18_4d:
3845        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3846        bne.b           _L18_5d                 # no
3847        bsr.l           src_qnan                        # yes
3848        bra.b           _L18_6d
3849_L18_5d:
3850        bsr.l           sgetexpd                        # operand is a DENORM
3851_L18_6d:
3852
3853#
3854#       Result is now in FP0
3855#
3856        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3857        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3858        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3859        unlk            %a6
3860        rts
3861
3862        global          _fgetexpx_
3863_fgetexpx_:
3864        link            %a6,&-LOCAL_SIZE
3865
3866        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3867        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3868        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3869
3870        fmov.l          &0x0,%fpcr              # zero FPCR
3871
3872#
3873#       copy, convert, and tag input argument
3874#
3875        lea             FP_SRC(%a6),%a0
3876        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
3877        mov.l           0x8+0x4(%a6),0x4(%a0)
3878        mov.l           0x8+0x8(%a6),0x8(%a0)
3879        bsr.l           tag                     # fetch operand type
3880        mov.b           %d0,STAG(%a6)
3881        mov.b           %d0,%d1
3882
3883        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3884
3885        clr.l           %d0
3886        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3887
3888        tst.b           %d1
3889        bne.b           _L18_2x
3890        bsr.l           sgetexp                 # operand is a NORM
3891        bra.b           _L18_6x
3892_L18_2x:
3893        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3894        bne.b           _L18_3x                 # no
3895        bsr.l           src_zero                        # yes
3896        bra.b           _L18_6x
3897_L18_3x:
3898        cmpi.b          %d1,&INF                # is operand an INF?
3899        bne.b           _L18_4x                 # no
3900        bsr.l           t_operr                 # yes
3901        bra.b           _L18_6x
3902_L18_4x:
3903        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3904        bne.b           _L18_5x                 # no
3905        bsr.l           src_qnan                        # yes
3906        bra.b           _L18_6x
3907_L18_5x:
3908        bsr.l           sgetexpd                        # operand is a DENORM
3909_L18_6x:
3910
3911#
3912#       Result is now in FP0
3913#
3914        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3915        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3916        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3917        unlk            %a6
3918        rts
3919
3920
3921#########################################################################
3922# MONADIC TEMPLATE                                                      #
3923#########################################################################
3924        global          _fgetmans_
3925_fgetmans_:
3926        link            %a6,&-LOCAL_SIZE
3927
3928        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3929        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3930        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3931
3932        fmov.l          &0x0,%fpcr              # zero FPCR
3933
3934#
3935#       copy, convert, and tag input argument
3936#
3937        fmov.s          0x8(%a6),%fp0           # load sgl input
3938        fmov.x          %fp0,FP_SRC(%a6)
3939        lea             FP_SRC(%a6),%a0
3940        bsr.l           tag                     # fetch operand type
3941        mov.b           %d0,STAG(%a6)
3942        mov.b           %d0,%d1
3943
3944        andi.l          &0x00ff00ff,USER_FPSR(%a6)
3945
3946        clr.l           %d0
3947        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
3948
3949        tst.b           %d1
3950        bne.b           _L19_2s
3951        bsr.l           sgetman                 # operand is a NORM
3952        bra.b           _L19_6s
3953_L19_2s:
3954        cmpi.b          %d1,&ZERO               # is operand a ZERO?
3955        bne.b           _L19_3s                 # no
3956        bsr.l           src_zero                        # yes
3957        bra.b           _L19_6s
3958_L19_3s:
3959        cmpi.b          %d1,&INF                # is operand an INF?
3960        bne.b           _L19_4s                 # no
3961        bsr.l           t_operr                 # yes
3962        bra.b           _L19_6s
3963_L19_4s:
3964        cmpi.b          %d1,&QNAN               # is operand a QNAN?
3965        bne.b           _L19_5s                 # no
3966        bsr.l           src_qnan                        # yes
3967        bra.b           _L19_6s
3968_L19_5s:
3969        bsr.l           sgetmand                        # operand is a DENORM
3970_L19_6s:
3971
3972#
3973#       Result is now in FP0
3974#
3975        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
3976        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
3977        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
3978        unlk            %a6
3979        rts
3980
3981        global          _fgetmand_
3982_fgetmand_:
3983        link            %a6,&-LOCAL_SIZE
3984
3985        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
3986        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
3987        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
3988
3989        fmov.l          &0x0,%fpcr              # zero FPCR
3990
3991#
3992#       copy, convert, and tag input argument
3993#
3994        fmov.d          0x8(%a6),%fp0           # load dbl input
3995        fmov.x          %fp0,FP_SRC(%a6)
3996        lea             FP_SRC(%a6),%a0
3997        bsr.l           tag                     # fetch operand type
3998        mov.b           %d0,STAG(%a6)
3999        mov.b           %d0,%d1
4000

4001        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4002
4003        clr.l           %d0
4004        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4005
4006        mov.b           %d1,STAG(%a6)
4007        tst.b           %d1
4008        bne.b           _L19_2d
4009        bsr.l           sgetman                 # operand is a NORM
4010        bra.b           _L19_6d
4011_L19_2d:
4012        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4013        bne.b           _L19_3d                 # no
4014        bsr.l           src_zero                        # yes
4015        bra.b           _L19_6d
4016_L19_3d:
4017        cmpi.b          %d1,&INF                # is operand an INF?
4018        bne.b           _L19_4d                 # no
4019        bsr.l           t_operr                 # yes
4020        bra.b           _L19_6d
4021_L19_4d:
4022        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4023        bne.b           _L19_5d                 # no
4024        bsr.l           src_qnan                        # yes
4025        bra.b           _L19_6d
4026_L19_5d:
4027        bsr.l           sgetmand                        # operand is a DENORM
4028_L19_6d:
4029
4030#
4031#       Result is now in FP0
4032#
4033        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4034        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4035        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4036        unlk            %a6
4037        rts
4038
4039        global          _fgetmanx_
4040_fgetmanx_:
4041        link            %a6,&-LOCAL_SIZE
4042
4043        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4044        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4045        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4046
4047        fmov.l          &0x0,%fpcr              # zero FPCR
4048
4049#
4050#       copy, convert, and tag input argument
4051#
4052        lea             FP_SRC(%a6),%a0
4053        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
4054        mov.l           0x8+0x4(%a6),0x4(%a0)
4055        mov.l           0x8+0x8(%a6),0x8(%a0)
4056        bsr.l           tag                     # fetch operand type
4057        mov.b           %d0,STAG(%a6)
4058        mov.b           %d0,%d1
4059
4060        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4061
4062        clr.l           %d0
4063        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4064
4065        tst.b           %d1
4066        bne.b           _L19_2x
4067        bsr.l           sgetman                 # operand is a NORM
4068        bra.b           _L19_6x
4069_L19_2x:
4070        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4071        bne.b           _L19_3x                 # no
4072        bsr.l           src_zero                        # yes
4073        bra.b           _L19_6x
4074_L19_3x:
4075        cmpi.b          %d1,&INF                # is operand an INF?
4076        bne.b           _L19_4x                 # no
4077        bsr.l           t_operr                 # yes
4078        bra.b           _L19_6x
4079_L19_4x:
4080        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4081        bne.b           _L19_5x                 # no
4082        bsr.l           src_qnan                        # yes
4083        bra.b           _L19_6x
4084_L19_5x:
4085        bsr.l           sgetmand                        # operand is a DENORM
4086_L19_6x:
4087
4088#
4089#       Result is now in FP0
4090#
4091        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4092        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4093        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4094        unlk            %a6
4095        rts
4096
4097
4098#########################################################################
4099# MONADIC TEMPLATE                                                      #
4100#########################################################################
4101        global          _fsincoss_
4102_fsincoss_:
4103        link            %a6,&-LOCAL_SIZE
4104
4105        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4106        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4107        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4108
4109        fmov.l          &0x0,%fpcr              # zero FPCR
4110
4111#
4112#       copy, convert, and tag input argument
4113#
4114        fmov.s          0x8(%a6),%fp0           # load sgl input
4115        fmov.x          %fp0,FP_SRC(%a6)
4116        lea             FP_SRC(%a6),%a0
4117        bsr.l           tag                     # fetch operand type
4118        mov.b           %d0,STAG(%a6)
4119        mov.b           %d0,%d1
4120
4121        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4122
4123        clr.l           %d0
4124        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4125
4126        tst.b           %d1
4127        bne.b           _L20_2s
4128        bsr.l           ssincos                 # operand is a NORM
4129        bra.b           _L20_6s
4130_L20_2s:
4131        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4132        bne.b           _L20_3s                 # no
4133        bsr.l           ssincosz                        # yes
4134        bra.b           _L20_6s
4135_L20_3s:
4136        cmpi.b          %d1,&INF                # is operand an INF?
4137        bne.b           _L20_4s                 # no
4138        bsr.l           ssincosi                        # yes
4139        bra.b           _L20_6s
4140_L20_4s:
4141        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4142        bne.b           _L20_5s                 # no
4143        bsr.l           ssincosqnan                     # yes
4144        bra.b           _L20_6s
4145_L20_5s:
4146        bsr.l           ssincosd                        # operand is a DENORM
4147_L20_6s:
4148
4149#
4150#       Result is now in FP0
4151#
4152        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4153        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4154        fmovm.x         &0x03,-(%sp)            # store off fp0/fp1
4155        fmovm.x         (%sp)+,&0x40            # fp0 now in fp1
4156        fmovm.x         (%sp)+,&0x80            # fp1 now in fp0
4157        unlk            %a6
4158        rts
4159
4160        global          _fsincosd_
4161_fsincosd_:
4162        link            %a6,&-LOCAL_SIZE
4163
4164        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4165        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4166        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4167
4168        fmov.l          &0x0,%fpcr              # zero FPCR
4169
4170#
4171#       copy, convert, and tag input argument
4172#
4173        fmov.d          0x8(%a6),%fp0           # load dbl input
4174        fmov.x          %fp0,FP_SRC(%a6)
4175        lea             FP_SRC(%a6),%a0
4176        bsr.l           tag                     # fetch operand type
4177        mov.b           %d0,STAG(%a6)
4178        mov.b           %d0,%d1
4179
4180        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4181
4182        clr.l           %d0
4183        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4184
4185        mov.b           %d1,STAG(%a6)
4186        tst.b           %d1
4187        bne.b           _L20_2d
4188        bsr.l           ssincos                 # operand is a NORM
4189        bra.b           _L20_6d
4190_L20_2d:
4191        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4192        bne.b           _L20_3d                 # no
4193        bsr.l           ssincosz                        # yes
4194        bra.b           _L20_6d
4195_L20_3d:
4196        cmpi.b          %d1,&INF                # is operand an INF?
4197        bne.b           _L20_4d                 # no
4198        bsr.l           ssincosi                        # yes
4199        bra.b           _L20_6d
4200_L20_4d:
4201        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4202        bne.b           _L20_5d                 # no
4203        bsr.l           ssincosqnan                     # yes
4204        bra.b           _L20_6d
4205_L20_5d:
4206        bsr.l           ssincosd                        # operand is a DENORM
4207_L20_6d:
4208
4209#
4210#       Result is now in FP0
4211#
4212        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4213        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4214        fmovm.x         &0x03,-(%sp)            # store off fp0/fp1
4215        fmovm.x         (%sp)+,&0x40            # fp0 now in fp1
4216        fmovm.x         (%sp)+,&0x80            # fp1 now in fp0
4217        unlk            %a6
4218        rts
4219
4220        global          _fsincosx_
4221_fsincosx_:
4222        link            %a6,&-LOCAL_SIZE
4223
4224        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4225        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4226        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4227
4228        fmov.l          &0x0,%fpcr              # zero FPCR
4229
4230#
4231#       copy, convert, and tag input argument
4232#
4233        lea             FP_SRC(%a6),%a0
4234        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext input
4235        mov.l           0x8+0x4(%a6),0x4(%a0)
4236        mov.l           0x8+0x8(%a6),0x8(%a0)
4237        bsr.l           tag                     # fetch operand type
4238        mov.b           %d0,STAG(%a6)
4239        mov.b           %d0,%d1
4240
4241        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4242
4243        clr.l           %d0
4244        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4245
4246        tst.b           %d1
4247        bne.b           _L20_2x
4248        bsr.l           ssincos                 # operand is a NORM
4249        bra.b           _L20_6x
4250_L20_2x:
4251        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4252        bne.b           _L20_3x                 # no
4253        bsr.l           ssincosz                        # yes
4254        bra.b           _L20_6x
4255_L20_3x:
4256        cmpi.b          %d1,&INF                # is operand an INF?
4257        bne.b           _L20_4x                 # no
4258        bsr.l           ssincosi                        # yes
4259        bra.b           _L20_6x
4260_L20_4x:
4261        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4262        bne.b           _L20_5x                 # no
4263        bsr.l           ssincosqnan                     # yes
4264        bra.b           _L20_6x
4265_L20_5x:
4266        bsr.l           ssincosd                        # operand is a DENORM
4267_L20_6x:
4268
4269#
4270#       Result is now in FP0
4271#
4272        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4273        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4274        fmovm.x         &0x03,-(%sp)            # store off fp0/fp1
4275        fmovm.x         (%sp)+,&0x40            # fp0 now in fp1
4276        fmovm.x         (%sp)+,&0x80            # fp1 now in fp0
4277        unlk            %a6
4278        rts
4279
4280
4281#########################################################################
4282# DYADIC TEMPLATE                                                       #
4283#########################################################################
4284        global          _frems_
4285_frems_:
4286        link            %a6,&-LOCAL_SIZE
4287
4288        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4289        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4290        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4291
4292        fmov.l          &0x0,%fpcr              # zero FPCR
4293
4294#
4295#       copy, convert, and tag input argument
4296#
4297        fmov.s          0x8(%a6),%fp0           # load sgl dst
4298        fmov.x          %fp0,FP_DST(%a6)
4299        lea             FP_DST(%a6),%a0
4300        bsr.l           tag                     # fetch operand type
4301        mov.b           %d0,DTAG(%a6)
4302
4303        fmov.s          0xc(%a6),%fp0           # load sgl src
4304        fmov.x          %fp0,FP_SRC(%a6)
4305        lea             FP_SRC(%a6),%a0
4306        bsr.l           tag                     # fetch operand type
4307        mov.b           %d0,STAG(%a6)
4308        mov.l           %d0,%d1
4309
4310        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4311
4312        clr.l           %d0
4313        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4314
4315        lea             FP_SRC(%a6),%a0         # pass ptr to src
4316        lea             FP_DST(%a6),%a1         # pass ptr to dst
4317
4318        tst.b           %d1
4319        bne.b           _L21_2s
4320        bsr.l           srem_snorm                      # operand is a NORM
4321        bra.b           _L21_6s
4322_L21_2s:
4323        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4324        bne.b           _L21_3s                 # no
4325        bsr.l           srem_szero                      # yes
4326        bra.b           _L21_6s
4327_L21_3s:
4328        cmpi.b          %d1,&INF                # is operand an INF?
4329        bne.b           _L21_4s                 # no
4330        bsr.l           srem_sinf                       # yes
4331        bra.b           _L21_6s
4332_L21_4s:
4333        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4334        bne.b           _L21_5s                 # no
4335        bsr.l           sop_sqnan                       # yes
4336        bra.b           _L21_6s
4337_L21_5s:
4338        bsr.l           srem_sdnrm                      # operand is a DENORM
4339_L21_6s:
4340
4341#
4342#       Result is now in FP0
4343#
4344        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4345        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4346        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4347        unlk            %a6
4348        rts
4349
4350        global          _fremd_
4351_fremd_:
4352        link            %a6,&-LOCAL_SIZE
4353
4354        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4355        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4356        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4357
4358        fmov.l          &0x0,%fpcr              # zero FPCR
4359
4360#
4361#       copy, convert, and tag input argument
4362#
4363        fmov.d          0x8(%a6),%fp0           # load dbl dst
4364        fmov.x          %fp0,FP_DST(%a6)
4365        lea             FP_DST(%a6),%a0
4366        bsr.l           tag                     # fetch operand type
4367        mov.b           %d0,DTAG(%a6)
4368
4369        fmov.d          0x10(%a6),%fp0          # load dbl src
4370        fmov.x          %fp0,FP_SRC(%a6)
4371        lea             FP_SRC(%a6),%a0
4372        bsr.l           tag                     # fetch operand type
4373        mov.b           %d0,STAG(%a6)
4374        mov.l           %d0,%d1
4375
4376        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4377
4378        clr.l           %d0
4379        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4380
4381        lea             FP_SRC(%a6),%a0         # pass ptr to src
4382        lea             FP_DST(%a6),%a1         # pass ptr to dst
4383
4384        tst.b           %d1
4385        bne.b           _L21_2d
4386        bsr.l           srem_snorm                      # operand is a NORM
4387        bra.b           _L21_6d
4388_L21_2d:
4389        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4390        bne.b           _L21_3d                 # no
4391        bsr.l           srem_szero                      # yes
4392        bra.b           _L21_6d
4393_L21_3d:
4394        cmpi.b          %d1,&INF                # is operand an INF?
4395        bne.b           _L21_4d                 # no
4396        bsr.l           srem_sinf                       # yes
4397        bra.b           _L21_6d
4398_L21_4d:
4399        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4400        bne.b           _L21_5d                 # no
4401        bsr.l           sop_sqnan                       # yes
4402        bra.b           _L21_6d
4403_L21_5d:
4404        bsr.l           srem_sdnrm                      # operand is a DENORM
4405_L21_6d:
4406
4407#
4408#       Result is now in FP0
4409#
4410        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4411        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4412        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4413        unlk            %a6
4414        rts
4415
4416        global          _fremx_
4417_fremx_:
4418        link            %a6,&-LOCAL_SIZE
4419
4420        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4421        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4422        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4423
4424        fmov.l          &0x0,%fpcr              # zero FPCR
4425
4426#
4427#       copy, convert, and tag input argument
4428#
4429        lea             FP_DST(%a6),%a0
4430        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext dst
4431        mov.l           0x8+0x4(%a6),0x4(%a0)
4432        mov.l           0x8+0x8(%a6),0x8(%a0)
4433        bsr.l           tag                     # fetch operand type
4434        mov.b           %d0,DTAG(%a6)
4435
4436        lea             FP_SRC(%a6),%a0
4437        mov.l           0x14+0x0(%a6),0x0(%a0)  # load ext src
4438        mov.l           0x14+0x4(%a6),0x4(%a0)
4439        mov.l           0x14+0x8(%a6),0x8(%a0)
4440        bsr.l           tag                     # fetch operand type
4441        mov.b           %d0,STAG(%a6)
4442        mov.l           %d0,%d1
4443
4444        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4445
4446        clr.l           %d0
4447        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4448
4449        lea             FP_SRC(%a6),%a0         # pass ptr to src
4450        lea             FP_DST(%a6),%a1         # pass ptr to dst
4451
4452        tst.b           %d1
4453        bne.b           _L21_2x
4454        bsr.l           srem_snorm                      # operand is a NORM
4455        bra.b           _L21_6x
4456_L21_2x:
4457        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4458        bne.b           _L21_3x                 # no
4459        bsr.l           srem_szero                      # yes
4460        bra.b           _L21_6x
4461_L21_3x:
4462        cmpi.b          %d1,&INF                # is operand an INF?
4463        bne.b           _L21_4x                 # no
4464        bsr.l           srem_sinf                       # yes
4465        bra.b           _L21_6x
4466_L21_4x:
4467        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4468        bne.b           _L21_5x                 # no
4469        bsr.l           sop_sqnan                       # yes
4470        bra.b           _L21_6x
4471_L21_5x:
4472        bsr.l           srem_sdnrm                      # operand is a DENORM
4473_L21_6x:
4474
4475#
4476#       Result is now in FP0
4477#
4478        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4479        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4480        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4481        unlk            %a6
4482        rts
4483
4484
4485#########################################################################
4486# DYADIC TEMPLATE                                                       #
4487#########################################################################
4488        global          _fmods_
4489_fmods_:
4490        link            %a6,&-LOCAL_SIZE
4491
4492        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4493        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4494        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4495
4496        fmov.l          &0x0,%fpcr              # zero FPCR
4497
4498#
4499#       copy, convert, and tag input argument
4500#
4501        fmov.s          0x8(%a6),%fp0           # load sgl dst
4502        fmov.x          %fp0,FP_DST(%a6)
4503        lea             FP_DST(%a6),%a0
4504        bsr.l           tag                     # fetch operand type
4505        mov.b           %d0,DTAG(%a6)
4506
4507        fmov.s          0xc(%a6),%fp0           # load sgl src
4508        fmov.x          %fp0,FP_SRC(%a6)
4509        lea             FP_SRC(%a6),%a0
4510        bsr.l           tag                     # fetch operand type
4511        mov.b           %d0,STAG(%a6)
4512        mov.l           %d0,%d1
4513
4514        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4515
4516        clr.l           %d0
4517        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4518
4519        lea             FP_SRC(%a6),%a0         # pass ptr to src
4520        lea             FP_DST(%a6),%a1         # pass ptr to dst
4521
4522        tst.b           %d1
4523        bne.b           _L22_2s
4524        bsr.l           smod_snorm                      # operand is a NORM
4525        bra.b           _L22_6s
4526_L22_2s:
4527        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4528        bne.b           _L22_3s                 # no
4529        bsr.l           smod_szero                      # yes
4530        bra.b           _L22_6s
4531_L22_3s:
4532        cmpi.b          %d1,&INF                # is operand an INF?
4533        bne.b           _L22_4s                 # no
4534        bsr.l           smod_sinf                       # yes
4535        bra.b           _L22_6s
4536_L22_4s:
4537        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4538        bne.b           _L22_5s                 # no
4539        bsr.l           sop_sqnan                       # yes
4540        bra.b           _L22_6s
4541_L22_5s:
4542        bsr.l           smod_sdnrm                      # operand is a DENORM
4543_L22_6s:
4544
4545#
4546#       Result is now in FP0
4547#
4548        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4549        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4550        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4551        unlk            %a6
4552        rts
4553
4554        global          _fmodd_
4555_fmodd_:
4556        link            %a6,&-LOCAL_SIZE
4557
4558        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4559        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4560        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4561
4562        fmov.l          &0x0,%fpcr              # zero FPCR
4563
4564#
4565#       copy, convert, and tag input argument
4566#
4567        fmov.d          0x8(%a6),%fp0           # load dbl dst
4568        fmov.x          %fp0,FP_DST(%a6)
4569        lea             FP_DST(%a6),%a0
4570        bsr.l           tag                     # fetch operand type
4571        mov.b           %d0,DTAG(%a6)
4572
4573        fmov.d          0x10(%a6),%fp0          # load dbl src
4574        fmov.x          %fp0,FP_SRC(%a6)
4575        lea             FP_SRC(%a6),%a0
4576        bsr.l           tag                     # fetch operand type
4577        mov.b           %d0,STAG(%a6)
4578        mov.l           %d0,%d1
4579
4580        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4581
4582        clr.l           %d0
4583        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4584
4585        lea             FP_SRC(%a6),%a0         # pass ptr to src
4586        lea             FP_DST(%a6),%a1         # pass ptr to dst
4587
4588        tst.b           %d1
4589        bne.b           _L22_2d
4590        bsr.l           smod_snorm                      # operand is a NORM
4591        bra.b           _L22_6d
4592_L22_2d:
4593        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4594        bne.b           _L22_3d                 # no
4595        bsr.l           smod_szero                      # yes
4596        bra.b           _L22_6d
4597_L22_3d:
4598        cmpi.b          %d1,&INF                # is operand an INF?
4599        bne.b           _L22_4d                 # no
4600        bsr.l           smod_sinf                       # yes
4601        bra.b           _L22_6d
4602_L22_4d:
4603        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4604        bne.b           _L22_5d                 # no
4605        bsr.l           sop_sqnan                       # yes
4606        bra.b           _L22_6d
4607_L22_5d:
4608        bsr.l           smod_sdnrm                      # operand is a DENORM
4609_L22_6d:
4610
4611#
4612#       Result is now in FP0
4613#
4614        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4615        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4616        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4617        unlk            %a6
4618        rts
4619
4620        global          _fmodx_
4621_fmodx_:
4622        link            %a6,&-LOCAL_SIZE
4623
4624        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4625        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4626        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4627
4628        fmov.l          &0x0,%fpcr              # zero FPCR
4629
4630#
4631#       copy, convert, and tag input argument
4632#
4633        lea             FP_DST(%a6),%a0
4634        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext dst
4635        mov.l           0x8+0x4(%a6),0x4(%a0)
4636        mov.l           0x8+0x8(%a6),0x8(%a0)
4637        bsr.l           tag                     # fetch operand type
4638        mov.b           %d0,DTAG(%a6)
4639
4640        lea             FP_SRC(%a6),%a0
4641        mov.l           0x14+0x0(%a6),0x0(%a0)  # load ext src
4642        mov.l           0x14+0x4(%a6),0x4(%a0)
4643        mov.l           0x14+0x8(%a6),0x8(%a0)
4644        bsr.l           tag                     # fetch operand type
4645        mov.b           %d0,STAG(%a6)
4646        mov.l           %d0,%d1
4647
4648        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4649
4650        clr.l           %d0
4651        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4652
4653        lea             FP_SRC(%a6),%a0         # pass ptr to src
4654        lea             FP_DST(%a6),%a1         # pass ptr to dst
4655
4656        tst.b           %d1
4657        bne.b           _L22_2x
4658        bsr.l           smod_snorm                      # operand is a NORM
4659        bra.b           _L22_6x
4660_L22_2x:
4661        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4662        bne.b           _L22_3x                 # no
4663        bsr.l           smod_szero                      # yes
4664        bra.b           _L22_6x
4665_L22_3x:
4666        cmpi.b          %d1,&INF                # is operand an INF?
4667        bne.b           _L22_4x                 # no
4668        bsr.l           smod_sinf                       # yes
4669        bra.b           _L22_6x
4670_L22_4x:
4671        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4672        bne.b           _L22_5x                 # no
4673        bsr.l           sop_sqnan                       # yes
4674        bra.b           _L22_6x
4675_L22_5x:
4676        bsr.l           smod_sdnrm                      # operand is a DENORM
4677_L22_6x:
4678
4679#
4680#       Result is now in FP0
4681#
4682        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4683        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4684        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4685        unlk            %a6
4686        rts
4687
4688
4689#########################################################################
4690# DYADIC TEMPLATE                                                       #
4691#########################################################################
4692        global          _fscales_
4693_fscales_:
4694        link            %a6,&-LOCAL_SIZE
4695
4696        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4697        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4698        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4699
4700        fmov.l          &0x0,%fpcr              # zero FPCR
4701
4702#
4703#       copy, convert, and tag input argument
4704#
4705        fmov.s          0x8(%a6),%fp0           # load sgl dst
4706        fmov.x          %fp0,FP_DST(%a6)
4707        lea             FP_DST(%a6),%a0
4708        bsr.l           tag                     # fetch operand type
4709        mov.b           %d0,DTAG(%a6)
4710
4711        fmov.s          0xc(%a6),%fp0           # load sgl src
4712        fmov.x          %fp0,FP_SRC(%a6)
4713        lea             FP_SRC(%a6),%a0
4714        bsr.l           tag                     # fetch operand type
4715        mov.b           %d0,STAG(%a6)
4716        mov.l           %d0,%d1
4717
4718        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4719
4720        clr.l           %d0
4721        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4722
4723        lea             FP_SRC(%a6),%a0         # pass ptr to src
4724        lea             FP_DST(%a6),%a1         # pass ptr to dst
4725
4726        tst.b           %d1
4727        bne.b           _L23_2s
4728        bsr.l           sscale_snorm                    # operand is a NORM
4729        bra.b           _L23_6s
4730_L23_2s:
4731        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4732        bne.b           _L23_3s                 # no
4733        bsr.l           sscale_szero                    # yes
4734        bra.b           _L23_6s
4735_L23_3s:
4736        cmpi.b          %d1,&INF                # is operand an INF?
4737        bne.b           _L23_4s                 # no
4738        bsr.l           sscale_sinf                     # yes
4739        bra.b           _L23_6s
4740_L23_4s:
4741        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4742        bne.b           _L23_5s                 # no
4743        bsr.l           sop_sqnan                       # yes
4744        bra.b           _L23_6s
4745_L23_5s:
4746        bsr.l           sscale_sdnrm                    # operand is a DENORM
4747_L23_6s:
4748
4749#
4750#       Result is now in FP0
4751#
4752        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4753        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4754        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4755        unlk            %a6
4756        rts
4757
4758        global          _fscaled_
4759_fscaled_:
4760        link            %a6,&-LOCAL_SIZE
4761
4762        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4763        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4764        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4765
4766        fmov.l          &0x0,%fpcr              # zero FPCR
4767
4768#
4769#       copy, convert, and tag input argument
4770#
4771        fmov.d          0x8(%a6),%fp0           # load dbl dst
4772        fmov.x          %fp0,FP_DST(%a6)
4773        lea             FP_DST(%a6),%a0
4774        bsr.l           tag                     # fetch operand type
4775        mov.b           %d0,DTAG(%a6)
4776
4777        fmov.d          0x10(%a6),%fp0          # load dbl src
4778        fmov.x          %fp0,FP_SRC(%a6)
4779        lea             FP_SRC(%a6),%a0
4780        bsr.l           tag                     # fetch operand type
4781        mov.b           %d0,STAG(%a6)
4782        mov.l           %d0,%d1
4783
4784        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4785
4786        clr.l           %d0
4787        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4788
4789        lea             FP_SRC(%a6),%a0         # pass ptr to src
4790        lea             FP_DST(%a6),%a1         # pass ptr to dst
4791
4792        tst.b           %d1
4793        bne.b           _L23_2d
4794        bsr.l           sscale_snorm                    # operand is a NORM
4795        bra.b           _L23_6d
4796_L23_2d:
4797        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4798        bne.b           _L23_3d                 # no
4799        bsr.l           sscale_szero                    # yes
4800        bra.b           _L23_6d
4801_L23_3d:
4802        cmpi.b          %d1,&INF                # is operand an INF?
4803        bne.b           _L23_4d                 # no
4804        bsr.l           sscale_sinf                     # yes
4805        bra.b           _L23_6d
4806_L23_4d:
4807        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4808        bne.b           _L23_5d                 # no
4809        bsr.l           sop_sqnan                       # yes
4810        bra.b           _L23_6d
4811_L23_5d:
4812        bsr.l           sscale_sdnrm                    # operand is a DENORM
4813_L23_6d:
4814
4815#
4816#       Result is now in FP0
4817#
4818        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4819        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4820        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4821        unlk            %a6
4822        rts
4823
4824        global          _fscalex_
4825_fscalex_:
4826        link            %a6,&-LOCAL_SIZE
4827
4828        movm.l          &0x0303,EXC_DREGS(%a6)  # save d0-d1/a0-a1
4829        fmovm.l         %fpcr,%fpsr,USER_FPCR(%a6) # save ctrl regs
4830        fmovm.x         &0xc0,EXC_FP0(%a6)      # save fp0/fp1
4831
4832        fmov.l          &0x0,%fpcr              # zero FPCR
4833
4834#
4835#       copy, convert, and tag input argument
4836#
4837        lea             FP_DST(%a6),%a0
4838        mov.l           0x8+0x0(%a6),0x0(%a0)   # load ext dst
4839        mov.l           0x8+0x4(%a6),0x4(%a0)
4840        mov.l           0x8+0x8(%a6),0x8(%a0)
4841        bsr.l           tag                     # fetch operand type
4842        mov.b           %d0,DTAG(%a6)
4843
4844        lea             FP_SRC(%a6),%a0
4845        mov.l           0x14+0x0(%a6),0x0(%a0)  # load ext src
4846        mov.l           0x14+0x4(%a6),0x4(%a0)
4847        mov.l           0x14+0x8(%a6),0x8(%a0)
4848        bsr.l           tag                     # fetch operand type
4849        mov.b           %d0,STAG(%a6)
4850        mov.l           %d0,%d1
4851
4852        andi.l          &0x00ff00ff,USER_FPSR(%a6)
4853
4854        clr.l           %d0
4855        mov.b           FPCR_MODE(%a6),%d0      # pass rnd mode,prec
4856
4857        lea             FP_SRC(%a6),%a0         # pass ptr to src
4858        lea             FP_DST(%a6),%a1         # pass ptr to dst
4859
4860        tst.b           %d1
4861        bne.b           _L23_2x
4862        bsr.l           sscale_snorm                    # operand is a NORM
4863        bra.b           _L23_6x
4864_L23_2x:
4865        cmpi.b          %d1,&ZERO               # is operand a ZERO?
4866        bne.b           _L23_3x                 # no
4867        bsr.l           sscale_szero                    # yes
4868        bra.b           _L23_6x
4869_L23_3x:
4870        cmpi.b          %d1,&INF                # is operand an INF?
4871        bne.b           _L23_4x                 # no
4872        bsr.l           sscale_sinf                     # yes
4873        bra.b           _L23_6x
4874_L23_4x:
4875        cmpi.b          %d1,&QNAN               # is operand a QNAN?
4876        bne.b           _L23_5x                 # no
4877        bsr.l           sop_sqnan                       # yes
4878        bra.b           _L23_6x
4879_L23_5x:
4880        bsr.l           sscale_sdnrm                    # operand is a DENORM
4881_L23_6x:
4882
4883#
4884#       Result is now in FP0
4885#
4886        movm.l          EXC_DREGS(%a6),&0x0303  # restore d0-d1/a0-a1
4887        fmovm.l         USER_FPCR(%a6),%fpcr,%fpsr # restore ctrl regs
4888        fmovm.x         EXC_FP1(%a6),&0x40      # restore fp1
4889        unlk            %a6
4890        rts
4891
4892
4893#########################################################################
4894# ssin():     computes the sine of a normalized input                   #
4895# ssind():    computes the sine of a denormalized input                 #
4896# scos():     computes the cosine of a normalized input                 #
4897# scosd():    computes the cosine of a denormalized input               #
4898# ssincos():  computes the sine and cosine of a normalized input        #
4899# ssincosd(): computes the sine and cosine of a denormalized input      #
4900#                                                                       #
4901# INPUT *************************************************************** #
4902#       a0 = pointer to extended precision input                        #
4903#       d0 = round precision,mode                                       #
4904#                                                                       #
4905# OUTPUT ************************************************************** #
4906#       fp0 = sin(X) or cos(X)                                          #
4907#                                                                       #
4908#    For ssincos(X):                                                    #
4909#       fp0 = sin(X)                                                    #
4910#       fp1 = cos(X)                                                    #
4911#                                                                       #
4912# ACCURACY and MONOTONICITY ******************************************* #
4913#       The returned result is within 1 ulp in 64 significant bit, i.e. #
4914#       within 0.5001 ulp to 53 bits if the result is subsequently      #
4915#       rounded to double precision. The result is provably monotonic   #
4916#       in double precision.                                            #
4917#                                                                       #
4918# ALGORITHM *********************************************************** #
4919#                                                                       #
4920#       SIN and COS:                                                    #
4921#       1. If SIN is invoked, set AdjN := 0; otherwise, set AdjN := 1.  #
4922#                                                                       #
4923#       2. If |X| >= 15Pi or |X| < 2**(-40), go to 7.                   #
4924#                                                                       #
4925#       3. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let        #
4926#               k = N mod 4, so in particular, k = 0,1,2,or 3.          #
4927#               Overwrite k by k := k + AdjN.                           #
4928#                                                                       #
4929#       4. If k is even, go to 6.                                       #
4930#                                                                       #
4931#       5. (k is odd) Set j := (k-1)/2, sgn := (-1)**j.                 #
4932#               Return sgn*cos(r) where cos(r) is approximated by an    #
4933#               even polynomial in r, 1 + r*r*(B1+s*(B2+ ... + s*B8)),  #
4934#               s = r*r.                                                #
4935#               Exit.                                                   #
4936#                                                                       #
4937#       6. (k is even) Set j := k/2, sgn := (-1)**j. Return sgn*sin(r)  #
4938#               where sin(r) is approximated by an odd polynomial in r  #
4939#               r + r*s*(A1+s*(A2+ ... + s*A7)),        s = r*r.        #
4940#               Exit.                                                   #
4941#                                                                       #
4942#       7. If |X| > 1, go to 9.                                         #
4943#                                                                       #
4944#       8. (|X|<2**(-40)) If SIN is invoked, return X;                  #
4945#               otherwise return 1.                                     #
4946#                                                                       #
4947#       9. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,           #
4948#               go back to 3.                                           #
4949#                                                                       #
4950#       SINCOS:                                                         #
4951#       1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.                   #
4952#                                                                       #
4953#       2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let        #
4954#               k = N mod 4, so in particular, k = 0,1,2,or 3.          #
4955#                                                                       #
4956#       3. If k is even, go to 5.                                       #
4957#                                                                       #
4958#       4. (k is odd) Set j1 := (k-1)/2, j2 := j1 (EOR) (k mod 2), ie.  #
4959#               j1 exclusive or with the l.s.b. of k.                   #
4960#               sgn1 := (-1)**j1, sgn2 := (-1)**j2.                     #
4961#               SIN(X) = sgn1 * cos(r) and COS(X) = sgn2*sin(r) where   #
4962#               sin(r) and cos(r) are computed as odd and even          #
4963#               polynomials in r, respectively. Exit                    #
4964#                                                                       #
4965#       5. (k is even) Set j1 := k/2, sgn1 := (-1)**j1.                 #
4966#               SIN(X) = sgn1 * sin(r) and COS(X) = sgn1*cos(r) where   #
4967#               sin(r) and cos(r) are computed as odd and even          #
4968#               polynomials in r, respectively. Exit                    #
4969#                                                                       #
4970#       6. If |X| > 1, go to 8.                                         #
4971#                                                                       #
4972#       7. (|X|<2**(-40)) SIN(X) = X and COS(X) = 1. Exit.              #
4973#                                                                       #
4974#       8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi,           #
4975#               go back to 2.                                           #
4976#                                                                       #
4977#########################################################################
4978
4979SINA7:  long            0xBD6AAA77,0xCCC994F5
4980SINA6:  long            0x3DE61209,0x7AAE8DA1
4981SINA5:  long            0xBE5AE645,0x2A118AE4
4982SINA4:  long            0x3EC71DE3,0xA5341531
4983SINA3:  long            0xBF2A01A0,0x1A018B59,0x00000000,0x00000000
4984SINA2:  long            0x3FF80000,0x88888888,0x888859AF,0x00000000
4985SINA1:  long            0xBFFC0000,0xAAAAAAAA,0xAAAAAA99,0x00000000
4986
4987COSB8:  long            0x3D2AC4D0,0xD6011EE3
4988COSB7:  long            0xBDA9396F,0x9F45AC19
4989COSB6:  long            0x3E21EED9,0x0612C972
4990COSB5:  long            0xBE927E4F,0xB79D9FCF
4991COSB4:  long            0x3EFA01A0,0x1A01D423,0x00000000,0x00000000
4992COSB3:  long            0xBFF50000,0xB60B60B6,0x0B61D438,0x00000000
4993COSB2:  long            0x3FFA0000,0xAAAAAAAA,0xAAAAAB5E
4994COSB1:  long            0xBF000000
4995
4996        set             INARG,FP_SCR0
4997
4998        set             X,FP_SCR0
4999#       set             XDCARE,X+2
5000        set             XFRAC,X+4

5001
5002        set             RPRIME,FP_SCR0
5003        set             SPRIME,FP_SCR1
5004
5005        set             POSNEG1,L_SCR1
5006        set             TWOTO63,L_SCR1
5007
5008        set             ENDFLAG,L_SCR2
5009        set             INT,L_SCR2
5010
5011        set             ADJN,L_SCR3
5012
5013############################################
5014        global          ssin
5015ssin:
5016        mov.l           &0,ADJN(%a6)            # yes; SET ADJN TO 0
5017        bra.b           SINBGN
5018
5019############################################
5020        global          scos
5021scos:
5022        mov.l           &1,ADJN(%a6)            # yes; SET ADJN TO 1
5023
5024############################################
5025SINBGN:
5026#--SAVE FPCR, FP1. CHECK IF |X| IS TOO SMALL OR LARGE
5027
5028        fmov.x          (%a0),%fp0              # LOAD INPUT
5029        fmov.x          %fp0,X(%a6)             # save input at X
5030
5031# "COMPACTIFY" X
5032        mov.l           (%a0),%d1               # put exp in hi word
5033        mov.w           4(%a0),%d1              # fetch hi(man)
5034        and.l           &0x7FFFFFFF,%d1         # strip sign
5035
5036        cmpi.l          %d1,&0x3FD78000         # is |X| >= 2**(-40)?
5037        bge.b           SOK1                    # no
5038        bra.w           SINSM                   # yes; input is very small
5039
5040SOK1:
5041        cmp.l           %d1,&0x4004BC7E         # is |X| < 15 PI?
5042        blt.b           SINMAIN                 # no
5043        bra.w           SREDUCEX                # yes; input is very large
5044
5045#--THIS IS THE USUAL CASE, |X| <= 15 PI.
5046#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5047SINMAIN:
5048        fmov.x          %fp0,%fp1
5049        fmul.d          TWOBYPI(%pc),%fp1       # X*2/PI
5050
5051        lea             PITBL+0x200(%pc),%a1    # TABLE OF N*PI/2, N = -32,...,32
5052
5053        fmov.l          %fp1,INT(%a6)           # CONVERT TO INTEGER
5054
5055        mov.l           INT(%a6),%d1            # make a copy of N
5056        asl.l           &4,%d1                  # N *= 16
5057        add.l           %d1,%a1                 # tbl_addr = a1 + (N*16)
5058
5059# A1 IS THE ADDRESS OF N*PIBY2
5060# ...WHICH IS IN TWO PIECES Y1 & Y2
5061        fsub.x          (%a1)+,%fp0             # X-Y1
5062        fsub.s          (%a1),%fp0              # fp0 = R = (X-Y1)-Y2
5063
5064SINCONT:
5065#--continuation from REDUCEX
5066
5067#--GET N+ADJN AND SEE IF SIN(R) OR COS(R) IS NEEDED
5068        mov.l           INT(%a6),%d1
5069        add.l           ADJN(%a6),%d1           # SEE IF D0 IS ODD OR EVEN
5070        ror.l           &1,%d1                  # D0 WAS ODD IFF D0 IS NEGATIVE
5071        cmp.l           %d1,&0
5072        blt.w           COSPOLY
5073
5074#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
5075#--THEN WE RETURN       SGN*SIN(R). SGN*SIN(R) IS COMPUTED BY
5076#--R' + R'*S*(A1 + S(A2 + S(A3 + S(A4 + ... + SA7)))), WHERE
5077#--R' = SGN*R, S=R*R. THIS CAN BE REWRITTEN AS
5078#--R' + R'*S*( [A1+T(A3+T(A5+TA7))] + [S(A2+T(A4+TA6))])
5079#--WHERE T=S*S.
5080#--NOTE THAT A3 THROUGH A7 ARE STORED IN DOUBLE PRECISION
5081#--WHILE A1 AND A2 ARE IN DOUBLE-EXTENDED FORMAT.
5082SINPOLY:
5083        fmovm.x         &0x0c,-(%sp)            # save fp2/fp3
5084
5085        fmov.x          %fp0,X(%a6)             # X IS R
5086        fmul.x          %fp0,%fp0               # FP0 IS S
5087
5088        fmov.d          SINA7(%pc),%fp3
5089        fmov.d          SINA6(%pc),%fp2
5090
5091        fmov.x          %fp0,%fp1
5092        fmul.x          %fp1,%fp1               # FP1 IS T
5093
5094        ror.l           &1,%d1
5095        and.l           &0x80000000,%d1
5096# ...LEAST SIG. BIT OF D0 IN SIGN POSITION
5097        eor.l           %d1,X(%a6)              # X IS NOW R'= SGN*R
5098
5099        fmul.x          %fp1,%fp3               # TA7
5100        fmul.x          %fp1,%fp2               # TA6
5101
5102        fadd.d          SINA5(%pc),%fp3         # A5+TA7
5103        fadd.d          SINA4(%pc),%fp2         # A4+TA6
5104
5105        fmul.x          %fp1,%fp3               # T(A5+TA7)
5106        fmul.x          %fp1,%fp2               # T(A4+TA6)
5107
5108        fadd.d          SINA3(%pc),%fp3         # A3+T(A5+TA7)
5109        fadd.x          SINA2(%pc),%fp2         # A2+T(A4+TA6)
5110
5111        fmul.x          %fp3,%fp1               # T(A3+T(A5+TA7))
5112
5113        fmul.x          %fp0,%fp2               # S(A2+T(A4+TA6))
5114        fadd.x          SINA1(%pc),%fp1         # A1+T(A3+T(A5+TA7))
5115        fmul.x          X(%a6),%fp0             # R'*S
5116
5117        fadd.x          %fp2,%fp1               # [A1+T(A3+T(A5+TA7))]+[S(A2+T(A4+TA6))]
5118
5119        fmul.x          %fp1,%fp0               # SIN(R')-R'
5120
5121        fmovm.x         (%sp)+,&0x30            # restore fp2/fp3
5122
5123        fmov.l          %d0,%fpcr               # restore users round mode,prec
5124        fadd.x          X(%a6),%fp0             # last inst - possible exception set
5125        bra             t_inx2
5126
5127#--LET J BE THE LEAST SIG. BIT OF D0, LET SGN := (-1)**J.
5128#--THEN WE RETURN       SGN*COS(R). SGN*COS(R) IS COMPUTED BY
5129#--SGN + S'*(B1 + S(B2 + S(B3 + S(B4 + ... + SB8)))), WHERE
5130#--S=R*R AND S'=SGN*S. THIS CAN BE REWRITTEN AS
5131#--SGN + S'*([B1+T(B3+T(B5+TB7))] + [S(B2+T(B4+T(B6+TB8)))])
5132#--WHERE T=S*S.
5133#--NOTE THAT B4 THROUGH B8 ARE STORED IN DOUBLE PRECISION
5134#--WHILE B2 AND B3 ARE IN DOUBLE-EXTENDED FORMAT, B1 IS -1/2
5135#--AND IS THEREFORE STORED AS SINGLE PRECISION.
5136COSPOLY:
5137        fmovm.x         &0x0c,-(%sp)            # save fp2/fp3
5138
5139        fmul.x          %fp0,%fp0               # FP0 IS S
5140
5141        fmov.d          COSB8(%pc),%fp2
5142        fmov.d          COSB7(%pc),%fp3
5143
5144        fmov.x          %fp0,%fp1
5145        fmul.x          %fp1,%fp1               # FP1 IS T
5146
5147        fmov.x          %fp0,X(%a6)             # X IS S
5148        ror.l           &1,%d1
5149        and.l           &0x80000000,%d1
5150# ...LEAST SIG. BIT OF D0 IN SIGN POSITION
5151
5152        fmul.x          %fp1,%fp2               # TB8
5153
5154        eor.l           %d1,X(%a6)              # X IS NOW S'= SGN*S
5155        and.l           &0x80000000,%d1
5156
5157        fmul.x          %fp1,%fp3               # TB7
5158
5159        or.l            &0x3F800000,%d1         # D0 IS SGN IN SINGLE
5160        mov.l           %d1,POSNEG1(%a6)
5161
5162        fadd.d          COSB6(%pc),%fp2         # B6+TB8
5163        fadd.d          COSB5(%pc),%fp3         # B5+TB7
5164
5165        fmul.x          %fp1,%fp2               # T(B6+TB8)
5166        fmul.x          %fp1,%fp3               # T(B5+TB7)
5167
5168        fadd.d          COSB4(%pc),%fp2         # B4+T(B6+TB8)
5169        fadd.x          COSB3(%pc),%fp3         # B3+T(B5+TB7)
5170
5171        fmul.x          %fp1,%fp2               # T(B4+T(B6+TB8))
5172        fmul.x          %fp3,%fp1               # T(B3+T(B5+TB7))
5173
5174        fadd.x          COSB2(%pc),%fp2         # B2+T(B4+T(B6+TB8))
5175        fadd.s          COSB1(%pc),%fp1         # B1+T(B3+T(B5+TB7))
5176
5177        fmul.x          %fp2,%fp0               # S(B2+T(B4+T(B6+TB8)))
5178
5179        fadd.x          %fp1,%fp0
5180
5181        fmul.x          X(%a6),%fp0
5182
5183        fmovm.x         (%sp)+,&0x30            # restore fp2/fp3
5184
5185        fmov.l          %d0,%fpcr               # restore users round mode,prec
5186        fadd.s          POSNEG1(%a6),%fp0       # last inst - possible exception set
5187        bra             t_inx2
5188
5189##############################################
5190
5191# SINe: Big OR Small?
5192#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5193#--IF |X| < 2**(-40), RETURN X OR 1.
5194SINBORS:
5195        cmp.l           %d1,&0x3FFF8000
5196        bgt.l           SREDUCEX
5197
5198SINSM:
5199        mov.l           ADJN(%a6),%d1
5200        cmp.l           %d1,&0
5201        bgt.b           COSTINY
5202
5203# here, the operation may underflow iff the precision is sgl or dbl.
5204# extended denorms are handled through another entry point.
5205SINTINY:
5206#       mov.w           &0x0000,XDCARE(%a6)     # JUST IN CASE
5207
5208        fmov.l          %d0,%fpcr               # restore users round mode,prec
5209        mov.b           &FMOV_OP,%d1            # last inst is MOVE
5210        fmov.x          X(%a6),%fp0             # last inst - possible exception set
5211        bra             t_catch
5212
5213COSTINY:
5214        fmov.s          &0x3F800000,%fp0        # fp0 = 1.0
5215        fmov.l          %d0,%fpcr               # restore users round mode,prec
5216        fadd.s          &0x80800000,%fp0        # last inst - possible exception set
5217        bra             t_pinx2
5218
5219################################################
5220        global          ssind
5221#--SIN(X) = X FOR DENORMALIZED X
5222ssind:
5223        bra             t_extdnrm
5224
5225############################################
5226        global          scosd
5227#--COS(X) = 1 FOR DENORMALIZED X
5228scosd:
5229        fmov.s          &0x3F800000,%fp0        # fp0 = 1.0
5230        bra             t_pinx2
5231
5232##################################################
5233
5234        global          ssincos
5235ssincos:
5236#--SET ADJN TO 4
5237        mov.l           &4,ADJN(%a6)
5238
5239        fmov.x          (%a0),%fp0              # LOAD INPUT
5240        fmov.x          %fp0,X(%a6)
5241
5242        mov.l           (%a0),%d1
5243        mov.w           4(%a0),%d1
5244        and.l           &0x7FFFFFFF,%d1         # COMPACTIFY X
5245
5246        cmp.l           %d1,&0x3FD78000         # |X| >= 2**(-40)?
5247        bge.b           SCOK1
5248        bra.w           SCSM
5249
5250SCOK1:
5251        cmp.l           %d1,&0x4004BC7E         # |X| < 15 PI?
5252        blt.b           SCMAIN
5253        bra.w           SREDUCEX
5254
5255
5256#--THIS IS THE USUAL CASE, |X| <= 15 PI.
5257#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5258SCMAIN:
5259        fmov.x          %fp0,%fp1
5260
5261        fmul.d          TWOBYPI(%pc),%fp1       # X*2/PI
5262
5263        lea             PITBL+0x200(%pc),%a1    # TABLE OF N*PI/2, N = -32,...,32
5264
5265        fmov.l          %fp1,INT(%a6)           # CONVERT TO INTEGER
5266
5267        mov.l           INT(%a6),%d1
5268        asl.l           &4,%d1
5269        add.l           %d1,%a1                 # ADDRESS OF N*PIBY2, IN Y1, Y2
5270
5271        fsub.x          (%a1)+,%fp0             # X-Y1
5272        fsub.s          (%a1),%fp0              # FP0 IS R = (X-Y1)-Y2
5273
5274SCCONT:
5275#--continuation point from REDUCEX
5276
5277        mov.l           INT(%a6),%d1
5278        ror.l           &1,%d1
5279        cmp.l           %d1,&0                  # D0 < 0 IFF N IS ODD
5280        bge.w           NEVEN
5281
5282SNODD:
5283#--REGISTERS SAVED SO FAR: D0, A0, FP2.
5284        fmovm.x         &0x04,-(%sp)            # save fp2
5285
5286        fmov.x          %fp0,RPRIME(%a6)
5287        fmul.x          %fp0,%fp0               # FP0 IS S = R*R
5288        fmov.d          SINA7(%pc),%fp1         # A7
5289        fmov.d          COSB8(%pc),%fp2         # B8
5290        fmul.x          %fp0,%fp1               # SA7
5291        fmul.x          %fp0,%fp2               # SB8
5292
5293        mov.l           %d2,-(%sp)
5294        mov.l           %d1,%d2
5295        ror.l           &1,%d2
5296        and.l           &0x80000000,%d2
5297        eor.l           %d1,%d2
5298        and.l           &0x80000000,%d2
5299
5300        fadd.d          SINA6(%pc),%fp1         # A6+SA7
5301        fadd.d          COSB7(%pc),%fp2         # B7+SB8
5302
5303        fmul.x          %fp0,%fp1               # S(A6+SA7)
5304        eor.l           %d2,RPRIME(%a6)
5305        mov.l           (%sp)+,%d2
5306        fmul.x          %fp0,%fp2               # S(B7+SB8)
5307        ror.l           &1,%d1
5308        and.l           &0x80000000,%d1
5309        mov.l           &0x3F800000,POSNEG1(%a6)
5310        eor.l           %d1,POSNEG1(%a6)
5311
5312        fadd.d          SINA5(%pc),%fp1         # A5+S(A6+SA7)
5313        fadd.d          COSB6(%pc),%fp2         # B6+S(B7+SB8)
5314
5315        fmul.x          %fp0,%fp1               # S(A5+S(A6+SA7))
5316        fmul.x          %fp0,%fp2               # S(B6+S(B7+SB8))
5317        fmov.x          %fp0,SPRIME(%a6)
5318
5319        fadd.d          SINA4(%pc),%fp1         # A4+S(A5+S(A6+SA7))
5320        eor.l           %d1,SPRIME(%a6)
5321        fadd.d          COSB5(%pc),%fp2         # B5+S(B6+S(B7+SB8))
5322
5323        fmul.x          %fp0,%fp1               # S(A4+...)
5324        fmul.x          %fp0,%fp2               # S(B5+...)
5325
5326        fadd.d          SINA3(%pc),%fp1         # A3+S(A4+...)
5327        fadd.d          COSB4(%pc),%fp2         # B4+S(B5+...)
5328
5329        fmul.x          %fp0,%fp1               # S(A3+...)
5330        fmul.x          %fp0,%fp2               # S(B4+...)
5331
5332        fadd.x          SINA2(%pc),%fp1         # A2+S(A3+...)
5333        fadd.x          COSB3(%pc),%fp2         # B3+S(B4+...)
5334
5335        fmul.x          %fp0,%fp1               # S(A2+...)
5336        fmul.x          %fp0,%fp2               # S(B3+...)
5337
5338        fadd.x          SINA1(%pc),%fp1         # A1+S(A2+...)
5339        fadd.x          COSB2(%pc),%fp2         # B2+S(B3+...)
5340
5341        fmul.x          %fp0,%fp1               # S(A1+...)
5342        fmul.x          %fp2,%fp0               # S(B2+...)
5343
5344        fmul.x          RPRIME(%a6),%fp1        # R'S(A1+...)
5345        fadd.s          COSB1(%pc),%fp0         # B1+S(B2...)
5346        fmul.x          SPRIME(%a6),%fp0        # S'(B1+S(B2+...))
5347
5348        fmovm.x         (%sp)+,&0x20            # restore fp2
5349
5350        fmov.l          %d0,%fpcr
5351        fadd.x          RPRIME(%a6),%fp1        # COS(X)
5352        bsr             sto_cos                 # store cosine result
5353        fadd.s          POSNEG1(%a6),%fp0       # SIN(X)
5354        bra             t_inx2
5355
5356NEVEN:
5357#--REGISTERS SAVED SO FAR: FP2.
5358        fmovm.x         &0x04,-(%sp)            # save fp2
5359
5360        fmov.x          %fp0,RPRIME(%a6)
5361        fmul.x          %fp0,%fp0               # FP0 IS S = R*R
5362
5363        fmov.d          COSB8(%pc),%fp1         # B8
5364        fmov.d          SINA7(%pc),%fp2         # A7
5365
5366        fmul.x          %fp0,%fp1               # SB8
5367        fmov.x          %fp0,SPRIME(%a6)
5368        fmul.x          %fp0,%fp2               # SA7
5369
5370        ror.l           &1,%d1
5371        and.l           &0x80000000,%d1
5372
5373        fadd.d          COSB7(%pc),%fp1         # B7+SB8
5374        fadd.d          SINA6(%pc),%fp2         # A6+SA7
5375
5376        eor.l           %d1,RPRIME(%a6)
5377        eor.l           %d1,SPRIME(%a6)
5378
5379        fmul.x          %fp0,%fp1               # S(B7+SB8)
5380
5381        or.l            &0x3F800000,%d1
5382        mov.l           %d1,POSNEG1(%a6)
5383
5384        fmul.x          %fp0,%fp2               # S(A6+SA7)
5385
5386        fadd.d          COSB6(%pc),%fp1         # B6+S(B7+SB8)
5387        fadd.d          SINA5(%pc),%fp2         # A5+S(A6+SA7)
5388
5389        fmul.x          %fp0,%fp1               # S(B6+S(B7+SB8))
5390        fmul.x          %fp0,%fp2               # S(A5+S(A6+SA7))
5391
5392        fadd.d          COSB5(%pc),%fp1         # B5+S(B6+S(B7+SB8))
5393        fadd.d          SINA4(%pc),%fp2         # A4+S(A5+S(A6+SA7))
5394
5395        fmul.x          %fp0,%fp1               # S(B5+...)
5396        fmul.x          %fp0,%fp2               # S(A4+...)
5397
5398        fadd.d          COSB4(%pc),%fp1         # B4+S(B5+...)
5399        fadd.d          SINA3(%pc),%fp2         # A3+S(A4+...)
5400
5401        fmul.x          %fp0,%fp1               # S(B4+...)
5402        fmul.x          %fp0,%fp2               # S(A3+...)
5403
5404        fadd.x          COSB3(%pc),%fp1         # B3+S(B4+...)
5405        fadd.x          SINA2(%pc),%fp2         # A2+S(A3+...)
5406
5407        fmul.x          %fp0,%fp1               # S(B3+...)
5408        fmul.x          %fp0,%fp2               # S(A2+...)
5409
5410        fadd.x          COSB2(%pc),%fp1         # B2+S(B3+...)
5411        fadd.x          SINA1(%pc),%fp2         # A1+S(A2+...)
5412
5413        fmul.x          %fp0,%fp1               # S(B2+...)
5414        fmul.x          %fp2,%fp0               # s(a1+...)
5415
5416
5417        fadd.s          COSB1(%pc),%fp1         # B1+S(B2...)
5418        fmul.x          RPRIME(%a6),%fp0        # R'S(A1+...)
5419        fmul.x          SPRIME(%a6),%fp1        # S'(B1+S(B2+...))
5420
5421        fmovm.x         (%sp)+,&0x20            # restore fp2
5422
5423        fmov.l          %d0,%fpcr
5424        fadd.s          POSNEG1(%a6),%fp1       # COS(X)
5425        bsr             sto_cos                 # store cosine result
5426        fadd.x          RPRIME(%a6),%fp0        # SIN(X)
5427        bra             t_inx2
5428
5429################################################
5430
5431SCBORS:
5432        cmp.l           %d1,&0x3FFF8000
5433        bgt.w           SREDUCEX
5434
5435################################################
5436
5437SCSM:
5438#       mov.w           &0x0000,XDCARE(%a6)
5439        fmov.s          &0x3F800000,%fp1
5440
5441        fmov.l          %d0,%fpcr
5442        fsub.s          &0x00800000,%fp1
5443        bsr             sto_cos                 # store cosine result
5444        fmov.l          %fpcr,%d0               # d0 must have fpcr,too
5445        mov.b           &FMOV_OP,%d1            # last inst is MOVE
5446        fmov.x          X(%a6),%fp0
5447        bra             t_catch
5448
5449##############################################
5450
5451        global          ssincosd
5452#--SIN AND COS OF X FOR DENORMALIZED X
5453ssincosd:
5454        mov.l           %d0,-(%sp)              # save d0
5455        fmov.s          &0x3F800000,%fp1
5456        bsr             sto_cos                 # store cosine result
5457        mov.l           (%sp)+,%d0              # restore d0
5458        bra             t_extdnrm
5459
5460############################################
5461
5462#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
5463#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
5464#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
5465SREDUCEX:
5466        fmovm.x         &0x3c,-(%sp)            # save {fp2-fp5}
5467        mov.l           %d2,-(%sp)              # save d2
5468        fmov.s          &0x00000000,%fp1        # fp1 = 0
5469
5470#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
5471#--there is a danger of unwanted overflow in first LOOP iteration.  In this
5472#--case, reduce argument by one remainder step to make subsequent reduction
5473#--safe.
5474        cmp.l           %d1,&0x7ffeffff         # is arg dangerously large?
5475        bne.b           SLOOP                   # no
5476
5477# yes; create 2**16383*PI/2
5478        mov.w           &0x7ffe,FP_SCR0_EX(%a6)
5479        mov.l           &0xc90fdaa2,FP_SCR0_HI(%a6)
5480        clr.l           FP_SCR0_LO(%a6)
5481
5482# create low half of 2**16383*PI/2 at FP_SCR1
5483        mov.w           &0x7fdc,FP_SCR1_EX(%a6)
5484        mov.l           &0x85a308d3,FP_SCR1_HI(%a6)
5485        clr.l           FP_SCR1_LO(%a6)
5486
5487        ftest.x         %fp0                    # test sign of argument
5488        fblt.w          sred_neg
5489
5490        or.b            &0x80,FP_SCR0_EX(%a6)   # positive arg
5491        or.b            &0x80,FP_SCR1_EX(%a6)
5492sred_neg:
5493        fadd.x          FP_SCR0(%a6),%fp0       # high part of reduction is exact
5494        fmov.x          %fp0,%fp1               # save high result in fp1
5495        fadd.x          FP_SCR1(%a6),%fp0       # low part of reduction
5496        fsub.x          %fp0,%fp1               # determine low component of result
5497        fadd.x          FP_SCR1(%a6),%fp1       # fp0/fp1 are reduced argument.
5498
5499#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5500#--integer quotient will be stored in N
5501#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5502SLOOP:
5503        fmov.x          %fp0,INARG(%a6)         # +-2**K * F, 1 <= F < 2
5504        mov.w           INARG(%a6),%d1
5505        mov.l           %d1,%a1                 # save a copy of D0
5506        and.l           &0x00007FFF,%d1
5507        sub.l           &0x00003FFF,%d1         # d0 = K
5508        cmp.l           %d1,&28
5509        ble.b           SLASTLOOP
5510SCONTLOOP:
5511        sub.l           &27,%d1                 # d0 = L := K-27
5512        mov.b           &0,ENDFLAG(%a6)
5513        bra.b           SWORK
5514SLASTLOOP:
5515        clr.l           %d1                     # d0 = L := 0
5516        mov.b           &1,ENDFLAG(%a6)
5517
5518SWORK:
5519#--FIND THE REMAINDER OF (R,r) W.R.T.   2**L * (PI/2). L IS SO CHOSEN
5520#--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.
5521
5522#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
5523#--2**L * (PIby2_1), 2**L * (PIby2_2)
5524
5525        mov.l           &0x00003FFE,%d2         # BIASED EXP OF 2/PI
5526        sub.l           %d1,%d2                 # BIASED EXP OF 2**(-L)*(2/PI)
5527
5528        mov.l           &0xA2F9836E,FP_SCR0_HI(%a6)
5529        mov.l           &0x4E44152A,FP_SCR0_LO(%a6)
5530        mov.w           %d2,FP_SCR0_EX(%a6)     # FP_SCR0 = 2**(-L)*(2/PI)
5531
5532        fmov.x          %fp0,%fp2
5533        fmul.x          FP_SCR0(%a6),%fp2       # fp2 = X * 2**(-L)*(2/PI)
5534
5535#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5536#--FLOATING POINT FORMAT, THE TWO FMOVE'S       FMOVE.L FP <--> N
5537#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
5538#--(SIGN(INARG)*2**63   +       FP2) - SIGN(INARG)*2**63 WILL GIVE
5539#--US THE DESIRED VALUE IN FLOATING POINT.
5540        mov.l           %a1,%d2
5541        swap            %d2
5542        and.l           &0x80000000,%d2
5543        or.l            &0x5F000000,%d2         # d2 = SIGN(INARG)*2**63 IN SGL
5544        mov.l           %d2,TWOTO63(%a6)
5545        fadd.s          TWOTO63(%a6),%fp2       # THE FRACTIONAL PART OF FP1 IS ROUNDED
5546        fsub.s          TWOTO63(%a6),%fp2       # fp2 = N
5547#       fint.x          %fp2
5548
5549#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
5550        mov.l           %d1,%d2                 # d2 = L
5551
5552        add.l           &0x00003FFF,%d2         # BIASED EXP OF 2**L * (PI/2)
5553        mov.w           %d2,FP_SCR0_EX(%a6)
5554        mov.l           &0xC90FDAA2,FP_SCR0_HI(%a6)
5555        clr.l           FP_SCR0_LO(%a6)         # FP_SCR0 = 2**(L) * Piby2_1
5556
5557        add.l           &0x00003FDD,%d1
5558        mov.w           %d1,FP_SCR1_EX(%a6)
5559        mov.l           &0x85A308D3,FP_SCR1_HI(%a6)
5560        clr.l           FP_SCR1_LO(%a6)         # FP_SCR1 = 2**(L) * Piby2_2
5561
5562        mov.b           ENDFLAG(%a6),%d1
5563
5564#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
5565#--P2 = 2**(L) * Piby2_2
5566        fmov.x          %fp2,%fp4               # fp4 = N
5567        fmul.x          FP_SCR0(%a6),%fp4       # fp4 = W = N*P1
5568        fmov.x          %fp2,%fp5               # fp5 = N
5569        fmul.x          FP_SCR1(%a6),%fp5       # fp5 = w = N*P2
5570        fmov.x          %fp4,%fp3               # fp3 = W = N*P1
5571
5572#--we want P+p = W+w  but  |p| <= half ulp of P
5573#--Then, we need to compute  A := R-P   and  a := r-p
5574        fadd.x          %fp5,%fp3               # fp3 = P
5575        fsub.x          %fp3,%fp4               # fp4 = W-P
5576
5577        fsub.x          %fp3,%fp0               # fp0 = A := R - P
5578        fadd.x          %fp5,%fp4               # fp4 = p = (W-P)+w
5579
5580        fmov.x          %fp0,%fp3               # fp3 = A
5581        fsub.x          %fp4,%fp1               # fp1 = a := r - p
5582
5583#--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
5584#--|r| <= half ulp of R.
5585        fadd.x          %fp1,%fp0               # fp0 = R := A+a
5586#--No need to calculate r if this is the last loop
5587        cmp.b           %d1,&0
5588        bgt.w           SRESTORE
5589
5590#--Need to calculate r
5591        fsub.x          %fp0,%fp3               # fp3 = A-R
5592        fadd.x          %fp3,%fp1               # fp1 = r := (A-R)+a
5593        bra.w           SLOOP
5594
5595SRESTORE:
5596        fmov.l          %fp2,INT(%a6)
5597        mov.l           (%sp)+,%d2              # restore d2
5598        fmovm.x         (%sp)+,&0x3c            # restore {fp2-fp5}
5599
5600        mov.l           ADJN(%a6),%d1
5601        cmp.l           %d1,&4
5602
5603        blt.w           SINCONT
5604        bra.w           SCCONT
5605
5606#########################################################################
5607# stan():  computes the tangent of a normalized input                   #
5608# stand(): computes the tangent of a denormalized input                 #
5609#                                                                       #
5610# INPUT *************************************************************** #
5611#       a0 = pointer to extended precision input                        #
5612#       d0 = round precision,mode                                       #
5613#                                                                       #
5614# OUTPUT ************************************************************** #
5615#       fp0 = tan(X)                                                    #
5616#                                                                       #
5617# ACCURACY and MONOTONICITY ******************************************* #
5618#       The returned result is within 3 ulp in 64 significant bit, i.e. #
5619#       within 0.5001 ulp to 53 bits if the result is subsequently      #
5620#       rounded to double precision. The result is provably monotonic   #
5621#       in double precision.                                            #
5622#                                                                       #
5623# ALGORITHM *********************************************************** #
5624#                                                                       #
5625#       1. If |X| >= 15Pi or |X| < 2**(-40), go to 6.                   #
5626#                                                                       #
5627#       2. Decompose X as X = N(Pi/2) + r where |r| <= Pi/4. Let        #
5628#               k = N mod 2, so in particular, k = 0 or 1.              #
5629#                                                                       #
5630#       3. If k is odd, go to 5.                                        #
5631#                                                                       #
5632#       4. (k is even) Tan(X) = tan(r) and tan(r) is approximated by a  #
5633#               rational function U/V where                             #
5634#               U = r + r*s*(P1 + s*(P2 + s*P3)), and                   #
5635#               V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))),  s = r*r.      #
5636#               Exit.                                                   #
5637#                                                                       #
5638#       4. (k is odd) Tan(X) = -cot(r). Since tan(r) is approximated by #
5639#               a rational function U/V where                           #
5640#               U = r + r*s*(P1 + s*(P2 + s*P3)), and                   #
5641#               V = 1 + s*(Q1 + s*(Q2 + s*(Q3 + s*Q4))), s = r*r,       #
5642#               -Cot(r) = -V/U. Exit.                                   #
5643#                                                                       #
5644#       6. If |X| > 1, go to 8.                                         #
5645#                                                                       #
5646#       7. (|X|<2**(-40)) Tan(X) = X. Exit.                             #
5647#                                                                       #
5648#       8. Overwrite X by X := X rem 2Pi. Now that |X| <= Pi, go back   #
5649#               to 2.                                                   #
5650#                                                                       #
5651#########################################################################
5652
5653TANQ4:
5654        long            0x3EA0B759,0xF50F8688
5655TANP3:
5656        long            0xBEF2BAA5,0xA8924F04
5657
5658TANQ3:
5659        long            0xBF346F59,0xB39BA65F,0x00000000,0x00000000
5660
5661TANP2:
5662        long            0x3FF60000,0xE073D3FC,0x199C4A00,0x00000000
5663
5664TANQ2:
5665        long            0x3FF90000,0xD23CD684,0x15D95FA1,0x00000000
5666
5667TANP1:
5668        long            0xBFFC0000,0x8895A6C5,0xFB423BCA,0x00000000
5669
5670TANQ1:
5671        long            0xBFFD0000,0xEEF57E0D,0xA84BC8CE,0x00000000
5672
5673INVTWOPI:
5674        long            0x3FFC0000,0xA2F9836E,0x4E44152A,0x00000000
5675
5676TWOPI1:
5677        long            0x40010000,0xC90FDAA2,0x00000000,0x00000000
5678TWOPI2:
5679        long            0x3FDF0000,0x85A308D4,0x00000000,0x00000000
5680
5681#--N*PI/2, -32 <= N <= 32, IN A LEADING TERM IN EXT. AND TRAILING
5682#--TERM IN SGL. NOTE THAT PI IS 64-BIT LONG, THUS N*PI/2 IS AT
5683#--MOST 69 BITS LONG.
5684#       global          PITBL
5685PITBL:
5686        long            0xC0040000,0xC90FDAA2,0x2168C235,0x21800000
5687        long            0xC0040000,0xC2C75BCD,0x105D7C23,0xA0D00000
5688        long            0xC0040000,0xBC7EDCF7,0xFF523611,0xA1E80000
5689        long            0xC0040000,0xB6365E22,0xEE46F000,0x21480000
5690        long            0xC0040000,0xAFEDDF4D,0xDD3BA9EE,0xA1200000
5691        long            0xC0040000,0xA9A56078,0xCC3063DD,0x21FC0000
5692        long            0xC0040000,0xA35CE1A3,0xBB251DCB,0x21100000
5693        long            0xC0040000,0x9D1462CE,0xAA19D7B9,0xA1580000
5694        long            0xC0040000,0x96CBE3F9,0x990E91A8,0x21E00000
5695        long            0xC0040000,0x90836524,0x88034B96,0x20B00000
5696        long            0xC0040000,0x8A3AE64F,0x76F80584,0xA1880000
5697        long            0xC0040000,0x83F2677A,0x65ECBF73,0x21C40000
5698        long            0xC0030000,0xFB53D14A,0xA9C2F2C2,0x20000000
5699        long            0xC0030000,0xEEC2D3A0,0x87AC669F,0x21380000
5700        long            0xC0030000,0xE231D5F6,0x6595DA7B,0xA1300000
5701        long            0xC0030000,0xD5A0D84C,0x437F4E58,0x9FC00000
5702        long            0xC0030000,0xC90FDAA2,0x2168C235,0x21000000
5703        long            0xC0030000,0xBC7EDCF7,0xFF523611,0xA1680000
5704        long            0xC0030000,0xAFEDDF4D,0xDD3BA9EE,0xA0A00000
5705        long            0xC0030000,0xA35CE1A3,0xBB251DCB,0x20900000
5706        long            0xC0030000,0x96CBE3F9,0x990E91A8,0x21600000
5707        long            0xC0030000,0x8A3AE64F,0x76F80584,0xA1080000
5708        long            0xC0020000,0xFB53D14A,0xA9C2F2C2,0x1F800000
5709        long            0xC0020000,0xE231D5F6,0x6595DA7B,0xA0B00000
5710        long            0xC0020000,0xC90FDAA2,0x2168C235,0x20800000
5711        long            0xC0020000,0xAFEDDF4D,0xDD3BA9EE,0xA0200000
5712        long            0xC0020000,0x96CBE3F9,0x990E91A8,0x20E00000
5713        long            0xC0010000,0xFB53D14A,0xA9C2F2C2,0x1F000000
5714        long            0xC0010000,0xC90FDAA2,0x2168C235,0x20000000
5715        long            0xC0010000,0x96CBE3F9,0x990E91A8,0x20600000
5716        long            0xC0000000,0xC90FDAA2,0x2168C235,0x1F800000
5717        long            0xBFFF0000,0xC90FDAA2,0x2168C235,0x1F000000
5718        long            0x00000000,0x00000000,0x00000000,0x00000000
5719        long            0x3FFF0000,0xC90FDAA2,0x2168C235,0x9F000000
5720        long            0x40000000,0xC90FDAA2,0x2168C235,0x9F800000
5721        long            0x40010000,0x96CBE3F9,0x990E91A8,0xA0600000
5722        long            0x40010000,0xC90FDAA2,0x2168C235,0xA0000000
5723        long            0x40010000,0xFB53D14A,0xA9C2F2C2,0x9F000000
5724        long            0x40020000,0x96CBE3F9,0x990E91A8,0xA0E00000
5725        long            0x40020000,0xAFEDDF4D,0xDD3BA9EE,0x20200000
5726        long            0x40020000,0xC90FDAA2,0x2168C235,0xA0800000
5727        long            0x40020000,0xE231D5F6,0x6595DA7B,0x20B00000
5728        long            0x40020000,0xFB53D14A,0xA9C2F2C2,0x9F800000
5729        long            0x40030000,0x8A3AE64F,0x76F80584,0x21080000
5730        long            0x40030000,0x96CBE3F9,0x990E91A8,0xA1600000
5731        long            0x40030000,0xA35CE1A3,0xBB251DCB,0xA0900000
5732        long            0x40030000,0xAFEDDF4D,0xDD3BA9EE,0x20A00000
5733        long            0x40030000,0xBC7EDCF7,0xFF523611,0x21680000
5734        long            0x40030000,0xC90FDAA2,0x2168C235,0xA1000000
5735        long            0x40030000,0xD5A0D84C,0x437F4E58,0x1FC00000
5736        long            0x40030000,0xE231D5F6,0x6595DA7B,0x21300000
5737        long            0x40030000,0xEEC2D3A0,0x87AC669F,0xA1380000
5738        long            0x40030000,0xFB53D14A,0xA9C2F2C2,0xA0000000
5739        long            0x40040000,0x83F2677A,0x65ECBF73,0xA1C40000
5740        long            0x40040000,0x8A3AE64F,0x76F80584,0x21880000
5741        long            0x40040000,0x90836524,0x88034B96,0xA0B00000
5742        long            0x40040000,0x96CBE3F9,0x990E91A8,0xA1E00000
5743        long            0x40040000,0x9D1462CE,0xAA19D7B9,0x21580000
5744        long            0x40040000,0xA35CE1A3,0xBB251DCB,0xA1100000
5745        long            0x40040000,0xA9A56078,0xCC3063DD,0xA1FC0000
5746        long            0x40040000,0xAFEDDF4D,0xDD3BA9EE,0x21200000
5747        long            0x40040000,0xB6365E22,0xEE46F000,0xA1480000
5748        long            0x40040000,0xBC7EDCF7,0xFF523611,0x21E80000
5749        long            0x40040000,0xC2C75BCD,0x105D7C23,0x20D00000
5750        long            0x40040000,0xC90FDAA2,0x2168C235,0xA1800000
5751
5752        set             INARG,FP_SCR0
5753
5754        set             TWOTO63,L_SCR1
5755        set             INT,L_SCR1
5756        set             ENDFLAG,L_SCR2
5757
5758        global          stan
5759stan:
5760        fmov.x          (%a0),%fp0              # LOAD INPUT
5761
5762        mov.l           (%a0),%d1
5763        mov.w           4(%a0),%d1
5764        and.l           &0x7FFFFFFF,%d1
5765
5766        cmp.l           %d1,&0x3FD78000         # |X| >= 2**(-40)?
5767        bge.b           TANOK1
5768        bra.w           TANSM
5769TANOK1:
5770        cmp.l           %d1,&0x4004BC7E         # |X| < 15 PI?
5771        blt.b           TANMAIN
5772        bra.w           REDUCEX
5773
5774TANMAIN:
5775#--THIS IS THE USUAL CASE, |X| <= 15 PI.
5776#--THE ARGUMENT REDUCTION IS DONE BY TABLE LOOK UP.
5777        fmov.x          %fp0,%fp1
5778        fmul.d          TWOBYPI(%pc),%fp1       # X*2/PI
5779
5780        lea.l           PITBL+0x200(%pc),%a1    # TABLE OF N*PI/2, N = -32,...,32
5781
5782        fmov.l          %fp1,%d1                # CONVERT TO INTEGER
5783
5784        asl.l           &4,%d1
5785        add.l           %d1,%a1                 # ADDRESS N*PIBY2 IN Y1, Y2
5786
5787        fsub.x          (%a1)+,%fp0             # X-Y1
5788
5789        fsub.s          (%a1),%fp0              # FP0 IS R = (X-Y1)-Y2
5790
5791        ror.l           &5,%d1
5792        and.l           &0x80000000,%d1         # D0 WAS ODD IFF D0 < 0
5793
5794TANCONT:
5795        fmovm.x         &0x0c,-(%sp)            # save fp2,fp3
5796
5797        cmp.l           %d1,&0
5798        blt.w           NODD
5799
5800        fmov.x          %fp0,%fp1
5801        fmul.x          %fp1,%fp1               # S = R*R
5802
5803        fmov.d          TANQ4(%pc),%fp3
5804        fmov.d          TANP3(%pc),%fp2
5805
5806        fmul.x          %fp1,%fp3               # SQ4
5807        fmul.x          %fp1,%fp2               # SP3
5808
5809        fadd.d          TANQ3(%pc),%fp3         # Q3+SQ4
5810        fadd.x          TANP2(%pc),%fp2         # P2+SP3
5811
5812        fmul.x          %fp1,%fp3               # S(Q3+SQ4)
5813        fmul.x          %fp1,%fp2               # S(P2+SP3)
5814
5815        fadd.x          TANQ2(%pc),%fp3         # Q2+S(Q3+SQ4)
5816        fadd.x          TANP1(%pc),%fp2         # P1+S(P2+SP3)
5817
5818        fmul.x          %fp1,%fp3               # S(Q2+S(Q3+SQ4))
5819        fmul.x          %fp1,%fp2               # S(P1+S(P2+SP3))
5820
5821        fadd.x          TANQ1(%pc),%fp3         # Q1+S(Q2+S(Q3+SQ4))
5822        fmul.x          %fp0,%fp2               # RS(P1+S(P2+SP3))
5823
5824        fmul.x          %fp3,%fp1               # S(Q1+S(Q2+S(Q3+SQ4)))
5825
5826        fadd.x          %fp2,%fp0               # R+RS(P1+S(P2+SP3))
5827
5828        fadd.s          &0x3F800000,%fp1        # 1+S(Q1+...)
5829
5830        fmovm.x         (%sp)+,&0x30            # restore fp2,fp3
5831
5832        fmov.l          %d0,%fpcr               # restore users round mode,prec
5833        fdiv.x          %fp1,%fp0               # last inst - possible exception set
5834        bra             t_inx2
5835
5836NODD:
5837        fmov.x          %fp0,%fp1
5838        fmul.x          %fp0,%fp0               # S = R*R
5839
5840        fmov.d          TANQ4(%pc),%fp3
5841        fmov.d          TANP3(%pc),%fp2
5842
5843        fmul.x          %fp0,%fp3               # SQ4
5844        fmul.x          %fp0,%fp2               # SP3
5845
5846        fadd.d          TANQ3(%pc),%fp3         # Q3+SQ4
5847        fadd.x          TANP2(%pc),%fp2         # P2+SP3
5848
5849        fmul.x          %fp0,%fp3               # S(Q3+SQ4)
5850        fmul.x          %fp0,%fp2               # S(P2+SP3)
5851
5852        fadd.x          TANQ2(%pc),%fp3         # Q2+S(Q3+SQ4)
5853        fadd.x          TANP1(%pc),%fp2         # P1+S(P2+SP3)
5854
5855        fmul.x          %fp0,%fp3               # S(Q2+S(Q3+SQ4))
5856        fmul.x          %fp0,%fp2               # S(P1+S(P2+SP3))
5857
5858        fadd.x          TANQ1(%pc),%fp3         # Q1+S(Q2+S(Q3+SQ4))
5859        fmul.x          %fp1,%fp2               # RS(P1+S(P2+SP3))
5860
5861        fmul.x          %fp3,%fp0               # S(Q1+S(Q2+S(Q3+SQ4)))
5862
5863        fadd.x          %fp2,%fp1               # R+RS(P1+S(P2+SP3))
5864        fadd.s          &0x3F800000,%fp0        # 1+S(Q1+...)
5865
5866        fmovm.x         (%sp)+,&0x30            # restore fp2,fp3
5867
5868        fmov.x          %fp1,-(%sp)
5869        eor.l           &0x80000000,(%sp)
5870
5871        fmov.l          %d0,%fpcr               # restore users round mode,prec
5872        fdiv.x          (%sp)+,%fp0             # last inst - possible exception set
5873        bra             t_inx2
5874
5875TANBORS:
5876#--IF |X| > 15PI, WE USE THE GENERAL ARGUMENT REDUCTION.
5877#--IF |X| < 2**(-40), RETURN X OR 1.
5878        cmp.l           %d1,&0x3FFF8000
5879        bgt.b           REDUCEX
5880
5881TANSM:
5882        fmov.x          %fp0,-(%sp)
5883        fmov.l          %d0,%fpcr               # restore users round mode,prec
5884        mov.b           &FMOV_OP,%d1            # last inst is MOVE
5885        fmov.x          (%sp)+,%fp0             # last inst - posibble exception set
5886        bra             t_catch
5887
5888        global          stand
5889#--TAN(X) = X FOR DENORMALIZED X
5890stand:
5891        bra             t_extdnrm
5892
5893#--WHEN REDUCEX IS USED, THE CODE WILL INEVITABLY BE SLOW.
5894#--THIS REDUCTION METHOD, HOWEVER, IS MUCH FASTER THAN USING
5895#--THE REMAINDER INSTRUCTION WHICH IS NOW IN SOFTWARE.
5896REDUCEX:
5897        fmovm.x         &0x3c,-(%sp)            # save {fp2-fp5}
5898        mov.l           %d2,-(%sp)              # save d2
5899        fmov.s          &0x00000000,%fp1        # fp1 = 0
5900
5901#--If compact form of abs(arg) in d0=$7ffeffff, argument is so large that
5902#--there is a danger of unwanted overflow in first LOOP iteration.  In this
5903#--case, reduce argument by one remainder step to make subsequent reduction
5904#--safe.
5905        cmp.l           %d1,&0x7ffeffff         # is arg dangerously large?
5906        bne.b           LOOP                    # no
5907
5908# yes; create 2**16383*PI/2
5909        mov.w           &0x7ffe,FP_SCR0_EX(%a6)
5910        mov.l           &0xc90fdaa2,FP_SCR0_HI(%a6)
5911        clr.l           FP_SCR0_LO(%a6)
5912
5913# create low half of 2**16383*PI/2 at FP_SCR1
5914        mov.w           &0x7fdc,FP_SCR1_EX(%a6)
5915        mov.l           &0x85a308d3,FP_SCR1_HI(%a6)
5916        clr.l           FP_SCR1_LO(%a6)
5917
5918        ftest.x         %fp0                    # test sign of argument
5919        fblt.w          red_neg
5920
5921        or.b            &0x80,FP_SCR0_EX(%a6)   # positive arg
5922        or.b            &0x80,FP_SCR1_EX(%a6)
5923red_neg:
5924        fadd.x          FP_SCR0(%a6),%fp0       # high part of reduction is exact
5925        fmov.x          %fp0,%fp1               # save high result in fp1
5926        fadd.x          FP_SCR1(%a6),%fp0       # low part of reduction
5927        fsub.x          %fp0,%fp1               # determine low component of result
5928        fadd.x          FP_SCR1(%a6),%fp1       # fp0/fp1 are reduced argument.
5929
5930#--ON ENTRY, FP0 IS X, ON RETURN, FP0 IS X REM PI/2, |X| <= PI/4.
5931#--integer quotient will be stored in N
5932#--Intermeditate remainder is 66-bit long; (R,r) in (FP0,FP1)
5933LOOP:
5934        fmov.x          %fp0,INARG(%a6)         # +-2**K * F, 1 <= F < 2
5935        mov.w           INARG(%a6),%d1
5936        mov.l           %d1,%a1                 # save a copy of D0
5937        and.l           &0x00007FFF,%d1
5938        sub.l           &0x00003FFF,%d1         # d0 = K
5939        cmp.l           %d1,&28
5940        ble.b           LASTLOOP
5941CONTLOOP:
5942        sub.l           &27,%d1                 # d0 = L := K-27
5943        mov.b           &0,ENDFLAG(%a6)
5944        bra.b           WORK
5945LASTLOOP:
5946        clr.l           %d1                     # d0 = L := 0
5947        mov.b           &1,ENDFLAG(%a6)
5948
5949WORK:
5950#--FIND THE REMAINDER OF (R,r) W.R.T.   2**L * (PI/2). L IS SO CHOSEN
5951#--THAT INT( X * (2/PI) / 2**(L) ) < 2**29.
5952
5953#--CREATE 2**(-L) * (2/PI), SIGN(INARG)*2**(63),
5954#--2**L * (PIby2_1), 2**L * (PIby2_2)
5955
5956        mov.l           &0x00003FFE,%d2         # BIASED EXP OF 2/PI
5957        sub.l           %d1,%d2                 # BIASED EXP OF 2**(-L)*(2/PI)
5958
5959        mov.l           &0xA2F9836E,FP_SCR0_HI(%a6)
5960        mov.l           &0x4E44152A,FP_SCR0_LO(%a6)
5961        mov.w           %d2,FP_SCR0_EX(%a6)     # FP_SCR0 = 2**(-L)*(2/PI)
5962
5963        fmov.x          %fp0,%fp2
5964        fmul.x          FP_SCR0(%a6),%fp2       # fp2 = X * 2**(-L)*(2/PI)
5965
5966#--WE MUST NOW FIND INT(FP2). SINCE WE NEED THIS VALUE IN
5967#--FLOATING POINT FORMAT, THE TWO FMOVE'S       FMOVE.L FP <--> N
5968#--WILL BE TOO INEFFICIENT. THE WAY AROUND IT IS THAT
5969#--(SIGN(INARG)*2**63   +       FP2) - SIGN(INARG)*2**63 WILL GIVE
5970#--US THE DESIRED VALUE IN FLOATING POINT.
5971        mov.l           %a1,%d2
5972        swap            %d2
5973        and.l           &0x80000000,%d2
5974        or.l            &0x5F000000,%d2         # d2 = SIGN(INARG)*2**63 IN SGL
5975        mov.l           %d2,TWOTO63(%a6)
5976        fadd.s          TWOTO63(%a6),%fp2       # THE FRACTIONAL PART OF FP1 IS ROUNDED
5977        fsub.s          TWOTO63(%a6),%fp2       # fp2 = N
5978#       fintrz.x        %fp2,%fp2
5979
5980#--CREATING 2**(L)*Piby2_1 and 2**(L)*Piby2_2
5981        mov.l           %d1,%d2                 # d2 = L
5982
5983        add.l           &0x00003FFF,%d2         # BIASED EXP OF 2**L * (PI/2)
5984        mov.w           %d2,FP_SCR0_EX(%a6)
5985        mov.l           &0xC90FDAA2,FP_SCR0_HI(%a6)
5986        clr.l           FP_SCR0_LO(%a6)         # FP_SCR0 = 2**(L) * Piby2_1
5987
5988        add.l           &0x00003FDD,%d1
5989        mov.w           %d1,FP_SCR1_EX(%a6)
5990        mov.l           &0x85A308D3,FP_SCR1_HI(%a6)
5991        clr.l           FP_SCR1_LO(%a6)         # FP_SCR1 = 2**(L) * Piby2_2
5992
5993        mov.b           ENDFLAG(%a6),%d1
5994
5995#--We are now ready to perform (R+r) - N*P1 - N*P2, P1 = 2**(L) * Piby2_1 and
5996#--P2 = 2**(L) * Piby2_2
5997        fmov.x          %fp2,%fp4               # fp4 = N
5998        fmul.x          FP_SCR0(%a6),%fp4       # fp4 = W = N*P1
5999        fmov.x          %fp2,%fp5               # fp5 = N
6000        fmul.x          FP_SCR1(%a6),%fp5       # fp5 = w = N*P2

6001        fmov.x          %fp4,%fp3               # fp3 = W = N*P1
6002
6003#--we want P+p = W+w  but  |p| <= half ulp of P
6004#--Then, we need to compute  A := R-P   and  a := r-p
6005        fadd.x          %fp5,%fp3               # fp3 = P
6006        fsub.x          %fp3,%fp4               # fp4 = W-P
6007
6008        fsub.x          %fp3,%fp0               # fp0 = A := R - P
6009        fadd.x          %fp5,%fp4               # fp4 = p = (W-P)+w
6010
6011        fmov.x          %fp0,%fp3               # fp3 = A
6012        fsub.x          %fp4,%fp1               # fp1 = a := r - p
6013
6014#--Now we need to normalize (A,a) to  "new (R,r)" where R+r = A+a but
6015#--|r| <= half ulp of R.
6016        fadd.x          %fp1,%fp0               # fp0 = R := A+a
6017#--No need to calculate r if this is the last loop
6018        cmp.b           %d1,&0
6019        bgt.w           RESTORE
6020
6021#--Need to calculate r
6022        fsub.x          %fp0,%fp3               # fp3 = A-R
6023        fadd.x          %fp3,%fp1               # fp1 = r := (A-R)+a
6024        bra.w           LOOP
6025
6026RESTORE:
6027        fmov.l          %fp2,INT(%a6)
6028        mov.l           (%sp)+,%d2              # restore d2
6029        fmovm.x         (%sp)+,&0x3c            # restore {fp2-fp5}
6030
6031        mov.l           INT(%a6),%d1
6032        ror.l           &1,%d1
6033
6034        bra.w           TANCONT
6035
6036#########################################################################
6037# satan():  computes the arctangent of a normalized number              #
6038# satand(): computes the arctangent of a denormalized number            #
6039#                                                                       #
6040# INPUT *************************************************************** #
6041#       a0 = pointer to extended precision input                        #
6042#       d0 = round precision,mode                                       #
6043#                                                                       #
6044# OUTPUT ************************************************************** #
6045#       fp0 = arctan(X)                                                 #
6046#                                                                       #
6047# ACCURACY and MONOTONICITY ******************************************* #
6048#       The returned result is within 2 ulps in 64 significant bit,     #
6049#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6050#       rounded to double precision. The result is provably monotonic   #
6051#       in double precision.                                            #
6052#                                                                       #
6053# ALGORITHM *********************************************************** #
6054#       Step 1. If |X| >= 16 or |X| < 1/16, go to Step 5.               #
6055#                                                                       #
6056#       Step 2. Let X = sgn * 2**k * 1.xxxxxxxx...x.                    #
6057#               Note that k = -4, -3,..., or 3.                         #
6058#               Define F = sgn * 2**k * 1.xxxx1, i.e. the first 5       #
6059#               significant bits of X with a bit-1 attached at the 6-th #
6060#               bit position. Define u to be u = (X-F) / (1 + X*F).     #
6061#                                                                       #
6062#       Step 3. Approximate arctan(u) by a polynomial poly.             #
6063#                                                                       #
6064#       Step 4. Return arctan(F) + poly, arctan(F) is fetched from a    #
6065#               table of values calculated beforehand. Exit.            #
6066#                                                                       #
6067#       Step 5. If |X| >= 16, go to Step 7.                             #
6068#                                                                       #
6069#       Step 6. Approximate arctan(X) by an odd polynomial in X. Exit.  #
6070#                                                                       #
6071#       Step 7. Define X' = -1/X. Approximate arctan(X') by an odd      #
6072#               polynomial in X'.                                       #
6073#               Arctan(X) = sign(X)*Pi/2 + arctan(X'). Exit.            #
6074#                                                                       #
6075#########################################################################
6076
6077ATANA3: long            0xBFF6687E,0x314987D8
6078ATANA2: long            0x4002AC69,0x34A26DB3
6079ATANA1: long            0xBFC2476F,0x4E1DA28E
6080
6081ATANB6: long            0x3FB34444,0x7F876989
6082ATANB5: long            0xBFB744EE,0x7FAF45DB
6083ATANB4: long            0x3FBC71C6,0x46940220
6084ATANB3: long            0xBFC24924,0x921872F9
6085ATANB2: long            0x3FC99999,0x99998FA9
6086ATANB1: long            0xBFD55555,0x55555555
6087
6088ATANC5: long            0xBFB70BF3,0x98539E6A
6089ATANC4: long            0x3FBC7187,0x962D1D7D
6090ATANC3: long            0xBFC24924,0x827107B8
6091ATANC2: long            0x3FC99999,0x9996263E
6092ATANC1: long            0xBFD55555,0x55555536
6093
6094PPIBY2: long            0x3FFF0000,0xC90FDAA2,0x2168C235,0x00000000
6095NPIBY2: long            0xBFFF0000,0xC90FDAA2,0x2168C235,0x00000000
6096
6097PTINY:  long            0x00010000,0x80000000,0x00000000,0x00000000
6098NTINY:  long            0x80010000,0x80000000,0x00000000,0x00000000
6099
6100ATANTBL:
6101        long            0x3FFB0000,0x83D152C5,0x060B7A51,0x00000000
6102        long            0x3FFB0000,0x8BC85445,0x65498B8B,0x00000000
6103        long            0x3FFB0000,0x93BE4060,0x17626B0D,0x00000000
6104        long            0x3FFB0000,0x9BB3078D,0x35AEC202,0x00000000
6105        long            0x3FFB0000,0xA3A69A52,0x5DDCE7DE,0x00000000
6106        long            0x3FFB0000,0xAB98E943,0x62765619,0x00000000
6107        long            0x3FFB0000,0xB389E502,0xF9C59862,0x00000000
6108        long            0x3FFB0000,0xBB797E43,0x6B09E6FB,0x00000000
6109        long            0x3FFB0000,0xC367A5C7,0x39E5F446,0x00000000
6110        long            0x3FFB0000,0xCB544C61,0xCFF7D5C6,0x00000000
6111        long            0x3FFB0000,0xD33F62F8,0x2488533E,0x00000000
6112        long            0x3FFB0000,0xDB28DA81,0x62404C77,0x00000000
6113        long            0x3FFB0000,0xE310A407,0x8AD34F18,0x00000000
6114        long            0x3FFB0000,0xEAF6B0A8,0x188EE1EB,0x00000000
6115        long            0x3FFB0000,0xF2DAF194,0x9DBE79D5,0x00000000
6116        long            0x3FFB0000,0xFABD5813,0x61D47E3E,0x00000000
6117        long            0x3FFC0000,0x8346AC21,0x0959ECC4,0x00000000
6118        long            0x3FFC0000,0x8B232A08,0x304282D8,0x00000000
6119        long            0x3FFC0000,0x92FB70B8,0xD29AE2F9,0x00000000
6120        long            0x3FFC0000,0x9ACF476F,0x5CCD1CB4,0x00000000
6121        long            0x3FFC0000,0xA29E7630,0x4954F23F,0x00000000
6122        long            0x3FFC0000,0xAA68C5D0,0x8AB85230,0x00000000
6123        long            0x3FFC0000,0xB22DFFFD,0x9D539F83,0x00000000
6124        long            0x3FFC0000,0xB9EDEF45,0x3E900EA5,0x00000000
6125        long            0x3FFC0000,0xC1A85F1C,0xC75E3EA5,0x00000000
6126        long            0x3FFC0000,0xC95D1BE8,0x28138DE6,0x00000000
6127        long            0x3FFC0000,0xD10BF300,0x840D2DE4,0x00000000
6128        long            0x3FFC0000,0xD8B4B2BA,0x6BC05E7A,0x00000000
6129        long            0x3FFC0000,0xE0572A6B,0xB42335F6,0x00000000
6130        long            0x3FFC0000,0xE7F32A70,0xEA9CAA8F,0x00000000
6131        long            0x3FFC0000,0xEF888432,0x64ECEFAA,0x00000000
6132        long            0x3FFC0000,0xF7170A28,0xECC06666,0x00000000
6133        long            0x3FFD0000,0x812FD288,0x332DAD32,0x00000000
6134        long            0x3FFD0000,0x88A8D1B1,0x218E4D64,0x00000000
6135        long            0x3FFD0000,0x9012AB3F,0x23E4AEE8,0x00000000
6136        long            0x3FFD0000,0x976CC3D4,0x11E7F1B9,0x00000000
6137        long            0x3FFD0000,0x9EB68949,0x3889A227,0x00000000
6138        long            0x3FFD0000,0xA5EF72C3,0x4487361B,0x00000000
6139        long            0x3FFD0000,0xAD1700BA,0xF07A7227,0x00000000
6140        long            0x3FFD0000,0xB42CBCFA,0xFD37EFB7,0x00000000
6141        long            0x3FFD0000,0xBB303A94,0x0BA80F89,0x00000000
6142        long            0x3FFD0000,0xC22115C6,0xFCAEBBAF,0x00000000
6143        long            0x3FFD0000,0xC8FEF3E6,0x86331221,0x00000000
6144        long            0x3FFD0000,0xCFC98330,0xB4000C70,0x00000000
6145        long            0x3FFD0000,0xD6807AA1,0x102C5BF9,0x00000000
6146        long            0x3FFD0000,0xDD2399BC,0x31252AA3,0x00000000
6147        long            0x3FFD0000,0xE3B2A855,0x6B8FC517,0x00000000
6148        long            0x3FFD0000,0xEA2D764F,0x64315989,0x00000000
6149        long            0x3FFD0000,0xF3BF5BF8,0xBAD1A21D,0x00000000
6150        long            0x3FFE0000,0x801CE39E,0x0D205C9A,0x00000000
6151        long            0x3FFE0000,0x8630A2DA,0xDA1ED066,0x00000000
6152        long            0x3FFE0000,0x8C1AD445,0xF3E09B8C,0x00000000
6153        long            0x3FFE0000,0x91DB8F16,0x64F350E2,0x00000000
6154        long            0x3FFE0000,0x97731420,0x365E538C,0x00000000
6155        long            0x3FFE0000,0x9CE1C8E6,0xA0B8CDBA,0x00000000
6156        long            0x3FFE0000,0xA22832DB,0xCADAAE09,0x00000000
6157        long            0x3FFE0000,0xA746F2DD,0xB7602294,0x00000000
6158        long            0x3FFE0000,0xAC3EC0FB,0x997DD6A2,0x00000000
6159        long            0x3FFE0000,0xB110688A,0xEBDC6F6A,0x00000000
6160        long            0x3FFE0000,0xB5BCC490,0x59ECC4B0,0x00000000
6161        long            0x3FFE0000,0xBA44BC7D,0xD470782F,0x00000000
6162        long            0x3FFE0000,0xBEA94144,0xFD049AAC,0x00000000
6163        long            0x3FFE0000,0xC2EB4ABB,0x661628B6,0x00000000
6164        long            0x3FFE0000,0xC70BD54C,0xE602EE14,0x00000000
6165        long            0x3FFE0000,0xCD000549,0xADEC7159,0x00000000
6166        long            0x3FFE0000,0xD48457D2,0xD8EA4EA3,0x00000000
6167        long            0x3FFE0000,0xDB948DA7,0x12DECE3B,0x00000000
6168        long            0x3FFE0000,0xE23855F9,0x69E8096A,0x00000000
6169        long            0x3FFE0000,0xE8771129,0xC4353259,0x00000000
6170        long            0x3FFE0000,0xEE57C16E,0x0D379C0D,0x00000000
6171        long            0x3FFE0000,0xF3E10211,0xA87C3779,0x00000000
6172        long            0x3FFE0000,0xF919039D,0x758B8D41,0x00000000
6173        long            0x3FFE0000,0xFE058B8F,0x64935FB3,0x00000000
6174        long            0x3FFF0000,0x8155FB49,0x7B685D04,0x00000000
6175        long            0x3FFF0000,0x83889E35,0x49D108E1,0x00000000
6176        long            0x3FFF0000,0x859CFA76,0x511D724B,0x00000000
6177        long            0x3FFF0000,0x87952ECF,0xFF8131E7,0x00000000
6178        long            0x3FFF0000,0x89732FD1,0x9557641B,0x00000000
6179        long            0x3FFF0000,0x8B38CAD1,0x01932A35,0x00000000
6180        long            0x3FFF0000,0x8CE7A8D8,0x301EE6B5,0x00000000
6181        long            0x3FFF0000,0x8F46A39E,0x2EAE5281,0x00000000
6182        long            0x3FFF0000,0x922DA7D7,0x91888487,0x00000000
6183        long            0x3FFF0000,0x94D19FCB,0xDEDF5241,0x00000000
6184        long            0x3FFF0000,0x973AB944,0x19D2A08B,0x00000000
6185        long            0x3FFF0000,0x996FF00E,0x08E10B96,0x00000000
6186        long            0x3FFF0000,0x9B773F95,0x12321DA7,0x00000000
6187        long            0x3FFF0000,0x9D55CC32,0x0F935624,0x00000000
6188        long            0x3FFF0000,0x9F100575,0x006CC571,0x00000000
6189        long            0x3FFF0000,0xA0A9C290,0xD97CC06C,0x00000000
6190        long            0x3FFF0000,0xA22659EB,0xEBC0630A,0x00000000
6191        long            0x3FFF0000,0xA388B4AF,0xF6EF0EC9,0x00000000
6192        long            0x3FFF0000,0xA4D35F10,0x61D292C4,0x00000000
6193        long            0x3FFF0000,0xA60895DC,0xFBE3187E,0x00000000
6194        long            0x3FFF0000,0xA72A51DC,0x7367BEAC,0x00000000
6195        long            0x3FFF0000,0xA83A5153,0x0956168F,0x00000000
6196        long            0x3FFF0000,0xA93A2007,0x7539546E,0x00000000
6197        long            0x3FFF0000,0xAA9E7245,0x023B2605,0x00000000
6198        long            0x3FFF0000,0xAC4C84BA,0x6FE4D58F,0x00000000
6199        long            0x3FFF0000,0xADCE4A4A,0x606B9712,0x00000000
6200        long            0x3FFF0000,0xAF2A2DCD,0x8D263C9C,0x00000000
6201        long            0x3FFF0000,0xB0656F81,0xF22265C7,0x00000000
6202        long            0x3FFF0000,0xB1846515,0x0F71496A,0x00000000
6203        long            0x3FFF0000,0xB28AAA15,0x6F9ADA35,0x00000000
6204        long            0x3FFF0000,0xB37B44FF,0x3766B895,0x00000000
6205        long            0x3FFF0000,0xB458C3DC,0xE9630433,0x00000000
6206        long            0x3FFF0000,0xB525529D,0x562246BD,0x00000000
6207        long            0x3FFF0000,0xB5E2CCA9,0x5F9D88CC,0x00000000
6208        long            0x3FFF0000,0xB692CADA,0x7ACA1ADA,0x00000000
6209        long            0x3FFF0000,0xB736AEA7,0xA6925838,0x00000000
6210        long            0x3FFF0000,0xB7CFAB28,0x7E9F7B36,0x00000000
6211        long            0x3FFF0000,0xB85ECC66,0xCB219835,0x00000000
6212        long            0x3FFF0000,0xB8E4FD5A,0x20A593DA,0x00000000
6213        long            0x3FFF0000,0xB99F41F6,0x4AFF9BB5,0x00000000
6214        long            0x3FFF0000,0xBA7F1E17,0x842BBE7B,0x00000000
6215        long            0x3FFF0000,0xBB471285,0x7637E17D,0x00000000
6216        long            0x3FFF0000,0xBBFABE8A,0x4788DF6F,0x00000000
6217        long            0x3FFF0000,0xBC9D0FAD,0x2B689D79,0x00000000
6218        long            0x3FFF0000,0xBD306A39,0x471ECD86,0x00000000
6219        long            0x3FFF0000,0xBDB6C731,0x856AF18A,0x00000000
6220        long            0x3FFF0000,0xBE31CAC5,0x02E80D70,0x00000000
6221        long            0x3FFF0000,0xBEA2D55C,0xE33194E2,0x00000000
6222        long            0x3FFF0000,0xBF0B10B7,0xC03128F0,0x00000000
6223        long            0x3FFF0000,0xBF6B7A18,0xDACB778D,0x00000000
6224        long            0x3FFF0000,0xBFC4EA46,0x63FA18F6,0x00000000
6225        long            0x3FFF0000,0xC0181BDE,0x8B89A454,0x00000000
6226        long            0x3FFF0000,0xC065B066,0xCFBF6439,0x00000000
6227        long            0x3FFF0000,0xC0AE345F,0x56340AE6,0x00000000
6228        long            0x3FFF0000,0xC0F22291,0x9CB9E6A7,0x00000000
6229
6230        set             X,FP_SCR0
6231        set             XDCARE,X+2
6232        set             XFRAC,X+4
6233        set             XFRACLO,X+8
6234
6235        set             ATANF,FP_SCR1
6236        set             ATANFHI,ATANF+4
6237        set             ATANFLO,ATANF+8
6238
6239        global          satan
6240#--ENTRY POINT FOR ATAN(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
6241satan:
6242        fmov.x          (%a0),%fp0              # LOAD INPUT
6243
6244        mov.l           (%a0),%d1
6245        mov.w           4(%a0),%d1
6246        fmov.x          %fp0,X(%a6)
6247        and.l           &0x7FFFFFFF,%d1
6248
6249        cmp.l           %d1,&0x3FFB8000         # |X| >= 1/16?
6250        bge.b           ATANOK1
6251        bra.w           ATANSM
6252
6253ATANOK1:
6254        cmp.l           %d1,&0x4002FFFF         # |X| < 16 ?
6255        ble.b           ATANMAIN
6256        bra.w           ATANBIG
6257
6258#--THE MOST LIKELY CASE, |X| IN [1/16, 16). WE USE TABLE TECHNIQUE
6259#--THE IDEA IS ATAN(X) = ATAN(F) + ATAN( [X-F] / [1+XF] ).
6260#--SO IF F IS CHOSEN TO BE CLOSE TO X AND ATAN(F) IS STORED IN
6261#--A TABLE, ALL WE NEED IS TO APPROXIMATE ATAN(U) WHERE
6262#--U = (X-F)/(1+XF) IS SMALL (REMEMBER F IS CLOSE TO X). IT IS
6263#--TRUE THAT A DIVIDE IS NOW NEEDED, BUT THE APPROXIMATION FOR
6264#--ATAN(U) IS A VERY SHORT POLYNOMIAL AND THE INDEXING TO
6265#--FETCH F AND SAVING OF REGISTERS CAN BE ALL HIDED UNDER THE
6266#--DIVIDE. IN THE END THIS METHOD IS MUCH FASTER THAN A TRADITIONAL
6267#--ONE. NOTE ALSO THAT THE TRADITIONAL SCHEME THAT APPROXIMATE
6268#--ATAN(X) DIRECTLY WILL NEED TO USE A RATIONAL APPROXIMATION
6269#--(DIVISION NEEDED) ANYWAY BECAUSE A POLYNOMIAL APPROXIMATION
6270#--WILL INVOLVE A VERY LONG POLYNOMIAL.
6271
6272#--NOW WE SEE X AS +-2^K * 1.BBBBBBB....B <- 1. + 63 BITS
6273#--WE CHOSE F TO BE +-2^K * 1.BBBB1
6274#--THAT IS IT MATCHES THE EXPONENT AND FIRST 5 BITS OF X, THE
6275#--SIXTH BITS IS SET TO BE 1. SINCE K = -4, -3, ..., 3, THERE
6276#--ARE ONLY 8 TIMES 16 = 2^7 = 128 |F|'S. SINCE ATAN(-|F|) IS
6277#-- -ATAN(|F|), WE NEED TO STORE ONLY ATAN(|F|).
6278
6279ATANMAIN:
6280
6281        and.l           &0xF8000000,XFRAC(%a6)  # FIRST 5 BITS
6282        or.l            &0x04000000,XFRAC(%a6)  # SET 6-TH BIT TO 1
6283        mov.l           &0x00000000,XFRACLO(%a6) # LOCATION OF X IS NOW F
6284
6285        fmov.x          %fp0,%fp1               # FP1 IS X
6286        fmul.x          X(%a6),%fp1             # FP1 IS X*F, NOTE THAT X*F > 0
6287        fsub.x          X(%a6),%fp0             # FP0 IS X-F
6288        fadd.s          &0x3F800000,%fp1        # FP1 IS 1 + X*F
6289        fdiv.x          %fp1,%fp0               # FP0 IS U = (X-F)/(1+X*F)
6290
6291#--WHILE THE DIVISION IS TAKING ITS TIME, WE FETCH ATAN(|F|)
6292#--CREATE ATAN(F) AND STORE IT IN ATANF, AND
6293#--SAVE REGISTERS FP2.
6294
6295        mov.l           %d2,-(%sp)              # SAVE d2 TEMPORARILY
6296        mov.l           %d1,%d2                 # THE EXP AND 16 BITS OF X
6297        and.l           &0x00007800,%d1         # 4 VARYING BITS OF F'S FRACTION
6298        and.l           &0x7FFF0000,%d2         # EXPONENT OF F
6299        sub.l           &0x3FFB0000,%d2         # K+4
6300        asr.l           &1,%d2
6301        add.l           %d2,%d1                 # THE 7 BITS IDENTIFYING F
6302        asr.l           &7,%d1                  # INDEX INTO TBL OF ATAN(|F|)
6303        lea             ATANTBL(%pc),%a1
6304        add.l           %d1,%a1                 # ADDRESS OF ATAN(|F|)
6305        mov.l           (%a1)+,ATANF(%a6)
6306        mov.l           (%a1)+,ATANFHI(%a6)
6307        mov.l           (%a1)+,ATANFLO(%a6)     # ATANF IS NOW ATAN(|F|)
6308        mov.l           X(%a6),%d1              # LOAD SIGN AND EXPO. AGAIN
6309        and.l           &0x80000000,%d1         # SIGN(F)
6310        or.l            %d1,ATANF(%a6)          # ATANF IS NOW SIGN(F)*ATAN(|F|)
6311        mov.l           (%sp)+,%d2              # RESTORE d2
6312
6313#--THAT'S ALL I HAVE TO DO FOR NOW,
6314#--BUT ALAS, THE DIVIDE IS STILL CRANKING!
6315
6316#--U IN FP0, WE ARE NOW READY TO COMPUTE ATAN(U) AS
6317#--U + A1*U*V*(A2 + V*(A3 + V)), V = U*U
6318#--THE POLYNOMIAL MAY LOOK STRANGE, BUT IS NEVERTHELESS CORRECT.
6319#--THE NATURAL FORM IS U + U*V*(A1 + V*(A2 + V*A3))
6320#--WHAT WE HAVE HERE IS MERELY  A1 = A3, A2 = A1/A3, A3 = A2/A3.
6321#--THE REASON FOR THIS REARRANGEMENT IS TO MAKE THE INDEPENDENT
6322#--PARTS A1*U*V AND (A2 + ... STUFF) MORE LOAD-BALANCED
6323
6324        fmovm.x         &0x04,-(%sp)            # save fp2
6325
6326        fmov.x          %fp0,%fp1
6327        fmul.x          %fp1,%fp1
6328        fmov.d          ATANA3(%pc),%fp2
6329        fadd.x          %fp1,%fp2               # A3+V
6330        fmul.x          %fp1,%fp2               # V*(A3+V)
6331        fmul.x          %fp0,%fp1               # U*V
6332        fadd.d          ATANA2(%pc),%fp2        # A2+V*(A3+V)
6333        fmul.d          ATANA1(%pc),%fp1        # A1*U*V
6334        fmul.x          %fp2,%fp1               # A1*U*V*(A2+V*(A3+V))
6335        fadd.x          %fp1,%fp0               # ATAN(U), FP1 RELEASED
6336
6337        fmovm.x         (%sp)+,&0x20            # restore fp2
6338
6339        fmov.l          %d0,%fpcr               # restore users rnd mode,prec
6340        fadd.x          ATANF(%a6),%fp0         # ATAN(X)
6341        bra             t_inx2
6342
6343ATANBORS:
6344#--|X| IS IN d0 IN COMPACT FORM. FP1, d0 SAVED.
6345#--FP0 IS X AND |X| <= 1/16 OR |X| >= 16.
6346        cmp.l           %d1,&0x3FFF8000
6347        bgt.w           ATANBIG                 # I.E. |X| >= 16
6348
6349ATANSM:
6350#--|X| <= 1/16
6351#--IF |X| < 2^(-40), RETURN X AS ANSWER. OTHERWISE, APPROXIMATE
6352#--ATAN(X) BY X + X*Y*(B1+Y*(B2+Y*(B3+Y*(B4+Y*(B5+Y*B6)))))
6353#--WHICH IS X + X*Y*( [B1+Z*(B3+Z*B5)] + [Y*(B2+Z*(B4+Z*B6)] )
6354#--WHERE Y = X*X, AND Z = Y*Y.
6355
6356        cmp.l           %d1,&0x3FD78000
6357        blt.w           ATANTINY
6358
6359#--COMPUTE POLYNOMIAL
6360        fmovm.x         &0x0c,-(%sp)            # save fp2/fp3
6361
6362        fmul.x          %fp0,%fp0               # FPO IS Y = X*X
6363
6364        fmov.x          %fp0,%fp1
6365        fmul.x          %fp1,%fp1               # FP1 IS Z = Y*Y
6366
6367        fmov.d          ATANB6(%pc),%fp2
6368        fmov.d          ATANB5(%pc),%fp3
6369
6370        fmul.x          %fp1,%fp2               # Z*B6
6371        fmul.x          %fp1,%fp3               # Z*B5
6372
6373        fadd.d          ATANB4(%pc),%fp2        # B4+Z*B6
6374        fadd.d          ATANB3(%pc),%fp3        # B3+Z*B5
6375
6376        fmul.x          %fp1,%fp2               # Z*(B4+Z*B6)
6377        fmul.x          %fp3,%fp1               # Z*(B3+Z*B5)
6378
6379        fadd.d          ATANB2(%pc),%fp2        # B2+Z*(B4+Z*B6)
6380        fadd.d          ATANB1(%pc),%fp1        # B1+Z*(B3+Z*B5)
6381
6382        fmul.x          %fp0,%fp2               # Y*(B2+Z*(B4+Z*B6))
6383        fmul.x          X(%a6),%fp0             # X*Y
6384
6385        fadd.x          %fp2,%fp1               # [B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))]
6386
6387        fmul.x          %fp1,%fp0               # X*Y*([B1+Z*(B3+Z*B5)]+[Y*(B2+Z*(B4+Z*B6))])
6388
6389        fmovm.x         (%sp)+,&0x30            # restore fp2/fp3
6390
6391        fmov.l          %d0,%fpcr               # restore users rnd mode,prec
6392        fadd.x          X(%a6),%fp0
6393        bra             t_inx2
6394
6395ATANTINY:
6396#--|X| < 2^(-40), ATAN(X) = X
6397
6398        fmov.l          %d0,%fpcr               # restore users rnd mode,prec
6399        mov.b           &FMOV_OP,%d1            # last inst is MOVE
6400        fmov.x          X(%a6),%fp0             # last inst - possible exception set
6401
6402        bra             t_catch
6403
6404ATANBIG:
6405#--IF |X| > 2^(100), RETURN     SIGN(X)*(PI/2 - TINY). OTHERWISE,
6406#--RETURN SIGN(X)*PI/2 + ATAN(-1/X).
6407        cmp.l           %d1,&0x40638000
6408        bgt.w           ATANHUGE
6409
6410#--APPROXIMATE ATAN(-1/X) BY
6411#--X'+X'*Y*(C1+Y*(C2+Y*(C3+Y*(C4+Y*C5)))), X' = -1/X, Y = X'*X'
6412#--THIS CAN BE RE-WRITTEN AS
6413#--X'+X'*Y*( [C1+Z*(C3+Z*C5)] + [Y*(C2+Z*C4)] ), Z = Y*Y.
6414
6415        fmovm.x         &0x0c,-(%sp)            # save fp2/fp3
6416
6417        fmov.s          &0xBF800000,%fp1        # LOAD -1
6418        fdiv.x          %fp0,%fp1               # FP1 IS -1/X
6419
6420#--DIVIDE IS STILL CRANKING
6421
6422        fmov.x          %fp1,%fp0               # FP0 IS X'
6423        fmul.x          %fp0,%fp0               # FP0 IS Y = X'*X'
6424        fmov.x          %fp1,X(%a6)             # X IS REALLY X'
6425
6426        fmov.x          %fp0,%fp1
6427        fmul.x          %fp1,%fp1               # FP1 IS Z = Y*Y
6428
6429        fmov.d          ATANC5(%pc),%fp3
6430        fmov.d          ATANC4(%pc),%fp2
6431
6432        fmul.x          %fp1,%fp3               # Z*C5
6433        fmul.x          %fp1,%fp2               # Z*B4
6434
6435        fadd.d          ATANC3(%pc),%fp3        # C3+Z*C5
6436        fadd.d          ATANC2(%pc),%fp2        # C2+Z*C4
6437
6438        fmul.x          %fp3,%fp1               # Z*(C3+Z*C5), FP3 RELEASED
6439        fmul.x          %fp0,%fp2               # Y*(C2+Z*C4)
6440
6441        fadd.d          ATANC1(%pc),%fp1        # C1+Z*(C3+Z*C5)
6442        fmul.x          X(%a6),%fp0             # X'*Y
6443
6444        fadd.x          %fp2,%fp1               # [Y*(C2+Z*C4)]+[C1+Z*(C3+Z*C5)]
6445
6446        fmul.x          %fp1,%fp0               # X'*Y*([B1+Z*(B3+Z*B5)]
6447#                                       ...     +[Y*(B2+Z*(B4+Z*B6))])
6448        fadd.x          X(%a6),%fp0
6449
6450        fmovm.x         (%sp)+,&0x30            # restore fp2/fp3
6451
6452        fmov.l          %d0,%fpcr               # restore users rnd mode,prec
6453        tst.b           (%a0)
6454        bpl.b           pos_big
6455
6456neg_big:
6457        fadd.x          NPIBY2(%pc),%fp0
6458        bra             t_minx2
6459
6460pos_big:
6461        fadd.x          PPIBY2(%pc),%fp0
6462        bra             t_pinx2
6463
6464ATANHUGE:
6465#--RETURN SIGN(X)*(PIBY2 - TINY) = SIGN(X)*PIBY2 - SIGN(X)*TINY
6466        tst.b           (%a0)
6467        bpl.b           pos_huge
6468
6469neg_huge:
6470        fmov.x          NPIBY2(%pc),%fp0
6471        fmov.l          %d0,%fpcr
6472        fadd.x          PTINY(%pc),%fp0
6473        bra             t_minx2
6474
6475pos_huge:
6476        fmov.x          PPIBY2(%pc),%fp0
6477        fmov.l          %d0,%fpcr
6478        fadd.x          NTINY(%pc),%fp0
6479        bra             t_pinx2
6480
6481        global          satand
6482#--ENTRY POINT FOR ATAN(X) FOR DENORMALIZED ARGUMENT
6483satand:
6484        bra             t_extdnrm
6485
6486#########################################################################
6487# sasin():  computes the inverse sine of a normalized input             #
6488# sasind(): computes the inverse sine of a denormalized input           #
6489#                                                                       #
6490# INPUT *************************************************************** #
6491#       a0 = pointer to extended precision input                        #
6492#       d0 = round precision,mode                                       #
6493#                                                                       #
6494# OUTPUT ************************************************************** #
6495#       fp0 = arcsin(X)                                                 #
6496#                                                                       #
6497# ACCURACY and MONOTONICITY ******************************************* #
6498#       The returned result is within 3 ulps in 64 significant bit,     #
6499#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6500#       rounded to double precision. The result is provably monotonic   #
6501#       in double precision.                                            #
6502#                                                                       #
6503# ALGORITHM *********************************************************** #
6504#                                                                       #
6505#       ASIN                                                            #
6506#       1. If |X| >= 1, go to 3.                                        #
6507#                                                                       #
6508#       2. (|X| < 1) Calculate asin(X) by                               #
6509#               z := sqrt( [1-X][1+X] )                                 #
6510#               asin(X) = atan( x / z ).                                #
6511#               Exit.                                                   #
6512#                                                                       #
6513#       3. If |X| > 1, go to 5.                                         #
6514#                                                                       #
6515#       4. (|X| = 1) sgn := sign(X), return asin(X) := sgn * Pi/2. Exit.#
6516#                                                                       #
6517#       5. (|X| > 1) Generate an invalid operation by 0 * infinity.     #
6518#               Exit.                                                   #
6519#                                                                       #
6520#########################################################################
6521
6522        global          sasin
6523sasin:
6524        fmov.x          (%a0),%fp0              # LOAD INPUT
6525
6526        mov.l           (%a0),%d1
6527        mov.w           4(%a0),%d1
6528        and.l           &0x7FFFFFFF,%d1
6529        cmp.l           %d1,&0x3FFF8000
6530        bge.b           ASINBIG
6531
6532# This catch is added here for the '060 QSP. Originally, the call to
6533# satan() would handle this case by causing the exception which would
6534# not be caught until gen_except(). Now, with the exceptions being
6535# detected inside of satan(), the exception would have been handled there
6536# instead of inside sasin() as expected.
6537        cmp.l           %d1,&0x3FD78000
6538        blt.w           ASINTINY
6539
6540#--THIS IS THE USUAL CASE, |X| < 1
6541#--ASIN(X) = ATAN( X / SQRT( (1-X)(1+X) ) )
6542
6543ASINMAIN:
6544        fmov.s          &0x3F800000,%fp1
6545        fsub.x          %fp0,%fp1               # 1-X
6546        fmovm.x         &0x4,-(%sp)             #  {fp2}
6547        fmov.s          &0x3F800000,%fp2
6548        fadd.x          %fp0,%fp2               # 1+X
6549        fmul.x          %fp2,%fp1               # (1+X)(1-X)
6550        fmovm.x         (%sp)+,&0x20            #  {fp2}
6551        fsqrt.x         %fp1                    # SQRT([1-X][1+X])
6552        fdiv.x          %fp1,%fp0               # X/SQRT([1-X][1+X])
6553        fmovm.x         &0x01,-(%sp)            # save X/SQRT(...)
6554        lea             (%sp),%a0               # pass ptr to X/SQRT(...)
6555        bsr             satan
6556        add.l           &0xc,%sp                # clear X/SQRT(...) from stack
6557        bra             t_inx2
6558
6559ASINBIG:
6560        fabs.x          %fp0                    # |X|
6561        fcmp.s          %fp0,&0x3F800000
6562        fbgt            t_operr                 # cause an operr exception
6563
6564#--|X| = 1, ASIN(X) = +- PI/2.
6565ASINONE:
6566        fmov.x          PIBY2(%pc),%fp0
6567        mov.l           (%a0),%d1
6568        and.l           &0x80000000,%d1         # SIGN BIT OF X
6569        or.l            &0x3F800000,%d1         # +-1 IN SGL FORMAT
6570        mov.l           %d1,-(%sp)              # push SIGN(X) IN SGL-FMT
6571        fmov.l          %d0,%fpcr
6572        fmul.s          (%sp)+,%fp0
6573        bra             t_inx2
6574
6575#--|X| < 2^(-40), ATAN(X) = X
6576ASINTINY:
6577        fmov.l          %d0,%fpcr               # restore users rnd mode,prec
6578        mov.b           &FMOV_OP,%d1            # last inst is MOVE
6579        fmov.x          (%a0),%fp0              # last inst - possible exception
6580        bra             t_catch
6581
6582        global          sasind
6583#--ASIN(X) = X FOR DENORMALIZED X
6584sasind:
6585        bra             t_extdnrm
6586
6587#########################################################################
6588# sacos():  computes the inverse cosine of a normalized input           #
6589# sacosd(): computes the inverse cosine of a denormalized input         #
6590#                                                                       #
6591# INPUT *************************************************************** #
6592#       a0 = pointer to extended precision input                        #
6593#       d0 = round precision,mode                                       #
6594#                                                                       #
6595# OUTPUT ************************************************************** #
6596#       fp0 = arccos(X)                                                 #
6597#                                                                       #
6598# ACCURACY and MONOTONICITY ******************************************* #
6599#       The returned result is within 3 ulps in 64 significant bit,     #
6600#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6601#       rounded to double precision. The result is provably monotonic   #
6602#       in double precision.                                            #
6603#                                                                       #
6604# ALGORITHM *********************************************************** #
6605#                                                                       #
6606#       ACOS                                                            #
6607#       1. If |X| >= 1, go to 3.                                        #
6608#                                                                       #
6609#       2. (|X| < 1) Calculate acos(X) by                               #
6610#               z := (1-X) / (1+X)                                      #
6611#               acos(X) = 2 * atan( sqrt(z) ).                          #
6612#               Exit.                                                   #
6613#                                                                       #
6614#       3. If |X| > 1, go to 5.                                         #
6615#                                                                       #
6616#       4. (|X| = 1) If X > 0, return 0. Otherwise, return Pi. Exit.    #
6617#                                                                       #
6618#       5. (|X| > 1) Generate an invalid operation by 0 * infinity.     #
6619#               Exit.                                                   #
6620#                                                                       #
6621#########################################################################
6622
6623        global          sacos
6624sacos:
6625        fmov.x          (%a0),%fp0              # LOAD INPUT
6626
6627        mov.l           (%a0),%d1               # pack exp w/ upper 16 fraction
6628        mov.w           4(%a0),%d1
6629        and.l           &0x7FFFFFFF,%d1
6630        cmp.l           %d1,&0x3FFF8000
6631        bge.b           ACOSBIG
6632
6633#--THIS IS THE USUAL CASE, |X| < 1
6634#--ACOS(X) = 2 * ATAN(  SQRT( (1-X)/(1+X) ) )
6635
6636ACOSMAIN:
6637        fmov.s          &0x3F800000,%fp1
6638        fadd.x          %fp0,%fp1               # 1+X
6639        fneg.x          %fp0                    # -X
6640        fadd.s          &0x3F800000,%fp0        # 1-X
6641        fdiv.x          %fp1,%fp0               # (1-X)/(1+X)
6642        fsqrt.x         %fp0                    # SQRT((1-X)/(1+X))
6643        mov.l           %d0,-(%sp)              # save original users fpcr
6644        clr.l           %d0
6645        fmovm.x         &0x01,-(%sp)            # save SQRT(...) to stack
6646        lea             (%sp),%a0               # pass ptr to sqrt
6647        bsr             satan                   # ATAN(SQRT([1-X]/[1+X]))
6648        add.l           &0xc,%sp                # clear SQRT(...) from stack
6649
6650        fmov.l          (%sp)+,%fpcr            # restore users round prec,mode
6651        fadd.x          %fp0,%fp0               # 2 * ATAN( STUFF )
6652        bra             t_pinx2
6653
6654ACOSBIG:
6655        fabs.x          %fp0
6656        fcmp.s          %fp0,&0x3F800000
6657        fbgt            t_operr                 # cause an operr exception
6658
6659#--|X| = 1, ACOS(X) = 0 OR PI
6660        tst.b           (%a0)                   # is X positive or negative?
6661        bpl.b           ACOSP1
6662
6663#--X = -1
6664#Returns PI and inexact exception
6665ACOSM1:
6666        fmov.x          PI(%pc),%fp0            # load PI
6667        fmov.l          %d0,%fpcr               # load round mode,prec
6668        fadd.s          &0x00800000,%fp0        # add a small value
6669        bra             t_pinx2
6670
6671ACOSP1:
6672        bra             ld_pzero                # answer is positive zero
6673
6674        global          sacosd
6675#--ACOS(X) = PI/2 FOR DENORMALIZED X
6676sacosd:
6677        fmov.l          %d0,%fpcr               # load user's rnd mode/prec
6678        fmov.x          PIBY2(%pc),%fp0
6679        bra             t_pinx2
6680
6681#########################################################################
6682# setox():    computes the exponential for a normalized input           #
6683# setoxd():   computes the exponential for a denormalized input         #
6684# setoxm1():  computes the exponential minus 1 for a normalized input   #
6685# setoxm1d(): computes the exponential minus 1 for a denormalized input #
6686#                                                                       #
6687# INPUT *************************************************************** #
6688#       a0 = pointer to extended precision input                        #
6689#       d0 = round precision,mode                                       #
6690#                                                                       #
6691# OUTPUT ************************************************************** #
6692#       fp0 = exp(X) or exp(X)-1                                        #
6693#                                                                       #
6694# ACCURACY and MONOTONICITY ******************************************* #
6695#       The returned result is within 0.85 ulps in 64 significant bit,  #
6696#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
6697#       rounded to double precision. The result is provably monotonic   #
6698#       in double precision.                                            #
6699#                                                                       #
6700# ALGORITHM and IMPLEMENTATION **************************************** #
6701#                                                                       #
6702#       setoxd                                                          #
6703#       ------                                                          #
6704#       Step 1. Set ans := 1.0                                          #
6705#                                                                       #
6706#       Step 2. Return  ans := ans + sign(X)*2^(-126). Exit.            #
6707#       Notes:  This will always generate one exception -- inexact.     #
6708#                                                                       #
6709#                                                                       #
6710#       setox                                                           #
6711#       -----                                                           #
6712#                                                                       #
6713#       Step 1. Filter out extreme cases of input argument.             #
6714#               1.1     If |X| >= 2^(-65), go to Step 1.3.              #
6715#               1.2     Go to Step 7.                                   #
6716#               1.3     If |X| < 16380 log(2), go to Step 2.            #
6717#               1.4     Go to Step 8.                                   #
6718#       Notes:  The usual case should take the branches 1.1 -> 1.3 -> 2.#
6719#               To avoid the use of floating-point comparisons, a       #
6720#               compact representation of |X| is used. This format is a #
6721#               32-bit integer, the upper (more significant) 16 bits    #
6722#               are the sign and biased exponent field of |X|; the      #
6723#               lower 16 bits are the 16 most significant fraction      #
6724#               (including the explicit bit) bits of |X|. Consequently, #
6725#               the comparisons in Steps 1.1 and 1.3 can be performed   #
6726#               by integer comparison. Note also that the constant      #
6727#               16380 log(2) used in Step 1.3 is also in the compact    #
6728#               form. Thus taking the branch to Step 2 guarantees       #
6729#               |X| < 16380 log(2). There is no harm to have a small    #
6730#               number of cases where |X| is less than, but close to,   #
6731#               16380 log(2) and the branch to Step 9 is taken.         #
6732#                                                                       #
6733#       Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ).      #
6734#               2.1     Set AdjFlag := 0 (indicates the branch 1.3 -> 2 #
6735#                       was taken)                                      #
6736#               2.2     N := round-to-nearest-integer( X * 64/log2 ).   #
6737#               2.3     Calculate       J = N mod 64; so J = 0,1,2,..., #
6738#                       or 63.                                          #
6739#               2.4     Calculate       M = (N - J)/64; so N = 64M + J. #
6740#               2.5     Calculate the address of the stored value of    #
6741#                       2^(J/64).                                       #
6742#               2.6     Create the value Scale = 2^M.                   #
6743#       Notes:  The calculation in 2.2 is really performed by           #
6744#                       Z := X * constant                               #
6745#                       N := round-to-nearest-integer(Z)                #
6746#               where                                                   #
6747#                       constant := single-precision( 64/log 2 ).       #
6748#                                                                       #
6749#               Using a single-precision constant avoids memory         #
6750#               access. Another effect of using a single-precision      #
6751#               "constant" is that the calculated value Z is            #
6752#                                                                       #
6753#                       Z = X*(64/log2)*(1+eps), |eps| <= 2^(-24).      #
6754#                                                                       #
6755#               This error has to be considered later in Steps 3 and 4. #
6756#                                                                       #
6757#       Step 3. Calculate X - N*log2/64.                                #
6758#               3.1     R := X + N*L1,                                  #
6759#                               where L1 := single-precision(-log2/64). #
6760#               3.2     R := R + N*L2,                                  #
6761#                               L2 := extended-precision(-log2/64 - L1).#
6762#       Notes:  a) The way L1 and L2 are chosen ensures L1+L2           #
6763#               approximate the value -log2/64 to 88 bits of accuracy.  #
6764#               b) N*L1 is exact because N is no longer than 22 bits    #
6765#               and L1 is no longer than 24 bits.                       #
6766#               c) The calculation X+N*L1 is also exact due to          #
6767#               cancellation. Thus, R is practically X+N(L1+L2) to full #
6768#               64 bits.                                                #
6769#               d) It is important to estimate how large can |R| be     #
6770#               after Step 3.2.                                         #
6771#                                                                       #
6772#               N = rnd-to-int( X*64/log2 (1+eps) ), |eps|<=2^(-24)     #
6773#               X*64/log2 (1+eps)       =       N + f,  |f| <= 0.5      #
6774#               X*64/log2 - N   =       f - eps*X 64/log2               #
6775#               X - N*log2/64   =       f*log2/64 - eps*X               #
6776#                                                                       #
6777#                                                                       #
6778#               Now |X| <= 16446 log2, thus                             #
6779#                                                                       #
6780#                       |X - N*log2/64| <= (0.5 + 16446/2^(18))*log2/64 #
6781#                                       <= 0.57 log2/64.                #
6782#                This bound will be used in Step 4.                     #
6783#                                                                       #
6784#       Step 4. Approximate exp(R)-1 by a polynomial                    #
6785#               p = R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))      #
6786#       Notes:  a) In order to reduce memory access, the coefficients   #
6787#               are made as "short" as possible: A1 (which is 1/2), A4  #
6788#               and A5 are single precision; A2 and A3 are double       #
6789#               precision.                                              #
6790#               b) Even with the restrictions above,                    #
6791#                  |p - (exp(R)-1)| < 2^(-68.8) for all |R| <= 0.0062.  #
6792#               Note that 0.0062 is slightly bigger than 0.57 log2/64.  #
6793#               c) To fully utilize the pipeline, p is separated into   #
6794#               two independent pieces of roughly equal complexities    #
6795#                       p = [ R + R*S*(A2 + S*A4) ]     +               #
6796#                               [ S*(A1 + S*(A3 + S*A5)) ]              #
6797#               where S = R*R.                                          #
6798#                                                                       #
6799#       Step 5. Compute 2^(J/64)*exp(R) = 2^(J/64)*(1+p) by             #
6800#                               ans := T + ( T*p + t)                   #
6801#               where T and t are the stored values for 2^(J/64).       #
6802#       Notes:  2^(J/64) is stored as T and t where T+t approximates    #
6803#               2^(J/64) to roughly 85 bits; T is in extended precision #
6804#               and t is in single precision. Note also that T is       #
6805#               rounded to 62 bits so that the last two bits of T are   #
6806#               zero. The reason for such a special form is that T-1,   #
6807#               T-2, and T-8 will all be exact --- a property that will #
6808#               give much more accurate computation of the function     #
6809#               EXPM1.                                                  #
6810#                                                                       #
6811#       Step 6. Reconstruction of exp(X)                                #
6812#                       exp(X) = 2^M * 2^(J/64) * exp(R).               #
6813#               6.1     If AdjFlag = 0, go to 6.3                       #
6814#               6.2     ans := ans * AdjScale                           #
6815#               6.3     Restore the user FPCR                           #
6816#               6.4     Return ans := ans * Scale. Exit.                #
6817#       Notes:  If AdjFlag = 0, we have X = Mlog2 + Jlog2/64 + R,       #
6818#               |M| <= 16380, and Scale = 2^M. Moreover, exp(X) will    #
6819#               neither overflow nor underflow. If AdjFlag = 1, that    #
6820#               means that                                              #
6821#                       X = (M1+M)log2 + Jlog2/64 + R, |M1+M| >= 16380. #
6822#               Hence, exp(X) may overflow or underflow or neither.     #
6823#               When that is the case, AdjScale = 2^(M1) where M1 is    #
6824#               approximately M. Thus 6.2 will never cause              #
6825#               over/underflow. Possible exception in 6.4 is overflow   #
6826#               or underflow. The inexact exception is not generated in #
6827#               6.4. Although one can argue that the inexact flag       #
6828#               should always be raised, to simulate that exception     #
6829#               cost to much than the flag is worth in practical uses.  #
6830#                                                                       #
6831#       Step 7. Return 1 + X.                                           #
6832#               7.1     ans := X                                        #
6833#               7.2     Restore user FPCR.                              #
6834#               7.3     Return ans := 1 + ans. Exit                     #
6835#       Notes:  For non-zero X, the inexact exception will always be    #
6836#               raised by 7.3. That is the only exception raised by 7.3.#
6837#               Note also that we use the FMOVEM instruction to move X  #
6838#               in Step 7.1 to avoid unnecessary trapping. (Although    #
6839#               the FMOVEM may not seem relevant since X is normalized, #
6840#               the precaution will be useful in the library version of #
6841#               this code where the separate entry for denormalized     #
6842#               inputs will be done away with.)                         #
6843#                                                                       #
6844#       Step 8. Handle exp(X) where |X| >= 16380log2.                   #
6845#               8.1     If |X| > 16480 log2, go to Step 9.              #
6846#               (mimic 2.2 - 2.6)                                       #
6847#               8.2     N := round-to-integer( X * 64/log2 )            #
6848#               8.3     Calculate J = N mod 64, J = 0,1,...,63          #
6849#               8.4     K := (N-J)/64, M1 := truncate(K/2), M = K-M1,   #
6850#                       AdjFlag := 1.                                   #
6851#               8.5     Calculate the address of the stored value       #
6852#                       2^(J/64).                                       #
6853#               8.6     Create the values Scale = 2^M, AdjScale = 2^M1. #
6854#               8.7     Go to Step 3.                                   #
6855#       Notes:  Refer to notes for 2.2 - 2.6.                           #
6856#                                                                       #
6857#       Step 9. Handle exp(X), |X| > 16480 log2.                        #
6858#               9.1     If X < 0, go to 9.3                             #
6859#               9.2     ans := Huge, go to 9.4                          #
6860#               9.3     ans := Tiny.                                    #
6861#               9.4     Restore user FPCR.                              #
6862#               9.5     Return ans := ans * ans. Exit.                  #
6863#       Notes:  Exp(X) will surely overflow or underflow, depending on  #
6864#               X's sign. "Huge" and "Tiny" are respectively large/tiny #
6865#               extended-precision numbers whose square over/underflow  #
6866#               with an inexact result. Thus, 9.5 always raises the     #
6867#               inexact together with either overflow or underflow.     #
6868#                                                                       #
6869#       setoxm1d                                                        #
6870#       --------                                                        #
6871#                                                                       #
6872#       Step 1. Set ans := 0                                            #
6873#                                                                       #
6874#       Step 2. Return  ans := X + ans. Exit.                           #
6875#       Notes:  This will return X with the appropriate rounding        #
6876#                precision prescribed by the user FPCR.                 #
6877#                                                                       #
6878#       setoxm1                                                         #
6879#       -------                                                         #
6880#                                                                       #
6881#       Step 1. Check |X|                                               #
6882#               1.1     If |X| >= 1/4, go to Step 1.3.                  #
6883#               1.2     Go to Step 7.                                   #
6884#               1.3     If |X| < 70 log(2), go to Step 2.               #
6885#               1.4     Go to Step 10.                                  #
6886#       Notes:  The usual case should take the branches 1.1 -> 1.3 -> 2.#
6887#               However, it is conceivable |X| can be small very often  #
6888#               because EXPM1 is intended to evaluate exp(X)-1          #
6889#               accurately when |X| is small. For further details on    #
6890#               the comparisons, see the notes on Step 1 of setox.      #
6891#                                                                       #
6892#       Step 2. Calculate N = round-to-nearest-int( X * 64/log2 ).      #
6893#               2.1     N := round-to-nearest-integer( X * 64/log2 ).   #
6894#               2.2     Calculate       J = N mod 64; so J = 0,1,2,..., #
6895#                       or 63.                                          #
6896#               2.3     Calculate       M = (N - J)/64; so N = 64M + J. #
6897#               2.4     Calculate the address of the stored value of    #
6898#                       2^(J/64).                                       #
6899#               2.5     Create the values Sc = 2^M and                  #
6900#                       OnebySc := -2^(-M).                             #
6901#       Notes:  See the notes on Step 2 of setox.                       #
6902#                                                                       #
6903#       Step 3. Calculate X - N*log2/64.                                #
6904#               3.1     R := X + N*L1,                                  #
6905#                               where L1 := single-precision(-log2/64). #
6906#               3.2     R := R + N*L2,                                  #
6907#                               L2 := extended-precision(-log2/64 - L1).#
6908#       Notes:  Applying the analysis of Step 3 of setox in this case   #
6909#               shows that |R| <= 0.0055 (note that |X| <= 70 log2 in   #
6910#               this case).                                             #
6911#                                                                       #
6912#       Step 4. Approximate exp(R)-1 by a polynomial                    #
6913#                       p = R+R*R*(A1+R*(A2+R*(A3+R*(A4+R*(A5+R*A6))))) #
6914#       Notes:  a) In order to reduce memory access, the coefficients   #
6915#               are made as "short" as possible: A1 (which is 1/2), A5  #
6916#               and A6 are single precision; A2, A3 and A4 are double   #
6917#               precision.                                              #
6918#               b) Even with the restriction above,                     #
6919#                       |p - (exp(R)-1)| <      |R| * 2^(-72.7)         #
6920#               for all |R| <= 0.0055.                                  #
6921#               c) To fully utilize the pipeline, p is separated into   #
6922#               two independent pieces of roughly equal complexity      #
6923#                       p = [ R*S*(A2 + S*(A4 + S*A6)) ]        +       #
6924#                               [ R + S*(A1 + S*(A3 + S*A5)) ]          #
6925#               where S = R*R.                                          #
6926#                                                                       #
6927#       Step 5. Compute 2^(J/64)*p by                                   #
6928#                               p := T*p                                #
6929#               where T and t are the stored values for 2^(J/64).       #
6930#       Notes:  2^(J/64) is stored as T and t where T+t approximates    #
6931#               2^(J/64) to roughly 85 bits; T is in extended precision #
6932#               and t is in single precision. Note also that T is       #
6933#               rounded to 62 bits so that the last two bits of T are   #
6934#               zero. The reason for such a special form is that T-1,   #
6935#               T-2, and T-8 will all be exact --- a property that will #
6936#               be exploited in Step 6 below. The total relative error  #
6937#               in p is no bigger than 2^(-67.7) compared to the final  #
6938#               result.                                                 #
6939#                                                                       #
6940#       Step 6. Reconstruction of exp(X)-1                              #
6941#                       exp(X)-1 = 2^M * ( 2^(J/64) + p - 2^(-M) ).     #
6942#               6.1     If M <= 63, go to Step 6.3.                     #
6943#               6.2     ans := T + (p + (t + OnebySc)). Go to 6.6       #
6944#               6.3     If M >= -3, go to 6.5.                          #
6945#               6.4     ans := (T + (p + t)) + OnebySc. Go to 6.6       #
6946#               6.5     ans := (T + OnebySc) + (p + t).                 #
6947#               6.6     Restore user FPCR.                              #
6948#               6.7     Return ans := Sc * ans. Exit.                   #
6949#       Notes:  The various arrangements of the expressions give        #
6950#               accurate evaluations.                                   #
6951#                                                                       #
6952#       Step 7. exp(X)-1 for |X| < 1/4.                                 #
6953#               7.1     If |X| >= 2^(-65), go to Step 9.                #
6954#               7.2     Go to Step 8.                                   #
6955#                                                                       #
6956#       Step 8. Calculate exp(X)-1, |X| < 2^(-65).                      #
6957#               8.1     If |X| < 2^(-16312), goto 8.3                   #
6958#               8.2     Restore FPCR; return ans := X - 2^(-16382).     #
6959#                       Exit.                                           #
6960#               8.3     X := X * 2^(140).                               #
6961#               8.4     Restore FPCR; ans := ans - 2^(-16382).          #
6962#                Return ans := ans*2^(140). Exit                        #
6963#       Notes:  The idea is to return "X - tiny" under the user         #
6964#               precision and rounding modes. To avoid unnecessary      #
6965#               inefficiency, we stay away from denormalized numbers    #
6966#               the best we can. For |X| >= 2^(-16312), the             #
6967#               straightforward 8.2 generates the inexact exception as  #
6968#               the case warrants.                                      #
6969#                                                                       #
6970#       Step 9. Calculate exp(X)-1, |X| < 1/4, by a polynomial          #
6971#                       p = X + X*X*(B1 + X*(B2 + ... + X*B12))         #
6972#       Notes:  a) In order to reduce memory access, the coefficients   #
6973#               are made as "short" as possible: B1 (which is 1/2), B9  #
6974#               to B12 are single precision; B3 to B8 are double        #
6975#               precision; and B2 is double extended.                   #
6976#               b) Even with the restriction above,                     #
6977#                       |p - (exp(X)-1)| < |X| 2^(-70.6)                #
6978#               for all |X| <= 0.251.                                   #
6979#               Note that 0.251 is slightly bigger than 1/4.            #
6980#               c) To fully preserve accuracy, the polynomial is        #
6981#               computed as                                             #
6982#                       X + ( S*B1 +    Q ) where S = X*X and           #
6983#                       Q       =       X*S*(B2 + X*(B3 + ... + X*B12)) #
6984#               d) To fully utilize the pipeline, Q is separated into   #
6985#               two independent pieces of roughly equal complexity      #
6986#                       Q = [ X*S*(B2 + S*(B4 + ... + S*B12)) ] +       #
6987#                               [ S*S*(B3 + S*(B5 + ... + S*B11)) ]     #
6988#                                                                       #
6989#       Step 10. Calculate exp(X)-1 for |X| >= 70 log 2.                #
6990#               10.1 If X >= 70log2 , exp(X) - 1 = exp(X) for all       #
6991#               practical purposes. Therefore, go to Step 1 of setox.   #
6992#               10.2 If X <= -70log2, exp(X) - 1 = -1 for all practical #
6993#               purposes.                                               #
6994#               ans := -1                                               #
6995#               Restore user FPCR                                       #
6996#               Return ans := ans + 2^(-126). Exit.                     #
6997#       Notes:  10.2 will always create an inexact and return -1 + tiny #
6998#               in the user rounding precision and mode.                #
6999#                                                                       #
7000#########################################################################

7001
7002L2:     long            0x3FDC0000,0x82E30865,0x4361C4C6,0x00000000
7003
7004EEXPA3: long            0x3FA55555,0x55554CC1
7005EEXPA2: long            0x3FC55555,0x55554A54
7006
7007EM1A4:  long            0x3F811111,0x11174385
7008EM1A3:  long            0x3FA55555,0x55554F5A
7009
7010EM1A2:  long            0x3FC55555,0x55555555,0x00000000,0x00000000
7011
7012EM1B8:  long            0x3EC71DE3,0xA5774682
7013EM1B7:  long            0x3EFA01A0,0x19D7CB68
7014
7015EM1B6:  long            0x3F2A01A0,0x1A019DF3
7016EM1B5:  long            0x3F56C16C,0x16C170E2
7017
7018EM1B4:  long            0x3F811111,0x11111111
7019EM1B3:  long            0x3FA55555,0x55555555
7020
7021EM1B2:  long            0x3FFC0000,0xAAAAAAAA,0xAAAAAAAB
7022        long            0x00000000
7023
7024TWO140: long            0x48B00000,0x00000000
7025TWON140:
7026        long            0x37300000,0x00000000
7027
7028EEXPTBL:
7029        long            0x3FFF0000,0x80000000,0x00000000,0x00000000
7030        long            0x3FFF0000,0x8164D1F3,0xBC030774,0x9F841A9B
7031        long            0x3FFF0000,0x82CD8698,0xAC2BA1D8,0x9FC1D5B9
7032        long            0x3FFF0000,0x843A28C3,0xACDE4048,0xA0728369
7033        long            0x3FFF0000,0x85AAC367,0xCC487B14,0x1FC5C95C
7034        long            0x3FFF0000,0x871F6196,0x9E8D1010,0x1EE85C9F
7035        long            0x3FFF0000,0x88980E80,0x92DA8528,0x9FA20729
7036        long            0x3FFF0000,0x8A14D575,0x496EFD9C,0xA07BF9AF
7037        long            0x3FFF0000,0x8B95C1E3,0xEA8BD6E8,0xA0020DCF
7038        long            0x3FFF0000,0x8D1ADF5B,0x7E5BA9E4,0x205A63DA
7039        long            0x3FFF0000,0x8EA4398B,0x45CD53C0,0x1EB70051
7040        long            0x3FFF0000,0x9031DC43,0x1466B1DC,0x1F6EB029
7041        long            0x3FFF0000,0x91C3D373,0xAB11C338,0xA0781494
7042        long            0x3FFF0000,0x935A2B2F,0x13E6E92C,0x9EB319B0
7043        long            0x3FFF0000,0x94F4EFA8,0xFEF70960,0x2017457D
7044        long            0x3FFF0000,0x96942D37,0x20185A00,0x1F11D537
7045        long            0x3FFF0000,0x9837F051,0x8DB8A970,0x9FB952DD
7046        long            0x3FFF0000,0x99E04593,0x20B7FA64,0x1FE43087
7047        long            0x3FFF0000,0x9B8D39B9,0xD54E5538,0x1FA2A818
7048        long            0x3FFF0000,0x9D3ED9A7,0x2CFFB750,0x1FDE494D
7049        long            0x3FFF0000,0x9EF53260,0x91A111AC,0x20504890
7050        long            0x3FFF0000,0xA0B0510F,0xB9714FC4,0xA073691C
7051        long            0x3FFF0000,0xA2704303,0x0C496818,0x1F9B7A05
7052        long            0x3FFF0000,0xA43515AE,0x09E680A0,0xA0797126
7053        long            0x3FFF0000,0xA5FED6A9,0xB15138EC,0xA071A140
7054        long            0x3FFF0000,0xA7CD93B4,0xE9653568,0x204F62DA
7055        long            0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x1F283C4A
7056        long            0x3FFF0000,0xAB7A39B5,0xA93ED338,0x9F9A7FDC
7057        long            0x3FFF0000,0xAD583EEA,0x42A14AC8,0xA05B3FAC
7058        long            0x3FFF0000,0xAF3B78AD,0x690A4374,0x1FDF2610
7059        long            0x3FFF0000,0xB123F581,0xD2AC2590,0x9F705F90
7060        long            0x3FFF0000,0xB311C412,0xA9112488,0x201F678A
7061        long            0x3FFF0000,0xB504F333,0xF9DE6484,0x1F32FB13
7062        long            0x3FFF0000,0xB6FD91E3,0x28D17790,0x20038B30
7063        long            0x3FFF0000,0xB8FBAF47,0x62FB9EE8,0x200DC3CC
7064        long            0x3FFF0000,0xBAFF5AB2,0x133E45FC,0x9F8B2AE6
7065        long            0x3FFF0000,0xBD08A39F,0x580C36C0,0xA02BBF70
7066        long            0x3FFF0000,0xBF1799B6,0x7A731084,0xA00BF518
7067        long            0x3FFF0000,0xC12C4CCA,0x66709458,0xA041DD41
7068        long            0x3FFF0000,0xC346CCDA,0x24976408,0x9FDF137B
7069        long            0x3FFF0000,0xC5672A11,0x5506DADC,0x201F1568
7070        long            0x3FFF0000,0xC78D74C8,0xABB9B15C,0x1FC13A2E
7071        long            0x3FFF0000,0xC9B9BD86,0x6E2F27A4,0xA03F8F03
7072        long            0x3FFF0000,0xCBEC14FE,0xF2727C5C,0x1FF4907D
7073        long            0x3FFF0000,0xCE248C15,0x1F8480E4,0x9E6E53E4
7074        long            0x3FFF0000,0xD06333DA,0xEF2B2594,0x1FD6D45C
7075        long            0x3FFF0000,0xD2A81D91,0xF12AE45C,0xA076EDB9
7076        long            0x3FFF0000,0xD4F35AAB,0xCFEDFA20,0x9FA6DE21
7077        long            0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x1EE69A2F
7078        long            0x3FFF0000,0xD99D15C2,0x78AFD7B4,0x207F439F
7079        long            0x3FFF0000,0xDBFBB797,0xDAF23754,0x201EC207
7080        long            0x3FFF0000,0xDE60F482,0x5E0E9124,0x9E8BE175
7081        long            0x3FFF0000,0xE0CCDEEC,0x2A94E110,0x20032C4B
7082        long            0x3FFF0000,0xE33F8972,0xBE8A5A50,0x2004DFF5
7083        long            0x3FFF0000,0xE5B906E7,0x7C8348A8,0x1E72F47A
7084        long            0x3FFF0000,0xE8396A50,0x3C4BDC68,0x1F722F22
7085        long            0x3FFF0000,0xEAC0C6E7,0xDD243930,0xA017E945
7086        long            0x3FFF0000,0xED4F301E,0xD9942B84,0x1F401A5B
7087        long            0x3FFF0000,0xEFE4B99B,0xDCDAF5CC,0x9FB9A9E3
7088        long            0x3FFF0000,0xF281773C,0x59FFB138,0x20744C05
7089        long            0x3FFF0000,0xF5257D15,0x2486CC2C,0x1F773A19
7090        long            0x3FFF0000,0xF7D0DF73,0x0AD13BB8,0x1FFE90D5
7091        long            0x3FFF0000,0xFA83B2DB,0x722A033C,0xA041ED22
7092        long            0x3FFF0000,0xFD3E0C0C,0xF486C174,0x1F853F3A
7093
7094        set             ADJFLAG,L_SCR2
7095        set             SCALE,FP_SCR0
7096        set             ADJSCALE,FP_SCR1
7097        set             SC,FP_SCR0
7098        set             ONEBYSC,FP_SCR1
7099
7100        global          setox
7101setox:
7102#--entry point for EXP(X), here X is finite, non-zero, and not NaN's
7103
7104#--Step 1.
7105        mov.l           (%a0),%d1               # load part of input X
7106        and.l           &0x7FFF0000,%d1         # biased expo. of X
7107        cmp.l           %d1,&0x3FBE0000         # 2^(-65)
7108        bge.b           EXPC1                   # normal case
7109        bra             EXPSM
7110
7111EXPC1:
7112#--The case |X| >= 2^(-65)
7113        mov.w           4(%a0),%d1              # expo. and partial sig. of |X|
7114        cmp.l           %d1,&0x400CB167         # 16380 log2 trunc. 16 bits
7115        blt.b           EXPMAIN                 # normal case
7116        bra             EEXPBIG
7117
7118EXPMAIN:
7119#--Step 2.
7120#--This is the normal branch:   2^(-65) <= |X| < 16380 log2.
7121        fmov.x          (%a0),%fp0              # load input from (a0)
7122
7123        fmov.x          %fp0,%fp1
7124        fmul.s          &0x42B8AA3B,%fp0        # 64/log2 * X
7125        fmovm.x         &0xc,-(%sp)             # save fp2 {%fp2/%fp3}
7126        mov.l           &0,ADJFLAG(%a6)
7127        fmov.l          %fp0,%d1                # N = int( X * 64/log2 )
7128        lea             EEXPTBL(%pc),%a1
7129        fmov.l          %d1,%fp0                # convert to floating-format
7130
7131        mov.l           %d1,L_SCR1(%a6)         # save N temporarily
7132        and.l           &0x3F,%d1               # D0 is J = N mod 64
7133        lsl.l           &4,%d1
7134        add.l           %d1,%a1                 # address of 2^(J/64)
7135        mov.l           L_SCR1(%a6),%d1
7136        asr.l           &6,%d1                  # D0 is M
7137        add.w           &0x3FFF,%d1             # biased expo. of 2^(M)
7138        mov.w           L2(%pc),L_SCR1(%a6)     # prefetch L2, no need in CB
7139
7140EXPCONT1:
7141#--Step 3.
7142#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7143#--a0 points to 2^(J/64), D0 is biased expo. of 2^(M)
7144        fmov.x          %fp0,%fp2
7145        fmul.s          &0xBC317218,%fp0        # N * L1, L1 = lead(-log2/64)
7146        fmul.x          L2(%pc),%fp2            # N * L2, L1+L2 = -log2/64
7147        fadd.x          %fp1,%fp0               # X + N*L1
7148        fadd.x          %fp2,%fp0               # fp0 is R, reduced arg.
7149
7150#--Step 4.
7151#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7152#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*A5))))
7153#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
7154#--[R+R*S*(A2+S*A4)] + [S*(A1+S*(A3+S*A5))]
7155
7156        fmov.x          %fp0,%fp1
7157        fmul.x          %fp1,%fp1               # fp1 IS S = R*R
7158
7159        fmov.s          &0x3AB60B70,%fp2        # fp2 IS A5
7160
7161        fmul.x          %fp1,%fp2               # fp2 IS S*A5
7162        fmov.x          %fp1,%fp3
7163        fmul.s          &0x3C088895,%fp3        # fp3 IS S*A4
7164
7165        fadd.d          EEXPA3(%pc),%fp2        # fp2 IS A3+S*A5
7166        fadd.d          EEXPA2(%pc),%fp3        # fp3 IS A2+S*A4
7167
7168        fmul.x          %fp1,%fp2               # fp2 IS S*(A3+S*A5)
7169        mov.w           %d1,SCALE(%a6)          # SCALE is 2^(M) in extended
7170        mov.l           &0x80000000,SCALE+4(%a6)
7171        clr.l           SCALE+8(%a6)
7172
7173        fmul.x          %fp1,%fp3               # fp3 IS S*(A2+S*A4)
7174
7175        fadd.s          &0x3F000000,%fp2        # fp2 IS A1+S*(A3+S*A5)
7176        fmul.x          %fp0,%fp3               # fp3 IS R*S*(A2+S*A4)
7177
7178        fmul.x          %fp1,%fp2               # fp2 IS S*(A1+S*(A3+S*A5))
7179        fadd.x          %fp3,%fp0               # fp0 IS R+R*S*(A2+S*A4),
7180
7181        fmov.x          (%a1)+,%fp1             # fp1 is lead. pt. of 2^(J/64)
7182        fadd.x          %fp2,%fp0               # fp0 is EXP(R) - 1
7183
7184#--Step 5
7185#--final reconstruction process
7186#--EXP(X) = 2^M * ( 2^(J/64) + 2^(J/64)*(EXP(R)-1) )
7187
7188        fmul.x          %fp1,%fp0               # 2^(J/64)*(Exp(R)-1)
7189        fmovm.x         (%sp)+,&0x30            # fp2 restored {%fp2/%fp3}
7190        fadd.s          (%a1),%fp0              # accurate 2^(J/64)
7191
7192        fadd.x          %fp1,%fp0               # 2^(J/64) + 2^(J/64)*...
7193        mov.l           ADJFLAG(%a6),%d1
7194
7195#--Step 6
7196        tst.l           %d1
7197        beq.b           NORMAL
7198ADJUST:
7199        fmul.x          ADJSCALE(%a6),%fp0
7200NORMAL:
7201        fmov.l          %d0,%fpcr               # restore user FPCR
7202        mov.b           &FMUL_OP,%d1            # last inst is MUL
7203        fmul.x          SCALE(%a6),%fp0         # multiply 2^(M)
7204        bra             t_catch
7205
7206EXPSM:
7207#--Step 7
7208        fmovm.x         (%a0),&0x80             # load X
7209        fmov.l          %d0,%fpcr
7210        fadd.s          &0x3F800000,%fp0        # 1+X in user mode
7211        bra             t_pinx2
7212
7213EEXPBIG:
7214#--Step 8
7215        cmp.l           %d1,&0x400CB27C         # 16480 log2
7216        bgt.b           EXP2BIG
7217#--Steps 8.2 -- 8.6
7218        fmov.x          (%a0),%fp0              # load input from (a0)
7219
7220        fmov.x          %fp0,%fp1
7221        fmul.s          &0x42B8AA3B,%fp0        # 64/log2 * X
7222        fmovm.x         &0xc,-(%sp)             # save fp2 {%fp2/%fp3}
7223        mov.l           &1,ADJFLAG(%a6)
7224        fmov.l          %fp0,%d1                # N = int( X * 64/log2 )
7225        lea             EEXPTBL(%pc),%a1
7226        fmov.l          %d1,%fp0                # convert to floating-format
7227        mov.l           %d1,L_SCR1(%a6)         # save N temporarily
7228        and.l           &0x3F,%d1               # D0 is J = N mod 64
7229        lsl.l           &4,%d1
7230        add.l           %d1,%a1                 # address of 2^(J/64)
7231        mov.l           L_SCR1(%a6),%d1
7232        asr.l           &6,%d1                  # D0 is K
7233        mov.l           %d1,L_SCR1(%a6)         # save K temporarily
7234        asr.l           &1,%d1                  # D0 is M1
7235        sub.l           %d1,L_SCR1(%a6)         # a1 is M
7236        add.w           &0x3FFF,%d1             # biased expo. of 2^(M1)
7237        mov.w           %d1,ADJSCALE(%a6)       # ADJSCALE := 2^(M1)
7238        mov.l           &0x80000000,ADJSCALE+4(%a6)
7239        clr.l           ADJSCALE+8(%a6)
7240        mov.l           L_SCR1(%a6),%d1         # D0 is M
7241        add.w           &0x3FFF,%d1             # biased expo. of 2^(M)
7242        bra.w           EXPCONT1                # go back to Step 3
7243
7244EXP2BIG:
7245#--Step 9
7246        tst.b           (%a0)                   # is X positive or negative?
7247        bmi             t_unfl2
7248        bra             t_ovfl2
7249
7250        global          setoxd
7251setoxd:
7252#--entry point for EXP(X), X is denormalized
7253        mov.l           (%a0),-(%sp)
7254        andi.l          &0x80000000,(%sp)
7255        ori.l           &0x00800000,(%sp)       # sign(X)*2^(-126)
7256
7257        fmov.s          &0x3F800000,%fp0
7258
7259        fmov.l          %d0,%fpcr
7260        fadd.s          (%sp)+,%fp0
7261        bra             t_pinx2
7262
7263        global          setoxm1
7264setoxm1:
7265#--entry point for EXPM1(X), here X is finite, non-zero, non-NaN
7266
7267#--Step 1.
7268#--Step 1.1
7269        mov.l           (%a0),%d1               # load part of input X
7270        and.l           &0x7FFF0000,%d1         # biased expo. of X
7271        cmp.l           %d1,&0x3FFD0000         # 1/4
7272        bge.b           EM1CON1                 # |X| >= 1/4
7273        bra             EM1SM
7274
7275EM1CON1:
7276#--Step 1.3
7277#--The case |X| >= 1/4
7278        mov.w           4(%a0),%d1              # expo. and partial sig. of |X|
7279        cmp.l           %d1,&0x4004C215         # 70log2 rounded up to 16 bits
7280        ble.b           EM1MAIN                 # 1/4 <= |X| <= 70log2
7281        bra             EM1BIG
7282
7283EM1MAIN:
7284#--Step 2.
7285#--This is the case:    1/4 <= |X| <= 70 log2.
7286        fmov.x          (%a0),%fp0              # load input from (a0)
7287
7288        fmov.x          %fp0,%fp1
7289        fmul.s          &0x42B8AA3B,%fp0        # 64/log2 * X
7290        fmovm.x         &0xc,-(%sp)             # save fp2 {%fp2/%fp3}
7291        fmov.l          %fp0,%d1                # N = int( X * 64/log2 )
7292        lea             EEXPTBL(%pc),%a1
7293        fmov.l          %d1,%fp0                # convert to floating-format
7294
7295        mov.l           %d1,L_SCR1(%a6)         # save N temporarily
7296        and.l           &0x3F,%d1               # D0 is J = N mod 64
7297        lsl.l           &4,%d1
7298        add.l           %d1,%a1                 # address of 2^(J/64)
7299        mov.l           L_SCR1(%a6),%d1
7300        asr.l           &6,%d1                  # D0 is M
7301        mov.l           %d1,L_SCR1(%a6)         # save a copy of M
7302
7303#--Step 3.
7304#--fp1,fp2 saved on the stack. fp0 is N, fp1 is X,
7305#--a0 points to 2^(J/64), D0 and a1 both contain M
7306        fmov.x          %fp0,%fp2
7307        fmul.s          &0xBC317218,%fp0        # N * L1, L1 = lead(-log2/64)
7308        fmul.x          L2(%pc),%fp2            # N * L2, L1+L2 = -log2/64
7309        fadd.x          %fp1,%fp0               # X + N*L1
7310        fadd.x          %fp2,%fp0               # fp0 is R, reduced arg.
7311        add.w           &0x3FFF,%d1             # D0 is biased expo. of 2^M
7312
7313#--Step 4.
7314#--WE NOW COMPUTE EXP(R)-1 BY A POLYNOMIAL
7315#-- R + R*R*(A1 + R*(A2 + R*(A3 + R*(A4 + R*(A5 + R*A6)))))
7316#--TO FULLY UTILIZE THE PIPELINE, WE COMPUTE S = R*R
7317#--[R*S*(A2+S*(A4+S*A6))] + [R+S*(A1+S*(A3+S*A5))]
7318
7319        fmov.x          %fp0,%fp1
7320        fmul.x          %fp1,%fp1               # fp1 IS S = R*R
7321
7322        fmov.s          &0x3950097B,%fp2        # fp2 IS a6
7323
7324        fmul.x          %fp1,%fp2               # fp2 IS S*A6
7325        fmov.x          %fp1,%fp3
7326        fmul.s          &0x3AB60B6A,%fp3        # fp3 IS S*A5
7327
7328        fadd.d          EM1A4(%pc),%fp2         # fp2 IS A4+S*A6
7329        fadd.d          EM1A3(%pc),%fp3         # fp3 IS A3+S*A5
7330        mov.w           %d1,SC(%a6)             # SC is 2^(M) in extended
7331        mov.l           &0x80000000,SC+4(%a6)
7332        clr.l           SC+8(%a6)
7333
7334        fmul.x          %fp1,%fp2               # fp2 IS S*(A4+S*A6)
7335        mov.l           L_SCR1(%a6),%d1         # D0 is M
7336        neg.w           %d1                     # D0 is -M
7337        fmul.x          %fp1,%fp3               # fp3 IS S*(A3+S*A5)
7338        add.w           &0x3FFF,%d1             # biased expo. of 2^(-M)
7339        fadd.d          EM1A2(%pc),%fp2         # fp2 IS A2+S*(A4+S*A6)
7340        fadd.s          &0x3F000000,%fp3        # fp3 IS A1+S*(A3+S*A5)
7341
7342        fmul.x          %fp1,%fp2               # fp2 IS S*(A2+S*(A4+S*A6))
7343        or.w            &0x8000,%d1             # signed/expo. of -2^(-M)
7344        mov.w           %d1,ONEBYSC(%a6)        # OnebySc is -2^(-M)
7345        mov.l           &0x80000000,ONEBYSC+4(%a6)
7346        clr.l           ONEBYSC+8(%a6)
7347        fmul.x          %fp3,%fp1               # fp1 IS S*(A1+S*(A3+S*A5))
7348
7349        fmul.x          %fp0,%fp2               # fp2 IS R*S*(A2+S*(A4+S*A6))
7350        fadd.x          %fp1,%fp0               # fp0 IS R+S*(A1+S*(A3+S*A5))
7351
7352        fadd.x          %fp2,%fp0               # fp0 IS EXP(R)-1
7353
7354        fmovm.x         (%sp)+,&0x30            # fp2 restored {%fp2/%fp3}
7355
7356#--Step 5
7357#--Compute 2^(J/64)*p
7358
7359        fmul.x          (%a1),%fp0              # 2^(J/64)*(Exp(R)-1)
7360
7361#--Step 6
7362#--Step 6.1
7363        mov.l           L_SCR1(%a6),%d1         # retrieve M
7364        cmp.l           %d1,&63
7365        ble.b           MLE63
7366#--Step 6.2     M >= 64
7367        fmov.s          12(%a1),%fp1            # fp1 is t
7368        fadd.x          ONEBYSC(%a6),%fp1       # fp1 is t+OnebySc
7369        fadd.x          %fp1,%fp0               # p+(t+OnebySc), fp1 released
7370        fadd.x          (%a1),%fp0              # T+(p+(t+OnebySc))
7371        bra             EM1SCALE
7372MLE63:
7373#--Step 6.3     M <= 63
7374        cmp.l           %d1,&-3
7375        bge.b           MGEN3
7376MLTN3:
7377#--Step 6.4     M <= -4
7378        fadd.s          12(%a1),%fp0            # p+t
7379        fadd.x          (%a1),%fp0              # T+(p+t)
7380        fadd.x          ONEBYSC(%a6),%fp0       # OnebySc + (T+(p+t))
7381        bra             EM1SCALE
7382MGEN3:
7383#--Step 6.5     -3 <= M <= 63
7384        fmov.x          (%a1)+,%fp1             # fp1 is T
7385        fadd.s          (%a1),%fp0              # fp0 is p+t
7386        fadd.x          ONEBYSC(%a6),%fp1       # fp1 is T+OnebySc
7387        fadd.x          %fp1,%fp0               # (T+OnebySc)+(p+t)
7388
7389EM1SCALE:
7390#--Step 6.6
7391        fmov.l          %d0,%fpcr
7392        fmul.x          SC(%a6),%fp0
7393        bra             t_inx2
7394
7395EM1SM:
7396#--Step 7       |X| < 1/4.
7397        cmp.l           %d1,&0x3FBE0000         # 2^(-65)
7398        bge.b           EM1POLY
7399
7400EM1TINY:
7401#--Step 8       |X| < 2^(-65)
7402        cmp.l           %d1,&0x00330000         # 2^(-16312)
7403        blt.b           EM12TINY
7404#--Step 8.2
7405        mov.l           &0x80010000,SC(%a6)     # SC is -2^(-16382)
7406        mov.l           &0x80000000,SC+4(%a6)
7407        clr.l           SC+8(%a6)
7408        fmov.x          (%a0),%fp0
7409        fmov.l          %d0,%fpcr
7410        mov.b           &FADD_OP,%d1            # last inst is ADD
7411        fadd.x          SC(%a6),%fp0
7412        bra             t_catch
7413
7414EM12TINY:
7415#--Step 8.3
7416        fmov.x          (%a0),%fp0
7417        fmul.d          TWO140(%pc),%fp0
7418        mov.l           &0x80010000,SC(%a6)
7419        mov.l           &0x80000000,SC+4(%a6)
7420        clr.l           SC+8(%a6)
7421        fadd.x          SC(%a6),%fp0
7422        fmov.l          %d0,%fpcr
7423        mov.b           &FMUL_OP,%d1            # last inst is MUL
7424        fmul.d          TWON140(%pc),%fp0
7425        bra             t_catch
7426
7427EM1POLY:
7428#--Step 9       exp(X)-1 by a simple polynomial
7429        fmov.x          (%a0),%fp0              # fp0 is X
7430        fmul.x          %fp0,%fp0               # fp0 is S := X*X
7431        fmovm.x         &0xc,-(%sp)             # save fp2 {%fp2/%fp3}
7432        fmov.s          &0x2F30CAA8,%fp1        # fp1 is B12
7433        fmul.x          %fp0,%fp1               # fp1 is S*B12
7434        fmov.s          &0x310F8290,%fp2        # fp2 is B11
7435        fadd.s          &0x32D73220,%fp1        # fp1 is B10+S*B12
7436
7437        fmul.x          %fp0,%fp2               # fp2 is S*B11
7438        fmul.x          %fp0,%fp1               # fp1 is S*(B10 + ...
7439
7440        fadd.s          &0x3493F281,%fp2        # fp2 is B9+S*...
7441        fadd.d          EM1B8(%pc),%fp1         # fp1 is B8+S*...
7442
7443        fmul.x          %fp0,%fp2               # fp2 is S*(B9+...
7444        fmul.x          %fp0,%fp1               # fp1 is S*(B8+...
7445
7446        fadd.d          EM1B7(%pc),%fp2         # fp2 is B7+S*...
7447        fadd.d          EM1B6(%pc),%fp1         # fp1 is B6+S*...
7448
7449        fmul.x          %fp0,%fp2               # fp2 is S*(B7+...
7450        fmul.x          %fp0,%fp1               # fp1 is S*(B6+...
7451
7452        fadd.d          EM1B5(%pc),%fp2         # fp2 is B5+S*...
7453        fadd.d          EM1B4(%pc),%fp1         # fp1 is B4+S*...
7454
7455        fmul.x          %fp0,%fp2               # fp2 is S*(B5+...
7456        fmul.x          %fp0,%fp1               # fp1 is S*(B4+...
7457
7458        fadd.d          EM1B3(%pc),%fp2         # fp2 is B3+S*...
7459        fadd.x          EM1B2(%pc),%fp1         # fp1 is B2+S*...
7460
7461        fmul.x          %fp0,%fp2               # fp2 is S*(B3+...
7462        fmul.x          %fp0,%fp1               # fp1 is S*(B2+...
7463
7464        fmul.x          %fp0,%fp2               # fp2 is S*S*(B3+...)
7465        fmul.x          (%a0),%fp1              # fp1 is X*S*(B2...
7466
7467        fmul.s          &0x3F000000,%fp0        # fp0 is S*B1
7468        fadd.x          %fp2,%fp1               # fp1 is Q
7469
7470        fmovm.x         (%sp)+,&0x30            # fp2 restored {%fp2/%fp3}
7471
7472        fadd.x          %fp1,%fp0               # fp0 is S*B1+Q
7473
7474        fmov.l          %d0,%fpcr
7475        fadd.x          (%a0),%fp0
7476        bra             t_inx2
7477
7478EM1BIG:
7479#--Step 10      |X| > 70 log2
7480        mov.l           (%a0),%d1
7481        cmp.l           %d1,&0
7482        bgt.w           EXPC1
7483#--Step 10.2
7484        fmov.s          &0xBF800000,%fp0        # fp0 is -1
7485        fmov.l          %d0,%fpcr
7486        fadd.s          &0x00800000,%fp0        # -1 + 2^(-126)
7487        bra             t_minx2
7488
7489        global          setoxm1d
7490setoxm1d:
7491#--entry point for EXPM1(X), here X is denormalized
7492#--Step 0.
7493        bra             t_extdnrm
7494
7495#########################################################################
7496# sgetexp():  returns the exponent portion of the input argument.       #
7497#             The exponent bias is removed and the exponent value is    #
7498#             returned as an extended precision number in fp0.          #
7499# sgetexpd(): handles denormalized numbers.                             #
7500#                                                                       #
7501# sgetman():  extracts the mantissa of the input argument. The          #
7502#             mantissa is converted to an extended precision number w/  #
7503#             an exponent of $3fff and is returned in fp0. The range of #
7504#             the result is [1.0 - 2.0).                                #
7505# sgetmand(): handles denormalized numbers.                             #
7506#                                                                       #
7507# INPUT *************************************************************** #
7508#       a0  = pointer to extended precision input                       #
7509#                                                                       #
7510# OUTPUT ************************************************************** #
7511#       fp0 = exponent(X) or mantissa(X)                                #
7512#                                                                       #
7513#########################################################################
7514
7515        global          sgetexp
7516sgetexp:
7517        mov.w           SRC_EX(%a0),%d0         # get the exponent
7518        bclr            &0xf,%d0                # clear the sign bit
7519        subi.w          &0x3fff,%d0             # subtract off the bias
7520        fmov.w          %d0,%fp0                # return exp in fp0
7521        blt.b           sgetexpn                # it's negative
7522        rts
7523
7524sgetexpn:
7525        mov.b           &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
7526        rts
7527
7528        global          sgetexpd
7529sgetexpd:
7530        bsr.l           norm                    # normalize
7531        neg.w           %d0                     # new exp = -(shft amt)
7532        subi.w          &0x3fff,%d0             # subtract off the bias
7533        fmov.w          %d0,%fp0                # return exp in fp0
7534        mov.b           &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
7535        rts
7536
7537        global          sgetman
7538sgetman:
7539        mov.w           SRC_EX(%a0),%d0         # get the exp
7540        ori.w           &0x7fff,%d0             # clear old exp
7541        bclr            &0xe,%d0                # make it the new exp +-3fff
7542
7543# here, we build the result in a tmp location so as not to disturb the input
7544        mov.l           SRC_HI(%a0),FP_SCR0_HI(%a6) # copy to tmp loc
7545        mov.l           SRC_LO(%a0),FP_SCR0_LO(%a6) # copy to tmp loc
7546        mov.w           %d0,FP_SCR0_EX(%a6)     # insert new exponent
7547        fmov.x          FP_SCR0(%a6),%fp0       # put new value back in fp0
7548        bmi.b           sgetmann                # it's negative
7549        rts
7550
7551sgetmann:
7552        mov.b           &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
7553        rts
7554
7555#
7556# For denormalized numbers, shift the mantissa until the j-bit = 1,
7557# then load the exponent with +/1 $3fff.
7558#
7559        global          sgetmand
7560sgetmand:
7561        bsr.l           norm                    # normalize exponent
7562        bra.b           sgetman
7563
7564#########################################################################
7565# scosh():  computes the hyperbolic cosine of a normalized input        #
7566# scoshd(): computes the hyperbolic cosine of a denormalized input      #
7567#                                                                       #
7568# INPUT *************************************************************** #
7569#       a0 = pointer to extended precision input                        #
7570#       d0 = round precision,mode                                       #
7571#                                                                       #
7572# OUTPUT ************************************************************** #
7573#       fp0 = cosh(X)                                                   #
7574#                                                                       #
7575# ACCURACY and MONOTONICITY ******************************************* #
7576#       The returned result is within 3 ulps in 64 significant bit,     #
7577#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7578#       rounded to double precision. The result is provably monotonic   #
7579#       in double precision.                                            #
7580#                                                                       #
7581# ALGORITHM *********************************************************** #
7582#                                                                       #
7583#       COSH                                                            #
7584#       1. If |X| > 16380 log2, go to 3.                                #
7585#                                                                       #
7586#       2. (|X| <= 16380 log2) Cosh(X) is obtained by the formulae      #
7587#               y = |X|, z = exp(Y), and                                #
7588#               cosh(X) = (1/2)*( z + 1/z ).                            #
7589#               Exit.                                                   #
7590#                                                                       #
7591#       3. (|X| > 16380 log2). If |X| > 16480 log2, go to 5.            #
7592#                                                                       #
7593#       4. (16380 log2 < |X| <= 16480 log2)                             #
7594#               cosh(X) = sign(X) * exp(|X|)/2.                         #
7595#               However, invoking exp(|X|) may cause premature          #
7596#               overflow. Thus, we calculate sinh(X) as follows:        #
7597#               Y       := |X|                                          #
7598#               Fact    :=      2**(16380)                              #
7599#               Y'      := Y - 16381 log2                               #
7600#               cosh(X) := Fact * exp(Y').                              #
7601#               Exit.                                                   #
7602#                                                                       #
7603#       5. (|X| > 16480 log2) sinh(X) must overflow. Return             #
7604#               Huge*Huge to generate overflow and an infinity with     #
7605#               the appropriate sign. Huge is the largest finite number #
7606#               in extended format. Exit.                               #
7607#                                                                       #
7608#########################################################################
7609
7610TWO16380:
7611        long            0x7FFB0000,0x80000000,0x00000000,0x00000000
7612
7613        global          scosh
7614scosh:
7615        fmov.x          (%a0),%fp0              # LOAD INPUT
7616
7617        mov.l           (%a0),%d1
7618        mov.w           4(%a0),%d1
7619        and.l           &0x7FFFFFFF,%d1
7620        cmp.l           %d1,&0x400CB167
7621        bgt.b           COSHBIG
7622
7623#--THIS IS THE USUAL CASE, |X| < 16380 LOG2
7624#--COSH(X) = (1/2) * ( EXP(X) + 1/EXP(X) )
7625
7626        fabs.x          %fp0                    # |X|
7627
7628        mov.l           %d0,-(%sp)
7629        clr.l           %d0
7630        fmovm.x         &0x01,-(%sp)            # save |X| to stack
7631        lea             (%sp),%a0               # pass ptr to |X|
7632        bsr             setox                   # FP0 IS EXP(|X|)
7633        add.l           &0xc,%sp                # erase |X| from stack
7634        fmul.s          &0x3F000000,%fp0        # (1/2)EXP(|X|)
7635        mov.l           (%sp)+,%d0
7636
7637        fmov.s          &0x3E800000,%fp1        # (1/4)
7638        fdiv.x          %fp0,%fp1               # 1/(2 EXP(|X|))
7639
7640        fmov.l          %d0,%fpcr
7641        mov.b           &FADD_OP,%d1            # last inst is ADD
7642        fadd.x          %fp1,%fp0
7643        bra             t_catch
7644
7645COSHBIG:
7646        cmp.l           %d1,&0x400CB2B3
7647        bgt.b           COSHHUGE
7648
7649        fabs.x          %fp0
7650        fsub.d          T1(%pc),%fp0            # (|X|-16381LOG2_LEAD)
7651        fsub.d          T2(%pc),%fp0            # |X| - 16381 LOG2, ACCURATE
7652
7653        mov.l           %d0,-(%sp)
7654        clr.l           %d0
7655        fmovm.x         &0x01,-(%sp)            # save fp0 to stack
7656        lea             (%sp),%a0               # pass ptr to fp0
7657        bsr             setox
7658        add.l           &0xc,%sp                # clear fp0 from stack
7659        mov.l           (%sp)+,%d0
7660
7661        fmov.l          %d0,%fpcr
7662        mov.b           &FMUL_OP,%d1            # last inst is MUL
7663        fmul.x          TWO16380(%pc),%fp0
7664        bra             t_catch
7665
7666COSHHUGE:
7667        bra             t_ovfl2
7668
7669        global          scoshd
7670#--COSH(X) = 1 FOR DENORMALIZED X
7671scoshd:
7672        fmov.s          &0x3F800000,%fp0
7673
7674        fmov.l          %d0,%fpcr
7675        fadd.s          &0x00800000,%fp0
7676        bra             t_pinx2
7677
7678#########################################################################
7679# ssinh():  computes the hyperbolic sine of a normalized input          #
7680# ssinhd(): computes the hyperbolic sine of a denormalized input        #
7681#                                                                       #
7682# INPUT *************************************************************** #
7683#       a0 = pointer to extended precision input                        #
7684#       d0 = round precision,mode                                       #
7685#                                                                       #
7686# OUTPUT ************************************************************** #
7687#       fp0 = sinh(X)                                                   #
7688#                                                                       #
7689# ACCURACY and MONOTONICITY ******************************************* #
7690#       The returned result is within 3 ulps in 64 significant bit,     #
7691#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7692#       rounded to double precision. The result is provably monotonic   #
7693#       in double precision.                                            #
7694#                                                                       #
7695# ALGORITHM *********************************************************** #
7696#                                                                       #
7697#       SINH                                                            #
7698#       1. If |X| > 16380 log2, go to 3.                                #
7699#                                                                       #
7700#       2. (|X| <= 16380 log2) Sinh(X) is obtained by the formula       #
7701#               y = |X|, sgn = sign(X), and z = expm1(Y),               #
7702#               sinh(X) = sgn*(1/2)*( z + z/(1+z) ).                    #
7703#          Exit.                                                        #
7704#                                                                       #
7705#       3. If |X| > 16480 log2, go to 5.                                #
7706#                                                                       #
7707#       4. (16380 log2 < |X| <= 16480 log2)                             #
7708#               sinh(X) = sign(X) * exp(|X|)/2.                         #
7709#          However, invoking exp(|X|) may cause premature overflow.     #
7710#          Thus, we calculate sinh(X) as follows:                       #
7711#             Y       := |X|                                            #
7712#             sgn     := sign(X)                                        #
7713#             sgnFact := sgn * 2**(16380)                               #
7714#             Y'      := Y - 16381 log2                                 #
7715#             sinh(X) := sgnFact * exp(Y').                             #
7716#          Exit.                                                        #
7717#                                                                       #
7718#       5. (|X| > 16480 log2) sinh(X) must overflow. Return             #
7719#          sign(X)*Huge*Huge to generate overflow and an infinity with  #
7720#          the appropriate sign. Huge is the largest finite number in   #
7721#          extended format. Exit.                                       #
7722#                                                                       #
7723#########################################################################
7724
7725        global          ssinh
7726ssinh:
7727        fmov.x          (%a0),%fp0              # LOAD INPUT
7728
7729        mov.l           (%a0),%d1
7730        mov.w           4(%a0),%d1
7731        mov.l           %d1,%a1                 # save (compacted) operand
7732        and.l           &0x7FFFFFFF,%d1
7733        cmp.l           %d1,&0x400CB167
7734        bgt.b           SINHBIG
7735
7736#--THIS IS THE USUAL CASE, |X| < 16380 LOG2
7737#--Y = |X|, Z = EXPM1(Y), SINH(X) = SIGN(X)*(1/2)*( Z + Z/(1+Z) )
7738
7739        fabs.x          %fp0                    # Y = |X|
7740
7741        movm.l          &0x8040,-(%sp)          # {a1/d0}
7742        fmovm.x         &0x01,-(%sp)            # save Y on stack
7743        lea             (%sp),%a0               # pass ptr to Y
7744        clr.l           %d0
7745        bsr             setoxm1                 # FP0 IS Z = EXPM1(Y)
7746        add.l           &0xc,%sp                # clear Y from stack
7747        fmov.l          &0,%fpcr
7748        movm.l          (%sp)+,&0x0201          # {a1/d0}
7749
7750        fmov.x          %fp0,%fp1
7751        fadd.s          &0x3F800000,%fp1        # 1+Z
7752        fmov.x          %fp0,-(%sp)
7753        fdiv.x          %fp1,%fp0               # Z/(1+Z)
7754        mov.l           %a1,%d1
7755        and.l           &0x80000000,%d1
7756        or.l            &0x3F000000,%d1
7757        fadd.x          (%sp)+,%fp0
7758        mov.l           %d1,-(%sp)
7759
7760        fmov.l          %d0,%fpcr
7761        mov.b           &FMUL_OP,%d1            # last inst is MUL
7762        fmul.s          (%sp)+,%fp0             # last fp inst - possible exceptions set
7763        bra             t_catch
7764
7765SINHBIG:
7766        cmp.l           %d1,&0x400CB2B3
7767        bgt             t_ovfl
7768        fabs.x          %fp0
7769        fsub.d          T1(%pc),%fp0            # (|X|-16381LOG2_LEAD)
7770        mov.l           &0,-(%sp)
7771        mov.l           &0x80000000,-(%sp)
7772        mov.l           %a1,%d1
7773        and.l           &0x80000000,%d1
7774        or.l            &0x7FFB0000,%d1
7775        mov.l           %d1,-(%sp)              # EXTENDED FMT
7776        fsub.d          T2(%pc),%fp0            # |X| - 16381 LOG2, ACCURATE
7777
7778        mov.l           %d0,-(%sp)
7779        clr.l           %d0
7780        fmovm.x         &0x01,-(%sp)            # save fp0 on stack
7781        lea             (%sp),%a0               # pass ptr to fp0
7782        bsr             setox
7783        add.l           &0xc,%sp                # clear fp0 from stack
7784
7785        mov.l           (%sp)+,%d0
7786        fmov.l          %d0,%fpcr
7787        mov.b           &FMUL_OP,%d1            # last inst is MUL
7788        fmul.x          (%sp)+,%fp0             # possible exception
7789        bra             t_catch
7790
7791        global          ssinhd
7792#--SINH(X) = X FOR DENORMALIZED X
7793ssinhd:
7794        bra             t_extdnrm
7795
7796#########################################################################
7797# stanh():  computes the hyperbolic tangent of a normalized input       #
7798# stanhd(): computes the hyperbolic tangent of a denormalized input     #
7799#                                                                       #
7800# INPUT *************************************************************** #
7801#       a0 = pointer to extended precision input                        #
7802#       d0 = round precision,mode                                       #
7803#                                                                       #
7804# OUTPUT ************************************************************** #
7805#       fp0 = tanh(X)                                                   #
7806#                                                                       #
7807# ACCURACY and MONOTONICITY ******************************************* #
7808#       The returned result is within 3 ulps in 64 significant bit,     #
7809#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7810#       rounded to double precision. The result is provably monotonic   #
7811#       in double precision.                                            #
7812#                                                                       #
7813# ALGORITHM *********************************************************** #
7814#                                                                       #
7815#       TANH                                                            #
7816#       1. If |X| >= (5/2) log2 or |X| <= 2**(-40), go to 3.            #
7817#                                                                       #
7818#       2. (2**(-40) < |X| < (5/2) log2) Calculate tanh(X) by           #
7819#               sgn := sign(X), y := 2|X|, z := expm1(Y), and           #
7820#               tanh(X) = sgn*( z/(2+z) ).                              #
7821#               Exit.                                                   #
7822#                                                                       #
7823#       3. (|X| <= 2**(-40) or |X| >= (5/2) log2). If |X| < 1,          #
7824#               go to 7.                                                #
7825#                                                                       #
7826#       4. (|X| >= (5/2) log2) If |X| >= 50 log2, go to 6.              #
7827#                                                                       #
7828#       5. ((5/2) log2 <= |X| < 50 log2) Calculate tanh(X) by           #
7829#               sgn := sign(X), y := 2|X|, z := exp(Y),                 #
7830#               tanh(X) = sgn - [ sgn*2/(1+z) ].                        #
7831#               Exit.                                                   #
7832#                                                                       #
7833#       6. (|X| >= 50 log2) Tanh(X) = +-1 (round to nearest). Thus, we  #
7834#               calculate Tanh(X) by                                    #
7835#               sgn := sign(X), Tiny := 2**(-126),                      #
7836#               tanh(X) := sgn - sgn*Tiny.                              #
7837#               Exit.                                                   #
7838#                                                                       #
7839#       7. (|X| < 2**(-40)). Tanh(X) = X.       Exit.                   #
7840#                                                                       #
7841#########################################################################
7842
7843        set             X,FP_SCR0
7844        set             XFRAC,X+4
7845
7846        set             SGN,L_SCR3
7847
7848        set             V,FP_SCR0
7849
7850        global          stanh
7851stanh:
7852        fmov.x          (%a0),%fp0              # LOAD INPUT
7853
7854        fmov.x          %fp0,X(%a6)
7855        mov.l           (%a0),%d1
7856        mov.w           4(%a0),%d1
7857        mov.l           %d1,X(%a6)
7858        and.l           &0x7FFFFFFF,%d1
7859        cmp.l           %d1, &0x3fd78000        # is |X| < 2^(-40)?
7860        blt.w           TANHBORS                # yes
7861        cmp.l           %d1, &0x3fffddce        # is |X| > (5/2)LOG2?
7862        bgt.w           TANHBORS                # yes
7863
7864#--THIS IS THE USUAL CASE
7865#--Y = 2|X|, Z = EXPM1(Y), TANH(X) = SIGN(X) * Z / (Z+2).
7866
7867        mov.l           X(%a6),%d1
7868        mov.l           %d1,SGN(%a6)
7869        and.l           &0x7FFF0000,%d1
7870        add.l           &0x00010000,%d1         # EXPONENT OF 2|X|
7871        mov.l           %d1,X(%a6)
7872        and.l           &0x80000000,SGN(%a6)
7873        fmov.x          X(%a6),%fp0             # FP0 IS Y = 2|X|
7874
7875        mov.l           %d0,-(%sp)
7876        clr.l           %d0
7877        fmovm.x         &0x1,-(%sp)             # save Y on stack
7878        lea             (%sp),%a0               # pass ptr to Y
7879        bsr             setoxm1                 # FP0 IS Z = EXPM1(Y)
7880        add.l           &0xc,%sp                # clear Y from stack
7881        mov.l           (%sp)+,%d0
7882
7883        fmov.x          %fp0,%fp1
7884        fadd.s          &0x40000000,%fp1        # Z+2
7885        mov.l           SGN(%a6),%d1
7886        fmov.x          %fp1,V(%a6)
7887        eor.l           %d1,V(%a6)
7888
7889        fmov.l          %d0,%fpcr               # restore users round prec,mode
7890        fdiv.x          V(%a6),%fp0
7891        bra             t_inx2
7892
7893TANHBORS:
7894        cmp.l           %d1,&0x3FFF8000
7895        blt.w           TANHSM
7896
7897        cmp.l           %d1,&0x40048AA1
7898        bgt.w           TANHHUGE
7899
7900#-- (5/2) LOG2 < |X| < 50 LOG2,
7901#--TANH(X) = 1 - (2/[EXP(2X)+1]). LET Y = 2|X|, SGN = SIGN(X),
7902#--TANH(X) = SGN -      SGN*2/[EXP(Y)+1].
7903
7904        mov.l           X(%a6),%d1
7905        mov.l           %d1,SGN(%a6)
7906        and.l           &0x7FFF0000,%d1
7907        add.l           &0x00010000,%d1         # EXPO OF 2|X|
7908        mov.l           %d1,X(%a6)              # Y = 2|X|
7909        and.l           &0x80000000,SGN(%a6)
7910        mov.l           SGN(%a6),%d1
7911        fmov.x          X(%a6),%fp0             # Y = 2|X|
7912
7913        mov.l           %d0,-(%sp)
7914        clr.l           %d0
7915        fmovm.x         &0x01,-(%sp)            # save Y on stack
7916        lea             (%sp),%a0               # pass ptr to Y
7917        bsr             setox                   # FP0 IS EXP(Y)
7918        add.l           &0xc,%sp                # clear Y from stack
7919        mov.l           (%sp)+,%d0
7920        mov.l           SGN(%a6),%d1
7921        fadd.s          &0x3F800000,%fp0        # EXP(Y)+1
7922
7923        eor.l           &0xC0000000,%d1         # -SIGN(X)*2
7924        fmov.s          %d1,%fp1                # -SIGN(X)*2 IN SGL FMT
7925        fdiv.x          %fp0,%fp1               # -SIGN(X)2 / [EXP(Y)+1 ]
7926
7927        mov.l           SGN(%a6),%d1
7928        or.l            &0x3F800000,%d1         # SGN
7929        fmov.s          %d1,%fp0                # SGN IN SGL FMT
7930
7931        fmov.l          %d0,%fpcr               # restore users round prec,mode
7932        mov.b           &FADD_OP,%d1            # last inst is ADD
7933        fadd.x          %fp1,%fp0
7934        bra             t_inx2
7935
7936TANHSM:
7937        fmov.l          %d0,%fpcr               # restore users round prec,mode
7938        mov.b           &FMOV_OP,%d1            # last inst is MOVE
7939        fmov.x          X(%a6),%fp0             # last inst - possible exception set
7940        bra             t_catch
7941
7942#---RETURN SGN(X) - SGN(X)EPS
7943TANHHUGE:
7944        mov.l           X(%a6),%d1
7945        and.l           &0x80000000,%d1
7946        or.l            &0x3F800000,%d1
7947        fmov.s          %d1,%fp0
7948        and.l           &0x80000000,%d1
7949        eor.l           &0x80800000,%d1         # -SIGN(X)*EPS
7950
7951        fmov.l          %d0,%fpcr               # restore users round prec,mode
7952        fadd.s          %d1,%fp0
7953        bra             t_inx2
7954
7955        global          stanhd
7956#--TANH(X) = X FOR DENORMALIZED X
7957stanhd:
7958        bra             t_extdnrm
7959
7960#########################################################################
7961# slogn():    computes the natural logarithm of a normalized input      #
7962# slognd():   computes the natural logarithm of a denormalized input    #
7963# slognp1():  computes the log(1+X) of a normalized input               #
7964# slognp1d(): computes the log(1+X) of a denormalized input             #
7965#                                                                       #
7966# INPUT *************************************************************** #
7967#       a0 = pointer to extended precision input                        #
7968#       d0 = round precision,mode                                       #
7969#                                                                       #
7970# OUTPUT ************************************************************** #
7971#       fp0 = log(X) or log(1+X)                                        #
7972#                                                                       #
7973# ACCURACY and MONOTONICITY ******************************************* #
7974#       The returned result is within 2 ulps in 64 significant bit,     #
7975#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
7976#       rounded to double precision. The result is provably monotonic   #
7977#       in double precision.                                            #
7978#                                                                       #
7979# ALGORITHM *********************************************************** #
7980#       LOGN:                                                           #
7981#       Step 1. If |X-1| < 1/16, approximate log(X) by an odd           #
7982#               polynomial in u, where u = 2(X-1)/(X+1). Otherwise,     #
7983#               move on to Step 2.                                      #
7984#                                                                       #
7985#       Step 2. X = 2**k * Y where 1 <= Y < 2. Define F to be the first #
7986#               seven significant bits of Y plus 2**(-7), i.e.          #
7987#               F = 1.xxxxxx1 in base 2 where the six "x" match those   #
7988#               of Y. Note that |Y-F| <= 2**(-7).                       #
7989#                                                                       #
7990#       Step 3. Define u = (Y-F)/F. Approximate log(1+u) by a           #
7991#               polynomial in u, log(1+u) = poly.                       #
7992#                                                                       #
7993#       Step 4. Reconstruct                                             #
7994#               log(X) = log( 2**k * Y ) = k*log(2) + log(F) + log(1+u) #
7995#               by k*log(2) + (log(F) + poly). The values of log(F) are #
7996#               calculated beforehand and stored in the program.        #
7997#                                                                       #
7998#       lognp1:                                                         #
7999#       Step 1: If |X| < 1/16, approximate log(1+X) by an odd           #
8000#               polynomial in u where u = 2X/(2+X). Otherwise, move on  #

8001#               to Step 2.                                              #
8002#                                                                       #
8003#       Step 2: Let 1+X = 2**k * Y, where 1 <= Y < 2. Define F as done  #
8004#               in Step 2 of the algorithm for LOGN and compute         #
8005#               log(1+X) as k*log(2) + log(F) + poly where poly         #
8006#               approximates log(1+u), u = (Y-F)/F.                     #
8007#                                                                       #
8008#       Implementation Notes:                                           #
8009#       Note 1. There are 64 different possible values for F, thus 64   #
8010#               log(F)'s need to be tabulated. Moreover, the values of  #
8011#               1/F are also tabulated so that the division in (Y-F)/F  #
8012#               can be performed by a multiplication.                   #
8013#                                                                       #
8014#       Note 2. In Step 2 of lognp1, in order to preserved accuracy,    #
8015#               the value Y-F has to be calculated carefully when       #
8016#               1/2 <= X < 3/2.                                         #
8017#                                                                       #
8018#       Note 3. To fully exploit the pipeline, polynomials are usually  #
8019#               separated into two parts evaluated independently before #
8020#               being added up.                                         #
8021#                                                                       #
8022#########################################################################
8023LOGOF2:
8024        long            0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
8025
8026one:
8027        long            0x3F800000
8028zero:
8029        long            0x00000000
8030infty:
8031        long            0x7F800000
8032negone:
8033        long            0xBF800000
8034
8035LOGA6:
8036        long            0x3FC2499A,0xB5E4040B
8037LOGA5:
8038        long            0xBFC555B5,0x848CB7DB
8039
8040LOGA4:
8041        long            0x3FC99999,0x987D8730
8042LOGA3:
8043        long            0xBFCFFFFF,0xFF6F7E97
8044
8045LOGA2:
8046        long            0x3FD55555,0x555555A4
8047LOGA1:
8048        long            0xBFE00000,0x00000008
8049
8050LOGB5:
8051        long            0x3F175496,0xADD7DAD6
8052LOGB4:
8053        long            0x3F3C71C2,0xFE80C7E0
8054
8055LOGB3:
8056        long            0x3F624924,0x928BCCFF
8057LOGB2:
8058        long            0x3F899999,0x999995EC
8059
8060LOGB1:
8061        long            0x3FB55555,0x55555555
8062TWO:
8063        long            0x40000000,0x00000000
8064
8065LTHOLD:
8066        long            0x3f990000,0x80000000,0x00000000,0x00000000
8067
8068LOGTBL:
8069        long            0x3FFE0000,0xFE03F80F,0xE03F80FE,0x00000000
8070        long            0x3FF70000,0xFF015358,0x833C47E2,0x00000000
8071        long            0x3FFE0000,0xFA232CF2,0x52138AC0,0x00000000
8072        long            0x3FF90000,0xBDC8D83E,0xAD88D549,0x00000000
8073        long            0x3FFE0000,0xF6603D98,0x0F6603DA,0x00000000
8074        long            0x3FFA0000,0x9CF43DCF,0xF5EAFD48,0x00000000
8075        long            0x3FFE0000,0xF2B9D648,0x0F2B9D65,0x00000000
8076        long            0x3FFA0000,0xDA16EB88,0xCB8DF614,0x00000000
8077        long            0x3FFE0000,0xEF2EB71F,0xC4345238,0x00000000
8078        long            0x3FFB0000,0x8B29B775,0x1BD70743,0x00000000
8079        long            0x3FFE0000,0xEBBDB2A5,0xC1619C8C,0x00000000
8080        long            0x3FFB0000,0xA8D839F8,0x30C1FB49,0x00000000
8081        long            0x3FFE0000,0xE865AC7B,0x7603A197,0x00000000
8082        long            0x3FFB0000,0xC61A2EB1,0x8CD907AD,0x00000000
8083        long            0x3FFE0000,0xE525982A,0xF70C880E,0x00000000
8084        long            0x3FFB0000,0xE2F2A47A,0xDE3A18AF,0x00000000
8085        long            0x3FFE0000,0xE1FC780E,0x1FC780E2,0x00000000
8086        long            0x3FFB0000,0xFF64898E,0xDF55D551,0x00000000
8087        long            0x3FFE0000,0xDEE95C4C,0xA037BA57,0x00000000
8088        long            0x3FFC0000,0x8DB956A9,0x7B3D0148,0x00000000
8089        long            0x3FFE0000,0xDBEB61EE,0xD19C5958,0x00000000
8090        long            0x3FFC0000,0x9B8FE100,0xF47BA1DE,0x00000000
8091        long            0x3FFE0000,0xD901B203,0x6406C80E,0x00000000
8092        long            0x3FFC0000,0xA9372F1D,0x0DA1BD17,0x00000000
8093        long            0x3FFE0000,0xD62B80D6,0x2B80D62C,0x00000000
8094        long            0x3FFC0000,0xB6B07F38,0xCE90E46B,0x00000000
8095        long            0x3FFE0000,0xD3680D36,0x80D3680D,0x00000000
8096        long            0x3FFC0000,0xC3FD0329,0x06488481,0x00000000
8097        long            0x3FFE0000,0xD0B69FCB,0xD2580D0B,0x00000000
8098        long            0x3FFC0000,0xD11DE0FF,0x15AB18CA,0x00000000
8099        long            0x3FFE0000,0xCE168A77,0x25080CE1,0x00000000
8100        long            0x3FFC0000,0xDE1433A1,0x6C66B150,0x00000000
8101        long            0x3FFE0000,0xCB8727C0,0x65C393E0,0x00000000
8102        long            0x3FFC0000,0xEAE10B5A,0x7DDC8ADD,0x00000000
8103        long            0x3FFE0000,0xC907DA4E,0x871146AD,0x00000000
8104        long            0x3FFC0000,0xF7856E5E,0xE2C9B291,0x00000000
8105        long            0x3FFE0000,0xC6980C69,0x80C6980C,0x00000000
8106        long            0x3FFD0000,0x82012CA5,0xA68206D7,0x00000000
8107        long            0x3FFE0000,0xC4372F85,0x5D824CA6,0x00000000
8108        long            0x3FFD0000,0x882C5FCD,0x7256A8C5,0x00000000
8109        long            0x3FFE0000,0xC1E4BBD5,0x95F6E947,0x00000000
8110        long            0x3FFD0000,0x8E44C60B,0x4CCFD7DE,0x00000000
8111        long            0x3FFE0000,0xBFA02FE8,0x0BFA02FF,0x00000000
8112        long            0x3FFD0000,0x944AD09E,0xF4351AF6,0x00000000
8113        long            0x3FFE0000,0xBD691047,0x07661AA3,0x00000000
8114        long            0x3FFD0000,0x9A3EECD4,0xC3EAA6B2,0x00000000
8115        long            0x3FFE0000,0xBB3EE721,0xA54D880C,0x00000000
8116        long            0x3FFD0000,0xA0218434,0x353F1DE8,0x00000000
8117        long            0x3FFE0000,0xB92143FA,0x36F5E02E,0x00000000
8118        long            0x3FFD0000,0xA5F2FCAB,0xBBC506DA,0x00000000
8119        long            0x3FFE0000,0xB70FBB5A,0x19BE3659,0x00000000
8120        long            0x3FFD0000,0xABB3B8BA,0x2AD362A5,0x00000000
8121        long            0x3FFE0000,0xB509E68A,0x9B94821F,0x00000000
8122        long            0x3FFD0000,0xB1641795,0xCE3CA97B,0x00000000
8123        long            0x3FFE0000,0xB30F6352,0x8917C80B,0x00000000
8124        long            0x3FFD0000,0xB7047551,0x5D0F1C61,0x00000000
8125        long            0x3FFE0000,0xB11FD3B8,0x0B11FD3C,0x00000000
8126        long            0x3FFD0000,0xBC952AFE,0xEA3D13E1,0x00000000
8127        long            0x3FFE0000,0xAF3ADDC6,0x80AF3ADE,0x00000000
8128        long            0x3FFD0000,0xC2168ED0,0xF458BA4A,0x00000000
8129        long            0x3FFE0000,0xAD602B58,0x0AD602B6,0x00000000
8130        long            0x3FFD0000,0xC788F439,0xB3163BF1,0x00000000
8131        long            0x3FFE0000,0xAB8F69E2,0x8359CD11,0x00000000
8132        long            0x3FFD0000,0xCCECAC08,0xBF04565D,0x00000000
8133        long            0x3FFE0000,0xA9C84A47,0xA07F5638,0x00000000
8134        long            0x3FFD0000,0xD2420487,0x2DD85160,0x00000000
8135        long            0x3FFE0000,0xA80A80A8,0x0A80A80B,0x00000000
8136        long            0x3FFD0000,0xD7894992,0x3BC3588A,0x00000000
8137        long            0x3FFE0000,0xA655C439,0x2D7B73A8,0x00000000
8138        long            0x3FFD0000,0xDCC2C4B4,0x9887DACC,0x00000000
8139        long            0x3FFE0000,0xA4A9CF1D,0x96833751,0x00000000
8140        long            0x3FFD0000,0xE1EEBD3E,0x6D6A6B9E,0x00000000
8141        long            0x3FFE0000,0xA3065E3F,0xAE7CD0E0,0x00000000
8142        long            0x3FFD0000,0xE70D785C,0x2F9F5BDC,0x00000000
8143        long            0x3FFE0000,0xA16B312E,0xA8FC377D,0x00000000
8144        long            0x3FFD0000,0xEC1F392C,0x5179F283,0x00000000
8145        long            0x3FFE0000,0x9FD809FD,0x809FD80A,0x00000000
8146        long            0x3FFD0000,0xF12440D3,0xE36130E6,0x00000000
8147        long            0x3FFE0000,0x9E4CAD23,0xDD5F3A20,0x00000000
8148        long            0x3FFD0000,0xF61CCE92,0x346600BB,0x00000000
8149        long            0x3FFE0000,0x9CC8E160,0xC3FB19B9,0x00000000
8150        long            0x3FFD0000,0xFB091FD3,0x8145630A,0x00000000
8151        long            0x3FFE0000,0x9B4C6F9E,0xF03A3CAA,0x00000000
8152        long            0x3FFD0000,0xFFE97042,0xBFA4C2AD,0x00000000
8153        long            0x3FFE0000,0x99D722DA,0xBDE58F06,0x00000000
8154        long            0x3FFE0000,0x825EFCED,0x49369330,0x00000000
8155        long            0x3FFE0000,0x9868C809,0x868C8098,0x00000000
8156        long            0x3FFE0000,0x84C37A7A,0xB9A905C9,0x00000000
8157        long            0x3FFE0000,0x97012E02,0x5C04B809,0x00000000
8158        long            0x3FFE0000,0x87224C2E,0x8E645FB7,0x00000000
8159        long            0x3FFE0000,0x95A02568,0x095A0257,0x00000000
8160        long            0x3FFE0000,0x897B8CAC,0x9F7DE298,0x00000000
8161        long            0x3FFE0000,0x94458094,0x45809446,0x00000000
8162        long            0x3FFE0000,0x8BCF55DE,0xC4CD05FE,0x00000000
8163        long            0x3FFE0000,0x92F11384,0x0497889C,0x00000000
8164        long            0x3FFE0000,0x8E1DC0FB,0x89E125E5,0x00000000
8165        long            0x3FFE0000,0x91A2B3C4,0xD5E6F809,0x00000000
8166        long            0x3FFE0000,0x9066E68C,0x955B6C9B,0x00000000
8167        long            0x3FFE0000,0x905A3863,0x3E06C43B,0x00000000
8168        long            0x3FFE0000,0x92AADE74,0xC7BE59E0,0x00000000
8169        long            0x3FFE0000,0x8F1779D9,0xFDC3A219,0x00000000
8170        long            0x3FFE0000,0x94E9BFF6,0x15845643,0x00000000
8171        long            0x3FFE0000,0x8DDA5202,0x37694809,0x00000000
8172        long            0x3FFE0000,0x9723A1B7,0x20134203,0x00000000
8173        long            0x3FFE0000,0x8CA29C04,0x6514E023,0x00000000
8174        long            0x3FFE0000,0x995899C8,0x90EB8990,0x00000000
8175        long            0x3FFE0000,0x8B70344A,0x139BC75A,0x00000000
8176        long            0x3FFE0000,0x9B88BDAA,0x3A3DAE2F,0x00000000
8177        long            0x3FFE0000,0x8A42F870,0x5669DB46,0x00000000
8178        long            0x3FFE0000,0x9DB4224F,0xFFE1157C,0x00000000
8179        long            0x3FFE0000,0x891AC73A,0xE9819B50,0x00000000
8180        long            0x3FFE0000,0x9FDADC26,0x8B7A12DA,0x00000000
8181        long            0x3FFE0000,0x87F78087,0xF78087F8,0x00000000
8182        long            0x3FFE0000,0xA1FCFF17,0xCE733BD4,0x00000000
8183        long            0x3FFE0000,0x86D90544,0x7A34ACC6,0x00000000
8184        long            0x3FFE0000,0xA41A9E8F,0x5446FB9F,0x00000000
8185        long            0x3FFE0000,0x85BF3761,0x2CEE3C9B,0x00000000
8186        long            0x3FFE0000,0xA633CD7E,0x6771CD8B,0x00000000
8187        long            0x3FFE0000,0x84A9F9C8,0x084A9F9D,0x00000000
8188        long            0x3FFE0000,0xA8489E60,0x0B435A5E,0x00000000
8189        long            0x3FFE0000,0x83993052,0x3FBE3368,0x00000000
8190        long            0x3FFE0000,0xAA59233C,0xCCA4BD49,0x00000000
8191        long            0x3FFE0000,0x828CBFBE,0xB9A020A3,0x00000000
8192        long            0x3FFE0000,0xAC656DAE,0x6BCC4985,0x00000000
8193        long            0x3FFE0000,0x81848DA8,0xFAF0D277,0x00000000
8194        long            0x3FFE0000,0xAE6D8EE3,0x60BB2468,0x00000000
8195        long            0x3FFE0000,0x80808080,0x80808081,0x00000000
8196        long            0x3FFE0000,0xB07197A2,0x3C46C654,0x00000000
8197
8198        set             ADJK,L_SCR1
8199
8200        set             X,FP_SCR0
8201        set             XDCARE,X+2
8202        set             XFRAC,X+4
8203
8204        set             F,FP_SCR1
8205        set             FFRAC,F+4
8206
8207        set             KLOG2,FP_SCR0
8208
8209        set             SAVEU,FP_SCR0
8210
8211        global          slogn
8212#--ENTRY POINT FOR LOG(X) FOR X FINITE, NON-ZERO, NOT NAN'S
8213slogn:
8214        fmov.x          (%a0),%fp0              # LOAD INPUT
8215        mov.l           &0x00000000,ADJK(%a6)
8216
8217LOGBGN:
8218#--FPCR SAVED AND CLEARED, INPUT IS 2^(ADJK)*FP0, FP0 CONTAINS
8219#--A FINITE, NON-ZERO, NORMALIZED NUMBER.
8220
8221        mov.l           (%a0),%d1
8222        mov.w           4(%a0),%d1
8223
8224        mov.l           (%a0),X(%a6)
8225        mov.l           4(%a0),X+4(%a6)
8226        mov.l           8(%a0),X+8(%a6)
8227
8228        cmp.l           %d1,&0                  # CHECK IF X IS NEGATIVE
8229        blt.w           LOGNEG                  # LOG OF NEGATIVE ARGUMENT IS INVALID
8230# X IS POSITIVE, CHECK IF X IS NEAR 1
8231        cmp.l           %d1,&0x3ffef07d         # IS X < 15/16?
8232        blt.b           LOGMAIN                 # YES
8233        cmp.l           %d1,&0x3fff8841         # IS X > 17/16?
8234        ble.w           LOGNEAR1                # NO
8235
8236LOGMAIN:
8237#--THIS SHOULD BE THE USUAL CASE, X NOT VERY CLOSE TO 1
8238
8239#--X = 2^(K) * Y, 1 <= Y < 2. THUS, Y = 1.XXXXXXXX....XX IN BINARY.
8240#--WE DEFINE F = 1.XXXXXX1, I.E. FIRST 7 BITS OF Y AND ATTACH A 1.
8241#--THE IDEA IS THAT LOG(X) = K*LOG2 + LOG(Y)
8242#--                      = K*LOG2 + LOG(F) + LOG(1 + (Y-F)/F).
8243#--NOTE THAT U = (Y-F)/F IS VERY SMALL AND THUS APPROXIMATING
8244#--LOG(1+U) CAN BE VERY EFFICIENT.
8245#--ALSO NOTE THAT THE VALUE 1/F IS STORED IN A TABLE SO THAT NO
8246#--DIVISION IS NEEDED TO CALCULATE (Y-F)/F.
8247
8248#--GET K, Y, F, AND ADDRESS OF 1/F.
8249        asr.l           &8,%d1
8250        asr.l           &8,%d1                  # SHIFTED 16 BITS, BIASED EXPO. OF X
8251        sub.l           &0x3FFF,%d1             # THIS IS K
8252        add.l           ADJK(%a6),%d1           # ADJUST K, ORIGINAL INPUT MAY BE  DENORM.
8253        lea             LOGTBL(%pc),%a0         # BASE ADDRESS OF 1/F AND LOG(F)
8254        fmov.l          %d1,%fp1                # CONVERT K TO FLOATING-POINT FORMAT
8255
8256#--WHILE THE CONVERSION IS GOING ON, WE GET F AND ADDRESS OF 1/F
8257        mov.l           &0x3FFF0000,X(%a6)      # X IS NOW Y, I.E. 2^(-K)*X
8258        mov.l           XFRAC(%a6),FFRAC(%a6)
8259        and.l           &0xFE000000,FFRAC(%a6)  # FIRST 7 BITS OF Y
8260        or.l            &0x01000000,FFRAC(%a6)  # GET F: ATTACH A 1 AT THE EIGHTH BIT
8261        mov.l           FFRAC(%a6),%d1  # READY TO GET ADDRESS OF 1/F
8262        and.l           &0x7E000000,%d1
8263        asr.l           &8,%d1
8264        asr.l           &8,%d1
8265        asr.l           &4,%d1                  # SHIFTED 20, D0 IS THE DISPLACEMENT
8266        add.l           %d1,%a0                 # A0 IS THE ADDRESS FOR 1/F
8267
8268        fmov.x          X(%a6),%fp0
8269        mov.l           &0x3fff0000,F(%a6)
8270        clr.l           F+8(%a6)
8271        fsub.x          F(%a6),%fp0             # Y-F
8272        fmovm.x         &0xc,-(%sp)             # SAVE FP2-3 WHILE FP0 IS NOT READY
8273#--SUMMARY: FP0 IS Y-F, A0 IS ADDRESS OF 1/F, FP1 IS K
8274#--REGISTERS SAVED: FPCR, FP1, FP2
8275
8276LP1CONT1:
8277#--AN RE-ENTRY POINT FOR LOGNP1
8278        fmul.x          (%a0),%fp0              # FP0 IS U = (Y-F)/F
8279        fmul.x          LOGOF2(%pc),%fp1        # GET K*LOG2 WHILE FP0 IS NOT READY
8280        fmov.x          %fp0,%fp2
8281        fmul.x          %fp2,%fp2               # FP2 IS V=U*U
8282        fmov.x          %fp1,KLOG2(%a6)         # PUT K*LOG2 IN MEMEORY, FREE FP1
8283
8284#--LOG(1+U) IS APPROXIMATED BY
8285#--U + V*(A1+U*(A2+U*(A3+U*(A4+U*(A5+U*A6))))) WHICH IS
8286#--[U + V*(A1+V*(A3+V*A5))]  +  [U*V*(A2+V*(A4+V*A6))]
8287
8288        fmov.x          %fp2,%fp3
8289        fmov.x          %fp2,%fp1
8290
8291        fmul.d          LOGA6(%pc),%fp1         # V*A6
8292        fmul.d          LOGA5(%pc),%fp2         # V*A5
8293
8294        fadd.d          LOGA4(%pc),%fp1         # A4+V*A6
8295        fadd.d          LOGA3(%pc),%fp2         # A3+V*A5
8296
8297        fmul.x          %fp3,%fp1               # V*(A4+V*A6)
8298        fmul.x          %fp3,%fp2               # V*(A3+V*A5)
8299
8300        fadd.d          LOGA2(%pc),%fp1         # A2+V*(A4+V*A6)
8301        fadd.d          LOGA1(%pc),%fp2         # A1+V*(A3+V*A5)
8302
8303        fmul.x          %fp3,%fp1               # V*(A2+V*(A4+V*A6))
8304        add.l           &16,%a0                 # ADDRESS OF LOG(F)
8305        fmul.x          %fp3,%fp2               # V*(A1+V*(A3+V*A5))
8306
8307        fmul.x          %fp0,%fp1               # U*V*(A2+V*(A4+V*A6))
8308        fadd.x          %fp2,%fp0               # U+V*(A1+V*(A3+V*A5))
8309
8310        fadd.x          (%a0),%fp1              # LOG(F)+U*V*(A2+V*(A4+V*A6))
8311        fmovm.x         (%sp)+,&0x30            # RESTORE FP2-3
8312        fadd.x          %fp1,%fp0               # FP0 IS LOG(F) + LOG(1+U)
8313
8314        fmov.l          %d0,%fpcr
8315        fadd.x          KLOG2(%a6),%fp0         # FINAL ADD
8316        bra             t_inx2
8317
8318
8319LOGNEAR1:
8320
8321# if the input is exactly equal to one, then exit through ld_pzero.
8322# if these 2 lines weren't here, the correct answer would be returned
8323# but the INEX2 bit would be set.
8324        fcmp.b          %fp0,&0x1               # is it equal to one?
8325        fbeq.l          ld_pzero                # yes
8326
8327#--REGISTERS SAVED: FPCR, FP1. FP0 CONTAINS THE INPUT.
8328        fmov.x          %fp0,%fp1
8329        fsub.s          one(%pc),%fp1           # FP1 IS X-1
8330        fadd.s          one(%pc),%fp0           # FP0 IS X+1
8331        fadd.x          %fp1,%fp1               # FP1 IS 2(X-1)
8332#--LOG(X) = LOG(1+U/2)-LOG(1-U/2) WHICH IS AN ODD POLYNOMIAL
8333#--IN U, U = 2(X-1)/(X+1) = FP1/FP0
8334
8335LP1CONT2:
8336#--THIS IS AN RE-ENTRY POINT FOR LOGNP1
8337        fdiv.x          %fp0,%fp1               # FP1 IS U
8338        fmovm.x         &0xc,-(%sp)             # SAVE FP2-3
8339#--REGISTERS SAVED ARE NOW FPCR,FP1,FP2,FP3
8340#--LET V=U*U, W=V*V, CALCULATE
8341#--U + U*V*(B1 + V*(B2 + V*(B3 + V*(B4 + V*B5)))) BY
8342#--U + U*V*(  [B1 + W*(B3 + W*B5)]  +  [V*(B2 + W*B4)]  )
8343        fmov.x          %fp1,%fp0
8344        fmul.x          %fp0,%fp0               # FP0 IS V
8345        fmov.x          %fp1,SAVEU(%a6)         # STORE U IN MEMORY, FREE FP1
8346        fmov.x          %fp0,%fp1
8347        fmul.x          %fp1,%fp1               # FP1 IS W
8348
8349        fmov.d          LOGB5(%pc),%fp3
8350        fmov.d          LOGB4(%pc),%fp2
8351
8352        fmul.x          %fp1,%fp3               # W*B5
8353        fmul.x          %fp1,%fp2               # W*B4
8354
8355        fadd.d          LOGB3(%pc),%fp3         # B3+W*B5
8356        fadd.d          LOGB2(%pc),%fp2         # B2+W*B4
8357
8358        fmul.x          %fp3,%fp1               # W*(B3+W*B5), FP3 RELEASED
8359
8360        fmul.x          %fp0,%fp2               # V*(B2+W*B4)
8361
8362        fadd.d          LOGB1(%pc),%fp1         # B1+W*(B3+W*B5)
8363        fmul.x          SAVEU(%a6),%fp0         # FP0 IS U*V
8364
8365        fadd.x          %fp2,%fp1               # B1+W*(B3+W*B5) + V*(B2+W*B4), FP2 RELEASED
8366        fmovm.x         (%sp)+,&0x30            # FP2-3 RESTORED
8367
8368        fmul.x          %fp1,%fp0               # U*V*( [B1+W*(B3+W*B5)] + [V*(B2+W*B4)] )
8369
8370        fmov.l          %d0,%fpcr
8371        fadd.x          SAVEU(%a6),%fp0
8372        bra             t_inx2
8373
8374#--REGISTERS SAVED FPCR. LOG(-VE) IS INVALID
8375LOGNEG:
8376        bra             t_operr
8377
8378        global          slognd
8379slognd:
8380#--ENTRY POINT FOR LOG(X) FOR DENORMALIZED INPUT
8381
8382        mov.l           &-100,ADJK(%a6)         # INPUT = 2^(ADJK) * FP0
8383
8384#----normalize the input value by left shifting k bits (k to be determined
8385#----below), adjusting exponent and storing -k to  ADJK
8386#----the value TWOTO100 is no longer needed.
8387#----Note that this code assumes the denormalized input is NON-ZERO.
8388
8389        movm.l          &0x3f00,-(%sp)          # save some registers  {d2-d7}
8390        mov.l           (%a0),%d3               # D3 is exponent of smallest norm. #
8391        mov.l           4(%a0),%d4
8392        mov.l           8(%a0),%d5              # (D4,D5) is (Hi_X,Lo_X)
8393        clr.l           %d2                     # D2 used for holding K
8394
8395        tst.l           %d4
8396        bne.b           Hi_not0
8397
8398Hi_0:
8399        mov.l           %d5,%d4
8400        clr.l           %d5
8401        mov.l           &32,%d2
8402        clr.l           %d6
8403        bfffo           %d4{&0:&32},%d6
8404        lsl.l           %d6,%d4
8405        add.l           %d6,%d2                 # (D3,D4,D5) is normalized
8406
8407        mov.l           %d3,X(%a6)
8408        mov.l           %d4,XFRAC(%a6)
8409        mov.l           %d5,XFRAC+4(%a6)
8410        neg.l           %d2
8411        mov.l           %d2,ADJK(%a6)
8412        fmov.x          X(%a6),%fp0
8413        movm.l          (%sp)+,&0xfc            # restore registers {d2-d7}
8414        lea             X(%a6),%a0
8415        bra.w           LOGBGN                  # begin regular log(X)
8416
8417Hi_not0:
8418        clr.l           %d6
8419        bfffo           %d4{&0:&32},%d6         # find first 1
8420        mov.l           %d6,%d2                 # get k
8421        lsl.l           %d6,%d4
8422        mov.l           %d5,%d7                 # a copy of D5
8423        lsl.l           %d6,%d5
8424        neg.l           %d6
8425        add.l           &32,%d6
8426        lsr.l           %d6,%d7
8427        or.l            %d7,%d4                 # (D3,D4,D5) normalized
8428
8429        mov.l           %d3,X(%a6)
8430        mov.l           %d4,XFRAC(%a6)
8431        mov.l           %d5,XFRAC+4(%a6)
8432        neg.l           %d2
8433        mov.l           %d2,ADJK(%a6)
8434        fmov.x          X(%a6),%fp0
8435        movm.l          (%sp)+,&0xfc            # restore registers {d2-d7}
8436        lea             X(%a6),%a0
8437        bra.w           LOGBGN                  # begin regular log(X)
8438
8439        global          slognp1
8440#--ENTRY POINT FOR LOG(1+X) FOR X FINITE, NON-ZERO, NOT NAN'S
8441slognp1:
8442        fmov.x          (%a0),%fp0              # LOAD INPUT
8443        fabs.x          %fp0                    # test magnitude
8444        fcmp.x          %fp0,LTHOLD(%pc)        # compare with min threshold
8445        fbgt.w          LP1REAL                 # if greater, continue
8446        fmov.l          %d0,%fpcr
8447        mov.b           &FMOV_OP,%d1            # last inst is MOVE
8448        fmov.x          (%a0),%fp0              # return signed argument
8449        bra             t_catch
8450
8451LP1REAL:
8452        fmov.x          (%a0),%fp0              # LOAD INPUT
8453        mov.l           &0x00000000,ADJK(%a6)
8454        fmov.x          %fp0,%fp1               # FP1 IS INPUT Z
8455        fadd.s          one(%pc),%fp0           # X := ROUND(1+Z)
8456        fmov.x          %fp0,X(%a6)
8457        mov.w           XFRAC(%a6),XDCARE(%a6)
8458        mov.l           X(%a6),%d1
8459        cmp.l           %d1,&0
8460        ble.w           LP1NEG0                 # LOG OF ZERO OR -VE
8461        cmp.l           %d1,&0x3ffe8000         # IS BOUNDS [1/2,3/2]?
8462        blt.w           LOGMAIN
8463        cmp.l           %d1,&0x3fffc000
8464        bgt.w           LOGMAIN
8465#--IF 1+Z > 3/2 OR 1+Z < 1/2, THEN X, WHICH IS ROUNDING 1+Z,
8466#--CONTAINS AT LEAST 63 BITS OF INFORMATION OF Z. IN THAT CASE,
8467#--SIMPLY INVOKE LOG(X) FOR LOG(1+Z).
8468
8469LP1NEAR1:
8470#--NEXT SEE IF EXP(-1/16) < X < EXP(1/16)
8471        cmp.l           %d1,&0x3ffef07d
8472        blt.w           LP1CARE
8473        cmp.l           %d1,&0x3fff8841
8474        bgt.w           LP1CARE
8475
8476LP1ONE16:
8477#--EXP(-1/16) < X < EXP(1/16). LOG(1+Z) = LOG(1+U/2) - LOG(1-U/2)
8478#--WHERE U = 2Z/(2+Z) = 2Z/(1+X).
8479        fadd.x          %fp1,%fp1               # FP1 IS 2Z
8480        fadd.s          one(%pc),%fp0           # FP0 IS 1+X
8481#--U = FP1/FP0
8482        bra.w           LP1CONT2
8483
8484LP1CARE:
8485#--HERE WE USE THE USUAL TABLE DRIVEN APPROACH. CARE HAS TO BE
8486#--TAKEN BECAUSE 1+Z CAN HAVE 67 BITS OF INFORMATION AND WE MUST
8487#--PRESERVE ALL THE INFORMATION. BECAUSE 1+Z IS IN [1/2,3/2],
8488#--THERE ARE ONLY TWO CASES.
8489#--CASE 1: 1+Z < 1, THEN K = -1 AND Y-F = (2-F) + 2Z
8490#--CASE 2: 1+Z > 1, THEN K = 0  AND Y-F = (1-F) + Z
8491#--ON RETURNING TO LP1CONT1, WE MUST HAVE K IN FP1, ADDRESS OF
8492#--(1/F) IN A0, Y-F IN FP0, AND FP2 SAVED.
8493
8494        mov.l           XFRAC(%a6),FFRAC(%a6)
8495        and.l           &0xFE000000,FFRAC(%a6)
8496        or.l            &0x01000000,FFRAC(%a6)  # F OBTAINED
8497        cmp.l           %d1,&0x3FFF8000         # SEE IF 1+Z > 1
8498        bge.b           KISZERO
8499
8500KISNEG1:
8501        fmov.s          TWO(%pc),%fp0
8502        mov.l           &0x3fff0000,F(%a6)
8503        clr.l           F+8(%a6)
8504        fsub.x          F(%a6),%fp0             # 2-F
8505        mov.l           FFRAC(%a6),%d1
8506        and.l           &0x7E000000,%d1
8507        asr.l           &8,%d1
8508        asr.l           &8,%d1
8509        asr.l           &4,%d1                  # D0 CONTAINS DISPLACEMENT FOR 1/F
8510        fadd.x          %fp1,%fp1               # GET 2Z
8511        fmovm.x         &0xc,-(%sp)             # SAVE FP2  {%fp2/%fp3}
8512        fadd.x          %fp1,%fp0               # FP0 IS Y-F = (2-F)+2Z
8513        lea             LOGTBL(%pc),%a0         # A0 IS ADDRESS OF 1/F
8514        add.l           %d1,%a0
8515        fmov.s          negone(%pc),%fp1        # FP1 IS K = -1
8516        bra.w           LP1CONT1
8517
8518KISZERO:
8519        fmov.s          one(%pc),%fp0
8520        mov.l           &0x3fff0000,F(%a6)
8521        clr.l           F+8(%a6)
8522        fsub.x          F(%a6),%fp0             # 1-F
8523        mov.l           FFRAC(%a6),%d1
8524        and.l           &0x7E000000,%d1
8525        asr.l           &8,%d1
8526        asr.l           &8,%d1
8527        asr.l           &4,%d1
8528        fadd.x          %fp1,%fp0               # FP0 IS Y-F
8529        fmovm.x         &0xc,-(%sp)             # FP2 SAVED {%fp2/%fp3}
8530        lea             LOGTBL(%pc),%a0
8531        add.l           %d1,%a0                 # A0 IS ADDRESS OF 1/F
8532        fmov.s          zero(%pc),%fp1          # FP1 IS K = 0
8533        bra.w           LP1CONT1
8534
8535LP1NEG0:
8536#--FPCR SAVED. D0 IS X IN COMPACT FORM.
8537        cmp.l           %d1,&0
8538        blt.b           LP1NEG
8539LP1ZERO:
8540        fmov.s          negone(%pc),%fp0
8541
8542        fmov.l          %d0,%fpcr
8543        bra             t_dz
8544
8545LP1NEG:
8546        fmov.s          zero(%pc),%fp0
8547
8548        fmov.l          %d0,%fpcr
8549        bra             t_operr
8550
8551        global          slognp1d
8552#--ENTRY POINT FOR LOG(1+Z) FOR DENORMALIZED INPUT
8553# Simply return the denorm
8554slognp1d:
8555        bra             t_extdnrm
8556
8557#########################################################################
8558# satanh():  computes the inverse hyperbolic tangent of a norm input    #
8559# satanhd(): computes the inverse hyperbolic tangent of a denorm input  #
8560#                                                                       #
8561# INPUT *************************************************************** #
8562#       a0 = pointer to extended precision input                        #
8563#       d0 = round precision,mode                                       #
8564#                                                                       #
8565# OUTPUT ************************************************************** #
8566#       fp0 = arctanh(X)                                                #
8567#                                                                       #
8568# ACCURACY and MONOTONICITY ******************************************* #
8569#       The returned result is within 3 ulps in 64 significant bit,     #
8570#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
8571#       rounded to double precision. The result is provably monotonic   #
8572#       in double precision.                                            #
8573#                                                                       #
8574# ALGORITHM *********************************************************** #
8575#                                                                       #
8576#       ATANH                                                           #
8577#       1. If |X| >= 1, go to 3.                                        #
8578#                                                                       #
8579#       2. (|X| < 1) Calculate atanh(X) by                              #
8580#               sgn := sign(X)                                          #
8581#               y := |X|                                                #
8582#               z := 2y/(1-y)                                           #
8583#               atanh(X) := sgn * (1/2) * logp1(z)                      #
8584#               Exit.                                                   #
8585#                                                                       #
8586#       3. If |X| > 1, go to 5.                                         #
8587#                                                                       #
8588#       4. (|X| = 1) Generate infinity with an appropriate sign and     #
8589#               divide-by-zero by                                       #
8590#               sgn := sign(X)                                          #
8591#               atan(X) := sgn / (+0).                                  #
8592#               Exit.                                                   #
8593#                                                                       #
8594#       5. (|X| > 1) Generate an invalid operation by 0 * infinity.     #
8595#               Exit.                                                   #
8596#                                                                       #
8597#########################################################################
8598
8599        global          satanh
8600satanh:
8601        mov.l           (%a0),%d1
8602        mov.w           4(%a0),%d1
8603        and.l           &0x7FFFFFFF,%d1
8604        cmp.l           %d1,&0x3FFF8000
8605        bge.b           ATANHBIG
8606
8607#--THIS IS THE USUAL CASE, |X| < 1
8608#--Y = |X|, Z = 2Y/(1-Y), ATANH(X) = SIGN(X) * (1/2) * LOG1P(Z).
8609
8610        fabs.x          (%a0),%fp0              # Y = |X|
8611        fmov.x          %fp0,%fp1
8612        fneg.x          %fp1                    # -Y
8613        fadd.x          %fp0,%fp0               # 2Y
8614        fadd.s          &0x3F800000,%fp1        # 1-Y
8615        fdiv.x          %fp1,%fp0               # 2Y/(1-Y)
8616        mov.l           (%a0),%d1
8617        and.l           &0x80000000,%d1
8618        or.l            &0x3F000000,%d1         # SIGN(X)*HALF
8619        mov.l           %d1,-(%sp)
8620
8621        mov.l           %d0,-(%sp)              # save rnd prec,mode
8622        clr.l           %d0                     # pass ext prec,RN
8623        fmovm.x         &0x01,-(%sp)            # save Z on stack
8624        lea             (%sp),%a0               # pass ptr to Z
8625        bsr             slognp1                 # LOG1P(Z)
8626        add.l           &0xc,%sp                # clear Z from stack
8627
8628        mov.l           (%sp)+,%d0              # fetch old prec,mode
8629        fmov.l          %d0,%fpcr               # load it
8630        mov.b           &FMUL_OP,%d1            # last inst is MUL
8631        fmul.s          (%sp)+,%fp0
8632        bra             t_catch
8633
8634ATANHBIG:
8635        fabs.x          (%a0),%fp0              # |X|
8636        fcmp.s          %fp0,&0x3F800000
8637        fbgt            t_operr
8638        bra             t_dz
8639
8640        global          satanhd
8641#--ATANH(X) = X FOR DENORMALIZED X
8642satanhd:
8643        bra             t_extdnrm
8644
8645#########################################################################
8646# slog10():  computes the base-10 logarithm of a normalized input       #
8647# slog10d(): computes the base-10 logarithm of a denormalized input     #
8648# slog2():   computes the base-2 logarithm of a normalized input        #
8649# slog2d():  computes the base-2 logarithm of a denormalized input      #
8650#                                                                       #
8651# INPUT *************************************************************** #
8652#       a0 = pointer to extended precision input                        #
8653#       d0 = round precision,mode                                       #
8654#                                                                       #
8655# OUTPUT ************************************************************** #
8656#       fp0 = log_10(X) or log_2(X)                                     #
8657#                                                                       #
8658# ACCURACY and MONOTONICITY ******************************************* #
8659#       The returned result is within 1.7 ulps in 64 significant bit,   #
8660#       i.e. within 0.5003 ulp to 53 bits if the result is subsequently #
8661#       rounded to double precision. The result is provably monotonic   #
8662#       in double precision.                                            #
8663#                                                                       #
8664# ALGORITHM *********************************************************** #
8665#                                                                       #
8666#       slog10d:                                                        #
8667#                                                                       #
8668#       Step 0. If X < 0, create a NaN and raise the invalid operation  #
8669#               flag. Otherwise, save FPCR in D1; set FpCR to default.  #
8670#       Notes:  Default means round-to-nearest mode, no floating-point  #
8671#               traps, and precision control = double extended.         #
8672#                                                                       #
8673#       Step 1. Call slognd to obtain Y = log(X), the natural log of X. #
8674#       Notes:  Even if X is denormalized, log(X) is always normalized. #
8675#                                                                       #
8676#       Step 2.  Compute log_10(X) = log(X) * (1/log(10)).              #
8677#            2.1 Restore the user FPCR                                  #
8678#            2.2 Return ans := Y * INV_L10.                             #
8679#                                                                       #
8680#       slog10:                                                         #
8681#                                                                       #
8682#       Step 0. If X < 0, create a NaN and raise the invalid operation  #
8683#               flag. Otherwise, save FPCR in D1; set FpCR to default.  #
8684#       Notes:  Default means round-to-nearest mode, no floating-point  #
8685#               traps, and precision control = double extended.         #
8686#                                                                       #
8687#       Step 1. Call sLogN to obtain Y = log(X), the natural log of X.  #
8688#                                                                       #
8689#       Step 2.   Compute log_10(X) = log(X) * (1/log(10)).             #
8690#            2.1  Restore the user FPCR                                 #
8691#            2.2  Return ans := Y * INV_L10.                            #
8692#                                                                       #
8693#       sLog2d:                                                         #
8694#                                                                       #
8695#       Step 0. If X < 0, create a NaN and raise the invalid operation  #
8696#               flag. Otherwise, save FPCR in D1; set FpCR to default.  #
8697#       Notes:  Default means round-to-nearest mode, no floating-point  #
8698#               traps, and precision control = double extended.         #
8699#                                                                       #
8700#       Step 1. Call slognd to obtain Y = log(X), the natural log of X. #
8701#       Notes:  Even if X is denormalized, log(X) is always normalized. #
8702#                                                                       #
8703#       Step 2.   Compute log_10(X) = log(X) * (1/log(2)).              #
8704#            2.1  Restore the user FPCR                                 #
8705#            2.2  Return ans := Y * INV_L2.                             #
8706#                                                                       #
8707#       sLog2:                                                          #
8708#                                                                       #
8709#       Step 0. If X < 0, create a NaN and raise the invalid operation  #
8710#               flag. Otherwise, save FPCR in D1; set FpCR to default.  #
8711#       Notes:  Default means round-to-nearest mode, no floating-point  #
8712#               traps, and precision control = double extended.         #
8713#                                                                       #
8714#       Step 1. If X is not an integer power of two, i.e., X != 2^k,    #
8715#               go to Step 3.                                           #
8716#                                                                       #
8717#       Step 2.   Return k.                                             #
8718#            2.1  Get integer k, X = 2^k.                               #
8719#            2.2  Restore the user FPCR.                                #
8720#            2.3  Return ans := convert-to-double-extended(k).          #
8721#                                                                       #
8722#       Step 3. Call sLogN to obtain Y = log(X), the natural log of X.  #
8723#                                                                       #
8724#       Step 4.   Compute log_2(X) = log(X) * (1/log(2)).               #
8725#            4.1  Restore the user FPCR                                 #
8726#            4.2  Return ans := Y * INV_L2.                             #
8727#                                                                       #
8728#########################################################################
8729
8730INV_L10:
8731        long            0x3FFD0000,0xDE5BD8A9,0x37287195,0x00000000
8732
8733INV_L2:
8734        long            0x3FFF0000,0xB8AA3B29,0x5C17F0BC,0x00000000
8735
8736        global          slog10
8737#--entry point for Log10(X), X is normalized
8738slog10:
8739        fmov.b          &0x1,%fp0
8740        fcmp.x          %fp0,(%a0)              # if operand == 1,
8741        fbeq.l          ld_pzero                # return an EXACT zero
8742
8743        mov.l           (%a0),%d1
8744        blt.w           invalid
8745        mov.l           %d0,-(%sp)
8746        clr.l           %d0
8747        bsr             slogn                   # log(X), X normal.
8748        fmov.l          (%sp)+,%fpcr
8749        fmul.x          INV_L10(%pc),%fp0
8750        bra             t_inx2
8751
8752        global          slog10d
8753#--entry point for Log10(X), X is denormalized
8754slog10d:
8755        mov.l           (%a0),%d1
8756        blt.w           invalid
8757        mov.l           %d0,-(%sp)
8758        clr.l           %d0
8759        bsr             slognd                  # log(X), X denorm.
8760        fmov.l          (%sp)+,%fpcr
8761        fmul.x          INV_L10(%pc),%fp0
8762        bra             t_minx2
8763
8764        global          slog2
8765#--entry point for Log2(X), X is normalized
8766slog2:
8767        mov.l           (%a0),%d1
8768        blt.w           invalid
8769
8770        mov.l           8(%a0),%d1
8771        bne.b           continue                # X is not 2^k
8772
8773        mov.l           4(%a0),%d1
8774        and.l           &0x7FFFFFFF,%d1
8775        bne.b           continue
8776
8777#--X = 2^k.
8778        mov.w           (%a0),%d1
8779        and.l           &0x00007FFF,%d1
8780        sub.l           &0x3FFF,%d1
8781        beq.l           ld_pzero
8782        fmov.l          %d0,%fpcr
8783        fmov.l          %d1,%fp0
8784        bra             t_inx2
8785
8786continue:
8787        mov.l           %d0,-(%sp)
8788        clr.l           %d0
8789        bsr             slogn                   # log(X), X normal.
8790        fmov.l          (%sp)+,%fpcr
8791        fmul.x          INV_L2(%pc),%fp0
8792        bra             t_inx2
8793
8794invalid:
8795        bra             t_operr
8796
8797        global          slog2d
8798#--entry point for Log2(X), X is denormalized
8799slog2d:
8800        mov.l           (%a0),%d1
8801        blt.w           invalid
8802        mov.l           %d0,-(%sp)
8803        clr.l           %d0
8804        bsr             slognd                  # log(X), X denorm.
8805        fmov.l          (%sp)+,%fpcr
8806        fmul.x          INV_L2(%pc),%fp0
8807        bra             t_minx2
8808
8809#########################################################################
8810# stwotox():  computes 2**X for a normalized input                      #
8811# stwotoxd(): computes 2**X for a denormalized input                    #
8812# stentox():  computes 10**X for a normalized input                     #
8813# stentoxd(): computes 10**X for a denormalized input                   #
8814#                                                                       #
8815# INPUT *************************************************************** #
8816#       a0 = pointer to extended precision input                        #
8817#       d0 = round precision,mode                                       #
8818#                                                                       #
8819# OUTPUT ************************************************************** #
8820#       fp0 = 2**X or 10**X                                             #
8821#                                                                       #
8822# ACCURACY and MONOTONICITY ******************************************* #
8823#       The returned result is within 2 ulps in 64 significant bit,     #
8824#       i.e. within 0.5001 ulp to 53 bits if the result is subsequently #
8825#       rounded to double precision. The result is provably monotonic   #
8826#       in double precision.                                            #
8827#                                                                       #
8828# ALGORITHM *********************************************************** #
8829#                                                                       #
8830#       twotox                                                          #
8831#       1. If |X| > 16480, go to ExpBig.                                #
8832#                                                                       #
8833#       2. If |X| < 2**(-70), go to ExpSm.                              #
8834#                                                                       #
8835#       3. Decompose X as X = N/64 + r where |r| <= 1/128. Furthermore  #
8836#               decompose N as                                          #
8837#                N = 64(M + M') + j,  j = 0,1,2,...,63.                 #
8838#                                                                       #
8839#       4. Overwrite r := r * log2. Then                                #
8840#               2**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).           #
8841#               Go to expr to compute that expression.                  #
8842#                                                                       #
8843#       tentox                                                          #
8844#       1. If |X| > 16480*log_10(2) (base 10 log of 2), go to ExpBig.   #
8845#                                                                       #
8846#       2. If |X| < 2**(-70), go to ExpSm.                              #
8847#                                                                       #
8848#       3. Set y := X*log_2(10)*64 (base 2 log of 10). Set              #
8849#               N := round-to-int(y). Decompose N as                    #
8850#                N = 64(M + M') + j,  j = 0,1,2,...,63.                 #
8851#                                                                       #
8852#       4. Define r as                                                  #
8853#               r := ((X - N*L1)-N*L2) * L10                            #
8854#               where L1, L2 are the leading and trailing parts of      #
8855#               log_10(2)/64 and L10 is the natural log of 10. Then     #
8856#               10**X = 2**(M') * 2**(M) * 2**(j/64) * exp(r).          #
8857#               Go to expr to compute that expression.                  #
8858#                                                                       #
8859#       expr                                                            #
8860#       1. Fetch 2**(j/64) from table as Fact1 and Fact2.               #
8861#                                                                       #
8862#       2. Overwrite Fact1 and Fact2 by                                 #
8863#               Fact1 := 2**(M) * Fact1                                 #
8864#               Fact2 := 2**(M) * Fact2                                 #
8865#               Thus Fact1 + Fact2 = 2**(M) * 2**(j/64).                #
8866#                                                                       #
8867#       3. Calculate P where 1 + P approximates exp(r):                 #
8868#               P = r + r*r*(A1+r*(A2+...+r*A5)).                       #
8869#                                                                       #
8870#       4. Let AdjFact := 2**(M'). Return                               #
8871#               AdjFact * ( Fact1 + ((Fact1*P) + Fact2) ).              #
8872#               Exit.                                                   #
8873#                                                                       #
8874#       ExpBig                                                          #
8875#       1. Generate overflow by Huge * Huge if X > 0; otherwise,        #
8876#               generate underflow by Tiny * Tiny.                      #
8877#                                                                       #
8878#       ExpSm                                                           #
8879#       1. Return 1 + X.                                                #
8880#                                                                       #
8881#########################################################################
8882
8883L2TEN64:
8884        long            0x406A934F,0x0979A371   # 64LOG10/LOG2
8885L10TWO1:
8886        long            0x3F734413,0x509F8000   # LOG2/64LOG10
8887
8888L10TWO2:
8889        long            0xBFCD0000,0xC0219DC1,0xDA994FD2,0x00000000
8890
8891LOG10:  long            0x40000000,0x935D8DDD,0xAAA8AC17,0x00000000
8892
8893LOG2:   long            0x3FFE0000,0xB17217F7,0xD1CF79AC,0x00000000
8894
8895EXPA5:  long            0x3F56C16D,0x6F7BD0B2
8896EXPA4:  long            0x3F811112,0x302C712C
8897EXPA3:  long            0x3FA55555,0x55554CC1
8898EXPA2:  long            0x3FC55555,0x55554A54
8899EXPA1:  long            0x3FE00000,0x00000000,0x00000000,0x00000000
8900
8901TEXPTBL:
8902        long            0x3FFF0000,0x80000000,0x00000000,0x3F738000
8903        long            0x3FFF0000,0x8164D1F3,0xBC030773,0x3FBEF7CA
8904        long            0x3FFF0000,0x82CD8698,0xAC2BA1D7,0x3FBDF8A9
8905        long            0x3FFF0000,0x843A28C3,0xACDE4046,0x3FBCD7C9
8906        long            0x3FFF0000,0x85AAC367,0xCC487B15,0xBFBDE8DA
8907        long            0x3FFF0000,0x871F6196,0x9E8D1010,0x3FBDE85C
8908        long            0x3FFF0000,0x88980E80,0x92DA8527,0x3FBEBBF1
8909        long            0x3FFF0000,0x8A14D575,0x496EFD9A,0x3FBB80CA
8910        long            0x3FFF0000,0x8B95C1E3,0xEA8BD6E7,0xBFBA8373
8911        long            0x3FFF0000,0x8D1ADF5B,0x7E5BA9E6,0xBFBE9670
8912        long            0x3FFF0000,0x8EA4398B,0x45CD53C0,0x3FBDB700
8913        long            0x3FFF0000,0x9031DC43,0x1466B1DC,0x3FBEEEB0
8914        long            0x3FFF0000,0x91C3D373,0xAB11C336,0x3FBBFD6D
8915        long            0x3FFF0000,0x935A2B2F,0x13E6E92C,0xBFBDB319
8916        long            0x3FFF0000,0x94F4EFA8,0xFEF70961,0x3FBDBA2B
8917        long            0x3FFF0000,0x96942D37,0x20185A00,0x3FBE91D5
8918        long            0x3FFF0000,0x9837F051,0x8DB8A96F,0x3FBE8D5A
8919        long            0x3FFF0000,0x99E04593,0x20B7FA65,0xBFBCDE7B
8920        long            0x3FFF0000,0x9B8D39B9,0xD54E5539,0xBFBEBAAF
8921        long            0x3FFF0000,0x9D3ED9A7,0x2CFFB751,0xBFBD86DA
8922        long            0x3FFF0000,0x9EF53260,0x91A111AE,0xBFBEBEDD
8923        long            0x3FFF0000,0xA0B0510F,0xB9714FC2,0x3FBCC96E
8924        long            0x3FFF0000,0xA2704303,0x0C496819,0xBFBEC90B
8925        long            0x3FFF0000,0xA43515AE,0x09E6809E,0x3FBBD1DB
8926        long            0x3FFF0000,0xA5FED6A9,0xB15138EA,0x3FBCE5EB
8927        long            0x3FFF0000,0xA7CD93B4,0xE965356A,0xBFBEC274
8928        long            0x3FFF0000,0xA9A15AB4,0xEA7C0EF8,0x3FBEA83C
8929        long            0x3FFF0000,0xAB7A39B5,0xA93ED337,0x3FBECB00
8930        long            0x3FFF0000,0xAD583EEA,0x42A14AC6,0x3FBE9301
8931        long            0x3FFF0000,0xAF3B78AD,0x690A4375,0xBFBD8367
8932        long            0x3FFF0000,0xB123F581,0xD2AC2590,0xBFBEF05F
8933        long            0x3FFF0000,0xB311C412,0xA9112489,0x3FBDFB3C
8934        long            0x3FFF0000,0xB504F333,0xF9DE6484,0x3FBEB2FB
8935        long            0x3FFF0000,0xB6FD91E3,0x28D17791,0x3FBAE2CB
8936        long            0x3FFF0000,0xB8FBAF47,0x62FB9EE9,0x3FBCDC3C
8937        long            0x3FFF0000,0xBAFF5AB2,0x133E45FB,0x3FBEE9AA
8938        long            0x3FFF0000,0xBD08A39F,0x580C36BF,0xBFBEAEFD
8939        long            0x3FFF0000,0xBF1799B6,0x7A731083,0xBFBCBF51
8940        long            0x3FFF0000,0xC12C4CCA,0x66709456,0x3FBEF88A
8941        long            0x3FFF0000,0xC346CCDA,0x24976407,0x3FBD83B2
8942        long            0x3FFF0000,0xC5672A11,0x5506DADD,0x3FBDF8AB
8943        long            0x3FFF0000,0xC78D74C8,0xABB9B15D,0xBFBDFB17
8944        long            0x3FFF0000,0xC9B9BD86,0x6E2F27A3,0xBFBEFE3C
8945        long            0x3FFF0000,0xCBEC14FE,0xF2727C5D,0xBFBBB6F8
8946        long            0x3FFF0000,0xCE248C15,0x1F8480E4,0xBFBCEE53
8947        long            0x3FFF0000,0xD06333DA,0xEF2B2595,0xBFBDA4AE
8948        long            0x3FFF0000,0xD2A81D91,0xF12AE45A,0x3FBC9124
8949        long            0x3FFF0000,0xD4F35AAB,0xCFEDFA1F,0x3FBEB243
8950        long            0x3FFF0000,0xD744FCCA,0xD69D6AF4,0x3FBDE69A
8951        long            0x3FFF0000,0xD99D15C2,0x78AFD7B6,0xBFB8BC61
8952        long            0x3FFF0000,0xDBFBB797,0xDAF23755,0x3FBDF610
8953        long            0x3FFF0000,0xDE60F482,0x5E0E9124,0xBFBD8BE1
8954        long            0x3FFF0000,0xE0CCDEEC,0x2A94E111,0x3FBACB12
8955        long            0x3FFF0000,0xE33F8972,0xBE8A5A51,0x3FBB9BFE
8956        long            0x3FFF0000,0xE5B906E7,0x7C8348A8,0x3FBCF2F4
8957        long            0x3FFF0000,0xE8396A50,0x3C4BDC68,0x3FBEF22F
8958        long            0x3FFF0000,0xEAC0C6E7,0xDD24392F,0xBFBDBF4A
8959        long            0x3FFF0000,0xED4F301E,0xD9942B84,0x3FBEC01A
8960        long            0x3FFF0000,0xEFE4B99B,0xDCDAF5CB,0x3FBE8CAC
8961        long            0x3FFF0000,0xF281773C,0x59FFB13A,0xBFBCBB3F
8962        long            0x3FFF0000,0xF5257D15,0x2486CC2C,0x3FBEF73A
8963        long            0x3FFF0000,0xF7D0DF73,0x0AD13BB9,0xBFB8B795
8964        long            0x3FFF0000,0xFA83B2DB,0x722A033A,0x3FBEF84B
8965        long            0x3FFF0000,0xFD3E0C0C,0xF486C175,0xBFBEF581
8966
8967        set             INT,L_SCR1
8968
8969        set             X,FP_SCR0
8970        set             XDCARE,X+2
8971        set             XFRAC,X+4
8972
8973        set             ADJFACT,FP_SCR0
8974
8975        set             FACT1,FP_SCR0
8976        set             FACT1HI,FACT1+4
8977        set             FACT1LOW,FACT1+8
8978
8979        set             FACT2,FP_SCR1
8980        set             FACT2HI,FACT2+4
8981        set             FACT2LOW,FACT2+8
8982
8983        global          stwotox
8984#--ENTRY POINT FOR 2**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
8985stwotox:
8986        fmovm.x         (%a0),&0x80             # LOAD INPUT
8987
8988        mov.l           (%a0),%d1
8989        mov.w           4(%a0),%d1
8990        fmov.x          %fp0,X(%a6)
8991        and.l           &0x7FFFFFFF,%d1
8992
8993        cmp.l           %d1,&0x3FB98000         # |X| >= 2**(-70)?
8994        bge.b           TWOOK1
8995        bra.w           EXPBORS
8996
8997TWOOK1:
8998        cmp.l           %d1,&0x400D80C0         # |X| > 16480?
8999        ble.b           TWOMAIN
9000        bra.w           EXPBORS

9001
9002TWOMAIN:
9003#--USUAL CASE, 2^(-70) <= |X| <= 16480
9004
9005        fmov.x          %fp0,%fp1
9006        fmul.s          &0x42800000,%fp1        # 64 * X
9007        fmov.l          %fp1,INT(%a6)           # N = ROUND-TO-INT(64 X)
9008        mov.l           %d2,-(%sp)
9009        lea             TEXPTBL(%pc),%a1        # LOAD ADDRESS OF TABLE OF 2^(J/64)
9010        fmov.l          INT(%a6),%fp1           # N --> FLOATING FMT
9011        mov.l           INT(%a6),%d1
9012        mov.l           %d1,%d2
9013        and.l           &0x3F,%d1               # D0 IS J
9014        asl.l           &4,%d1                  # DISPLACEMENT FOR 2^(J/64)
9015        add.l           %d1,%a1                 # ADDRESS FOR 2^(J/64)
9016        asr.l           &6,%d2                  # d2 IS L, N = 64L + J
9017        mov.l           %d2,%d1
9018        asr.l           &1,%d1                  # D0 IS M
9019        sub.l           %d1,%d2                 # d2 IS M', N = 64(M+M') + J
9020        add.l           &0x3FFF,%d2
9021
9022#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
9023#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
9024#--ADJFACT = 2^(M').
9025#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9026
9027        fmovm.x         &0x0c,-(%sp)            # save fp2/fp3
9028
9029        fmul.s          &0x3C800000,%fp1        # (1/64)*N
9030        mov.l           (%a1)+,FACT1(%a6)
9031        mov.l           (%a1)+,FACT1HI(%a6)
9032        mov.l           (%a1)+,FACT1LOW(%a6)
9033        mov.w           (%a1)+,FACT2(%a6)
9034
9035        fsub.x          %fp1,%fp0               # X - (1/64)*INT(64 X)
9036
9037        mov.w           (%a1)+,FACT2HI(%a6)
9038        clr.w           FACT2HI+2(%a6)
9039        clr.l           FACT2LOW(%a6)
9040        add.w           %d1,FACT1(%a6)
9041        fmul.x          LOG2(%pc),%fp0          # FP0 IS R
9042        add.w           %d1,FACT2(%a6)
9043
9044        bra.w           expr
9045
9046EXPBORS:
9047#--FPCR, D0 SAVED
9048        cmp.l           %d1,&0x3FFF8000
9049        bgt.b           TEXPBIG
9050
9051#--|X| IS SMALL, RETURN 1 + X
9052
9053        fmov.l          %d0,%fpcr               # restore users round prec,mode
9054        fadd.s          &0x3F800000,%fp0        # RETURN 1 + X
9055        bra             t_pinx2
9056
9057TEXPBIG:
9058#--|X| IS LARGE, GENERATE OVERFLOW IF X > 0; ELSE GENERATE UNDERFLOW
9059#--REGISTERS SAVE SO FAR ARE FPCR AND  D0
9060        mov.l           X(%a6),%d1
9061        cmp.l           %d1,&0
9062        blt.b           EXPNEG
9063
9064        bra             t_ovfl2                 # t_ovfl expects positive value
9065
9066EXPNEG:
9067        bra             t_unfl2                 # t_unfl expects positive value
9068
9069        global          stwotoxd
9070stwotoxd:
9071#--ENTRY POINT FOR 2**(X) FOR DENORMALIZED ARGUMENT
9072
9073        fmov.l          %d0,%fpcr               # set user's rounding mode/precision
9074        fmov.s          &0x3F800000,%fp0        # RETURN 1 + X
9075        mov.l           (%a0),%d1
9076        or.l            &0x00800001,%d1
9077        fadd.s          %d1,%fp0
9078        bra             t_pinx2
9079
9080        global          stentox
9081#--ENTRY POINT FOR 10**(X), HERE X IS FINITE, NON-ZERO, AND NOT NAN'S
9082stentox:
9083        fmovm.x         (%a0),&0x80             # LOAD INPUT
9084
9085        mov.l           (%a0),%d1
9086        mov.w           4(%a0),%d1
9087        fmov.x          %fp0,X(%a6)
9088        and.l           &0x7FFFFFFF,%d1
9089
9090        cmp.l           %d1,&0x3FB98000         # |X| >= 2**(-70)?
9091        bge.b           TENOK1
9092        bra.w           EXPBORS
9093
9094TENOK1:
9095        cmp.l           %d1,&0x400B9B07         # |X| <= 16480*log2/log10 ?
9096        ble.b           TENMAIN
9097        bra.w           EXPBORS
9098
9099TENMAIN:
9100#--USUAL CASE, 2^(-70) <= |X| <= 16480 LOG 2 / LOG 10
9101
9102        fmov.x          %fp0,%fp1
9103        fmul.d          L2TEN64(%pc),%fp1       # X*64*LOG10/LOG2
9104        fmov.l          %fp1,INT(%a6)           # N=INT(X*64*LOG10/LOG2)
9105        mov.l           %d2,-(%sp)
9106        lea             TEXPTBL(%pc),%a1        # LOAD ADDRESS OF TABLE OF 2^(J/64)
9107        fmov.l          INT(%a6),%fp1           # N --> FLOATING FMT
9108        mov.l           INT(%a6),%d1
9109        mov.l           %d1,%d2
9110        and.l           &0x3F,%d1               # D0 IS J
9111        asl.l           &4,%d1                  # DISPLACEMENT FOR 2^(J/64)
9112        add.l           %d1,%a1                 # ADDRESS FOR 2^(J/64)
9113        asr.l           &6,%d2                  # d2 IS L, N = 64L + J
9114        mov.l           %d2,%d1
9115        asr.l           &1,%d1                  # D0 IS M
9116        sub.l           %d1,%d2                 # d2 IS M', N = 64(M+M') + J
9117        add.l           &0x3FFF,%d2
9118
9119#--SUMMARY: a1 IS ADDRESS FOR THE LEADING PORTION OF 2^(J/64),
9120#--D0 IS M WHERE N = 64(M+M') + J. NOTE THAT |M| <= 16140 BY DESIGN.
9121#--ADJFACT = 2^(M').
9122#--REGISTERS SAVED SO FAR ARE (IN ORDER) FPCR, D0, FP1, a1, AND FP2.
9123        fmovm.x         &0x0c,-(%sp)            # save fp2/fp3
9124
9125        fmov.x          %fp1,%fp2
9126
9127        fmul.d          L10TWO1(%pc),%fp1       # N*(LOG2/64LOG10)_LEAD
9128        mov.l           (%a1)+,FACT1(%a6)
9129
9130        fmul.x          L10TWO2(%pc),%fp2       # N*(LOG2/64LOG10)_TRAIL
9131
9132        mov.l           (%a1)+,FACT1HI(%a6)
9133        mov.l           (%a1)+,FACT1LOW(%a6)
9134        fsub.x          %fp1,%fp0               # X - N L_LEAD
9135        mov.w           (%a1)+,FACT2(%a6)
9136
9137        fsub.x          %fp2,%fp0               # X - N L_TRAIL
9138
9139        mov.w           (%a1)+,FACT2HI(%a6)
9140        clr.w           FACT2HI+2(%a6)
9141        clr.l           FACT2LOW(%a6)
9142
9143        fmul.x          LOG10(%pc),%fp0         # FP0 IS R
9144        add.w           %d1,FACT1(%a6)
9145        add.w           %d1,FACT2(%a6)
9146
9147expr:
9148#--FPCR, FP2, FP3 ARE SAVED IN ORDER AS SHOWN.
9149#--ADJFACT CONTAINS 2**(M'), FACT1 + FACT2 = 2**(M) * 2**(J/64).
9150#--FP0 IS R. THE FOLLOWING CODE COMPUTES
9151#--     2**(M'+M) * 2**(J/64) * EXP(R)
9152
9153        fmov.x          %fp0,%fp1
9154        fmul.x          %fp1,%fp1               # FP1 IS S = R*R
9155
9156        fmov.d          EXPA5(%pc),%fp2         # FP2 IS A5
9157        fmov.d          EXPA4(%pc),%fp3         # FP3 IS A4
9158
9159        fmul.x          %fp1,%fp2               # FP2 IS S*A5
9160        fmul.x          %fp1,%fp3               # FP3 IS S*A4
9161
9162        fadd.d          EXPA3(%pc),%fp2         # FP2 IS A3+S*A5
9163        fadd.d          EXPA2(%pc),%fp3         # FP3 IS A2+S*A4
9164
9165        fmul.x          %fp1,%fp2               # FP2 IS S*(A3+S*A5)
9166        fmul.x          %fp1,%fp3               # FP3 IS S*(A2+S*A4)
9167
9168        fadd.d          EXPA1(%pc),%fp2         # FP2 IS A1+S*(A3+S*A5)
9169        fmul.x          %fp0,%fp3               # FP3 IS R*S*(A2+S*A4)
9170
9171        fmul.x          %fp1,%fp2               # FP2 IS S*(A1+S*(A3+S*A5))
9172        fadd.x          %fp3,%fp0               # FP0 IS R+R*S*(A2+S*A4)
9173        fadd.x          %fp2,%fp0               # FP0 IS EXP(R) - 1
9174
9175        fmovm.x         (%sp)+,&0x30            # restore fp2/fp3
9176
9177#--FINAL RECONSTRUCTION PROCESS
9178#--EXP(X) = 2^M*2^(J/64) + 2^M*2^(J/64)*(EXP(R)-1)  -  (1 OR 0)
9179
9180        fmul.x          FACT1(%a6),%fp0
9181        fadd.x          FACT2(%a6),%fp0
9182        fadd.x          FACT1(%a6),%fp0
9183
9184        fmov.l          %d0,%fpcr               # restore users round prec,mode
9185        mov.w           %d2,ADJFACT(%a6)        # INSERT EXPONENT
9186        mov.l           (%sp)+,%d2
9187        mov.l           &0x80000000,ADJFACT+4(%a6)
9188        clr.l           ADJFACT+8(%a6)
9189        mov.b           &FMUL_OP,%d1            # last inst is MUL
9190        fmul.x          ADJFACT(%a6),%fp0       # FINAL ADJUSTMENT
9191        bra             t_catch
9192
9193        global          stentoxd
9194stentoxd:
9195#--ENTRY POINT FOR 10**(X) FOR DENORMALIZED ARGUMENT
9196
9197        fmov.l          %d0,%fpcr               # set user's rounding mode/precision
9198        fmov.s          &0x3F800000,%fp0        # RETURN 1 + X
9199        mov.l           (%a0),%d1
9200        or.l            &0x00800001,%d1
9201        fadd.s          %d1,%fp0
9202        bra             t_pinx2
9203
9204#########################################################################
9205# sscale(): computes the destination operand scaled by the source       #
9206#           operand. If the absoulute value of the source operand is    #
9207#           >= 2^14, an overflow or underflow is returned.              #
9208#                                                                       #
9209# INPUT *************************************************************** #
9210#       a0  = pointer to double-extended source operand X               #
9211#       a1  = pointer to double-extended destination operand Y          #
9212#                                                                       #
9213# OUTPUT ************************************************************** #
9214#       fp0 =  scale(X,Y)                                               #
9215#                                                                       #
9216#########################################################################
9217
9218set     SIGN,           L_SCR1
9219
9220        global          sscale
9221sscale:
9222        mov.l           %d0,-(%sp)              # store off ctrl bits for now
9223
9224        mov.w           DST_EX(%a1),%d1         # get dst exponent
9225        smi.b           SIGN(%a6)               # use SIGN to hold dst sign
9226        andi.l          &0x00007fff,%d1         # strip sign from dst exp
9227
9228        mov.w           SRC_EX(%a0),%d0         # check src bounds
9229        andi.w          &0x7fff,%d0             # clr src sign bit
9230        cmpi.w          %d0,&0x3fff             # is src ~ ZERO?
9231        blt.w           src_small               # yes
9232        cmpi.w          %d0,&0x400c             # no; is src too big?
9233        bgt.w           src_out                 # yes
9234
9235#
9236# Source is within 2^14 range.
9237#
9238src_ok:
9239        fintrz.x        SRC(%a0),%fp0           # calc int of src
9240        fmov.l          %fp0,%d0                # int src to d0
9241# don't want any accrued bits from the fintrz showing up later since
9242# we may need to read the fpsr for the last fp op in t_catch2().
9243        fmov.l          &0x0,%fpsr
9244
9245        tst.b           DST_HI(%a1)             # is dst denormalized?
9246        bmi.b           sok_norm
9247
9248# the dst is a DENORM. normalize the DENORM and add the adjustment to
9249# the src value. then, jump to the norm part of the routine.
9250sok_dnrm:
9251        mov.l           %d0,-(%sp)              # save src for now
9252
9253        mov.w           DST_EX(%a1),FP_SCR0_EX(%a6) # make a copy
9254        mov.l           DST_HI(%a1),FP_SCR0_HI(%a6)
9255        mov.l           DST_LO(%a1),FP_SCR0_LO(%a6)
9256
9257        lea             FP_SCR0(%a6),%a0        # pass ptr to DENORM
9258        bsr.l           norm                    # normalize the DENORM
9259        neg.l           %d0
9260        add.l           (%sp)+,%d0              # add adjustment to src
9261
9262        fmovm.x         FP_SCR0(%a6),&0x80      # load normalized DENORM
9263
9264        cmpi.w          %d0,&-0x3fff            # is the shft amt really low?
9265        bge.b           sok_norm2               # thank goodness no
9266
9267# the multiply factor that we're trying to create should be a denorm
9268# for the multiply to work. therefore, we're going to actually do a
9269# multiply with a denorm which will cause an unimplemented data type
9270# exception to be put into the machine which will be caught and corrected
9271# later. we don't do this with the DENORMs above because this method
9272# is slower. but, don't fret, I don't see it being used much either.
9273        fmov.l          (%sp)+,%fpcr            # restore user fpcr
9274        mov.l           &0x80000000,%d1         # load normalized mantissa
9275        subi.l          &-0x3fff,%d0            # how many should we shift?
9276        neg.l           %d0                     # make it positive
9277        cmpi.b          %d0,&0x20               # is it > 32?
9278        bge.b           sok_dnrm_32             # yes
9279        lsr.l           %d0,%d1                 # no; bit stays in upper lw
9280        clr.l           -(%sp)                  # insert zero low mantissa
9281        mov.l           %d1,-(%sp)              # insert new high mantissa
9282        clr.l           -(%sp)                  # make zero exponent
9283        bra.b           sok_norm_cont
9284sok_dnrm_32:
9285        subi.b          &0x20,%d0               # get shift count
9286        lsr.l           %d0,%d1                 # make low mantissa longword
9287        mov.l           %d1,-(%sp)              # insert new low mantissa
9288        clr.l           -(%sp)                  # insert zero high mantissa
9289        clr.l           -(%sp)                  # make zero exponent
9290        bra.b           sok_norm_cont
9291
9292# the src will force the dst to a DENORM value or worse. so, let's
9293# create an fp multiply that will create the result.
9294sok_norm:
9295        fmovm.x         DST(%a1),&0x80          # load fp0 with normalized src
9296sok_norm2:
9297        fmov.l          (%sp)+,%fpcr            # restore user fpcr
9298
9299        addi.w          &0x3fff,%d0             # turn src amt into exp value
9300        swap            %d0                     # put exponent in high word
9301        clr.l           -(%sp)                  # insert new exponent
9302        mov.l           &0x80000000,-(%sp)      # insert new high mantissa
9303        mov.l           %d0,-(%sp)              # insert new lo mantissa
9304
9305sok_norm_cont:
9306        fmov.l          %fpcr,%d0               # d0 needs fpcr for t_catch2
9307        mov.b           &FMUL_OP,%d1            # last inst is MUL
9308        fmul.x          (%sp)+,%fp0             # do the multiply
9309        bra             t_catch2                # catch any exceptions
9310
9311#
9312# Source is outside of 2^14 range.  Test the sign and branch
9313# to the appropriate exception handler.
9314#
9315src_out:
9316        mov.l           (%sp)+,%d0              # restore ctrl bits
9317        exg             %a0,%a1                 # swap src,dst ptrs
9318        tst.b           SRC_EX(%a1)             # is src negative?
9319        bmi             t_unfl                  # yes; underflow
9320        bra             t_ovfl_sc               # no; overflow
9321
9322#
9323# The source input is below 1, so we check for denormalized numbers
9324# and set unfl.
9325#
9326src_small:
9327        tst.b           DST_HI(%a1)             # is dst denormalized?
9328        bpl.b           ssmall_done             # yes
9329
9330        mov.l           (%sp)+,%d0
9331        fmov.l          %d0,%fpcr               # no; load control bits
9332        mov.b           &FMOV_OP,%d1            # last inst is MOVE
9333        fmov.x          DST(%a1),%fp0           # simply return dest
9334        bra             t_catch2
9335ssmall_done:
9336        mov.l           (%sp)+,%d0              # load control bits into d1
9337        mov.l           %a1,%a0                 # pass ptr to dst
9338        bra             t_resdnrm
9339
9340#########################################################################
9341# smod(): computes the fp MOD of the input values X,Y.                  #
9342# srem(): computes the fp (IEEE) REM of the input values X,Y.           #
9343#                                                                       #
9344# INPUT *************************************************************** #
9345#       a0 = pointer to extended precision input X                      #
9346#       a1 = pointer to extended precision input Y                      #
9347#       d0 = round precision,mode                                       #
9348#                                                                       #
9349#       The input operands X and Y can be either normalized or          #
9350#       denormalized.                                                   #
9351#                                                                       #
9352# OUTPUT ************************************************************** #
9353#      fp0 = FREM(X,Y) or FMOD(X,Y)                                     #
9354#                                                                       #
9355# ALGORITHM *********************************************************** #
9356#                                                                       #
9357#       Step 1.  Save and strip signs of X and Y: signX := sign(X),     #
9358#                signY := sign(Y), X := |X|, Y := |Y|,                  #
9359#                signQ := signX EOR signY. Record whether MOD or REM    #
9360#                is requested.                                          #
9361#                                                                       #
9362#       Step 2.  Set L := expo(X)-expo(Y), k := 0, Q := 0.              #
9363#                If (L < 0) then                                        #
9364#                   R := X, go to Step 4.                               #
9365#                else                                                   #
9366#                   R := 2^(-L)X, j := L.                               #
9367#                endif                                                  #
9368#                                                                       #
9369#       Step 3.  Perform MOD(X,Y)                                       #
9370#            3.1 If R = Y, go to Step 9.                                #
9371#            3.2 If R > Y, then { R := R - Y, Q := Q + 1}               #
9372#            3.3 If j = 0, go to Step 4.                                #
9373#            3.4 k := k + 1, j := j - 1, Q := 2Q, R := 2R. Go to        #
9374#                Step 3.1.                                              #
9375#                                                                       #
9376#       Step 4.  At this point, R = X - QY = MOD(X,Y). Set              #
9377#                Last_Subtract := false (used in Step 7 below). If      #
9378#                MOD is requested, go to Step 6.                        #
9379#                                                                       #
9380#       Step 5.  R = MOD(X,Y), but REM(X,Y) is requested.               #
9381#            5.1 If R < Y/2, then R = MOD(X,Y) = REM(X,Y). Go to        #
9382#                Step 6.                                                #
9383#            5.2 If R > Y/2, then { set Last_Subtract := true,          #
9384#                Q := Q + 1, Y := signY*Y }. Go to Step 6.              #
9385#            5.3 This is the tricky case of R = Y/2. If Q is odd,       #
9386#                then { Q := Q + 1, signX := -signX }.                  #
9387#                                                                       #
9388#       Step 6.  R := signX*R.                                          #
9389#                                                                       #
9390#       Step 7.  If Last_Subtract = true, R := R - Y.                   #
9391#                                                                       #
9392#       Step 8.  Return signQ, last 7 bits of Q, and R as required.     #
9393#                                                                       #
9394#       Step 9.  At this point, R = 2^(-j)*X - Q Y = Y. Thus,           #
9395#                X = 2^(j)*(Q+1)Y. set Q := 2^(j)*(Q+1),                #
9396#                R := 0. Return signQ, last 7 bits of Q, and R.         #
9397#                                                                       #
9398#########################################################################
9399
9400        set             Mod_Flag,L_SCR3
9401        set             Sc_Flag,L_SCR3+1
9402
9403        set             SignY,L_SCR2
9404        set             SignX,L_SCR2+2
9405        set             SignQ,L_SCR3+2
9406
9407        set             Y,FP_SCR0
9408        set             Y_Hi,Y+4
9409        set             Y_Lo,Y+8
9410
9411        set             R,FP_SCR1
9412        set             R_Hi,R+4
9413        set             R_Lo,R+8
9414
9415Scale:
9416        long            0x00010000,0x80000000,0x00000000,0x00000000
9417
9418        global          smod
9419smod:
9420        clr.b           FPSR_QBYTE(%a6)
9421        mov.l           %d0,-(%sp)              # save ctrl bits
9422        clr.b           Mod_Flag(%a6)
9423        bra.b           Mod_Rem
9424
9425        global          srem
9426srem:
9427        clr.b           FPSR_QBYTE(%a6)
9428        mov.l           %d0,-(%sp)              # save ctrl bits
9429        mov.b           &0x1,Mod_Flag(%a6)
9430
9431Mod_Rem:
9432#..Save sign of X and Y
9433        movm.l          &0x3f00,-(%sp)          # save data registers
9434        mov.w           SRC_EX(%a0),%d3
9435        mov.w           %d3,SignY(%a6)
9436        and.l           &0x00007FFF,%d3         # Y := |Y|
9437
9438#
9439        mov.l           SRC_HI(%a0),%d4
9440        mov.l           SRC_LO(%a0),%d5         # (D3,D4,D5) is |Y|
9441
9442        tst.l           %d3
9443        bne.b           Y_Normal
9444
9445        mov.l           &0x00003FFE,%d3         # $3FFD + 1
9446        tst.l           %d4
9447        bne.b           HiY_not0
9448
9449HiY_0:
9450        mov.l           %d5,%d4
9451        clr.l           %d5
9452        sub.l           &32,%d3
9453        clr.l           %d6
9454        bfffo           %d4{&0:&32},%d6
9455        lsl.l           %d6,%d4
9456        sub.l           %d6,%d3                 # (D3,D4,D5) is normalized
9457#                                               ...with bias $7FFD
9458        bra.b           Chk_X
9459
9460HiY_not0:
9461        clr.l           %d6
9462        bfffo           %d4{&0:&32},%d6
9463        sub.l           %d6,%d3
9464        lsl.l           %d6,%d4
9465        mov.l           %d5,%d7                 # a copy of D5
9466        lsl.l           %d6,%d5
9467        neg.l           %d6
9468        add.l           &32,%d6
9469        lsr.l           %d6,%d7
9470        or.l            %d7,%d4                 # (D3,D4,D5) normalized
9471#                                       ...with bias $7FFD
9472        bra.b           Chk_X
9473
9474Y_Normal:
9475        add.l           &0x00003FFE,%d3         # (D3,D4,D5) normalized
9476#                                       ...with bias $7FFD
9477
9478Chk_X:
9479        mov.w           DST_EX(%a1),%d0
9480        mov.w           %d0,SignX(%a6)
9481        mov.w           SignY(%a6),%d1
9482        eor.l           %d0,%d1
9483        and.l           &0x00008000,%d1
9484        mov.w           %d1,SignQ(%a6)          # sign(Q) obtained
9485        and.l           &0x00007FFF,%d0
9486        mov.l           DST_HI(%a1),%d1
9487        mov.l           DST_LO(%a1),%d2         # (D0,D1,D2) is |X|
9488        tst.l           %d0
9489        bne.b           X_Normal
9490        mov.l           &0x00003FFE,%d0
9491        tst.l           %d1
9492        bne.b           HiX_not0
9493
9494HiX_0:
9495        mov.l           %d2,%d1
9496        clr.l           %d2
9497        sub.l           &32,%d0
9498        clr.l           %d6
9499        bfffo           %d1{&0:&32},%d6
9500        lsl.l           %d6,%d1
9501        sub.l           %d6,%d0                 # (D0,D1,D2) is normalized
9502#                                       ...with bias $7FFD
9503        bra.b           Init
9504
9505HiX_not0:
9506        clr.l           %d6
9507        bfffo           %d1{&0:&32},%d6
9508        sub.l           %d6,%d0
9509        lsl.l           %d6,%d1
9510        mov.l           %d2,%d7                 # a copy of D2
9511        lsl.l           %d6,%d2
9512        neg.l           %d6
9513        add.l           &32,%d6
9514        lsr.l           %d6,%d7
9515        or.l            %d7,%d1                 # (D0,D1,D2) normalized
9516#                                       ...with bias $7FFD
9517        bra.b           Init
9518
9519X_Normal:
9520        add.l           &0x00003FFE,%d0         # (D0,D1,D2) normalized
9521#                                       ...with bias $7FFD
9522
9523Init:
9524#
9525        mov.l           %d3,L_SCR1(%a6)         # save biased exp(Y)
9526        mov.l           %d0,-(%sp)              # save biased exp(X)
9527        sub.l           %d3,%d0                 # L := expo(X)-expo(Y)
9528
9529        clr.l           %d6                     # D6 := carry <- 0
9530        clr.l           %d3                     # D3 is Q
9531        mov.l           &0,%a1                  # A1 is k; j+k=L, Q=0
9532
9533#..(Carry,D1,D2) is R
9534        tst.l           %d0
9535        bge.b           Mod_Loop_pre
9536
9537#..expo(X) < expo(Y). Thus X = mod(X,Y)
9538#
9539        mov.l           (%sp)+,%d0              # restore d0
9540        bra.w           Get_Mod
9541
9542Mod_Loop_pre:
9543        addq.l          &0x4,%sp                # erase exp(X)
9544#..At this point  R = 2^(-L)X; Q = 0; k = 0; and  k+j = L
9545Mod_Loop:
9546        tst.l           %d6                     # test carry bit
9547        bgt.b           R_GT_Y
9548
9549#..At this point carry = 0, R = (D1,D2), Y = (D4,D5)
9550        cmp.l           %d1,%d4                 # compare hi(R) and hi(Y)
9551        bne.b           R_NE_Y
9552        cmp.l           %d2,%d5                 # compare lo(R) and lo(Y)
9553        bne.b           R_NE_Y
9554
9555#..At this point, R = Y
9556        bra.w           Rem_is_0
9557
9558R_NE_Y:
9559#..use the borrow of the previous compare
9560        bcs.b           R_LT_Y                  # borrow is set iff R < Y
9561
9562R_GT_Y:
9563#..If Carry is set, then Y < (Carry,D1,D2) < 2Y. Otherwise, Carry = 0
9564#..and Y < (D1,D2) < 2Y. Either way, perform R - Y
9565        sub.l           %d5,%d2                 # lo(R) - lo(Y)
9566        subx.l          %d4,%d1                 # hi(R) - hi(Y)
9567        clr.l           %d6                     # clear carry
9568        addq.l          &1,%d3                  # Q := Q + 1
9569
9570R_LT_Y:
9571#..At this point, Carry=0, R < Y. R = 2^(k-L)X - QY; k+j = L; j >= 0.
9572        tst.l           %d0                     # see if j = 0.
9573        beq.b           PostLoop
9574
9575        add.l           %d3,%d3                 # Q := 2Q
9576        add.l           %d2,%d2                 # lo(R) = 2lo(R)
9577        roxl.l          &1,%d1                  # hi(R) = 2hi(R) + carry
9578        scs             %d6                     # set Carry if 2(R) overflows
9579        addq.l          &1,%a1                  # k := k+1
9580        subq.l          &1,%d0                  # j := j - 1
9581#..At this point, R=(Carry,D1,D2) = 2^(k-L)X - QY, j+k=L, j >= 0, R < 2Y.
9582
9583        bra.b           Mod_Loop
9584
9585PostLoop:
9586#..k = L, j = 0, Carry = 0, R = (D1,D2) = X - QY, R < Y.
9587
9588#..normalize R.
9589        mov.l           L_SCR1(%a6),%d0         # new biased expo of R
9590        tst.l           %d1
9591        bne.b           HiR_not0
9592
9593HiR_0:
9594        mov.l           %d2,%d1
9595        clr.l           %d2
9596        sub.l           &32,%d0
9597        clr.l           %d6
9598        bfffo           %d1{&0:&32},%d6
9599        lsl.l           %d6,%d1
9600        sub.l           %d6,%d0                 # (D0,D1,D2) is normalized
9601#                                       ...with bias $7FFD
9602        bra.b           Get_Mod
9603
9604HiR_not0:
9605        clr.l           %d6
9606        bfffo           %d1{&0:&32},%d6
9607        bmi.b           Get_Mod                 # already normalized
9608        sub.l           %d6,%d0
9609        lsl.l           %d6,%d1
9610        mov.l           %d2,%d7                 # a copy of D2
9611        lsl.l           %d6,%d2
9612        neg.l           %d6
9613        add.l           &32,%d6
9614        lsr.l           %d6,%d7
9615        or.l            %d7,%d1                 # (D0,D1,D2) normalized
9616
9617#
9618Get_Mod:
9619        cmp.l           %d0,&0x000041FE
9620        bge.b           No_Scale
9621Do_Scale:
9622        mov.w           %d0,R(%a6)
9623        mov.l           %d1,R_Hi(%a6)
9624        mov.l           %d2,R_Lo(%a6)
9625        mov.l           L_SCR1(%a6),%d6
9626        mov.w           %d6,Y(%a6)
9627        mov.l           %d4,Y_Hi(%a6)
9628        mov.l           %d5,Y_Lo(%a6)
9629        fmov.x          R(%a6),%fp0             # no exception
9630        mov.b           &1,Sc_Flag(%a6)
9631        bra.b           ModOrRem
9632No_Scale:
9633        mov.l           %d1,R_Hi(%a6)
9634        mov.l           %d2,R_Lo(%a6)
9635        sub.l           &0x3FFE,%d0
9636        mov.w           %d0,R(%a6)
9637        mov.l           L_SCR1(%a6),%d6
9638        sub.l           &0x3FFE,%d6
9639        mov.l           %d6,L_SCR1(%a6)
9640        fmov.x          R(%a6),%fp0
9641        mov.w           %d6,Y(%a6)
9642        mov.l           %d4,Y_Hi(%a6)
9643        mov.l           %d5,Y_Lo(%a6)
9644        clr.b           Sc_Flag(%a6)
9645
9646#
9647ModOrRem:
9648        tst.b           Mod_Flag(%a6)
9649        beq.b           Fix_Sign
9650
9651        mov.l           L_SCR1(%a6),%d6         # new biased expo(Y)
9652        subq.l          &1,%d6                  # biased expo(Y/2)
9653        cmp.l           %d0,%d6
9654        blt.b           Fix_Sign
9655        bgt.b           Last_Sub
9656
9657        cmp.l           %d1,%d4
9658        bne.b           Not_EQ
9659        cmp.l           %d2,%d5
9660        bne.b           Not_EQ
9661        bra.w           Tie_Case
9662
9663Not_EQ:
9664        bcs.b           Fix_Sign
9665
9666Last_Sub:
9667#
9668        fsub.x          Y(%a6),%fp0             # no exceptions
9669        addq.l          &1,%d3                  # Q := Q + 1
9670
9671#
9672Fix_Sign:
9673#..Get sign of X
9674        mov.w           SignX(%a6),%d6
9675        bge.b           Get_Q
9676        fneg.x          %fp0
9677
9678#..Get Q
9679#
9680Get_Q:
9681        clr.l           %d6
9682        mov.w           SignQ(%a6),%d6          # D6 is sign(Q)
9683        mov.l           &8,%d7
9684        lsr.l           %d7,%d6
9685        and.l           &0x0000007F,%d3         # 7 bits of Q
9686        or.l            %d6,%d3                 # sign and bits of Q
9687#       swap            %d3
9688#       fmov.l          %fpsr,%d6
9689#       and.l           &0xFF00FFFF,%d6
9690#       or.l            %d3,%d6
9691#       fmov.l          %d6,%fpsr               # put Q in fpsr
9692        mov.b           %d3,FPSR_QBYTE(%a6)     # put Q in fpsr
9693
9694#
9695Restore:
9696        movm.l          (%sp)+,&0xfc            #  {%d2-%d7}
9697        mov.l           (%sp)+,%d0
9698        fmov.l          %d0,%fpcr
9699        tst.b           Sc_Flag(%a6)
9700        beq.b           Finish
9701        mov.b           &FMUL_OP,%d1            # last inst is MUL
9702        fmul.x          Scale(%pc),%fp0         # may cause underflow
9703        bra             t_catch2
9704# the '040 package did this apparently to see if the dst operand for the
9705# preceding fmul was a denorm. but, it better not have been since the
9706# algorithm just got done playing with fp0 and expected no exceptions
9707# as a result. trust me...
9708#       bra             t_avoid_unsupp          # check for denorm as a
9709#                                               ;result of the scaling
9710
9711Finish:
9712        mov.b           &FMOV_OP,%d1            # last inst is MOVE
9713        fmov.x          %fp0,%fp0               # capture exceptions & round
9714        bra             t_catch2
9715
9716Rem_is_0:
9717#..R = 2^(-j)X - Q Y = Y, thus R = 0 and quotient = 2^j (Q+1)
9718        addq.l          &1,%d3
9719        cmp.l           %d0,&8                  # D0 is j
9720        bge.b           Q_Big
9721
9722        lsl.l           %d0,%d3
9723        bra.b           Set_R_0
9724
9725Q_Big:
9726        clr.l           %d3
9727
9728Set_R_0:
9729        fmov.s          &0x00000000,%fp0
9730        clr.b           Sc_Flag(%a6)
9731        bra.w           Fix_Sign
9732
9733Tie_Case:
9734#..Check parity of Q
9735        mov.l           %d3,%d6
9736        and.l           &0x00000001,%d6
9737        tst.l           %d6
9738        beq.w           Fix_Sign                # Q is even
9739
9740#..Q is odd, Q := Q + 1, signX := -signX
9741        addq.l          &1,%d3
9742        mov.w           SignX(%a6),%d6
9743        eor.l           &0x00008000,%d6
9744        mov.w           %d6,SignX(%a6)
9745        bra.w           Fix_Sign
9746
9747#########################################################################
9748# XDEF **************************************************************** #
9749#       tag(): return the optype of the input ext fp number             #
9750#                                                                       #
9751#       This routine is used by the 060FPLSP.                           #
9752#                                                                       #
9753# XREF **************************************************************** #
9754#       None                                                            #
9755#                                                                       #
9756# INPUT *************************************************************** #
9757#       a0 = pointer to extended precision operand                      #
9758#                                                                       #
9759# OUTPUT ************************************************************** #
9760#       d0 = value of type tag                                          #
9761#               one of: NORM, INF, QNAN, SNAN, DENORM, ZERO             #
9762#                                                                       #
9763# ALGORITHM *********************************************************** #
9764#       Simply test the exponent, j-bit, and mantissa values to         #
9765# determine the type of operand.                                        #
9766#       If it's an unnormalized zero, alter the operand and force it    #
9767# to be a normal zero.                                                  #
9768#                                                                       #
9769#########################################################################
9770
9771        global          tag
9772tag:
9773        mov.w           FTEMP_EX(%a0), %d0      # extract exponent
9774        andi.w          &0x7fff, %d0            # strip off sign
9775        cmpi.w          %d0, &0x7fff            # is (EXP == MAX)?
9776        beq.b           inf_or_nan_x
9777not_inf_or_nan_x:
9778        btst            &0x7,FTEMP_HI(%a0)
9779        beq.b           not_norm_x
9780is_norm_x:
9781        mov.b           &NORM, %d0
9782        rts
9783not_norm_x:
9784        tst.w           %d0                     # is exponent = 0?
9785        bne.b           is_unnorm_x
9786not_unnorm_x:
9787        tst.l           FTEMP_HI(%a0)
9788        bne.b           is_denorm_x
9789        tst.l           FTEMP_LO(%a0)
9790        bne.b           is_denorm_x
9791is_zero_x:
9792        mov.b           &ZERO, %d0
9793        rts
9794is_denorm_x:
9795        mov.b           &DENORM, %d0
9796        rts
9797is_unnorm_x:
9798        bsr.l           unnorm_fix              # convert to norm,denorm,or zero
9799        rts
9800is_unnorm_reg_x:
9801        mov.b           &UNNORM, %d0
9802        rts
9803inf_or_nan_x:
9804        tst.l           FTEMP_LO(%a0)
9805        bne.b           is_nan_x
9806        mov.l           FTEMP_HI(%a0), %d0
9807        and.l           &0x7fffffff, %d0        # msb is a don't care!
9808        bne.b           is_nan_x
9809is_inf_x:
9810        mov.b           &INF, %d0
9811        rts
9812is_nan_x:
9813        mov.b           &QNAN, %d0
9814        rts
9815
9816#############################################################
9817
9818qnan:   long            0x7fff0000, 0xffffffff, 0xffffffff
9819
9820#########################################################################
9821# XDEF **************************************************************** #
9822#       t_dz(): Handle 060FPLSP dz exception for "flogn" emulation.     #
9823#       t_dz2(): Handle 060FPLSP dz exception for "fatanh" emulation.   #
9824#                                                                       #
9825#       These rouitnes are used by the 060FPLSP package.                #
9826#                                                                       #
9827# XREF **************************************************************** #
9828#       None                                                            #
9829#                                                                       #
9830# INPUT *************************************************************** #
9831#       a0 = pointer to extended precision source operand.              #
9832#                                                                       #
9833# OUTPUT ************************************************************** #
9834#       fp0 = default DZ result.                                        #
9835#                                                                       #
9836# ALGORITHM *********************************************************** #
9837#       Transcendental emulation for the 060FPLSP has detected that     #
9838# a DZ exception should occur for the instruction. If DZ is disabled,   #
9839# return the default result.                                            #
9840#       If DZ is enabled, the dst operand should be returned unscathed  #
9841# in fp0 while fp1 is used to create a DZ exception so that the         #
9842# operating system can log that such an event occurred.                 #
9843#                                                                       #
9844#########################################################################
9845
9846        global          t_dz
9847t_dz:
9848        tst.b           SRC_EX(%a0)             # check sign for neg or pos
9849        bpl.b           dz_pinf                 # branch if pos sign
9850
9851        global          t_dz2
9852t_dz2:
9853        ori.l           &dzinf_mask+neg_mask,USER_FPSR(%a6) # set N/I/DZ/ADZ
9854
9855        btst            &dz_bit,FPCR_ENABLE(%a6)
9856        bne.b           dz_minf_ena
9857
9858# dz is disabled. return a -INF.
9859        fmov.s          &0xff800000,%fp0        # return -INF
9860        rts
9861
9862# dz is enabled. create a dz exception so the user can record it
9863# but use fp1 instead. return the dst operand unscathed in fp0.
9864dz_minf_ena:
9865        fmovm.x         EXC_FP0(%a6),&0x80      # return fp0 unscathed
9866        fmov.l          USER_FPCR(%a6),%fpcr
9867        fmov.s          &0xbf800000,%fp1        # load -1
9868        fdiv.s          &0x00000000,%fp1        # -1 / 0
9869        rts
9870
9871dz_pinf:
9872        ori.l           &dzinf_mask,USER_FPSR(%a6) # set I/DZ/ADZ
9873
9874        btst            &dz_bit,FPCR_ENABLE(%a6)
9875        bne.b           dz_pinf_ena
9876
9877# dz is disabled. return a +INF.
9878        fmov.s          &0x7f800000,%fp0        # return +INF
9879        rts
9880
9881# dz is enabled. create a dz exception so the user can record it
9882# but use fp1 instead. return the dst operand unscathed in fp0.
9883dz_pinf_ena:
9884        fmovm.x         EXC_FP0(%a6),&0x80      # return fp0 unscathed
9885        fmov.l          USER_FPCR(%a6),%fpcr
9886        fmov.s          &0x3f800000,%fp1        # load +1
9887        fdiv.s          &0x00000000,%fp1        # +1 / 0
9888        rts
9889
9890#########################################################################
9891# XDEF **************************************************************** #
9892#       t_operr(): Handle 060FPLSP OPERR exception during emulation.    #
9893#                                                                       #
9894#       This routine is used by the 060FPLSP package.                   #
9895#                                                                       #
9896# XREF **************************************************************** #
9897#       None.                                                           #
9898#                                                                       #
9899# INPUT *************************************************************** #
9900#       fp1 = source operand                                            #
9901#                                                                       #
9902# OUTPUT ************************************************************** #
9903#       fp0 = default result                                            #
9904#       fp1 = unchanged                                                 #
9905#                                                                       #
9906# ALGORITHM *********************************************************** #
9907#       An operand error should occur as the result of transcendental   #
9908# emulation in the 060FPLSP. If OPERR is disabled, just return a NAN    #
9909# in fp0. If OPERR is enabled, return the dst operand unscathed in fp0  #
9910# and the source operand in fp1. Use fp2 to create an OPERR exception   #
9911# so that the operating system can log the event.                       #
9912#                                                                       #
9913#########################################################################
9914
9915        global          t_operr
9916t_operr:
9917        ori.l           &opnan_mask,USER_FPSR(%a6) # set NAN/OPERR/AIOP
9918
9919        btst            &operr_bit,FPCR_ENABLE(%a6)
9920        bne.b           operr_ena
9921
9922# operr is disabled. return a QNAN in fp0
9923        fmovm.x         qnan(%pc),&0x80         # return QNAN
9924        rts
9925
9926# operr is enabled. create an operr exception so the user can record it
9927# but use fp2 instead. return the dst operand unscathed in fp0.
9928operr_ena:
9929        fmovm.x         EXC_FP0(%a6),&0x80      # return fp0 unscathed
9930        fmov.l          USER_FPCR(%a6),%fpcr
9931        fmovm.x         &0x04,-(%sp)            # save fp2
9932        fmov.s          &0x7f800000,%fp2        # load +INF
9933        fmul.s          &0x00000000,%fp2        # +INF x 0
9934        fmovm.x         (%sp)+,&0x20            # restore fp2
9935        rts
9936
9937pls_huge:
9938        long            0x7ffe0000,0xffffffff,0xffffffff
9939mns_huge:
9940        long            0xfffe0000,0xffffffff,0xffffffff
9941pls_tiny:
9942        long            0x00000000,0x80000000,0x00000000
9943mns_tiny:
9944        long            0x80000000,0x80000000,0x00000000
9945
9946#########################################################################
9947# XDEF **************************************************************** #
9948#       t_unfl(): Handle 060FPLSP underflow exception during emulation. #
9949#       t_unfl2(): Handle 060FPLSP underflow exception during           #
9950#                  emulation. result always positive.                   #
9951#                                                                       #
9952#       This routine is used by the 060FPLSP package.                   #
9953#                                                                       #
9954# XREF **************************************************************** #
9955#       None.                                                           #
9956#                                                                       #
9957# INPUT *************************************************************** #
9958#       a0 = pointer to extended precision source operand               #
9959#                                                                       #
9960# OUTPUT ************************************************************** #
9961#       fp0 = default underflow result                                  #
9962#                                                                       #
9963# ALGORITHM *********************************************************** #
9964#       An underflow should occur as the result of transcendental       #
9965# emulation in the 060FPLSP. Create an underflow by using "fmul"        #
9966# and two very small numbers of appropriate sign so the operating       #
9967# system can log the event.                                             #
9968#                                                                       #
9969#########################################################################
9970
9971        global          t_unfl
9972t_unfl:
9973        tst.b           SRC_EX(%a0)
9974        bpl.b           unf_pos
9975
9976        global          t_unfl2
9977t_unfl2:
9978        ori.l           &unfinx_mask+neg_mask,USER_FPSR(%a6) # set N/UNFL/INEX2/AUNFL/AINEX
9979
9980        fmov.l          USER_FPCR(%a6),%fpcr
9981        fmovm.x         mns_tiny(%pc),&0x80
9982        fmul.x          pls_tiny(%pc),%fp0
9983
9984        fmov.l          %fpsr,%d0
9985        rol.l           &0x8,%d0
9986        mov.b           %d0,FPSR_CC(%a6)
9987        rts
9988unf_pos:
9989        ori.w           &unfinx_mask,FPSR_EXCEPT(%a6) # set UNFL/INEX2/AUNFL/AINEX
9990
9991        fmov.l          USER_FPCR(%a6),%fpcr
9992        fmovm.x         pls_tiny(%pc),&0x80
9993        fmul.x          %fp0,%fp0
9994
9995        fmov.l          %fpsr,%d0
9996        rol.l           &0x8,%d0
9997        mov.b           %d0,FPSR_CC(%a6)
9998        rts
9999
10000#########################################################################

10001# XDEF **************************************************************** #
10002#       t_ovfl(): Handle 060FPLSP overflow exception during emulation.  #
10003#                 (monadic)                                             #
10004#       t_ovfl2(): Handle 060FPLSP overflow exception during            #
10005#                  emulation. result always positive. (dyadic)          #
10006#       t_ovfl_sc(): Handle 060FPLSP overflow exception during          #
10007#                    emulation for "fscale".                            #
10008#                                                                       #
10009#       This routine is used by the 060FPLSP package.                   #
10010#                                                                       #
10011# XREF **************************************************************** #
10012#       None.                                                           #
10013#                                                                       #
10014# INPUT *************************************************************** #
10015#       a0 = pointer to extended precision source operand               #
10016#                                                                       #
10017# OUTPUT ************************************************************** #
10018#       fp0 = default underflow result                                  #
10019#                                                                       #
10020# ALGORITHM *********************************************************** #
10021#       An overflow should occur as the result of transcendental        #
10022# emulation in the 060FPLSP. Create an overflow by using "fmul"         #
10023# and two very lareg numbers of appropriate sign so the operating       #
10024# system can log the event.                                             #
10025#       For t_ovfl_sc() we take special care not to lose the INEX2 bit. #
10026#                                                                       #
10027#########################################################################
10028
10029        global          t_ovfl_sc
10030t_ovfl_sc:
10031        ori.l           &ovfl_inx_mask,USER_FPSR(%a6) # set OVFL/AOVFL/AINEX
10032
10033        mov.b           %d0,%d1                 # fetch rnd prec,mode
10034        andi.b          &0xc0,%d1               # extract prec
10035        beq.w           ovfl_work
10036
10037# dst op is a DENORM. we have to normalize the mantissa to see if the
10038# result would be inexact for the given precision. make a copy of the
10039# dst so we don't screw up the version passed to us.
10040        mov.w           LOCAL_EX(%a0),FP_SCR0_EX(%a6)
10041        mov.l           LOCAL_HI(%a0),FP_SCR0_HI(%a6)
10042        mov.l           LOCAL_LO(%a0),FP_SCR0_LO(%a6)
10043        lea             FP_SCR0(%a6),%a0        # pass ptr to FP_SCR0
10044        movm.l          &0xc080,-(%sp)          # save d0-d1/a0
10045        bsr.l           norm                    # normalize mantissa
10046        movm.l          (%sp)+,&0x0103          # restore d0-d1/a0
10047
10048        cmpi.b          %d1,&0x40               # is precision sgl?
10049        bne.b           ovfl_sc_dbl             # no; dbl
10050ovfl_sc_sgl:
10051        tst.l           LOCAL_LO(%a0)           # is lo lw of sgl set?
10052        bne.b           ovfl_sc_inx             # yes
10053        tst.b           3+LOCAL_HI(%a0)         # is lo byte of hi lw set?
10054        bne.b           ovfl_sc_inx             # yes
10055        bra.w           ovfl_work               # don't set INEX2
10056ovfl_sc_dbl:
10057        mov.l           LOCAL_LO(%a0),%d1       # are any of lo 11 bits of
10058        andi.l          &0x7ff,%d1              # dbl mantissa set?
10059        beq.w           ovfl_work               # no; don't set INEX2
10060ovfl_sc_inx:
10061        ori.l           &inex2_mask,USER_FPSR(%a6) # set INEX2
10062        bra.b           ovfl_work               # continue
10063
10064        global          t_ovfl
10065t_ovfl:
10066        ori.w           &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
10067ovfl_work:
10068        tst.b           SRC_EX(%a0)
10069        bpl.b           ovfl_p
10070ovfl_m:
10071        fmov.l          USER_FPCR(%a6),%fpcr
10072        fmovm.x         mns_huge(%pc),&0x80
10073        fmul.x          pls_huge(%pc),%fp0
10074
10075        fmov.l          %fpsr,%d0
10076        rol.l           &0x8,%d0
10077        ori.b           &neg_mask,%d0
10078        mov.b           %d0,FPSR_CC(%a6)
10079        rts
10080ovfl_p:
10081        fmov.l          USER_FPCR(%a6),%fpcr
10082        fmovm.x         pls_huge(%pc),&0x80
10083        fmul.x          pls_huge(%pc),%fp0
10084
10085        fmov.l          %fpsr,%d0
10086        rol.l           &0x8,%d0
10087        mov.b           %d0,FPSR_CC(%a6)
10088        rts
10089
10090        global          t_ovfl2
10091t_ovfl2:
10092        ori.w           &ovfinx_mask,FPSR_EXCEPT(%a6) # set OVFL/INEX2/AOVFL/AINEX
10093        fmov.l          USER_FPCR(%a6),%fpcr
10094        fmovm.x         pls_huge(%pc),&0x80
10095        fmul.x          pls_huge(%pc),%fp0
10096
10097        fmov.l          %fpsr,%d0
10098        rol.l           &0x8,%d0
10099        mov.b           %d0,FPSR_CC(%a6)
10100        rts
10101
10102#########################################################################
10103# XDEF **************************************************************** #
10104#       t_catch(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during  #
10105#                  emulation.                                           #
10106#       t_catch2(): Handle 060FPLSP OVFL,UNFL,or INEX2 exception during #
10107#                   emulation.                                          #
10108#                                                                       #
10109#       These routines are used by the 060FPLSP package.                #
10110#                                                                       #
10111# XREF **************************************************************** #
10112#       None.                                                           #
10113#                                                                       #
10114# INPUT *************************************************************** #
10115#       fp0 = default underflow or overflow result                      #
10116#                                                                       #
10117# OUTPUT ************************************************************** #
10118#       fp0 = default result                                            #
10119#                                                                       #
10120# ALGORITHM *********************************************************** #
10121#       If an overflow or underflow occurred during the last            #
10122# instruction of transcendental 060FPLSP emulation, then it has already #
10123# occurred and has been logged. Now we need to see if an inexact        #
10124# exception should occur.                                               #
10125#                                                                       #
10126#########################################################################
10127
10128        global          t_catch2
10129t_catch2:
10130        fmov.l          %fpsr,%d0
10131        or.l            %d0,USER_FPSR(%a6)
10132        bra.b           inx2_work
10133
10134        global          t_catch
10135t_catch:
10136        fmov.l          %fpsr,%d0
10137        or.l            %d0,USER_FPSR(%a6)
10138
10139#########################################################################
10140# XDEF **************************************************************** #
10141#       t_inx2(): Handle inexact 060FPLSP exception during emulation.   #
10142#       t_pinx2(): Handle inexact 060FPLSP exception for "+" results.   #
10143#       t_minx2(): Handle inexact 060FPLSP exception for "-" results.   #
10144#                                                                       #
10145# XREF **************************************************************** #
10146#       None.                                                           #
10147#                                                                       #
10148# INPUT *************************************************************** #
10149#       fp0 = default result                                            #
10150#                                                                       #
10151# OUTPUT ************************************************************** #
10152#       fp0 = default result                                            #
10153#                                                                       #
10154# ALGORITHM *********************************************************** #
10155#       The last instruction of transcendental emulation for the        #
10156# 060FPLSP should be inexact. So, if inexact is enabled, then we create #
10157# the event here by adding a large and very small number together       #
10158# so that the operating system can log the event.                       #
10159#       Must check, too, if the result was zero, in which case we just  #
10160# set the FPSR bits and return.                                         #
10161#                                                                       #
10162#########################################################################
10163
10164        global          t_inx2
10165t_inx2:
10166        fblt.w          t_minx2
10167        fbeq.w          inx2_zero
10168
10169        global          t_pinx2
10170t_pinx2:
10171        ori.w           &inx2a_mask,FPSR_EXCEPT(%a6) # set INEX2/AINEX
10172        bra.b           inx2_work
10173
10174        global          t_minx2
10175t_minx2:
10176        ori.l           &inx2a_mask+neg_mask,USER_FPSR(%a6)
10177
10178inx2_work:
10179        btst            &inex2_bit,FPCR_ENABLE(%a6) # is inexact enabled?
10180        bne.b           inx2_work_ena           # yes
10181        rts
10182inx2_work_ena:
10183        fmov.l          USER_FPCR(%a6),%fpcr    # insert user's exceptions
10184        fmov.s          &0x3f800000,%fp1        # load +1
10185        fadd.x          pls_tiny(%pc),%fp1      # cause exception
10186        rts
10187
10188inx2_zero:
10189        mov.b           &z_bmask,FPSR_CC(%a6)
10190        ori.w           &inx2a_mask,2+USER_FPSR(%a6) # set INEX/AINEX
10191        rts
10192
10193#########################################################################
10194# XDEF **************************************************************** #
10195#       t_extdnrm(): Handle DENORM inputs in 060FPLSP.                  #
10196#       t_resdnrm(): Handle DENORM inputs in 060FPLSP for "fscale".     #
10197#                                                                       #
10198#       This routine is used by the 060FPLSP package.                   #
10199#                                                                       #
10200# XREF **************************************************************** #
10201#       None.                                                           #
10202#                                                                       #
10203# INPUT *************************************************************** #
10204#       a0 = pointer to extended precision input operand                #
10205#                                                                       #
10206# OUTPUT ************************************************************** #
10207#       fp0 = default result                                            #
10208#                                                                       #
10209# ALGORITHM *********************************************************** #
10210#       For all functions that have a denormalized input and that       #
10211# f(x)=x, this is the entry point.                                      #
10212#       DENORM value is moved using "fmove" which triggers an exception #
10213# if enabled so the operating system can log the event.                 #
10214#                                                                       #
10215#########################################################################
10216
10217        global          t_extdnrm
10218t_extdnrm:
10219        fmov.l          USER_FPCR(%a6),%fpcr
10220        fmov.x          SRC_EX(%a0),%fp0
10221        fmov.l          %fpsr,%d0
10222        ori.l           &unfinx_mask,%d0
10223        or.l            %d0,USER_FPSR(%a6)
10224        rts
10225
10226        global          t_resdnrm
10227t_resdnrm:
10228        fmov.l          USER_FPCR(%a6),%fpcr
10229        fmov.x          SRC_EX(%a0),%fp0
10230        fmov.l          %fpsr,%d0
10231        or.l            %d0,USER_FPSR(%a6)
10232        rts
10233
10234##########################################
10235
10236#
10237# sto_cos:
10238#       This is used by fsincos library emulation. The correct
10239# values are already in fp0 and fp1 so we do nothing here.
10240#
10241        global          sto_cos
10242sto_cos:
10243        rts
10244
10245##########################################
10246
10247#
10248#       dst_qnan --- force result when destination is a NaN
10249#
10250        global          dst_qnan
10251dst_qnan:
10252        fmov.x          DST(%a1),%fp0
10253        tst.b           DST_EX(%a1)
10254        bmi.b           dst_qnan_m
10255dst_qnan_p:
10256        mov.b           &nan_bmask,FPSR_CC(%a6)
10257        rts
10258dst_qnan_m:
10259        mov.b           &nan_bmask+neg_bmask,FPSR_CC(%a6)
10260        rts
10261
10262#
10263#       src_qnan --- force result when source is a NaN
10264#
10265        global          src_qnan
10266src_qnan:
10267        fmov.x          SRC(%a0),%fp0
10268        tst.b           SRC_EX(%a0)
10269        bmi.b           src_qnan_m
10270src_qnan_p:
10271        mov.b           &nan_bmask,FPSR_CC(%a6)
10272        rts
10273src_qnan_m:
10274        mov.b           &nan_bmask+neg_bmask,FPSR_CC(%a6)
10275        rts
10276
10277##########################################
10278
10279#
10280#       Native instruction support
10281#
10282#       Some systems may need entry points even for 68060 native
10283#       instructions.  These routines are provided for
10284#       convenience.
10285#
10286        global          _fadds_
10287_fadds_:
10288        fmov.l          %fpcr,-(%sp)            # save fpcr
10289        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10290        fmov.s          0x8(%sp),%fp0           # load sgl dst
10291        fmov.l          (%sp)+,%fpcr            # restore fpcr
10292        fadd.s          0x8(%sp),%fp0           # fadd w/ sgl src
10293        rts
10294
10295        global          _faddd_
10296_faddd_:
10297        fmov.l          %fpcr,-(%sp)            # save fpcr
10298        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10299        fmov.d          0x8(%sp),%fp0           # load dbl dst
10300        fmov.l          (%sp)+,%fpcr            # restore fpcr
10301        fadd.d          0xc(%sp),%fp0           # fadd w/ dbl src
10302        rts
10303
10304        global          _faddx_
10305_faddx_:
10306        fmovm.x         0x4(%sp),&0x80          # load ext dst
10307        fadd.x          0x10(%sp),%fp0          # fadd w/ ext src
10308        rts
10309
10310        global          _fsubs_
10311_fsubs_:
10312        fmov.l          %fpcr,-(%sp)            # save fpcr
10313        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10314        fmov.s          0x8(%sp),%fp0           # load sgl dst
10315        fmov.l          (%sp)+,%fpcr            # restore fpcr
10316        fsub.s          0x8(%sp),%fp0           # fsub w/ sgl src
10317        rts
10318
10319        global          _fsubd_
10320_fsubd_:
10321        fmov.l          %fpcr,-(%sp)            # save fpcr
10322        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10323        fmov.d          0x8(%sp),%fp0           # load dbl dst
10324        fmov.l          (%sp)+,%fpcr            # restore fpcr
10325        fsub.d          0xc(%sp),%fp0           # fsub w/ dbl src
10326        rts
10327
10328        global          _fsubx_
10329_fsubx_:
10330        fmovm.x         0x4(%sp),&0x80          # load ext dst
10331        fsub.x          0x10(%sp),%fp0          # fsub w/ ext src
10332        rts
10333
10334        global          _fmuls_
10335_fmuls_:
10336        fmov.l          %fpcr,-(%sp)            # save fpcr
10337        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10338        fmov.s          0x8(%sp),%fp0           # load sgl dst
10339        fmov.l          (%sp)+,%fpcr            # restore fpcr
10340        fmul.s          0x8(%sp),%fp0           # fmul w/ sgl src
10341        rts
10342
10343        global          _fmuld_
10344_fmuld_:
10345        fmov.l          %fpcr,-(%sp)            # save fpcr
10346        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10347        fmov.d          0x8(%sp),%fp0           # load dbl dst
10348        fmov.l          (%sp)+,%fpcr            # restore fpcr
10349        fmul.d          0xc(%sp),%fp0           # fmul w/ dbl src
10350        rts
10351
10352        global          _fmulx_
10353_fmulx_:
10354        fmovm.x         0x4(%sp),&0x80          # load ext dst
10355        fmul.x          0x10(%sp),%fp0          # fmul w/ ext src
10356        rts
10357
10358        global          _fdivs_
10359_fdivs_:
10360        fmov.l          %fpcr,-(%sp)            # save fpcr
10361        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10362        fmov.s          0x8(%sp),%fp0           # load sgl dst
10363        fmov.l          (%sp)+,%fpcr            # restore fpcr
10364        fdiv.s          0x8(%sp),%fp0           # fdiv w/ sgl src
10365        rts
10366
10367        global          _fdivd_
10368_fdivd_:
10369        fmov.l          %fpcr,-(%sp)            # save fpcr
10370        fmov.l          &0x00000000,%fpcr       # clear fpcr for load
10371        fmov.d          0x8(%sp),%fp0           # load dbl dst
10372        fmov.l          (%sp)+,%fpcr            # restore fpcr
10373        fdiv.d          0xc(%sp),%fp0           # fdiv w/ dbl src
10374        rts
10375
10376        global          _fdivx_
10377_fdivx_:
10378        fmovm.x         0x4(%sp),&0x80          # load ext dst
10379        fdiv.x          0x10(%sp),%fp0          # fdiv w/ ext src
10380        rts
10381
10382        global          _fabss_
10383_fabss_:
10384        fabs.s          0x4(%sp),%fp0           # fabs w/ sgl src
10385        rts
10386
10387        global          _fabsd_
10388_fabsd_:
10389        fabs.d          0x4(%sp),%fp0           # fabs w/ dbl src
10390        rts
10391
10392        global          _fabsx_
10393_fabsx_:
10394        fabs.x          0x4(%sp),%fp0           # fabs w/ ext src
10395        rts
10396
10397        global          _fnegs_
10398_fnegs_:
10399        fneg.s          0x4(%sp),%fp0           # fneg w/ sgl src
10400        rts
10401
10402        global          _fnegd_
10403_fnegd_:
10404        fneg.d          0x4(%sp),%fp0           # fneg w/ dbl src
10405        rts
10406
10407        global          _fnegx_
10408_fnegx_:
10409        fneg.x          0x4(%sp),%fp0           # fneg w/ ext src
10410        rts
10411
10412        global          _fsqrts_
10413_fsqrts_:
10414        fsqrt.s         0x4(%sp),%fp0           # fsqrt w/ sgl src
10415        rts
10416
10417        global          _fsqrtd_
10418_fsqrtd_:
10419        fsqrt.d         0x4(%sp),%fp0           # fsqrt w/ dbl src
10420        rts
10421
10422        global          _fsqrtx_
10423_fsqrtx_:
10424        fsqrt.x         0x4(%sp),%fp0           # fsqrt w/ ext src
10425        rts
10426
10427        global          _fints_
10428_fints_:
10429        fint.s          0x4(%sp),%fp0           # fint w/ sgl src
10430        rts
10431
10432        global          _fintd_
10433_fintd_:
10434        fint.d          0x4(%sp),%fp0           # fint w/ dbl src
10435        rts
10436
10437        global          _fintx_
10438_fintx_:
10439        fint.x          0x4(%sp),%fp0           # fint w/ ext src
10440        rts
10441
10442        global          _fintrzs_
10443_fintrzs_:
10444        fintrz.s        0x4(%sp),%fp0           # fintrz w/ sgl src
10445        rts
10446
10447        global          _fintrzd_
10448_fintrzd_:
10449        fintrz.d        0x4(%sp),%fp0           # fintrx w/ dbl src
10450        rts
10451
10452        global          _fintrzx_
10453_fintrzx_:
10454        fintrz.x        0x4(%sp),%fp0           # fintrz w/ ext src
10455        rts
10456
10457########################################################################
10458
10459#########################################################################
10460# src_zero(): Return signed zero according to sign of src operand.      #
10461#########################################################################
10462        global          src_zero
10463src_zero:
10464        tst.b           SRC_EX(%a0)             # get sign of src operand
10465        bmi.b           ld_mzero                # if neg, load neg zero
10466
10467#
10468# ld_pzero(): return a positive zero.
10469#
10470        global          ld_pzero
10471ld_pzero:
10472        fmov.s          &0x00000000,%fp0        # load +0
10473        mov.b           &z_bmask,FPSR_CC(%a6)   # set 'Z' ccode bit
10474        rts
10475
10476# ld_mzero(): return a negative zero.
10477        global          ld_mzero
10478ld_mzero:
10479        fmov.s          &0x80000000,%fp0        # load -0
10480        mov.b           &neg_bmask+z_bmask,FPSR_CC(%a6) # set 'N','Z' ccode bits
10481        rts
10482
10483#########################################################################
10484# dst_zero(): Return signed zero according to sign of dst operand.      #
10485#########################################################################
10486        global          dst_zero
10487dst_zero:
10488        tst.b           DST_EX(%a1)             # get sign of dst operand
10489        bmi.b           ld_mzero                # if neg, load neg zero
10490        bra.b           ld_pzero                # load positive zero
10491
10492#########################################################################
10493# src_inf(): Return signed inf according to sign of src operand.        #
10494#########################################################################
10495        global          src_inf
10496src_inf:
10497        tst.b           SRC_EX(%a0)             # get sign of src operand
10498        bmi.b           ld_minf                 # if negative branch
10499
10500#
10501# ld_pinf(): return a positive infinity.
10502#
10503        global          ld_pinf
10504ld_pinf:
10505        fmov.s          &0x7f800000,%fp0        # load +INF
10506        mov.b           &inf_bmask,FPSR_CC(%a6) # set 'INF' ccode bit
10507        rts
10508
10509#
10510# ld_minf():return a negative infinity.
10511#
10512        global          ld_minf
10513ld_minf:
10514        fmov.s          &0xff800000,%fp0        # load -INF
10515        mov.b           &neg_bmask+inf_bmask,FPSR_CC(%a6) # set 'N','I' ccode bits
10516        rts
10517
10518#########################################################################
10519# dst_inf(): Return signed inf according to sign of dst operand.        #
10520#########################################################################
10521        global          dst_inf
10522dst_inf:
10523        tst.b           DST_EX(%a1)             # get sign of dst operand
10524        bmi.b           ld_minf                 # if negative branch
10525        bra.b           ld_pinf
10526
10527        global          szr_inf
10528#################################################################
10529# szr_inf(): Return +ZERO for a negative src operand or         #
10530#                   +INF for a positive src operand.            #
10531#            Routine used for fetox, ftwotox, and ftentox.      #
10532#################################################################
10533szr_inf:
10534        tst.b           SRC_EX(%a0)             # check sign of source
10535        bmi.b           ld_pzero
10536        bra.b           ld_pinf
10537
10538#########################################################################
10539# sopr_inf(): Return +INF for a positive src operand or                 #
10540#             jump to operand error routine for a negative src operand. #
10541#             Routine used for flogn, flognp1, flog10, and flog2.       #
10542#########################################################################
10543        global          sopr_inf
10544sopr_inf:
10545        tst.b           SRC_EX(%a0)             # check sign of source
10546        bmi.w           t_operr
10547        bra.b           ld_pinf
10548
10549#################################################################
10550# setoxm1i(): Return minus one for a negative src operand or    #
10551#             positive infinity for a positive src operand.     #
10552#             Routine used for fetoxm1.                         #
10553#################################################################
10554        global          setoxm1i
10555setoxm1i:
10556        tst.b           SRC_EX(%a0)             # check sign of source
10557        bmi.b           ld_mone
10558        bra.b           ld_pinf
10559
10560#########################################################################
10561# src_one(): Return signed one according to sign of src operand.        #
10562#########################################################################
10563        global          src_one
10564src_one:
10565        tst.b           SRC_EX(%a0)             # check sign of source
10566        bmi.b           ld_mone
10567
10568#
10569# ld_pone(): return positive one.
10570#
10571        global          ld_pone
10572ld_pone:
10573        fmov.s          &0x3f800000,%fp0        # load +1
10574        clr.b           FPSR_CC(%a6)
10575        rts
10576
10577#
10578# ld_mone(): return negative one.
10579#
10580        global          ld_mone
10581ld_mone:
10582        fmov.s          &0xbf800000,%fp0        # load -1
10583        mov.b           &neg_bmask,FPSR_CC(%a6) # set 'N' ccode bit
10584        rts
10585
10586ppiby2: long            0x3fff0000, 0xc90fdaa2, 0x2168c235
10587mpiby2: long            0xbfff0000, 0xc90fdaa2, 0x2168c235
10588
10589#################################################################
10590# spi_2(): Return signed PI/2 according to sign of src operand. #
10591#################################################################
10592        global          spi_2
10593spi_2:
10594        tst.b           SRC_EX(%a0)             # check sign of source
10595        bmi.b           ld_mpi2
10596
10597#
10598# ld_ppi2(): return positive PI/2.
10599#
10600        global          ld_ppi2
10601ld_ppi2:
10602        fmov.l          %d0,%fpcr
10603        fmov.x          ppiby2(%pc),%fp0        # load +pi/2
10604        bra.w           t_pinx2                 # set INEX2
10605
10606#
10607# ld_mpi2(): return negative PI/2.
10608#
10609        global          ld_mpi2
10610ld_mpi2:
10611        fmov.l          %d0,%fpcr
10612        fmov.x          mpiby2(%pc),%fp0        # load -pi/2
10613        bra.w           t_minx2                 # set INEX2
10614
10615####################################################
10616# The following routines give support for fsincos. #
10617####################################################
10618
10619#
10620# ssincosz(): When the src operand is ZERO, store a one in the
10621#             cosine register and return a ZERO in fp0 w/ the same sign
10622#             as the src operand.
10623#
10624        global          ssincosz
10625ssincosz:
10626        fmov.s          &0x3f800000,%fp1
10627        tst.b           SRC_EX(%a0)             # test sign
10628        bpl.b           sincoszp
10629        fmov.s          &0x80000000,%fp0        # return sin result in fp0
10630        mov.b           &z_bmask+neg_bmask,FPSR_CC(%a6)
10631        rts
10632sincoszp:
10633        fmov.s          &0x00000000,%fp0        # return sin result in fp0
10634        mov.b           &z_bmask,FPSR_CC(%a6)
10635        rts
10636
10637#
10638# ssincosi(): When the src operand is INF, store a QNAN in the cosine
10639#             register and jump to the operand error routine for negative
10640#             src operands.
10641#
10642        global          ssincosi
10643ssincosi:
10644        fmov.x          qnan(%pc),%fp1          # load NAN
10645        bra.w           t_operr
10646
10647#
10648# ssincosqnan(): When the src operand is a QNAN, store the QNAN in the cosine
10649#                register and branch to the src QNAN routine.
10650#
10651        global          ssincosqnan
10652ssincosqnan:
10653        fmov.x          LOCAL_EX(%a0),%fp1
10654        bra.w           src_qnan
10655
10656########################################################################
10657
10658        global          smod_sdnrm
10659        global          smod_snorm
10660smod_sdnrm:
10661smod_snorm:
10662        mov.b           DTAG(%a6),%d1
10663        beq.l           smod
10664        cmpi.b          %d1,&ZERO
10665        beq.w           smod_zro
10666        cmpi.b          %d1,&INF
10667        beq.l           t_operr
10668        cmpi.b          %d1,&DENORM
10669        beq.l           smod
10670        bra.l           dst_qnan
10671
10672        global          smod_szero
10673smod_szero:
10674        mov.b           DTAG(%a6),%d1
10675        beq.l           t_operr
10676        cmpi.b          %d1,&ZERO
10677        beq.l           t_operr
10678        cmpi.b          %d1,&INF
10679        beq.l           t_operr
10680        cmpi.b          %d1,&DENORM
10681        beq.l           t_operr
10682        bra.l           dst_qnan
10683
10684        global          smod_sinf
10685smod_sinf:
10686        mov.b           DTAG(%a6),%d1
10687        beq.l           smod_fpn
10688        cmpi.b          %d1,&ZERO
10689        beq.l           smod_zro
10690        cmpi.b          %d1,&INF
10691        beq.l           t_operr
10692        cmpi.b          %d1,&DENORM
10693        beq.l           smod_fpn
10694        bra.l           dst_qnan
10695
10696smod_zro:
10697srem_zro:
10698        mov.b           SRC_EX(%a0),%d1         # get src sign
10699        mov.b           DST_EX(%a1),%d0         # get dst sign
10700        eor.b           %d0,%d1                 # get qbyte sign
10701        andi.b          &0x80,%d1
10702        mov.b           %d1,FPSR_QBYTE(%a6)
10703        tst.b           %d0
10704        bpl.w           ld_pzero
10705        bra.w           ld_mzero
10706
10707smod_fpn:
10708srem_fpn:
10709        clr.b           FPSR_QBYTE(%a6)
10710        mov.l           %d0,-(%sp)
10711        mov.b           SRC_EX(%a0),%d1         # get src sign
10712        mov.b           DST_EX(%a1),%d0         # get dst sign
10713        eor.b           %d0,%d1                 # get qbyte sign
10714        andi.b          &0x80,%d1
10715        mov.b           %d1,FPSR_QBYTE(%a6)
10716        cmpi.b          DTAG(%a6),&DENORM
10717        bne.b           smod_nrm
10718        lea             DST(%a1),%a0
10719        mov.l           (%sp)+,%d0
10720        bra             t_resdnrm
10721smod_nrm:
10722        fmov.l          (%sp)+,%fpcr
10723        fmov.x          DST(%a1),%fp0
10724        tst.b           DST_EX(%a1)
10725        bmi.b           smod_nrm_neg
10726        rts
10727
10728smod_nrm_neg:
10729        mov.b           &neg_bmask,FPSR_CC(%a6) # set 'N' code
10730        rts
10731
10732#########################################################################
10733        global          srem_snorm
10734        global          srem_sdnrm
10735srem_sdnrm:
10736srem_snorm:
10737        mov.b           DTAG(%a6),%d1
10738        beq.l           srem
10739        cmpi.b          %d1,&ZERO
10740        beq.w           srem_zro
10741        cmpi.b          %d1,&INF
10742        beq.l           t_operr
10743        cmpi.b          %d1,&DENORM
10744        beq.l           srem
10745        bra.l           dst_qnan
10746
10747        global          srem_szero
10748srem_szero:
10749        mov.b           DTAG(%a6),%d1
10750        beq.l           t_operr
10751        cmpi.b          %d1,&ZERO
10752        beq.l           t_operr
10753        cmpi.b          %d1,&INF
10754        beq.l           t_operr
10755        cmpi.b          %d1,&DENORM
10756        beq.l           t_operr
10757        bra.l           dst_qnan
10758
10759        global          srem_sinf
10760srem_sinf:
10761        mov.b           DTAG(%a6),%d1
10762        beq.w           srem_fpn
10763        cmpi.b          %d1,&ZERO
10764        beq.w           srem_zro
10765        cmpi.b          %d1,&INF
10766        beq.l           t_operr
10767        cmpi.b          %d1,&DENORM
10768        beq.l           srem_fpn
10769        bra.l           dst_qnan
10770
10771#########################################################################
10772
10773        global          sscale_snorm
10774        global          sscale_sdnrm
10775sscale_snorm:
10776sscale_sdnrm:
10777        mov.b           DTAG(%a6),%d1
10778        beq.l           sscale
10779        cmpi.b          %d1,&ZERO
10780        beq.l           dst_zero
10781        cmpi.b          %d1,&INF
10782        beq.l           dst_inf
10783        cmpi.b          %d1,&DENORM
10784        beq.l           sscale
10785        bra.l           dst_qnan
10786
10787        global          sscale_szero
10788sscale_szero:
10789        mov.b           DTAG(%a6),%d1
10790        beq.l           sscale
10791        cmpi.b          %d1,&ZERO
10792        beq.l           dst_zero
10793        cmpi.b          %d1,&INF
10794        beq.l           dst_inf
10795        cmpi.b          %d1,&DENORM
10796        beq.l           sscale
10797        bra.l           dst_qnan
10798
10799        global          sscale_sinf
10800sscale_sinf:
10801        mov.b           DTAG(%a6),%d1
10802        beq.l           t_operr
10803        cmpi.b          %d1,&QNAN
10804        beq.l           dst_qnan
10805        bra.l           t_operr
10806
10807########################################################################
10808
10809        global          sop_sqnan
10810sop_sqnan:
10811        mov.b           DTAG(%a6),%d1
10812        cmpi.b          %d1,&QNAN
10813        beq.l           dst_qnan
10814        bra.l           src_qnan
10815
10816#########################################################################
10817# norm(): normalize the mantissa of an extended precision input. the    #
10818#         input operand should not be normalized already.               #
10819#                                                                       #
10820# XDEF **************************************************************** #
10821#       norm()                                                          #
10822#                                                                       #
10823# XREF **************************************************************** #
10824#       none                                                            #
10825#                                                                       #
10826# INPUT *************************************************************** #
10827#       a0 = pointer fp extended precision operand to normalize         #
10828#                                                                       #
10829# OUTPUT ************************************************************** #
10830#       d0 = number of bit positions the mantissa was shifted           #
10831#       a0 = the input operand's mantissa is normalized; the exponent   #
10832#            is unchanged.                                              #
10833#                                                                       #
10834#########################################################################
10835        global          norm
10836norm:
10837        mov.l           %d2, -(%sp)             # create some temp regs
10838        mov.l           %d3, -(%sp)
10839
10840        mov.l           FTEMP_HI(%a0), %d0      # load hi(mantissa)
10841        mov.l           FTEMP_LO(%a0), %d1      # load lo(mantissa)
10842
10843        bfffo           %d0{&0:&32}, %d2        # how many places to shift?
10844        beq.b           norm_lo                 # hi(man) is all zeroes!
10845
10846norm_hi:
10847        lsl.l           %d2, %d0                # left shift hi(man)
10848        bfextu          %d1{&0:%d2}, %d3        # extract lo bits
10849
10850        or.l            %d3, %d0                # create hi(man)
10851        lsl.l           %d2, %d1                # create lo(man)
10852
10853        mov.l           %d0, FTEMP_HI(%a0)      # store new hi(man)
10854        mov.l           %d1, FTEMP_LO(%a0)      # store new lo(man)
10855
10856        mov.l           %d2, %d0                # return shift amount
10857
10858        mov.l           (%sp)+, %d3             # restore temp regs
10859        mov.l           (%sp)+, %d2
10860
10861        rts
10862
10863norm_lo:
10864        bfffo           %d1{&0:&32}, %d2        # how many places to shift?
10865        lsl.l           %d2, %d1                # shift lo(man)
10866        add.l           &32, %d2                # add 32 to shft amount
10867
10868        mov.l           %d1, FTEMP_HI(%a0)      # store hi(man)
10869        clr.l           FTEMP_LO(%a0)           # lo(man) is now zero
10870
10871        mov.l           %d2, %d0                # return shift amount
10872
10873        mov.l           (%sp)+, %d3             # restore temp regs
10874        mov.l           (%sp)+, %d2
10875
10876        rts
10877
10878#########################################################################
10879# unnorm_fix(): - changes an UNNORM to one of NORM, DENORM, or ZERO     #
10880#               - returns corresponding optype tag                      #
10881#                                                                       #
10882# XDEF **************************************************************** #
10883#       unnorm_fix()                                                    #
10884#                                                                       #
10885# XREF **************************************************************** #
10886#       norm() - normalize the mantissa                                 #
10887#                                                                       #
10888# INPUT *************************************************************** #
10889#       a0 = pointer to unnormalized extended precision number          #
10890#                                                                       #
10891# OUTPUT ************************************************************** #
10892#       d0 = optype tag - is corrected to one of NORM, DENORM, or ZERO  #
10893#       a0 = input operand has been converted to a norm, denorm, or     #
10894#            zero; both the exponent and mantissa are changed.          #
10895#                                                                       #
10896#########################################################################
10897
10898        global          unnorm_fix
10899unnorm_fix:
10900        bfffo           FTEMP_HI(%a0){&0:&32}, %d0 # how many shifts are needed?
10901        bne.b           unnorm_shift            # hi(man) is not all zeroes
10902
10903#
10904# hi(man) is all zeroes so see if any bits in lo(man) are set
10905#
10906unnorm_chk_lo:
10907        bfffo           FTEMP_LO(%a0){&0:&32}, %d0 # is operand really a zero?
10908        beq.w           unnorm_zero             # yes
10909
10910        add.w           &32, %d0                # no; fix shift distance
10911
10912#
10913# d0 = # shifts needed for complete normalization
10914#
10915unnorm_shift:
10916        clr.l           %d1                     # clear top word
10917        mov.w           FTEMP_EX(%a0), %d1      # extract exponent
10918        and.w           &0x7fff, %d1            # strip off sgn
10919
10920        cmp.w           %d0, %d1                # will denorm push exp < 0?
10921        bgt.b           unnorm_nrm_zero         # yes; denorm only until exp = 0
10922
10923#
10924# exponent would not go < 0. therefore, number stays normalized
10925#
10926        sub.w           %d0, %d1                # shift exponent value
10927        mov.w           FTEMP_EX(%a0), %d0      # load old exponent
10928        and.w           &0x8000, %d0            # save old sign
10929        or.w            %d0, %d1                # {sgn,new exp}
10930        mov.w           %d1, FTEMP_EX(%a0)      # insert new exponent
10931
10932        bsr.l           norm                    # normalize UNNORM
10933
10934        mov.b           &NORM, %d0              # return new optype tag
10935        rts
10936
10937#
10938# exponent would go < 0, so only denormalize until exp = 0
10939#
10940unnorm_nrm_zero:
10941        cmp.b           %d1, &32                # is exp <= 32?
10942        bgt.b           unnorm_nrm_zero_lrg     # no; go handle large exponent
10943
10944        bfextu          FTEMP_HI(%a0){%d1:&32}, %d0 # extract new hi(man)
10945        mov.l           %d0, FTEMP_HI(%a0)      # save new hi(man)
10946
10947        mov.l           FTEMP_LO(%a0), %d0      # fetch old lo(man)
10948        lsl.l           %d1, %d0                # extract new lo(man)
10949        mov.l           %d0, FTEMP_LO(%a0)      # save new lo(man)
10950
10951        and.w           &0x8000, FTEMP_EX(%a0)  # set exp = 0
10952
10953        mov.b           &DENORM, %d0            # return new optype tag
10954        rts
10955
10956#
10957# only mantissa bits set are in lo(man)
10958#
10959unnorm_nrm_zero_lrg:
10960        sub.w           &32, %d1                # adjust shft amt by 32
10961
10962        mov.l           FTEMP_LO(%a0), %d0      # fetch old lo(man)
10963        lsl.l           %d1, %d0                # left shift lo(man)
10964
10965        mov.l           %d0, FTEMP_HI(%a0)      # store new hi(man)
10966        clr.l           FTEMP_LO(%a0)           # lo(man) = 0
10967
10968        and.w           &0x8000, FTEMP_EX(%a0)  # set exp = 0
10969
10970        mov.b           &DENORM, %d0            # return new optype tag
10971        rts
10972
10973#
10974# whole mantissa is zero so this UNNORM is actually a zero
10975#
10976unnorm_zero:
10977        and.w           &0x8000, FTEMP_EX(%a0)  # force exponent to zero
10978
10979        mov.b           &ZERO, %d0              # fix optype tag
10980        rts
10981