gcc/config/m68k/fpgnulib.c

   1 /* This is a stripped down version of floatlib.c.  It supplies only those
   2    functions which exist in libgcc, but for which there is not assembly
   3    language versions in m68k/lb1sf68.asm.
   4
   5    It also includes simplistic support for extended floats (by working in
   6    double precision).  You must compile this file again with -DEXTFLOAT
   7    to get this support.  */
   8
   9 /*
  10 ** gnulib support for software floating point.
  11 ** Copyright (C) 1991 by Pipeline Associates, Inc.  All rights reserved.
  12 ** Permission is granted to do *anything* you want with this file,
  13 ** commercial or otherwise, provided this message remains intact.  So there!
  14 ** I would appreciate receiving any updates/patches/changes that anyone
  15 ** makes, and am willing to be the repository for said changes (am I
  16 ** making a big mistake?).
  17 **
  18 ** Pat Wood
  19 ** Pipeline Associates, Inc.
  20 ** pipeline!phw@motown.com or
  21 ** sun!pipeline!phw or
  22 ** uunet!motown!pipeline!phw
  23 **
  24 ** 05/01/91 -- V1.0 -- first release to gcc mailing lists
  25 ** 05/04/91 -- V1.1 -- added float and double prototypes and return values
  26 **                  -- fixed problems with adding and subtracting zero
  27 **                  -- fixed rounding in truncdfsf2
  28 **                  -- fixed SWAP define and tested on 386
  29 */
  30
  31 /*
  32 ** The following are routines that replace the gnulib soft floating point
  33 ** routines that are called automatically when -msoft-float is selected.
  34 ** The support single and double precision IEEE format, with provisions
  35 ** for byte-swapped machines (tested on 386).  Some of the double-precision
  36 ** routines work at full precision, but most of the hard ones simply punt
  37 ** and call the single precision routines, producing a loss of accuracy.
  38 ** long long support is not assumed or included.
  39 ** Overall accuracy is close to IEEE (actually 68882) for single-precision
  40 ** arithmetic.  I think there may still be a 1 in 1000 chance of a bit
  41 ** being rounded the wrong way during a multiply.  I'm not fussy enough to
  42 ** bother with it, but if anyone is, knock yourself out.
  43 **
  44 ** Efficiency has only been addressed where it was obvious that something
  45 ** would make a big difference.  Anyone who wants to do this right for
  46 ** best speed should go in and rewrite in assembler.
  47 **
  48 ** I have tested this only on a 68030 workstation and 386/ix integrated
  49 ** in with -msoft-float.
  50 */
  51
  52 /* the following deal with IEEE single-precision numbers */
  53 #define EXCESS          126L
  54 #define SIGNBIT         0x80000000L
  55 #define HIDDEN          (1L << 23L)
  56 #define SIGN(fp)        ((fp) & SIGNBIT)
  57 #define EXP(fp)         (((fp) >> 23L) & 0xFF)
  58 #define MANT(fp)        (((fp) & 0x7FFFFFL) | HIDDEN)
  59 #define PACK(s,e,m)     ((s) | ((e) << 23L) | (m))
  60
  61 /* the following deal with IEEE double-precision numbers */
  62 #define EXCESSD         1022L
  63 #define HIDDEND         (1L << 20L)
  64 #define EXPDBITS        11
  65 #define EXPDMASK        0x7FFL
  66 #define EXPD(fp)        (((fp.l.upper) >> 20L) & 0x7FFL)
  67 #define SIGND(fp)       ((fp.l.upper) & SIGNBIT)
  68 #define MANTD(fp)       (((((fp.l.upper) & 0xFFFFF) | HIDDEND) << 10) | \
  69                                 (fp.l.lower >> 22))
  70 #define MANTDMASK       0xFFFFFL /* mask of upper part */
  71
  72 /* the following deal with IEEE extended-precision numbers */
  73 #define EXCESSX         16382L
  74 #define HIDDENX         (1L << 31L)
  75 #define EXPXBITS        15
  76 #define EXPXMASK        0x7FFF
  77 #define EXPX(fp)        (((fp.l.upper) >> 16) & EXPXMASK)
  78 #define SIGNX(fp)       ((fp.l.upper) & SIGNBIT)
  79 #define MANTXMASK       0x7FFFFFFFL /* mask of upper part */
  80
  81 union double_long
  82 {
  83   double d;
  84   struct {
  85       long upper;
  86       unsigned long lower;
  87     } l;
  88 };
  89
  90 union float_long {
  91   float f;
  92   long l;
  93 };
  94
  95 union long_double_long
  96 {
  97   long double ld;
  98   struct
  99     {
 100       long upper;
 101       unsigned long middle;
 102       unsigned long lower;
 103     } l;
 104 };
 105 \f
 106 #ifndef EXTFLOAT
 107
 108 int
 109 __unordsf2(float a, float b)
 110 {
 111   union float_long fl;
 112
 113   fl.f = a;
 114   if (EXP(fl.l) == EXP(~0u) && (MANT(fl.l) & ~HIDDEN) != 0)
 115     return 1;
 116   fl.f = b;
 117   if (EXP(fl.l) == EXP(~0u) && (MANT(fl.l) & ~HIDDEN) != 0)
 118     return 1;
 119   return 0;
 120 }
 121
 122 int
 123 __unorddf2(double a, double b)
 124 {
 125   union double_long dl;
 126
 127   dl.d = a;
 128   if (EXPD(dl) == EXPDMASK
 129       && ((dl.l.upper & MANTDMASK) != 0 || dl.l.lower != 0))
 130     return 1;
 131   dl.d = b;
 132   if (EXPD(dl) == EXPDMASK
 133       && ((dl.l.upper & MANTDMASK) != 0 || dl.l.lower != 0))
 134     return 1;
 135   return 0;
 136 }
 137
 138 /* convert unsigned int to double */
 139 double
 140 __floatunsidf (unsigned long a1)
 141 {
 142   long exp = 32 + EXCESSD;
 143   union double_long dl;
 144
 145   if (!a1)
 146     {
 147       dl.l.upper = dl.l.lower = 0;
 148       return dl.d;
 149     }
 150
 151   while (a1 < 0x2000000L)
 152     {
 153       a1 <<= 4;
 154       exp -= 4;
 155     }
 156
 157   while (a1 < 0x80000000L)
 158     {
 159       a1 <<= 1;
 160       exp--;
 161     }
 162
 163   /* pack up and go home */
 164   dl.l.upper = exp << 20L;
 165   dl.l.upper |= (a1 >> 11L) & ~HIDDEND;
 166   dl.l.lower = a1 << 21L;
 167
 168   return dl.d;
 169 }
 170
 171 /* convert int to double */
 172 double
 173 __floatsidf (long a1)
 174 {
 175   long sign = 0, exp = 31 + EXCESSD;
 176   union double_long dl;
 177
 178   if (!a1)
 179     {
 180       dl.l.upper = dl.l.lower = 0;
 181       return dl.d;
 182     }
 183
 184   if (a1 < 0)
 185     {
 186       sign = SIGNBIT;
 187       a1 = (long)-(unsigned long)a1;
 188       if (a1 < 0)
 189         {
 190           dl.l.upper = SIGNBIT | ((32 + EXCESSD) << 20L);
 191           dl.l.lower = 0;
 192           return dl.d;
 193         }
 194     }
 195
 196   while (a1 < 0x1000000L)
 197     {
 198       a1 <<= 4;
 199       exp -= 4;
 200     }
 201
 202   while (a1 < 0x40000000L)
 203     {
 204       a1 <<= 1;
 205       exp--;
 206     }
 207
 208   /* pack up and go home */
 209   dl.l.upper = sign;
 210   dl.l.upper |= exp << 20L;
 211   dl.l.upper |= (a1 >> 10L) & ~HIDDEND;
 212   dl.l.lower = a1 << 22L;
 213
 214   return dl.d;
 215 }
 216
 217 /* convert unsigned int to float */
 218 float
 219 __floatunsisf (unsigned long l)
 220 {
 221   double foo = __floatunsidf (l);
 222   return foo;
 223 }
 224
 225 /* convert int to float */
 226 float
 227 __floatsisf (long l)
 228 {
 229   double foo = __floatsidf (l);
 230   return foo;
 231 }
 232
 233 /* convert float to double */
 234 double
 235 __extendsfdf2 (float a1)
 236 {
 237   register union float_long fl1;
 238   register union double_long dl;
 239   register long exp;
 240   register long mant;
 241
 242   fl1.f = a1;
 243
 244   dl.l.upper = SIGN (fl1.l);
 245   if ((fl1.l & ~SIGNBIT) == 0)
 246     {
 247       dl.l.lower = 0;
 248       return dl.d;
 249     }
 250
 251   exp = EXP(fl1.l);
 252   mant = MANT (fl1.l) & ~HIDDEN;
 253   if (exp == 0)
 254     {
 255       /* Denormal.  */
 256       exp = 1;
 257       while (!(mant & HIDDEN))
 258         {
 259           mant <<= 1;
 260           exp--;
 261         }
 262       mant &= ~HIDDEN;
 263     }
 264   exp = exp - EXCESS + EXCESSD;
 265   dl.l.upper |= exp << 20;
 266   dl.l.upper |= mant >> 3;
 267   dl.l.lower = mant << 29;
 268
 269   return dl.d;
 270 }
 271
 272 /* convert double to float */
 273 float
 274 __truncdfsf2 (double a1)
 275 {
 276   register long exp;
 277   register long mant;
 278   register union float_long fl;
 279   register union double_long dl1;
 280   int sticky;
 281   int shift;
 282
 283   dl1.d = a1;
 284
 285   if ((dl1.l.upper & ~SIGNBIT) == 0 && !dl1.l.lower)
 286     {
 287       fl.l = SIGND(dl1);
 288       return fl.f;
 289     }
 290
 291   exp = EXPD (dl1) - EXCESSD + EXCESS;
 292
 293   sticky = dl1.l.lower & ((1 << 22) - 1);
 294   mant = MANTD (dl1);
 295   /* shift double mantissa 6 bits so we can round */
 296   sticky |= mant & ((1 << 6) - 1);
 297   mant >>= 6;
 298
 299   /* Check for underflow and denormals.  */
 300   if (exp <= 0)
 301     {
 302       if (exp < -24)
 303         {
 304           sticky |= mant;
 305           mant = 0;
 306         }
 307       else
 308         {
 309           sticky |= mant & ((1 << (1 - exp)) - 1);
 310           mant >>= 1 - exp;
 311         }
 312       exp = 0;
 313     }
 314
 315   /* now round */
 316   shift = 1;
 317   if ((mant & 1) && (sticky || (mant & 2)))
 318     {
 319       int rounding = exp ? 2 : 1;
 320
 321       mant += 1;
 322
 323       /* did the round overflow? */
 324       if (mant >= (HIDDEN << rounding))
 325         {
 326           exp++;
 327           shift = rounding;
 328         }
 329     }
 330   /* shift down */
 331   mant >>= shift;
 332
 333   mant &= ~HIDDEN;
 334
 335   /* pack up and go home */
 336   fl.l = PACK (SIGND (dl1), exp, mant);
 337   return (fl.f);
 338 }
 339
 340 /* convert double to int */
 341 long
 342 __fixdfsi (double a1)
 343 {
 344   register union double_long dl1;
 345   register long exp;
 346   register long l;
 347
 348   dl1.d = a1;
 349
 350   if (!dl1.l.upper && !dl1.l.lower)
 351     return 0;
 352
 353   exp = EXPD (dl1) - EXCESSD - 31;
 354   l = MANTD (dl1);
 355
 356   if (exp > 0)
 357     {
 358       /* Return largest integer.  */
 359       return SIGND (dl1) ? 0x80000000L : 0x7fffffffL;
 360     }
 361
 362   if (exp <= -32)
 363     return 0;
 364
 365   /* shift down until exp = 0 */
 366   if (exp < 0)
 367     l >>= -exp;
 368
 369   return (SIGND (dl1) ? -l : l);
 370 }
 371
 372 /* convert float to int */
 373 long
 374 __fixsfsi (float a1)
 375 {
 376   double foo = a1;
 377   return __fixdfsi (foo);
 378 }
 379 \f
 380 #else /* EXTFLOAT */
 381
 382 /* We do not need these routines for coldfire, as it has no extended
 383    float format. */
 384 #if !defined (__mcoldfire__)
 385
 386 /* Primitive extended precision floating point support.
 387
 388    We assume all numbers are normalized, don't do any rounding, etc.  */
 389
 390 /* Prototypes for the above in case we use them.  */
 391 double __floatunsidf (unsigned long);
 392 double __floatsidf (long);
 393 float __floatsisf (long);
 394 double __extendsfdf2 (float);
 395 float __truncdfsf2 (double);
 396 long __fixdfsi (double);
 397 long __fixsfsi (float);
 398
 399 int
 400 __unordxf2(long double a, long double b)
 401 {
 402   union long_double_long ldl;
 403
 404   ldl.ld = a;
 405   if (EXPX(ldl) == EXPXMASK
 406       && ((ldl.l.middle & MANTXMASK) != 0 || ldl.l.lower != 0))
 407     return 1;
 408   ldl.ld = b;
 409   if (EXPX(ldl) == EXPXMASK
 410       && ((ldl.l.middle & MANTXMASK) != 0 || ldl.l.lower != 0))
 411     return 1;
 412   return 0;
 413 }
 414
 415 /* convert double to long double */
 416 long double
 417 __extenddfxf2 (double d)
 418 {
 419   register union double_long dl;
 420   register union long_double_long ldl;
 421   register long exp;
 422
 423   dl.d = d;
 424   /*printf ("dfxf in: %g\n", d);*/
 425
 426   ldl.l.upper = SIGND (dl);
 427   if ((dl.l.upper & ~SIGNBIT) == 0 && !dl.l.lower)
 428     {
 429       ldl.l.middle = 0;
 430       ldl.l.lower = 0;
 431       return ldl.ld;
 432     }
 433
 434   exp = EXPD (dl) - EXCESSD + EXCESSX;
 435   ldl.l.upper |= exp << 16;
 436   ldl.l.middle = HIDDENX;
 437   /* 31-20: # mantissa bits in ldl.l.middle - # mantissa bits in dl.l.upper */
 438   ldl.l.middle |= (dl.l.upper & MANTDMASK) << (31 - 20);
 439   /* 1+20: explicit-integer-bit + # mantissa bits in dl.l.upper */
 440   ldl.l.middle |= dl.l.lower >> (1 + 20);
 441   /* 32 - 21: # bits of dl.l.lower in ldl.l.middle */
 442   ldl.l.lower = dl.l.lower << (32 - 21);
 443
 444   /*printf ("dfxf out: %s\n", dumpxf (ldl.ld));*/
 445   return ldl.ld;
 446 }
 447
 448 /* convert long double to double */
 449 double
 450 __truncxfdf2 (long double ld)
 451 {
 452   register long exp;
 453   register union double_long dl;
 454   register union long_double_long ldl;
 455
 456   ldl.ld = ld;
 457   /*printf ("xfdf in: %s\n", dumpxf (ld));*/
 458
 459   dl.l.upper = SIGNX (ldl);
 460   if ((ldl.l.upper & ~SIGNBIT) == 0 && !ldl.l.middle && !ldl.l.lower)
 461     {
 462       dl.l.lower = 0;
 463       return dl.d;
 464     }
 465
 466   exp = EXPX (ldl) - EXCESSX + EXCESSD;
 467   /* ??? quick and dirty: keep `exp' sane */
 468   if (exp >= EXPDMASK)
 469     exp = EXPDMASK - 1;
 470   dl.l.upper |= exp << (32 - (EXPDBITS + 1));
 471   /* +1-1: add one for sign bit, but take one off for explicit-integer-bit */
 472   dl.l.upper |= (ldl.l.middle & MANTXMASK) >> (EXPDBITS + 1 - 1);
 473   dl.l.lower = (ldl.l.middle & MANTXMASK) << (32 - (EXPDBITS + 1 - 1));
 474   dl.l.lower |= ldl.l.lower >> (EXPDBITS + 1 - 1);
 475
 476   /*printf ("xfdf out: %g\n", dl.d);*/
 477   return dl.d;
 478 }
 479
 480 /* convert a float to a long double */
 481 long double
 482 __extendsfxf2 (float f)
 483 {
 484   long double foo = __extenddfxf2 (__extendsfdf2 (f));
 485   return foo;
 486 }
 487
 488 /* convert a long double to a float */
 489 float
 490 __truncxfsf2 (long double ld)
 491 {
 492   float foo = __truncdfsf2 (__truncxfdf2 (ld));
 493   return foo;
 494 }
 495
 496 /* convert an int to a long double */
 497 long double
 498 __floatsixf (long l)
 499 {
 500   double foo = __floatsidf (l);
 501   return foo;
 502 }
 503
 504 /* convert an unsigned int to a long double */
 505 long double
 506 __floatunsixf (unsigned long l)
 507 {
 508   double foo = __floatunsidf (l);
 509   return foo;
 510 }
 511
 512 /* convert a long double to an int */
 513 long
 514 __fixxfsi (long double ld)
 515 {
 516   long foo = __fixdfsi ((double) ld);
 517   return foo;
 518 }
 519
 520 /* The remaining provide crude math support by working in double precision.  */
 521
 522 long double
 523 __addxf3 (long double x1, long double x2)
 524 {
 525   return (double) x1 + (double) x2;
 526 }
 527
 528 long double
 529 __subxf3 (long double x1, long double x2)
 530 {
 531   return (double) x1 - (double) x2;
 532 }
 533
 534 long double
 535 __mulxf3 (long double x1, long double x2)
 536 {
 537   return (double) x1 * (double) x2;
 538 }
 539
 540 long double
 541 __divxf3 (long double x1, long double x2)
 542 {
 543   return (double) x1 / (double) x2;
 544 }
 545
 546 long double
 547 __negxf2 (long double x1)
 548 {
 549   return - (double) x1;
 550 }
 551
 552 long
 553 __cmpxf2 (long double x1, long double x2)
 554 {
 555   return __cmpdf2 ((double) x1, (double) x2);
 556 }
 557
 558 long
 559 __eqxf2 (long double x1, long double x2)
 560 {
 561   return __cmpdf2 ((double) x1, (double) x2);
 562 }
 563
 564 long
 565 __nexf2 (long double x1, long double x2)
 566 {
 567   return __cmpdf2 ((double) x1, (double) x2);
 568 }
 569
 570 long
 571 __ltxf2 (long double x1, long double x2)
 572 {
 573   return __cmpdf2 ((double) x1, (double) x2);
 574 }
 575
 576 long
 577 __lexf2 (long double x1, long double x2)
 578 {
 579   return __cmpdf2 ((double) x1, (double) x2);
 580 }
 581
 582 long
 583 __gtxf2 (long double x1, long double x2)
 584 {
 585   return __cmpdf2 ((double) x1, (double) x2);
 586 }
 587
 588 long
 589 __gexf2 (long double x1, long double x2)
 590 {
 591   return __cmpdf2 ((double) x1, (double) x2);
 592 }
 593
 594 #endif /* !__mcoldfire__ */
 595 #endif /* EXTFLOAT */