sys/arch/m68k/fpsp/l_entry.sa

   1         section 8
   2         include l_fpsp.h
   3
   4         xref    tag
   5         xref    szero
   6         xref    sinf
   7         xref    sopr_inf
   8         xref    sone
   9         xref    spi_2
  10         xref    szr_inf
  11         xref    src_nan
  12         xref    t_operr
  13         xref    t_dz2
  14         xref    snzrinx
  15         xref    ld_pone
  16         xref    ld_pinf
  17         xref    ld_ppi2
  18         xref    ssincosz
  19         xref    ssincosi
  20         xref    ssincosnan
  21         xref    setoxm1i
  22 *
  23 *       MONADIC.GEN 1.4 1/16/92
  24 *
  25 *       MONADIC.GEN 1.3 4/30/91
  26 *
  27 *       MONADIC.GEN --- generic MONADIC template
  28 *
  29 *       This version saves all registers that will be used by the emulation
  30 *       routines and restores all but FP0 on exit.  The FPSR is
  31 *       updated to reflect the result of the operation.  Return value
  32 *       is placed in FP0 for single, double and extended results.
  33 *
  34 *       The package subroutines expect the incoming FPCR to be zeroed
  35 *       since they need extended precision to work properly.  The
  36 *       'final' FPCR is expected in d1 so that the calculated result
  37 *       can be properly sized and rounded.  Also, if the incoming FPCR
  38 *       has enabled any exceptions, the exception will be taken on the
  39 *       final fmovem in this template.
  40 *
  41 *       Customizations:
  42 *               1. Remove the movem.l at the entry and exit of
  43 *                  each routine if your compiler treats those
  44 *                  registers as scratch.
  45 *               2. Likewise, don't save FP0/FP1 if they are scratch
  46 *                  registers.
  47 *               3. Delete handling of the fpsr if you only care about
  48 *                  the result.
  49 *               4. Some (most?) C compilers convert all float arguments
  50 *                  to double, and provide no support at all for extended
  51 *                  precision so remove the facoss and facosx entry points.
  52 *               5. Move the result to d0/d1 if the compiler is that old.
  53
  54 *               Copyright (C) Motorola, Inc. 1991
  55 *                       All Rights Reserved
  56 *
  57 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
  58 *       The copyright notice above does not evidence any
  59 *       actual or intended publication of such source code.
  60
  61         xref    tag
  62         xref    sacos
  63         xref    ld_ppi2
  64         xref    t_operr
  65         xref    mon_nan
  66         xref    sacosd
  67
  68         xdef    facoss
  69 facoss:
  70         link    a6,#-LOCAL_SIZE
  71         movem.l d0-d1/a0-a1,USER_DA(a6)
  72         fmovem.x fp0-fp3,USER_FP0(a6)
  73         fmove.l fpsr,USER_FPSR(a6)
  74         fmove.l fpcr,USER_FPCR(a6)
  75         fmove.l fpcr,d1         ; user's rounding mode/precision
  76         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
  77 *
  78 *       copy, convert and tag input argument
  79 *
  80         fmove.s 8(a6),fp0
  81         fmove.x fp0,ETEMP(a6)
  82         lea     ETEMP(a6),a0
  83         bsr     tag
  84         move.b  d0,STAG(a6)
  85         tst.b   d0
  86         bne.b   L_1012
  87         bsr     sacos           ; normalized (regular) number
  88         bra.b   L_1016
  89 L_1012:
  90         cmp.b   #$20,d0         ; zero?
  91         bne.b   L_1013
  92         bsr     ld_ppi2
  93         bra.b   L_1016
  94 L_1013:
  95         cmp.b   #$40,d0         ; infinity?
  96         bne.b   L_1014
  97         bsr     t_operr
  98         bra.b   L_1016
  99 L_1014:
 100         cmp.b   #$60,d0         ; NaN?
 101         bne.b   L_1015
 102         bsr     mon_nan
 103         bra.b   L_1016
 104 L_1015:
 105         bsr     sacosd          ; assuming a denorm...
 106
 107 L_1016:
 108         fmove.l fpsr,d0         ; update status register
 109         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 110         fmove.l d0,fpsr
 111 *
 112 *       Result is now in FP0
 113 *
 114         movem.l USER_DA(a6),d0-d1/a0-a1
 115         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 116         unlk    a6
 117         rts
 118
 119         xdef    facosd
 120 facosd:
 121         link    a6,#-LOCAL_SIZE
 122         movem.l d0-d1/a0-a1,USER_DA(a6)
 123         fmovem.x fp0-fp3,USER_FP0(a6)
 124         fmove.l fpsr,USER_FPSR(a6)
 125         fmove.l fpcr,USER_FPCR(a6)
 126         fmove.l fpcr,d1         ; user's rounding mode/precision
 127         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 128 *
 129 *       copy, convert and tag input argument
 130 *
 131         fmove.d 8(a6),fp0
 132         fmove.x fp0,ETEMP(a6)
 133         lea     ETEMP(a6),a0
 134         bsr     tag
 135         move.b  d0,STAG(a6)
 136         tst.b   d0
 137         bne.b   L_1017
 138         bsr     sacos           ; normalized (regular) number
 139         bra.b   L_101B
 140 L_1017:
 141         cmp.b   #$20,d0         ; zero?
 142         bne.b   L_1018
 143         bsr     ld_ppi2
 144         bra.b   L_101B
 145 L_1018:
 146         cmp.b   #$40,d0         ; infinity?
 147         bne.b   L_1019
 148         bsr     t_operr
 149         bra.b   L_101B
 150 L_1019:
 151         cmp.b   #$60,d0         ; NaN?
 152         bne.b   L_101A
 153         bsr     mon_nan
 154         bra.b   L_101B
 155 L_101A:
 156         bsr     sacosd          ; assuming a denorm...
 157
 158 L_101B:
 159         fmove.l fpsr,d0         ; update status register
 160         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 161         fmove.l d0,fpsr
 162 *
 163 *       Result is now in FP0
 164 *
 165         movem.l USER_DA(a6),d0-d1/a0-a1
 166         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 167         unlk    a6
 168         rts
 169
 170         xdef    facosx
 171 facosx:
 172         link    a6,#-LOCAL_SIZE
 173         movem.l d0-d1/a0-a1,USER_DA(a6)
 174         fmovem.x fp0-fp3,USER_FP0(a6)
 175         fmove.l fpsr,USER_FPSR(a6)
 176         fmove.l fpcr,USER_FPCR(a6)
 177         fmove.l fpcr,d1         ; user's rounding mode/precision
 178         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 179 *
 180 *       copy, convert and tag input argument
 181 *
 182         fmove.x 8(a6),fp0
 183         fmove.x fp0,ETEMP(a6)
 184         lea     ETEMP(a6),a0
 185         bsr     tag
 186         move.b  d0,STAG(a6)
 187         tst.b   d0
 188         bne.b   L_101C
 189         bsr     sacos           ; normalized (regular) number
 190         bra.b   L_101G
 191 L_101C:
 192         cmp.b   #$20,d0         ; zero?
 193         bne.b   L_101D
 194         bsr     ld_ppi2
 195         bra.b   L_101G
 196 L_101D:
 197         cmp.b   #$40,d0         ; infinity?
 198         bne.b   L_101E
 199         bsr     t_operr
 200         bra.b   L_101G
 201 L_101E:
 202         cmp.b   #$60,d0         ; NaN?
 203         bne.b   L_101F
 204         bsr     mon_nan
 205         bra.b   L_101G
 206 L_101F:
 207         bsr     sacosd          ; assuming a denorm...
 208
 209 L_101G:
 210         fmove.l fpsr,d0         ; update status register
 211         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 212         fmove.l d0,fpsr
 213 *
 214 *       Result is now in FP0
 215 *
 216         movem.l USER_DA(a6),d0-d1/a0-a1
 217         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 218         unlk    a6
 219         rts
 220
 221 *
 222 *       MONADIC.GEN 1.4 1/16/92
 223 *
 224 *       MONADIC.GEN 1.3 4/30/91
 225 *
 226 *       MONADIC.GEN --- generic MONADIC template
 227 *
 228 *       This version saves all registers that will be used by the emulation
 229 *       routines and restores all but FP0 on exit.  The FPSR is
 230 *       updated to reflect the result of the operation.  Return value
 231 *       is placed in FP0 for single, double and extended results.
 232 *
 233 *       The package subroutines expect the incoming FPCR to be zeroed
 234 *       since they need extended precision to work properly.  The
 235 *       'final' FPCR is expected in d1 so that the calculated result
 236 *       can be properly sized and rounded.  Also, if the incoming FPCR
 237 *       has enabled any exceptions, the exception will be taken on the
 238 *       final fmovem in this template.
 239 *
 240 *       Customizations:
 241 *               1. Remove the movem.l at the entry and exit of
 242 *                  each routine if your compiler treats those
 243 *                  registers as scratch.
 244 *               2. Likewise, don't save FP0/FP1 if they are scratch
 245 *                  registers.
 246 *               3. Delete handling of the fpsr if you only care about
 247 *                  the result.
 248 *               4. Some (most?) C compilers convert all float arguments
 249 *                  to double, and provide no support at all for extended
 250 *                  precision so remove the fasins and fasinx entry points.
 251 *               5. Move the result to d0/d1 if the compiler is that old.
 252
 253 *               Copyright (C) Motorola, Inc. 1991
 254 *                       All Rights Reserved
 255 *
 256 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
 257 *       The copyright notice above does not evidence any
 258 *       actual or intended publication of such source code.
 259
 260         xref    tag
 261         xref    sasin
 262         xref    szero
 263         xref    t_operr
 264         xref    mon_nan
 265         xref    sasind
 266
 267         xdef    fasins
 268 fasins:
 269         link    a6,#-LOCAL_SIZE
 270         movem.l d0-d1/a0-a1,USER_DA(a6)
 271         fmovem.x fp0-fp3,USER_FP0(a6)
 272         fmove.l fpsr,USER_FPSR(a6)
 273         fmove.l fpcr,USER_FPCR(a6)
 274         fmove.l fpcr,d1         ; user's rounding mode/precision
 275         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 276 *
 277 *       copy, convert and tag input argument
 278 *
 279         fmove.s 8(a6),fp0
 280         fmove.x fp0,ETEMP(a6)
 281         lea     ETEMP(a6),a0
 282         bsr     tag
 283         move.b  d0,STAG(a6)
 284         tst.b   d0
 285         bne.b   L_1022
 286         bsr     sasin           ; normalized (regular) number
 287         bra.b   L_1026
 288 L_1022:
 289         cmp.b   #$20,d0         ; zero?
 290         bne.b   L_1023
 291         bsr     szero
 292         bra.b   L_1026
 293 L_1023:
 294         cmp.b   #$40,d0         ; infinity?
 295         bne.b   L_1024
 296         bsr     t_operr
 297         bra.b   L_1026
 298 L_1024:
 299         cmp.b   #$60,d0         ; NaN?
 300         bne.b   L_1025
 301         bsr     mon_nan
 302         bra.b   L_1026
 303 L_1025:
 304         bsr     sasind          ; assuming a denorm...
 305
 306 L_1026:
 307         fmove.l fpsr,d0         ; update status register
 308         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 309         fmove.l d0,fpsr
 310 *
 311 *       Result is now in FP0
 312 *
 313         movem.l USER_DA(a6),d0-d1/a0-a1
 314         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 315         unlk    a6
 316         rts
 317
 318         xdef    fasind
 319 fasind:
 320         link    a6,#-LOCAL_SIZE
 321         movem.l d0-d1/a0-a1,USER_DA(a6)
 322         fmovem.x fp0-fp3,USER_FP0(a6)
 323         fmove.l fpsr,USER_FPSR(a6)
 324         fmove.l fpcr,USER_FPCR(a6)
 325         fmove.l fpcr,d1         ; user's rounding mode/precision
 326         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 327 *
 328 *       copy, convert and tag input argument
 329 *
 330         fmove.d 8(a6),fp0
 331         fmove.x fp0,ETEMP(a6)
 332         lea     ETEMP(a6),a0
 333         bsr     tag
 334         move.b  d0,STAG(a6)
 335         tst.b   d0
 336         bne.b   L_1027
 337         bsr     sasin           ; normalized (regular) number
 338         bra.b   L_102B
 339 L_1027:
 340         cmp.b   #$20,d0         ; zero?
 341         bne.b   L_1028
 342         bsr     szero
 343         bra.b   L_102B
 344 L_1028:
 345         cmp.b   #$40,d0         ; infinity?
 346         bne.b   L_1029
 347         bsr     t_operr
 348         bra.b   L_102B
 349 L_1029:
 350         cmp.b   #$60,d0         ; NaN?
 351         bne.b   L_102A
 352         bsr     mon_nan
 353         bra.b   L_102B
 354 L_102A:
 355         bsr     sasind          ; assuming a denorm...
 356
 357 L_102B:
 358         fmove.l fpsr,d0         ; update status register
 359         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 360         fmove.l d0,fpsr
 361 *
 362 *       Result is now in FP0
 363 *
 364         movem.l USER_DA(a6),d0-d1/a0-a1
 365         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 366         unlk    a6
 367         rts
 368
 369         xdef    fasinx
 370 fasinx:
 371         link    a6,#-LOCAL_SIZE
 372         movem.l d0-d1/a0-a1,USER_DA(a6)
 373         fmovem.x fp0-fp3,USER_FP0(a6)
 374         fmove.l fpsr,USER_FPSR(a6)
 375         fmove.l fpcr,USER_FPCR(a6)
 376         fmove.l fpcr,d1         ; user's rounding mode/precision
 377         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 378 *
 379 *       copy, convert and tag input argument
 380 *
 381         fmove.x 8(a6),fp0
 382         fmove.x fp0,ETEMP(a6)
 383         lea     ETEMP(a6),a0
 384         bsr     tag
 385         move.b  d0,STAG(a6)
 386         tst.b   d0
 387         bne.b   L_102C
 388         bsr     sasin           ; normalized (regular) number
 389         bra.b   L_102G
 390 L_102C:
 391         cmp.b   #$20,d0         ; zero?
 392         bne.b   L_102D
 393         bsr     szero
 394         bra.b   L_102G
 395 L_102D:
 396         cmp.b   #$40,d0         ; infinity?
 397         bne.b   L_102E
 398         bsr     t_operr
 399         bra.b   L_102G
 400 L_102E:
 401         cmp.b   #$60,d0         ; NaN?
 402         bne.b   L_102F
 403         bsr     mon_nan
 404         bra.b   L_102G
 405 L_102F:
 406         bsr     sasind          ; assuming a denorm...
 407
 408 L_102G:
 409         fmove.l fpsr,d0         ; update status register
 410         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 411         fmove.l d0,fpsr
 412 *
 413 *       Result is now in FP0
 414 *
 415         movem.l USER_DA(a6),d0-d1/a0-a1
 416         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 417         unlk    a6
 418         rts
 419
 420 *
 421 *       MONADIC.GEN 1.4 1/16/92
 422 *
 423 *       MONADIC.GEN 1.3 4/30/91
 424 *
 425 *       MONADIC.GEN --- generic MONADIC template
 426 *
 427 *       This version saves all registers that will be used by the emulation
 428 *       routines and restores all but FP0 on exit.  The FPSR is
 429 *       updated to reflect the result of the operation.  Return value
 430 *       is placed in FP0 for single, double and extended results.
 431 *
 432 *       The package subroutines expect the incoming FPCR to be zeroed
 433 *       since they need extended precision to work properly.  The
 434 *       'final' FPCR is expected in d1 so that the calculated result
 435 *       can be properly sized and rounded.  Also, if the incoming FPCR
 436 *       has enabled any exceptions, the exception will be taken on the
 437 *       final fmovem in this template.
 438 *
 439 *       Customizations:
 440 *               1. Remove the movem.l at the entry and exit of
 441 *                  each routine if your compiler treats those
 442 *                  registers as scratch.
 443 *               2. Likewise, don't save FP0/FP1 if they are scratch
 444 *                  registers.
 445 *               3. Delete handling of the fpsr if you only care about
 446 *                  the result.
 447 *               4. Some (most?) C compilers convert all float arguments
 448 *                  to double, and provide no support at all for extended
 449 *                  precision so remove the fatans and fatanx entry points.
 450 *               5. Move the result to d0/d1 if the compiler is that old.
 451
 452 *               Copyright (C) Motorola, Inc. 1991
 453 *                       All Rights Reserved
 454 *
 455 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
 456 *       The copyright notice above does not evidence any
 457 *       actual or intended publication of such source code.
 458
 459         xref    tag
 460         xref    satan
 461         xref    szero
 462         xref    spi_2
 463         xref    mon_nan
 464         xref    satand
 465
 466         xdef    fatans
 467 fatans:
 468         link    a6,#-LOCAL_SIZE
 469         movem.l d0-d1/a0-a1,USER_DA(a6)
 470         fmovem.x fp0-fp3,USER_FP0(a6)
 471         fmove.l fpsr,USER_FPSR(a6)
 472         fmove.l fpcr,USER_FPCR(a6)
 473         fmove.l fpcr,d1         ; user's rounding mode/precision
 474         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 475 *
 476 *       copy, convert and tag input argument
 477 *
 478         fmove.s 8(a6),fp0
 479         fmove.x fp0,ETEMP(a6)
 480         lea     ETEMP(a6),a0
 481         bsr     tag
 482         move.b  d0,STAG(a6)
 483         tst.b   d0
 484         bne.b   L_1032
 485         bsr     satan           ; normalized (regular) number
 486         bra.b   L_1036
 487 L_1032:
 488         cmp.b   #$20,d0         ; zero?
 489         bne.b   L_1033
 490         bsr     szero
 491         bra.b   L_1036
 492 L_1033:
 493         cmp.b   #$40,d0         ; infinity?
 494         bne.b   L_1034
 495         bsr     spi_2
 496         bra.b   L_1036
 497 L_1034:
 498         cmp.b   #$60,d0         ; NaN?
 499         bne.b   L_1035
 500         bsr     mon_nan
 501         bra.b   L_1036
 502 L_1035:
 503         bsr     satand          ; assuming a denorm...
 504
 505 L_1036:
 506         fmove.l fpsr,d0         ; update status register
 507         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 508         fmove.l d0,fpsr
 509 *
 510 *       Result is now in FP0
 511 *
 512         movem.l USER_DA(a6),d0-d1/a0-a1
 513         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 514         unlk    a6
 515         rts
 516
 517         xdef    fatand
 518 fatand:
 519         link    a6,#-LOCAL_SIZE
 520         movem.l d0-d1/a0-a1,USER_DA(a6)
 521         fmovem.x fp0-fp3,USER_FP0(a6)
 522         fmove.l fpsr,USER_FPSR(a6)
 523         fmove.l fpcr,USER_FPCR(a6)
 524         fmove.l fpcr,d1         ; user's rounding mode/precision
 525         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 526 *
 527 *       copy, convert and tag input argument
 528 *
 529         fmove.d 8(a6),fp0
 530         fmove.x fp0,ETEMP(a6)
 531         lea     ETEMP(a6),a0
 532         bsr     tag
 533         move.b  d0,STAG(a6)
 534         tst.b   d0
 535         bne.b   L_1037
 536         bsr     satan           ; normalized (regular) number
 537         bra.b   L_103B
 538 L_1037:
 539         cmp.b   #$20,d0         ; zero?
 540         bne.b   L_1038
 541         bsr     szero
 542         bra.b   L_103B
 543 L_1038:
 544         cmp.b   #$40,d0         ; infinity?
 545         bne.b   L_1039
 546         bsr     spi_2
 547         bra.b   L_103B
 548 L_1039:
 549         cmp.b   #$60,d0         ; NaN?
 550         bne.b   L_103A
 551         bsr     mon_nan
 552         bra.b   L_103B
 553 L_103A:
 554         bsr     satand          ; assuming a denorm...
 555
 556 L_103B:
 557         fmove.l fpsr,d0         ; update status register
 558         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 559         fmove.l d0,fpsr
 560 *
 561 *       Result is now in FP0
 562 *
 563         movem.l USER_DA(a6),d0-d1/a0-a1
 564         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 565         unlk    a6
 566         rts
 567
 568         xdef    fatanx
 569 fatanx:
 570         link    a6,#-LOCAL_SIZE
 571         movem.l d0-d1/a0-a1,USER_DA(a6)
 572         fmovem.x fp0-fp3,USER_FP0(a6)
 573         fmove.l fpsr,USER_FPSR(a6)
 574         fmove.l fpcr,USER_FPCR(a6)
 575         fmove.l fpcr,d1         ; user's rounding mode/precision
 576         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 577 *
 578 *       copy, convert and tag input argument
 579 *
 580         fmove.x 8(a6),fp0
 581         fmove.x fp0,ETEMP(a6)
 582         lea     ETEMP(a6),a0
 583         bsr     tag
 584         move.b  d0,STAG(a6)
 585         tst.b   d0
 586         bne.b   L_103C
 587         bsr     satan           ; normalized (regular) number
 588         bra.b   L_103G
 589 L_103C:
 590         cmp.b   #$20,d0         ; zero?
 591         bne.b   L_103D
 592         bsr     szero
 593         bra.b   L_103G
 594 L_103D:
 595         cmp.b   #$40,d0         ; infinity?
 596         bne.b   L_103E
 597         bsr     spi_2
 598         bra.b   L_103G
 599 L_103E:
 600         cmp.b   #$60,d0         ; NaN?
 601         bne.b   L_103F
 602         bsr     mon_nan
 603         bra.b   L_103G
 604 L_103F:
 605         bsr     satand          ; assuming a denorm...
 606
 607 L_103G:
 608         fmove.l fpsr,d0         ; update status register
 609         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 610         fmove.l d0,fpsr
 611 *
 612 *       Result is now in FP0
 613 *
 614         movem.l USER_DA(a6),d0-d1/a0-a1
 615         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 616         unlk    a6
 617         rts
 618
 619 *
 620 *       MONADIC.GEN 1.4 1/16/92
 621 *
 622 *       MONADIC.GEN 1.3 4/30/91
 623 *
 624 *       MONADIC.GEN --- generic MONADIC template
 625 *
 626 *       This version saves all registers that will be used by the emulation
 627 *       routines and restores all but FP0 on exit.  The FPSR is
 628 *       updated to reflect the result of the operation.  Return value
 629 *       is placed in FP0 for single, double and extended results.
 630 *
 631 *       The package subroutines expect the incoming FPCR to be zeroed
 632 *       since they need extended precision to work properly.  The
 633 *       'final' FPCR is expected in d1 so that the calculated result
 634 *       can be properly sized and rounded.  Also, if the incoming FPCR
 635 *       has enabled any exceptions, the exception will be taken on the
 636 *       final fmovem in this template.
 637 *
 638 *       Customizations:
 639 *               1. Remove the movem.l at the entry and exit of
 640 *                  each routine if your compiler treats those
 641 *                  registers as scratch.
 642 *               2. Likewise, don't save FP0/FP1 if they are scratch
 643 *                  registers.
 644 *               3. Delete handling of the fpsr if you only care about
 645 *                  the result.
 646 *               4. Some (most?) C compilers convert all float arguments
 647 *                  to double, and provide no support at all for extended
 648 *                  precision so remove the fatanhs and fatanhx entry points.
 649 *               5. Move the result to d0/d1 if the compiler is that old.
 650
 651 *               Copyright (C) Motorola, Inc. 1991
 652 *                       All Rights Reserved
 653 *
 654 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
 655 *       The copyright notice above does not evidence any
 656 *       actual or intended publication of such source code.
 657
 658         xref    tag
 659         xref    satanh
 660         xref    szero
 661         xref    t_operr
 662         xref    mon_nan
 663         xref    satanhd
 664
 665         xdef    fatanhs
 666 fatanhs:
 667         link    a6,#-LOCAL_SIZE
 668         movem.l d0-d1/a0-a1,USER_DA(a6)
 669         fmovem.x fp0-fp3,USER_FP0(a6)
 670         fmove.l fpsr,USER_FPSR(a6)
 671         fmove.l fpcr,USER_FPCR(a6)
 672         fmove.l fpcr,d1         ; user's rounding mode/precision
 673         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 674 *
 675 *       copy, convert and tag input argument
 676 *
 677         fmove.s 8(a6),fp0
 678         fmove.x fp0,ETEMP(a6)
 679         lea     ETEMP(a6),a0
 680         bsr     tag
 681         move.b  d0,STAG(a6)
 682         tst.b   d0
 683         bne.b   L_1042
 684         bsr     satanh          ; normalized (regular) number
 685         bra.b   L_1046
 686 L_1042:
 687         cmp.b   #$20,d0         ; zero?
 688         bne.b   L_1043
 689         bsr     szero
 690         bra.b   L_1046
 691 L_1043:
 692         cmp.b   #$40,d0         ; infinity?
 693         bne.b   L_1044
 694         bsr     t_operr
 695         bra.b   L_1046
 696 L_1044:
 697         cmp.b   #$60,d0         ; NaN?
 698         bne.b   L_1045
 699         bsr     mon_nan
 700         bra.b   L_1046
 701 L_1045:
 702         bsr     satanhd         ; assuming a denorm...
 703
 704 L_1046:
 705         fmove.l fpsr,d0         ; update status register
 706         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 707         fmove.l d0,fpsr
 708 *
 709 *       Result is now in FP0
 710 *
 711         movem.l USER_DA(a6),d0-d1/a0-a1
 712         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 713         unlk    a6
 714         rts
 715
 716         xdef    fatanhd
 717 fatanhd:
 718         link    a6,#-LOCAL_SIZE
 719         movem.l d0-d1/a0-a1,USER_DA(a6)
 720         fmovem.x fp0-fp3,USER_FP0(a6)
 721         fmove.l fpsr,USER_FPSR(a6)
 722         fmove.l fpcr,USER_FPCR(a6)
 723         fmove.l fpcr,d1         ; user's rounding mode/precision
 724         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 725 *
 726 *       copy, convert and tag input argument
 727 *
 728         fmove.d 8(a6),fp0
 729         fmove.x fp0,ETEMP(a6)
 730         lea     ETEMP(a6),a0
 731         bsr     tag
 732         move.b  d0,STAG(a6)
 733         tst.b   d0
 734         bne.b   L_1047
 735         bsr     satanh          ; normalized (regular) number
 736         bra.b   L_104B
 737 L_1047:
 738         cmp.b   #$20,d0         ; zero?
 739         bne.b   L_1048
 740         bsr     szero
 741         bra.b   L_104B
 742 L_1048:
 743         cmp.b   #$40,d0         ; infinity?
 744         bne.b   L_1049
 745         bsr     t_operr
 746         bra.b   L_104B
 747 L_1049:
 748         cmp.b   #$60,d0         ; NaN?
 749         bne.b   L_104A
 750         bsr     mon_nan
 751         bra.b   L_104B
 752 L_104A:
 753         bsr     satanhd         ; assuming a denorm...
 754
 755 L_104B:
 756         fmove.l fpsr,d0         ; update status register
 757         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 758         fmove.l d0,fpsr
 759 *
 760 *       Result is now in FP0
 761 *
 762         movem.l USER_DA(a6),d0-d1/a0-a1
 763         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 764         unlk    a6
 765         rts
 766
 767         xdef    fatanhx
 768 fatanhx:
 769         link    a6,#-LOCAL_SIZE
 770         movem.l d0-d1/a0-a1,USER_DA(a6)
 771         fmovem.x fp0-fp3,USER_FP0(a6)
 772         fmove.l fpsr,USER_FPSR(a6)
 773         fmove.l fpcr,USER_FPCR(a6)
 774         fmove.l fpcr,d1         ; user's rounding mode/precision
 775         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 776 *
 777 *       copy, convert and tag input argument
 778 *
 779         fmove.x 8(a6),fp0
 780         fmove.x fp0,ETEMP(a6)
 781         lea     ETEMP(a6),a0
 782         bsr     tag
 783         move.b  d0,STAG(a6)
 784         tst.b   d0
 785         bne.b   L_104C
 786         bsr     satanh          ; normalized (regular) number
 787         bra.b   L_104G
 788 L_104C:
 789         cmp.b   #$20,d0         ; zero?
 790         bne.b   L_104D
 791         bsr     szero
 792         bra.b   L_104G
 793 L_104D:
 794         cmp.b   #$40,d0         ; infinity?
 795         bne.b   L_104E
 796         bsr     t_operr
 797         bra.b   L_104G
 798 L_104E:
 799         cmp.b   #$60,d0         ; NaN?
 800         bne.b   L_104F
 801         bsr     mon_nan
 802         bra.b   L_104G
 803 L_104F:
 804         bsr     satanhd         ; assuming a denorm...
 805
 806 L_104G:
 807         fmove.l fpsr,d0         ; update status register
 808         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 809         fmove.l d0,fpsr
 810 *
 811 *       Result is now in FP0
 812 *
 813         movem.l USER_DA(a6),d0-d1/a0-a1
 814         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 815         unlk    a6
 816         rts
 817
 818 *
 819 *       MONADIC.GEN 1.4 1/16/92
 820 *
 821 *       MONADIC.GEN 1.3 4/30/91
 822 *
 823 *       MONADIC.GEN --- generic MONADIC template
 824 *
 825 *       This version saves all registers that will be used by the emulation
 826 *       routines and restores all but FP0 on exit.  The FPSR is
 827 *       updated to reflect the result of the operation.  Return value
 828 *       is placed in FP0 for single, double and extended results.
 829 *
 830 *       The package subroutines expect the incoming FPCR to be zeroed
 831 *       since they need extended precision to work properly.  The
 832 *       'final' FPCR is expected in d1 so that the calculated result
 833 *       can be properly sized and rounded.  Also, if the incoming FPCR
 834 *       has enabled any exceptions, the exception will be taken on the
 835 *       final fmovem in this template.
 836 *
 837 *       Customizations:
 838 *               1. Remove the movem.l at the entry and exit of
 839 *                  each routine if your compiler treats those
 840 *                  registers as scratch.
 841 *               2. Likewise, don't save FP0/FP1 if they are scratch
 842 *                  registers.
 843 *               3. Delete handling of the fpsr if you only care about
 844 *                  the result.
 845 *               4. Some (most?) C compilers convert all float arguments
 846 *                  to double, and provide no support at all for extended
 847 *                  precision so remove the fcoss and fcosx entry points.
 848 *               5. Move the result to d0/d1 if the compiler is that old.
 849
 850 *               Copyright (C) Motorola, Inc. 1991
 851 *                       All Rights Reserved
 852 *
 853 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
 854 *       The copyright notice above does not evidence any
 855 *       actual or intended publication of such source code.
 856
 857         xref    tag
 858         xref    scos
 859         xref    ld_pone
 860         xref    t_operr
 861         xref    mon_nan
 862         xref    scosd
 863
 864         xdef    fcoss
 865 fcoss:
 866         link    a6,#-LOCAL_SIZE
 867         movem.l d0-d1/a0-a1,USER_DA(a6)
 868         fmovem.x fp0-fp3,USER_FP0(a6)
 869         fmove.l fpsr,USER_FPSR(a6)
 870         fmove.l fpcr,USER_FPCR(a6)
 871         fmove.l fpcr,d1         ; user's rounding mode/precision
 872         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 873 *
 874 *       copy, convert and tag input argument
 875 *
 876         fmove.s 8(a6),fp0
 877         fmove.x fp0,ETEMP(a6)
 878         lea     ETEMP(a6),a0
 879         bsr     tag
 880         move.b  d0,STAG(a6)
 881         tst.b   d0
 882         bne.b   L_1052
 883         bsr     scos            ; normalized (regular) number
 884         bra.b   L_1056
 885 L_1052:
 886         cmp.b   #$20,d0         ; zero?
 887         bne.b   L_1053
 888         bsr     ld_pone
 889         bra.b   L_1056
 890 L_1053:
 891         cmp.b   #$40,d0         ; infinity?
 892         bne.b   L_1054
 893         bsr     t_operr
 894         bra.b   L_1056
 895 L_1054:
 896         cmp.b   #$60,d0         ; NaN?
 897         bne.b   L_1055
 898         bsr     mon_nan
 899         bra.b   L_1056
 900 L_1055:
 901         bsr     scosd           ; assuming a denorm...
 902
 903 L_1056:
 904         fmove.l fpsr,d0         ; update status register
 905         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 906         fmove.l d0,fpsr
 907 *
 908 *       Result is now in FP0
 909 *
 910         movem.l USER_DA(a6),d0-d1/a0-a1
 911         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 912         unlk    a6
 913         rts
 914
 915         xdef    fcosd
 916 fcosd:
 917         link    a6,#-LOCAL_SIZE
 918         movem.l d0-d1/a0-a1,USER_DA(a6)
 919         fmovem.x fp0-fp3,USER_FP0(a6)
 920         fmove.l fpsr,USER_FPSR(a6)
 921         fmove.l fpcr,USER_FPCR(a6)
 922         fmove.l fpcr,d1         ; user's rounding mode/precision
 923         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 924 *
 925 *       copy, convert and tag input argument
 926 *
 927         fmove.d 8(a6),fp0
 928         fmove.x fp0,ETEMP(a6)
 929         lea     ETEMP(a6),a0
 930         bsr     tag
 931         move.b  d0,STAG(a6)
 932         tst.b   d0
 933         bne.b   L_1057
 934         bsr     scos            ; normalized (regular) number
 935         bra.b   L_105B
 936 L_1057:
 937         cmp.b   #$20,d0         ; zero?
 938         bne.b   L_1058
 939         bsr     ld_pone
 940         bra.b   L_105B
 941 L_1058:
 942         cmp.b   #$40,d0         ; infinity?
 943         bne.b   L_1059
 944         bsr     t_operr
 945         bra.b   L_105B
 946 L_1059:
 947         cmp.b   #$60,d0         ; NaN?
 948         bne.b   L_105A
 949         bsr     mon_nan
 950         bra.b   L_105B
 951 L_105A:
 952         bsr     scosd           ; assuming a denorm...
 953
 954 L_105B:
 955         fmove.l fpsr,d0         ; update status register
 956         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
 957         fmove.l d0,fpsr
 958 *
 959 *       Result is now in FP0
 960 *
 961         movem.l USER_DA(a6),d0-d1/a0-a1
 962         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
 963         unlk    a6
 964         rts
 965
 966         xdef    fcosx
 967 fcosx:
 968         link    a6,#-LOCAL_SIZE
 969         movem.l d0-d1/a0-a1,USER_DA(a6)
 970         fmovem.x fp0-fp3,USER_FP0(a6)
 971         fmove.l fpsr,USER_FPSR(a6)
 972         fmove.l fpcr,USER_FPCR(a6)
 973         fmove.l fpcr,d1         ; user's rounding mode/precision
 974         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
 975 *
 976 *       copy, convert and tag input argument
 977 *
 978         fmove.x 8(a6),fp0
 979         fmove.x fp0,ETEMP(a6)
 980         lea     ETEMP(a6),a0
 981         bsr     tag
 982         move.b  d0,STAG(a6)
 983         tst.b   d0
 984         bne.b   L_105C
 985         bsr     scos            ; normalized (regular) number
 986         bra.b   L_105G
 987 L_105C:
 988         cmp.b   #$20,d0         ; zero?
 989         bne.b   L_105D
 990         bsr     ld_pone
 991         bra.b   L_105G
 992 L_105D:
 993         cmp.b   #$40,d0         ; infinity?
 994         bne.b   L_105E
 995         bsr     t_operr
 996         bra.b   L_105G
 997 L_105E:
 998         cmp.b   #$60,d0         ; NaN?
 999         bne.b   L_105F
