git.oblomov.eu Git - linux-2.6/blob - arch/m68k/fpsp040/res_func.S

   1 |
   2 |       res_func.sa 3.9 7/29/91
   3 |
   4 | Normalizes denormalized numbers if necessary and updates the
   5 | stack frame.  The function is then restored back into the
   6 | machine and the 040 completes the operation.  This routine
   7 | is only used by the unsupported data type/format handler.
   8 | (Exception vector 55).
   9 |
  10 | For packed move out (fmove.p fpm,<ea>) the operation is
  11 | completed here; data is packed and moved to user memory.
  12 | The stack is restored to the 040 only in the case of a
  13 | reportable exception in the conversion.
  14 |
  15 |
  16 |               Copyright (C) Motorola, Inc. 1990
  17 |                       All Rights Reserved
  18 |
  19 |       For details on the license for this file, please see the
  20 |       file, README, in this same directory.
  21
  22 RES_FUNC:    |idnt    2,1 | Motorola 040 Floating Point Software Package
  23
  24         |section        8
  25
  26 #include "fpsp.h"
  27
  28 sp_bnds:        .short  0x3f81,0x407e
  29                 .short  0x3f6a,0x0000
  30 dp_bnds:        .short  0x3c01,0x43fe
  31                 .short  0x3bcd,0x0000
  32
  33         |xref   mem_write
  34         |xref   bindec
  35         |xref   get_fline
  36         |xref   round
  37         |xref   denorm
  38         |xref   dest_ext
  39         |xref   dest_dbl
  40         |xref   dest_sgl
  41         |xref   unf_sub
  42         |xref   nrm_set
  43         |xref   dnrm_lp
  44         |xref   ovf_res
  45         |xref   reg_dest
  46         |xref   t_ovfl
  47         |xref   t_unfl
  48
  49         .global res_func
  50         .global p_move
  51
  52 res_func:
  53         clrb    DNRM_FLG(%a6)
  54         clrb    RES_FLG(%a6)
  55         clrb    CU_ONLY(%a6)
  56         tstb    DY_MO_FLG(%a6)
  57         beqs    monadic
  58 dyadic:
  59         btstb   #7,DTAG(%a6)    |if dop = norm=000, zero=001,
  60 |                               ;inf=010 or nan=011
  61         beqs    monadic         |then branch
  62 |                               ;else denorm
  63 | HANDLE DESTINATION DENORM HERE
  64 |                               ;set dtag to norm
  65 |                               ;write the tag & fpte15 to the fstack
  66         leal    FPTEMP(%a6),%a0
  67
  68         bclrb   #sign_bit,LOCAL_EX(%a0)
  69         sne     LOCAL_SGN(%a0)
  70
  71         bsr     nrm_set         |normalize number (exp will go negative)
  72         bclrb   #sign_bit,LOCAL_EX(%a0) |get rid of false sign
  73         bfclr   LOCAL_SGN(%a0){#0:#8}   |change back to IEEE ext format
  74         beqs    dpos
  75         bsetb   #sign_bit,LOCAL_EX(%a0)
  76 dpos:
  77         bfclr   DTAG(%a6){#0:#4}        |set tag to normalized, FPTE15 = 0
  78         bsetb   #4,DTAG(%a6)    |set FPTE15
  79         orb     #0x0f,DNRM_FLG(%a6)
  80 monadic:
  81         leal    ETEMP(%a6),%a0
  82         btstb   #direction_bit,CMDREG1B(%a6)    |check direction
  83         bne     opclass3                        |it is a mv out
  84 |
  85 | At this point, only opclass 0 and 2 possible
  86 |
  87         btstb   #7,STAG(%a6)    |if sop = norm=000, zero=001,
  88 |                               ;inf=010 or nan=011
  89         bne     mon_dnrm        |else denorm
  90         tstb    DY_MO_FLG(%a6)  |all cases of dyadic instructions would
  91         bne     normal          |require normalization of denorm
  92
  93 | At this point:
  94 |       monadic instructions:   fabs  = $18  fneg   = $1a  ftst   = $3a
  95 |                               fmove = $00  fsmove = $40  fdmove = $44
  96 |                               fsqrt = $05* fssqrt = $41  fdsqrt = $45
  97 |                               (*fsqrt reencoded to $05)
  98 |
  99         movew   CMDREG1B(%a6),%d0       |get command register
 100         andil   #0x7f,%d0                       |strip to only command word
 101 |
 102 | At this point, fabs, fneg, fsmove, fdmove, ftst, fsqrt, fssqrt, and
 103 | fdsqrt are possible.
 104 | For cases fabs, fneg, fsmove, and fdmove goto spos (do not normalize)
 105 | For cases fsqrt, fssqrt, and fdsqrt goto nrm_src (do normalize)
 106 |
 107         btstl   #0,%d0
 108         bne     normal                  |weed out fsqrt instructions
 109 |
 110 | cu_norm handles fmove in instructions with normalized inputs.
 111 | The routine round is used to correctly round the input for the
 112 | destination precision and mode.
 113 |
 114 cu_norm:
 115         st      CU_ONLY(%a6)            |set cu-only inst flag
 116         movew   CMDREG1B(%a6),%d0
 117         andib   #0x3b,%d0               |isolate bits to select inst
 118         tstb    %d0
 119         beql    cu_nmove        |if zero, it is an fmove
 120         cmpib   #0x18,%d0
 121         beql    cu_nabs         |if $18, it is fabs
 122         cmpib   #0x1a,%d0
 123         beql    cu_nneg         |if $1a, it is fneg
 124 |
 125 | Inst is ftst.  Check the source operand and set the cc's accordingly.
 126 | No write is done, so simply rts.
 127 |
 128 cu_ntst:
 129         movew   LOCAL_EX(%a0),%d0
 130         bclrl   #15,%d0
 131         sne     LOCAL_SGN(%a0)
 132         beqs    cu_ntpo
 133         orl     #neg_mask,USER_FPSR(%a6) |set N
 134 cu_ntpo:
 135         cmpiw   #0x7fff,%d0     |test for inf/nan
 136         bnes    cu_ntcz
 137         tstl    LOCAL_HI(%a0)
 138         bnes    cu_ntn
 139         tstl    LOCAL_LO(%a0)
 140         bnes    cu_ntn
 141         orl     #inf_mask,USER_FPSR(%a6)
 142         rts
 143 cu_ntn:
 144         orl     #nan_mask,USER_FPSR(%a6)
 145         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
 146 |                                               ;snan handler
 147
 148         rts
 149 cu_ntcz:
 150         tstl    LOCAL_HI(%a0)
 151         bnel    cu_ntsx
 152         tstl    LOCAL_LO(%a0)
 153         bnel    cu_ntsx
 154         orl     #z_mask,USER_FPSR(%a6)
 155 cu_ntsx:
 156         rts
 157 |
 158 | Inst is fabs.  Execute the absolute value function on the input.
 159 | Branch to the fmove code.  If the operand is NaN, do nothing.
 160 |
 161 cu_nabs:
 162         moveb   STAG(%a6),%d0
 163         btstl   #5,%d0                  |test for NaN or zero
 164         bne     wr_etemp                |if either, simply write it
 165         bclrb   #7,LOCAL_EX(%a0)                |do abs
 166         bras    cu_nmove                |fmove code will finish
 167 |
 168 | Inst is fneg.  Execute the negate value function on the input.
 169 | Fall though to the fmove code.  If the operand is NaN, do nothing.
 170 |
 171 cu_nneg:
 172         moveb   STAG(%a6),%d0
 173         btstl   #5,%d0                  |test for NaN or zero
 174         bne     wr_etemp                |if either, simply write it
 175         bchgb   #7,LOCAL_EX(%a0)                |do neg
 176 |
 177 | Inst is fmove.  This code also handles all result writes.
 178 | If bit 2 is set, round is forced to double.  If it is clear,
 179 | and bit 6 is set, round is forced to single.  If both are clear,
 180 | the round precision is found in the fpcr.  If the rounding precision
 181 | is double or single, round the result before the write.
 182 |
 183 cu_nmove:
 184         moveb   STAG(%a6),%d0
 185         andib   #0xe0,%d0                       |isolate stag bits
 186         bne     wr_etemp                |if not norm, simply write it
 187         btstb   #2,CMDREG1B+1(%a6)      |check for rd
 188         bne     cu_nmrd
 189         btstb   #6,CMDREG1B+1(%a6)      |check for rs
 190         bne     cu_nmrs
 191 |
 192 | The move or operation is not with forced precision.  Test for
 193 | nan or inf as the input; if so, simply write it to FPn.  Use the
 194 | FPCR_MODE byte to get rounding on norms and zeros.
 195 |
 196 cu_nmnr:
 197         bfextu  FPCR_MODE(%a6){#0:#2},%d0
 198         tstb    %d0                     |check for extended
 199         beq     cu_wrexn                |if so, just write result
 200         cmpib   #1,%d0                  |check for single
 201         beq     cu_nmrs                 |fall through to double
 202 |
 203 | The move is fdmove or round precision is double.
 204 |
 205 cu_nmrd:
 206         movel   #2,%d0                  |set up the size for denorm
 207         movew   LOCAL_EX(%a0),%d1               |compare exponent to double threshold
 208         andw    #0x7fff,%d1
 209         cmpw    #0x3c01,%d1
 210         bls     cu_nunfl
 211         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |get rmode
 212         orl     #0x00020000,%d1         |or in rprec (double)
 213         clrl    %d0                     |clear g,r,s for round
 214         bclrb   #sign_bit,LOCAL_EX(%a0) |convert to internal format
 215         sne     LOCAL_SGN(%a0)
 216         bsrl    round
 217         bfclr   LOCAL_SGN(%a0){#0:#8}
 218         beqs    cu_nmrdc
 219         bsetb   #sign_bit,LOCAL_EX(%a0)
 220 cu_nmrdc:
 221         movew   LOCAL_EX(%a0),%d1               |check for overflow
 222         andw    #0x7fff,%d1
 223         cmpw    #0x43ff,%d1
 224         bge     cu_novfl                |take care of overflow case
 225         bra     cu_wrexn
 226 |
 227 | The move is fsmove or round precision is single.
 228 |
 229 cu_nmrs:
 230         movel   #1,%d0
 231         movew   LOCAL_EX(%a0),%d1
 232         andw    #0x7fff,%d1
 233         cmpw    #0x3f81,%d1
 234         bls     cu_nunfl
 235         bfextu  FPCR_MODE(%a6){#2:#2},%d1
 236         orl     #0x00010000,%d1
 237         clrl    %d0
 238         bclrb   #sign_bit,LOCAL_EX(%a0)
 239         sne     LOCAL_SGN(%a0)
 240         bsrl    round
 241         bfclr   LOCAL_SGN(%a0){#0:#8}
 242         beqs    cu_nmrsc
 243         bsetb   #sign_bit,LOCAL_EX(%a0)
 244 cu_nmrsc:
 245         movew   LOCAL_EX(%a0),%d1
 246         andw    #0x7FFF,%d1
 247         cmpw    #0x407f,%d1
 248         blt     cu_wrexn
 249 |
 250 | The operand is above precision boundaries.  Use t_ovfl to
 251 | generate the correct value.
 252 |
 253 cu_novfl:
 254         bsr     t_ovfl
 255         bra     cu_wrexn
 256 |
 257 | The operand is below precision boundaries.  Use denorm to
 258 | generate the correct value.
 259 |
 260 cu_nunfl:
 261         bclrb   #sign_bit,LOCAL_EX(%a0)
 262         sne     LOCAL_SGN(%a0)
 263         bsr     denorm
 264         bfclr   LOCAL_SGN(%a0){#0:#8}   |change back to IEEE ext format
 265         beqs    cu_nucont
 266         bsetb   #sign_bit,LOCAL_EX(%a0)
 267 cu_nucont:
 268         bfextu  FPCR_MODE(%a6){#2:#2},%d1
 269         btstb   #2,CMDREG1B+1(%a6)      |check for rd
 270         bne     inst_d
 271         btstb   #6,CMDREG1B+1(%a6)      |check for rs
 272         bne     inst_s
 273         swap    %d1
 274         moveb   FPCR_MODE(%a6),%d1
 275         lsrb    #6,%d1
 276         swap    %d1
 277         bra     inst_sd
 278 inst_d:
 279         orl     #0x00020000,%d1
 280         bra     inst_sd
 281 inst_s:
 282         orl     #0x00010000,%d1
 283 inst_sd:
 284         bclrb   #sign_bit,LOCAL_EX(%a0)
 285         sne     LOCAL_SGN(%a0)
 286         bsrl    round
 287         bfclr   LOCAL_SGN(%a0){#0:#8}
 288         beqs    cu_nuflp
 289         bsetb   #sign_bit,LOCAL_EX(%a0)
 290 cu_nuflp:
 291         btstb   #inex2_bit,FPSR_EXCEPT(%a6)
 292         beqs    cu_nuninx
 293         orl     #aunfl_mask,USER_FPSR(%a6) |if the round was inex, set AUNFL
 294 cu_nuninx:
 295         tstl    LOCAL_HI(%a0)           |test for zero
 296         bnes    cu_nunzro
 297         tstl    LOCAL_LO(%a0)
 298         bnes    cu_nunzro
 299 |
 300 | The mantissa is zero from the denorm loop.  Check sign and rmode
 301 | to see if rounding should have occurred which would leave the lsb.
 302 |
 303         movel   USER_FPCR(%a6),%d0
 304         andil   #0x30,%d0               |isolate rmode
 305         cmpil   #0x20,%d0
 306         blts    cu_nzro
 307         bnes    cu_nrp
 308 cu_nrm:
 309         tstw    LOCAL_EX(%a0)   |if positive, set lsb
 310         bges    cu_nzro
 311         btstb   #7,FPCR_MODE(%a6) |check for double
 312         beqs    cu_nincs
 313         bras    cu_nincd
 314 cu_nrp:
 315         tstw    LOCAL_EX(%a0)   |if positive, set lsb
 316         blts    cu_nzro
 317         btstb   #7,FPCR_MODE(%a6) |check for double
 318         beqs    cu_nincs
 319 cu_nincd:
 320         orl     #0x800,LOCAL_LO(%a0) |inc for double
 321         bra     cu_nunzro
 322 cu_nincs:
 323         orl     #0x100,LOCAL_HI(%a0) |inc for single
 324         bra     cu_nunzro
 325 cu_nzro:
 326         orl     #z_mask,USER_FPSR(%a6)
 327         moveb   STAG(%a6),%d0
 328         andib   #0xe0,%d0
 329         cmpib   #0x40,%d0               |check if input was tagged zero
 330         beqs    cu_numv
 331 cu_nunzro:
 332         orl     #unfl_mask,USER_FPSR(%a6) |set unfl
 333 cu_numv:
 334         movel   (%a0),ETEMP(%a6)
 335         movel   4(%a0),ETEMP_HI(%a6)
 336         movel   8(%a0),ETEMP_LO(%a6)
 337 |
 338 | Write the result to memory, setting the fpsr cc bits.  NaN and Inf
 339 | bypass cu_wrexn.
 340 |
 341 cu_wrexn:
 342         tstw    LOCAL_EX(%a0)           |test for zero
 343         beqs    cu_wrzero
 344         cmpw    #0x8000,LOCAL_EX(%a0)   |test for zero
 345         bnes    cu_wreon
 346 cu_wrzero:
 347         orl     #z_mask,USER_FPSR(%a6)  |set Z bit
 348 cu_wreon:
 349         tstw    LOCAL_EX(%a0)
 350         bpl     wr_etemp
 351         orl     #neg_mask,USER_FPSR(%a6)
 352         bra     wr_etemp
 353
 354 |
 355 | HANDLE SOURCE DENORM HERE
 356 |
 357 |                               ;clear denorm stag to norm
 358 |                               ;write the new tag & ete15 to the fstack
 359 mon_dnrm:
 360 |
 361 | At this point, check for the cases in which normalizing the
 362 | denorm produces incorrect results.
 363 |
 364         tstb    DY_MO_FLG(%a6)  |all cases of dyadic instructions would
 365         bnes    nrm_src         |require normalization of denorm
 366
 367 | At this point:
 368 |       monadic instructions:   fabs  = $18  fneg   = $1a  ftst   = $3a
 369 |                               fmove = $00  fsmove = $40  fdmove = $44
 370 |                               fsqrt = $05* fssqrt = $41  fdsqrt = $45
 371 |                               (*fsqrt reencoded to $05)
 372 |
 373         movew   CMDREG1B(%a6),%d0       |get command register
 374         andil   #0x7f,%d0                       |strip to only command word
 375 |
 376 | At this point, fabs, fneg, fsmove, fdmove, ftst, fsqrt, fssqrt, and
 377 | fdsqrt are possible.
 378 | For cases fabs, fneg, fsmove, and fdmove goto spos (do not normalize)
 379 | For cases fsqrt, fssqrt, and fdsqrt goto nrm_src (do normalize)
 380 |
 381         btstl   #0,%d0
 382         bnes    nrm_src         |weed out fsqrt instructions
 383         st      CU_ONLY(%a6)    |set cu-only inst flag
 384         bra     cu_dnrm         |fmove, fabs, fneg, ftst
 385 |                               ;cases go to cu_dnrm
 386 nrm_src:
 387         bclrb   #sign_bit,LOCAL_EX(%a0)
 388         sne     LOCAL_SGN(%a0)
 389         bsr     nrm_set         |normalize number (exponent will go
 390 |                               ; negative)
 391         bclrb   #sign_bit,LOCAL_EX(%a0) |get rid of false sign
 392
 393         bfclr   LOCAL_SGN(%a0){#0:#8}   |change back to IEEE ext format
 394         beqs    spos
 395         bsetb   #sign_bit,LOCAL_EX(%a0)
 396 spos:
 397         bfclr   STAG(%a6){#0:#4}        |set tag to normalized, FPTE15 = 0
 398         bsetb   #4,STAG(%a6)    |set ETE15
 399         orb     #0xf0,DNRM_FLG(%a6)
 400 normal:
 401         tstb    DNRM_FLG(%a6)   |check if any of the ops were denorms
 402         bne     ck_wrap         |if so, check if it is a potential
 403 |                               ;wrap-around case
 404 fix_stk:
 405         moveb   #0xfe,CU_SAVEPC(%a6)
 406         bclrb   #E1,E_BYTE(%a6)
 407
 408         clrw    NMNEXC(%a6)
 409
 410         st      RES_FLG(%a6)    |indicate that a restore is needed
 411         rts
 412
 413 |
 414 | cu_dnrm handles all cu-only instructions (fmove, fabs, fneg, and
 415 | ftst) completely in software without an frestore to the 040.
 416 |
 417 cu_dnrm:
 418         st      CU_ONLY(%a6)
 419         movew   CMDREG1B(%a6),%d0
 420         andib   #0x3b,%d0               |isolate bits to select inst
 421         tstb    %d0
 422         beql    cu_dmove        |if zero, it is an fmove
 423         cmpib   #0x18,%d0
 424         beql    cu_dabs         |if $18, it is fabs
 425         cmpib   #0x1a,%d0
 426         beql    cu_dneg         |if $1a, it is fneg
 427 |
 428 | Inst is ftst.  Check the source operand and set the cc's accordingly.
 429 | No write is done, so simply rts.
 430 |
 431 cu_dtst:
 432         movew   LOCAL_EX(%a0),%d0
 433         bclrl   #15,%d0
 434         sne     LOCAL_SGN(%a0)
 435         beqs    cu_dtpo
 436         orl     #neg_mask,USER_FPSR(%a6) |set N
 437 cu_dtpo:
 438         cmpiw   #0x7fff,%d0     |test for inf/nan
 439         bnes    cu_dtcz
 440         tstl    LOCAL_HI(%a0)
 441         bnes    cu_dtn
 442         tstl    LOCAL_LO(%a0)
 443         bnes    cu_dtn
 444         orl     #inf_mask,USER_FPSR(%a6)
 445         rts
 446 cu_dtn:
 447         orl     #nan_mask,USER_FPSR(%a6)
 448         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
 449 |                                               ;snan handler
 450         rts
 451 cu_dtcz:
 452         tstl    LOCAL_HI(%a0)
 453         bnel    cu_dtsx
 454         tstl    LOCAL_LO(%a0)
 455         bnel    cu_dtsx
 456         orl     #z_mask,USER_FPSR(%a6)
 457 cu_dtsx:
 458         rts
 459 |
 460 | Inst is fabs.  Execute the absolute value function on the input.
 461 | Branch to the fmove code.
 462 |
 463 cu_dabs:
 464         bclrb   #7,LOCAL_EX(%a0)                |do abs
 465         bras    cu_dmove                |fmove code will finish
 466 |
 467 | Inst is fneg.  Execute the negate value function on the input.
 468 | Fall though to the fmove code.
 469 |
 470 cu_dneg:
 471         bchgb   #7,LOCAL_EX(%a0)                |do neg
 472 |
 473 | Inst is fmove.  This code also handles all result writes.
 474 | If bit 2 is set, round is forced to double.  If it is clear,
 475 | and bit 6 is set, round is forced to single.  If both are clear,
 476 | the round precision is found in the fpcr.  If the rounding precision
 477 | is double or single, the result is zero, and the mode is checked
 478 | to determine if the lsb of the result should be set.
 479 |
 480 cu_dmove:
 481         btstb   #2,CMDREG1B+1(%a6)      |check for rd
 482         bne     cu_dmrd
 483         btstb   #6,CMDREG1B+1(%a6)      |check for rs
 484         bne     cu_dmrs
 485 |
 486 | The move or operation is not with forced precision.  Use the
 487 | FPCR_MODE byte to get rounding.
 488 |
 489 cu_dmnr:
 490         bfextu  FPCR_MODE(%a6){#0:#2},%d0
 491         tstb    %d0                     |check for extended
 492         beq     cu_wrexd                |if so, just write result
 493         cmpib   #1,%d0                  |check for single
 494         beq     cu_dmrs                 |fall through to double
 495 |
 496 | The move is fdmove or round precision is double.  Result is zero.
 497 | Check rmode for rp or rm and set lsb accordingly.
 498 |
 499 cu_dmrd:
 500         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |get rmode
 501         tstw    LOCAL_EX(%a0)           |check sign
 502         blts    cu_dmdn
 503         cmpib   #3,%d1                  |check for rp
 504         bne     cu_dpd                  |load double pos zero
 505         bra     cu_dpdr                 |load double pos zero w/lsb
 506 cu_dmdn:
 507         cmpib   #2,%d1                  |check for rm
 508         bne     cu_dnd                  |load double neg zero
 509         bra     cu_dndr                 |load double neg zero w/lsb
 510 |
 511 | The move is fsmove or round precision is single.  Result is zero.
 512 | Check for rp or rm and set lsb accordingly.
 513 |
 514 cu_dmrs:
 515         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |get rmode
 516         tstw    LOCAL_EX(%a0)           |check sign
 517         blts    cu_dmsn
 518         cmpib   #3,%d1                  |check for rp
 519         bne     cu_spd                  |load single pos zero
 520         bra     cu_spdr                 |load single pos zero w/lsb
 521 cu_dmsn:
 522         cmpib   #2,%d1                  |check for rm
 523         bne     cu_snd                  |load single neg zero
 524         bra     cu_sndr                 |load single neg zero w/lsb
 525 |
 526 | The precision is extended, so the result in etemp is correct.
 527 | Simply set unfl (not inex2 or aunfl) and write the result to
 528 | the correct fp register.
 529 cu_wrexd:
 530         orl     #unfl_mask,USER_FPSR(%a6)
 531         tstw    LOCAL_EX(%a0)
 532         beq     wr_etemp
 533         orl     #neg_mask,USER_FPSR(%a6)
 534         bra     wr_etemp
 535 |
 536 | These routines write +/- zero in double format.  The routines
 537 | cu_dpdr and cu_dndr set the double lsb.
 538 |
 539 cu_dpd:
 540         movel   #0x3c010000,LOCAL_EX(%a0)       |force pos double zero
 541         clrl    LOCAL_HI(%a0)
 542         clrl    LOCAL_LO(%a0)
 543         orl     #z_mask,USER_FPSR(%a6)
 544         orl     #unfinx_mask,USER_FPSR(%a6)
 545         bra     wr_etemp
 546 cu_dpdr:
 547         movel   #0x3c010000,LOCAL_EX(%a0)       |force pos double zero
 548         clrl    LOCAL_HI(%a0)
 549         movel   #0x800,LOCAL_LO(%a0)    |with lsb set
 550         orl     #unfinx_mask,USER_FPSR(%a6)
 551         bra     wr_etemp
 552 cu_dnd:
 553         movel   #0xbc010000,LOCAL_EX(%a0)       |force pos double zero
 554         clrl    LOCAL_HI(%a0)
 555         clrl    LOCAL_LO(%a0)
 556         orl     #z_mask,USER_FPSR(%a6)
 557         orl     #neg_mask,USER_FPSR(%a6)
 558         orl     #unfinx_mask,USER_FPSR(%a6)
 559         bra     wr_etemp
 560 cu_dndr:
 561         movel   #0xbc010000,LOCAL_EX(%a0)       |force pos double zero
 562         clrl    LOCAL_HI(%a0)
 563         movel   #0x800,LOCAL_LO(%a0)    |with lsb set
 564         orl     #neg_mask,USER_FPSR(%a6)
 565         orl     #unfinx_mask,USER_FPSR(%a6)
 566         bra     wr_etemp
 567 |
 568 | These routines write +/- zero in single format.  The routines
 569 | cu_dpdr and cu_dndr set the single lsb.
 570 |
 571 cu_spd:
 572         movel   #0x3f810000,LOCAL_EX(%a0)       |force pos single zero
 573         clrl    LOCAL_HI(%a0)
 574         clrl    LOCAL_LO(%a0)
 575         orl     #z_mask,USER_FPSR(%a6)
 576         orl     #unfinx_mask,USER_FPSR(%a6)
 577         bra     wr_etemp
 578 cu_spdr:
 579         movel   #0x3f810000,LOCAL_EX(%a0)       |force pos single zero
 580         movel   #0x100,LOCAL_HI(%a0)    |with lsb set
 581         clrl    LOCAL_LO(%a0)
 582         orl     #unfinx_mask,USER_FPSR(%a6)
 583         bra     wr_etemp
 584 cu_snd:
 585         movel   #0xbf810000,LOCAL_EX(%a0)       |force pos single zero
 586         clrl    LOCAL_HI(%a0)
 587         clrl    LOCAL_LO(%a0)
 588         orl     #z_mask,USER_FPSR(%a6)
 589         orl     #neg_mask,USER_FPSR(%a6)
 590         orl     #unfinx_mask,USER_FPSR(%a6)
 591         bra     wr_etemp
 592 cu_sndr:
 593         movel   #0xbf810000,LOCAL_EX(%a0)       |force pos single zero
 594         movel   #0x100,LOCAL_HI(%a0)    |with lsb set
 595         clrl    LOCAL_LO(%a0)
 596         orl     #neg_mask,USER_FPSR(%a6)
 597         orl     #unfinx_mask,USER_FPSR(%a6)
 598         bra     wr_etemp
 599
 600 |
 601 | This code checks for 16-bit overflow conditions on dyadic
 602 | operations which are not restorable into the floating-point
 603 | unit and must be completed in software.  Basically, this
 604 | condition exists with a very large norm and a denorm.  One
 605 | of the operands must be denormalized to enter this code.
 606 |
 607 | Flags used:
 608 |       DY_MO_FLG contains 0 for monadic op, $ff for dyadic
 609 |       DNRM_FLG contains $00 for neither op denormalized
 610 |                         $0f for the destination op denormalized
 611 |                         $f0 for the source op denormalized
 612 |                         $ff for both ops denormalized
 613 |
 614 | The wrap-around condition occurs for add, sub, div, and cmp
 615 | when
 616 |
 617 |       abs(dest_exp - src_exp) >= $8000
 618 |
 619 | and for mul when
 620 |
 621 |       (dest_exp + src_exp) < $0
 622 |
 623 | we must process the operation here if this case is true.
 624 |
 625 | The rts following the frcfpn routine is the exit from res_func
 626 | for this condition.  The restore flag (RES_FLG) is left clear.
 627 | No frestore is done unless an exception is to be reported.
 628 |
 629 | For fadd:
 630 |       if(sign_of(dest) != sign_of(src))
 631 |               replace exponent of src with $3fff (keep sign)
 632 |               use fpu to perform dest+new_src (user's rmode and X)
 633 |               clr sticky
 634 |       else
 635 |               set sticky
 636 |       call round with user's precision and mode
 637 |       move result to fpn and wbtemp
 638 |
 639 | For fsub:
 640 |       if(sign_of(dest) == sign_of(src))
 641 |               replace exponent of src with $3fff (keep sign)
 642 |               use fpu to perform dest+new_src (user's rmode and X)
 643 |               clr sticky
 644 |       else
 645 |               set sticky
 646 |       call round with user's precision and mode
 647 |       move result to fpn and wbtemp
 648 |
 649 | For fdiv/fsgldiv:
 650 |       if(both operands are denorm)
 651 |               restore_to_fpu;
 652 |       if(dest is norm)
 653 |               force_ovf;
 654 |       else(dest is denorm)
 655 |               force_unf:
 656 |
 657 | For fcmp:
 658 |       if(dest is norm)
 659 |               N = sign_of(dest);
 660 |       else(dest is denorm)
 661 |               N = sign_of(src);
 662 |
 663 | For fmul:
 664 |       if(both operands are denorm)
 665 |               force_unf;
 666 |       if((dest_exp + src_exp) < 0)
 667 |               force_unf:
 668 |       else
 669 |               restore_to_fpu;
 670 |
 671 | local equates:
 672         .set    addcode,0x22
 673         .set    subcode,0x28
 674         .set    mulcode,0x23
 675         .set    divcode,0x20
 676         .set    cmpcode,0x38
 677 ck_wrap:
 678         | tstb  DY_MO_FLG(%a6)  ;check for fsqrt
 679         beq     fix_stk         |if zero, it is fsqrt
 680         movew   CMDREG1B(%a6),%d0
 681         andiw   #0x3b,%d0               |strip to command bits
 682         cmpiw   #addcode,%d0
 683         beq     wrap_add
 684         cmpiw   #subcode,%d0
 685         beq     wrap_sub
 686         cmpiw   #mulcode,%d0
 687         beq     wrap_mul
 688         cmpiw   #cmpcode,%d0
 689         beq     wrap_cmp
 690 |
 691 | Inst is fdiv.
 692 |
 693 wrap_div:
 694         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
 695         beq     fix_stk          |restore to fpu
 696 |
 697 | One of the ops is denormalized.  Test for wrap condition
 698 | and force the result.
 699 |
 700         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
 701         bnes    div_srcd
 702 div_destd:
 703         bsrl    ckinf_ns
 704         bne     fix_stk
 705         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
 706         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
 707         subl    %d1,%d0                 |subtract dest from src
 708         cmpl    #0x7fff,%d0
 709         blt     fix_stk                 |if less, not wrap case
 710         clrb    WBTEMP_SGN(%a6)
 711         movew   ETEMP_EX(%a6),%d0               |find the sign of the result
 712         movew   FPTEMP_EX(%a6),%d1
 713         eorw    %d1,%d0
 714         andiw   #0x8000,%d0
 715         beq     force_unf
 716         st      WBTEMP_SGN(%a6)
 717         bra     force_unf
 718
 719 ckinf_ns:
 720         moveb   STAG(%a6),%d0           |check source tag for inf or nan
 721         bra     ck_in_com
 722 ckinf_nd:
 723         moveb   DTAG(%a6),%d0           |check destination tag for inf or nan
 724 ck_in_com:
 725         andib   #0x60,%d0                       |isolate tag bits
 726         cmpb    #0x40,%d0                       |is it inf?
 727         beq     nan_or_inf              |not wrap case
 728         cmpb    #0x60,%d0                       |is it nan?
 729         beq     nan_or_inf              |yes, not wrap case?
 730         cmpb    #0x20,%d0                       |is it a zero?
 731         beq     nan_or_inf              |yes
 732         clrl    %d0
 733         rts                             |then ; it is either a zero of norm,
 734 |                                       ;check wrap case
 735 nan_or_inf:
 736         moveql  #-1,%d0
 737         rts
 738
 739
 740
 741 div_srcd:
 742         bsrl    ckinf_nd
 743         bne     fix_stk
 744         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
 745         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
 746         subl    %d1,%d0                 |subtract src from dest
 747         cmpl    #0x8000,%d0
 748         blt     fix_stk                 |if less, not wrap case
 749         clrb    WBTEMP_SGN(%a6)
 750         movew   ETEMP_EX(%a6),%d0               |find the sign of the result
 751         movew   FPTEMP_EX(%a6),%d1
 752         eorw    %d1,%d0
 753         andiw   #0x8000,%d0
 754         beqs    force_ovf
 755         st      WBTEMP_SGN(%a6)
 756 |
 757 | This code handles the case of the instruction resulting in
 758 | an overflow condition.
 759 |
 760 force_ovf:
 761         bclrb   #E1,E_BYTE(%a6)
 762         orl     #ovfl_inx_mask,USER_FPSR(%a6)
 763         clrw    NMNEXC(%a6)
 764         leal    WBTEMP(%a6),%a0         |point a0 to memory location
 765         movew   CMDREG1B(%a6),%d0
 766         btstl   #6,%d0                  |test for forced precision
 767         beqs    frcovf_fpcr
 768         btstl   #2,%d0                  |check for double
 769         bnes    frcovf_dbl
 770         movel   #0x1,%d0                        |inst is forced single
 771         bras    frcovf_rnd
 772 frcovf_dbl:
 773         movel   #0x2,%d0                        |inst is forced double
 774         bras    frcovf_rnd
 775 frcovf_fpcr:
 776         bfextu  FPCR_MODE(%a6){#0:#2},%d0       |inst not forced - use fpcr prec
 777 frcovf_rnd:
 778
 779 | The 881/882 does not set inex2 for the following case, so the
 780 | line is commented out to be compatible with 881/882
 781 |       tst.b   %d0
 782 |       beq.b   frcovf_x
 783 |       or.l    #inex2_mask,USER_FPSR(%a6) ;if prec is s or d, set inex2
 784
 785 |frcovf_x:
 786         bsrl    ovf_res                 |get correct result based on
 787 |                                       ;round precision/mode.  This
 788 |                                       ;sets FPSR_CC correctly
 789 |                                       ;returns in external format
 790         bfclr   WBTEMP_SGN(%a6){#0:#8}
 791         beq     frcfpn
 792         bsetb   #sign_bit,WBTEMP_EX(%a6)
 793         bra     frcfpn
 794 |
 795 | Inst is fadd.
 796 |
 797 wrap_add:
 798         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
 799         beq     fix_stk          |restore to fpu
 800 |
 801 | One of the ops is denormalized.  Test for wrap condition
 802 | and complete the instruction.
 803 |
 804         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
 805         bnes    add_srcd
 806 add_destd:
 807         bsrl    ckinf_ns
 808         bne     fix_stk
 809         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
 810         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
 811         subl    %d1,%d0                 |subtract dest from src
 812         cmpl    #0x8000,%d0
 813         blt     fix_stk                 |if less, not wrap case
 814         bra     add_wrap
 815 add_srcd:
 816         bsrl    ckinf_nd
 817         bne     fix_stk
 818         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
 819         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
 820         subl    %d1,%d0                 |subtract src from dest
 821         cmpl    #0x8000,%d0
 822         blt     fix_stk                 |if less, not wrap case
 823 |
 824 | Check the signs of the operands.  If they are unlike, the fpu
 825 | can be used to add the norm and 1.0 with the sign of the
 826 | denorm and it will correctly generate the result in extended
 827 | precision.  We can then call round with no sticky and the result
 828 | will be correct for the user's rounding mode and precision.  If
 829 | the signs are the same, we call round with the sticky bit set
 830 | and the result will be correct for the user's rounding mode and
 831 | precision.
 832 |
 833 add_wrap:
 834         movew   ETEMP_EX(%a6),%d0
 835         movew   FPTEMP_EX(%a6),%d1
 836         eorw    %d1,%d0
 837         andiw   #0x8000,%d0
 838         beq     add_same
 839 |
 840 | The signs are unlike.
 841 |
 842         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
 843         bnes    add_u_srcd
 844         movew   FPTEMP_EX(%a6),%d0
 845         andiw   #0x8000,%d0
 846         orw     #0x3fff,%d0     |force the exponent to +/- 1
 847         movew   %d0,FPTEMP_EX(%a6) |in the denorm
 848         movel   USER_FPCR(%a6),%d0
 849         andil   #0x30,%d0
 850         fmovel  %d0,%fpcr               |set up users rmode and X
 851         fmovex  ETEMP(%a6),%fp0
 852         faddx   FPTEMP(%a6),%fp0
 853         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
 854         fmovel  %fpsr,%d1
 855         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
 856         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
 857         lsrl    #4,%d0          |put rmode in lower 2 bits
 858         movel   USER_FPCR(%a6),%d1
 859         andil   #0xc0,%d1
 860         lsrl    #6,%d1          |put precision in upper word
 861         swap    %d1
 862         orl     %d0,%d1         |set up for round call
 863         clrl    %d0             |force sticky to zero
 864         bclrb   #sign_bit,WBTEMP_EX(%a6)
 865         sne     WBTEMP_SGN(%a6)
 866         bsrl    round           |round result to users rmode & prec
 867         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
 868         beq     frcfpnr
 869         bsetb   #sign_bit,WBTEMP_EX(%a6)
 870         bra     frcfpnr
 871 add_u_srcd:
 872         movew   ETEMP_EX(%a6),%d0
 873         andiw   #0x8000,%d0
 874         orw     #0x3fff,%d0     |force the exponent to +/- 1
 875         movew   %d0,ETEMP_EX(%a6) |in the denorm
 876         movel   USER_FPCR(%a6),%d0
 877         andil   #0x30,%d0
 878         fmovel  %d0,%fpcr               |set up users rmode and X
 879         fmovex  ETEMP(%a6),%fp0
 880         faddx   FPTEMP(%a6),%fp0
 881         fmovel  %fpsr,%d1
 882         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
 883         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
 884         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
 885         lsrl    #4,%d0          |put rmode in lower 2 bits
 886         movel   USER_FPCR(%a6),%d1
 887         andil   #0xc0,%d1
 888         lsrl    #6,%d1          |put precision in upper word
 889         swap    %d1
 890         orl     %d0,%d1         |set up for round call
 891         clrl    %d0             |force sticky to zero
 892         bclrb   #sign_bit,WBTEMP_EX(%a6)
 893         sne     WBTEMP_SGN(%a6) |use internal format for round
 894         bsrl    round           |round result to users rmode & prec
 895         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
 896         beq     frcfpnr
 897         bsetb   #sign_bit,WBTEMP_EX(%a6)
 898         bra     frcfpnr
 899 |
 900 | Signs are alike:
 901 |
 902 add_same:
 903         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
 904         bnes    add_s_srcd
 905 add_s_destd:
 906         leal    ETEMP(%a6),%a0
 907         movel   USER_FPCR(%a6),%d0
 908         andil   #0x30,%d0
 909         lsrl    #4,%d0          |put rmode in lower 2 bits
 910         movel   USER_FPCR(%a6),%d1
 911         andil   #0xc0,%d1
 912         lsrl    #6,%d1          |put precision in upper word
 913         swap    %d1
 914         orl     %d0,%d1         |set up for round call
 915         movel   #0x20000000,%d0 |set sticky for round
 916         bclrb   #sign_bit,ETEMP_EX(%a6)
 917         sne     ETEMP_SGN(%a6)
 918         bsrl    round           |round result to users rmode & prec
 919         bfclr   ETEMP_SGN(%a6){#0:#8}   |convert back to IEEE ext format
 920         beqs    add_s_dclr
 921         bsetb   #sign_bit,ETEMP_EX(%a6)
 922 add_s_dclr:
 923         leal    WBTEMP(%a6),%a0
 924         movel   ETEMP(%a6),(%a0)        |write result to wbtemp
 925         movel   ETEMP_HI(%a6),4(%a0)
 926         movel   ETEMP_LO(%a6),8(%a0)
 927         tstw    ETEMP_EX(%a6)
 928         bgt     add_ckovf
 929         orl     #neg_mask,USER_FPSR(%a6)
 930         bra     add_ckovf
 931 add_s_srcd:
 932         leal    FPTEMP(%a6),%a0
 933         movel   USER_FPCR(%a6),%d0
 934         andil   #0x30,%d0
 935         lsrl    #4,%d0          |put rmode in lower 2 bits
 936         movel   USER_FPCR(%a6),%d1
 937         andil   #0xc0,%d1
 938         lsrl    #6,%d1          |put precision in upper word
 939         swap    %d1
 940         orl     %d0,%d1         |set up for round call
 941         movel   #0x20000000,%d0 |set sticky for round
 942         bclrb   #sign_bit,FPTEMP_EX(%a6)
 943         sne     FPTEMP_SGN(%a6)
 944         bsrl    round           |round result to users rmode & prec
 945         bfclr   FPTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
 946         beqs    add_s_sclr
 947         bsetb   #sign_bit,FPTEMP_EX(%a6)
 948 add_s_sclr:
 949         leal    WBTEMP(%a6),%a0
 950         movel   FPTEMP(%a6),(%a0)       |write result to wbtemp
 951         movel   FPTEMP_HI(%a6),4(%a0)
 952         movel   FPTEMP_LO(%a6),8(%a0)
 953         tstw    FPTEMP_EX(%a6)
 954         bgt     add_ckovf
 955         orl     #neg_mask,USER_FPSR(%a6)
 956 add_ckovf:
 957         movew   WBTEMP_EX(%a6),%d0
 958         andiw   #0x7fff,%d0
 959         cmpiw   #0x7fff,%d0
 960         bne     frcfpnr
 961 |
 962 | The result has overflowed to $7fff exponent.  Set I, ovfl,
 963 | and aovfl, and clr the mantissa (incorrectly set by the
 964 | round routine.)
 965 |
 966         orl     #inf_mask+ovfl_inx_mask,USER_FPSR(%a6)
 967         clrl    4(%a0)
 968         bra     frcfpnr
 969 |
 970 | Inst is fsub.
 971 |
 972 wrap_sub:
 973         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
 974         beq     fix_stk          |restore to fpu
 975 |
 976 | One of the ops is denormalized.  Test for wrap condition
 977 | and complete the instruction.
 978 |
 979         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
 980         bnes    sub_srcd
 981 sub_destd:
 982         bsrl    ckinf_ns
 983         bne     fix_stk
 984         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
 985         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
 986         subl    %d1,%d0                 |subtract src from dest
 987         cmpl    #0x8000,%d0
 988         blt     fix_stk                 |if less, not wrap case
 989         bra     sub_wrap
 990 sub_srcd:
 991         bsrl    ckinf_nd
 992         bne     fix_stk
 993         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
 994         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
 995         subl    %d1,%d0                 |subtract dest from src
 996         cmpl    #0x8000,%d0
 997         blt     fix_stk                 |if less, not wrap case
 998 |
 999 | Check the signs of the operands.  If they are alike, the fpu
1000 | can be used to subtract from the norm 1.0 with the sign of the
1001 | denorm and it will correctly generate the result in extended
1002 | precision.  We can then call round with no sticky and the result
1003 | will be correct for the user's rounding mode and precision.  If
1004 | the signs are unlike, we call round with the sticky bit set
1005 | and the result will be correct for the user's rounding mode and
1006 | precision.
1007 |
1008 sub_wrap:
1009         movew   ETEMP_EX(%a6),%d0
1010         movew   FPTEMP_EX(%a6),%d1
1011         eorw    %d1,%d0
1012         andiw   #0x8000,%d0
1013         bne     sub_diff
1014 |
1015 | The signs are alike.
1016 |
1017         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
1018         bnes    sub_u_srcd
1019         movew   FPTEMP_EX(%a6),%d0
1020         andiw   #0x8000,%d0
1021         orw     #0x3fff,%d0     |force the exponent to +/- 1
1022         movew   %d0,FPTEMP_EX(%a6) |in the denorm
1023         movel   USER_FPCR(%a6),%d0
1024         andil   #0x30,%d0
1025         fmovel  %d0,%fpcr               |set up users rmode and X
1026         fmovex  FPTEMP(%a6),%fp0
1027         fsubx   ETEMP(%a6),%fp0
1028         fmovel  %fpsr,%d1
1029         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
1030         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
1031         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
1032         lsrl    #4,%d0          |put rmode in lower 2 bits
1033         movel   USER_FPCR(%a6),%d1
1034         andil   #0xc0,%d1
1035         lsrl    #6,%d1          |put precision in upper word
1036         swap    %d1
1037         orl     %d0,%d1         |set up for round call
1038         clrl    %d0             |force sticky to zero
1039         bclrb   #sign_bit,WBTEMP_EX(%a6)
1040         sne     WBTEMP_SGN(%a6)
1041         bsrl    round           |round result to users rmode & prec
1042         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1043         beq     frcfpnr
1044         bsetb   #sign_bit,WBTEMP_EX(%a6)
1045         bra     frcfpnr
1046 sub_u_srcd:
1047         movew   ETEMP_EX(%a6),%d0
1048         andiw   #0x8000,%d0
1049         orw     #0x3fff,%d0     |force the exponent to +/- 1
1050         movew   %d0,ETEMP_EX(%a6) |in the denorm
1051         movel   USER_FPCR(%a6),%d0
1052         andil   #0x30,%d0
1053         fmovel  %d0,%fpcr               |set up users rmode and X
1054         fmovex  FPTEMP(%a6),%fp0
1055         fsubx   ETEMP(%a6),%fp0
1056         fmovel  %fpsr,%d1
1057         orl     %d1,USER_FPSR(%a6) |capture cc's and inex from fadd
1058         leal    WBTEMP(%a6),%a0 |point a0 to wbtemp in frame
1059         fmovex  %fp0,WBTEMP(%a6)        |write result to memory
1060         lsrl    #4,%d0          |put rmode in lower 2 bits
1061         movel   USER_FPCR(%a6),%d1
1062         andil   #0xc0,%d1
1063         lsrl    #6,%d1          |put precision in upper word
1064         swap    %d1
1065         orl     %d0,%d1         |set up for round call
1066         clrl    %d0             |force sticky to zero
1067         bclrb   #sign_bit,WBTEMP_EX(%a6)
1068         sne     WBTEMP_SGN(%a6)
1069         bsrl    round           |round result to users rmode & prec
1070         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1071         beq     frcfpnr
1072         bsetb   #sign_bit,WBTEMP_EX(%a6)
1073         bra     frcfpnr
1074 |
1075 | Signs are unlike:
1076 |
1077 sub_diff:
1078         cmpb    #0x0f,DNRM_FLG(%a6) |is dest the denorm?
1079         bnes    sub_s_srcd
1080 sub_s_destd:
1081         leal    ETEMP(%a6),%a0
1082         movel   USER_FPCR(%a6),%d0
1083         andil   #0x30,%d0
1084         lsrl    #4,%d0          |put rmode in lower 2 bits
1085         movel   USER_FPCR(%a6),%d1
1086         andil   #0xc0,%d1
1087         lsrl    #6,%d1          |put precision in upper word
1088         swap    %d1
1089         orl     %d0,%d1         |set up for round call
1090         movel   #0x20000000,%d0 |set sticky for round
1091 |
1092 | Since the dest is the denorm, the sign is the opposite of the
1093 | norm sign.
1094 |
1095         eoriw   #0x8000,ETEMP_EX(%a6)   |flip sign on result
1096         tstw    ETEMP_EX(%a6)
1097         bgts    sub_s_dwr
1098         orl     #neg_mask,USER_FPSR(%a6)
1099 sub_s_dwr:
1100         bclrb   #sign_bit,ETEMP_EX(%a6)
1101         sne     ETEMP_SGN(%a6)
1102         bsrl    round           |round result to users rmode & prec
1103         bfclr   ETEMP_SGN(%a6){#0:#8}   |convert back to IEEE ext format
1104         beqs    sub_s_dclr
1105         bsetb   #sign_bit,ETEMP_EX(%a6)
1106 sub_s_dclr:
1107         leal    WBTEMP(%a6),%a0
1108         movel   ETEMP(%a6),(%a0)        |write result to wbtemp
1109         movel   ETEMP_HI(%a6),4(%a0)
1110         movel   ETEMP_LO(%a6),8(%a0)
1111         bra     sub_ckovf
1112 sub_s_srcd:
1113         leal    FPTEMP(%a6),%a0
1114         movel   USER_FPCR(%a6),%d0
1115         andil   #0x30,%d0
1116         lsrl    #4,%d0          |put rmode in lower 2 bits
1117         movel   USER_FPCR(%a6),%d1
1118         andil   #0xc0,%d1
1119         lsrl    #6,%d1          |put precision in upper word
1120         swap    %d1
1121         orl     %d0,%d1         |set up for round call
1122         movel   #0x20000000,%d0 |set sticky for round
1123         bclrb   #sign_bit,FPTEMP_EX(%a6)
1124         sne     FPTEMP_SGN(%a6)
1125         bsrl    round           |round result to users rmode & prec
1126         bfclr   FPTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1127         beqs    sub_s_sclr
1128         bsetb   #sign_bit,FPTEMP_EX(%a6)
1129 sub_s_sclr:
1130         leal    WBTEMP(%a6),%a0
1131         movel   FPTEMP(%a6),(%a0)       |write result to wbtemp
1132         movel   FPTEMP_HI(%a6),4(%a0)
1133         movel   FPTEMP_LO(%a6),8(%a0)
1134         tstw    FPTEMP_EX(%a6)
1135         bgt     sub_ckovf
1136         orl     #neg_mask,USER_FPSR(%a6)
1137 sub_ckovf:
1138         movew   WBTEMP_EX(%a6),%d0
1139         andiw   #0x7fff,%d0
1140         cmpiw   #0x7fff,%d0
1141         bne     frcfpnr
1142 |
1143 | The result has overflowed to $7fff exponent.  Set I, ovfl,
1144 | and aovfl, and clr the mantissa (incorrectly set by the
1145 | round routine.)
1146 |
1147         orl     #inf_mask+ovfl_inx_mask,USER_FPSR(%a6)
1148         clrl    4(%a0)
1149         bra     frcfpnr
1150 |
1151 | Inst is fcmp.
1152 |
1153 wrap_cmp:
1154         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
1155         beq     fix_stk          |restore to fpu
1156 |
1157 | One of the ops is denormalized.  Test for wrap condition
1158 | and complete the instruction.
1159 |
1160         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
1161         bnes    cmp_srcd
1162 cmp_destd:
1163         bsrl    ckinf_ns
1164         bne     fix_stk
1165         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
1166         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
1167         subl    %d1,%d0                 |subtract dest from src
1168         cmpl    #0x8000,%d0
1169         blt     fix_stk                 |if less, not wrap case
1170         tstw    ETEMP_EX(%a6)           |set N to ~sign_of(src)
1171         bge     cmp_setn
1172         rts
1173 cmp_srcd:
1174         bsrl    ckinf_nd
1175         bne     fix_stk
1176         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
1177         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
1178         subl    %d1,%d0                 |subtract src from dest
1179         cmpl    #0x8000,%d0
1180         blt     fix_stk                 |if less, not wrap case
1181         tstw    FPTEMP_EX(%a6)          |set N to sign_of(dest)
1182         blt     cmp_setn
1183         rts
1184 cmp_setn:
1185         orl     #neg_mask,USER_FPSR(%a6)
1186         rts
1187
1188 |
1189 | Inst is fmul.
1190 |
1191 wrap_mul:
1192         cmpb    #0xff,DNRM_FLG(%a6) |if both ops denorm,
1193         beq     force_unf       |force an underflow (really!)
1194 |
1195 | One of the ops is denormalized.  Test for wrap condition
1196 | and complete the instruction.
1197 |
1198         cmpb    #0x0f,DNRM_FLG(%a6) |check for dest denorm
1199         bnes    mul_srcd
1200 mul_destd:
1201         bsrl    ckinf_ns
1202         bne     fix_stk
1203         bfextu  ETEMP_EX(%a6){#1:#15},%d0       |get src exp (always pos)
1204         bfexts  FPTEMP_EX(%a6){#1:#15},%d1      |get dest exp (always neg)
1205         addl    %d1,%d0                 |subtract dest from src
1206         bgt     fix_stk
1207         bra     force_unf
1208 mul_srcd:
1209         bsrl    ckinf_nd
1210         bne     fix_stk
1211         bfextu  FPTEMP_EX(%a6){#1:#15},%d0      |get dest exp (always pos)
1212         bfexts  ETEMP_EX(%a6){#1:#15},%d1       |get src exp (always neg)
1213         addl    %d1,%d0                 |subtract src from dest
1214         bgt     fix_stk
1215
1216 |
1217 | This code handles the case of the instruction resulting in
1218 | an underflow condition.
1219 |
1220 force_unf:
1221         bclrb   #E1,E_BYTE(%a6)
1222         orl     #unfinx_mask,USER_FPSR(%a6)
1223         clrw    NMNEXC(%a6)
1224         clrb    WBTEMP_SGN(%a6)
1225         movew   ETEMP_EX(%a6),%d0               |find the sign of the result
1226         movew   FPTEMP_EX(%a6),%d1
1227         eorw    %d1,%d0
1228         andiw   #0x8000,%d0
1229         beqs    frcunfcont
1230         st      WBTEMP_SGN(%a6)
1231 frcunfcont:
1232         lea     WBTEMP(%a6),%a0         |point a0 to memory location
1233         movew   CMDREG1B(%a6),%d0
1234         btstl   #6,%d0                  |test for forced precision
1235         beqs    frcunf_fpcr
1236         btstl   #2,%d0                  |check for double
1237         bnes    frcunf_dbl
1238         movel   #0x1,%d0                        |inst is forced single
1239         bras    frcunf_rnd
1240 frcunf_dbl:
1241         movel   #0x2,%d0                        |inst is forced double
1242         bras    frcunf_rnd
1243 frcunf_fpcr:
1244         bfextu  FPCR_MODE(%a6){#0:#2},%d0       |inst not forced - use fpcr prec
1245 frcunf_rnd:
1246         bsrl    unf_sub                 |get correct result based on
1247 |                                       ;round precision/mode.  This
1248 |                                       ;sets FPSR_CC correctly
1249         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1250         beqs    frcfpn
1251         bsetb   #sign_bit,WBTEMP_EX(%a6)
1252         bra     frcfpn
1253
1254 |
1255 | Write the result to the user's fpn.  All results must be HUGE to be
1256 | written; otherwise the results would have overflowed or underflowed.
1257 | If the rounding precision is single or double, the ovf_res routine
1258 | is needed to correctly supply the max value.
1259 |
1260 frcfpnr:
1261         movew   CMDREG1B(%a6),%d0
1262         btstl   #6,%d0                  |test for forced precision
1263         beqs    frcfpn_fpcr
1264         btstl   #2,%d0                  |check for double
1265         bnes    frcfpn_dbl
1266         movel   #0x1,%d0                        |inst is forced single
1267         bras    frcfpn_rnd
1268 frcfpn_dbl:
1269         movel   #0x2,%d0                        |inst is forced double
1270         bras    frcfpn_rnd
1271 frcfpn_fpcr:
1272         bfextu  FPCR_MODE(%a6){#0:#2},%d0       |inst not forced - use fpcr prec
1273         tstb    %d0
1274         beqs    frcfpn                  |if extended, write what you got
1275 frcfpn_rnd:
1276         bclrb   #sign_bit,WBTEMP_EX(%a6)
1277         sne     WBTEMP_SGN(%a6)
1278         bsrl    ovf_res                 |get correct result based on
1279 |                                       ;round precision/mode.  This
1280 |                                       ;sets FPSR_CC correctly
1281         bfclr   WBTEMP_SGN(%a6){#0:#8}  |convert back to IEEE ext format
1282         beqs    frcfpn_clr
1283         bsetb   #sign_bit,WBTEMP_EX(%a6)
1284 frcfpn_clr:
1285         orl     #ovfinx_mask,USER_FPSR(%a6)
1286 |
1287 | Perform the write.
1288 |
1289 frcfpn:
1290         bfextu  CMDREG1B(%a6){#6:#3},%d0        |extract fp destination register
1291         cmpib   #3,%d0
1292         bles    frc0123                 |check if dest is fp0-fp3
1293         movel   #7,%d1
1294         subl    %d0,%d1
1295         clrl    %d0
1296         bsetl   %d1,%d0
1297         fmovemx WBTEMP(%a6),%d0
1298         rts
1299 frc0123:
1300         cmpib   #0,%d0
1301         beqs    frc0_dst
1302         cmpib   #1,%d0
1303         beqs    frc1_dst
1304         cmpib   #2,%d0
1305         beqs    frc2_dst
1306 frc3_dst:
1307         movel   WBTEMP_EX(%a6),USER_FP3(%a6)
1308         movel   WBTEMP_HI(%a6),USER_FP3+4(%a6)
1309         movel   WBTEMP_LO(%a6),USER_FP3+8(%a6)
1310         rts
1311 frc2_dst:
1312         movel   WBTEMP_EX(%a6),USER_FP2(%a6)
1313         movel   WBTEMP_HI(%a6),USER_FP2+4(%a6)
1314         movel   WBTEMP_LO(%a6),USER_FP2+8(%a6)
1315         rts
1316 frc1_dst:
1317         movel   WBTEMP_EX(%a6),USER_FP1(%a6)
1318         movel   WBTEMP_HI(%a6),USER_FP1+4(%a6)
1319         movel   WBTEMP_LO(%a6),USER_FP1+8(%a6)
1320         rts
1321 frc0_dst:
1322         movel   WBTEMP_EX(%a6),USER_FP0(%a6)
1323         movel   WBTEMP_HI(%a6),USER_FP0+4(%a6)
1324         movel   WBTEMP_LO(%a6),USER_FP0+8(%a6)
1325         rts
1326
1327 |
1328 | Write etemp to fpn.
1329 | A check is made on enabled and signalled snan exceptions,
1330 | and the destination is not overwritten if this condition exists.
1331 | This code is designed to make fmoveins of unsupported data types
1332 | faster.
1333 |
1334 wr_etemp:
1335         btstb   #snan_bit,FPSR_EXCEPT(%a6)      |if snan is set, and
1336         beqs    fmoveinc                |enabled, force restore
1337         btstb   #snan_bit,FPCR_ENABLE(%a6) |and don't overwrite
1338         beqs    fmoveinc                |the dest
1339         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
1340 |                                               ;snan handler
1341         tstb    ETEMP(%a6)              |check for negative
1342         blts    snan_neg
1343         rts
1344 snan_neg:
1345         orl     #neg_bit,USER_FPSR(%a6) |snan is negative; set N
1346         rts
1347 fmoveinc:
1348         clrw    NMNEXC(%a6)
1349         bclrb   #E1,E_BYTE(%a6)
1350         moveb   STAG(%a6),%d0           |check if stag is inf
1351         andib   #0xe0,%d0
1352         cmpib   #0x40,%d0
1353         bnes    fminc_cnan
1354         orl     #inf_mask,USER_FPSR(%a6) |if inf, nothing yet has set I
1355         tstw    LOCAL_EX(%a0)           |check sign
1356         bges    fminc_con
1357         orl     #neg_mask,USER_FPSR(%a6)
1358         bra     fminc_con
1359 fminc_cnan:
1360         cmpib   #0x60,%d0                       |check if stag is NaN
1361         bnes    fminc_czero
1362         orl     #nan_mask,USER_FPSR(%a6) |if nan, nothing yet has set NaN
1363         movel   ETEMP_EX(%a6),FPTEMP_EX(%a6)    |set up fptemp sign for
1364 |                                               ;snan handler
1365         tstw    LOCAL_EX(%a0)           |check sign
1366         bges    fminc_con
1367         orl     #neg_mask,USER_FPSR(%a6)
1368         bra     fminc_con
1369 fminc_czero:
1370         cmpib   #0x20,%d0                       |check if zero
1371         bnes    fminc_con
1372         orl     #z_mask,USER_FPSR(%a6)  |if zero, set Z
1373         tstw    LOCAL_EX(%a0)           |check sign
1374         bges    fminc_con
1375         orl     #neg_mask,USER_FPSR(%a6)
1376 fminc_con:
1377         bfextu  CMDREG1B(%a6){#6:#3},%d0        |extract fp destination register
1378         cmpib   #3,%d0
1379         bles    fp0123                  |check if dest is fp0-fp3
1380         movel   #7,%d1
1381         subl    %d0,%d1
1382         clrl    %d0
1383         bsetl   %d1,%d0
1384         fmovemx ETEMP(%a6),%d0
1385         rts
1386
1387 fp0123:
1388         cmpib   #0,%d0
1389         beqs    fp0_dst
1390         cmpib   #1,%d0
1391         beqs    fp1_dst
1392         cmpib   #2,%d0
1393         beqs    fp2_dst
1394 fp3_dst:
1395         movel   ETEMP_EX(%a6),USER_FP3(%a6)
1396         movel   ETEMP_HI(%a6),USER_FP3+4(%a6)
1397         movel   ETEMP_LO(%a6),USER_FP3+8(%a6)
1398         rts
1399 fp2_dst:
1400         movel   ETEMP_EX(%a6),USER_FP2(%a6)
1401         movel   ETEMP_HI(%a6),USER_FP2+4(%a6)
1402         movel   ETEMP_LO(%a6),USER_FP2+8(%a6)
1403         rts
1404 fp1_dst:
1405         movel   ETEMP_EX(%a6),USER_FP1(%a6)
1406         movel   ETEMP_HI(%a6),USER_FP1+4(%a6)
1407         movel   ETEMP_LO(%a6),USER_FP1+8(%a6)
1408         rts
1409 fp0_dst:
1410         movel   ETEMP_EX(%a6),USER_FP0(%a6)
1411         movel   ETEMP_HI(%a6),USER_FP0+4(%a6)
1412         movel   ETEMP_LO(%a6),USER_FP0+8(%a6)
1413         rts
1414
1415 opclass3:
1416         st      CU_ONLY(%a6)
1417         movew   CMDREG1B(%a6),%d0       |check if packed moveout
1418         andiw   #0x0c00,%d0     |isolate last 2 bits of size field
1419         cmpiw   #0x0c00,%d0     |if size is 011 or 111, it is packed
1420         beq     pack_out        |else it is norm or denorm
1421         bra     mv_out
1422
1423
1424 |
1425 |       MOVE OUT
1426 |
1427
1428 mv_tbl:
1429         .long   li
1430         .long   sgp
1431         .long   xp
1432         .long   mvout_end       |should never be taken
1433         .long   wi
1434         .long   dp
1435         .long   bi
1436         .long   mvout_end       |should never be taken
1437 mv_out:
1438         bfextu  CMDREG1B(%a6){#3:#3},%d1        |put source specifier in d1
1439         leal    mv_tbl,%a0
1440         movel   %a0@(%d1:l:4),%a0
1441         jmp     (%a0)
1442
1443 |
1444 | This exit is for move-out to memory.  The aunfl bit is
1445 | set if the result is inex and unfl is signalled.
1446 |
1447 mvout_end:
1448         btstb   #inex2_bit,FPSR_EXCEPT(%a6)
1449         beqs    no_aufl
1450         btstb   #unfl_bit,FPSR_EXCEPT(%a6)
1451         beqs    no_aufl
1452         bsetb   #aunfl_bit,FPSR_AEXCEPT(%a6)
1453 no_aufl:
1454         clrw    NMNEXC(%a6)
1455         bclrb   #E1,E_BYTE(%a6)
1456         fmovel  #0,%FPSR                        |clear any cc bits from res_func
1457 |
1458 | Return ETEMP to extended format from internal extended format so
1459 | that gen_except will have a correctly signed value for ovfl/unfl
1460 | handlers.
1461 |
1462         bfclr   ETEMP_SGN(%a6){#0:#8}
1463         beqs    mvout_con
1464         bsetb   #sign_bit,ETEMP_EX(%a6)
1465 mvout_con:
1466         rts
1467 |
1468 | This exit is for move-out to int register.  The aunfl bit is
1469 | not set in any case for this move.
1470 |
1471 mvouti_end:
1472         clrw    NMNEXC(%a6)
1473         bclrb   #E1,E_BYTE(%a6)
1474         fmovel  #0,%FPSR                        |clear any cc bits from res_func
1475 |
1476 | Return ETEMP to extended format from internal extended format so
1477 | that gen_except will have a correctly signed value for ovfl/unfl
1478 | handlers.
1479 |
1480         bfclr   ETEMP_SGN(%a6){#0:#8}
1481         beqs    mvouti_con
1482         bsetb   #sign_bit,ETEMP_EX(%a6)
1483 mvouti_con:
1484         rts
1485 |
1486 | li is used to handle a long integer source specifier
1487 |
1488
1489 li:
1490         moveql  #4,%d0          |set byte count
1491
1492         btstb   #7,STAG(%a6)    |check for extended denorm
1493         bne     int_dnrm        |if so, branch
1494
1495         fmovemx ETEMP(%a6),%fp0-%fp0
1496         fcmpd   #0x41dfffffffc00000,%fp0
1497 | 41dfffffffc00000 in dbl prec = 401d0000fffffffe00000000 in ext prec
1498         fbge    lo_plrg
1499         fcmpd   #0xc1e0000000000000,%fp0
1500 | c1e0000000000000 in dbl prec = c01e00008000000000000000 in ext prec
1501         fble    lo_nlrg
1502 |
1503 | at this point, the answer is between the largest pos and neg values
1504 |
1505         movel   USER_FPCR(%a6),%d1      |use user's rounding mode
1506         andil   #0x30,%d1
1507         fmovel  %d1,%fpcr
1508         fmovel  %fp0,L_SCR1(%a6)        |let the 040 perform conversion
1509         fmovel %fpsr,%d1
1510         orl     %d1,USER_FPSR(%a6)      |capture inex2/ainex if set
1511         bra     int_wrt
1512
1513
1514 lo_plrg:
1515         movel   #0x7fffffff,L_SCR1(%a6) |answer is largest positive int
1516         fbeq    int_wrt                 |exact answer
1517         fcmpd   #0x41dfffffffe00000,%fp0
1518 | 41dfffffffe00000 in dbl prec = 401d0000ffffffff00000000 in ext prec
1519         fbge    int_operr               |set operr
1520         bra     int_inx                 |set inexact
1521
1522 lo_nlrg:
1523         movel   #0x80000000,L_SCR1(%a6)
1524         fbeq    int_wrt                 |exact answer
1525         fcmpd   #0xc1e0000000100000,%fp0
1526 | c1e0000000100000 in dbl prec = c01e00008000000080000000 in ext prec
1527         fblt    int_operr               |set operr
1528         bra     int_inx                 |set inexact
1529
1530 |
1531 | wi is used to handle a word integer source specifier
1532 |
1533
1534 wi:
1535         moveql  #2,%d0          |set byte count
1536
1537         btstb   #7,STAG(%a6)    |check for extended denorm
1538         bne     int_dnrm        |branch if so
1539
1540         fmovemx ETEMP(%a6),%fp0-%fp0
1541         fcmps   #0x46fffe00,%fp0
1542 | 46fffe00 in sgl prec = 400d0000fffe000000000000 in ext prec
1543         fbge    wo_plrg
1544         fcmps   #0xc7000000,%fp0
1545 | c7000000 in sgl prec = c00e00008000000000000000 in ext prec
1546         fble    wo_nlrg
1547
1548 |
1549 | at this point, the answer is between the largest pos and neg values
1550 |
1551         movel   USER_FPCR(%a6),%d1      |use user's rounding mode
1552         andil   #0x30,%d1
1553         fmovel  %d1,%fpcr
1554         fmovew  %fp0,L_SCR1(%a6)        |let the 040 perform conversion
1555         fmovel %fpsr,%d1
1556         orl     %d1,USER_FPSR(%a6)      |capture inex2/ainex if set
1557         bra     int_wrt
1558
1559 wo_plrg:
1560         movew   #0x7fff,L_SCR1(%a6)     |answer is largest positive int
1561         fbeq    int_wrt                 |exact answer
1562         fcmps   #0x46ffff00,%fp0
1563 | 46ffff00 in sgl prec = 400d0000ffff000000000000 in ext prec
1564         fbge    int_operr               |set operr
1565         bra     int_inx                 |set inexact
1566
1567 wo_nlrg:
1568         movew   #0x8000,L_SCR1(%a6)
1569         fbeq    int_wrt                 |exact answer
1570         fcmps   #0xc7000080,%fp0
1571 | c7000080 in sgl prec = c00e00008000800000000000 in ext prec
1572         fblt    int_operr               |set operr
1573         bra     int_inx                 |set inexact
1574
1575 |
1576 | bi is used to handle a byte integer source specifier
1577 |
1578
1579 bi:
1580         moveql  #1,%d0          |set byte count
1581
1582         btstb   #7,STAG(%a6)    |check for extended denorm
1583         bne     int_dnrm        |branch if so
1584
1585         fmovemx ETEMP(%a6),%fp0-%fp0
1586         fcmps   #0x42fe0000,%fp0
1587 | 42fe0000 in sgl prec = 40050000fe00000000000000 in ext prec
1588         fbge    by_plrg
1589         fcmps   #0xc3000000,%fp0
1590 | c3000000 in sgl prec = c00600008000000000000000 in ext prec
1591         fble    by_nlrg
1592
1593 |
1594 | at this point, the answer is between the largest pos and neg values
1595 |
1596         movel   USER_FPCR(%a6),%d1      |use user's rounding mode
1597         andil   #0x30,%d1
1598         fmovel  %d1,%fpcr
1599         fmoveb  %fp0,L_SCR1(%a6)        |let the 040 perform conversion
1600         fmovel %fpsr,%d1
1601         orl     %d1,USER_FPSR(%a6)      |capture inex2/ainex if set
1602         bra     int_wrt
1603
1604 by_plrg:
1605         moveb   #0x7f,L_SCR1(%a6)               |answer is largest positive int
1606         fbeq    int_wrt                 |exact answer
1607         fcmps   #0x42ff0000,%fp0
1608 | 42ff0000 in sgl prec = 40050000ff00000000000000 in ext prec
1609         fbge    int_operr               |set operr
1610         bra     int_inx                 |set inexact
1611
1612 by_nlrg:
1613         moveb   #0x80,L_SCR1(%a6)
1614         fbeq    int_wrt                 |exact answer
1615         fcmps   #0xc3008000,%fp0
1616 | c3008000 in sgl prec = c00600008080000000000000 in ext prec
1617         fblt    int_operr               |set operr
1618         bra     int_inx                 |set inexact
1619
1620 |
1621 | Common integer routines
1622 |
1623 | int_drnrm---account for possible nonzero result for round up with positive
1624 | operand and round down for negative answer.  In the first case (result = 1)
1625 | byte-width (store in d0) of result must be honored.  In the second case,
1626 | -1 in L_SCR1(a6) will cover all contingencies (FMOVE.B/W/L out).
1627
1628 int_dnrm:
1629         movel   #0,L_SCR1(%a6)  | initialize result to 0
1630         bfextu  FPCR_MODE(%a6){#2:#2},%d1       | d1 is the rounding mode
1631         cmpb    #2,%d1
1632         bmis    int_inx         | if RN or RZ, done
1633         bnes    int_rp          | if RP, continue below
1634         tstw    ETEMP(%a6)      | RM: store -1 in L_SCR1 if src is negative
1635         bpls    int_inx         | otherwise result is 0
1636         movel   #-1,L_SCR1(%a6)
1637         bras    int_inx
1638 int_rp:
1639         tstw    ETEMP(%a6)      | RP: store +1 of proper width in L_SCR1 if
1640 |                               ; source is greater than 0
1641         bmis    int_inx         | otherwise, result is 0
1642         lea     L_SCR1(%a6),%a1 | a1 is address of L_SCR1
1643         addal   %d0,%a1         | offset by destination width -1
1644         subal   #1,%a1
1645         bsetb   #0,(%a1)                | set low bit at a1 address
1646 int_inx:
1647         oril    #inx2a_mask,USER_FPSR(%a6)
1648         bras    int_wrt
1649 int_operr:
1650         fmovemx %fp0-%fp0,FPTEMP(%a6)   |FPTEMP must contain the extended
1651 |                               ;precision source that needs to be
1652 |                               ;converted to integer this is required
1653 |                               ;if the operr exception is enabled.
1654 |                               ;set operr/aiop (no inex2 on int ovfl)
1655
1656         oril    #opaop_mask,USER_FPSR(%a6)
1657 |                               ;fall through to perform int_wrt
1658 int_wrt:
1659         movel   EXC_EA(%a6),%a1 |load destination address
1660         tstl    %a1             |check to see if it is a dest register
1661         beqs    wrt_dn          |write data register
1662         lea     L_SCR1(%a6),%a0 |point to supervisor source address
1663         bsrl    mem_write
1664         bra     mvouti_end
1665
1666 wrt_dn:
1667         movel   %d0,-(%sp)      |d0 currently contains the size to write
1668         bsrl    get_fline       |get_fline returns Dn in d0
1669         andiw   #0x7,%d0                |isolate register
1670         movel   (%sp)+,%d1      |get size
1671         cmpil   #4,%d1          |most frequent case
1672         beqs    sz_long
1673         cmpil   #2,%d1
1674         bnes    sz_con
1675         orl     #8,%d0          |add 'word' size to register#
1676         bras    sz_con
1677 sz_long:
1678         orl     #0x10,%d0               |add 'long' size to register#
1679 sz_con:
1680         movel   %d0,%d1         |reg_dest expects size:reg in d1
1681         bsrl    reg_dest        |load proper data register
1682         bra     mvouti_end
1683 xp:
1684         lea     ETEMP(%a6),%a0
1685         bclrb   #sign_bit,LOCAL_EX(%a0)
1686         sne     LOCAL_SGN(%a0)
1687         btstb   #7,STAG(%a6)    |check for extended denorm
1688         bne     xdnrm
1689         clrl    %d0
1690         bras    do_fp           |do normal case
1691 sgp:
1692         lea     ETEMP(%a6),%a0
1693         bclrb   #sign_bit,LOCAL_EX(%a0)
1694         sne     LOCAL_SGN(%a0)
1695         btstb   #7,STAG(%a6)    |check for extended denorm
1696         bne     sp_catas        |branch if so
1697         movew   LOCAL_EX(%a0),%d0
1698         lea     sp_bnds,%a1
1699         cmpw    (%a1),%d0
1700         blt     sp_under
1701         cmpw    2(%a1),%d0
1702         bgt     sp_over
1703         movel   #1,%d0          |set destination format to single
1704         bras    do_fp           |do normal case
1705 dp:
1706         lea     ETEMP(%a6),%a0
1707         bclrb   #sign_bit,LOCAL_EX(%a0)
1708         sne     LOCAL_SGN(%a0)
1709
1710         btstb   #7,STAG(%a6)    |check for extended denorm
1711         bne     dp_catas        |branch if so
1712
1713         movew   LOCAL_EX(%a0),%d0
1714         lea     dp_bnds,%a1
1715
1716         cmpw    (%a1),%d0
1717         blt     dp_under
1718         cmpw    2(%a1),%d0
1719         bgt     dp_over
1720
1721         movel   #2,%d0          |set destination format to double
1722 |                               ;fall through to do_fp
1723 |
1724 do_fp:
1725         bfextu  FPCR_MODE(%a6){#2:#2},%d1       |rnd mode in d1
1726         swap    %d0                     |rnd prec in upper word
1727         addl    %d0,%d1                 |d1 has PREC/MODE info
1728
1729         clrl    %d0                     |clear g,r,s
1730
1731         bsrl    round                   |round
1732
1733         movel   %a0,%a1
1734         movel   EXC_EA(%a6),%a0
1735
1736         bfextu  CMDREG1B(%a6){#3:#3},%d1        |extract destination format
1737 |                                       ;at this point only the dest
1738 |                                       ;formats sgl, dbl, ext are
1739 |                                       ;possible
1740         cmpb    #2,%d1
1741         bgts    ddbl                    |double=5, extended=2, single=1
1742         bnes    dsgl
1743 |                                       ;fall through to dext
1744 dext:
1745         bsrl    dest_ext
1746         bra     mvout_end
1747 dsgl:
1748         bsrl    dest_sgl
1749         bra     mvout_end
1750 ddbl:
1751         bsrl    dest_dbl
1752         bra     mvout_end
1753
1754 |
1755 | Handle possible denorm or catastrophic underflow cases here
1756 |
1757 xdnrm:
1758         bsr     set_xop         |initialize WBTEMP
1759         bsetb   #wbtemp15_bit,WB_BYTE(%a6) |set wbtemp15
1760
1761         movel   %a0,%a1
1762         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1763         bsrl    dest_ext        |store to memory
1764         bsetb   #unfl_bit,FPSR_EXCEPT(%a6)
1765         bra     mvout_end
1766
1767 sp_under:
1768         bsetb   #etemp15_bit,STAG(%a6)
1769
1770         cmpw    4(%a1),%d0
1771         blts    sp_catas        |catastrophic underflow case
1772
1773         movel   #1,%d0          |load in round precision
1774         movel   #sgl_thresh,%d1 |load in single denorm threshold
1775         bsrl    dpspdnrm        |expects d1 to have the proper
1776 |                               ;denorm threshold
1777         bsrl    dest_sgl        |stores value to destination
1778         bsetb   #unfl_bit,FPSR_EXCEPT(%a6)
1779         bra     mvout_end       |exit
1780
1781 dp_under:
1782         bsetb   #etemp15_bit,STAG(%a6)
1783
1784         cmpw    4(%a1),%d0
1785         blts    dp_catas        |catastrophic underflow case
1786
1787         movel   #dbl_thresh,%d1 |load in double precision threshold
1788         movel   #2,%d0
1789         bsrl    dpspdnrm        |expects d1 to have proper
1790 |                               ;denorm threshold
1791 |                               ;expects d0 to have round precision
1792         bsrl    dest_dbl        |store value to destination
1793         bsetb   #unfl_bit,FPSR_EXCEPT(%a6)
1794         bra     mvout_end       |exit
1795
1796 |
1797 | Handle catastrophic underflow cases here
1798 |
1799 sp_catas:
1800 | Temp fix for z bit set in unf_sub
1801         movel   USER_FPSR(%a6),-(%a7)
1802
1803         movel   #1,%d0          |set round precision to sgl
1804
1805         bsrl    unf_sub         |a0 points to result
1806
1807         movel   (%a7)+,USER_FPSR(%a6)
1808
1809         movel   #1,%d0
1810         subw    %d0,LOCAL_EX(%a0) |account for difference between
1811 |                               ;denorm/norm bias
1812
1813         movel   %a0,%a1         |a1 has the operand input
1814         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1815
1816         bsrl    dest_sgl        |store the result
1817         oril    #unfinx_mask,USER_FPSR(%a6)
1818         bra     mvout_end
1819
1820 dp_catas:
1821 | Temp fix for z bit set in unf_sub
1822         movel   USER_FPSR(%a6),-(%a7)
1823
1824         movel   #2,%d0          |set round precision to dbl
1825         bsrl    unf_sub         |a0 points to result
1826
1827         movel   (%a7)+,USER_FPSR(%a6)
1828
1829         movel   #1,%d0
1830         subw    %d0,LOCAL_EX(%a0) |account for difference between
1831 |                               ;denorm/norm bias
1832
1833         movel   %a0,%a1         |a1 has the operand input
1834         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1835
1836         bsrl    dest_dbl        |store the result
1837         oril    #unfinx_mask,USER_FPSR(%a6)
1838         bra     mvout_end
1839
1840 |
1841 | Handle catastrophic overflow cases here
1842 |
1843 sp_over:
1844 | Temp fix for z bit set in unf_sub
1845         movel   USER_FPSR(%a6),-(%a7)
1846
1847         movel   #1,%d0
1848         leal    FP_SCR1(%a6),%a0        |use FP_SCR1 for creating result
1849         movel   ETEMP_EX(%a6),(%a0)
1850         movel   ETEMP_HI(%a6),4(%a0)
1851         movel   ETEMP_LO(%a6),8(%a0)
1852         bsrl    ovf_res
1853
1854         movel   (%a7)+,USER_FPSR(%a6)
1855
1856         movel   %a0,%a1
1857         movel   EXC_EA(%a6),%a0
1858         bsrl    dest_sgl
1859         orl     #ovfinx_mask,USER_FPSR(%a6)
1860         bra     mvout_end
1861
1862 dp_over:
1863 | Temp fix for z bit set in ovf_res
1864         movel   USER_FPSR(%a6),-(%a7)
1865
1866         movel   #2,%d0
1867         leal    FP_SCR1(%a6),%a0        |use FP_SCR1 for creating result
1868         movel   ETEMP_EX(%a6),(%a0)
1869         movel   ETEMP_HI(%a6),4(%a0)
1870         movel   ETEMP_LO(%a6),8(%a0)
1871         bsrl    ovf_res
1872
1873         movel   (%a7)+,USER_FPSR(%a6)
1874
1875         movel   %a0,%a1
1876         movel   EXC_EA(%a6),%a0
1877         bsrl    dest_dbl
1878         orl     #ovfinx_mask,USER_FPSR(%a6)
1879         bra     mvout_end
1880
1881 |
1882 |       DPSPDNRM
1883 |
1884 | This subroutine takes an extended normalized number and denormalizes
1885 | it to the given round precision. This subroutine also decrements
1886 | the input operand's exponent by 1 to account for the fact that
1887 | dest_sgl or dest_dbl expects a normalized number's bias.
1888 |
1889 | Input: a0  points to a normalized number in internal extended format
1890 |        d0  is the round precision (=1 for sgl; =2 for dbl)
1891 |        d1  is the single precision or double precision
1892 |            denorm threshold
1893 |
1894 | Output: (In the format for dest_sgl or dest_dbl)
1895 |        a0   points to the destination
1896 |        a1   points to the operand
1897 |
1898 | Exceptions: Reports inexact 2 exception by setting USER_FPSR bits
1899 |
1900 dpspdnrm:
1901         movel   %d0,-(%a7)      |save round precision
1902         clrl    %d0             |clear initial g,r,s
1903         bsrl    dnrm_lp         |careful with d0, it's needed by round
1904
1905         bfextu  FPCR_MODE(%a6){#2:#2},%d1 |get rounding mode
1906         swap    %d1
1907         movew   2(%a7),%d1      |set rounding precision
1908         swap    %d1             |at this point d1 has PREC/MODE info
1909         bsrl    round           |round result, sets the inex bit in
1910 |                               ;USER_FPSR if needed
1911
1912         movew   #1,%d0
1913         subw    %d0,LOCAL_EX(%a0) |account for difference in denorm
1914 |                               ;vs norm bias
1915
1916         movel   %a0,%a1         |a1 has the operand input
1917         movel   EXC_EA(%a6),%a0 |a0 has the destination pointer
1918         addw    #4,%a7          |pop stack
1919         rts
1920 |
1921 | SET_XOP initialized WBTEMP with the value pointed to by a0
1922 | input: a0 points to input operand in the internal extended format
1923 |
1924 set_xop:
1925         movel   LOCAL_EX(%a0),WBTEMP_EX(%a6)
1926         movel   LOCAL_HI(%a0),WBTEMP_HI(%a6)
1927         movel   LOCAL_LO(%a0),WBTEMP_LO(%a6)
1928         bfclr   WBTEMP_SGN(%a6){#0:#8}
1929         beqs    sxop
1930         bsetb   #sign_bit,WBTEMP_EX(%a6)
1931 sxop:
1932         bfclr   STAG(%a6){#5:#4}        |clear wbtm66,wbtm1,wbtm0,sbit
1933         rts
1934 |
1935 |       P_MOVE
1936 |
1937 p_movet:
1938         .long   p_move
1939         .long   p_movez
1940         .long   p_movei
1941         .long   p_moven
1942         .long   p_move
1943 p_regd:
1944         .long   p_dyd0
1945         .long   p_dyd1
1946         .long   p_dyd2
1947         .long   p_dyd3
1948         .long   p_dyd4
1949         .long   p_dyd5
1950         .long   p_dyd6
1951         .long   p_dyd7
1952
1953 pack_out:
1954         leal    p_movet,%a0     |load jmp table address
1955         movew   STAG(%a6),%d0   |get source tag
1956         bfextu  %d0{#16:#3},%d0 |isolate source bits
1957         movel   (%a0,%d0.w*4),%a0       |load a0 with routine label for tag
1958         jmp     (%a0)           |go to the routine
1959
1960 p_write:
1961         movel   #0x0c,%d0       |get byte count
1962         movel   EXC_EA(%a6),%a1 |get the destination address
1963         bsr     mem_write       |write the user's destination
1964         moveb   #0,CU_SAVEPC(%a6) |set the cu save pc to all 0's
1965
1966 |
1967 | Also note that the dtag must be set to norm here - this is because
1968 | the 040 uses the dtag to execute the correct microcode.
1969 |
1970         bfclr    DTAG(%a6){#0:#3}  |set dtag to norm
1971
1972         rts
1973
1974 | Notes on handling of special case (zero, inf, and nan) inputs:
1975 |       1. Operr is not signalled if the k-factor is greater than 18.
1976 |       2. Per the manual, status bits are not set.
1977 |
1978
1979 p_move:
1980         movew   CMDREG1B(%a6),%d0
1981         btstl   #kfact_bit,%d0  |test for dynamic k-factor
1982         beqs    statick         |if clear, k-factor is static
1983 dynamick:
1984         bfextu  %d0{#25:#3},%d0 |isolate register for dynamic k-factor
1985         lea     p_regd,%a0
1986         movel   %a0@(%d0:l:4),%a0
1987         jmp     (%a0)
1988 statick:
1989         andiw   #0x007f,%d0     |get k-factor
1990         bfexts  %d0{#25:#7},%d0 |sign extend d0 for bindec
1991         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
1992         bsrl    bindec          |perform the convert; data at a6
1993         leal    FP_SCR1(%a6),%a0        |load a0 with result address
1994         bral    p_write
1995 p_movez:
1996         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
1997         clrw    2(%a0)          |clear lower word of exp
1998         clrl    4(%a0)          |load second lword of ZERO
1999         clrl    8(%a0)          |load third lword of ZERO
2000         bra     p_write         |go write results
2001 p_movei:
2002         fmovel  #0,%FPSR                |clear aiop
2003         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
2004         clrw    2(%a0)          |clear lower word of exp
2005         bra     p_write         |go write the result
2006 p_moven:
2007         leal    ETEMP(%a6),%a0  |a0 will point to the packed decimal
2008         clrw    2(%a0)          |clear lower word of exp
2009         bra     p_write         |go write the result
2010
2011 |
2012 | Routines to read the dynamic k-factor from Dn.
2013 |
2014 p_dyd0:
2015         movel   USER_D0(%a6),%d0
2016         bras    statick
2017 p_dyd1:
2018         movel   USER_D1(%a6),%d0
2019         bras    statick
2020 p_dyd2:
2021         movel   %d2,%d0
2022         bras    statick
2023 p_dyd3:
2024         movel   %d3,%d0
2025         bras    statick
2026 p_dyd4:
2027         movel   %d4,%d0
2028         bras    statick
2029 p_dyd5:
2030         movel   %d5,%d0
2031         bras    statick
2032 p_dyd6:
2033         movel   %d6,%d0
2034         bra     statick
2035 p_dyd7:
2036         movel   %d7,%d0
2037         bra     statick
2038
2039         |end