linux/arch/m68k/math-emu/fp_util.S
<<
>>
Prefs
   1/*
   2 * fp_util.S
   3 *
   4 * Copyright Roman Zippel, 1997.  All rights reserved.
   5 *
   6 * Redistribution and use in source and binary forms, with or without
   7 * modification, are permitted provided that the following conditions
   8 * are met:
   9 * 1. Redistributions of source code must retain the above copyright
  10 *    notice, and the entire permission notice in its entirety,
  11 *    including the disclaimer of warranties.
  12 * 2. Redistributions in binary form must reproduce the above copyright
  13 *    notice, this list of conditions and the following disclaimer in the
  14 *    documentation and/or other materials provided with the distribution.
  15 * 3. The name of the author may not be used to endorse or promote
  16 *    products derived from this software without specific prior
  17 *    written permission.
  18 *
  19 * ALTERNATIVELY, this product may be distributed under the terms of
  20 * the GNU General Public License, in which case the provisions of the GPL are
  21 * required INSTEAD OF the above restrictions.  (This clause is
  22 * necessary due to a potential bad interaction between the GPL and
  23 * the restrictions contained in a BSD-style copyright.)
  24 *
  25 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  26 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  28 * DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  29 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  30 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  33 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  35 * OF THE POSSIBILITY OF SUCH DAMAGE.
  36 */
  37
  38#include "fp_emu.h"
  39
  40/*
  41 * Here are lots of conversion and normalization functions mainly
  42 * used by fp_scan.S
  43 * Note that these functions are optimized for "normal" numbers,
  44 * these are handled first and exit as fast as possible, this is
  45 * especially important for fp_normalize_ext/fp_conv_ext2ext, as
  46 * it's called very often.
  47 * The register usage is optimized for fp_scan.S and which register
  48 * is currently at that time unused, be careful if you want change
  49 * something here. %d0 and %d1 is always usable, sometimes %d2 (or
  50 * only the lower half) most function have to return the %a0
  51 * unmodified, so that the caller can immediately reuse it.
  52 */
  53
  54        .globl  fp_ill, fp_end
  55
  56        | exits from fp_scan:
  57        | illegal instruction
  58fp_ill:
  59        printf  ,"fp_illegal\n"
  60        rts
  61        | completed instruction
  62fp_end:
  63        tst.l   (TASK_MM-8,%a2)
  64        jmi     1f
  65        tst.l   (TASK_MM-4,%a2)
  66        jmi     1f
  67        tst.l   (TASK_MM,%a2)
  68        jpl     2f
  691:      printf  ,"oops:%p,%p,%p\n",3,%a2@(TASK_MM-8),%a2@(TASK_MM-4),%a2@(TASK_MM)
  702:      clr.l   %d0
  71        rts
  72
  73        .globl  fp_conv_long2ext, fp_conv_single2ext
  74        .globl  fp_conv_double2ext, fp_conv_ext2ext
  75        .globl  fp_normalize_ext, fp_normalize_double
  76        .globl  fp_normalize_single, fp_normalize_single_fast
  77        .globl  fp_conv_ext2double, fp_conv_ext2single
  78        .globl  fp_conv_ext2long, fp_conv_ext2short
  79        .globl  fp_conv_ext2byte
  80        .globl  fp_finalrounding_single, fp_finalrounding_single_fast
  81        .globl  fp_finalrounding_double
  82        .globl  fp_finalrounding, fp_finaltest, fp_final
  83
  84/*
  85 * First several conversion functions from a source operand
  86 * into the extended format. Note, that only fp_conv_ext2ext
  87 * normalizes the number and is always called after the other
  88 * conversion functions, which only move the information into
  89 * fp_ext structure.
  90 */
  91
  92        | fp_conv_long2ext:
  93        |
  94        | args: %d0 = source (32-bit long)
  95        |       %a0 = destination (ptr to struct fp_ext)
  96
  97fp_conv_long2ext:
  98        printf  PCONV,"l2e: %p -> %p(",2,%d0,%a0
  99        clr.l   %d1                     | sign defaults to zero
 100        tst.l   %d0
 101        jeq     fp_l2e_zero             | is source zero?
 102        jpl     1f                      | positive?
 103        moveq   #1,%d1
 104        neg.l   %d0
 1051:      swap    %d1
 106        move.w  #0x3fff+31,%d1
 107        move.l  %d1,(%a0)+              | set sign / exp
 108        move.l  %d0,(%a0)+              | set mantissa
 109        clr.l   (%a0)
 110        subq.l  #8,%a0                  | restore %a0
 111        printx  PCONV,%a0@
 112        printf  PCONV,")\n"
 113        rts
 114        | source is zero
 115fp_l2e_zero:
 116        clr.l   (%a0)+
 117        clr.l   (%a0)+
 118        clr.l   (%a0)
 119        subq.l  #8,%a0
 120        printx  PCONV,%a0@
 121        printf  PCONV,")\n"
 122        rts
 123
 124        | fp_conv_single2ext
 125        | args: %d0 = source (single-precision fp value)
 126        |       %a0 = dest (struct fp_ext *)
 127
 128fp_conv_single2ext:
 129        printf  PCONV,"s2e: %p -> %p(",2,%d0,%a0
 130        move.l  %d0,%d1
 131        lsl.l   #8,%d0                  | shift mantissa
 132        lsr.l   #8,%d1                  | exponent / sign
 133        lsr.l   #7,%d1
 134        lsr.w   #8,%d1
 135        jeq     fp_s2e_small            | zero / denormal?
 136        cmp.w   #0xff,%d1               | NaN / Inf?
 137        jeq     fp_s2e_large
 138        bset    #31,%d0                 | set explizit bit
 139        add.w   #0x3fff-0x7f,%d1        | re-bias the exponent.
 1409:      move.l  %d1,(%a0)+              | fp_ext.sign, fp_ext.exp
 141        move.l  %d0,(%a0)+              | high lword of fp_ext.mant
 142        clr.l   (%a0)                   | low lword = 0
 143        subq.l  #8,%a0
 144        printx  PCONV,%a0@
 145        printf  PCONV,")\n"
 146        rts
 147        | zeros and denormalized
 148fp_s2e_small:
 149        | exponent is zero, so explizit bit is already zero too
 150        tst.l   %d0
 151        jeq     9b
 152        move.w  #0x4000-0x7f,%d1
 153        jra     9b
 154        | infinities and NAN
 155fp_s2e_large:
 156        bclr    #31,%d0                 | clear explizit bit
 157        move.w  #0x7fff,%d1
 158        jra     9b
 159
 160fp_conv_double2ext:
 161#ifdef FPU_EMU_DEBUG
 162        getuser.l %a1@(0),%d0,fp_err_ua2,%a1
 163        getuser.l %a1@(4),%d1,fp_err_ua2,%a1
 164        printf  PCONV,"d2e: %p%p -> %p(",3,%d0,%d1,%a0
 165#endif
 166        getuser.l (%a1)+,%d0,fp_err_ua2,%a1
 167        move.l  %d0,%d1
 168        lsl.l   #8,%d0                  | shift high mantissa
 169        lsl.l   #3,%d0
 170        lsr.l   #8,%d1                  | exponent / sign
 171        lsr.l   #7,%d1
 172        lsr.w   #5,%d1
 173        jeq     fp_d2e_small            | zero / denormal?
 174        cmp.w   #0x7ff,%d1              | NaN / Inf?
 175        jeq     fp_d2e_large
 176        bset    #31,%d0                 | set explizit bit
 177        add.w   #0x3fff-0x3ff,%d1       | re-bias the exponent.
 1789:      move.l  %d1,(%a0)+              | fp_ext.sign, fp_ext.exp
 179        move.l  %d0,(%a0)+
 180        getuser.l (%a1)+,%d0,fp_err_ua2,%a1
 181        move.l  %d0,%d1
 182        lsl.l   #8,%d0
 183        lsl.l   #3,%d0
 184        move.l  %d0,(%a0)
 185        moveq   #21,%d0
 186        lsr.l   %d0,%d1
 187        or.l    %d1,-(%a0)
 188        subq.l  #4,%a0
 189        printx  PCONV,%a0@
 190        printf  PCONV,")\n"
 191        rts
 192        | zeros and denormalized
 193fp_d2e_small:
 194        | exponent is zero, so explizit bit is already zero too
 195        tst.l   %d0
 196        jeq     9b
 197        move.w  #0x4000-0x3ff,%d1
 198        jra     9b
 199        | infinities and NAN
 200fp_d2e_large:
 201        bclr    #31,%d0                 | clear explizit bit
 202        move.w  #0x7fff,%d1
 203        jra     9b
 204
 205        | fp_conv_ext2ext:
 206        | originally used to get longdouble from userspace, now it's
 207        | called before arithmetic operations to make sure the number
 208        | is normalized [maybe rename it?].
 209        | args: %a0 = dest (struct fp_ext *)
 210        | returns 0 in %d0 for a NaN, otherwise 1
 211
 212fp_conv_ext2ext:
 213        printf  PCONV,"e2e: %p(",1,%a0
 214        printx  PCONV,%a0@
 215        printf  PCONV,"), "
 216        move.l  (%a0)+,%d0
 217        cmp.w   #0x7fff,%d0             | Inf / NaN?
 218        jeq     fp_e2e_large
 219        move.l  (%a0),%d0
 220        jpl     fp_e2e_small            | zero / denorm?
 221        | The high bit is set, so normalization is irrelevant.
 222fp_e2e_checkround:
 223        subq.l  #4,%a0
 224#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 225        move.b  (%a0),%d0
 226        jne     fp_e2e_round
 227#endif
 228        printf  PCONV,"%p(",1,%a0
 229        printx  PCONV,%a0@
 230        printf  PCONV,")\n"
 231        moveq   #1,%d0
 232        rts
 233#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 234fp_e2e_round:
 235        fp_set_sr FPSR_EXC_INEX2
 236        clr.b   (%a0)
 237        move.w  (FPD_RND,FPDATA),%d2
 238        jne     fp_e2e_roundother       | %d2 == 0, round to nearest
 239        tst.b   %d0                     | test guard bit
 240        jpl     9f                      | zero is closer
 241        btst    #0,(11,%a0)             | test lsb bit
 242        jne     fp_e2e_doroundup        | round to infinity
 243        lsl.b   #1,%d0                  | check low bits
 244        jeq     9f                      | round to zero
 245fp_e2e_doroundup:
 246        addq.l  #1,(8,%a0)
 247        jcc     9f
 248        addq.l  #1,(4,%a0)
 249        jcc     9f
 250        move.w  #0x8000,(4,%a0)
 251        addq.w  #1,(2,%a0)
 2529:      printf  PNORM,"%p(",1,%a0
 253        printx  PNORM,%a0@
 254        printf  PNORM,")\n"
 255        rts
 256fp_e2e_roundother:
 257        subq.w  #2,%d2
 258        jcs     9b                      | %d2 < 2, round to zero
 259        jhi     1f                      | %d2 > 2, round to +infinity
 260        tst.b   (1,%a0)                 | to -inf
 261        jne     fp_e2e_doroundup        | negative, round to infinity
 262        jra     9b                      | positive, round to zero
 2631:      tst.b   (1,%a0)                 | to +inf
 264        jeq     fp_e2e_doroundup        | positive, round to infinity
 265        jra     9b                      | negative, round to zero
 266#endif
 267        | zeros and subnormals:
 268        | try to normalize these anyway.
 269fp_e2e_small:
 270        jne     fp_e2e_small1           | high lword zero?
 271        move.l  (4,%a0),%d0
 272        jne     fp_e2e_small2
 273#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 274        clr.l   %d0
 275        move.b  (-4,%a0),%d0
 276        jne     fp_e2e_small3
 277#endif
 278        | Genuine zero.
 279        clr.w   -(%a0)
 280        subq.l  #2,%a0
 281        printf  PNORM,"%p(",1,%a0
 282        printx  PNORM,%a0@
 283        printf  PNORM,")\n"
 284        moveq   #1,%d0
 285        rts
 286        | definitely subnormal, need to shift all 64 bits
 287fp_e2e_small1:
 288        bfffo   %d0{#0,#32},%d1
 289        move.w  -(%a0),%d2
 290        sub.w   %d1,%d2
 291        jcc     1f
 292        | Pathologically small, denormalize.
 293        add.w   %d2,%d1
 294        clr.w   %d2
 2951:      move.w  %d2,(%a0)+
 296        move.w  %d1,%d2
 297        jeq     fp_e2e_checkround
 298        | fancy 64-bit double-shift begins here
 299        lsl.l   %d2,%d0
 300        move.l  %d0,(%a0)+
 301        move.l  (%a0),%d0
 302        move.l  %d0,%d1
 303        lsl.l   %d2,%d0
 304        move.l  %d0,(%a0)
 305        neg.w   %d2
 306        and.w   #0x1f,%d2
 307        lsr.l   %d2,%d1
 308        or.l    %d1,-(%a0)
 309#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 310fp_e2e_extra1:
 311        clr.l   %d0
 312        move.b  (-4,%a0),%d0
 313        neg.w   %d2
 314        add.w   #24,%d2
 315        jcc     1f
 316        clr.b   (-4,%a0)
 317        lsl.l   %d2,%d0
 318        or.l    %d0,(4,%a0)
 319        jra     fp_e2e_checkround
 3201:      addq.w  #8,%d2
 321        lsl.l   %d2,%d0
 322        move.b  %d0,(-4,%a0)
 323        lsr.l   #8,%d0
 324        or.l    %d0,(4,%a0)
 325#endif
 326        jra     fp_e2e_checkround
 327        | pathologically small subnormal
 328fp_e2e_small2:
 329        bfffo   %d0{#0,#32},%d1
 330        add.w   #32,%d1
 331        move.w  -(%a0),%d2
 332        sub.w   %d1,%d2
 333        jcc     1f
 334        | Beyond pathologically small, denormalize.
 335        add.w   %d2,%d1
 336        clr.w   %d2
 3371:      move.w  %d2,(%a0)+
 338        ext.l   %d1
 339        jeq     fp_e2e_checkround
 340        clr.l   (4,%a0)
 341        sub.w   #32,%d2
 342        jcs     1f
 343        lsl.l   %d1,%d0                 | lower lword needs only to be shifted
 344        move.l  %d0,(%a0)               | into the higher lword
 345#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 346        clr.l   %d0
 347        move.b  (-4,%a0),%d0
 348        clr.b   (-4,%a0)
 349        neg.w   %d1
 350        add.w   #32,%d1
 351        bfins   %d0,(%a0){%d1,#8}
 352#endif
 353        jra     fp_e2e_checkround
 3541:      neg.w   %d1                     | lower lword is splitted between
 355        bfins   %d0,(%a0){%d1,#32}      | higher and lower lword
 356#ifndef CONFIG_M68KFPU_EMU_EXTRAPREC
 357        jra     fp_e2e_checkround
 358#else
 359        move.w  %d1,%d2
 360        jra     fp_e2e_extra1
 361        | These are extremely small numbers, that will mostly end up as zero
 362        | anyway, so this is only important for correct rounding.
 363fp_e2e_small3:
 364        bfffo   %d0{#24,#8},%d1
 365        add.w   #40,%d1
 366        move.w  -(%a0),%d2
 367        sub.w   %d1,%d2
 368        jcc     1f
 369        | Pathologically small, denormalize.
 370        add.w   %d2,%d1
 371        clr.w   %d2
 3721:      move.w  %d2,(%a0)+
 373        ext.l   %d1
 374        jeq     fp_e2e_checkround
 375        cmp.w   #8,%d1
 376        jcs     2f
 3771:      clr.b   (-4,%a0)
 378        sub.w   #64,%d1
 379        jcs     1f
 380        add.w   #24,%d1
 381        lsl.l   %d1,%d0
 382        move.l  %d0,(%a0)
 383        jra     fp_e2e_checkround
 3841:      neg.w   %d1
 385        bfins   %d0,(%a0){%d1,#8}
 386        jra     fp_e2e_checkround
 3872:      lsl.l   %d1,%d0
 388        move.b  %d0,(-4,%a0)
 389        lsr.l   #8,%d0
 390        move.b  %d0,(7,%a0)
 391        jra     fp_e2e_checkround
 392#endif
 3931:      move.l  %d0,%d1                 | lower lword is splitted between
 394        lsl.l   %d2,%d0                 | higher and lower lword
 395        move.l  %d0,(%a0)
 396        move.l  %d1,%d0
 397        neg.w   %d2
 398        add.w   #32,%d2
 399        lsr.l   %d2,%d0
 400        move.l  %d0,-(%a0)
 401        jra     fp_e2e_checkround
 402        | Infinities and NaNs
 403fp_e2e_large:
 404        move.l  (%a0)+,%d0
 405        jne     3f
 4061:      tst.l   (%a0)
 407        jne     4f
 408        moveq   #1,%d0
 4092:      subq.l  #8,%a0
 410        printf  PCONV,"%p(",1,%a0
 411        printx  PCONV,%a0@
 412        printf  PCONV,")\n"
 413        rts
 414        | we have maybe a NaN, shift off the highest bit
 4153:      lsl.l   #1,%d0
 416        jeq     1b
 417        | we have a NaN, clear the return value
 4184:      clrl    %d0
 419        jra     2b
 420
 421
 422/*
 423 * Normalization functions.  Call these on the output of general
 424 * FP operators, and before any conversion into the destination
 425 * formats. fp_normalize_ext has always to be called first, the
 426 * following conversion functions expect an already normalized
 427 * number.
 428 */
 429
 430        | fp_normalize_ext:
 431        | normalize an extended in extended (unpacked) format, basically
 432        | it does the same as fp_conv_ext2ext, additionally it also does
 433        | the necessary postprocessing checks.
 434        | args: %a0 (struct fp_ext *)
 435        | NOTE: it does _not_ modify %a0/%a1 and the upper word of %d2
 436
 437fp_normalize_ext:
 438        printf  PNORM,"ne: %p(",1,%a0
 439        printx  PNORM,%a0@
 440        printf  PNORM,"), "
 441        move.l  (%a0)+,%d0
 442        cmp.w   #0x7fff,%d0             | Inf / NaN?
 443        jeq     fp_ne_large
 444        move.l  (%a0),%d0
 445        jpl     fp_ne_small             | zero / denorm?
 446        | The high bit is set, so normalization is irrelevant.
 447fp_ne_checkround:
 448        subq.l  #4,%a0
 449#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 450        move.b  (%a0),%d0
 451        jne     fp_ne_round
 452#endif
 453        printf  PNORM,"%p(",1,%a0
 454        printx  PNORM,%a0@
 455        printf  PNORM,")\n"
 456        rts
 457#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 458fp_ne_round:
 459        fp_set_sr FPSR_EXC_INEX2
 460        clr.b   (%a0)
 461        move.w  (FPD_RND,FPDATA),%d2
 462        jne     fp_ne_roundother        | %d2 == 0, round to nearest
 463        tst.b   %d0                     | test guard bit
 464        jpl     9f                      | zero is closer
 465        btst    #0,(11,%a0)             | test lsb bit
 466        jne     fp_ne_doroundup         | round to infinity
 467        lsl.b   #1,%d0                  | check low bits
 468        jeq     9f                      | round to zero
 469fp_ne_doroundup:
 470        addq.l  #1,(8,%a0)
 471        jcc     9f
 472        addq.l  #1,(4,%a0)
 473        jcc     9f
 474        addq.w  #1,(2,%a0)
 475        move.w  #0x8000,(4,%a0)
 4769:      printf  PNORM,"%p(",1,%a0
 477        printx  PNORM,%a0@
 478        printf  PNORM,")\n"
 479        rts
 480fp_ne_roundother:
 481        subq.w  #2,%d2
 482        jcs     9b                      | %d2 < 2, round to zero
 483        jhi     1f                      | %d2 > 2, round to +infinity
 484        tst.b   (1,%a0)                 | to -inf
 485        jne     fp_ne_doroundup         | negative, round to infinity
 486        jra     9b                      | positive, round to zero
 4871:      tst.b   (1,%a0)                 | to +inf
 488        jeq     fp_ne_doroundup         | positive, round to infinity
 489        jra     9b                      | negative, round to zero
 490#endif
 491        | Zeros and subnormal numbers
 492        | These are probably merely subnormal, rather than "denormalized"
 493        |  numbers, so we will try to make them normal again.
 494fp_ne_small:
 495        jne     fp_ne_small1            | high lword zero?
 496        move.l  (4,%a0),%d0
 497        jne     fp_ne_small2
 498#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 499        clr.l   %d0
 500        move.b  (-4,%a0),%d0
 501        jne     fp_ne_small3
 502#endif
 503        | Genuine zero.
 504        clr.w   -(%a0)
 505        subq.l  #2,%a0
 506        printf  PNORM,"%p(",1,%a0
 507        printx  PNORM,%a0@
 508        printf  PNORM,")\n"
 509        rts
 510        | Subnormal.
 511fp_ne_small1:
 512        bfffo   %d0{#0,#32},%d1
 513        move.w  -(%a0),%d2
 514        sub.w   %d1,%d2
 515        jcc     1f
 516        | Pathologically small, denormalize.
 517        add.w   %d2,%d1
 518        clr.w   %d2
 519        fp_set_sr FPSR_EXC_UNFL
 5201:      move.w  %d2,(%a0)+
 521        move.w  %d1,%d2
 522        jeq     fp_ne_checkround
 523        | This is exactly the same 64-bit double shift as seen above.
 524        lsl.l   %d2,%d0
 525        move.l  %d0,(%a0)+
 526        move.l  (%a0),%d0
 527        move.l  %d0,%d1
 528        lsl.l   %d2,%d0
 529        move.l  %d0,(%a0)
 530        neg.w   %d2
 531        and.w   #0x1f,%d2
 532        lsr.l   %d2,%d1
 533        or.l    %d1,-(%a0)
 534#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 535fp_ne_extra1:
 536        clr.l   %d0
 537        move.b  (-4,%a0),%d0
 538        neg.w   %d2
 539        add.w   #24,%d2
 540        jcc     1f
 541        clr.b   (-4,%a0)
 542        lsl.l   %d2,%d0
 543        or.l    %d0,(4,%a0)
 544        jra     fp_ne_checkround
 5451:      addq.w  #8,%d2
 546        lsl.l   %d2,%d0
 547        move.b  %d0,(-4,%a0)
 548        lsr.l   #8,%d0
 549        or.l    %d0,(4,%a0)
 550#endif
 551        jra     fp_ne_checkround
 552        | May or may not be subnormal, if so, only 32 bits to shift.
 553fp_ne_small2:
 554        bfffo   %d0{#0,#32},%d1
 555        add.w   #32,%d1
 556        move.w  -(%a0),%d2
 557        sub.w   %d1,%d2
 558        jcc     1f
 559        | Beyond pathologically small, denormalize.
 560        add.w   %d2,%d1
 561        clr.w   %d2
 562        fp_set_sr FPSR_EXC_UNFL
 5631:      move.w  %d2,(%a0)+
 564        ext.l   %d1
 565        jeq     fp_ne_checkround
 566        clr.l   (4,%a0)
 567        sub.w   #32,%d1
 568        jcs     1f
 569        lsl.l   %d1,%d0                 | lower lword needs only to be shifted
 570        move.l  %d0,(%a0)               | into the higher lword
 571#ifdef CONFIG_M68KFPU_EMU_EXTRAPREC
 572        clr.l   %d0
 573        move.b  (-4,%a0),%d0
 574        clr.b   (-4,%a0)
 575        neg.w   %d1
 576        add.w   #32,%d1
 577        bfins   %d0,(%a0){%d1,#8}
 578#endif
 579        jra     fp_ne_checkround
 5801:      neg.w   %d1                     | lower lword is splitted between
 581        bfins   %d0,(%a0){%d1,#32}      | higher and lower lword
 582#ifndef CONFIG_M68KFPU_EMU_EXTRAPREC
 583        jra     fp_ne_checkround
 584#else
 585        move.w  %d1,%d2
 586        jra     fp_ne_extra1
 587        | These are extremely small numbers, that will mostly end up as zero
 588        | anyway, so this is only important for correct rounding.
 589fp_ne_small3:
 590        bfffo   %d0{#24,#8},%d1
 591        add.w   #40,%d1
 592        move.w  -(%a0),%d2
 593        sub.w   %d1,%d2
 594        jcc     1f
 595        | Pathologically small, denormalize.
 596        add.w   %d2,%d1
 597        clr.w   %d2
 5981:      move.w  %d2,(%a0)+
 599        ext.l   %d1
 600        jeq     fp_ne_checkround
 601        cmp.w   #8,%d1
 602        jcs     2f
 6031:      clr.b   (-4,%a0)
 604        sub.w   #64,%d1
 605        jcs     1f
 606        add.w   #24,%d1
 607        lsl.l   %d1,%d0
 608        move.l  %d0,(%a0)
 609        jra     fp_ne_checkround
 6101:      neg.w   %d1
 611        bfins   %d0,(%a0){%d1,#8}
 612        jra     fp_ne_checkround
 6132:      lsl.l   %d1,%d0
 614        move.b  %d0,(-4,%a0)
 615        lsr.l   #8,%d0
 616        move.b  %d0,(7,%a0)
 617        jra     fp_ne_checkround
 618#endif
 619        | Infinities and NaNs, again, same as above.
 620fp_ne_large:
 621        move.l  (%a0)+,%d0
 622        jne     3f
 6231:      tst.l   (%a0)
 624        jne     4f
 6252:      subq.l  #8,%a0
 626        printf  PNORM,"%p(",1,%a0
 627        printx  PNORM,%a0@
 628        printf  PNORM,")\n"
 629        rts
 630        | we have maybe a NaN, shift off the highest bit
 6313:      move.l  %d0,%d1
 632        lsl.l   #1,%d1
 633        jne     4f
 634        clr.l   (-4,%a0)
 635        jra     1b
 636        | we have a NaN, test if it is signaling
 6374:      bset    #30,%d0
 638        jne     2b
 639        fp_set_sr FPSR_EXC_SNAN
 640        move.l  %d0,(-4,%a0)
 641        jra     2b
 642
 643        | these next two do rounding as per the IEEE standard.
 644        | values for the rounding modes appear to be:
 645        | 0:    Round to nearest
 646        | 1:    Round to zero
 647        | 2:    Round to -Infinity
 648        | 3:    Round to +Infinity
 649        | both functions expect that fp_normalize was already
 650        | called (and extended argument is already normalized
 651        | as far as possible), these are used if there is different
 652        | rounding precision is selected and before converting
 653        | into single/double
 654
 655        | fp_normalize_double:
 656        | normalize an extended with double (52-bit) precision
 657        | args:  %a0 (struct fp_ext *)
 658
 659fp_normalize_double:
 660        printf  PNORM,"nd: %p(",1,%a0
 661        printx  PNORM,%a0@
 662        printf  PNORM,"), "
 663        move.l  (%a0)+,%d2
 664        tst.w   %d2
 665        jeq     fp_nd_zero              | zero / denormalized
 666        cmp.w   #0x7fff,%d2
 667        jeq     fp_nd_huge              | NaN / infinitive.
 668        sub.w   #0x4000-0x3ff,%d2       | will the exponent fit?
 669        jcs     fp_nd_small             | too small.
 670        cmp.w   #0x7fe,%d2
 671        jcc     fp_nd_large             | too big.
 672        addq.l  #4,%a0
 673        move.l  (%a0),%d0               | low lword of mantissa
 674        | now, round off the low 11 bits.
 675fp_nd_round:
 676        moveq   #21,%d1
 677        lsl.l   %d1,%d0                 | keep 11 low bits.
 678        jne     fp_nd_checkround        | Are they non-zero?
 679        | nothing to do here
 6809:      subq.l  #8,%a0
 681        printf  PNORM,"%p(",1,%a0
 682        printx  PNORM,%a0@
 683        printf  PNORM,")\n"
 684        rts
 685        | Be careful with the X bit! It contains the lsb
 686        | from the shift above, it is needed for round to nearest.
 687fp_nd_checkround:
 688        fp_set_sr FPSR_EXC_INEX2        | INEX2 bit
 689        and.w   #0xf800,(2,%a0)         | clear bits 0-10
 690        move.w  (FPD_RND,FPDATA),%d2    | rounding mode
 691        jne     2f                      | %d2 == 0, round to nearest
 692        tst.l   %d0                     | test guard bit
 693        jpl     9b                      | zero is closer
 694        | here we test the X bit by adding it to %d2
 695        clr.w   %d2                     | first set z bit, addx only clears it
 696        addx.w  %d2,%d2                 | test lsb bit
 697        | IEEE754-specified "round to even" behaviour.  If the guard
 698        | bit is set, then the number is odd, so rounding works like
 699        | in grade-school arithmetic (i.e. 1.5 rounds to 2.0)
 700        | Otherwise, an equal distance rounds towards zero, so as not
 701        | to produce an odd number.  This is strange, but it is what
 702        | the standard says.
 703        jne     fp_nd_doroundup         | round to infinity
 704        lsl.l   #1,%d0                  | check low bits
 705        jeq     9b                      | round to zero
 706fp_nd_doroundup:
 707        | round (the mantissa, that is) towards infinity
 708        add.l   #0x800,(%a0)
 709        jcc     9b                      | no overflow, good.
 710        addq.l  #1,-(%a0)               | extend to high lword
 711        jcc     1f                      | no overflow, good.
 712        | Yow! we have managed to overflow the mantissa.  Since this
 713        | only happens when %d1 was 0xfffff800, it is now zero, so
 714        | reset the high bit, and increment the exponent.
 715        move.w  #0x8000,(%a0)
 716        addq.w  #1,-(%a0)
 717        cmp.w   #0x43ff,(%a0)+          | exponent now overflown?
 718        jeq     fp_nd_large             | yes, so make it infinity.
 7191:      subq.l  #4,%a0
 720        printf  PNORM,"%p(",1,%a0
 721        printx  PNORM,%a0@
 722        printf  PNORM,")\n"
 723        rts
 7242:      subq.w  #2,%d2
 725        jcs     9b                      | %d2 < 2, round to zero
 726        jhi     3f                      | %d2 > 2, round to +infinity
 727        | Round to +Inf or -Inf.  High word of %d2 contains the
 728        | sign of the number, by the way.
 729        swap    %d2                     | to -inf
 730        tst.b   %d2
 731        jne     fp_nd_doroundup         | negative, round to infinity
 732        jra     9b                      | positive, round to zero
 7333:      swap    %d2                     | to +inf
 734        tst.b   %d2
 735        jeq     fp_nd_doroundup         | positive, round to infinity
 736        jra     9b                      | negative, round to zero
 737        | Exponent underflow.  Try to make a denormal, and set it to
 738        | the smallest possible fraction if this fails.
 739fp_nd_small:
 740        fp_set_sr FPSR_EXC_UNFL         | set UNFL bit
 741        move.w  #0x3c01,(-2,%a0)        | 2**-1022
 742        neg.w   %d2                     | degree of underflow
 743        cmp.w   #32,%d2                 | single or double shift?
 744        jcc     1f
 745        | Again, another 64-bit double shift.
 746        move.l  (%a0),%d0
 747        move.l  %d0,%d1
 748        lsr.l   %d2,%d0
 749        move.l  %d0,(%a0)+
 750        move.l  (%a0),%d0
 751        lsr.l   %d2,%d0
 752        neg.w   %d2
 753        add.w   #32,%d2
 754        lsl.l   %d2,%d1
 755        or.l    %d1,%d0
 756        move.l  (%a0),%d1
 757        move.l  %d0,(%a0)
 758        | Check to see if we shifted off any significant bits
 759        lsl.l   %d2,%d1
 760        jeq     fp_nd_round             | Nope, round.
 761        bset    #0,%d0                  | Yes, so set the "sticky bit".
 762        jra     fp_nd_round             | Now, round.
 763        | Another 64-bit single shift and store
 7641:      sub.w   #32,%d2
 765        cmp.w   #32,%d2                 | Do we really need to shift?
 766        jcc     2f                      | No, the number is too small.
 767        move.l  (%a0),%d0
 768        clr.l   (%a0)+
 769        move.l  %d0,%d1
 770        lsr.l   %d2,%d0
 771        neg.w   %d2
 772        add.w   #32,%d2
 773        | Again, check to see if we shifted off any significant bits.
 774        tst.l   (%a0)
 775        jeq     1f
 776        bset    #0,%d0                  | Sticky bit.
 7771:      move.l  %d0,(%a0)
 778        lsl.l   %d2,%d1
 779        jeq     fp_nd_round
 780        bset    #0,%d0
 781        jra     fp_nd_round
 782        | Sorry, the number is just too small.
 7832:      clr.l   (%a0)+
 784        clr.l   (%a0)
 785        moveq   #1,%d0                  | Smallest possible fraction,
 786        jra     fp_nd_round             | round as desired.
 787        | zero and denormalized
 788fp_nd_zero:
 789        tst.l   (%a0)+
 790        jne     1f
 791        tst.l   (%a0)
 792        jne     1f
 793        subq.l  #8,%a0
 794        printf  PNORM,"%p(",1,%a0
 795        printx  PNORM,%a0@
 796        printf  PNORM,")\n"
 797        rts                             | zero.  nothing to do.
 798        | These are not merely subnormal numbers, but true denormals,
 799        | i.e. pathologically small (exponent is 2**-16383) numbers.
 800        | It is clearly impossible for even a normal extended number
 801        | with that exponent to fit into double precision, so just
 802        | write these ones off as "too darn small".
 8031:      fp_set_sr FPSR_EXC_UNFL         | Set UNFL bit
 804        clr.l   (%a0)
 805        clr.l   -(%a0)
 806        move.w  #0x3c01,-(%a0)          | i.e. 2**-1022
 807        addq.l  #6,%a0
 808        moveq   #1,%d0
 809        jra     fp_nd_round             | round.
 810        | Exponent overflow.  Just call it infinity.
 811fp_nd_large:
 812        move.w  #0x7ff,%d0
 813        and.w   (6,%a0),%d0
 814        jeq     1f
 815        fp_set_sr FPSR_EXC_INEX2
 8161:      fp_set_sr FPSR_EXC_OVFL
 817        move.w  (FPD_RND,FPDATA),%d2
 818        jne     3f                      | %d2 = 0 round to nearest
 8191:      move.w  #0x7fff,(-2,%a0)
 820        clr.l   (%a0)+
 821        clr.l   (%a0)
 8222:      subq.l  #8,%a0
 823        printf  PNORM,"%p(",1,%a0
 824        printx  PNORM,%a0@
 825        printf  PNORM,")\n"
 826        rts
 8273:      subq.w  #2,%d2
 828        jcs     5f                      | %d2 < 2, round to zero
 829        jhi     4f                      | %d2 > 2, round to +infinity
 830        tst.b   (-3,%a0)                | to -inf
 831        jne     1b
 832        jra     5f
 8334:      tst.b   (-3,%a0)                | to +inf
 834        jeq     1b
 8355:      move.w  #0x43fe,(-2,%a0)
 836        moveq   #-1,%d0
 837        move.l  %d0,(%a0)+
 838        move.w  #0xf800,%d0
 839        move.l  %d0,(%a0)
 840        jra     2b
 841        | Infinities or NaNs
 842fp_nd_huge:
 843        subq.l  #4,%a0
 844        printf  PNORM,"%p(",1,%a0
 845        printx  PNORM,%a0@
 846        printf  PNORM,")\n"
 847        rts
 848
 849        | fp_normalize_single:
 850        | normalize an extended with single (23-bit) precision
 851        | args:  %a0 (struct fp_ext *)
 852
 853fp_normalize_single:
 854        printf  PNORM,"ns: %p(",1,%a0
 855        printx  PNORM,%a0@
 856        printf  PNORM,") "
 857        addq.l  #2,%a0
 858        move.w  (%a0)+,%d2
 859        jeq     fp_ns_zero              | zero / denormalized
 860        cmp.w   #0x7fff,%d2
 861        jeq     fp_ns_huge              | NaN / infinitive.
 862        sub.w   #0x4000-0x7f,%d2        | will the exponent fit?
 863        jcs     fp_ns_small             | too small.
 864        cmp.w   #0xfe,%d2
 865        jcc     fp_ns_large             | too big.
 866        move.l  (%a0)+,%d0              | get high lword of mantissa
 867fp_ns_round:
 868        tst.l   (%a0)                   | check the low lword
 869        jeq     1f
 870        | Set a sticky bit if it is non-zero.  This should only
 871        | affect the rounding in what would otherwise be equal-
 872        | distance situations, which is what we want it to do.
 873        bset    #0,%d0
 8741:      clr.l   (%a0)                   | zap it from memory.
 875        | now, round off the low 8 bits of the hi lword.
 876        tst.b   %d0                     | 8 low bits.
 877        jne     fp_ns_checkround        | Are they non-zero?
 878        | nothing to do here
 879        subq.l  #8,%a0
 880        printf  PNORM,"%p(",1,%a0
 881        printx  PNORM,%a0@
 882        printf  PNORM,")\n"
 883        rts
 884fp_ns_checkround:
 885        fp_set_sr FPSR_EXC_INEX2        | INEX2 bit
 886        clr.b   -(%a0)                  | clear low byte of high lword
 887        subq.l  #3,%a0
 888        move.w  (FPD_RND,FPDATA),%d2    | rounding mode
 889        jne     2f                      | %d2 == 0, round to nearest
 890        tst.b   %d0                     | test guard bit
 891        jpl     9f                      | zero is closer
 892        btst    #8,%d0                  | test lsb bit
 893        | round to even behaviour, see above.
 894        jne     fp_ns_doroundup         | round to infinity
 895        lsl.b   #1,%d0                  | check low bits
 896        jeq     9f                      | round to zero
 897fp_ns_doroundup:
 898        | round (the mantissa, that is) towards infinity
 899        add.l   #0x100,(%a0)
 900        jcc     9f                      | no overflow, good.
 901        | Overflow.  This means that the %d1 was 0xffffff00, so it
 902        | is now zero.  We will set the mantissa to reflect this, and
 903        | increment the exponent (checking for overflow there too)
 904        move.w  #0x8000,(%a0)
 905        addq.w  #1,-(%a0)
 906        cmp.w   #0x407f,(%a0)+          | exponent now overflown?
 907        jeq     fp_ns_large             | yes, so make it infinity.
 9089:      subq.l  #4,%a0
 909        printf  PNORM,"%p(",1,%a0
 910        printx  PNORM,%a0@
 911        printf  PNORM,")\n"
 912        rts
 913        | check nondefault rounding modes
 9142:      subq.w  #2,%d2
 915        jcs     9b                      | %d2 < 2, round to zero
 916        jhi     3f                      | %d2 > 2, round to +infinity
 917        tst.b   (-3,%a0)                | to -inf
 918        jne     fp_ns_doroundup         | negative, round to infinity
 919        jra     9b                      | positive, round to zero
 9203:      tst.b   (-3,%a0)                | to +inf
 921        jeq     fp_ns_doroundup         | positive, round to infinity
 922        jra     9b                      | negative, round to zero
 923        | Exponent underflow.  Try to make a denormal, and set it to
 924        | the smallest possible fraction if this fails.
 925fp_ns_small:
 926        fp_set_sr FPSR_EXC_UNFL         | set UNFL bit
 927        move.w  #0x3f81,(-2,%a0)        | 2**-126
 928        neg.w   %d2                     | degree of underflow
 929        cmp.w   #32,%d2                 | single or double shift?
 930        jcc     2f
 931        | a 32-bit shift.
 932        move.l  (%a0),%d0
 933        move.l  %d0,%d1
 934        lsr.l   %d2,%d0
 935        move.l  %d0,(%a0)+
 936        | Check to see if we shifted off any significant bits.
 937        neg.w   %d2
 938        add.w   #32,%d2
 939        lsl.l   %d2,%d1
 940        jeq     1f
 941        bset    #0,%d0                  | Sticky bit.
 942        | Check the lower lword
 9431:      tst.l   (%a0)
 944        jeq     fp_ns_round
 945        clr     (%a0)
 946        bset    #0,%d0                  | Sticky bit.
 947        jra     fp_ns_round
 948        | Sorry, the number is just too small.
 9492:      clr.l   (%a0)+
 950        clr.l   (%a0)
 951        moveq   #1,%d0                  | Smallest possible fraction,
 952        jra     fp_ns_round             | round as desired.
 953        | Exponent overflow.  Just call it infinity.
 954fp_ns_large:
 955        tst.b   (3,%a0)
 956        jeq     1f
 957        fp_set_sr FPSR_EXC_INEX2
 9581:      fp_set_sr FPSR_EXC_OVFL
 959        move.w  (FPD_RND,FPDATA),%d2
 960        jne     3f                      | %d2 = 0 round to nearest
 9611:      move.w  #0x7fff,(-2,%a0)
 962        clr.l   (%a0)+
 963        clr.l   (%a0)
 9642:      subq.l  #8,%a0
 965        printf  PNORM,"%p(",1,%a0
 966        printx  PNORM,%a0@
 967        printf  PNORM,")\n"
 968        rts
 9693:      subq.w  #2,%d2
 970        jcs     5f                      | %d2 < 2, round to zero
 971        jhi     4f                      | %d2 > 2, round to +infinity
 972        tst.b   (-3,%a0)                | to -inf
 973        jne     1b
 974        jra     5f
 9754:      tst.b   (-3,%a0)                | to +inf
 976        jeq     1b
 9775:      move.w  #0x407e,(-2,%a0)
 978        move.l  #0xffffff00,(%a0)+
 979        clr.l   (%a0)
 980        jra     2b
 981        | zero and denormalized
 982fp_ns_zero:
 983        tst.l   (%a0)+
 984        jne     1f
 985        tst.l   (%a0)
 986        jne     1f
 987        subq.l  #8,%a0
 988        printf  PNORM,"%p(",1,%a0
 989        printx  PNORM,%a0@
 990        printf  PNORM,")\n"
 991        rts                             | zero.  nothing to do.
 992        | These are not merely subnormal numbers, but true denormals,
 993        | i.e. pathologically small (exponent is 2**-16383) numbers.
 994        | It is clearly impossible for even a normal extended number
 995        | with that exponent to fit into single precision, so just
 996        | write these ones off as "too darn small".
 9971:      fp_set_sr FPSR_EXC_UNFL         | Set UNFL bit
 998        clr.l   (%a0)
 999        clr.l   -(%a0)
1000        move.w  #0x3f81,-(%a0)          | i.e. 2**-126
1001        addq.l  #6,%a0
1002        moveq   #1,%d0
1003        jra     fp_ns_round             | round.
1004        | Infinities or NaNs
1005fp_ns_huge:
1006        subq.l  #4,%a0
1007        printf  PNORM,"%p(",1,%a0
1008        printx  PNORM,%a0@
1009        printf  PNORM,")\n"
1010        rts
1011
1012        | fp_normalize_single_fast:
1013        | normalize an extended with single (23-bit) precision
1014        | this is only used by fsgldiv/fsgdlmul, where the
1015        | operand is not completly normalized.
1016        | args:  %a0 (struct fp_ext *)
1017
1018fp_normalize_single_fast:
1019        printf  PNORM,"nsf: %p(",1,%a0
1020        printx  PNORM,%a0@
1021        printf  PNORM,") "
1022        addq.l  #2,%a0
1023        move.w  (%a0)+,%d2
1024        cmp.w   #0x7fff,%d2
1025        jeq     fp_nsf_huge             | NaN / infinitive.
1026        move.l  (%a0)+,%d0              | get high lword of mantissa
1027fp_nsf_round:
1028        tst.l   (%a0)                   | check the low lword
1029        jeq     1f
1030        | Set a sticky bit if it is non-zero.  This should only
1031        | affect the rounding in what would otherwise be equal-
1032        | distance situations, which is what we want it to do.
1033        bset    #0,%d0
10341:      clr.l   (%a0)                   | zap it from memory.
1035        | now, round off the low 8 bits of the hi lword.
1036        tst.b   %d0                     | 8 low bits.
1037        jne     fp_nsf_checkround       | Are they non-zero?
1038        | nothing to do here
1039        subq.l  #8,%a0
1040        printf  PNORM,"%p(",1,%a0
1041        printx  PNORM,%a0@
1042        printf  PNORM,")\n"
1043        rts
1044fp_nsf_checkround:
1045        fp_set_sr FPSR_EXC_INEX2        | INEX2 bit
1046        clr.b   -(%a0)                  | clear low byte of high lword
1047        subq.l  #3,%a0
1048        move.w  (FPD_RND,FPDATA),%d2    | rounding mode
1049        jne     2f                      | %d2 == 0, round to nearest
1050        tst.b   %d0                     | test guard bit
1051        jpl     9f                      | zero is closer
1052        btst    #8,%d0                  | test lsb bit
1053        | round to even behaviour, see above.
1054        jne     fp_nsf_doroundup                | round to infinity
1055        lsl.b   #1,%d0                  | check low bits
1056        jeq     9f                      | round to zero
1057fp_nsf_doroundup:
1058        | round (the mantissa, that is) towards infinity
1059        add.l   #0x100,(%a0)
1060        jcc     9f                      | no overflow, good.
1061        | Overflow.  This means that the %d1 was 0xffffff00, so it
1062        | is now zero.  We will set the mantissa to reflect this, and
1063        | increment the exponent (checking for overflow there too)
1064        move.w  #0x8000,(%a0)
1065        addq.w  #1,-(%a0)
1066        cmp.w   #0x407f,(%a0)+          | exponent now overflown?
1067        jeq     fp_nsf_large            | yes, so make it infinity.
10689:      subq.l  #4,%a0
1069        printf  PNORM,"%p(",1,%a0
1070        printx  PNORM,%a0@
1071        printf  PNORM,")\n"
1072        rts
1073        | check nondefault rounding modes
10742:      subq.w  #2,%d2
1075        jcs     9b                      | %d2 < 2, round to zero
1076        jhi     3f                      | %d2 > 2, round to +infinity
1077        tst.b   (-3,%a0)                | to -inf
1078        jne     fp_nsf_doroundup        | negative, round to infinity
1079        jra     9b                      | positive, round to zero
10803:      tst.b   (-3,%a0)                | to +inf
1081        jeq     fp_nsf_doroundup                | positive, round to infinity
1082        jra     9b                      | negative, round to zero
1083        | Exponent overflow.  Just call it infinity.
1084fp_nsf_large:
1085        tst.b   (3,%a0)
1086        jeq     1f
1087        fp_set_sr FPSR_EXC_INEX2
10881:      fp_set_sr FPSR_EXC_OVFL
1089        move.w  (FPD_RND,FPDATA),%d2
1090        jne     3f                      | %d2 = 0 round to nearest
10911:      move.w  #0x7fff,(-2,%a0)
1092        clr.l   (%a0)+
1093        clr.l   (%a0)
10942:      subq.l  #8,%a0
1095        printf  PNORM,"%p(",1,%a0
1096        printx  PNORM,%a0@
1097        printf  PNORM,")\n"
1098        rts
10993:      subq.w  #2,%d2
1100        jcs     5f                      | %d2 < 2, round to zero
1101        jhi     4f                      | %d2 > 2, round to +infinity
1102        tst.b   (-3,%a0)                | to -inf
1103        jne     1b
1104        jra     5f
11054:      tst.b   (-3,%a0)                | to +inf
1106        jeq     1b
11075:      move.w  #0x407e,(-2,%a0)
1108        move.l  #0xffffff00,(%a0)+
1109        clr.l   (%a0)
1110        jra     2b
1111        | Infinities or NaNs
1112fp_nsf_huge:
1113        subq.l  #4,%a0
1114        printf  PNORM,"%p(",1,%a0
1115        printx  PNORM,%a0@
1116        printf  PNORM,")\n"
1117        rts
1118
1119        | conv_ext2int (macro):
1120        | Generates a subroutine that converts an extended value to an
1121        | integer of a given size, again, with the appropriate type of
1122        | rounding.
1123
1124        | Macro arguments:
1125        | s:    size, as given in an assembly instruction.
1126        | b:    number of bits in that size.
1127
1128        | Subroutine arguments:
1129        | %a0:  source (struct fp_ext *)
1130
1131        | Returns the integer in %d0 (like it should)
1132
1133.macro conv_ext2int s,b
1134        .set    inf,(1<<(\b-1))-1       | i.e. MAXINT
1135        printf  PCONV,"e2i%d: %p(",2,#\b,%a0
1136        printx  PCONV,%a0@
1137        printf  PCONV,") "
1138        addq.l  #2,%a0
1139        move.w  (%a0)+,%d2              | exponent
1140        jeq     fp_e2i_zero\b           | zero / denorm (== 0, here)
1141        cmp.w   #0x7fff,%d2
1142        jeq     fp_e2i_huge\b           | Inf / NaN
1143        sub.w   #0x3ffe,%d2
1144        jcs     fp_e2i_small\b
1145        cmp.w   #\b,%d2
1146        jhi     fp_e2i_large\b
1147        move.l  (%a0),%d0
1148        move.l  %d0,%d1
1149        lsl.l   %d2,%d1
1150        jne     fp_e2i_round\b
1151        tst.l   (4,%a0)
1152        jne     fp_e2i_round\b
1153        neg.w   %d2
1154        add.w   #32,%d2
1155        lsr.l   %d2,%d0
11569:      tst.w   (-4,%a0)
1157        jne     1f
1158        tst.\s  %d0
1159        jmi     fp_e2i_large\b
1160        printf  PCONV,"-> %p\n",1,%d0
1161        rts
11621:      neg.\s  %d0
1163        jeq     1f
1164        jpl     fp_e2i_large\b
11651:      printf  PCONV,"-> %p\n",1,%d0
1166        rts
1167fp_e2i_round\b:
1168        fp_set_sr FPSR_EXC_INEX2        | INEX2 bit
1169        neg.w   %d2
1170        add.w   #32,%d2
1171        .if     \b>16
1172        jeq     5f
1173        .endif
1174        lsr.l   %d2,%d0
1175        move.w  (FPD_RND,FPDATA),%d2    | rounding mode
1176        jne     2f                      | %d2 == 0, round to nearest
1177        tst.l   %d1                     | test guard bit
1178        jpl     9b                      | zero is closer
1179        btst    %d2,%d0                 | test lsb bit (%d2 still 0)
1180        jne     fp_e2i_doroundup\b
1181        lsl.l   #1,%d1                  | check low bits
1182        jne     fp_e2i_doroundup\b
1183        tst.l   (4,%a0)
1184        jeq     9b
1185fp_e2i_doroundup\b:
1186        addq.l  #1,%d0
1187        jra     9b
1188        | check nondefault rounding modes
11892:      subq.w  #2,%d2
1190        jcs     9b                      | %d2 < 2, round to zero
1191        jhi     3f                      | %d2 > 2, round to +infinity
1192        tst.w   (-4,%a0)                | to -inf
1193        jne     fp_e2i_doroundup\b      | negative, round to infinity
1194        jra     9b                      | positive, round to zero
11953:      tst.w   (-4,%a0)                | to +inf
1196        jeq     fp_e2i_doroundup\b      | positive, round to infinity
1197        jra     9b      | negative, round to zero
1198        | we are only want -2**127 get correctly rounded here,
1199        | since the guard bit is in the lower lword.
1200        | everything else ends up anyway as overflow.
1201        .if     \b>16
12025:      move.w  (FPD_RND,FPDATA),%d2    | rounding mode
1203        jne     2b                      | %d2 == 0, round to nearest
1204        move.l  (4,%a0),%d1             | test guard bit
1205        jpl     9b                      | zero is closer
1206        lsl.l   #1,%d1                  | check low bits
1207        jne     fp_e2i_doroundup\b
1208        jra     9b
1209        .endif
1210fp_e2i_zero\b:
1211        clr.l   %d0
1212        tst.l   (%a0)+
1213        jne     1f
1214        tst.l   (%a0)
1215        jeq     3f
12161:      subq.l  #4,%a0
1217        fp_clr_sr FPSR_EXC_UNFL         | fp_normalize_ext has set this bit
1218fp_e2i_small\b:
1219        fp_set_sr FPSR_EXC_INEX2
1220        clr.l   %d0
1221        move.w  (FPD_RND,FPDATA),%d2    | rounding mode
1222        subq.w  #2,%d2
1223        jcs     3f                      | %d2 < 2, round to nearest/zero
1224        jhi     2f                      | %d2 > 2, round to +infinity
1225        tst.w   (-4,%a0)                | to -inf
1226        jeq     3f
1227        subq.\s #1,%d0
1228        jra     3f
12292:      tst.w   (-4,%a0)                | to +inf
1230        jne     3f
1231        addq.\s #1,%d0
12323:      printf  PCONV,"-> %p\n",1,%d0
1233        rts
1234fp_e2i_large\b:
1235        fp_set_sr FPSR_EXC_OPERR
1236        move.\s #inf,%d0
1237        tst.w   (-4,%a0)
1238        jeq     1f
1239        addq.\s #1,%d0
12401:      printf  PCONV,"-> %p\n",1,%d0
1241        rts
1242fp_e2i_huge\b:
1243        move.\s (%a0),%d0
1244        tst.l   (%a0)
1245        jne     1f
1246        tst.l   (%a0)
1247        jeq     fp_e2i_large\b
1248        | fp_normalize_ext has set this bit already
1249        | and made the number nonsignaling
12501:      fp_tst_sr FPSR_EXC_SNAN
1251        jne     1f
1252        fp_set_sr FPSR_EXC_OPERR
12531:      printf  PCONV,"-> %p\n",1,%d0
1254        rts
1255.endm
1256
1257fp_conv_ext2long:
1258        conv_ext2int l,32
1259
1260fp_conv_ext2short:
1261        conv_ext2int w,16
1262
1263fp_conv_ext2byte:
1264        conv_ext2int b,8
1265
1266fp_conv_ext2double:
1267        jsr     fp_normalize_double
1268        printf  PCONV,"e2d: %p(",1,%a0
1269        printx  PCONV,%a0@
1270        printf  PCONV,"), "
1271        move.l  (%a0)+,%d2
1272        cmp.w   #0x7fff,%d2
1273        jne     1f
1274        move.w  #0x7ff,%d2
1275        move.l  (%a0)+,%d0
1276        jra     2f
12771:      sub.w   #0x3fff-0x3ff,%d2
1278        move.l  (%a0)+,%d0
1279        jmi     2f
1280        clr.w   %d2
12812:      lsl.w   #5,%d2
1282        lsl.l   #7,%d2
1283        lsl.l   #8,%d2
1284        move.l  %d0,%d1
1285        lsl.l   #1,%d0
1286        lsr.l   #4,%d0
1287        lsr.l   #8,%d0
1288        or.l    %d2,%d0
1289        putuser.l %d0,(%a1)+,fp_err_ua2,%a1
1290        moveq   #21,%d0
1291        lsl.l   %d0,%d1
1292        move.l  (%a0),%d0
1293        lsr.l   #4,%d0
1294        lsr.l   #7,%d0
1295        or.l    %d1,%d0
1296        putuser.l %d0,(%a1),fp_err_ua2,%a1
1297#ifdef FPU_EMU_DEBUG
1298        getuser.l %a1@(-4),%d0,fp_err_ua2,%a1
1299        getuser.l %a1@(0),%d1,fp_err_ua2,%a1
1300        printf  PCONV,"%p(%08x%08x)\n",3,%a1,%d0,%d1
1301#endif
1302        rts
1303
1304fp_conv_ext2single:
1305        jsr     fp_normalize_single
1306        printf  PCONV,"e2s: %p(",1,%a0
1307        printx  PCONV,%a0@
1308        printf  PCONV,"), "
1309        move.l  (%a0)+,%d1
1310        cmp.w   #0x7fff,%d1
1311        jne     1f
1312        move.w  #0xff,%d1
1313        move.l  (%a0)+,%d0
1314        jra     2f
13151:      sub.w   #0x3fff-0x7f,%d1
1316        move.l  (%a0)+,%d0
1317        jmi     2f
1318        clr.w   %d1
13192:      lsl.w   #8,%d1
1320        lsl.l   #7,%d1
1321        lsl.l   #8,%d1
1322        bclr    #31,%d0
1323        lsr.l   #8,%d0
1324        or.l    %d1,%d0
1325        printf  PCONV,"%08x\n",1,%d0
1326        rts
1327
1328        | special return addresses for instr that
1329        | encode the rounding precision in the opcode
1330        | (e.g. fsmove,fdmove)
1331
1332fp_finalrounding_single:
1333        addq.l  #8,%sp
1334        jsr     fp_normalize_ext
1335        jsr     fp_normalize_single
1336        jra     fp_finaltest
1337
1338fp_finalrounding_single_fast:
1339        addq.l  #8,%sp
1340        jsr     fp_normalize_ext
1341        jsr     fp_normalize_single_fast
1342        jra     fp_finaltest
1343
1344fp_finalrounding_double:
1345        addq.l  #8,%sp
1346        jsr     fp_normalize_ext
1347        jsr     fp_normalize_double
1348        jra     fp_finaltest
1349
1350        | fp_finaltest:
1351        | set the emulated status register based on the outcome of an
1352        | emulated instruction.
1353
1354fp_finalrounding:
1355        addq.l  #8,%sp
1356|       printf  ,"f: %p\n",1,%a0
1357        jsr     fp_normalize_ext
1358        move.w  (FPD_PREC,FPDATA),%d0
1359        subq.w  #1,%d0
1360        jcs     fp_finaltest
1361        jne     1f
1362        jsr     fp_normalize_single
1363        jra     2f
13641:      jsr     fp_normalize_double
13652:|     printf  ,"f: %p\n",1,%a0
1366fp_finaltest:
1367        | First, we do some of the obvious tests for the exception
1368        | status byte and condition code bytes of fp_sr here, so that
1369        | they do not have to be handled individually by every
1370        | emulated instruction.
1371        clr.l   %d0
1372        addq.l  #1,%a0
1373        tst.b   (%a0)+                  | sign
1374        jeq     1f
1375        bset    #FPSR_CC_NEG-24,%d0     | N bit
13761:      cmp.w   #0x7fff,(%a0)+          | exponent
1377        jeq     2f
1378        | test for zero
1379        moveq   #FPSR_CC_Z-24,%d1
1380        tst.l   (%a0)+
1381        jne     9f
1382        tst.l   (%a0)
1383        jne     9f
1384        jra     8f
1385        | infinitiv and NAN
13862:      moveq   #FPSR_CC_NAN-24,%d1
1387        move.l  (%a0)+,%d2
1388        lsl.l   #1,%d2                  | ignore high bit
1389        jne     8f
1390        tst.l   (%a0)
1391        jne     8f
1392        moveq   #FPSR_CC_INF-24,%d1
13938:      bset    %d1,%d0
13949:      move.b  %d0,(FPD_FPSR+0,FPDATA) | set condition test result
1395        | move instructions enter here
1396        | Here, we test things in the exception status byte, and set
1397        | other things in the accrued exception byte accordingly.
1398        | Emulated instructions can set various things in the former,
1399        | as defined in fp_emu.h.
1400fp_final:
1401        move.l  (FPD_FPSR,FPDATA),%d0
1402#if 0
1403        btst    #FPSR_EXC_SNAN,%d0      | EXC_SNAN
1404        jne     1f
1405        btst    #FPSR_EXC_OPERR,%d0     | EXC_OPERR
1406        jeq     2f
14071:      bset    #FPSR_AEXC_IOP,%d0      | set IOP bit
14082:      btst    #FPSR_EXC_OVFL,%d0      | EXC_OVFL
1409        jeq     1f
1410        bset    #FPSR_AEXC_OVFL,%d0     | set OVFL bit
14111:      btst    #FPSR_EXC_UNFL,%d0      | EXC_UNFL
1412        jeq     1f
1413        btst    #FPSR_EXC_INEX2,%d0     | EXC_INEX2
1414        jeq     1f
1415        bset    #FPSR_AEXC_UNFL,%d0     | set UNFL bit
14161:      btst    #FPSR_EXC_DZ,%d0        | EXC_INEX1
1417        jeq     1f
1418        bset    #FPSR_AEXC_DZ,%d0       | set DZ bit
14191:      btst    #FPSR_EXC_OVFL,%d0      | EXC_OVFL
1420        jne     1f
1421        btst    #FPSR_EXC_INEX2,%d0     | EXC_INEX2
1422        jne     1f
1423        btst    #FPSR_EXC_INEX1,%d0     | EXC_INEX1
1424        jeq     2f
14251:      bset    #FPSR_AEXC_INEX,%d0     | set INEX bit
14262:      move.l  %d0,(FPD_FPSR,FPDATA)
1427#else
1428        | same as above, greatly optimized, but untested (yet)
1429        move.l  %d0,%d2
1430        lsr.l   #5,%d0
1431        move.l  %d0,%d1
1432        lsr.l   #4,%d1
1433        or.l    %d0,%d1
1434        and.b   #0x08,%d1
1435        move.l  %d2,%d0
1436        lsr.l   #6,%d0
1437        or.l    %d1,%d0
1438        move.l  %d2,%d1
1439        lsr.l   #4,%d1
1440        or.b    #0xdf,%d1
1441        and.b   %d1,%d0
1442        move.l  %d2,%d1
1443        lsr.l   #7,%d1
1444        and.b   #0x80,%d1
1445        or.b    %d1,%d0
1446        and.b   #0xf8,%d0
1447        or.b    %d0,%d2
1448        move.l  %d2,(FPD_FPSR,FPDATA)
1449#endif
1450        move.b  (FPD_FPSR+2,FPDATA),%d0
1451        and.b   (FPD_FPCR+2,FPDATA),%d0
1452        jeq     1f
1453        printf  ,"send signal!!!\n"
14541:      jra     fp_end
1455