1000         bsr     mon_nan
1001         bra.b   L_105G
1002 L_105F:
1003         bsr     scosd           ; assuming a denorm...
1004
1005 L_105G:
1006         fmove.l fpsr,d0         ; update status register
1007         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1008         fmove.l d0,fpsr
1009 *
1010 *       Result is now in FP0
1011 *
1012         movem.l USER_DA(a6),d0-d1/a0-a1
1013         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1014         unlk    a6
1015         rts
1016
1017 *
1018 *       MONADIC.GEN 1.4 1/16/92
1019 *
1020 *       MONADIC.GEN 1.3 4/30/91
1021 *
1022 *       MONADIC.GEN --- generic MONADIC template
1023 *
1024 *       This version saves all registers that will be used by the emulation
1025 *       routines and restores all but FP0 on exit.  The FPSR is
1026 *       updated to reflect the result of the operation.  Return value
1027 *       is placed in FP0 for single, double and extended results.
1028 *
1029 *       The package subroutines expect the incoming FPCR to be zeroed
1030 *       since they need extended precision to work properly.  The
1031 *       'final' FPCR is expected in d1 so that the calculated result
1032 *       can be properly sized and rounded.  Also, if the incoming FPCR
1033 *       has enabled any exceptions, the exception will be taken on the
1034 *       final fmovem in this template.
1035 *
1036 *       Customizations:
1037 *               1. Remove the movem.l at the entry and exit of
1038 *                  each routine if your compiler treats those
1039 *                  registers as scratch.
1040 *               2. Likewise, don't save FP0/FP1 if they are scratch
1041 *                  registers.
1042 *               3. Delete handling of the fpsr if you only care about
1043 *                  the result.
1044 *               4. Some (most?) C compilers convert all float arguments
1045 *                  to double, and provide no support at all for extended
1046 *                  precision so remove the fcoshs and fcoshx entry points.
1047 *               5. Move the result to d0/d1 if the compiler is that old.
1048
1049 *               Copyright (C) Motorola, Inc. 1991
1050 *                       All Rights Reserved
1051 *
1052 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
1053 *       The copyright notice above does not evidence any
1054 *       actual or intended publication of such source code.
1055
1056         xref    tag
1057         xref    scosh
1058         xref    ld_pone
1059         xref    ld_pinf
1060         xref    mon_nan
1061         xref    scoshd
1062
1063         xdef    fcoshs
1064 fcoshs:
1065         link    a6,#-LOCAL_SIZE
1066         movem.l d0-d1/a0-a1,USER_DA(a6)
1067         fmovem.x fp0-fp3,USER_FP0(a6)
1068         fmove.l fpsr,USER_FPSR(a6)
1069         fmove.l fpcr,USER_FPCR(a6)
1070         fmove.l fpcr,d1         ; user's rounding mode/precision
1071         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1072 *
1073 *       copy, convert and tag input argument
1074 *
1075         fmove.s 8(a6),fp0
1076         fmove.x fp0,ETEMP(a6)
1077         lea     ETEMP(a6),a0
1078         bsr     tag
1079         move.b  d0,STAG(a6)
1080         tst.b   d0
1081         bne.b   L_1062
1082         bsr     scosh           ; normalized (regular) number
1083         bra.b   L_1066
1084 L_1062:
1085         cmp.b   #$20,d0         ; zero?
1086         bne.b   L_1063
1087         bsr     ld_pone
1088         bra.b   L_1066
1089 L_1063:
1090         cmp.b   #$40,d0         ; infinity?
1091         bne.b   L_1064
1092         bsr     ld_pinf
1093         bra.b   L_1066
1094 L_1064:
1095         cmp.b   #$60,d0         ; NaN?
1096         bne.b   L_1065
1097         bsr     mon_nan
1098         bra.b   L_1066
1099 L_1065:
1100         bsr     scoshd          ; assuming a denorm...
1101
1102 L_1066:
1103         fmove.l fpsr,d0         ; update status register
1104         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1105         fmove.l d0,fpsr
1106 *
1107 *       Result is now in FP0
1108 *
1109         movem.l USER_DA(a6),d0-d1/a0-a1
1110         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1111         unlk    a6
1112         rts
1113
1114         xdef    fcoshd
1115 fcoshd:
1116         link    a6,#-LOCAL_SIZE
1117         movem.l d0-d1/a0-a1,USER_DA(a6)
1118         fmovem.x fp0-fp3,USER_FP0(a6)
1119         fmove.l fpsr,USER_FPSR(a6)
1120         fmove.l fpcr,USER_FPCR(a6)
1121         fmove.l fpcr,d1         ; user's rounding mode/precision
1122         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1123 *
1124 *       copy, convert and tag input argument
1125 *
1126         fmove.d 8(a6),fp0
1127         fmove.x fp0,ETEMP(a6)
1128         lea     ETEMP(a6),a0
1129         bsr     tag
1130         move.b  d0,STAG(a6)
1131         tst.b   d0
1132         bne.b   L_1067
1133         bsr     scosh           ; normalized (regular) number
1134         bra.b   L_106B
1135 L_1067:
1136         cmp.b   #$20,d0         ; zero?
1137         bne.b   L_1068
1138         bsr     ld_pone
1139         bra.b   L_106B
1140 L_1068:
1141         cmp.b   #$40,d0         ; infinity?
1142         bne.b   L_1069
1143         bsr     ld_pinf
1144         bra.b   L_106B
1145 L_1069:
1146         cmp.b   #$60,d0         ; NaN?
1147         bne.b   L_106A
1148         bsr     mon_nan
1149         bra.b   L_106B
1150 L_106A:
1151         bsr     scoshd          ; assuming a denorm...
1152
1153 L_106B:
1154         fmove.l fpsr,d0         ; update status register
1155         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1156         fmove.l d0,fpsr
1157 *
1158 *       Result is now in FP0
1159 *
1160         movem.l USER_DA(a6),d0-d1/a0-a1
1161         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1162         unlk    a6
1163         rts
1164
1165         xdef    fcoshx
1166 fcoshx:
1167         link    a6,#-LOCAL_SIZE
1168         movem.l d0-d1/a0-a1,USER_DA(a6)
1169         fmovem.x fp0-fp3,USER_FP0(a6)
1170         fmove.l fpsr,USER_FPSR(a6)
1171         fmove.l fpcr,USER_FPCR(a6)
1172         fmove.l fpcr,d1         ; user's rounding mode/precision
1173         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1174 *
1175 *       copy, convert and tag input argument
1176 *
1177         fmove.x 8(a6),fp0
1178         fmove.x fp0,ETEMP(a6)
1179         lea     ETEMP(a6),a0
1180         bsr     tag
1181         move.b  d0,STAG(a6)
1182         tst.b   d0
1183         bne.b   L_106C
1184         bsr     scosh           ; normalized (regular) number
1185         bra.b   L_106G
1186 L_106C:
1187         cmp.b   #$20,d0         ; zero?
1188         bne.b   L_106D
1189         bsr     ld_pone
1190         bra.b   L_106G
1191 L_106D:
1192         cmp.b   #$40,d0         ; infinity?
1193         bne.b   L_106E
1194         bsr     ld_pinf
1195         bra.b   L_106G
1196 L_106E:
1197         cmp.b   #$60,d0         ; NaN?
1198         bne.b   L_106F
1199         bsr     mon_nan
1200         bra.b   L_106G
1201 L_106F:
1202         bsr     scoshd          ; assuming a denorm...
1203
1204 L_106G:
1205         fmove.l fpsr,d0         ; update status register
1206         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1207         fmove.l d0,fpsr
1208 *
1209 *       Result is now in FP0
1210 *
1211         movem.l USER_DA(a6),d0-d1/a0-a1
1212         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1213         unlk    a6
1214         rts
1215
1216 *
1217 *       MONADIC.GEN 1.4 1/16/92
1218 *
1219 *       MONADIC.GEN 1.3 4/30/91
1220 *
1221 *       MONADIC.GEN --- generic MONADIC template
1222 *
1223 *       This version saves all registers that will be used by the emulation
1224 *       routines and restores all but FP0 on exit.  The FPSR is
1225 *       updated to reflect the result of the operation.  Return value
1226 *       is placed in FP0 for single, double and extended results.
1227 *
1228 *       The package subroutines expect the incoming FPCR to be zeroed
1229 *       since they need extended precision to work properly.  The
1230 *       'final' FPCR is expected in d1 so that the calculated result
1231 *       can be properly sized and rounded.  Also, if the incoming FPCR
1232 *       has enabled any exceptions, the exception will be taken on the
1233 *       final fmovem in this template.
1234 *
1235 *       Customizations:
1236 *               1. Remove the movem.l at the entry and exit of
1237 *                  each routine if your compiler treats those
1238 *                  registers as scratch.
1239 *               2. Likewise, don't save FP0/FP1 if they are scratch
1240 *                  registers.
1241 *               3. Delete handling of the fpsr if you only care about
1242 *                  the result.
1243 *               4. Some (most?) C compilers convert all float arguments
1244 *                  to double, and provide no support at all for extended
1245 *                  precision so remove the fetoxs and fetoxx entry points.
1246 *               5. Move the result to d0/d1 if the compiler is that old.
1247
1248 *               Copyright (C) Motorola, Inc. 1991
1249 *                       All Rights Reserved
1250 *
1251 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
1252 *       The copyright notice above does not evidence any
1253 *       actual or intended publication of such source code.
1254
1255         xref    tag
1256         xref    setox
1257         xref    ld_pone
1258         xref    szr_inf
1259         xref    mon_nan
1260         xref    setoxd
1261
1262         xdef    fetoxs
1263 fetoxs:
1264         link    a6,#-LOCAL_SIZE
1265         movem.l d0-d1/a0-a1,USER_DA(a6)
1266         fmovem.x fp0-fp3,USER_FP0(a6)
1267         fmove.l fpsr,USER_FPSR(a6)
1268         fmove.l fpcr,USER_FPCR(a6)
1269         fmove.l fpcr,d1         ; user's rounding mode/precision
1270         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1271 *
1272 *       copy, convert and tag input argument
1273 *
1274         fmove.s 8(a6),fp0
1275         fmove.x fp0,ETEMP(a6)
1276         lea     ETEMP(a6),a0
1277         bsr     tag
1278         move.b  d0,STAG(a6)
1279         tst.b   d0
1280         bne.b   L_1072
1281         bsr     setox           ; normalized (regular) number
1282         bra.b   L_1076
1283 L_1072:
1284         cmp.b   #$20,d0         ; zero?
1285         bne.b   L_1073
1286         bsr     ld_pone
1287         bra.b   L_1076
1288 L_1073:
1289         cmp.b   #$40,d0         ; infinity?
1290         bne.b   L_1074
1291         bsr     szr_inf
1292         bra.b   L_1076
1293 L_1074:
1294         cmp.b   #$60,d0         ; NaN?
1295         bne.b   L_1075
1296         bsr     mon_nan
1297         bra.b   L_1076
1298 L_1075:
1299         bsr     setoxd          ; assuming a denorm...
1300
1301 L_1076:
1302         fmove.l fpsr,d0         ; update status register
1303         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1304         fmove.l d0,fpsr
1305 *
1306 *       Result is now in FP0
1307 *
1308         movem.l USER_DA(a6),d0-d1/a0-a1
1309         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1310         unlk    a6
1311         rts
1312
1313         xdef    fetoxd
1314 fetoxd:
1315         link    a6,#-LOCAL_SIZE
1316         movem.l d0-d1/a0-a1,USER_DA(a6)
1317         fmovem.x fp0-fp3,USER_FP0(a6)
1318         fmove.l fpsr,USER_FPSR(a6)
1319         fmove.l fpcr,USER_FPCR(a6)
1320         fmove.l fpcr,d1         ; user's rounding mode/precision
1321         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1322 *
1323 *       copy, convert and tag input argument
1324 *
1325         fmove.d 8(a6),fp0
1326         fmove.x fp0,ETEMP(a6)
1327         lea     ETEMP(a6),a0
1328         bsr     tag
1329         move.b  d0,STAG(a6)
1330         tst.b   d0
1331         bne.b   L_1077
1332         bsr     setox           ; normalized (regular) number
1333         bra.b   L_107B
1334 L_1077:
1335         cmp.b   #$20,d0         ; zero?
1336         bne.b   L_1078
1337         bsr     ld_pone
1338         bra.b   L_107B
1339 L_1078:
1340         cmp.b   #$40,d0         ; infinity?
1341         bne.b   L_1079
1342         bsr     szr_inf
1343         bra.b   L_107B
1344 L_1079:
1345         cmp.b   #$60,d0         ; NaN?
1346         bne.b   L_107A
1347         bsr     mon_nan
1348         bra.b   L_107B
1349 L_107A:
1350         bsr     setoxd          ; assuming a denorm...
1351
1352 L_107B:
1353         fmove.l fpsr,d0         ; update status register
1354         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1355         fmove.l d0,fpsr
1356 *
1357 *       Result is now in FP0
1358 *
1359         movem.l USER_DA(a6),d0-d1/a0-a1
1360         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1361         unlk    a6
1362         rts
1363
1364         xdef    fetoxx
1365 fetoxx:
1366         link    a6,#-LOCAL_SIZE
1367         movem.l d0-d1/a0-a1,USER_DA(a6)
1368         fmovem.x fp0-fp3,USER_FP0(a6)
1369         fmove.l fpsr,USER_FPSR(a6)
1370         fmove.l fpcr,USER_FPCR(a6)
1371         fmove.l fpcr,d1         ; user's rounding mode/precision
1372         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1373 *
1374 *       copy, convert and tag input argument
1375 *
1376         fmove.x 8(a6),fp0
1377         fmove.x fp0,ETEMP(a6)
1378         lea     ETEMP(a6),a0
1379         bsr     tag
1380         move.b  d0,STAG(a6)
1381         tst.b   d0
1382         bne.b   L_107C
1383         bsr     setox           ; normalized (regular) number
1384         bra.b   L_107G
1385 L_107C:
1386         cmp.b   #$20,d0         ; zero?
1387         bne.b   L_107D
1388         bsr     ld_pone
1389         bra.b   L_107G
1390 L_107D:
1391         cmp.b   #$40,d0         ; infinity?
1392         bne.b   L_107E
1393         bsr     szr_inf
1394         bra.b   L_107G
1395 L_107E:
1396         cmp.b   #$60,d0         ; NaN?
1397         bne.b   L_107F
1398         bsr     mon_nan
1399         bra.b   L_107G
1400 L_107F:
1401         bsr     setoxd          ; assuming a denorm...
1402
1403 L_107G:
1404         fmove.l fpsr,d0         ; update status register
1405         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1406         fmove.l d0,fpsr
1407 *
1408 *       Result is now in FP0
1409 *
1410         movem.l USER_DA(a6),d0-d1/a0-a1
1411         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1412         unlk    a6
1413         rts
1414
1415 *
1416 *       MONADIC.GEN 1.4 1/16/92
1417 *
1418 *       MONADIC.GEN 1.3 4/30/91
1419 *
1420 *       MONADIC.GEN --- generic MONADIC template
1421 *
1422 *       This version saves all registers that will be used by the emulation
1423 *       routines and restores all but FP0 on exit.  The FPSR is
1424 *       updated to reflect the result of the operation.  Return value
1425 *       is placed in FP0 for single, double and extended results.
1426 *
1427 *       The package subroutines expect the incoming FPCR to be zeroed
1428 *       since they need extended precision to work properly.  The
1429 *       'final' FPCR is expected in d1 so that the calculated result
1430 *       can be properly sized and rounded.  Also, if the incoming FPCR
1431 *       has enabled any exceptions, the exception will be taken on the
1432 *       final fmovem in this template.
1433 *
1434 *       Customizations:
1435 *               1. Remove the movem.l at the entry and exit of
1436 *                  each routine if your compiler treats those
1437 *                  registers as scratch.
1438 *               2. Likewise, don't save FP0/FP1 if they are scratch
1439 *                  registers.
1440 *               3. Delete handling of the fpsr if you only care about
1441 *                  the result.
1442 *               4. Some (most?) C compilers convert all float arguments
1443 *                  to double, and provide no support at all for extended
1444 *                  precision so remove the fetoxm1s and fetoxm1x entry points.
1445 *               5. Move the result to d0/d1 if the compiler is that old.
1446
1447 *               Copyright (C) Motorola, Inc. 1991
1448 *                       All Rights Reserved
1449 *
1450 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
1451 *       The copyright notice above does not evidence any
1452 *       actual or intended publication of such source code.
1453
1454         xref    tag
1455         xref    setoxm1
1456         xref    szero
1457         xref    setoxm1i
1458         xref    mon_nan
1459         xref    setoxm1d
1460
1461         xdef    fetoxm1s
1462 fetoxm1s:
1463         link    a6,#-LOCAL_SIZE
1464         movem.l d0-d1/a0-a1,USER_DA(a6)
1465         fmovem.x fp0-fp3,USER_FP0(a6)
1466         fmove.l fpsr,USER_FPSR(a6)
1467         fmove.l fpcr,USER_FPCR(a6)
1468         fmove.l fpcr,d1         ; user's rounding mode/precision
1469         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1470 *
1471 *       copy, convert and tag input argument
1472 *
1473         fmove.s 8(a6),fp0
1474         fmove.x fp0,ETEMP(a6)
1475         lea     ETEMP(a6),a0
1476         bsr     tag
1477         move.b  d0,STAG(a6)
1478         tst.b   d0
1479         bne.b   L_1082
1480         bsr     setoxm1         ; normalized (regular) number
1481         bra.b   L_1086
1482 L_1082:
1483         cmp.b   #$20,d0         ; zero?
1484         bne.b   L_1083
1485         bsr     szero
1486         bra.b   L_1086
1487 L_1083:
1488         cmp.b   #$40,d0         ; infinity?
1489         bne.b   L_1084
1490         bsr     setoxm1i
1491         bra.b   L_1086
1492 L_1084:
1493         cmp.b   #$60,d0         ; NaN?
1494         bne.b   L_1085
1495         bsr     mon_nan
1496         bra.b   L_1086
1497 L_1085:
1498         bsr     setoxm1d                ; assuming a denorm...
1499
1500 L_1086:
1501         fmove.l fpsr,d0         ; update status register
1502         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1503         fmove.l d0,fpsr
1504 *
1505 *       Result is now in FP0
1506 *
1507         movem.l USER_DA(a6),d0-d1/a0-a1
1508         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1509         unlk    a6
1510         rts
1511
1512         xdef    fetoxm1d
1513 fetoxm1d:
1514         link    a6,#-LOCAL_SIZE
1515         movem.l d0-d1/a0-a1,USER_DA(a6)
1516         fmovem.x fp0-fp3,USER_FP0(a6)
1517         fmove.l fpsr,USER_FPSR(a6)
1518         fmove.l fpcr,USER_FPCR(a6)
1519         fmove.l fpcr,d1         ; user's rounding mode/precision
1520         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1521 *
1522 *       copy, convert and tag input argument
1523 *
1524         fmove.d 8(a6),fp0
1525         fmove.x fp0,ETEMP(a6)
1526         lea     ETEMP(a6),a0
1527         bsr     tag
1528         move.b  d0,STAG(a6)
1529         tst.b   d0
1530         bne.b   L_1087
1531         bsr     setoxm1         ; normalized (regular) number
1532         bra.b   L_108B
1533 L_1087:
1534         cmp.b   #$20,d0         ; zero?
1535         bne.b   L_1088
1536         bsr     szero
1537         bra.b   L_108B
1538 L_1088:
1539         cmp.b   #$40,d0         ; infinity?
1540         bne.b   L_1089
1541         bsr     setoxm1i
1542         bra.b   L_108B
1543 L_1089:
1544         cmp.b   #$60,d0         ; NaN?
1545         bne.b   L_108A
1546         bsr     mon_nan
1547         bra.b   L_108B
1548 L_108A:
1549         bsr     setoxm1d                ; assuming a denorm...
1550
1551 L_108B:
1552         fmove.l fpsr,d0         ; update status register
1553         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1554         fmove.l d0,fpsr
1555 *
1556 *       Result is now in FP0
1557 *
1558         movem.l USER_DA(a6),d0-d1/a0-a1
1559         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1560         unlk    a6
1561         rts
1562
1563         xdef    fetoxm1x
1564 fetoxm1x:
1565         link    a6,#-LOCAL_SIZE
1566         movem.l d0-d1/a0-a1,USER_DA(a6)
1567         fmovem.x fp0-fp3,USER_FP0(a6)
1568         fmove.l fpsr,USER_FPSR(a6)
1569         fmove.l fpcr,USER_FPCR(a6)
1570         fmove.l fpcr,d1         ; user's rounding mode/precision
1571         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1572 *
1573 *       copy, convert and tag input argument
1574 *
1575         fmove.x 8(a6),fp0
1576         fmove.x fp0,ETEMP(a6)
1577         lea     ETEMP(a6),a0
1578         bsr     tag
1579         move.b  d0,STAG(a6)
1580         tst.b   d0
1581         bne.b   L_108C
1582         bsr     setoxm1         ; normalized (regular) number
1583         bra.b   L_108G
1584 L_108C:
1585         cmp.b   #$20,d0         ; zero?
1586         bne.b   L_108D
1587         bsr     szero
1588         bra.b   L_108G
1589 L_108D:
1590         cmp.b   #$40,d0         ; infinity?
1591         bne.b   L_108E
1592         bsr     setoxm1i
1593         bra.b   L_108G
1594 L_108E:
1595         cmp.b   #$60,d0         ; NaN?
1596         bne.b   L_108F
1597         bsr     mon_nan
1598         bra.b   L_108G
1599 L_108F:
1600         bsr     setoxm1d                ; assuming a denorm...
1601
1602 L_108G:
1603         fmove.l fpsr,d0         ; update status register
1604         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1605         fmove.l d0,fpsr
1606 *
1607 *       Result is now in FP0
1608 *
1609         movem.l USER_DA(a6),d0-d1/a0-a1
1610         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1611         unlk    a6
1612         rts
1613
1614 *
1615 *       MONADIC.GEN 1.4 1/16/92
1616 *
1617 *       MONADIC.GEN 1.3 4/30/91
1618 *
1619 *       MONADIC.GEN --- generic MONADIC template
1620 *
1621 *       This version saves all registers that will be used by the emulation
1622 *       routines and restores all but FP0 on exit.  The FPSR is
1623 *       updated to reflect the result of the operation.  Return value
1624 *       is placed in FP0 for single, double and extended results.
1625 *
1626 *       The package subroutines expect the incoming FPCR to be zeroed
1627 *       since they need extended precision to work properly.  The
1628 *       'final' FPCR is expected in d1 so that the calculated result
1629 *       can be properly sized and rounded.  Also, if the incoming FPCR
1630 *       has enabled any exceptions, the exception will be taken on the
1631 *       final fmovem in this template.
1632 *
1633 *       Customizations:
1634 *               1. Remove the movem.l at the entry and exit of
1635 *                  each routine if your compiler treats those
1636 *                  registers as scratch.
1637 *               2. Likewise, don't save FP0/FP1 if they are scratch
1638 *                  registers.
1639 *               3. Delete handling of the fpsr if you only care about
1640 *                  the result.
1641 *               4. Some (most?) C compilers convert all float arguments
1642 *                  to double, and provide no support at all for extended
1643 *                  precision so remove the fgetexps and fgetexpx entry points.
1644 *               5. Move the result to d0/d1 if the compiler is that old.
1645
1646 *               Copyright (C) Motorola, Inc. 1991
1647 *                       All Rights Reserved
1648 *
1649 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
1650 *       The copyright notice above does not evidence any
1651 *       actual or intended publication of such source code.
1652
1653         xref    tag
1654         xref    sgetexp
1655         xref    szero
1656         xref    t_operr
1657         xref    mon_nan
1658         xref    sgetexpd
1659
1660         xdef    fgetexps
1661 fgetexps:
1662         link    a6,#-LOCAL_SIZE
1663         movem.l d0-d1/a0-a1,USER_DA(a6)
1664         fmovem.x fp0-fp3,USER_FP0(a6)
1665         fmove.l fpsr,USER_FPSR(a6)
1666         fmove.l fpcr,USER_FPCR(a6)
1667         fmove.l fpcr,d1         ; user's rounding mode/precision
1668         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1669 *
1670 *       copy, convert and tag input argument
1671 *
1672         fmove.s 8(a6),fp0
1673         fmove.x fp0,ETEMP(a6)
1674         lea     ETEMP(a6),a0
1675         bsr     tag
1676         move.b  d0,STAG(a6)
1677         tst.b   d0
1678         bne.b   L_1092
1679         bsr     sgetexp         ; normalized (regular) number
1680         bra.b   L_1096
1681 L_1092:
1682         cmp.b   #$20,d0         ; zero?
1683         bne.b   L_1093
1684         bsr     szero
1685         bra.b   L_1096
1686 L_1093:
1687         cmp.b   #$40,d0         ; infinity?
1688         bne.b   L_1094
1689         bsr     t_operr
1690         bra.b   L_1096
1691 L_1094:
1692         cmp.b   #$60,d0         ; NaN?
1693         bne.b   L_1095
1694         bsr     mon_nan
1695         bra.b   L_1096
1696 L_1095:
1697         bsr     sgetexpd                ; assuming a denorm...
1698
1699 L_1096:
1700         fmove.l fpsr,d0         ; update status register
1701         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1702         fmove.l d0,fpsr
1703 *
1704 *       Result is now in FP0
1705 *
1706         movem.l USER_DA(a6),d0-d1/a0-a1
1707         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1708         unlk    a6
1709         rts
1710
1711         xdef    fgetexpd
1712 fgetexpd:
1713         link    a6,#-LOCAL_SIZE
1714         movem.l d0-d1/a0-a1,USER_DA(a6)
1715         fmovem.x fp0-fp3,USER_FP0(a6)
1716         fmove.l fpsr,USER_FPSR(a6)
1717         fmove.l fpcr,USER_FPCR(a6)
1718         fmove.l fpcr,d1         ; user's rounding mode/precision
1719         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1720 *
1721 *       copy, convert and tag input argument
1722 *
1723         fmove.d 8(a6),fp0
1724         fmove.x fp0,ETEMP(a6)
1725         lea     ETEMP(a6),a0
1726         bsr     tag
1727         move.b  d0,STAG(a6)
1728         tst.b   d0
1729         bne.b   L_1097
1730         bsr     sgetexp         ; normalized (regular) number
1731         bra.b   L_109B
1732 L_1097:
1733         cmp.b   #$20,d0         ; zero?
1734         bne.b   L_1098
1735         bsr     szero
1736         bra.b   L_109B
1737 L_1098:
1738         cmp.b   #$40,d0         ; infinity?
1739         bne.b   L_1099
1740         bsr     t_operr
1741         bra.b   L_109B
1742 L_1099:
1743         cmp.b   #$60,d0         ; NaN?
1744         bne.b   L_109A
1745         bsr     mon_nan
1746         bra.b   L_109B
1747 L_109A:
1748         bsr     sgetexpd                ; assuming a denorm...
1749
1750 L_109B:
1751         fmove.l fpsr,d0         ; update status register
1752         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1753         fmove.l d0,fpsr
1754 *
1755 *       Result is now in FP0
1756 *
1757         movem.l USER_DA(a6),d0-d1/a0-a1
1758         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1759         unlk    a6
1760         rts
1761
1762         xdef    fgetexpx
1763 fgetexpx:
1764         link    a6,#-LOCAL_SIZE
1765         movem.l d0-d1/a0-a1,USER_DA(a6)
1766         fmovem.x fp0-fp3,USER_FP0(a6)
1767         fmove.l fpsr,USER_FPSR(a6)
1768         fmove.l fpcr,USER_FPCR(a6)
1769         fmove.l fpcr,d1         ; user's rounding mode/precision
1770         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1771 *
1772 *       copy, convert and tag input argument
1773 *
1774         fmove.x 8(a6),fp0
1775         fmove.x fp0,ETEMP(a6)
1776         lea     ETEMP(a6),a0
1777         bsr     tag
1778         move.b  d0,STAG(a6)
1779         tst.b   d0
1780         bne.b   L_109C
1781         bsr     sgetexp         ; normalized (regular) number
1782         bra.b   L_109G
1783 L_109C:
1784         cmp.b   #$20,d0         ; zero?
1785         bne.b   L_109D
1786         bsr     szero
1787         bra.b   L_109G
1788 L_109D:
1789         cmp.b   #$40,d0         ; infinity?
1790         bne.b   L_109E
1791         bsr     t_operr
1792         bra.b   L_109G
1793 L_109E:
1794         cmp.b   #$60,d0         ; NaN?
1795         bne.b   L_109F
1796         bsr     mon_nan
1797         bra.b   L_109G
1798 L_109F:
1799         bsr     sgetexpd                ; assuming a denorm...
1800
1801 L_109G:
1802         fmove.l fpsr,d0         ; update status register
1803         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1804         fmove.l d0,fpsr
1805 *
1806 *       Result is now in FP0
1807 *
1808         movem.l USER_DA(a6),d0-d1/a0-a1
1809         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1810         unlk    a6
1811         rts
1812
1813 *
1814 *       MONADIC.GEN 1.4 1/16/92
1815 *
1816 *       MONADIC.GEN 1.3 4/30/91
1817 *
1818 *       MONADIC.GEN --- generic MONADIC template
1819 *
1820 *       This version saves all registers that will be used by the emulation
1821 *       routines and restores all but FP0 on exit.  The FPSR is
1822 *       updated to reflect the result of the operation.  Return value
1823 *       is placed in FP0 for single, double and extended results.
1824 *
1825 *       The package subroutines expect the incoming FPCR to be zeroed
1826 *       since they need extended precision to work properly.  The
1827 *       'final' FPCR is expected in d1 so that the calculated result
1828 *       can be properly sized and rounded.  Also, if the incoming FPCR
1829 *       has enabled any exceptions, the exception will be taken on the
1830 *       final fmovem in this template.
1831 *
1832 *       Customizations:
1833 *               1. Remove the movem.l at the entry and exit of
1834 *                  each routine if your compiler treats those
1835 *                  registers as scratch.
1836 *               2. Likewise, don't save FP0/FP1 if they are scratch
1837 *                  registers.
1838 *               3. Delete handling of the fpsr if you only care about
1839 *                  the result.
1840 *               4. Some (most?) C compilers convert all float arguments
1841 *                  to double, and provide no support at all for extended
1842 *                  precision so remove the fsins and fsinx entry points.
1843 *               5. Move the result to d0/d1 if the compiler is that old.
1844
1845 *               Copyright (C) Motorola, Inc. 1991
1846 *                       All Rights Reserved
1847 *
1848 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
1849 *       The copyright notice above does not evidence any
1850 *       actual or intended publication of such source code.
1851
1852         xref    tag
1853         xref    ssin
1854         xref    szero
1855         xref    t_operr
1856         xref    mon_nan
1857         xref    ssind
1858
1859         xdef    fsins
1860 fsins:
1861         link    a6,#-LOCAL_SIZE
1862         movem.l d0-d1/a0-a1,USER_DA(a6)
1863         fmovem.x fp0-fp3,USER_FP0(a6)
1864         fmove.l fpsr,USER_FPSR(a6)
1865         fmove.l fpcr,USER_FPCR(a6)
1866         fmove.l fpcr,d1         ; user's rounding mode/precision
1867         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1868 *
1869 *       copy, convert and tag input argument
1870 *
1871         fmove.s 8(a6),fp0
1872         fmove.x fp0,ETEMP(a6)
1873         lea     ETEMP(a6),a0
1874         bsr     tag
1875         move.b  d0,STAG(a6)
1876         tst.b   d0
1877         bne.b   L_1102
1878         bsr     ssin            ; normalized (regular) number
1879         bra.b   L_1106
1880 L_1102:
1881         cmp.b   #$20,d0         ; zero?
1882         bne.b   L_1103
1883         bsr     szero
1884         bra.b   L_1106
1885 L_1103:
1886         cmp.b   #$40,d0         ; infinity?
1887         bne.b   L_1104
1888         bsr     t_operr
1889         bra.b   L_1106
1890 L_1104:
1891         cmp.b   #$60,d0         ; NaN?
1892         bne.b   L_1105
1893         bsr     mon_nan
1894         bra.b   L_1106
1895 L_1105:
1896         bsr     ssind           ; assuming a denorm...
1897
1898 L_1106:
1899         fmove.l fpsr,d0         ; update status register
1900         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1901         fmove.l d0,fpsr
1902 *
1903 *       Result is now in FP0
1904 *
1905         movem.l USER_DA(a6),d0-d1/a0-a1
1906         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1907         unlk    a6
1908         rts
1909
1910         xdef    fsind
1911 fsind:
1912         link    a6,#-LOCAL_SIZE
1913         movem.l d0-d1/a0-a1,USER_DA(a6)
1914         fmovem.x fp0-fp3,USER_FP0(a6)
1915         fmove.l fpsr,USER_FPSR(a6)
1916         fmove.l fpcr,USER_FPCR(a6)
1917         fmove.l fpcr,d1         ; user's rounding mode/precision
1918         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1919 *
1920 *       copy, convert and tag input argument
1921 *
1922         fmove.d 8(a6),fp0
1923         fmove.x fp0,ETEMP(a6)
1924         lea     ETEMP(a6),a0
1925         bsr     tag
1926         move.b  d0,STAG(a6)
1927         tst.b   d0
1928         bne.b   L_1107
1929         bsr     ssin            ; normalized (regular) number
1930         bra.b   L_110B
1931 L_1107:
1932         cmp.b   #$20,d0         ; zero?
1933         bne.b   L_1108
1934         bsr     szero
1935         bra.b   L_110B
1936 L_1108:
1937         cmp.b   #$40,d0         ; infinity?
1938         bne.b   L_1109
1939         bsr     t_operr
1940         bra.b   L_110B
1941 L_1109:
1942         cmp.b   #$60,d0         ; NaN?
1943         bne.b   L_110A
1944         bsr     mon_nan
1945         bra.b   L_110B
1946 L_110A:
1947         bsr     ssind           ; assuming a denorm...
1948
1949 L_110B:
1950         fmove.l fpsr,d0         ; update status register
1951         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
1952         fmove.l d0,fpsr
1953 *
1954 *       Result is now in FP0
1955 *
1956         movem.l USER_DA(a6),d0-d1/a0-a1
1957         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
1958         unlk    a6
1959         rts
1960
1961         xdef    fsinx
1962 fsinx:
1963         link    a6,#-LOCAL_SIZE
1964         movem.l d0-d1/a0-a1,USER_DA(a6)
1965         fmovem.x fp0-fp3,USER_FP0(a6)
1966         fmove.l fpsr,USER_FPSR(a6)
1967         fmove.l fpcr,USER_FPCR(a6)
1968         fmove.l fpcr,d1         ; user's rounding mode/precision
1969         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
1970 *
1971 *       copy, convert and tag input argument
1972 *
1973         fmove.x 8(a6),fp0
1974         fmove.x fp0,ETEMP(a6)
1975         lea     ETEMP(a6),a0
1976         bsr     tag
1977         move.b  d0,STAG(a6)
1978         tst.b   d0
1979         bne.b   L_110C
1980         bsr     ssin            ; normalized (regular) number
1981         bra.b   L_110G
1982 L_110C:
1983         cmp.b   #$20,d0         ; zero?
1984         bne.b   L_110D
1985         bsr     szero
1986         bra.b   L_110G
1987 L_110D:
1988         cmp.b   #$40,d0         ; infinity?
1989         bne.b   L_110E
1990         bsr     t_operr
1991         bra.b   L_110G
1992 L_110E:
1993         cmp.b   #$60,d0         ; NaN?
1994         bne.b   L_110F
1995         bsr     mon_nan
1996         bra.b   L_110G
1997 L_110F:
1998         bsr     ssind           ; assuming a denorm...
1999
2000 L_110G:
2001         fmove.l fpsr,d0         ; update status register
2002         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2003         fmove.l d0,fpsr
2004 *
2005 *       Result is now in FP0
2006 *
2007         movem.l USER_DA(a6),d0-d1/a0-a1
2008         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2009         unlk    a6
2010         rts
2011
2012 *
2013 *       MONADIC.GEN 1.4 1/16/92
2014 *
2015 *       MONADIC.GEN 1.3 4/30/91
2016 *
2017 *       MONADIC.GEN --- generic MONADIC template
2018 *
2019 *       This version saves all registers that will be used by the emulation
2020 *       routines and restores all but FP0 on exit.  The FPSR is
2021 *       updated to reflect the result of the operation.  Return value
2022 *       is placed in FP0 for single, double and extended results.
2023 *
2024 *       The package subroutines expect the incoming FPCR to be zeroed
2025 *       since they need extended precision to work properly.  The
2026 *       'final' FPCR is expected in d1 so that the calculated result
2027 *       can be properly sized and rounded.  Also, if the incoming FPCR
2028 *       has enabled any exceptions, the exception will be taken on the
2029 *       final fmovem in this template.
2030 *
2031 *       Customizations:
2032 *               1. Remove the movem.l at the entry and exit of
2033 *                  each routine if your compiler treats those
2034 *                  registers as scratch.
2035 *               2. Likewise, don't save FP0/FP1 if they are scratch
2036 *                  registers.
2037 *               3. Delete handling of the fpsr if you only care about
2038 *                  the result.
2039 *               4. Some (most?) C compilers convert all float arguments
2040 *                  to double, and provide no support at all for extended
2041 *                  precision so remove the fsinhs and fsinhx entry points.
2042 *               5. Move the result to d0/d1 if the compiler is that old.
2043
2044 *               Copyright (C) Motorola, Inc. 1991
2045 *                       All Rights Reserved
2046 *
2047 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
2048 *       The copyright notice above does not evidence any
2049 *       actual or intended publication of such source code.
2050
2051         xref    tag
2052         xref    ssinh
2053         xref    szero
2054         xref    sinf
2055         xref    mon_nan
2056         xref    ssinhd
2057
2058         xdef    fsinhs
2059 fsinhs:
2060         link    a6,#-LOCAL_SIZE
2061         movem.l d0-d1/a0-a1,USER_DA(a6)
2062         fmovem.x fp0-fp3,USER_FP0(a6)
2063         fmove.l fpsr,USER_FPSR(a6)
2064         fmove.l fpcr,USER_FPCR(a6)
2065         fmove.l fpcr,d1         ; user's rounding mode/precision
2066         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2067 *
2068 *       copy, convert and tag input argument
2069 *
2070         fmove.s 8(a6),fp0
2071         fmove.x fp0,ETEMP(a6)
2072         lea     ETEMP(a6),a0
2073         bsr     tag
2074         move.b  d0,STAG(a6)
2075         tst.b   d0
2076         bne.b   L_1112
2077         bsr     ssinh           ; normalized (regular) number
2078         bra.b   L_1116
2079 L_1112:
2080         cmp.b   #$20,d0         ; zero?
2081         bne.b   L_1113
2082         bsr     szero
2083         bra.b   L_1116
2084 L_1113:
2085         cmp.b   #$40,d0         ; infinity?
2086         bne.b   L_1114
2087         bsr     sinf
2088         bra.b   L_1116
2089 L_1114:
2090         cmp.b   #$60,d0         ; NaN?
2091         bne.b   L_1115
2092         bsr     mon_nan
2093         bra.b   L_1116
2094 L_1115:
2095         bsr     ssinhd          ; assuming a denorm...
2096
2097 L_1116:
2098         fmove.l fpsr,d0         ; update status register
2099         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2100         fmove.l d0,fpsr
2101 *
2102 *       Result is now in FP0
2103 *
2104         movem.l USER_DA(a6),d0-d1/a0-a1
2105         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2106         unlk    a6
2107         rts
2108
2109         xdef    fsinhd
2110 fsinhd:
2111         link    a6,#-LOCAL_SIZE
2112         movem.l d0-d1/a0-a1,USER_DA(a6)
2113         fmovem.x fp0-fp3,USER_FP0(a6)
2114         fmove.l fpsr,USER_FPSR(a6)
2115         fmove.l fpcr,USER_FPCR(a6)
2116         fmove.l fpcr,d1         ; user's rounding mode/precision
2117         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2118 *
2119 *       copy, convert and tag input argument
2120 *
2121         fmove.d 8(a6),fp0
2122         fmove.x fp0,ETEMP(a6)
2123         lea     ETEMP(a6),a0
2124         bsr     tag
2125         move.b  d0,STAG(a6)
2126         tst.b   d0
2127         bne.b   L_1117
2128         bsr     ssinh           ; normalized (regular) number
2129         bra.b   L_111B
2130 L_1117:
2131         cmp.b   #$20,d0         ; zero?
2132         bne.b   L_1118
2133         bsr     szero
2134         bra.b   L_111B
2135 L_1118:
2136         cmp.b   #$40,d0         ; infinity?
2137         bne.b   L_1119
2138         bsr     sinf
2139         bra.b   L_111B
2140 L_1119:
2141         cmp.b   #$60,d0         ; NaN?
2142         bne.b   L_111A
2143         bsr     mon_nan
2144         bra.b   L_111B
2145 L_111A:
2146         bsr     ssinhd          ; assuming a denorm...
2147
2148 L_111B:
2149         fmove.l fpsr,d0         ; update status register
2150         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2151         fmove.l d0,fpsr
2152 *
2153 *       Result is now in FP0
2154 *
2155         movem.l USER_DA(a6),d0-d1/a0-a1
2156         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2157         unlk    a6
2158         rts
2159
2160         xdef    fsinhx
2161 fsinhx:
2162         link    a6,#-LOCAL_SIZE
2163         movem.l d0-d1/a0-a1,USER_DA(a6)
2164         fmovem.x fp0-fp3,USER_FP0(a6)
2165         fmove.l fpsr,USER_FPSR(a6)
2166         fmove.l fpcr,USER_FPCR(a6)
2167         fmove.l fpcr,d1         ; user's rounding mode/precision
2168         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2169 *
2170 *       copy, convert and tag input argument
2171 *
2172         fmove.x 8(a6),fp0
2173         fmove.x fp0,ETEMP(a6)
2174         lea     ETEMP(a6),a0
2175         bsr     tag
2176         move.b  d0,STAG(a6)
2177         tst.b   d0
2178         bne.b   L_111C
2179         bsr     ssinh           ; normalized (regular) number
2180         bra.b   L_111G
2181 L_111C:
2182         cmp.b   #$20,d0         ; zero?
2183         bne.b   L_111D
2184         bsr     szero
2185         bra.b   L_111G
2186 L_111D:
2187         cmp.b   #$40,d0         ; infinity?
2188         bne.b   L_111E
2189         bsr     sinf
2190         bra.b   L_111G
2191 L_111E:
2192         cmp.b   #$60,d0         ; NaN?
2193         bne.b   L_111F
2194         bsr     mon_nan
2195         bra.b   L_111G
2196 L_111F:
2197         bsr     ssinhd          ; assuming a denorm...
2198
2199 L_111G:
2200         fmove.l fpsr,d0         ; update status register
2201         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2202         fmove.l d0,fpsr
2203 *
2204 *       Result is now in FP0
2205 *
2206         movem.l USER_DA(a6),d0-d1/a0-a1
2207         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2208         unlk    a6
2209         rts
2210
2211 *
2212 *       MONADIC.GEN 1.4 1/16/92
2213 *
2214 *       MONADIC.GEN 1.3 4/30/91
2215 *
2216 *       MONADIC.GEN --- generic MONADIC template
2217 *
2218 *       This version saves all registers that will be used by the emulation
2219 *       routines and restores all but FP0 on exit.  The FPSR is
2220 *       updated to reflect the result of the operation.  Return value
2221 *       is placed in FP0 for single, double and extended results.
2222 *
2223 *       The package subroutines expect the incoming FPCR to be zeroed
2224 *       since they need extended precision to work properly.  The
2225 *       'final' FPCR is expected in d1 so that the calculated result
2226 *       can be properly sized and rounded.  Also, if the incoming FPCR
2227 *       has enabled any exceptions, the exception will be taken on the
2228 *       final fmovem in this template.
2229 *
2230 *       Customizations:
2231 *               1. Remove the movem.l at the entry and exit of
2232 *                  each routine if your compiler treats those
2233 *                  registers as scratch.
2234 *               2. Likewise, don't save FP0/FP1 if they are scratch
2235 *                  registers.
2236 *               3. Delete handling of the fpsr if you only care about
2237 *                  the result.
2238 *               4. Some (most?) C compilers convert all float arguments
2239 *                  to double, and provide no support at all for extended
2240 *                  precision so remove the ftans and ftanx entry points.
2241 *               5. Move the result to d0/d1 if the compiler is that old.
2242
2243 *               Copyright (C) Motorola, Inc. 1991
2244 *                       All Rights Reserved
2245 *
2246 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
2247 *       The copyright notice above does not evidence any
2248 *       actual or intended publication of such source code.
2249
2250         xref    tag
2251         xref    stan
2252         xref    szero
2253         xref    t_operr
2254         xref    mon_nan
2255         xref    stand
2256
2257         xdef    ftans
2258 ftans:
2259         link    a6,#-LOCAL_SIZE
2260         movem.l d0-d1/a0-a1,USER_DA(a6)
2261         fmovem.x fp0-fp3,USER_FP0(a6)
2262         fmove.l fpsr,USER_FPSR(a6)
2263         fmove.l fpcr,USER_FPCR(a6)
2264         fmove.l fpcr,d1         ; user's rounding mode/precision
2265         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2266 *
2267 *       copy, convert and tag input argument
2268 *
2269         fmove.s 8(a6),fp0
2270         fmove.x fp0,ETEMP(a6)
2271         lea     ETEMP(a6),a0
2272         bsr     tag
2273         move.b  d0,STAG(a6)
2274         tst.b   d0
2275         bne.b   L_1122
2276         bsr     stan            ; normalized (regular) number
2277         bra.b   L_1126
2278 L_1122:
2279         cmp.b   #$20,d0         ; zero?
2280         bne.b   L_1123
2281         bsr     szero
2282         bra.b   L_1126
2283 L_1123:
2284         cmp.b   #$40,d0         ; infinity?
2285         bne.b   L_1124
2286         bsr     t_operr
2287         bra.b   L_1126
2288 L_1124:
2289         cmp.b   #$60,d0         ; NaN?
2290         bne.b   L_1125
2291         bsr     mon_nan
2292         bra.b   L_1126
2293 L_1125:
2294         bsr     stand           ; assuming a denorm...
2295
2296 L_1126:
2297         fmove.l fpsr,d0         ; update status register
2298         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2299         fmove.l d0,fpsr
2300 *
2301 *       Result is now in FP0
2302 *
2303         movem.l USER_DA(a6),d0-d1/a0-a1
2304         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2305         unlk    a6
2306         rts
2307
2308         xdef    ftand
2309 ftand:
2310         link    a6,#-LOCAL_SIZE
2311         movem.l d0-d1/a0-a1,USER_DA(a6)
2312         fmovem.x fp0-fp3,USER_FP0(a6)
2313         fmove.l fpsr,USER_FPSR(a6)
2314         fmove.l fpcr,USER_FPCR(a6)
2315         fmove.l fpcr,d1         ; user's rounding mode/precision
2316         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2317 *
2318 *       copy, convert and tag input argument
2319 *
2320         fmove.d 8(a6),fp0
2321         fmove.x fp0,ETEMP(a6)
2322         lea     ETEMP(a6),a0
2323         bsr     tag
2324         move.b  d0,STAG(a6)
2325         tst.b   d0
2326         bne.b   L_1127
2327         bsr     stan            ; normalized (regular) number
2328         bra.b   L_112B
2329 L_1127:
2330         cmp.b   #$20,d0         ; zero?
2331         bne.b   L_1128
2332         bsr     szero
2333         bra.b   L_112B
2334 L_1128:
2335         cmp.b   #$40,d0         ; infinity?
2336         bne.b   L_1129
2337         bsr     t_operr
2338         bra.b   L_112B
2339 L_1129:
2340         cmp.b   #$60,d0         ; NaN?
2341         bne.b   L_112A
2342         bsr     mon_nan
2343         bra.b   L_112B
2344 L_112A:
2345         bsr     stand           ; assuming a denorm...
2346
2347 L_112B:
2348         fmove.l fpsr,d0         ; update status register
2349         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2350         fmove.l d0,fpsr
2351 *
2352 *       Result is now in FP0
2353 *
2354         movem.l USER_DA(a6),d0-d1/a0-a1
2355         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2356         unlk    a6
2357         rts
2358
2359         xdef    ftanx
2360 ftanx:
2361         link    a6,#-LOCAL_SIZE
2362         movem.l d0-d1/a0-a1,USER_DA(a6)
2363         fmovem.x fp0-fp3,USER_FP0(a6)
2364         fmove.l fpsr,USER_FPSR(a6)
2365         fmove.l fpcr,USER_FPCR(a6)
2366         fmove.l fpcr,d1         ; user's rounding mode/precision
2367         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2368 *
2369 *       copy, convert and tag input argument
2370 *
2371         fmove.x 8(a6),fp0
2372         fmove.x fp0,ETEMP(a6)
2373         lea     ETEMP(a6),a0
2374         bsr     tag
2375         move.b  d0,STAG(a6)
2376         tst.b   d0
2377         bne.b   L_112C
2378         bsr     stan            ; normalized (regular) number
2379         bra.b   L_112G
2380 L_112C:
2381         cmp.b   #$20,d0         ; zero?
2382         bne.b   L_112D
2383         bsr     szero
2384         bra.b   L_112G
2385 L_112D:
2386         cmp.b   #$40,d0         ; infinity?
2387         bne.b   L_112E
2388         bsr     t_operr
2389         bra.b   L_112G
2390 L_112E:
2391         cmp.b   #$60,d0         ; NaN?
2392         bne.b   L_112F
2393         bsr     mon_nan
2394         bra.b   L_112G
2395 L_112F:
2396         bsr     stand           ; assuming a denorm...
2397
2398 L_112G:
2399         fmove.l fpsr,d0         ; update status register
2400         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2401         fmove.l d0,fpsr
2402 *
2403 *       Result is now in FP0
2404 *
2405         movem.l USER_DA(a6),d0-d1/a0-a1
2406         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2407         unlk    a6
2408         rts
2409
2410 *
2411 *       MONADIC.GEN 1.4 1/16/92
2412 *
2413 *       MONADIC.GEN 1.3 4/30/91
2414 *
2415 *       MONADIC.GEN --- generic MONADIC template
2416 *
2417 *       This version saves all registers that will be used by the emulation
2418 *       routines and restores all but FP0 on exit.  The FPSR is
2419 *       updated to reflect the result of the operation.  Return value
2420 *       is placed in FP0 for single, double and extended results.
2421 *
2422 *       The package subroutines expect the incoming FPCR to be zeroed
2423 *       since they need extended precision to work properly.  The
2424 *       'final' FPCR is expected in d1 so that the calculated result
2425 *       can be properly sized and rounded.  Also, if the incoming FPCR
2426 *       has enabled any exceptions, the exception will be taken on the
2427 *       final fmovem in this template.
2428 *
2429 *       Customizations:
2430 *               1. Remove the movem.l at the entry and exit of
2431 *                  each routine if your compiler treats those
2432 *                  registers as scratch.
2433 *               2. Likewise, don't save FP0/FP1 if they are scratch
2434 *                  registers.
2435 *               3. Delete handling of the fpsr if you only care about
2436 *                  the result.
2437 *               4. Some (most?) C compilers convert all float arguments
2438 *                  to double, and provide no support at all for extended
2439 *                  precision so remove the ftanhs and ftanhx entry points.
2440 *               5. Move the result to d0/d1 if the compiler is that old.
2441
2442 *               Copyright (C) Motorola, Inc. 1991
2443 *                       All Rights Reserved
2444 *
2445 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
2446 *       The copyright notice above does not evidence any
2447 *       actual or intended publication of such source code.
2448
2449         xref    tag
2450         xref    stanh
2451         xref    szero
2452         xref    sone
2453         xref    mon_nan
2454         xref    stanhd
2455
2456         xdef    ftanhs
2457 ftanhs:
2458         link    a6,#-LOCAL_SIZE
2459         movem.l d0-d1/a0-a1,USER_DA(a6)
2460         fmovem.x fp0-fp3,USER_FP0(a6)
2461         fmove.l fpsr,USER_FPSR(a6)
2462         fmove.l fpcr,USER_FPCR(a6)
2463         fmove.l fpcr,d1         ; user's rounding mode/precision
2464         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2465 *
2466 *       copy, convert and tag input argument
2467 *
2468         fmove.s 8(a6),fp0
2469         fmove.x fp0,ETEMP(a6)
2470         lea     ETEMP(a6),a0
2471         bsr     tag
2472         move.b  d0,STAG(a6)
2473         tst.b   d0
2474         bne.b   L_1132
2475         bsr     stanh           ; normalized (regular) number
2476         bra.b   L_1136
2477 L_1132:
2478         cmp.b   #$20,d0         ; zero?
2479         bne.b   L_1133
2480         bsr     szero
2481         bra.b   L_1136
2482 L_1133:
2483         cmp.b   #$40,d0         ; infinity?
2484         bne.b   L_1134
2485         bsr     sone
2486         bra.b   L_1136
2487 L_1134:
2488         cmp.b   #$60,d0         ; NaN?
2489         bne.b   L_1135
2490         bsr     mon_nan
2491         bra.b   L_1136
2492 L_1135:
2493         bsr     stanhd          ; assuming a denorm...
2494
2495 L_1136:
2496         fmove.l fpsr,d0         ; update status register
2497         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2498         fmove.l d0,fpsr
2499 *
2500 *       Result is now in FP0
2501 *
2502         movem.l USER_DA(a6),d0-d1/a0-a1
2503         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2504         unlk    a6
2505         rts
2506
2507         xdef    ftanhd
2508 ftanhd:
2509         link    a6,#-LOCAL_SIZE
2510         movem.l d0-d1/a0-a1,USER_DA(a6)
2511         fmovem.x fp0-fp3,USER_FP0(a6)
2512         fmove.l fpsr,USER_FPSR(a6)
2513         fmove.l fpcr,USER_FPCR(a6)
2514         fmove.l fpcr,d1         ; user's rounding mode/precision
2515         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2516 *
2517 *       copy, convert and tag input argument
2518 *
2519         fmove.d 8(a6),fp0
2520         fmove.x fp0,ETEMP(a6)
2521         lea     ETEMP(a6),a0
2522         bsr     tag
2523         move.b  d0,STAG(a6)
2524         tst.b   d0
2525         bne.b   L_1137
2526         bsr     stanh           ; normalized (regular) number
2527         bra.b   L_113B
2528 L_1137:
2529         cmp.b   #$20,d0         ; zero?
2530         bne.b   L_1138
2531         bsr     szero
2532         bra.b   L_113B
2533 L_1138:
2534         cmp.b   #$40,d0         ; infinity?
2535         bne.b   L_1139
2536         bsr     sone
2537         bra.b   L_113B
2538 L_1139:
2539         cmp.b   #$60,d0         ; NaN?
2540         bne.b   L_113A
2541         bsr     mon_nan
2542         bra.b   L_113B
2543 L_113A:
2544         bsr     stanhd          ; assuming a denorm...
2545
2546 L_113B:
2547         fmove.l fpsr,d0         ; update status register
2548         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2549         fmove.l d0,fpsr
2550 *
2551 *       Result is now in FP0
2552 *
2553         movem.l USER_DA(a6),d0-d1/a0-a1
2554         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2555         unlk    a6
2556         rts
2557
2558         xdef    ftanhx
2559 ftanhx:
2560         link    a6,#-LOCAL_SIZE
2561         movem.l d0-d1/a0-a1,USER_DA(a6)
2562         fmovem.x fp0-fp3,USER_FP0(a6)
2563         fmove.l fpsr,USER_FPSR(a6)
2564         fmove.l fpcr,USER_FPCR(a6)
2565         fmove.l fpcr,d1         ; user's rounding mode/precision
2566         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2567 *
2568 *       copy, convert and tag input argument
2569 *
2570         fmove.x 8(a6),fp0
2571         fmove.x fp0,ETEMP(a6)
2572         lea     ETEMP(a6),a0
2573         bsr     tag
2574         move.b  d0,STAG(a6)
2575         tst.b   d0
2576         bne.b   L_113C
2577         bsr     stanh           ; normalized (regular) number
2578         bra.b   L_113G
2579 L_113C:
2580         cmp.b   #$20,d0         ; zero?
2581         bne.b   L_113D
2582         bsr     szero
2583         bra.b   L_113G
2584 L_113D:
2585         cmp.b   #$40,d0         ; infinity?
2586         bne.b   L_113E
2587         bsr     sone
2588         bra.b   L_113G
2589 L_113E:
2590         cmp.b   #$60,d0         ; NaN?
2591         bne.b   L_113F
2592         bsr     mon_nan
2593         bra.b   L_113G
2594 L_113F:
2595         bsr     stanhd          ; assuming a denorm...
2596
2597 L_113G:
2598         fmove.l fpsr,d0         ; update status register
2599         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2600         fmove.l d0,fpsr
2601 *
2602 *       Result is now in FP0
2603 *
2604         movem.l USER_DA(a6),d0-d1/a0-a1
2605         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2606         unlk    a6
2607         rts
2608
2609 *
2610 *       MONADIC.GEN 1.4 1/16/92
2611 *
2612 *       MONADIC.GEN 1.3 4/30/91
2613 *
2614 *       MONADIC.GEN --- generic MONADIC template
2615 *
2616 *       This version saves all registers that will be used by the emulation
2617 *       routines and restores all but FP0 on exit.  The FPSR is
2618 *       updated to reflect the result of the operation.  Return value
2619 *       is placed in FP0 for single, double and extended results.
2620 *
2621 *       The package subroutines expect the incoming FPCR to be zeroed
2622 *       since they need extended precision to work properly.  The
2623 *       'final' FPCR is expected in d1 so that the calculated result
2624 *       can be properly sized and rounded.  Also, if the incoming FPCR
2625 *       has enabled any exceptions, the exception will be taken on the
2626 *       final fmovem in this template.
2627 *
2628 *       Customizations:
2629 *               1. Remove the movem.l at the entry and exit of
2630 *                  each routine if your compiler treats those
2631 *                  registers as scratch.
2632 *               2. Likewise, don't save FP0/FP1 if they are scratch
2633 *                  registers.
2634 *               3. Delete handling of the fpsr if you only care about
2635 *                  the result.
2636 *               4. Some (most?) C compilers convert all float arguments
2637 *                  to double, and provide no support at all for extended
2638 *                  precision so remove the ftentoxs and ftentoxx entry points.
2639 *               5. Move the result to d0/d1 if the compiler is that old.
2640
2641 *               Copyright (C) Motorola, Inc. 1991
2642 *                       All Rights Reserved
2643 *
2644 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
2645 *       The copyright notice above does not evidence any
2646 *       actual or intended publication of such source code.
2647
2648         xref    tag
2649         xref    stentox
2650         xref    ld_pone
2651         xref    szr_inf
2652         xref    mon_nan
2653         xref    stentoxd
2654
2655         xdef    ftentoxs
2656 ftentoxs:
2657         link    a6,#-LOCAL_SIZE
2658         movem.l d0-d1/a0-a1,USER_DA(a6)
2659         fmovem.x fp0-fp3,USER_FP0(a6)
2660         fmove.l fpsr,USER_FPSR(a6)
2661         fmove.l fpcr,USER_FPCR(a6)
2662         fmove.l fpcr,d1         ; user's rounding mode/precision
2663         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2664 *
2665 *       copy, convert and tag input argument
2666 *
2667         fmove.s 8(a6),fp0
2668         fmove.x fp0,ETEMP(a6)
2669         lea     ETEMP(a6),a0
2670         bsr     tag
2671         move.b  d0,STAG(a6)
2672         tst.b   d0
2673         bne.b   L_1142
2674         bsr     stentox         ; normalized (regular) number
2675         bra.b   L_1146
2676 L_1142:
2677         cmp.b   #$20,d0         ; zero?
2678         bne.b   L_1143
2679         bsr     ld_pone
2680         bra.b   L_1146
2681 L_1143:
2682         cmp.b   #$40,d0         ; infinity?
2683         bne.b   L_1144
2684         bsr     szr_inf
2685         bra.b   L_1146
2686 L_1144:
2687         cmp.b   #$60,d0         ; NaN?
2688         bne.b   L_1145
2689         bsr     mon_nan
2690         bra.b   L_1146
2691 L_1145:
2692         bsr     stentoxd                ; assuming a denorm...
2693
2694 L_1146:
2695         fmove.l fpsr,d0         ; update status register
2696         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2697         fmove.l d0,fpsr
2698 *
2699 *       Result is now in FP0
2700 *
2701         movem.l USER_DA(a6),d0-d1/a0-a1
2702         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2703         unlk    a6
2704         rts
2705
2706         xdef    ftentoxd
2707 ftentoxd:
2708         link    a6,#-LOCAL_SIZE
2709         movem.l d0-d1/a0-a1,USER_DA(a6)
2710         fmovem.x fp0-fp3,USER_FP0(a6)
2711         fmove.l fpsr,USER_FPSR(a6)
2712         fmove.l fpcr,USER_FPCR(a6)
2713         fmove.l fpcr,d1         ; user's rounding mode/precision
2714         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2715 *
2716 *       copy, convert and tag input argument
2717 *
2718         fmove.d 8(a6),fp0
2719         fmove.x fp0,ETEMP(a6)
2720         lea     ETEMP(a6),a0
2721         bsr     tag
2722         move.b  d0,STAG(a6)
2723         tst.b   d0
2724         bne.b   L_1147
2725         bsr     stentox         ; normalized (regular) number
2726         bra.b   L_114B
2727 L_1147:
2728         cmp.b   #$20,d0         ; zero?
2729         bne.b   L_1148
2730         bsr     ld_pone
2731         bra.b   L_114B
2732 L_1148:
2733         cmp.b   #$40,d0         ; infinity?
2734         bne.b   L_1149
2735         bsr     szr_inf
2736         bra.b   L_114B
2737 L_1149:
2738         cmp.b   #$60,d0         ; NaN?
2739         bne.b   L_114A
2740         bsr     mon_nan
2741         bra.b   L_114B
2742 L_114A:
2743         bsr     stentoxd                ; assuming a denorm...
2744
2745 L_114B:
2746         fmove.l fpsr,d0         ; update status register
2747         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2748         fmove.l d0,fpsr
2749 *
2750 *       Result is now in FP0
2751 *
2752         movem.l USER_DA(a6),d0-d1/a0-a1
2753         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2754         unlk    a6
2755         rts
2756
2757         xdef    ftentoxx
2758 ftentoxx:
2759         link    a6,#-LOCAL_SIZE
2760         movem.l d0-d1/a0-a1,USER_DA(a6)
2761         fmovem.x fp0-fp3,USER_FP0(a6)
2762         fmove.l fpsr,USER_FPSR(a6)
2763         fmove.l fpcr,USER_FPCR(a6)
2764         fmove.l fpcr,d1         ; user's rounding mode/precision
2765         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2766 *
2767 *       copy, convert and tag input argument
2768 *
2769         fmove.x 8(a6),fp0
2770         fmove.x fp0,ETEMP(a6)
2771         lea     ETEMP(a6),a0
2772         bsr     tag
2773         move.b  d0,STAG(a6)
2774         tst.b   d0
2775         bne.b   L_114C
2776         bsr     stentox         ; normalized (regular) number
2777         bra.b   L_114G
2778 L_114C:
2779         cmp.b   #$20,d0         ; zero?
2780         bne.b   L_114D
2781         bsr     ld_pone
2782         bra.b   L_114G
2783 L_114D:
2784         cmp.b   #$40,d0         ; infinity?
2785         bne.b   L_114E
2786         bsr     szr_inf
2787         bra.b   L_114G
2788 L_114E:
2789         cmp.b   #$60,d0         ; NaN?
2790         bne.b   L_114F
2791         bsr     mon_nan
2792         bra.b   L_114G
2793 L_114F:
2794         bsr     stentoxd                ; assuming a denorm...
2795
2796 L_114G:
2797         fmove.l fpsr,d0         ; update status register
2798         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2799         fmove.l d0,fpsr
2800 *
2801 *       Result is now in FP0
2802 *
2803         movem.l USER_DA(a6),d0-d1/a0-a1
2804         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2805         unlk    a6
2806         rts
2807
2808 *
2809 *       MONADIC.GEN 1.4 1/16/92
2810 *
2811 *       MONADIC.GEN 1.3 4/30/91
2812 *
2813 *       MONADIC.GEN --- generic MONADIC template
2814 *
2815 *       This version saves all registers that will be used by the emulation
2816 *       routines and restores all but FP0 on exit.  The FPSR is
2817 *       updated to reflect the result of the operation.  Return value
2818 *       is placed in FP0 for single, double and extended results.
2819 *
2820 *       The package subroutines expect the incoming FPCR to be zeroed
2821 *       since they need extended precision to work properly.  The
2822 *       'final' FPCR is expected in d1 so that the calculated result
2823 *       can be properly sized and rounded.  Also, if the incoming FPCR
2824 *       has enabled any exceptions, the exception will be taken on the
2825 *       final fmovem in this template.
2826 *
2827 *       Customizations:
2828 *               1. Remove the movem.l at the entry and exit of
2829 *                  each routine if your compiler treats those
2830 *                  registers as scratch.
2831 *               2. Likewise, don't save FP0/FP1 if they are scratch
2832 *                  registers.
2833 *               3. Delete handling of the fpsr if you only care about
2834 *                  the result.
2835 *               4. Some (most?) C compilers convert all float arguments
2836 *                  to double, and provide no support at all for extended
2837 *                  precision so remove the ftwotoxs and ftwotoxx entry points.
2838 *               5. Move the result to d0/d1 if the compiler is that old.
2839
2840 *               Copyright (C) Motorola, Inc. 1991
2841 *                       All Rights Reserved
2842 *
2843 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
2844 *       The copyright notice above does not evidence any
2845 *       actual or intended publication of such source code.
2846
2847         xref    tag
2848         xref    stwotox
2849         xref    ld_pone
2850         xref    szr_inf
2851         xref    mon_nan
2852         xref    stwotoxd
2853
2854         xdef    ftwotoxs
2855 ftwotoxs:
2856         link    a6,#-LOCAL_SIZE
2857         movem.l d0-d1/a0-a1,USER_DA(a6)
2858         fmovem.x fp0-fp3,USER_FP0(a6)
2859         fmove.l fpsr,USER_FPSR(a6)
2860         fmove.l fpcr,USER_FPCR(a6)
2861         fmove.l fpcr,d1         ; user's rounding mode/precision
2862         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2863 *
2864 *       copy, convert and tag input argument
2865 *
2866         fmove.s 8(a6),fp0
2867         fmove.x fp0,ETEMP(a6)
2868         lea     ETEMP(a6),a0
2869         bsr     tag
2870         move.b  d0,STAG(a6)
2871         tst.b   d0
2872         bne.b   L_1152
2873         bsr     stwotox         ; normalized (regular) number
2874         bra.b   L_1156
2875 L_1152:
2876         cmp.b   #$20,d0         ; zero?
2877         bne.b   L_1153
2878         bsr     ld_pone
2879         bra.b   L_1156
2880 L_1153:
2881         cmp.b   #$40,d0         ; infinity?
2882         bne.b   L_1154
2883         bsr     szr_inf
2884         bra.b   L_1156
2885 L_1154:
2886         cmp.b   #$60,d0         ; NaN?
2887         bne.b   L_1155
2888         bsr     mon_nan
2889         bra.b   L_1156
2890 L_1155:
2891         bsr     stwotoxd                ; assuming a denorm...
2892
2893 L_1156:
2894         fmove.l fpsr,d0         ; update status register
2895         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2896         fmove.l d0,fpsr
2897 *
2898 *       Result is now in FP0
2899 *
2900         movem.l USER_DA(a6),d0-d1/a0-a1
2901         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2902         unlk    a6
2903         rts
2904
2905         xdef    ftwotoxd
2906 ftwotoxd:
2907         link    a6,#-LOCAL_SIZE
2908         movem.l d0-d1/a0-a1,USER_DA(a6)
2909         fmovem.x fp0-fp3,USER_FP0(a6)
2910         fmove.l fpsr,USER_FPSR(a6)
2911         fmove.l fpcr,USER_FPCR(a6)
2912         fmove.l fpcr,d1         ; user's rounding mode/precision
2913         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2914 *
2915 *       copy, convert and tag input argument
2916 *
2917         fmove.d 8(a6),fp0
2918         fmove.x fp0,ETEMP(a6)
2919         lea     ETEMP(a6),a0
2920         bsr     tag
2921         move.b  d0,STAG(a6)
2922         tst.b   d0
2923         bne.b   L_1157
2924         bsr     stwotox         ; normalized (regular) number
2925         bra.b   L_115B
2926 L_1157:
2927         cmp.b   #$20,d0         ; zero?
2928         bne.b   L_1158
2929         bsr     ld_pone
2930         bra.b   L_115B
2931 L_1158:
2932         cmp.b   #$40,d0         ; infinity?
2933         bne.b   L_1159
2934         bsr     szr_inf
2935         bra.b   L_115B
2936 L_1159:
2937         cmp.b   #$60,d0         ; NaN?
2938         bne.b   L_115A
2939         bsr     mon_nan
2940         bra.b   L_115B
2941 L_115A:
2942         bsr     stwotoxd                ; assuming a denorm...
2943
2944 L_115B:
2945         fmove.l fpsr,d0         ; update status register
2946         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2947         fmove.l d0,fpsr
2948 *
2949 *       Result is now in FP0
2950 *
2951         movem.l USER_DA(a6),d0-d1/a0-a1
2952         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
2953         unlk    a6
2954         rts
2955
2956         xdef    ftwotoxx
2957 ftwotoxx:
2958         link    a6,#-LOCAL_SIZE
2959         movem.l d0-d1/a0-a1,USER_DA(a6)
2960         fmovem.x fp0-fp3,USER_FP0(a6)
2961         fmove.l fpsr,USER_FPSR(a6)
2962         fmove.l fpcr,USER_FPCR(a6)
2963         fmove.l fpcr,d1         ; user's rounding mode/precision
2964         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
2965 *
2966 *       copy, convert and tag input argument
2967 *
2968         fmove.x 8(a6),fp0
2969         fmove.x fp0,ETEMP(a6)
2970         lea     ETEMP(a6),a0
2971         bsr     tag
2972         move.b  d0,STAG(a6)
2973         tst.b   d0
2974         bne.b   L_115C
2975         bsr     stwotox         ; normalized (regular) number
2976         bra.b   L_115G
2977 L_115C:
2978         cmp.b   #$20,d0         ; zero?
2979         bne.b   L_115D
2980         bsr     ld_pone
2981         bra.b   L_115G
2982 L_115D:
2983         cmp.b   #$40,d0         ; infinity?
2984         bne.b   L_115E
2985         bsr     szr_inf
2986         bra.b   L_115G
2987 L_115E:
2988         cmp.b   #$60,d0         ; NaN?
2989         bne.b   L_115F
2990         bsr     mon_nan
2991         bra.b   L_115G
2992 L_115F:
2993         bsr     stwotoxd                ; assuming a denorm...
2994
2995 L_115G:
2996         fmove.l fpsr,d0         ; update status register
2997         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
2998         fmove.l d0,fpsr
2999 *
3000 *       Result is now in FP0
3001 *
3002         movem.l USER_DA(a6),d0-d1/a0-a1
3003         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3004         unlk    a6
3005         rts
3006
3007 *
3008 *       MONADIC.GEN 1.4 1/16/92
3009 *
3010 *       MONADIC.GEN 1.3 4/30/91
3011 *
3012 *       MONADIC.GEN --- generic MONADIC template
3013 *
3014 *       This version saves all registers that will be used by the emulation
3015 *       routines and restores all but FP0 on exit.  The FPSR is
3016 *       updated to reflect the result of the operation.  Return value
3017 *       is placed in FP0 for single, double and extended results.
3018 *
3019 *       The package subroutines expect the incoming FPCR to be zeroed
3020 *       since they need extended precision to work properly.  The
3021 *       'final' FPCR is expected in d1 so that the calculated result
3022 *       can be properly sized and rounded.  Also, if the incoming FPCR
3023 *       has enabled any exceptions, the exception will be taken on the
3024 *       final fmovem in this template.
3025 *
3026 *       Customizations:
3027 *               1. Remove the movem.l at the entry and exit of
3028 *                  each routine if your compiler treats those
3029 *                  registers as scratch.
3030 *               2. Likewise, don't save FP0/FP1 if they are scratch
3031 *                  registers.
3032 *               3. Delete handling of the fpsr if you only care about
3033 *                  the result.
3034 *               4. Some (most?) C compilers convert all float arguments
3035 *                  to double, and provide no support at all for extended
3036 *                  precision so remove the fgetmans and fgetmanx entry points.
3037 *               5. Move the result to d0/d1 if the compiler is that old.
3038
3039 *               Copyright (C) Motorola, Inc. 1991
3040 *                       All Rights Reserved
3041 *
3042 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
3043 *       The copyright notice above does not evidence any
3044 *       actual or intended publication of such source code.
3045
3046         xref    tag
3047         xref    sgetman
3048         xref    szero
3049         xref    t_operr
3050         xref    mon_nan
3051         xref    sgetmand
3052
3053         xdef    fgetmans
3054 fgetmans:
3055         link    a6,#-LOCAL_SIZE
3056         movem.l d0-d1/a0-a1,USER_DA(a6)
3057         fmovem.x fp0-fp3,USER_FP0(a6)
3058         fmove.l fpsr,USER_FPSR(a6)
3059         fmove.l fpcr,USER_FPCR(a6)
3060         fmove.l fpcr,d1         ; user's rounding mode/precision
3061         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3062 *
3063 *       copy, convert and tag input argument
3064 *
3065         fmove.s 8(a6),fp0
3066         fmove.x fp0,ETEMP(a6)
3067         lea     ETEMP(a6),a0
3068         bsr     tag
3069         move.b  d0,STAG(a6)
3070         tst.b   d0
3071         bne.b   L_1162
3072         bsr     sgetman         ; normalized (regular) number
3073         bra.b   L_1166
3074 L_1162:
3075         cmp.b   #$20,d0         ; zero?
3076         bne.b   L_1163
3077         bsr     szero
3078         bra.b   L_1166
3079 L_1163:
3080         cmp.b   #$40,d0         ; infinity?
3081         bne.b   L_1164
3082         bsr     t_operr
3083         bra.b   L_1166
3084 L_1164:
3085         cmp.b   #$60,d0         ; NaN?
3086         bne.b   L_1165
3087         bsr     mon_nan
3088         bra.b   L_1166
3089 L_1165:
3090         bsr     sgetmand                ; assuming a denorm...
3091
3092 L_1166:
3093         fmove.l fpsr,d0         ; update status register
3094         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3095         fmove.l d0,fpsr
3096 *
3097 *       Result is now in FP0
3098 *
3099         movem.l USER_DA(a6),d0-d1/a0-a1
3100         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3101         unlk    a6
3102         rts
3103
3104         xdef    fgetmand
3105 fgetmand:
3106         link    a6,#-LOCAL_SIZE
3107         movem.l d0-d1/a0-a1,USER_DA(a6)
3108         fmovem.x fp0-fp3,USER_FP0(a6)
3109         fmove.l fpsr,USER_FPSR(a6)
3110         fmove.l fpcr,USER_FPCR(a6)
3111         fmove.l fpcr,d1         ; user's rounding mode/precision
3112         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3113 *
3114 *       copy, convert and tag input argument
3115 *
3116         fmove.d 8(a6),fp0
3117         fmove.x fp0,ETEMP(a6)
3118         lea     ETEMP(a6),a0
3119         bsr     tag
3120         move.b  d0,STAG(a6)
3121         tst.b   d0
3122         bne.b   L_1167
3123         bsr     sgetman         ; normalized (regular) number
3124         bra.b   L_116B
3125 L_1167:
3126         cmp.b   #$20,d0         ; zero?
3127         bne.b   L_1168
3128         bsr     szero
3129         bra.b   L_116B
3130 L_1168:
3131         cmp.b   #$40,d0         ; infinity?
3132         bne.b   L_1169
3133         bsr     t_operr
3134         bra.b   L_116B
3135 L_1169:
3136         cmp.b   #$60,d0         ; NaN?
3137         bne.b   L_116A
3138         bsr     mon_nan
3139         bra.b   L_116B
3140 L_116A:
3141         bsr     sgetmand                ; assuming a denorm...
3142
3143 L_116B:
3144         fmove.l fpsr,d0         ; update status register
3145         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3146         fmove.l d0,fpsr
3147 *
3148 *       Result is now in FP0
3149 *
3150         movem.l USER_DA(a6),d0-d1/a0-a1
3151         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3152         unlk    a6
3153         rts
3154
3155         xdef    fgetmanx
3156 fgetmanx:
3157         link    a6,#-LOCAL_SIZE
3158         movem.l d0-d1/a0-a1,USER_DA(a6)
3159         fmovem.x fp0-fp3,USER_FP0(a6)
3160         fmove.l fpsr,USER_FPSR(a6)
3161         fmove.l fpcr,USER_FPCR(a6)
3162         fmove.l fpcr,d1         ; user's rounding mode/precision
3163         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3164 *
3165 *       copy, convert and tag input argument
3166 *
3167         fmove.x 8(a6),fp0
3168         fmove.x fp0,ETEMP(a6)
3169         lea     ETEMP(a6),a0
3170         bsr     tag
3171         move.b  d0,STAG(a6)
3172         tst.b   d0
3173         bne.b   L_116C
3174         bsr     sgetman         ; normalized (regular) number
3175         bra.b   L_116G
3176 L_116C:
3177         cmp.b   #$20,d0         ; zero?
3178         bne.b   L_116D
3179         bsr     szero
3180         bra.b   L_116G
3181 L_116D:
3182         cmp.b   #$40,d0         ; infinity?
3183         bne.b   L_116E
3184         bsr     t_operr
3185         bra.b   L_116G
3186 L_116E:
3187         cmp.b   #$60,d0         ; NaN?
3188         bne.b   L_116F
3189         bsr     mon_nan
3190         bra.b   L_116G
3191 L_116F:
3192         bsr     sgetmand                ; assuming a denorm...
3193
3194 L_116G:
3195         fmove.l fpsr,d0         ; update status register
3196         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3197         fmove.l d0,fpsr
3198 *
3199 *       Result is now in FP0
3200 *
3201         movem.l USER_DA(a6),d0-d1/a0-a1
3202         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3203         unlk    a6
3204         rts
3205
3206 *
3207 *       MONADIC.GEN 1.4 1/16/92
3208 *
3209 *       MONADIC.GEN 1.3 4/30/91
3210 *
3211 *       MONADIC.GEN --- generic MONADIC template
3212 *
3213 *       This version saves all registers that will be used by the emulation
3214 *       routines and restores all but FP0 on exit.  The FPSR is
3215 *       updated to reflect the result of the operation.  Return value
3216 *       is placed in FP0 for single, double and extended results.
3217 *
3218 *       The package subroutines expect the incoming FPCR to be zeroed
3219 *       since they need extended precision to work properly.  The
3220 *       'final' FPCR is expected in d1 so that the calculated result
3221 *       can be properly sized and rounded.  Also, if the incoming FPCR
3222 *       has enabled any exceptions, the exception will be taken on the
3223 *       final fmovem in this template.
3224 *
3225 *       Customizations:
3226 *               1. Remove the movem.l at the entry and exit of
3227 *                  each routine if your compiler treats those
3228 *                  registers as scratch.
3229 *               2. Likewise, don't save FP0/FP1 if they are scratch
3230 *                  registers.
3231 *               3. Delete handling of the fpsr if you only care about
3232 *                  the result.
3233 *               4. Some (most?) C compilers convert all float arguments
3234 *                  to double, and provide no support at all for extended
3235 *                  precision so remove the flogns and flognx entry points.
3236 *               5. Move the result to d0/d1 if the compiler is that old.
3237
3238 *               Copyright (C) Motorola, Inc. 1991
3239 *                       All Rights Reserved
3240 *
3241 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
3242 *       The copyright notice above does not evidence any
3243 *       actual or intended publication of such source code.
3244
3245         xref    tag
3246         xref    sslogn
3247         xref    t_dz2
3248         xref    sopr_inf
3249         xref    mon_nan
3250         xref    sslognd
3251
3252         xdef    flogns
3253 flogns:
3254         link    a6,#-LOCAL_SIZE
3255         movem.l d0-d1/a0-a1,USER_DA(a6)
3256         fmovem.x fp0-fp3,USER_FP0(a6)
3257         fmove.l fpsr,USER_FPSR(a6)
3258         fmove.l fpcr,USER_FPCR(a6)
3259         fmove.l fpcr,d1         ; user's rounding mode/precision
3260         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3261 *
3262 *       copy, convert and tag input argument
3263 *
3264         fmove.s 8(a6),fp0
3265         fmove.x fp0,ETEMP(a6)
3266         lea     ETEMP(a6),a0
3267         bsr     tag
3268         move.b  d0,STAG(a6)
3269         tst.b   d0
3270         bne.b   L_1172
3271         bsr     sslogn          ; normalized (regular) number
3272         bra.b   L_1176
3273 L_1172:
3274         cmp.b   #$20,d0         ; zero?
3275         bne.b   L_1173
3276         bsr     t_dz2
3277         bra.b   L_1176
3278 L_1173:
3279         cmp.b   #$40,d0         ; infinity?
3280         bne.b   L_1174
3281         bsr     sopr_inf
3282         bra.b   L_1176
3283 L_1174:
3284         cmp.b   #$60,d0         ; NaN?
3285         bne.b   L_1175
3286         bsr     mon_nan
3287         bra.b   L_1176
3288 L_1175:
3289         bsr     sslognd         ; assuming a denorm...
3290
3291 L_1176:
3292         fmove.l fpsr,d0         ; update status register
3293         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3294         fmove.l d0,fpsr
3295 *
3296 *       Result is now in FP0
3297 *
3298         movem.l USER_DA(a6),d0-d1/a0-a1
3299         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3300         unlk    a6
3301         rts
3302
3303         xdef    flognd
3304 flognd:
3305         link    a6,#-LOCAL_SIZE
3306         movem.l d0-d1/a0-a1,USER_DA(a6)
3307         fmovem.x fp0-fp3,USER_FP0(a6)
3308         fmove.l fpsr,USER_FPSR(a6)
3309         fmove.l fpcr,USER_FPCR(a6)
3310         fmove.l fpcr,d1         ; user's rounding mode/precision
3311         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3312 *
3313 *       copy, convert and tag input argument
3314 *
3315         fmove.d 8(a6),fp0
3316         fmove.x fp0,ETEMP(a6)
3317         lea     ETEMP(a6),a0
3318         bsr     tag
3319         move.b  d0,STAG(a6)
3320         tst.b   d0
3321         bne.b   L_1177
3322         bsr     sslogn          ; normalized (regular) number
3323         bra.b   L_117B
3324 L_1177:
3325         cmp.b   #$20,d0         ; zero?
3326         bne.b   L_1178
3327         bsr     t_dz2
3328         bra.b   L_117B
3329 L_1178:
3330         cmp.b   #$40,d0         ; infinity?
3331         bne.b   L_1179
3332         bsr     sopr_inf
3333         bra.b   L_117B
3334 L_1179:
3335         cmp.b   #$60,d0         ; NaN?
3336         bne.b   L_117A
3337         bsr     mon_nan
3338         bra.b   L_117B
3339 L_117A:
3340         bsr     sslognd         ; assuming a denorm...
3341
3342 L_117B:
3343         fmove.l fpsr,d0         ; update status register
3344         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3345         fmove.l d0,fpsr
3346 *
3347 *       Result is now in FP0
3348 *
3349         movem.l USER_DA(a6),d0-d1/a0-a1
3350         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3351         unlk    a6
3352         rts
3353
3354         xdef    flognx
3355 flognx:
3356         link    a6,#-LOCAL_SIZE
3357         movem.l d0-d1/a0-a1,USER_DA(a6)
3358         fmovem.x fp0-fp3,USER_FP0(a6)
3359         fmove.l fpsr,USER_FPSR(a6)
3360         fmove.l fpcr,USER_FPCR(a6)
3361         fmove.l fpcr,d1         ; user's rounding mode/precision
3362         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3363 *
3364 *       copy, convert and tag input argument
3365 *
3366         fmove.x 8(a6),fp0
3367         fmove.x fp0,ETEMP(a6)
3368         lea     ETEMP(a6),a0
3369         bsr     tag
3370         move.b  d0,STAG(a6)
3371         tst.b   d0
3372         bne.b   L_117C
3373         bsr     sslogn          ; normalized (regular) number
3374         bra.b   L_117G
3375 L_117C:
3376         cmp.b   #$20,d0         ; zero?
3377         bne.b   L_117D
3378         bsr     t_dz2
3379         bra.b   L_117G
3380 L_117D:
3381         cmp.b   #$40,d0         ; infinity?
3382         bne.b   L_117E
3383         bsr     sopr_inf
3384         bra.b   L_117G
3385 L_117E:
3386         cmp.b   #$60,d0         ; NaN?
3387         bne.b   L_117F
3388         bsr     mon_nan
3389         bra.b   L_117G
3390 L_117F:
3391         bsr     sslognd         ; assuming a denorm...
3392
3393 L_117G:
3394         fmove.l fpsr,d0         ; update status register
3395         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3396         fmove.l d0,fpsr
3397 *
3398 *       Result is now in FP0
3399 *
3400         movem.l USER_DA(a6),d0-d1/a0-a1
3401         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3402         unlk    a6
3403         rts
3404
3405 *
3406 *       MONADIC.GEN 1.4 1/16/92
3407 *
3408 *       MONADIC.GEN 1.3 4/30/91
3409 *
3410 *       MONADIC.GEN --- generic MONADIC template
3411 *
3412 *       This version saves all registers that will be used by the emulation
3413 *       routines and restores all but FP0 on exit.  The FPSR is
3414 *       updated to reflect the result of the operation.  Return value
3415 *       is placed in FP0 for single, double and extended results.
3416 *
3417 *       The package subroutines expect the incoming FPCR to be zeroed
3418 *       since they need extended precision to work properly.  The
3419 *       'final' FPCR is expected in d1 so that the calculated result
3420 *       can be properly sized and rounded.  Also, if the incoming FPCR
3421 *       has enabled any exceptions, the exception will be taken on the
3422 *       final fmovem in this template.
3423 *
3424 *       Customizations:
3425 *               1. Remove the movem.l at the entry and exit of
3426 *                  each routine if your compiler treats those
3427 *                  registers as scratch.
3428 *               2. Likewise, don't save FP0/FP1 if they are scratch
3429 *                  registers.
3430 *               3. Delete handling of the fpsr if you only care about
3431 *                  the result.
3432 *               4. Some (most?) C compilers convert all float arguments
3433 *                  to double, and provide no support at all for extended
3434 *                  precision so remove the flog2s and flog2x entry points.
3435 *               5. Move the result to d0/d1 if the compiler is that old.
3436
3437 *               Copyright (C) Motorola, Inc. 1991
3438 *                       All Rights Reserved
3439 *
3440 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
3441 *       The copyright notice above does not evidence any
3442 *       actual or intended publication of such source code.
3443
3444         xref    tag
3445         xref    sslog2
3446         xref    t_dz2
3447         xref    sopr_inf
3448         xref    mon_nan
3449         xref    sslog2d
3450
3451         xdef    flog2s
3452 flog2s:
3453         link    a6,#-LOCAL_SIZE
3454         movem.l d0-d1/a0-a1,USER_DA(a6)
3455         fmovem.x fp0-fp3,USER_FP0(a6)
3456         fmove.l fpsr,USER_FPSR(a6)
3457         fmove.l fpcr,USER_FPCR(a6)
3458         fmove.l fpcr,d1         ; user's rounding mode/precision
3459         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3460 *
3461 *       copy, convert and tag input argument
3462 *
3463         fmove.s 8(a6),fp0
3464         fmove.x fp0,ETEMP(a6)
3465         lea     ETEMP(a6),a0
3466         bsr     tag
3467         move.b  d0,STAG(a6)
3468         tst.b   d0
3469         bne.b   L_1182
3470         bsr     sslog2          ; normalized (regular) number
3471         bra.b   L_1186
3472 L_1182:
3473         cmp.b   #$20,d0         ; zero?
3474         bne.b   L_1183
3475         bsr     t_dz2
3476         bra.b   L_1186
3477 L_1183:
3478         cmp.b   #$40,d0         ; infinity?
3479         bne.b   L_1184
3480         bsr     sopr_inf
3481         bra.b   L_1186
3482 L_1184:
3483         cmp.b   #$60,d0         ; NaN?
3484         bne.b   L_1185
3485         bsr     mon_nan
3486         bra.b   L_1186
3487 L_1185:
3488         bsr     sslog2d         ; assuming a denorm...
3489
3490 L_1186:
3491         fmove.l fpsr,d0         ; update status register
3492         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3493         fmove.l d0,fpsr
3494 *
3495 *       Result is now in FP0
3496 *
3497         movem.l USER_DA(a6),d0-d1/a0-a1
3498         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3499         unlk    a6
3500         rts
3501
3502         xdef    flog2d
3503 flog2d:
3504         link    a6,#-LOCAL_SIZE
3505         movem.l d0-d1/a0-a1,USER_DA(a6)
3506         fmovem.x fp0-fp3,USER_FP0(a6)
3507         fmove.l fpsr,USER_FPSR(a6)
3508         fmove.l fpcr,USER_FPCR(a6)
3509         fmove.l fpcr,d1         ; user's rounding mode/precision
3510         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3511 *
3512 *       copy, convert and tag input argument
3513 *
3514         fmove.d 8(a6),fp0
3515         fmove.x fp0,ETEMP(a6)
3516         lea     ETEMP(a6),a0
3517         bsr     tag
3518         move.b  d0,STAG(a6)
3519         tst.b   d0
3520         bne.b   L_1187
3521         bsr     sslog2          ; normalized (regular) number
3522         bra.b   L_118B
3523 L_1187:
3524         cmp.b   #$20,d0         ; zero?
3525         bne.b   L_1188
3526         bsr     t_dz2
3527         bra.b   L_118B
3528 L_1188:
3529         cmp.b   #$40,d0         ; infinity?
3530         bne.b   L_1189
3531         bsr     sopr_inf
3532         bra.b   L_118B
3533 L_1189:
3534         cmp.b   #$60,d0         ; NaN?
3535         bne.b   L_118A
3536         bsr     mon_nan
3537         bra.b   L_118B
3538 L_118A:
3539         bsr     sslog2d         ; assuming a denorm...
3540
3541 L_118B:
3542         fmove.l fpsr,d0         ; update status register
3543         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3544         fmove.l d0,fpsr
3545 *
3546 *       Result is now in FP0
3547 *
3548         movem.l USER_DA(a6),d0-d1/a0-a1
3549         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3550         unlk    a6
3551         rts
3552
3553         xdef    flog2x
3554 flog2x:
3555         link    a6,#-LOCAL_SIZE
3556         movem.l d0-d1/a0-a1,USER_DA(a6)
3557         fmovem.x fp0-fp3,USER_FP0(a6)
3558         fmove.l fpsr,USER_FPSR(a6)
3559         fmove.l fpcr,USER_FPCR(a6)
3560         fmove.l fpcr,d1         ; user's rounding mode/precision
3561         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3562 *
3563 *       copy, convert and tag input argument
3564 *
3565         fmove.x 8(a6),fp0
3566         fmove.x fp0,ETEMP(a6)
3567         lea     ETEMP(a6),a0
3568         bsr     tag
3569         move.b  d0,STAG(a6)
3570         tst.b   d0
3571         bne.b   L_118C
3572         bsr     sslog2          ; normalized (regular) number
3573         bra.b   L_118G
3574 L_118C:
3575         cmp.b   #$20,d0         ; zero?
3576         bne.b   L_118D
3577         bsr     t_dz2
3578         bra.b   L_118G
3579 L_118D:
3580         cmp.b   #$40,d0         ; infinity?
3581         bne.b   L_118E
3582         bsr     sopr_inf
3583         bra.b   L_118G
3584 L_118E:
3585         cmp.b   #$60,d0         ; NaN?
3586         bne.b   L_118F
3587         bsr     mon_nan
3588         bra.b   L_118G
3589 L_118F:
3590         bsr     sslog2d         ; assuming a denorm...
3591
3592 L_118G:
3593         fmove.l fpsr,d0         ; update status register
3594         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3595         fmove.l d0,fpsr
3596 *
3597 *       Result is now in FP0
3598 *
3599         movem.l USER_DA(a6),d0-d1/a0-a1
3600         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3601         unlk    a6
3602         rts
3603
3604 *
3605 *       MONADIC.GEN 1.4 1/16/92
3606 *
3607 *       MONADIC.GEN 1.3 4/30/91
3608 *
3609 *       MONADIC.GEN --- generic MONADIC template
3610 *
3611 *       This version saves all registers that will be used by the emulation
3612 *       routines and restores all but FP0 on exit.  The FPSR is
3613 *       updated to reflect the result of the operation.  Return value
3614 *       is placed in FP0 for single, double and extended results.
3615 *
3616 *       The package subroutines expect the incoming FPCR to be zeroed
3617 *       since they need extended precision to work properly.  The
3618 *       'final' FPCR is expected in d1 so that the calculated result
3619 *       can be properly sized and rounded.  Also, if the incoming FPCR
3620 *       has enabled any exceptions, the exception will be taken on the
3621 *       final fmovem in this template.
3622 *
3623 *       Customizations:
3624 *               1. Remove the movem.l at the entry and exit of
3625 *                  each routine if your compiler treats those
3626 *                  registers as scratch.
3627 *               2. Likewise, don't save FP0/FP1 if they are scratch
3628 *                  registers.
3629 *               3. Delete handling of the fpsr if you only care about
3630 *                  the result.
3631 *               4. Some (most?) C compilers convert all float arguments
3632 *                  to double, and provide no support at all for extended
3633 *                  precision so remove the flog10s and flog10x entry points.
3634 *               5. Move the result to d0/d1 if the compiler is that old.
3635
3636 *               Copyright (C) Motorola, Inc. 1991
3637 *                       All Rights Reserved
3638 *
3639 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
3640 *       The copyright notice above does not evidence any
3641 *       actual or intended publication of such source code.
3642
3643         xref    tag
3644         xref    sslog10
3645         xref    t_dz2
3646         xref    sopr_inf
3647         xref    mon_nan
3648         xref    sslog10d
3649
3650         xdef    flog10s
3651 flog10s:
3652         link    a6,#-LOCAL_SIZE
3653         movem.l d0-d1/a0-a1,USER_DA(a6)
3654         fmovem.x fp0-fp3,USER_FP0(a6)
3655         fmove.l fpsr,USER_FPSR(a6)
3656         fmove.l fpcr,USER_FPCR(a6)
3657         fmove.l fpcr,d1         ; user's rounding mode/precision
3658         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3659 *
3660 *       copy, convert and tag input argument
3661 *
3662         fmove.s 8(a6),fp0
3663         fmove.x fp0,ETEMP(a6)
3664         lea     ETEMP(a6),a0
3665         bsr     tag
3666         move.b  d0,STAG(a6)
3667         tst.b   d0
3668         bne.b   L_1192
3669         bsr     sslog10         ; normalized (regular) number
3670         bra.b   L_1196
3671 L_1192:
3672         cmp.b   #$20,d0         ; zero?
3673         bne.b   L_1193
3674         bsr     t_dz2
3675         bra.b   L_1196
3676 L_1193:
3677         cmp.b   #$40,d0         ; infinity?
3678         bne.b   L_1194
3679         bsr     sopr_inf
3680         bra.b   L_1196
3681 L_1194:
3682         cmp.b   #$60,d0         ; NaN?
3683         bne.b   L_1195
3684         bsr     mon_nan
3685         bra.b   L_1196
3686 L_1195:
3687         bsr     sslog10d                ; assuming a denorm...
3688
3689 L_1196:
3690         fmove.l fpsr,d0         ; update status register
3691         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3692         fmove.l d0,fpsr
3693 *
3694 *       Result is now in FP0
3695 *
3696         movem.l USER_DA(a6),d0-d1/a0-a1
3697         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3698         unlk    a6
3699         rts
3700
3701         xdef    flog10d
3702 flog10d:
3703         link    a6,#-LOCAL_SIZE
3704         movem.l d0-d1/a0-a1,USER_DA(a6)
3705         fmovem.x fp0-fp3,USER_FP0(a6)
3706         fmove.l fpsr,USER_FPSR(a6)
3707         fmove.l fpcr,USER_FPCR(a6)
3708         fmove.l fpcr,d1         ; user's rounding mode/precision
3709         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3710 *
3711 *       copy, convert and tag input argument
3712 *
3713         fmove.d 8(a6),fp0
3714         fmove.x fp0,ETEMP(a6)
3715         lea     ETEMP(a6),a0
3716         bsr     tag
3717         move.b  d0,STAG(a6)
3718         tst.b   d0
3719         bne.b   L_1197
3720         bsr     sslog10         ; normalized (regular) number
3721         bra.b   L_119B
3722 L_1197:
3723         cmp.b   #$20,d0         ; zero?
3724         bne.b   L_1198
3725         bsr     t_dz2
3726         bra.b   L_119B
3727 L_1198:
3728         cmp.b   #$40,d0         ; infinity?
3729         bne.b   L_1199
3730         bsr     sopr_inf
3731         bra.b   L_119B
3732 L_1199:
3733         cmp.b   #$60,d0         ; NaN?
3734         bne.b   L_119A
3735         bsr     mon_nan
3736         bra.b   L_119B
3737 L_119A:
3738         bsr     sslog10d                ; assuming a denorm...
3739
3740 L_119B:
3741         fmove.l fpsr,d0         ; update status register
3742         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3743         fmove.l d0,fpsr
3744 *
3745 *       Result is now in FP0
3746 *
3747         movem.l USER_DA(a6),d0-d1/a0-a1
3748         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3749         unlk    a6
3750         rts
3751
3752         xdef    flog10x
3753 flog10x:
3754         link    a6,#-LOCAL_SIZE
3755         movem.l d0-d1/a0-a1,USER_DA(a6)
3756         fmovem.x fp0-fp3,USER_FP0(a6)
3757         fmove.l fpsr,USER_FPSR(a6)
3758         fmove.l fpcr,USER_FPCR(a6)
3759         fmove.l fpcr,d1         ; user's rounding mode/precision
3760         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3761 *
3762 *       copy, convert and tag input argument
3763 *
3764         fmove.x 8(a6),fp0
3765         fmove.x fp0,ETEMP(a6)
3766         lea     ETEMP(a6),a0
3767         bsr     tag
3768         move.b  d0,STAG(a6)
3769         tst.b   d0
3770         bne.b   L_119C
3771         bsr     sslog10         ; normalized (regular) number
3772         bra.b   L_119G
3773 L_119C:
3774         cmp.b   #$20,d0         ; zero?
3775         bne.b   L_119D
3776         bsr     t_dz2
3777         bra.b   L_119G
3778 L_119D:
3779         cmp.b   #$40,d0         ; infinity?
3780         bne.b   L_119E
3781         bsr     sopr_inf
3782         bra.b   L_119G
3783 L_119E:
3784         cmp.b   #$60,d0         ; NaN?
3785         bne.b   L_119F
3786         bsr     mon_nan
3787         bra.b   L_119G
3788 L_119F:
3789         bsr     sslog10d                ; assuming a denorm...
3790
3791 L_119G:
3792         fmove.l fpsr,d0         ; update status register
3793         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3794         fmove.l d0,fpsr
3795 *
3796 *       Result is now in FP0
3797 *
3798         movem.l USER_DA(a6),d0-d1/a0-a1
3799         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3800         unlk    a6
3801         rts
3802
3803 *
3804 *       MONADIC.GEN 1.4 1/16/92
3805 *
3806 *       MONADIC.GEN 1.3 4/30/91
3807 *
3808 *       MONADIC.GEN --- generic MONADIC template
3809 *
3810 *       This version saves all registers that will be used by the emulation
3811 *       routines and restores all but FP0 on exit.  The FPSR is
3812 *       updated to reflect the result of the operation.  Return value
3813 *       is placed in FP0 for single, double and extended results.
3814 *
3815 *       The package subroutines expect the incoming FPCR to be zeroed
3816 *       since they need extended precision to work properly.  The
3817 *       'final' FPCR is expected in d1 so that the calculated result
3818 *       can be properly sized and rounded.  Also, if the incoming FPCR
3819 *       has enabled any exceptions, the exception will be taken on the
3820 *       final fmovem in this template.
3821 *
3822 *       Customizations:
3823 *               1. Remove the movem.l at the entry and exit of
3824 *                  each routine if your compiler treats those
3825 *                  registers as scratch.
3826 *               2. Likewise, don't save FP0/FP1 if they are scratch
3827 *                  registers.
3828 *               3. Delete handling of the fpsr if you only care about
3829 *                  the result.
3830 *               4. Some (most?) C compilers convert all float arguments
3831 *                  to double, and provide no support at all for extended
3832 *                  precision so remove the flognp1s and flognp1x entry points.
3833 *               5. Move the result to d0/d1 if the compiler is that old.
3834
3835 *               Copyright (C) Motorola, Inc. 1991
3836 *                       All Rights Reserved
3837 *
3838 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
3839 *       The copyright notice above does not evidence any
3840 *       actual or intended publication of such source code.
3841
3842         xref    tag
3843         xref    sslognp1
3844         xref    szero
3845         xref    sopr_inf
3846         xref    mon_nan
3847         xref    slognp1d
3848
3849         xdef    flognp1s
3850 flognp1s:
3851         link    a6,#-LOCAL_SIZE
3852         movem.l d0-d1/a0-a1,USER_DA(a6)
3853         fmovem.x fp0-fp3,USER_FP0(a6)
3854         fmove.l fpsr,USER_FPSR(a6)
3855         fmove.l fpcr,USER_FPCR(a6)
3856         fmove.l fpcr,d1         ; user's rounding mode/precision
3857         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3858 *
3859 *       copy, convert and tag input argument
3860 *
3861         fmove.s 8(a6),fp0
3862         fmove.x fp0,ETEMP(a6)
3863         lea     ETEMP(a6),a0
3864         bsr     tag
3865         move.b  d0,STAG(a6)
3866         tst.b   d0
3867         bne.b   L_1202
3868         bsr     sslognp1                ; normalized (regular) number
3869         bra.b   L_1206
3870 L_1202:
3871         cmp.b   #$20,d0         ; zero?
3872         bne.b   L_1203
3873         bsr     szero
3874         bra.b   L_1206
3875 L_1203:
3876         cmp.b   #$40,d0         ; infinity?
3877         bne.b   L_1204
3878         bsr     sopr_inf
3879         bra.b   L_1206
3880 L_1204:
3881         cmp.b   #$60,d0         ; NaN?
3882         bne.b   L_1205
3883         bsr     mon_nan
3884         bra.b   L_1206
3885 L_1205:
3886         bsr     slognp1d                ; assuming a denorm...
3887
3888 L_1206:
3889         fmove.l fpsr,d0         ; update status register
3890         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3891         fmove.l d0,fpsr
3892 *
3893 *       Result is now in FP0
3894 *
3895         movem.l USER_DA(a6),d0-d1/a0-a1
3896         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3897         unlk    a6
3898         rts
3899
3900         xdef    flognp1d
3901 flognp1d:
3902         link    a6,#-LOCAL_SIZE
3903         movem.l d0-d1/a0-a1,USER_DA(a6)
3904         fmovem.x fp0-fp3,USER_FP0(a6)
3905         fmove.l fpsr,USER_FPSR(a6)
3906         fmove.l fpcr,USER_FPCR(a6)
3907         fmove.l fpcr,d1         ; user's rounding mode/precision
3908         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3909 *
3910 *       copy, convert and tag input argument
3911 *
3912         fmove.d 8(a6),fp0
3913         fmove.x fp0,ETEMP(a6)
3914         lea     ETEMP(a6),a0
3915         bsr     tag
3916         move.b  d0,STAG(a6)
3917         tst.b   d0
3918         bne.b   L_1207
3919         bsr     sslognp1                ; normalized (regular) number
3920         bra.b   L_120B
3921 L_1207:
3922         cmp.b   #$20,d0         ; zero?
3923         bne.b   L_1208
3924         bsr     szero
3925         bra.b   L_120B
3926 L_1208:
3927         cmp.b   #$40,d0         ; infinity?
3928         bne.b   L_1209
3929         bsr     sopr_inf
3930         bra.b   L_120B
3931 L_1209:
3932         cmp.b   #$60,d0         ; NaN?
3933         bne.b   L_120A
3934         bsr     mon_nan
3935         bra.b   L_120B
3936 L_120A:
3937         bsr     slognp1d                ; assuming a denorm...
3938
3939 L_120B:
3940         fmove.l fpsr,d0         ; update status register
3941         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3942         fmove.l d0,fpsr
3943 *
3944 *       Result is now in FP0
3945 *
3946         movem.l USER_DA(a6),d0-d1/a0-a1
3947         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3948         unlk    a6
3949         rts
3950
3951         xdef    flognp1x
3952 flognp1x:
3953         link    a6,#-LOCAL_SIZE
3954         movem.l d0-d1/a0-a1,USER_DA(a6)
3955         fmovem.x fp0-fp3,USER_FP0(a6)
3956         fmove.l fpsr,USER_FPSR(a6)
3957         fmove.l fpcr,USER_FPCR(a6)
3958         fmove.l fpcr,d1         ; user's rounding mode/precision
3959         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
3960 *
3961 *       copy, convert and tag input argument
3962 *
3963         fmove.x 8(a6),fp0
3964         fmove.x fp0,ETEMP(a6)
3965         lea     ETEMP(a6),a0
3966         bsr     tag
3967         move.b  d0,STAG(a6)
3968         tst.b   d0
3969         bne.b   L_120C
3970         bsr     sslognp1                ; normalized (regular) number
3971         bra.b   L_120G
3972 L_120C:
3973         cmp.b   #$20,d0         ; zero?
3974         bne.b   L_120D
3975         bsr     szero
3976         bra.b   L_120G
3977 L_120D:
3978         cmp.b   #$40,d0         ; infinity?
3979         bne.b   L_120E
3980         bsr     sopr_inf
3981         bra.b   L_120G
3982 L_120E:
3983         cmp.b   #$60,d0         ; NaN?
3984         bne.b   L_120F
3985         bsr     mon_nan
3986         bra.b   L_120G
3987 L_120F:
3988         bsr     slognp1d                ; assuming a denorm...
3989
3990 L_120G:
3991         fmove.l fpsr,d0         ; update status register
3992         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
3993         fmove.l d0,fpsr
3994 *
3995 *       Result is now in FP0
3996 *
3997         movem.l USER_DA(a6),d0-d1/a0-a1
3998         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
3999         unlk    a6
4000         rts
4001
4002 *
4003 *       MONADIC.GEN 1.4 1/16/92
4004 *
4005 *       MONADIC.GEN 1.3 4/30/91
4006 *
4007 *       MONADIC.GEN --- generic MONADIC template
4008 *
4009 *       This version saves all registers that will be used by the emulation
4010 *       routines and restores all but FP0 on exit.  The FPSR is
4011 *       updated to reflect the result of the operation.  Return value
4012 *       is placed in FP0 for single, double and extended results.
4013 *
4014 *       The package subroutines expect the incoming FPCR to be zeroed
4015 *       since they need extended precision to work properly.  The
4016 *       'final' FPCR is expected in d1 so that the calculated result
4017 *       can be properly sized and rounded.  Also, if the incoming FPCR
4018 *       has enabled any exceptions, the exception will be taken on the
4019 *       final fmovem in this template.
4020 *
4021 *       Customizations:
4022 *               1. Remove the movem.l at the entry and exit of
4023 *                  each routine if your compiler treats those
4024 *                  registers as scratch.
4025 *               2. Likewise, don't save FP0/FP1 if they are scratch
4026 *                  registers.
4027 *               3. Delete handling of the fpsr if you only care about
4028 *                  the result.
4029 *               4. Some (most?) C compilers convert all float arguments
4030 *                  to double, and provide no support at all for extended
4031 *                  precision so remove the fints and fintx entry points.
4032 *               5. Move the result to d0/d1 if the compiler is that old.
4033
4034 *               Copyright (C) Motorola, Inc. 1991
4035 *                       All Rights Reserved
4036 *
4037 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
4038 *       The copyright notice above does not evidence any
4039 *       actual or intended publication of such source code.
4040
4041         xref    tag
4042         xref    l_sint
4043         xref    szero
4044         xref    sinf
4045         xref    mon_nan
4046         xref    l_sintd
4047
4048         xdef    fints
4049 fints:
4050         link    a6,#-LOCAL_SIZE
4051         movem.l d0-d1/a0-a1,USER_DA(a6)
4052         fmovem.x fp0-fp3,USER_FP0(a6)
4053         fmove.l fpsr,USER_FPSR(a6)
4054         fmove.l fpcr,USER_FPCR(a6)
4055         fmove.l fpcr,d1         ; user's rounding mode/precision
4056         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4057 *
4058 *       copy, convert and tag input argument
4059 *
4060         fmove.s 8(a6),fp0
4061         fmove.x fp0,ETEMP(a6)
4062         lea     ETEMP(a6),a0
4063         bsr     tag
4064         move.b  d0,STAG(a6)
4065         tst.b   d0
4066         bne.b   L_1212
4067         bsr     l_sint          ; normalized (regular) number
4068         bra.b   L_1216
4069 L_1212:
4070         cmp.b   #$20,d0         ; zero?
4071         bne.b   L_1213
4072         bsr     szero
4073         bra.b   L_1216
4074 L_1213:
4075         cmp.b   #$40,d0         ; infinity?
4076         bne.b   L_1214
4077         bsr     sinf
4078         bra.b   L_1216
4079 L_1214:
4080         cmp.b   #$60,d0         ; NaN?
4081         bne.b   L_1215
4082         bsr     mon_nan
4083         bra.b   L_1216
4084 L_1215:
4085         bsr     l_sintd         ; assuming a denorm...
4086
4087 L_1216:
4088         fmove.l fpsr,d0         ; update status register
4089         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4090         fmove.l d0,fpsr
4091 *
4092 *       Result is now in FP0
4093 *
4094         movem.l USER_DA(a6),d0-d1/a0-a1
4095         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4096         unlk    a6
4097         rts
4098
4099         xdef    fintd
4100 fintd:
4101         link    a6,#-LOCAL_SIZE
4102         movem.l d0-d1/a0-a1,USER_DA(a6)
4103         fmovem.x fp0-fp3,USER_FP0(a6)
4104         fmove.l fpsr,USER_FPSR(a6)
4105         fmove.l fpcr,USER_FPCR(a6)
4106         fmove.l fpcr,d1         ; user's rounding mode/precision
4107         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4108 *
4109 *       copy, convert and tag input argument
4110 *
4111         fmove.d 8(a6),fp0
4112         fmove.x fp0,ETEMP(a6)
4113         lea     ETEMP(a6),a0
4114         bsr     tag
4115         move.b  d0,STAG(a6)
4116         tst.b   d0
4117         bne.b   L_1217
4118         bsr     l_sint          ; normalized (regular) number
4119         bra.b   L_121B
4120 L_1217:
4121         cmp.b   #$20,d0         ; zero?
4122         bne.b   L_1218
4123         bsr     szero
4124         bra.b   L_121B
4125 L_1218:
4126         cmp.b   #$40,d0         ; infinity?
4127         bne.b   L_1219
4128         bsr     sinf
4129         bra.b   L_121B
4130 L_1219:
4131         cmp.b   #$60,d0         ; NaN?
4132         bne.b   L_121A
4133         bsr     mon_nan
4134         bra.b   L_121B
4135 L_121A:
4136         bsr     l_sintd         ; assuming a denorm...
4137
4138 L_121B:
4139         fmove.l fpsr,d0         ; update status register
4140         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4141         fmove.l d0,fpsr
4142 *
4143 *       Result is now in FP0
4144 *
4145         movem.l USER_DA(a6),d0-d1/a0-a1
4146         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4147         unlk    a6
4148         rts
4149
4150         xdef    fintx
4151 fintx:
4152         link    a6,#-LOCAL_SIZE
4153         movem.l d0-d1/a0-a1,USER_DA(a6)
4154         fmovem.x fp0-fp3,USER_FP0(a6)
4155         fmove.l fpsr,USER_FPSR(a6)
4156         fmove.l fpcr,USER_FPCR(a6)
4157         fmove.l fpcr,d1         ; user's rounding mode/precision
4158         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4159 *
4160 *       copy, convert and tag input argument
4161 *
4162         fmove.x 8(a6),fp0
4163         fmove.x fp0,ETEMP(a6)
4164         lea     ETEMP(a6),a0
4165         bsr     tag
4166         move.b  d0,STAG(a6)
4167         tst.b   d0
4168         bne.b   L_121C
4169         bsr     l_sint          ; normalized (regular) number
4170         bra.b   L_121G
4171 L_121C:
4172         cmp.b   #$20,d0         ; zero?
4173         bne.b   L_121D
4174         bsr     szero
4175         bra.b   L_121G
4176 L_121D:
4177         cmp.b   #$40,d0         ; infinity?
4178         bne.b   L_121E
4179         bsr     sinf
4180         bra.b   L_121G
4181 L_121E:
4182         cmp.b   #$60,d0         ; NaN?
4183         bne.b   L_121F
4184         bsr     mon_nan
4185         bra.b   L_121G
4186 L_121F:
4187         bsr     l_sintd         ; assuming a denorm...
4188
4189 L_121G:
4190         fmove.l fpsr,d0         ; update status register
4191         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4192         fmove.l d0,fpsr
4193 *
4194 *       Result is now in FP0
4195 *
4196         movem.l USER_DA(a6),d0-d1/a0-a1
4197         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4198         unlk    a6
4199         rts
4200
4201 *
4202 *       MONADIC.GEN 1.4 1/16/92
4203 *
4204 *       MONADIC.GEN 1.3 4/30/91
4205 *
4206 *       MONADIC.GEN --- generic MONADIC template
4207 *
4208 *       This version saves all registers that will be used by the emulation
4209 *       routines and restores all but FP0 on exit.  The FPSR is
4210 *       updated to reflect the result of the operation.  Return value
4211 *       is placed in FP0 for single, double and extended results.
4212 *
4213 *       The package subroutines expect the incoming FPCR to be zeroed
4214 *       since they need extended precision to work properly.  The
4215 *       'final' FPCR is expected in d1 so that the calculated result
4216 *       can be properly sized and rounded.  Also, if the incoming FPCR
4217 *       has enabled any exceptions, the exception will be taken on the
4218 *       final fmovem in this template.
4219 *
4220 *       Customizations:
4221 *               1. Remove the movem.l at the entry and exit of
4222 *                  each routine if your compiler treats those
4223 *                  registers as scratch.
4224 *               2. Likewise, don't save FP0/FP1 if they are scratch
4225 *                  registers.
4226 *               3. Delete handling of the fpsr if you only care about
4227 *                  the result.
4228 *               4. Some (most?) C compilers convert all float arguments
4229 *                  to double, and provide no support at all for extended
4230 *                  precision so remove the fintrzs and fintrzx entry points.
4231 *               5. Move the result to d0/d1 if the compiler is that old.
4232
4233 *               Copyright (C) Motorola, Inc. 1991
4234 *                       All Rights Reserved
4235 *
4236 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
4237 *       The copyright notice above does not evidence any
4238 *       actual or intended publication of such source code.
4239
4240         xref    tag
4241         xref    l_sintrz
4242         xref    szero
4243         xref    sinf
4244         xref    mon_nan
4245         xref    snzrinx
4246
4247         xdef    fintrzs
4248 fintrzs:
4249         link    a6,#-LOCAL_SIZE
4250         movem.l d0-d1/a0-a1,USER_DA(a6)
4251         fmovem.x fp0-fp3,USER_FP0(a6)
4252         fmove.l fpsr,USER_FPSR(a6)
4253         fmove.l fpcr,USER_FPCR(a6)
4254         fmove.l fpcr,d1         ; user's rounding mode/precision
4255         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4256 *
4257 *       copy, convert and tag input argument
4258 *
4259         fmove.s 8(a6),fp0
4260         fmove.x fp0,ETEMP(a6)
4261         lea     ETEMP(a6),a0
4262         bsr     tag
4263         move.b  d0,STAG(a6)
4264         tst.b   d0
4265         bne.b   L_1222
4266         bsr     l_sintrz                ; normalized (regular) number
4267         bra.b   L_1226
4268 L_1222:
4269         cmp.b   #$20,d0         ; zero?
4270         bne.b   L_1223
4271         bsr     szero
4272         bra.b   L_1226
4273 L_1223:
4274         cmp.b   #$40,d0         ; infinity?
4275         bne.b   L_1224
4276         bsr     sinf
4277         bra.b   L_1226
4278 L_1224:
4279         cmp.b   #$60,d0         ; NaN?
4280         bne.b   L_1225
4281         bsr     mon_nan
4282         bra.b   L_1226
4283 L_1225:
4284         bsr     snzrinx         ; assuming a denorm...
4285
4286 L_1226:
4287         fmove.l fpsr,d0         ; update status register
4288         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4289         fmove.l d0,fpsr
4290 *
4291 *       Result is now in FP0
4292 *
4293         movem.l USER_DA(a6),d0-d1/a0-a1
4294         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4295         unlk    a6
4296         rts
4297
4298         xdef    fintrzd
4299 fintrzd:
4300         link    a6,#-LOCAL_SIZE
4301         movem.l d0-d1/a0-a1,USER_DA(a6)
4302         fmovem.x fp0-fp3,USER_FP0(a6)
4303         fmove.l fpsr,USER_FPSR(a6)
4304         fmove.l fpcr,USER_FPCR(a6)
4305         fmove.l fpcr,d1         ; user's rounding mode/precision
4306         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4307 *
4308 *       copy, convert and tag input argument
4309 *
4310         fmove.d 8(a6),fp0
4311         fmove.x fp0,ETEMP(a6)
4312         lea     ETEMP(a6),a0
4313         bsr     tag
4314         move.b  d0,STAG(a6)
4315         tst.b   d0
4316         bne.b   L_1227
4317         bsr     l_sintrz                ; normalized (regular) number
4318         bra.b   L_122B
4319 L_1227:
4320         cmp.b   #$20,d0         ; zero?
4321         bne.b   L_1228
4322         bsr     szero
4323         bra.b   L_122B
4324 L_1228:
4325         cmp.b   #$40,d0         ; infinity?
4326         bne.b   L_1229
4327         bsr     sinf
4328         bra.b   L_122B
4329 L_1229:
4330         cmp.b   #$60,d0         ; NaN?
4331         bne.b   L_122A
4332         bsr     mon_nan
4333         bra.b   L_122B
4334 L_122A:
4335         bsr     snzrinx         ; assuming a denorm...
4336
4337 L_122B:
4338         fmove.l fpsr,d0         ; update status register
4339         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4340         fmove.l d0,fpsr
4341 *
4342 *       Result is now in FP0
4343 *
4344         movem.l USER_DA(a6),d0-d1/a0-a1
4345         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4346         unlk    a6
4347         rts
4348
4349         xdef    fintrzx
4350 fintrzx:
4351         link    a6,#-LOCAL_SIZE
4352         movem.l d0-d1/a0-a1,USER_DA(a6)
4353         fmovem.x fp0-fp3,USER_FP0(a6)
4354         fmove.l fpsr,USER_FPSR(a6)
4355         fmove.l fpcr,USER_FPCR(a6)
4356         fmove.l fpcr,d1         ; user's rounding mode/precision
4357         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4358 *
4359 *       copy, convert and tag input argument
4360 *
4361         fmove.x 8(a6),fp0
4362         fmove.x fp0,ETEMP(a6)
4363         lea     ETEMP(a6),a0
4364         bsr     tag
4365         move.b  d0,STAG(a6)
4366         tst.b   d0
4367         bne.b   L_122C
4368         bsr     l_sintrz                ; normalized (regular) number
4369         bra.b   L_122G
4370 L_122C:
4371         cmp.b   #$20,d0         ; zero?
4372         bne.b   L_122D
4373         bsr     szero
4374         bra.b   L_122G
4375 L_122D:
4376         cmp.b   #$40,d0         ; infinity?
4377         bne.b   L_122E
4378         bsr     sinf
4379         bra.b   L_122G
4380 L_122E:
4381         cmp.b   #$60,d0         ; NaN?
4382         bne.b   L_122F
4383         bsr     mon_nan
4384         bra.b   L_122G
4385 L_122F:
4386         bsr     snzrinx         ; assuming a denorm...
4387
4388 L_122G:
4389         fmove.l fpsr,d0         ; update status register
4390         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4391         fmove.l d0,fpsr
4392 *
4393 *       Result is now in FP0
4394 *
4395         movem.l USER_DA(a6),d0-d1/a0-a1
4396         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4397         unlk    a6
4398         rts
4399
4400 *
4401 *       DYADIC.GEN 1.2 4/30/91
4402 *
4403 *       DYADIC.GEN --- generic DYADIC template
4404 *
4405 *       This version saves all registers that will be used by the emulation
4406 *       routines and restores all but FP0 on exit.  The FPSR is
4407 *       updated to reflect the result of the operation.  Return value
4408 *       is placed in FP0 for single, double and extended results.
4409 *
4410 *       The package subroutines expect the incoming FPCR to be zeroed
4411 *       since they need extended precision to work properly.  The
4412 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
4413 *       can be properly sized and rounded.  Also, if the incoming FPCR
4414 *       has enabled any exceptions, the exception will be taken on the
4415 *       final fmovem in this template.
4416 *
4417 *       Customizations:
4418 *               1. Remove the movem.l at the entry and exit of
4419 *                  each routine if your compiler treats those
4420 *                  registers as scratch.
4421 *               2. Likewise, don't save FP0/FP1 if they are scratch
4422 *                  registers.
4423 *               3. Delete updating of the fpsr if you only care about
4424 *                  the result.
4425 *               4. Remove the frems and fremx entry points if your compiler
4426 *                  treats everything as doubles.
4427 *               5. Move the result to d0/d1 if the compiler is that old.
4428 *
4429
4430 *               Copyright (C) Motorola, Inc. 1991
4431 *                       All Rights Reserved
4432 *
4433 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
4434 *       The copyright notice above does not evidence any
4435 *       actual or intended publication of such source code.
4436
4437         xref    prem
4438         xref    tag
4439
4440         xdef    frems
4441 frems:
4442         link    a6,#-LOCAL_SIZE
4443         movem.l d0-d1/a0-a1,USER_DA(a6)
4444         fmovem.x fp0-fp3,USER_FP0(a6)
4445         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4446         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4447 *
4448 *       copy, convert and tag input arguments
4449 *
4450         fmove.s 8(a6),fp0
4451         fmove.x fp0,FPTEMP(a6)
4452         lea     FPTEMP(a6),a0
4453         bsr     tag
4454         move.b  d0,DTAG(a6)
4455
4456         fmove.s 12(a6),fp0
4457         fmove.x fp0,ETEMP(a6)
4458         lea     ETEMP(a6),a0
4459         bsr     tag
4460         move.b  d0,STAG(a6)
4461
4462         bsr     prem
4463
4464         fmove.l fpsr,d0         ; update status register
4465         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4466         swap.w  d0
4467         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4468         swap.w  d0
4469         fmove.l d0,fpsr
4470 *
4471 *       Result is now in FP0
4472 *
4473         movem.l USER_DA(a6),d0-d1/a0-a1
4474         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4475         unlk    a6
4476         rts
4477
4478         xdef    fremd
4479 fremd:
4480         link    a6,#-LOCAL_SIZE
4481         movem.l d0-d1/a0-a1,USER_DA(a6)
4482         fmovem.x fp0-fp3,USER_FP0(a6)
4483         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4484         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4485 *
4486 *       copy, convert and tag input arguments
4487 *
4488         fmove.d 8(a6),fp0
4489         fmove.x fp0,FPTEMP(a6)
4490         lea     FPTEMP(a6),a0
4491         bsr     tag
4492         move.b  d0,DTAG(a6)
4493
4494         fmove.d 16(a6),fp0
4495         fmove.x fp0,ETEMP(a6)
4496         lea     ETEMP(a6),a0
4497         bsr     tag
4498         move.b  d0,STAG(a6)
4499
4500         bsr     prem
4501
4502         fmove.l fpsr,d0         ; update status register
4503         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4504         swap.w  d0
4505         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4506         swap.w  d0
4507         fmove.l d0,fpsr
4508 *
4509 *       Result is now in FP0
4510 *
4511         movem.l USER_DA(a6),d0-d1/a0-a1
4512         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4513         unlk    a6
4514         rts
4515
4516         xdef    fremx
4517 fremx:
4518         link    a6,#-LOCAL_SIZE
4519         movem.l d0-d1/a0-a1,USER_DA(a6)
4520         fmovem.x fp0-fp3,USER_FP0(a6)
4521         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4522         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4523 *
4524 *       copy, convert and tag input arguments
4525 *
4526         fmove.x 8(a6),fp0
4527         fmove.x fp0,FPTEMP(a6)
4528         lea     FPTEMP(a6),a0
4529         bsr     tag
4530         move.b  d0,DTAG(a6)
4531
4532         fmove.x 20(a6),fp0
4533         fmove.x fp0,ETEMP(a6)
4534         lea     ETEMP(a6),a0
4535         bsr     tag
4536         move.b  d0,STAG(a6)
4537
4538         bsr     prem
4539
4540         fmove.l fpsr,d0         ; update status register
4541         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4542         swap.w  d0
4543         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4544         swap.w  d0
4545         fmove.l d0,fpsr
4546 *
4547 *       Result is now in FP0
4548 *
4549         movem.l USER_DA(a6),d0-d1/a0-a1
4550         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4551         unlk    a6
4552         rts
4553
4554 *
4555 *       DYADIC.GEN 1.2 4/30/91
4556 *
4557 *       DYADIC.GEN --- generic DYADIC template
4558 *
4559 *       This version saves all registers that will be used by the emulation
4560 *       routines and restores all but FP0 on exit.  The FPSR is
4561 *       updated to reflect the result of the operation.  Return value
4562 *       is placed in FP0 for single, double and extended results.
4563 *
4564 *       The package subroutines expect the incoming FPCR to be zeroed
4565 *       since they need extended precision to work properly.  The
4566 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
4567 *       can be properly sized and rounded.  Also, if the incoming FPCR
4568 *       has enabled any exceptions, the exception will be taken on the
4569 *       final fmovem in this template.
4570 *
4571 *       Customizations:
4572 *               1. Remove the movem.l at the entry and exit of
4573 *                  each routine if your compiler treats those
4574 *                  registers as scratch.
4575 *               2. Likewise, don't save FP0/FP1 if they are scratch
4576 *                  registers.
4577 *               3. Delete updating of the fpsr if you only care about
4578 *                  the result.
4579 *               4. Remove the fmods and fmodx entry points if your compiler
4580 *                  treats everything as doubles.
4581 *               5. Move the result to d0/d1 if the compiler is that old.
4582 *
4583
4584 *               Copyright (C) Motorola, Inc. 1991
4585 *                       All Rights Reserved
4586 *
4587 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
4588 *       The copyright notice above does not evidence any
4589 *       actual or intended publication of such source code.
4590
4591         xref    pmod
4592         xref    tag
4593
4594         xdef    fmods
4595 fmods:
4596         link    a6,#-LOCAL_SIZE
4597         movem.l d0-d1/a0-a1,USER_DA(a6)
4598         fmovem.x fp0-fp3,USER_FP0(a6)
4599         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4600         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4601 *
4602 *       copy, convert and tag input arguments
4603 *
4604         fmove.s 8(a6),fp0
4605         fmove.x fp0,FPTEMP(a6)
4606         lea     FPTEMP(a6),a0
4607         bsr     tag
4608         move.b  d0,DTAG(a6)
4609
4610         fmove.s 12(a6),fp0
4611         fmove.x fp0,ETEMP(a6)
4612         lea     ETEMP(a6),a0
4613         bsr     tag
4614         move.b  d0,STAG(a6)
4615
4616         bsr     pmod
4617
4618         fmove.l fpsr,d0         ; update status register
4619         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4620         swap.w  d0
4621         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4622         swap.w  d0
4623         fmove.l d0,fpsr
4624 *
4625 *       Result is now in FP0
4626 *
4627         movem.l USER_DA(a6),d0-d1/a0-a1
4628         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4629         unlk    a6
4630         rts
4631
4632         xdef    fmodd
4633 fmodd:
4634         link    a6,#-LOCAL_SIZE
4635         movem.l d0-d1/a0-a1,USER_DA(a6)
4636         fmovem.x fp0-fp3,USER_FP0(a6)
4637         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4638         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4639 *
4640 *       copy, convert and tag input arguments
4641 *
4642         fmove.d 8(a6),fp0
4643         fmove.x fp0,FPTEMP(a6)
4644         lea     FPTEMP(a6),a0
4645         bsr     tag
4646         move.b  d0,DTAG(a6)
4647
4648         fmove.d 16(a6),fp0
4649         fmove.x fp0,ETEMP(a6)
4650         lea     ETEMP(a6),a0
4651         bsr     tag
4652         move.b  d0,STAG(a6)
4653
4654         bsr     pmod
4655
4656         fmove.l fpsr,d0         ; update status register
4657         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4658         swap.w  d0
4659         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4660         swap.w  d0
4661         fmove.l d0,fpsr
4662 *
4663 *       Result is now in FP0
4664 *
4665         movem.l USER_DA(a6),d0-d1/a0-a1
4666         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4667         unlk    a6
4668         rts
4669
4670         xdef    fmodx
4671 fmodx:
4672         link    a6,#-LOCAL_SIZE
4673         movem.l d0-d1/a0-a1,USER_DA(a6)
4674         fmovem.x fp0-fp3,USER_FP0(a6)
4675         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4676         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4677 *
4678 *       copy, convert and tag input arguments
4679 *
4680         fmove.x 8(a6),fp0
4681         fmove.x fp0,FPTEMP(a6)
4682         lea     FPTEMP(a6),a0
4683         bsr     tag
4684         move.b  d0,DTAG(a6)
4685
4686         fmove.x 20(a6),fp0
4687         fmove.x fp0,ETEMP(a6)
4688         lea     ETEMP(a6),a0
4689         bsr     tag
4690         move.b  d0,STAG(a6)
4691
4692         bsr     pmod
4693
4694         fmove.l fpsr,d0         ; update status register
4695         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4696         swap.w  d0
4697         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4698         swap.w  d0
4699         fmove.l d0,fpsr
4700 *
4701 *       Result is now in FP0
4702 *
4703         movem.l USER_DA(a6),d0-d1/a0-a1
4704         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4705         unlk    a6
4706         rts
4707
4708 *
4709 *       DYADIC.GEN 1.2 4/30/91
4710 *
4711 *       DYADIC.GEN --- generic DYADIC template
4712 *
4713 *       This version saves all registers that will be used by the emulation
4714 *       routines and restores all but FP0 on exit.  The FPSR is
4715 *       updated to reflect the result of the operation.  Return value
4716 *       is placed in FP0 for single, double and extended results.
4717 *
4718 *       The package subroutines expect the incoming FPCR to be zeroed
4719 *       since they need extended precision to work properly.  The
4720 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
4721 *       can be properly sized and rounded.  Also, if the incoming FPCR
4722 *       has enabled any exceptions, the exception will be taken on the
4723 *       final fmovem in this template.
4724 *
4725 *       Customizations:
4726 *               1. Remove the movem.l at the entry and exit of
4727 *                  each routine if your compiler treats those
4728 *                  registers as scratch.
4729 *               2. Likewise, don't save FP0/FP1 if they are scratch
4730 *                  registers.
4731 *               3. Delete updating of the fpsr if you only care about
4732 *                  the result.
4733 *               4. Remove the fscales and fscalex entry points if your compiler
4734 *                  treats everything as doubles.
4735 *               5. Move the result to d0/d1 if the compiler is that old.
4736 *
4737
4738 *               Copyright (C) Motorola, Inc. 1991
4739 *                       All Rights Reserved
4740 *
4741 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
4742 *       The copyright notice above does not evidence any
4743 *       actual or intended publication of such source code.
4744
4745         xref    pscale
4746         xref    tag
4747
4748         xdef    fscales
4749 fscales:
4750         link    a6,#-LOCAL_SIZE
4751         movem.l d0-d1/a0-a1,USER_DA(a6)
4752         fmovem.x fp0-fp3,USER_FP0(a6)
4753         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4754         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4755 *
4756 *       copy, convert and tag input arguments
4757 *
4758         fmove.s 8(a6),fp0
4759         fmove.x fp0,FPTEMP(a6)
4760         lea     FPTEMP(a6),a0
4761         bsr     tag
4762         move.b  d0,DTAG(a6)
4763
4764         fmove.s 12(a6),fp0
4765         fmove.x fp0,ETEMP(a6)
4766         lea     ETEMP(a6),a0
4767         bsr     tag
4768         move.b  d0,STAG(a6)
4769
4770         bsr     pscale
4771
4772         fmove.l fpsr,d0         ; update status register
4773         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4774         swap.w  d0
4775         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4776         swap.w  d0
4777         fmove.l d0,fpsr
4778 *
4779 *       Result is now in FP0
4780 *
4781         movem.l USER_DA(a6),d0-d1/a0-a1
4782         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4783         unlk    a6
4784         rts
4785
4786         xdef    fscaled
4787 fscaled:
4788         link    a6,#-LOCAL_SIZE
4789         movem.l d0-d1/a0-a1,USER_DA(a6)
4790         fmovem.x fp0-fp3,USER_FP0(a6)
4791         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4792         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4793 *
4794 *       copy, convert and tag input arguments
4795 *
4796         fmove.d 8(a6),fp0
4797         fmove.x fp0,FPTEMP(a6)
4798         lea     FPTEMP(a6),a0
4799         bsr     tag
4800         move.b  d0,DTAG(a6)
4801
4802         fmove.d 16(a6),fp0
4803         fmove.x fp0,ETEMP(a6)
4804         lea     ETEMP(a6),a0
4805         bsr     tag
4806         move.b  d0,STAG(a6)
4807
4808         bsr     pscale
4809
4810         fmove.l fpsr,d0         ; update status register
4811         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4812         swap.w  d0
4813         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4814         swap.w  d0
4815         fmove.l d0,fpsr
4816 *
4817 *       Result is now in FP0
4818 *
4819         movem.l USER_DA(a6),d0-d1/a0-a1
4820         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4821         unlk    a6
4822         rts
4823
4824         xdef    fscalex
4825 fscalex:
4826         link    a6,#-LOCAL_SIZE
4827         movem.l d0-d1/a0-a1,USER_DA(a6)
4828         fmovem.x fp0-fp3,USER_FP0(a6)
4829         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
4830         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4831 *
4832 *       copy, convert and tag input arguments
4833 *
4834         fmove.x 8(a6),fp0
4835         fmove.x fp0,FPTEMP(a6)
4836         lea     FPTEMP(a6),a0
4837         bsr     tag
4838         move.b  d0,DTAG(a6)
4839
4840         fmove.x 20(a6),fp0
4841         fmove.x fp0,ETEMP(a6)
4842         lea     ETEMP(a6),a0
4843         bsr     tag
4844         move.b  d0,STAG(a6)
4845
4846         bsr     pscale
4847
4848         fmove.l fpsr,d0         ; update status register
4849         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
4850         swap.w  d0
4851         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
4852         swap.w  d0
4853         fmove.l d0,fpsr
4854 *
4855 *       Result is now in FP0
4856 *
4857         movem.l USER_DA(a6),d0-d1/a0-a1
4858         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4859         unlk    a6
4860         rts
4861
4862 *
4863 *       MONADIC.GEN 1.4 1/16/92
4864 *
4865 *       MONADIC.GEN 1.3 4/30/91
4866 *
4867 *       MONADIC.GEN --- generic MONADIC template
4868 *
4869 *       This version saves all registers that will be used by the emulation
4870 *       routines and restores all but FP0 on exit.  The FPSR is
4871 *       updated to reflect the result of the operation.  Return value
4872 *       is placed in FP0 for single, double and extended results.
4873 *
4874 *       The package subroutines expect the incoming FPCR to be zeroed
4875 *       since they need extended precision to work properly.  The
4876 *       'final' FPCR is expected in d1 so that the calculated result
4877 *       can be properly sized and rounded.  Also, if the incoming FPCR
4878 *       has enabled any exceptions, the exception will be taken on the
4879 *       final fmovem in this template.
4880 *
4881 *       Customizations:
4882 *               1. Remove the movem.l at the entry and exit of
4883 *                  each routine if your compiler treats those
4884 *                  registers as scratch.
4885 *               2. Likewise, don't save FP0/FP1 if they are scratch
4886 *                  registers.
4887 *               3. Delete handling of the fpsr if you only care about
4888 *                  the result.
4889 *               4. Some (most?) C compilers convert all float arguments
4890 *                  to double, and provide no support at all for extended
4891 *                  precision so remove the fabss and fabsx entry points.
4892 *               5. Move the result to d0/d1 if the compiler is that old.
4893
4894 *               Copyright (C) Motorola, Inc. 1991
4895 *                       All Rights Reserved
4896 *
4897 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
4898 *       The copyright notice above does not evidence any
4899 *       actual or intended publication of such source code.
4900
4901         xref    tag
4902         xref    sabs
4903         xref    sabs
4904         xref    sabs
4905         xref    sabs
4906         xref    sabs
4907
4908         xdef    fabss
4909 fabss:
4910         link    a6,#-LOCAL_SIZE
4911         movem.l d0-d1/a0-a1,USER_DA(a6)
4912         fmovem.x fp0-fp3,USER_FP0(a6)
4913         fmove.l fpsr,USER_FPSR(a6)
4914         fmove.l fpcr,USER_FPCR(a6)
4915         fmove.l fpcr,d1         ; user's rounding mode/precision
4916         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4917 *
4918 *       copy, convert and tag input argument
4919 *
4920         fmove.s 8(a6),fp0
4921         fmove.x fp0,ETEMP(a6)
4922         lea     ETEMP(a6),a0
4923         bsr     tag
4924         move.b  d0,STAG(a6)
4925         tst.b   d0
4926         bne.b   L_1262
4927         bsr     sabs            ; normalized (regular) number
4928         bra.b   L_1266
4929 L_1262:
4930         cmp.b   #$20,d0         ; zero?
4931         bne.b   L_1263
4932         bsr     sabs
4933         bra.b   L_1266
4934 L_1263:
4935         cmp.b   #$40,d0         ; infinity?
4936         bne.b   L_1264
4937         bsr     sabs
4938         bra.b   L_1266
4939 L_1264:
4940         cmp.b   #$60,d0         ; NaN?
4941         bne.b   L_1265
4942         bsr     sabs
4943         bra.b   L_1266
4944 L_1265:
4945         bsr     sabs            ; assuming a denorm...
4946
4947 L_1266:
4948         fmove.l fpsr,d0         ; update status register
4949         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
4950         fmove.l d0,fpsr
4951 *
4952 *       Result is now in FP0
4953 *
4954         movem.l USER_DA(a6),d0-d1/a0-a1
4955         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
4956         unlk    a6
4957         rts
4958
4959         xdef    fabsd
4960 fabsd:
4961         link    a6,#-LOCAL_SIZE
4962         movem.l d0-d1/a0-a1,USER_DA(a6)
4963         fmovem.x fp0-fp3,USER_FP0(a6)
4964         fmove.l fpsr,USER_FPSR(a6)
4965         fmove.l fpcr,USER_FPCR(a6)
4966         fmove.l fpcr,d1         ; user's rounding mode/precision
4967         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
4968 *
4969 *       copy, convert and tag input argument
4970 *
4971         fmove.d 8(a6),fp0
4972         fmove.x fp0,ETEMP(a6)
4973         lea     ETEMP(a6),a0
4974         bsr     tag
4975         move.b  d0,STAG(a6)
4976         tst.b   d0
4977         bne.b   L_1267
4978         bsr     sabs            ; normalized (regular) number
4979         bra.b   L_126B
4980 L_1267:
4981         cmp.b   #$20,d0         ; zero?
4982         bne.b   L_1268
4983         bsr     sabs
4984         bra.b   L_126B
4985 L_1268:
4986         cmp.b   #$40,d0         ; infinity?
4987         bne.b   L_1269
4988         bsr     sabs
4989         bra.b   L_126B
4990 L_1269:
4991         cmp.b   #$60,d0         ; NaN?
4992         bne.b   L_126A
4993         bsr     sabs
4994         bra.b   L_126B
4995 L_126A:
4996         bsr     sabs            ; assuming a denorm...
4997
4998 L_126B:
4999         fmove.l fpsr,d0         ; update status register
5000         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5001         fmove.l d0,fpsr
5002 *
5003 *       Result is now in FP0
5004 *
5005         movem.l USER_DA(a6),d0-d1/a0-a1
5006         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5007         unlk    a6
5008         rts
5009
5010         xdef    fabsx
5011 fabsx:
5012         link    a6,#-LOCAL_SIZE
5013         movem.l d0-d1/a0-a1,USER_DA(a6)
5014         fmovem.x fp0-fp3,USER_FP0(a6)
5015         fmove.l fpsr,USER_FPSR(a6)
5016         fmove.l fpcr,USER_FPCR(a6)
5017         fmove.l fpcr,d1         ; user's rounding mode/precision
5018         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5019 *
5020 *       copy, convert and tag input argument
5021 *
5022         fmove.x 8(a6),fp0
5023         fmove.x fp0,ETEMP(a6)
5024         lea     ETEMP(a6),a0
5025         bsr     tag
5026         move.b  d0,STAG(a6)
5027         tst.b   d0
5028         bne.b   L_126C
5029         bsr     sabs            ; normalized (regular) number
5030         bra.b   L_126G
5031 L_126C:
5032         cmp.b   #$20,d0         ; zero?
5033         bne.b   L_126D
5034         bsr     sabs
5035         bra.b   L_126G
5036 L_126D:
5037         cmp.b   #$40,d0         ; infinity?
5038         bne.b   L_126E
5039         bsr     sabs
5040         bra.b   L_126G
5041 L_126E:
5042         cmp.b   #$60,d0         ; NaN?
5043         bne.b   L_126F
5044         bsr     sabs
5045         bra.b   L_126G
5046 L_126F:
5047         bsr     sabs            ; assuming a denorm...
5048
5049 L_126G:
5050         fmove.l fpsr,d0         ; update status register
5051         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5052         fmove.l d0,fpsr
5053 *
5054 *       Result is now in FP0
5055 *
5056         movem.l USER_DA(a6),d0-d1/a0-a1
5057         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5058         unlk    a6
5059         rts
5060
5061 *
5062 *       MONADIC.GEN 1.4 1/16/92
5063 *
5064 *       MONADIC.GEN 1.3 4/30/91
5065 *
5066 *       MONADIC.GEN --- generic MONADIC template
5067 *
5068 *       This version saves all registers that will be used by the emulation
5069 *       routines and restores all but FP0 on exit.  The FPSR is
5070 *       updated to reflect the result of the operation.  Return value
5071 *       is placed in FP0 for single, double and extended results.
5072 *
5073 *       The package subroutines expect the incoming FPCR to be zeroed
5074 *       since they need extended precision to work properly.  The
5075 *       'final' FPCR is expected in d1 so that the calculated result
5076 *       can be properly sized and rounded.  Also, if the incoming FPCR
5077 *       has enabled any exceptions, the exception will be taken on the
5078 *       final fmovem in this template.
5079 *
5080 *       Customizations:
5081 *               1. Remove the movem.l at the entry and exit of
5082 *                  each routine if your compiler treats those
5083 *                  registers as scratch.
5084 *               2. Likewise, don't save FP0/FP1 if they are scratch
5085 *                  registers.
5086 *               3. Delete handling of the fpsr if you only care about
5087 *                  the result.
5088 *               4. Some (most?) C compilers convert all float arguments
5089 *                  to double, and provide no support at all for extended
5090 *                  precision so remove the fnegs and fnegx entry points.
5091 *               5. Move the result to d0/d1 if the compiler is that old.
5092
5093 *               Copyright (C) Motorola, Inc. 1991
5094 *                       All Rights Reserved
5095 *
5096 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
5097 *       The copyright notice above does not evidence any
5098 *       actual or intended publication of such source code.
5099
5100         xref    tag
5101         xref    sneg
5102         xref    sneg
5103         xref    sneg
5104         xref    sneg
5105         xref    sneg
5106
5107         xdef    fnegs
5108 fnegs:
5109         link    a6,#-LOCAL_SIZE
5110         movem.l d0-d1/a0-a1,USER_DA(a6)
5111         fmovem.x fp0-fp3,USER_FP0(a6)
5112         fmove.l fpsr,USER_FPSR(a6)
5113         fmove.l fpcr,USER_FPCR(a6)
5114         fmove.l fpcr,d1         ; user's rounding mode/precision
5115         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5116 *
5117 *       copy, convert and tag input argument
5118 *
5119         fmove.s 8(a6),fp0
5120         fmove.x fp0,ETEMP(a6)
5121         lea     ETEMP(a6),a0
5122         bsr     tag
5123         move.b  d0,STAG(a6)
5124         tst.b   d0
5125         bne.b   L_1272
5126         bsr     sneg            ; normalized (regular) number
5127         bra.b   L_1276
5128 L_1272:
5129         cmp.b   #$20,d0         ; zero?
5130         bne.b   L_1273
5131         bsr     sneg
5132         bra.b   L_1276
5133 L_1273:
5134         cmp.b   #$40,d0         ; infinity?
5135         bne.b   L_1274
5136         bsr     sneg
5137         bra.b   L_1276
5138 L_1274:
5139         cmp.b   #$60,d0         ; NaN?
5140         bne.b   L_1275
5141         bsr     sneg
5142         bra.b   L_1276
5143 L_1275:
5144         bsr     sneg            ; assuming a denorm...
5145
5146 L_1276:
5147         fmove.l fpsr,d0         ; update status register
5148         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5149         fmove.l d0,fpsr
5150 *
5151 *       Result is now in FP0
5152 *
5153         movem.l USER_DA(a6),d0-d1/a0-a1
5154         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5155         unlk    a6
5156         rts
5157
5158         xdef    fnegd
5159 fnegd:
5160         link    a6,#-LOCAL_SIZE
5161         movem.l d0-d1/a0-a1,USER_DA(a6)
5162         fmovem.x fp0-fp3,USER_FP0(a6)
5163         fmove.l fpsr,USER_FPSR(a6)
5164         fmove.l fpcr,USER_FPCR(a6)
5165         fmove.l fpcr,d1         ; user's rounding mode/precision
5166         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5167 *
5168 *       copy, convert and tag input argument
5169 *
5170         fmove.d 8(a6),fp0
5171         fmove.x fp0,ETEMP(a6)
5172         lea     ETEMP(a6),a0
5173         bsr     tag
5174         move.b  d0,STAG(a6)
5175         tst.b   d0
5176         bne.b   L_1277
5177         bsr     sneg            ; normalized (regular) number
5178         bra.b   L_127B
5179 L_1277:
5180         cmp.b   #$20,d0         ; zero?
5181         bne.b   L_1278
5182         bsr     sneg
5183         bra.b   L_127B
5184 L_1278:
5185         cmp.b   #$40,d0         ; infinity?
5186         bne.b   L_1279
5187         bsr     sneg
5188         bra.b   L_127B
5189 L_1279:
5190         cmp.b   #$60,d0         ; NaN?
5191         bne.b   L_127A
5192         bsr     sneg
5193         bra.b   L_127B
5194 L_127A:
5195         bsr     sneg            ; assuming a denorm...
5196
5197 L_127B:
5198         fmove.l fpsr,d0         ; update status register
5199         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5200         fmove.l d0,fpsr
5201 *
5202 *       Result is now in FP0
5203 *
5204         movem.l USER_DA(a6),d0-d1/a0-a1
5205         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5206         unlk    a6
5207         rts
5208
5209         xdef    fnegx
5210 fnegx:
5211         link    a6,#-LOCAL_SIZE
5212         movem.l d0-d1/a0-a1,USER_DA(a6)
5213         fmovem.x fp0-fp3,USER_FP0(a6)
5214         fmove.l fpsr,USER_FPSR(a6)
5215         fmove.l fpcr,USER_FPCR(a6)
5216         fmove.l fpcr,d1         ; user's rounding mode/precision
5217         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5218 *
5219 *       copy, convert and tag input argument
5220 *
5221         fmove.x 8(a6),fp0
5222         fmove.x fp0,ETEMP(a6)
5223         lea     ETEMP(a6),a0
5224         bsr     tag
5225         move.b  d0,STAG(a6)
5226         tst.b   d0
5227         bne.b   L_127C
5228         bsr     sneg            ; normalized (regular) number
5229         bra.b   L_127G
5230 L_127C:
5231         cmp.b   #$20,d0         ; zero?
5232         bne.b   L_127D
5233         bsr     sneg
5234         bra.b   L_127G
5235 L_127D:
5236         cmp.b   #$40,d0         ; infinity?
5237         bne.b   L_127E
5238         bsr     sneg
5239         bra.b   L_127G
5240 L_127E:
5241         cmp.b   #$60,d0         ; NaN?
5242         bne.b   L_127F
5243         bsr     sneg
5244         bra.b   L_127G
5245 L_127F:
5246         bsr     sneg            ; assuming a denorm...
5247
5248 L_127G:
5249         fmove.l fpsr,d0         ; update status register
5250         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5251         fmove.l d0,fpsr
5252 *
5253 *       Result is now in FP0
5254 *
5255         movem.l USER_DA(a6),d0-d1/a0-a1
5256         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5257         unlk    a6
5258         rts
5259
5260 *
5261 *       MONADIC.GEN 1.4 1/16/92
5262 *
5263 *       MONADIC.GEN 1.3 4/30/91
5264 *
5265 *       MONADIC.GEN --- generic MONADIC template
5266 *
5267 *       This version saves all registers that will be used by the emulation
5268 *       routines and restores all but FP0 on exit.  The FPSR is
5269 *       updated to reflect the result of the operation.  Return value
5270 *       is placed in FP0 for single, double and extended results.
5271 *
5272 *       The package subroutines expect the incoming FPCR to be zeroed
5273 *       since they need extended precision to work properly.  The
5274 *       'final' FPCR is expected in d1 so that the calculated result
5275 *       can be properly sized and rounded.  Also, if the incoming FPCR
5276 *       has enabled any exceptions, the exception will be taken on the
5277 *       final fmovem in this template.
5278 *
5279 *       Customizations:
5280 *               1. Remove the movem.l at the entry and exit of
5281 *                  each routine if your compiler treats those
5282 *                  registers as scratch.
5283 *               2. Likewise, don't save FP0/FP1 if they are scratch
5284 *                  registers.
5285 *               3. Delete handling of the fpsr if you only care about
5286 *                  the result.
5287 *               4. Some (most?) C compilers convert all float arguments
5288 *                  to double, and provide no support at all for extended
5289 *                  precision so remove the fsqrts and fsqrtx entry points.
5290 *               5. Move the result to d0/d1 if the compiler is that old.
5291
5292 *               Copyright (C) Motorola, Inc. 1991
5293 *                       All Rights Reserved
5294 *
5295 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
5296 *       The copyright notice above does not evidence any
5297 *       actual or intended publication of such source code.
5298
5299         xref    tag
5300         xref    ssqrt
5301         xref    ssqrt
5302         xref    ssqrt
5303         xref    ssqrt
5304         xref    ssqrt
5305
5306         xdef    fsqrts
5307 fsqrts:
5308         link    a6,#-LOCAL_SIZE
5309         movem.l d0-d1/a0-a1,USER_DA(a6)
5310         fmovem.x fp0-fp3,USER_FP0(a6)
5311         fmove.l fpsr,USER_FPSR(a6)
5312         fmove.l fpcr,USER_FPCR(a6)
5313         fmove.l fpcr,d1         ; user's rounding mode/precision
5314         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5315 *
5316 *       copy, convert and tag input argument
5317 *
5318         fmove.s 8(a6),fp0
5319         fmove.x fp0,ETEMP(a6)
5320         lea     ETEMP(a6),a0
5321         bsr     tag
5322         move.b  d0,STAG(a6)
5323         tst.b   d0
5324         bne.b   L_1282
5325         bsr     ssqrt           ; normalized (regular) number
5326         bra.b   L_1286
5327 L_1282:
5328         cmp.b   #$20,d0         ; zero?
5329         bne.b   L_1283
5330         bsr     ssqrt
5331         bra.b   L_1286
5332 L_1283:
5333         cmp.b   #$40,d0         ; infinity?
5334         bne.b   L_1284
5335         bsr     ssqrt
5336         bra.b   L_1286
5337 L_1284:
5338         cmp.b   #$60,d0         ; NaN?
5339         bne.b   L_1285
5340         bsr     ssqrt
5341         bra.b   L_1286
5342 L_1285:
5343         bsr     ssqrt           ; assuming a denorm...
5344
5345 L_1286:
5346         fmove.l fpsr,d0         ; update status register
5347         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5348         fmove.l d0,fpsr
5349 *
5350 *       Result is now in FP0
5351 *
5352         movem.l USER_DA(a6),d0-d1/a0-a1
5353         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5354         unlk    a6
5355         rts
5356
5357         xdef    fsqrtd
5358 fsqrtd:
5359         link    a6,#-LOCAL_SIZE
5360         movem.l d0-d1/a0-a1,USER_DA(a6)
5361         fmovem.x fp0-fp3,USER_FP0(a6)
5362         fmove.l fpsr,USER_FPSR(a6)
5363         fmove.l fpcr,USER_FPCR(a6)
5364         fmove.l fpcr,d1         ; user's rounding mode/precision
5365         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5366 *
5367 *       copy, convert and tag input argument
5368 *
5369         fmove.d 8(a6),fp0
5370         fmove.x fp0,ETEMP(a6)
5371         lea     ETEMP(a6),a0
5372         bsr     tag
5373         move.b  d0,STAG(a6)
5374         tst.b   d0
5375         bne.b   L_1287
5376         bsr     ssqrt           ; normalized (regular) number
5377         bra.b   L_128B
5378 L_1287:
5379         cmp.b   #$20,d0         ; zero?
5380         bne.b   L_1288
5381         bsr     ssqrt
5382         bra.b   L_128B
5383 L_1288:
5384         cmp.b   #$40,d0         ; infinity?
5385         bne.b   L_1289
5386         bsr     ssqrt
5387         bra.b   L_128B
5388 L_1289:
5389         cmp.b   #$60,d0         ; NaN?
5390         bne.b   L_128A
5391         bsr     ssqrt
5392         bra.b   L_128B
5393 L_128A:
5394         bsr     ssqrt           ; assuming a denorm...
5395
5396 L_128B:
5397         fmove.l fpsr,d0         ; update status register
5398         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5399         fmove.l d0,fpsr
5400 *
5401 *       Result is now in FP0
5402 *
5403         movem.l USER_DA(a6),d0-d1/a0-a1
5404         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5405         unlk    a6
5406         rts
5407
5408         xdef    fsqrtx
5409 fsqrtx:
5410         link    a6,#-LOCAL_SIZE
5411         movem.l d0-d1/a0-a1,USER_DA(a6)
5412         fmovem.x fp0-fp3,USER_FP0(a6)
5413         fmove.l fpsr,USER_FPSR(a6)
5414         fmove.l fpcr,USER_FPCR(a6)
5415         fmove.l fpcr,d1         ; user's rounding mode/precision
5416         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5417 *
5418 *       copy, convert and tag input argument
5419 *
5420         fmove.x 8(a6),fp0
5421         fmove.x fp0,ETEMP(a6)
5422         lea     ETEMP(a6),a0
5423         bsr     tag
5424         move.b  d0,STAG(a6)
5425         tst.b   d0
5426         bne.b   L_128C
5427         bsr     ssqrt           ; normalized (regular) number
5428         bra.b   L_128G
5429 L_128C:
5430         cmp.b   #$20,d0         ; zero?
5431         bne.b   L_128D
5432         bsr     ssqrt
5433         bra.b   L_128G
5434 L_128D:
5435         cmp.b   #$40,d0         ; infinity?
5436         bne.b   L_128E
5437         bsr     ssqrt
5438         bra.b   L_128G
5439 L_128E:
5440         cmp.b   #$60,d0         ; NaN?
5441         bne.b   L_128F
5442         bsr     ssqrt
5443         bra.b   L_128G
5444 L_128F:
5445         bsr     ssqrt           ; assuming a denorm...
5446
5447 L_128G:
5448         fmove.l fpsr,d0         ; update status register
5449         or.b    USER_FPSR+3(a6),d0      ;add previously accrued exceptions
5450         fmove.l d0,fpsr
5451 *
5452 *       Result is now in FP0
5453 *
5454         movem.l USER_DA(a6),d0-d1/a0-a1
5455         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5456         unlk    a6
5457         rts
5458
5459 *
5460 *       DYADIC.GEN 1.2 4/30/91
5461 *
5462 *       DYADIC.GEN --- generic DYADIC template
5463 *
5464 *       This version saves all registers that will be used by the emulation
5465 *       routines and restores all but FP0 on exit.  The FPSR is
5466 *       updated to reflect the result of the operation.  Return value
5467 *       is placed in FP0 for single, double and extended results.
5468 *
5469 *       The package subroutines expect the incoming FPCR to be zeroed
5470 *       since they need extended precision to work properly.  The
5471 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
5472 *       can be properly sized and rounded.  Also, if the incoming FPCR
5473 *       has enabled any exceptions, the exception will be taken on the
5474 *       final fmovem in this template.
5475 *
5476 *       Customizations:
5477 *               1. Remove the movem.l at the entry and exit of
5478 *                  each routine if your compiler treats those
5479 *                  registers as scratch.
5480 *               2. Likewise, don't save FP0/FP1 if they are scratch
5481 *                  registers.
5482 *               3. Delete updating of the fpsr if you only care about
5483 *                  the result.
5484 *               4. Remove the fadds and faddx entry points if your compiler
5485 *                  treats everything as doubles.
5486 *               5. Move the result to d0/d1 if the compiler is that old.
5487 *
5488
5489 *               Copyright (C) Motorola, Inc. 1991
5490 *                       All Rights Reserved
5491 *
5492 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
5493 *       The copyright notice above does not evidence any
5494 *       actual or intended publication of such source code.
5495
5496         xref    sadd
5497         xref    tag
5498
5499         xdef    fadds
5500 fadds:
5501         link    a6,#-LOCAL_SIZE
5502         movem.l d0-d1/a0-a1,USER_DA(a6)
5503         fmovem.x fp0-fp3,USER_FP0(a6)
5504         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5505         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5506 *
5507 *       copy, convert and tag input arguments
5508 *
5509         fmove.s 8(a6),fp0
5510         fmove.x fp0,FPTEMP(a6)
5511         lea     FPTEMP(a6),a0
5512         bsr     tag
5513         move.b  d0,DTAG(a6)
5514
5515         fmove.s 12(a6),fp0
5516         fmove.x fp0,ETEMP(a6)
5517         lea     ETEMP(a6),a0
5518         bsr     tag
5519         move.b  d0,STAG(a6)
5520
5521         bsr     sadd
5522
5523         fmove.l fpsr,d0         ; update status register
5524         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5525         swap.w  d0
5526         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5527         swap.w  d0
5528         fmove.l d0,fpsr
5529 *
5530 *       Result is now in FP0
5531 *
5532         movem.l USER_DA(a6),d0-d1/a0-a1
5533         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5534         unlk    a6
5535         rts
5536
5537         xdef    faddd
5538 faddd:
5539         link    a6,#-LOCAL_SIZE
5540         movem.l d0-d1/a0-a1,USER_DA(a6)
5541         fmovem.x fp0-fp3,USER_FP0(a6)
5542         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5543         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5544 *
5545 *       copy, convert and tag input arguments
5546 *
5547         fmove.d 8(a6),fp0
5548         fmove.x fp0,FPTEMP(a6)
5549         lea     FPTEMP(a6),a0
5550         bsr     tag
5551         move.b  d0,DTAG(a6)
5552
5553         fmove.d 16(a6),fp0
5554         fmove.x fp0,ETEMP(a6)
5555         lea     ETEMP(a6),a0
5556         bsr     tag
5557         move.b  d0,STAG(a6)
5558
5559         bsr     sadd
5560
5561         fmove.l fpsr,d0         ; update status register
5562         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5563         swap.w  d0
5564         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5565         swap.w  d0
5566         fmove.l d0,fpsr
5567 *
5568 *       Result is now in FP0
5569 *
5570         movem.l USER_DA(a6),d0-d1/a0-a1
5571         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5572         unlk    a6
5573         rts
5574
5575         xdef    faddx
5576 faddx:
5577         link    a6,#-LOCAL_SIZE
5578         movem.l d0-d1/a0-a1,USER_DA(a6)
5579         fmovem.x fp0-fp3,USER_FP0(a6)
5580         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5581         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5582 *
5583 *       copy, convert and tag input arguments
5584 *
5585         fmove.x 8(a6),fp0
5586         fmove.x fp0,FPTEMP(a6)
5587         lea     FPTEMP(a6),a0
5588         bsr     tag
5589         move.b  d0,DTAG(a6)
5590
5591         fmove.x 20(a6),fp0
5592         fmove.x fp0,ETEMP(a6)
5593         lea     ETEMP(a6),a0
5594         bsr     tag
5595         move.b  d0,STAG(a6)
5596
5597         bsr     sadd
5598
5599         fmove.l fpsr,d0         ; update status register
5600         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5601         swap.w  d0
5602         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5603         swap.w  d0
5604         fmove.l d0,fpsr
5605 *
5606 *       Result is now in FP0
5607 *
5608         movem.l USER_DA(a6),d0-d1/a0-a1
5609         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5610         unlk    a6
5611         rts
5612
5613 *
5614 *       DYADIC.GEN 1.2 4/30/91
5615 *
5616 *       DYADIC.GEN --- generic DYADIC template
5617 *
5618 *       This version saves all registers that will be used by the emulation
5619 *       routines and restores all but FP0 on exit.  The FPSR is
5620 *       updated to reflect the result of the operation.  Return value
5621 *       is placed in FP0 for single, double and extended results.
5622 *
5623 *       The package subroutines expect the incoming FPCR to be zeroed
5624 *       since they need extended precision to work properly.  The
5625 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
5626 *       can be properly sized and rounded.  Also, if the incoming FPCR
5627 *       has enabled any exceptions, the exception will be taken on the
5628 *       final fmovem in this template.
5629 *
5630 *       Customizations:
5631 *               1. Remove the movem.l at the entry and exit of
5632 *                  each routine if your compiler treats those
5633 *                  registers as scratch.
5634 *               2. Likewise, don't save FP0/FP1 if they are scratch
5635 *                  registers.
5636 *               3. Delete updating of the fpsr if you only care about
5637 *                  the result.
5638 *               4. Remove the fsubs and fsubx entry points if your compiler
5639 *                  treats everything as doubles.
5640 *               5. Move the result to d0/d1 if the compiler is that old.
5641 *
5642
5643 *               Copyright (C) Motorola, Inc. 1991
5644 *                       All Rights Reserved
5645 *
5646 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
5647 *       The copyright notice above does not evidence any
5648 *       actual or intended publication of such source code.
5649
5650         xref    ssub
5651         xref    tag
5652
5653         xdef    fsubs
5654 fsubs:
5655         link    a6,#-LOCAL_SIZE
5656         movem.l d0-d1/a0-a1,USER_DA(a6)
5657         fmovem.x fp0-fp3,USER_FP0(a6)
5658         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5659         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5660 *
5661 *       copy, convert and tag input arguments
5662 *
5663         fmove.s 8(a6),fp0
5664         fmove.x fp0,FPTEMP(a6)
5665         lea     FPTEMP(a6),a0
5666         bsr     tag
5667         move.b  d0,DTAG(a6)
5668
5669         fmove.s 12(a6),fp0
5670         fmove.x fp0,ETEMP(a6)
5671         lea     ETEMP(a6),a0
5672         bsr     tag
5673         move.b  d0,STAG(a6)
5674
5675         bsr     ssub
5676
5677         fmove.l fpsr,d0         ; update status register
5678         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5679         swap.w  d0
5680         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5681         swap.w  d0
5682         fmove.l d0,fpsr
5683 *
5684 *       Result is now in FP0
5685 *
5686         movem.l USER_DA(a6),d0-d1/a0-a1
5687         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5688         unlk    a6
5689         rts
5690
5691         xdef    fsubd
5692 fsubd:
5693         link    a6,#-LOCAL_SIZE
5694         movem.l d0-d1/a0-a1,USER_DA(a6)
5695         fmovem.x fp0-fp3,USER_FP0(a6)
5696         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5697         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5698 *
5699 *       copy, convert and tag input arguments
5700 *
5701         fmove.d 8(a6),fp0
5702         fmove.x fp0,FPTEMP(a6)
5703         lea     FPTEMP(a6),a0
5704         bsr     tag
5705         move.b  d0,DTAG(a6)
5706
5707         fmove.d 16(a6),fp0
5708         fmove.x fp0,ETEMP(a6)
5709         lea     ETEMP(a6),a0
5710         bsr     tag
5711         move.b  d0,STAG(a6)
5712
5713         bsr     ssub
5714
5715         fmove.l fpsr,d0         ; update status register
5716         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5717         swap.w  d0
5718         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5719         swap.w  d0
5720         fmove.l d0,fpsr
5721 *
5722 *       Result is now in FP0
5723 *
5724         movem.l USER_DA(a6),d0-d1/a0-a1
5725         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5726         unlk    a6
5727         rts
5728
5729         xdef    fsubx
5730 fsubx:
5731         link    a6,#-LOCAL_SIZE
5732         movem.l d0-d1/a0-a1,USER_DA(a6)
5733         fmovem.x fp0-fp3,USER_FP0(a6)
5734         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5735         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5736 *
5737 *       copy, convert and tag input arguments
5738 *
5739         fmove.x 8(a6),fp0
5740         fmove.x fp0,FPTEMP(a6)
5741         lea     FPTEMP(a6),a0
5742         bsr     tag
5743         move.b  d0,DTAG(a6)
5744
5745         fmove.x 20(a6),fp0
5746         fmove.x fp0,ETEMP(a6)
5747         lea     ETEMP(a6),a0
5748         bsr     tag
5749         move.b  d0,STAG(a6)
5750
5751         bsr     ssub
5752
5753         fmove.l fpsr,d0         ; update status register
5754         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5755         swap.w  d0
5756         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5757         swap.w  d0
5758         fmove.l d0,fpsr
5759 *
5760 *       Result is now in FP0
5761 *
5762         movem.l USER_DA(a6),d0-d1/a0-a1
5763         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5764         unlk    a6
5765         rts
5766
5767 *
5768 *       DYADIC.GEN 1.2 4/30/91
5769 *
5770 *       DYADIC.GEN --- generic DYADIC template
5771 *
5772 *       This version saves all registers that will be used by the emulation
5773 *       routines and restores all but FP0 on exit.  The FPSR is
5774 *       updated to reflect the result of the operation.  Return value
5775 *       is placed in FP0 for single, double and extended results.
5776 *
5777 *       The package subroutines expect the incoming FPCR to be zeroed
5778 *       since they need extended precision to work properly.  The
5779 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
5780 *       can be properly sized and rounded.  Also, if the incoming FPCR
5781 *       has enabled any exceptions, the exception will be taken on the
5782 *       final fmovem in this template.
5783 *
5784 *       Customizations:
5785 *               1. Remove the movem.l at the entry and exit of
5786 *                  each routine if your compiler treats those
5787 *                  registers as scratch.
5788 *               2. Likewise, don't save FP0/FP1 if they are scratch
5789 *                  registers.
5790 *               3. Delete updating of the fpsr if you only care about
5791 *                  the result.
5792 *               4. Remove the fmuls and fmulx entry points if your compiler
5793 *                  treats everything as doubles.
5794 *               5. Move the result to d0/d1 if the compiler is that old.
5795 *
5796
5797 *               Copyright (C) Motorola, Inc. 1991
5798 *                       All Rights Reserved
5799 *
5800 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
5801 *       The copyright notice above does not evidence any
5802 *       actual or intended publication of such source code.
5803
5804         xref    smul
5805         xref    tag
5806
5807         xdef    fmuls
5808 fmuls:
5809         link    a6,#-LOCAL_SIZE
5810         movem.l d0-d1/a0-a1,USER_DA(a6)
5811         fmovem.x fp0-fp3,USER_FP0(a6)
5812         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5813         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5814 *
5815 *       copy, convert and tag input arguments
5816 *
5817         fmove.s 8(a6),fp0
5818         fmove.x fp0,FPTEMP(a6)
5819         lea     FPTEMP(a6),a0
5820         bsr     tag
5821         move.b  d0,DTAG(a6)
5822
5823         fmove.s 12(a6),fp0
5824         fmove.x fp0,ETEMP(a6)
5825         lea     ETEMP(a6),a0
5826         bsr     tag
5827         move.b  d0,STAG(a6)
5828
5829         bsr     smul
5830
5831         fmove.l fpsr,d0         ; update status register
5832         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5833         swap.w  d0
5834         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5835         swap.w  d0
5836         fmove.l d0,fpsr
5837 *
5838 *       Result is now in FP0
5839 *
5840         movem.l USER_DA(a6),d0-d1/a0-a1
5841         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5842         unlk    a6
5843         rts
5844
5845         xdef    fmuld
5846 fmuld:
5847         link    a6,#-LOCAL_SIZE
5848         movem.l d0-d1/a0-a1,USER_DA(a6)
5849         fmovem.x fp0-fp3,USER_FP0(a6)
5850         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5851         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5852 *
5853 *       copy, convert and tag input arguments
5854 *
5855         fmove.d 8(a6),fp0
5856         fmove.x fp0,FPTEMP(a6)
5857         lea     FPTEMP(a6),a0
5858         bsr     tag
5859         move.b  d0,DTAG(a6)
5860
5861         fmove.d 16(a6),fp0
5862         fmove.x fp0,ETEMP(a6)
5863         lea     ETEMP(a6),a0
5864         bsr     tag
5865         move.b  d0,STAG(a6)
5866
5867         bsr     smul
5868
5869         fmove.l fpsr,d0         ; update status register
5870         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5871         swap.w  d0
5872         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5873         swap.w  d0
5874         fmove.l d0,fpsr
5875 *
5876 *       Result is now in FP0
5877 *
5878         movem.l USER_DA(a6),d0-d1/a0-a1
5879         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5880         unlk    a6
5881         rts
5882
5883         xdef    fmulx
5884 fmulx:
5885         link    a6,#-LOCAL_SIZE
5886         movem.l d0-d1/a0-a1,USER_DA(a6)
5887         fmovem.x fp0-fp3,USER_FP0(a6)
5888         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5889         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5890 *
5891 *       copy, convert and tag input arguments
5892 *
5893         fmove.x 8(a6),fp0
5894         fmove.x fp0,FPTEMP(a6)
5895         lea     FPTEMP(a6),a0
5896         bsr     tag
5897         move.b  d0,DTAG(a6)
5898
5899         fmove.x 20(a6),fp0
5900         fmove.x fp0,ETEMP(a6)
5901         lea     ETEMP(a6),a0
5902         bsr     tag
5903         move.b  d0,STAG(a6)
5904
5905         bsr     smul
5906
5907         fmove.l fpsr,d0         ; update status register
5908         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5909         swap.w  d0
5910         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5911         swap.w  d0
5912         fmove.l d0,fpsr
5913 *
5914 *       Result is now in FP0
5915 *
5916         movem.l USER_DA(a6),d0-d1/a0-a1
5917         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5918         unlk    a6
5919         rts
5920
5921 *
5922 *       DYADIC.GEN 1.2 4/30/91
5923 *
5924 *       DYADIC.GEN --- generic DYADIC template
5925 *
5926 *       This version saves all registers that will be used by the emulation
5927 *       routines and restores all but FP0 on exit.  The FPSR is
5928 *       updated to reflect the result of the operation.  Return value
5929 *       is placed in FP0 for single, double and extended results.
5930 *
5931 *       The package subroutines expect the incoming FPCR to be zeroed
5932 *       since they need extended precision to work properly.  The
5933 *       'final' FPCR is expected in USER_FPCR(a6) so that the calculated result
5934 *       can be properly sized and rounded.  Also, if the incoming FPCR
5935 *       has enabled any exceptions, the exception will be taken on the
5936 *       final fmovem in this template.
5937 *
5938 *       Customizations:
5939 *               1. Remove the movem.l at the entry and exit of
5940 *                  each routine if your compiler treats those
5941 *                  registers as scratch.
5942 *               2. Likewise, don't save FP0/FP1 if they are scratch
5943 *                  registers.
5944 *               3. Delete updating of the fpsr if you only care about
5945 *                  the result.
5946 *               4. Remove the fdivs and fdivx entry points if your compiler
5947 *                  treats everything as doubles.
5948 *               5. Move the result to d0/d1 if the compiler is that old.
5949 *
5950
5951 *               Copyright (C) Motorola, Inc. 1991
5952 *                       All Rights Reserved
5953 *
5954 *       THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF MOTOROLA
5955 *       The copyright notice above does not evidence any
5956 *       actual or intended publication of such source code.
5957
5958         xref    sdiv
5959         xref    tag
5960
5961         xdef    fdivs
5962 fdivs:
5963         link    a6,#-LOCAL_SIZE
5964         movem.l d0-d1/a0-a1,USER_DA(a6)
5965         fmovem.x fp0-fp3,USER_FP0(a6)
5966         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
5967         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
5968 *
5969 *       copy, convert and tag input arguments
5970 *
5971         fmove.s 8(a6),fp0
5972         fmove.x fp0,FPTEMP(a6)
5973         lea     FPTEMP(a6),a0
5974         bsr     tag
5975         move.b  d0,DTAG(a6)
5976
5977         fmove.s 12(a6),fp0
5978         fmove.x fp0,ETEMP(a6)
5979         lea     ETEMP(a6),a0
5980         bsr     tag
5981         move.b  d0,STAG(a6)
5982
5983         bsr     sdiv
5984
5985         fmove.l fpsr,d0         ; update status register
5986         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
5987         swap.w  d0
5988         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
5989         swap.w  d0
5990         fmove.l d0,fpsr
5991 *
5992 *       Result is now in FP0
5993 *
5994         movem.l USER_DA(a6),d0-d1/a0-a1
5995         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
5996         unlk    a6
5997         rts
5998
5999         xdef    fdivd
6000 fdivd:
6001         link    a6,#-LOCAL_SIZE
6002         movem.l d0-d1/a0-a1,USER_DA(a6)
6003         fmovem.x fp0-fp3,USER_FP0(a6)
6004         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
6005         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
6006 *
6007 *       copy, convert and tag input arguments
6008 *
6009         fmove.d 8(a6),fp0
6010         fmove.x fp0,FPTEMP(a6)
6011         lea     FPTEMP(a6),a0
6012         bsr     tag
6013         move.b  d0,DTAG(a6)
6014
6015         fmove.d 16(a6),fp0
6016         fmove.x fp0,ETEMP(a6)
6017         lea     ETEMP(a6),a0
6018         bsr     tag
6019         move.b  d0,STAG(a6)
6020
6021         bsr     sdiv
6022
6023         fmove.l fpsr,d0         ; update status register
6024         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
6025         swap.w  d0
6026         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
6027         swap.w  d0
6028         fmove.l d0,fpsr
6029 *
6030 *       Result is now in FP0
6031 *
6032         movem.l USER_DA(a6),d0-d1/a0-a1
6033         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
6034         unlk    a6
6035         rts
6036
6037         xdef    fdivx
6038 fdivx:
6039         link    a6,#-LOCAL_SIZE
6040         movem.l d0-d1/a0-a1,USER_DA(a6)
6041         fmovem.x fp0-fp3,USER_FP0(a6)
6042         fmovem.l fpsr/fpcr,USER_FPSR(a6) ; user's rounding mode/precision
6043         fmove.l #0,fpcr         ; force rounding mode/prec to extended,rn
6044 *
6045 *       copy, convert and tag input arguments
6046 *
6047         fmove.x 8(a6),fp0
6048         fmove.x fp0,FPTEMP(a6)
6049         lea     FPTEMP(a6),a0
6050         bsr     tag
6051         move.b  d0,DTAG(a6)
6052
6053         fmove.x 20(a6),fp0
6054         fmove.x fp0,ETEMP(a6)
6055         lea     ETEMP(a6),a0
6056         bsr     tag
6057         move.b  d0,STAG(a6)
6058
6059         bsr     sdiv
6060
6061         fmove.l fpsr,d0         ; update status register
6062         or.b    FPSR_AEXCEPT(a6),d0     ;add previously accrued exceptions
6063         swap.w  d0
6064         or.b    FPSR_QBYTE(a6),d0       ; pickup sign of quotient byte
6065         swap.w  d0
6066         fmove.l d0,fpsr
6067 *
6068 *       Result is now in FP0
6069 *
6070         movem.l USER_DA(a6),d0-d1/a0-a1
6071         fmovem.x USER_FP1(a6),fp1-fp3   ; note: FP0 not restored
6072         unlk    a6
6073         rts
6074
6075         end