contrib/gcc-4.1/gcc/libgcc2.c

   1 /* More subroutines needed by GCC output code on some machines.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2001, 2002, 2003, 2004, 2005  Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 In addition to the permissions in the GNU General Public License, the
  14 Free Software Foundation gives you unlimited permission to link the
  15 compiled version of this file into combinations with other programs,
  16 and to distribute those combinations without any restriction coming
  17 from the use of this file.  (The General Public License restrictions
  18 do apply in other respects; for example, they cover modification of
  19 the file, and distribution when not linked into a combine
  20 executable.)
  21
  22 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  23 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  24 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  25 for more details.
  26
  27 You should have received a copy of the GNU General Public License
  28 along with GCC; see the file COPYING.  If not, write to the Free
  29 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  30 02110-1301, USA.  */
  31
  32 #include "tconfig.h"
  33 #include "tsystem.h"
  34 #include "coretypes.h"
  35 #include "tm.h"
  36
  37 #ifdef HAVE_GAS_HIDDEN
  38 #define ATTRIBUTE_HIDDEN  __attribute__ ((__visibility__ ("hidden")))
  39 #else
  40 #define ATTRIBUTE_HIDDEN
  41 #endif
  42
  43 #include "libgcc2.h"
  44 \f
  45 #ifdef DECLARE_LIBRARY_RENAMES
  46   DECLARE_LIBRARY_RENAMES
  47 #endif
  48
  49 #if defined (L_negdi2)
  50 DWtype
  51 __negdi2 (DWtype u)
  52 {
  53   const DWunion uu = {.ll = u};
  54   const DWunion w = { {.low = -uu.s.low,
  55                        .high = -uu.s.high - ((UWtype) -uu.s.low > 0) } };
  56
  57   return w.ll;
  58 }
  59 #endif
  60
  61 #ifdef L_addvsi3
  62 Wtype
  63 __addvSI3 (Wtype a, Wtype b)
  64 {
  65   const Wtype w = a + b;
  66
  67   if (b >= 0 ? w < a : w > a)
  68     abort ();
  69
  70   return w;
  71 }
  72 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
  73 SItype
  74 __addvsi3 (SItype a, SItype b)
  75 {
  76   const SItype w = a + b;
  77
  78   if (b >= 0 ? w < a : w > a)
  79     abort ();
  80
  81   return w;
  82 }
  83 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
  84 #endif
  85 \f
  86 #ifdef L_addvdi3
  87 DWtype
  88 __addvDI3 (DWtype a, DWtype b)
  89 {
  90   const DWtype w = a + b;
  91
  92   if (b >= 0 ? w < a : w > a)
  93     abort ();
  94
  95   return w;
  96 }
  97 #endif
  98 \f
  99 #ifdef L_subvsi3
 100 Wtype
 101 __subvSI3 (Wtype a, Wtype b)
 102 {
 103   const Wtype w = a - b;
 104
 105   if (b >= 0 ? w > a : w < a)
 106     abort ();
 107
 108   return w;
 109 }
 110 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
 111 SItype
 112 __subvsi3 (SItype a, SItype b)
 113 {
 114   const SItype w = a - b;
 115
 116   if (b >= 0 ? w > a : w < a)
 117     abort ();
 118
 119   return w;
 120 }
 121 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
 122 #endif
 123 \f
 124 #ifdef L_subvdi3
 125 DWtype
 126 __subvDI3 (DWtype a, DWtype b)
 127 {
 128   const DWtype w = a - b;
 129
 130   if (b >= 0 ? w > a : w < a)
 131     abort ();
 132
 133   return w;
 134 }
 135 #endif
 136 \f
 137 #ifdef L_mulvsi3
 138 Wtype
 139 __mulvSI3 (Wtype a, Wtype b)
 140 {
 141   const DWtype w = (DWtype) a * (DWtype) b;
 142
 143   if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1))
 144     abort ();
 145
 146   return w;
 147 }
 148 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
 149 #undef WORD_SIZE
 150 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 151 SItype
 152 __mulvsi3 (SItype a, SItype b)
 153 {
 154   const DItype w = (DItype) a * (DItype) b;
 155
 156   if ((SItype) (w >> WORD_SIZE) != (SItype) w >> (WORD_SIZE-1))
 157     abort ();
 158
 159   return w;
 160 }
 161 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
 162 #endif
 163 \f
 164 #ifdef L_negvsi2
 165 Wtype
 166 __negvSI2 (Wtype a)
 167 {
 168   const Wtype w = -a;
 169
 170   if (a >= 0 ? w > 0 : w < 0)
 171     abort ();
 172
 173    return w;
 174 }
 175 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
 176 SItype
 177 __negvsi2 (SItype a)
 178 {
 179   const SItype w = -a;
 180
 181   if (a >= 0 ? w > 0 : w < 0)
 182     abort ();
 183
 184    return w;
 185 }
 186 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
 187 #endif
 188 \f
 189 #ifdef L_negvdi2
 190 DWtype
 191 __negvDI2 (DWtype a)
 192 {
 193   const DWtype w = -a;
 194
 195   if (a >= 0 ? w > 0 : w < 0)
 196     abort ();
 197
 198   return w;
 199 }
 200 #endif
 201 \f
 202 #ifdef L_absvsi2
 203 Wtype
 204 __absvSI2 (Wtype a)
 205 {
 206   Wtype w = a;
 207
 208   if (a < 0)
 209 #ifdef L_negvsi2
 210     w = __negvSI2 (a);
 211 #else
 212     w = -a;
 213
 214   if (w < 0)
 215     abort ();
 216 #endif
 217
 218    return w;
 219 }
 220 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
 221 SItype
 222 __absvsi2 (SItype a)
 223 {
 224   SItype w = a;
 225
 226   if (a < 0)
 227 #ifdef L_negvsi2
 228     w = __negvsi2 (a);
 229 #else
 230     w = -a;
 231
 232   if (w < 0)
 233     abort ();
 234 #endif
 235
 236    return w;
 237 }
 238 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
 239 #endif
 240 \f
 241 #ifdef L_absvdi2
 242 DWtype
 243 __absvDI2 (DWtype a)
 244 {
 245   DWtype w = a;
 246
 247   if (a < 0)
 248 #ifdef L_negvdi2
 249     w = __negvDI2 (a);
 250 #else
 251     w = -a;
 252
 253   if (w < 0)
 254     abort ();
 255 #endif
 256
 257   return w;
 258 }
 259 #endif
 260 \f
 261 #ifdef L_mulvdi3
 262 DWtype
 263 __mulvDI3 (DWtype u, DWtype v)
 264 {
 265   /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
 266      but the checked multiplication needs only two.  */
 267   const DWunion uu = {.ll = u};
 268   const DWunion vv = {.ll = v};
 269
 270   if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1))
 271     {
 272       /* u fits in a single Wtype.  */
 273       if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
 274         {
 275           /* v fits in a single Wtype as well.  */
 276           /* A single multiplication.  No overflow risk.  */
 277           return (DWtype) uu.s.low * (DWtype) vv.s.low;
 278         }
 279       else
 280         {
 281           /* Two multiplications.  */
 282           DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
 283                         * (UDWtype) (UWtype) vv.s.low};
 284           DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.low
 285                         * (UDWtype) (UWtype) vv.s.high};
 286
 287           if (vv.s.high < 0)
 288             w1.s.high -= uu.s.low;
 289           if (uu.s.low < 0)
 290             w1.ll -= vv.ll;
 291           w1.ll += (UWtype) w0.s.high;
 292           if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
 293             {
 294               w0.s.high = w1.s.low;
 295               return w0.ll;
 296             }
 297         }
 298     }
 299   else
 300     {
 301       if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
 302         {
 303           /* v fits into a single Wtype.  */
 304           /* Two multiplications.  */
 305           DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
 306                         * (UDWtype) (UWtype) vv.s.low};
 307           DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.high
 308                         * (UDWtype) (UWtype) vv.s.low};
 309
 310           if (uu.s.high < 0)
 311             w1.s.high -= vv.s.low;
 312           if (vv.s.low < 0)
 313             w1.ll -= uu.ll;
 314           w1.ll += (UWtype) w0.s.high;
 315           if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
 316             {
 317               w0.s.high = w1.s.low;
 318               return w0.ll;
 319             }
 320         }
 321       else
 322         {
 323           /* A few sign checks and a single multiplication.  */
 324           if (uu.s.high >= 0)
 325             {
 326               if (vv.s.high >= 0)
 327                 {
 328                   if (uu.s.high == 0 && vv.s.high == 0)
 329                     {
 330                       const DWtype w = (UDWtype) (UWtype) uu.s.low
 331                         * (UDWtype) (UWtype) vv.s.low;
 332                       if (__builtin_expect (w >= 0, 1))
 333                         return w;
 334                     }
 335                 }
 336               else
 337                 {
 338                   if (uu.s.high == 0 && vv.s.high == (Wtype) -1)
 339                     {
 340                       DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
 341                                     * (UDWtype) (UWtype) vv.s.low};
 342
 343                       ww.s.high -= uu.s.low;
 344                       if (__builtin_expect (ww.s.high < 0, 1))
 345                         return ww.ll;
 346                     }
 347                 }
 348             }
 349           else
 350             {
 351               if (vv.s.high >= 0)
 352                 {
 353                   if (uu.s.high == (Wtype) -1 && vv.s.high == 0)
 354                     {
 355                       DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
 356                                     * (UDWtype) (UWtype) vv.s.low};
 357
 358                       ww.s.high -= vv.s.low;
 359                       if (__builtin_expect (ww.s.high < 0, 1))
 360                         return ww.ll;
 361                     }
 362                 }
 363               else
 364                 {
 365                   if (uu.s.high == (Wtype) -1 && vv.s.high == (Wtype) - 1)
 366                     {
 367                       DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
 368                                     * (UDWtype) (UWtype) vv.s.low};
 369
 370                       ww.s.high -= uu.s.low;
 371                       ww.s.high -= vv.s.low;
 372                       if (__builtin_expect (ww.s.high >= 0, 1))
 373                         return ww.ll;
 374                     }
 375                 }
 376             }
 377         }
 378     }
 379
 380   /* Overflow.  */
 381   abort ();
 382 }
 383 #endif
 384 \f
 385
 386 /* Unless shift functions are defined with full ANSI prototypes,
 387    parameter b will be promoted to int if word_type is smaller than an int.  */
 388 #ifdef L_lshrdi3
 389 DWtype
 390 __lshrdi3 (DWtype u, word_type b)
 391 {
 392   if (b == 0)
 393     return u;
 394
 395   const DWunion uu = {.ll = u};
 396   const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 397   DWunion w;
 398
 399   if (bm <= 0)
 400     {
 401       w.s.high = 0;
 402       w.s.low = (UWtype) uu.s.high >> -bm;
 403     }
 404   else
 405     {
 406       const UWtype carries = (UWtype) uu.s.high << bm;
 407
 408       w.s.high = (UWtype) uu.s.high >> b;
 409       w.s.low = ((UWtype) uu.s.low >> b) | carries;
 410     }
 411
 412   return w.ll;
 413 }
 414 #endif
 415
 416 #ifdef L_ashldi3
 417 DWtype
 418 __ashldi3 (DWtype u, word_type b)
 419 {
 420   if (b == 0)
 421     return u;
 422
 423   const DWunion uu = {.ll = u};
 424   const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 425   DWunion w;
 426
 427   if (bm <= 0)
 428     {
 429       w.s.low = 0;
 430       w.s.high = (UWtype) uu.s.low << -bm;
 431     }
 432   else
 433     {
 434       const UWtype carries = (UWtype) uu.s.low >> bm;
 435
 436       w.s.low = (UWtype) uu.s.low << b;
 437       w.s.high = ((UWtype) uu.s.high << b) | carries;
 438     }
 439
 440   return w.ll;
 441 }
 442 #endif
 443
 444 #ifdef L_ashrdi3
 445 DWtype
 446 __ashrdi3 (DWtype u, word_type b)
 447 {
 448   if (b == 0)
 449     return u;
 450
 451   const DWunion uu = {.ll = u};
 452   const word_type bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 453   DWunion w;
 454
 455   if (bm <= 0)
 456     {
 457       /* w.s.high = 1..1 or 0..0 */
 458       w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
 459       w.s.low = uu.s.high >> -bm;
 460     }
 461   else
 462     {
 463       const UWtype carries = (UWtype) uu.s.high << bm;
 464
 465       w.s.high = uu.s.high >> b;
 466       w.s.low = ((UWtype) uu.s.low >> b) | carries;
 467     }
 468
 469   return w.ll;
 470 }
 471 #endif
 472 \f
 473 #ifdef L_ffssi2
 474 #undef int
 475 int
 476 __ffsSI2 (UWtype u)
 477 {
 478   UWtype count;
 479
 480   if (u == 0)
 481     return 0;
 482
 483   count_trailing_zeros (count, u);
 484   return count + 1;
 485 }
 486 #endif
 487 \f
 488 #ifdef L_ffsdi2
 489 #undef int
 490 int
 491 __ffsDI2 (DWtype u)
 492 {
 493   const DWunion uu = {.ll = u};
 494   UWtype word, count, add;
 495
 496   if (uu.s.low != 0)
 497     word = uu.s.low, add = 0;
 498   else if (uu.s.high != 0)
 499     word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
 500   else
 501     return 0;
 502
 503   count_trailing_zeros (count, word);
 504   return count + add + 1;
 505 }
 506 #endif
 507 \f
 508 #ifdef L_muldi3
 509 DWtype
 510 __muldi3 (DWtype u, DWtype v)
 511 {
 512   const DWunion uu = {.ll = u};
 513   const DWunion vv = {.ll = v};
 514   DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
 515
 516   w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
 517                + (UWtype) uu.s.high * (UWtype) vv.s.low);
 518
 519   return w.ll;
 520 }
 521 #endif
 522 \f
 523 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 524      defined (L_umoddi3) || defined (L_moddi3))
 525 #if defined (sdiv_qrnnd)
 526 #define L_udiv_w_sdiv
 527 #endif
 528 #endif
 529
 530 #ifdef L_udiv_w_sdiv
 531 #if defined (sdiv_qrnnd)
 532 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 533      defined (L_umoddi3) || defined (L_moddi3))
 534 static inline __attribute__ ((__always_inline__))
 535 #endif
 536 UWtype
 537 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
 538 {
 539   UWtype q, r;
 540   UWtype c0, c1, b1;
 541
 542   if ((Wtype) d >= 0)
 543     {
 544       if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
 545         {
 546           /* Dividend, divisor, and quotient are nonnegative.  */
 547           sdiv_qrnnd (q, r, a1, a0, d);
 548         }
 549       else
 550         {
 551           /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d.  */
 552           sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
 553           /* Divide (c1*2^32 + c0) by d.  */
 554           sdiv_qrnnd (q, r, c1, c0, d);
 555           /* Add 2^31 to quotient.  */
 556           q += (UWtype) 1 << (W_TYPE_SIZE - 1);
 557         }
 558     }
 559   else
 560     {
 561       b1 = d >> 1;                      /* d/2, between 2^30 and 2^31 - 1 */
 562       c1 = a1 >> 1;                     /* A/2 */
 563       c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
 564
 565       if (a1 < b1)                      /* A < 2^32*b1, so A/2 < 2^31*b1 */
 566         {
 567           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 568
 569           r = 2*r + (a0 & 1);           /* Remainder from A/(2*b1) */
 570           if ((d & 1) != 0)
 571             {
 572               if (r >= q)
 573                 r = r - q;
 574               else if (q - r <= d)
 575                 {
 576                   r = r - q + d;
 577                   q--;
 578                 }
 579               else
 580                 {
 581                   r = r - q + 2*d;
 582                   q -= 2;
 583                 }
 584             }
 585         }
 586       else if (c1 < b1)                 /* So 2^31 <= (A/2)/b1 < 2^32 */
 587         {
 588           c1 = (b1 - 1) - c1;
 589           c0 = ~c0;                     /* logical NOT */
 590
 591           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 592
 593           q = ~q;                       /* (A/2)/b1 */
 594           r = (b1 - 1) - r;
 595
 596           r = 2*r + (a0 & 1);           /* A/(2*b1) */
 597
 598           if ((d & 1) != 0)
 599             {
 600               if (r >= q)
 601                 r = r - q;
 602               else if (q - r <= d)
 603                 {
 604                   r = r - q + d;
 605                   q--;
 606                 }
 607               else
 608                 {
 609                   r = r - q + 2*d;
 610                   q -= 2;
 611                 }
 612             }
 613         }
 614       else                              /* Implies c1 = b1 */
 615         {                               /* Hence a1 = d - 1 = 2*b1 - 1 */
 616           if (a0 >= -d)
 617             {
 618               q = -1;
 619               r = a0 + d;
 620             }
 621           else
 622             {
 623               q = -2;
 624               r = a0 + 2*d;
 625             }
 626         }
 627     }
 628
 629   *rp = r;
 630   return q;
 631 }
 632 #else
 633 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv.  */
 634 UWtype
 635 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
 636                UWtype a1 __attribute__ ((__unused__)),
 637                UWtype a0 __attribute__ ((__unused__)),
 638                UWtype d __attribute__ ((__unused__)))
 639 {
 640   return 0;
 641 }
 642 #endif
 643 #endif
 644 \f
 645 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 646      defined (L_umoddi3) || defined (L_moddi3))
 647 #define L_udivmoddi4
 648 #endif
 649
 650 #ifdef L_clz
 651 const UQItype __clz_tab[256] =
 652 {
 653   0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 654   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 655   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 656   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 657   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 658   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 659   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 660   8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
 661 };
 662 #endif
 663 \f
 664 #ifdef L_clzsi2
 665 #undef int
 666 int
 667 __clzSI2 (UWtype x)
 668 {
 669   Wtype ret;
 670
 671   count_leading_zeros (ret, x);
 672
 673   return ret;
 674 }
 675 #endif
 676 \f
 677 #ifdef L_clzdi2
 678 #undef int
 679 int
 680 __clzDI2 (UDWtype x)
 681 {
 682   const DWunion uu = {.ll = x};
 683   UWtype word;
 684   Wtype ret, add;
 685
 686   if (uu.s.high)
 687     word = uu.s.high, add = 0;
 688   else
 689     word = uu.s.low, add = W_TYPE_SIZE;
 690
 691   count_leading_zeros (ret, word);
 692   return ret + add;
 693 }
 694 #endif
 695 \f
 696 #ifdef L_ctzsi2
 697 #undef int
 698 int
 699 __ctzSI2 (UWtype x)
 700 {
 701   Wtype ret;
 702
 703   count_trailing_zeros (ret, x);
 704
 705   return ret;
 706 }
 707 #endif
 708 \f
 709 #ifdef L_ctzdi2
 710 #undef int
 711 int
 712 __ctzDI2 (UDWtype x)
 713 {
 714   const DWunion uu = {.ll = x};
 715   UWtype word;
 716   Wtype ret, add;
 717
 718   if (uu.s.low)
 719     word = uu.s.low, add = 0;
 720   else
 721     word = uu.s.high, add = W_TYPE_SIZE;
 722
 723   count_trailing_zeros (ret, word);
 724   return ret + add;
 725 }
 726 #endif
 727
 728 #ifdef L_popcount_tab
 729 const UQItype __popcount_tab[256] =
 730 {
 731     0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
 732     1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
 733     1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
 734     2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
 735     1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
 736     2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
 737     2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
 738     3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
 739 };
 740 #endif
 741 \f
 742 #ifdef L_popcountsi2
 743 #undef int
 744 int
 745 __popcountSI2 (UWtype x)
 746 {
 747   UWtype i, ret = 0;
 748
 749   for (i = 0; i < W_TYPE_SIZE; i += 8)
 750     ret += __popcount_tab[(x >> i) & 0xff];
 751
 752   return ret;
 753 }
 754 #endif
 755 \f
 756 #ifdef L_popcountdi2
 757 #undef int
 758 int
 759 __popcountDI2 (UDWtype x)
 760 {
 761   UWtype i, ret = 0;
 762
 763   for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
 764     ret += __popcount_tab[(x >> i) & 0xff];
 765
 766   return ret;
 767 }
 768 #endif
 769 \f
 770 #ifdef L_paritysi2
 771 #undef int
 772 int
 773 __paritySI2 (UWtype x)
 774 {
 775 #if W_TYPE_SIZE > 64
 776 # error "fill out the table"
 777 #endif
 778 #if W_TYPE_SIZE > 32
 779   x ^= x >> 32;
 780 #endif
 781 #if W_TYPE_SIZE > 16
 782   x ^= x >> 16;
 783 #endif
 784   x ^= x >> 8;
 785   x ^= x >> 4;
 786   x &= 0xf;
 787   return (0x6996 >> x) & 1;
 788 }
 789 #endif
 790 \f
 791 #ifdef L_paritydi2
 792 #undef int
 793 int
 794 __parityDI2 (UDWtype x)
 795 {
 796   const DWunion uu = {.ll = x};
 797   UWtype nx = uu.s.low ^ uu.s.high;
 798
 799 #if W_TYPE_SIZE > 64
 800 # error "fill out the table"
 801 #endif
 802 #if W_TYPE_SIZE > 32
 803   nx ^= nx >> 32;
 804 #endif
 805 #if W_TYPE_SIZE > 16
 806   nx ^= nx >> 16;
 807 #endif
 808   nx ^= nx >> 8;
 809   nx ^= nx >> 4;
 810   nx &= 0xf;
 811   return (0x6996 >> nx) & 1;
 812 }
 813 #endif
 814
 815 #ifdef L_udivmoddi4
 816
 817 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 818      defined (L_umoddi3) || defined (L_moddi3))
 819 static inline __attribute__ ((__always_inline__))
 820 #endif
 821 UDWtype
 822 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
 823 {
 824   const DWunion nn = {.ll = n};
 825   const DWunion dd = {.ll = d};
 826   DWunion rr;
 827   UWtype d0, d1, n0, n1, n2;
 828   UWtype q0, q1;
 829   UWtype b, bm;
 830
 831   d0 = dd.s.low;
 832   d1 = dd.s.high;
 833   n0 = nn.s.low;
 834   n1 = nn.s.high;
 835
 836 #if !UDIV_NEEDS_NORMALIZATION
 837   if (d1 == 0)
 838     {
 839       if (d0 > n1)
 840         {
 841           /* 0q = nn / 0D */
 842
 843           udiv_qrnnd (q0, n0, n1, n0, d0);
 844           q1 = 0;
 845
 846           /* Remainder in n0.  */
 847         }
 848       else
 849         {
 850           /* qq = NN / 0d */
 851
 852           if (d0 == 0)
 853             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 854
 855           udiv_qrnnd (q1, n1, 0, n1, d0);
 856           udiv_qrnnd (q0, n0, n1, n0, d0);
 857
 858           /* Remainder in n0.  */
 859         }
 860
 861       if (rp != 0)
 862         {
 863           rr.s.low = n0;
 864           rr.s.high = 0;
 865           *rp = rr.ll;
 866         }
 867     }
 868
 869 #else /* UDIV_NEEDS_NORMALIZATION */
 870
 871   if (d1 == 0)
 872     {
 873       if (d0 > n1)
 874         {
 875           /* 0q = nn / 0D */
 876
 877           count_leading_zeros (bm, d0);
 878
 879           if (bm != 0)
 880             {
 881               /* Normalize, i.e. make the most significant bit of the
 882                  denominator set.  */
 883
 884               d0 = d0 << bm;
 885               n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
 886               n0 = n0 << bm;
 887             }
 888
 889           udiv_qrnnd (q0, n0, n1, n0, d0);
 890           q1 = 0;
 891
 892           /* Remainder in n0 >> bm.  */
 893         }
 894       else
 895         {
 896           /* qq = NN / 0d */
 897
 898           if (d0 == 0)
 899             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 900
 901           count_leading_zeros (bm, d0);
 902
 903           if (bm == 0)
 904             {
 905               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 906                  conclude (the most significant bit of n1 is set) /\ (the
 907                  leading quotient digit q1 = 1).
 908
 909                  This special case is necessary, not an optimization.
 910                  (Shifts counts of W_TYPE_SIZE are undefined.)  */
 911
 912               n1 -= d0;
 913               q1 = 1;
 914             }
 915           else
 916             {
 917               /* Normalize.  */
 918
 919               b = W_TYPE_SIZE - bm;
 920
 921               d0 = d0 << bm;
 922               n2 = n1 >> b;
 923               n1 = (n1 << bm) | (n0 >> b);
 924               n0 = n0 << bm;
 925
 926               udiv_qrnnd (q1, n1, n2, n1, d0);
 927             }
 928
 929           /* n1 != d0...  */
 930
 931           udiv_qrnnd (q0, n0, n1, n0, d0);
 932
 933           /* Remainder in n0 >> bm.  */
 934         }
 935
 936       if (rp != 0)
 937         {
 938           rr.s.low = n0 >> bm;
 939           rr.s.high = 0;
 940           *rp = rr.ll;
 941         }
 942     }
 943 #endif /* UDIV_NEEDS_NORMALIZATION */
 944
 945   else
 946     {
 947       if (d1 > n1)
 948         {
 949           /* 00 = nn / DD */
 950
 951           q0 = 0;
 952           q1 = 0;
 953
 954           /* Remainder in n1n0.  */
 955           if (rp != 0)
 956             {
 957               rr.s.low = n0;
 958               rr.s.high = n1;
 959               *rp = rr.ll;
 960             }
 961         }
 962       else
 963         {
 964           /* 0q = NN / dd */
 965
 966           count_leading_zeros (bm, d1);
 967           if (bm == 0)
 968             {
 969               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 970                  conclude (the most significant bit of n1 is set) /\ (the
 971                  quotient digit q0 = 0 or 1).
 972
 973                  This special case is necessary, not an optimization.  */
 974
 975               /* The condition on the next line takes advantage of that
 976                  n1 >= d1 (true due to program flow).  */
 977               if (n1 > d1 || n0 >= d0)
 978                 {
 979                   q0 = 1;
 980                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 981                 }
 982               else
 983                 q0 = 0;
 984
 985               q1 = 0;
 986
 987               if (rp != 0)
 988                 {
 989                   rr.s.low = n0;
 990                   rr.s.high = n1;
 991                   *rp = rr.ll;
 992                 }
 993             }
 994           else
 995             {
 996               UWtype m1, m0;
 997               /* Normalize.  */
 998
 999               b = W_TYPE_SIZE - bm;
1000
1001               d1 = (d1 << bm) | (d0 >> b);
1002               d0 = d0 << bm;
1003               n2 = n1 >> b;
1004               n1 = (n1 << bm) | (n0 >> b);
1005               n0 = n0 << bm;
1006
1007               udiv_qrnnd (q0, n1, n2, n1, d1);
1008               umul_ppmm (m1, m0, q0, d0);
1009
1010               if (m1 > n1 || (m1 == n1 && m0 > n0))
1011                 {
1012                   q0--;
1013                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
1014                 }
1015
1016               q1 = 0;
1017
1018               /* Remainder in (n1n0 - m1m0) >> bm.  */
1019               if (rp != 0)
1020                 {
1021                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
1022                   rr.s.low = (n1 << b) | (n0 >> bm);
1023                   rr.s.high = n1 >> bm;
1024                   *rp = rr.ll;
1025                 }
1026             }
1027         }
1028     }
1029
1030   const DWunion ww = {{.low = q0, .high = q1}};
1031   return ww.ll;
1032 }
1033 #endif
1034
1035 #ifdef L_divdi3
1036 DWtype
1037 __divdi3 (DWtype u, DWtype v)
1038 {
1039   word_type c = 0;
1040   DWunion uu = {.ll = u};
1041   DWunion vv = {.ll = v};
1042   DWtype w;
1043
1044   if (uu.s.high < 0)
1045     c = ~c,
1046     uu.ll = -uu.ll;
1047   if (vv.s.high < 0)
1048     c = ~c,
1049     vv.ll = -vv.ll;
1050
1051   w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
1052   if (c)
1053     w = -w;
1054
1055   return w;
1056 }
1057 #endif
1058
1059 #ifdef L_moddi3
1060 DWtype
1061 __moddi3 (DWtype u, DWtype v)
1062 {
1063   word_type c = 0;
1064   DWunion uu = {.ll = u};
1065   DWunion vv = {.ll = v};
1066   DWtype w;
1067
1068   if (uu.s.high < 0)
1069     c = ~c,
1070     uu.ll = -uu.ll;
1071   if (vv.s.high < 0)
1072     vv.ll = -vv.ll;
1073
1074   (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
1075   if (c)
1076     w = -w;
1077
1078   return w;
1079 }
1080 #endif
1081
1082 #ifdef L_umoddi3
1083 UDWtype
1084 __umoddi3 (UDWtype u, UDWtype v)
1085 {
1086   UDWtype w;
1087
1088   (void) __udivmoddi4 (u, v, &w);
1089
1090   return w;
1091 }
1092 #endif
1093
1094 #ifdef L_udivdi3
1095 UDWtype
1096 __udivdi3 (UDWtype n, UDWtype d)
1097 {
1098   return __udivmoddi4 (n, d, (UDWtype *) 0);
1099 }
1100 #endif
1101 \f
1102 #ifdef L_cmpdi2
1103 word_type
1104 __cmpdi2 (DWtype a, DWtype b)
1105 {
1106   const DWunion au = {.ll = a};
1107   const DWunion bu = {.ll = b};
1108
1109   if (au.s.high < bu.s.high)
1110     return 0;
1111   else if (au.s.high > bu.s.high)
1112     return 2;
1113   if ((UWtype) au.s.low < (UWtype) bu.s.low)
1114     return 0;
1115   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1116     return 2;
1117   return 1;
1118 }
1119 #endif
1120
1121 #ifdef L_ucmpdi2
1122 word_type
1123 __ucmpdi2 (DWtype a, DWtype b)
1124 {
1125   const DWunion au = {.ll = a};
1126   const DWunion bu = {.ll = b};
1127
1128   if ((UWtype) au.s.high < (UWtype) bu.s.high)
1129     return 0;
1130   else if ((UWtype) au.s.high > (UWtype) bu.s.high)
1131     return 2;
1132   if ((UWtype) au.s.low < (UWtype) bu.s.low)
1133     return 0;
1134   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1135     return 2;
1136   return 1;
1137 }
1138 #endif
1139 \f
1140 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1141 DWtype
1142 __fixunstfDI (TFtype a)
1143 {
1144   if (a < 0)
1145     return 0;
1146
1147   /* Compute high word of result, as a flonum.  */
1148   const TFtype b = (a / Wtype_MAXp1_F);
1149   /* Convert that to fixed (but not to DWtype!),
1150      and shift it into the high word.  */
1151   UDWtype v = (UWtype) b;
1152   v <<= W_TYPE_SIZE;
1153   /* Remove high part from the TFtype, leaving the low part as flonum.  */
1154   a -= (TFtype)v;
1155   /* Convert that to fixed (but not to DWtype!) and add it in.
1156      Sometimes A comes out negative.  This is significant, since
1157      A has more bits than a long int does.  */
1158   if (a < 0)
1159     v -= (UWtype) (- a);
1160   else
1161     v += (UWtype) a;
1162   return v;
1163 }
1164 #endif
1165
1166 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1167 DWtype
1168 __fixtfdi (TFtype a)
1169 {
1170   if (a < 0)
1171     return - __fixunstfDI (-a);
1172   return __fixunstfDI (a);
1173 }
1174 #endif
1175
1176 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1177 DWtype
1178 __fixunsxfDI (XFtype a)
1179 {
1180   if (a < 0)
1181     return 0;
1182
1183   /* Compute high word of result, as a flonum.  */
1184   const XFtype b = (a / Wtype_MAXp1_F);
1185   /* Convert that to fixed (but not to DWtype!),
1186      and shift it into the high word.  */
1187   UDWtype v = (UWtype) b;
1188   v <<= W_TYPE_SIZE;
1189   /* Remove high part from the XFtype, leaving the low part as flonum.  */
1190   a -= (XFtype)v;
1191   /* Convert that to fixed (but not to DWtype!) and add it in.
1192      Sometimes A comes out negative.  This is significant, since
1193      A has more bits than a long int does.  */
1194   if (a < 0)
1195     v -= (UWtype) (- a);
1196   else
1197     v += (UWtype) a;
1198   return v;
1199 }
1200 #endif
1201
1202 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1203 DWtype
1204 __fixxfdi (XFtype a)
1205 {
1206   if (a < 0)
1207     return - __fixunsxfDI (-a);
1208   return __fixunsxfDI (a);
1209 }
1210 #endif
1211
1212 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1213 DWtype
1214 __fixunsdfDI (DFtype a)
1215 {
1216   /* Get high part of result.  The division here will just moves the radix
1217      point and will not cause any rounding.  Then the conversion to integral
1218      type chops result as desired.  */
1219   const UWtype hi = a / Wtype_MAXp1_F;
1220
1221   /* Get low part of result.  Convert `hi' to floating type and scale it back,
1222      then subtract this from the number being converted.  This leaves the low
1223      part.  Convert that to integral type.  */
1224   const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
1225
1226   /* Assemble result from the two parts.  */
1227   return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1228 }
1229 #endif
1230
1231 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1232 DWtype
1233 __fixdfdi (DFtype a)
1234 {
1235   if (a < 0)
1236     return - __fixunsdfDI (-a);
1237   return __fixunsdfDI (a);
1238 }
1239 #endif
1240
1241 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1242 DWtype
1243 __fixunssfDI (SFtype a)
1244 {
1245 #if LIBGCC2_HAS_DF_MODE
1246   /* Convert the SFtype to a DFtype, because that is surely not going
1247      to lose any bits.  Some day someone else can write a faster version
1248      that avoids converting to DFtype, and verify it really works right.  */
1249   const DFtype dfa = a;
1250
1251   /* Get high part of result.  The division here will just moves the radix
1252      point and will not cause any rounding.  Then the conversion to integral
1253      type chops result as desired.  */
1254   const UWtype hi = dfa / Wtype_MAXp1_F;
1255
1256   /* Get low part of result.  Convert `hi' to floating type and scale it back,
1257      then subtract this from the number being converted.  This leaves the low
1258      part.  Convert that to integral type.  */
1259   const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
1260
1261   /* Assemble result from the two parts.  */
1262   return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1263 #elif FLT_MANT_DIG < W_TYPE_SIZE
1264   if (a < 1)
1265     return 0;
1266   if (a < Wtype_MAXp1_F)
1267     return (UWtype)a;
1268   if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
1269     {
1270       /* Since we know that there are fewer significant bits in the SFmode
1271          quantity than in a word, we know that we can convert out all the
1272          significant bits in one step, and thus avoid losing bits.  */
1273
1274       /* ??? This following loop essentially performs frexpf.  If we could
1275          use the real libm function, or poke at the actual bits of the fp
1276          format, it would be significantly faster.  */
1277
1278       UWtype shift = 0, counter;
1279       SFtype msb;
1280
1281       a /= Wtype_MAXp1_F;
1282       for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
1283         {
1284           SFtype counterf = (UWtype)1 << counter;
1285           if (a >= counterf)
1286             {
1287               shift |= counter;
1288               a /= counterf;
1289             }
1290         }
1291
1292       /* Rescale into the range of one word, extract the bits of that
1293          one word, and shift the result into position.  */
1294       a *= Wtype_MAXp1_F;
1295       counter = a;
1296       return (DWtype)counter << shift;
1297     }
1298   return -1;
1299 #else
1300 # error
1301 #endif
1302 }
1303 #endif
1304
1305 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1306 DWtype
1307 __fixsfdi (SFtype a)
1308 {
1309   if (a < 0)
1310     return - __fixunssfDI (-a);
1311   return __fixunssfDI (a);
1312 }
1313 #endif
1314
1315 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1316 XFtype
1317 __floatdixf (DWtype u)
1318 {
1319   XFtype d = (Wtype) (u >> W_TYPE_SIZE);
1320   d *= Wtype_MAXp1_F;
1321   d += (UWtype)u;
1322   return d;
1323 }
1324 #endif
1325
1326 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1327 TFtype
1328 __floatditf (DWtype u)
1329 {
1330   TFtype d = (Wtype) (u >> W_TYPE_SIZE);
1331   d *= Wtype_MAXp1_F;
1332   d += (UWtype)u;
1333   return d;
1334 }
1335 #endif
1336
1337 #if defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE
1338 DFtype
1339 __floatdidf (DWtype u)
1340 {
1341   DFtype d = (Wtype) (u >> W_TYPE_SIZE);
1342   d *= Wtype_MAXp1_F;
1343   d += (UWtype)u;
1344   return d;
1345 }
1346 #endif
1347
1348 #if defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE
1349 #define DI_SIZE (W_TYPE_SIZE * 2)
1350 #define SF_SIZE FLT_MANT_DIG
1351
1352 SFtype
1353 __floatdisf (DWtype u)
1354 {
1355 #if SF_SIZE >= W_TYPE_SIZE
1356   /* When the word size is small, we never get any rounding error.  */
1357   SFtype f = (Wtype) (u >> W_TYPE_SIZE);
1358   f *= Wtype_MAXp1_F;
1359   f += (UWtype)u;
1360   return f;
1361 #elif LIBGCC2_HAS_DF_MODE
1362
1363 #if LIBGCC2_DOUBLE_TYPE_SIZE == 64
1364 #define DF_SIZE DBL_MANT_DIG
1365 #elif LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1366 #define DF_SIZE LDBL_MANT_DIG
1367 #else
1368 # error
1369 #endif
1370
1371 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1372
1373   /* Protect against double-rounding error.
1374      Represent any low-order bits, that might be truncated by a bit that
1375      won't be lost.  The bit can go in anywhere below the rounding position
1376      of the SFmode.  A fixed mask and bit position handles all usual
1377      configurations.  It doesn't handle the case of 128-bit DImode, however.  */
1378   if (DF_SIZE < DI_SIZE
1379       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1380     {
1381       if (! (- ((DWtype) 1 << DF_SIZE) < u
1382              && u < ((DWtype) 1 << DF_SIZE)))
1383         {
1384           if ((UDWtype) u & (REP_BIT - 1))
1385             {
1386               u &= ~ (REP_BIT - 1);
1387               u |= REP_BIT;
1388             }
1389         }
1390     }
1391
1392   /* Do the calculation in DFmode so that we don't lose any of the
1393      precision of the high word while multiplying it.  */
1394   DFtype f = (Wtype) (u >> W_TYPE_SIZE);
1395   f *= Wtype_MAXp1_F;
1396   f += (UWtype)u;
1397   return (SFtype) f;
1398 #else
1399   /* Finally, the word size is larger than the number of bits in SFmode,
1400      and we've got no DFmode.  The only way to avoid double rounding is
1401      to special case the extraction.  */
1402
1403   /* If there are no high bits set, fall back to one conversion.  */
1404   if ((Wtype)u == u)
1405     return (SFtype)(Wtype)u;
1406
1407   /* Otherwise, find the power of two.  */
1408   Wtype hi = u >> W_TYPE_SIZE;
1409   if (hi < 0)
1410     hi = -hi;
1411
1412   UWtype count, shift;
1413   count_leading_zeros (count, hi);
1414
1415   /* No leading bits means u == minimum.  */
1416   if (count == 0)
1417     return -(Wtype_MAXp1_F * Wtype_MAXp1_F / 2);
1418
1419   shift = W_TYPE_SIZE - count;
1420
1421   /* Shift down the most significant bits.  */
1422   hi = u >> shift;
1423
1424   /* If we lost any nonzero bits, set the lsb to ensure correct rounding.  */
1425   if (u & ((1 << shift) - 1))
1426     hi |= 1;
1427
1428   /* Convert the one word of data, and rescale.  */
1429   SFtype f = hi;
1430   f *= (UWtype)1 << shift;
1431   return f;
1432 #endif
1433 }
1434 #endif
1435
1436 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1437 /* Reenable the normal types, in case limits.h needs them.  */
1438 #undef char
1439 #undef short
1440 #undef int
1441 #undef long
1442 #undef unsigned
1443 #undef float
1444 #undef double
1445 #undef MIN
1446 #undef MAX
1447 #include <limits.h>
1448
1449 UWtype
1450 __fixunsxfSI (XFtype a)
1451 {
1452   if (a >= - (DFtype) Wtype_MIN)
1453     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1454   return (Wtype) a;
1455 }
1456 #endif
1457
1458 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1459 /* Reenable the normal types, in case limits.h needs them.  */
1460 #undef char
1461 #undef short
1462 #undef int
1463 #undef long
1464 #undef unsigned
1465 #undef float
1466 #undef double
1467 #undef MIN
1468 #undef MAX
1469 #include <limits.h>
1470
1471 UWtype
1472 __fixunsdfSI (DFtype a)
1473 {
1474   if (a >= - (DFtype) Wtype_MIN)
1475     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1476   return (Wtype) a;
1477 }
1478 #endif
1479
1480 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1481 /* Reenable the normal types, in case limits.h needs them.  */
1482 #undef char
1483 #undef short
1484 #undef int
1485 #undef long
1486 #undef unsigned
1487 #undef float
1488 #undef double
1489 #undef MIN
1490 #undef MAX
1491 #include <limits.h>
1492
1493 UWtype
1494 __fixunssfSI (SFtype a)
1495 {
1496   if (a >= - (SFtype) Wtype_MIN)
1497     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1498   return (Wtype) a;
1499 }
1500 #endif
1501 \f
1502 /* Integer power helper used from __builtin_powi for non-constant
1503    exponents.  */
1504
1505 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1506     || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1507     || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1508     || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1509 # if defined(L_powisf2)
1510 #  define TYPE SFtype
1511 #  define NAME __powisf2
1512 # elif defined(L_powidf2)
1513 #  define TYPE DFtype
1514 #  define NAME __powidf2
1515 # elif defined(L_powixf2)
1516 #  define TYPE XFtype
1517 #  define NAME __powixf2
1518 # elif defined(L_powitf2)
1519 #  define TYPE TFtype
1520 #  define NAME __powitf2
1521 # endif
1522
1523 #undef int
1524 #undef unsigned
1525 TYPE
1526 NAME (TYPE x, int m)
1527 {
1528   unsigned int n = m < 0 ? -m : m;
1529   TYPE y = n % 2 ? x : 1;
1530   while (n >>= 1)
1531     {
1532       x = x * x;
1533       if (n % 2)
1534         y = y * x;
1535     }
1536   return m < 0 ? 1/y : y;
1537 }
1538
1539 #endif
1540 \f
1541 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1542     || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1543     || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1544     || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1545
1546 #undef float
1547 #undef double
1548 #undef long
1549
1550 #if defined(L_mulsc3) || defined(L_divsc3)
1551 # define MTYPE  SFtype
1552 # define CTYPE  SCtype
1553 # define MODE   sc
1554 # define CEXT   f
1555 # define NOTRUNC __FLT_EVAL_METHOD__ == 0
1556 #elif defined(L_muldc3) || defined(L_divdc3)
1557 # define MTYPE  DFtype
1558 # define CTYPE  DCtype
1559 # define MODE   dc
1560 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1561 #  define CEXT  l
1562 #  define NOTRUNC 1
1563 # else
1564 #  define CEXT
1565 #  define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1
1566 # endif
1567 #elif defined(L_mulxc3) || defined(L_divxc3)
1568 # define MTYPE  XFtype
1569 # define CTYPE  XCtype
1570 # define MODE   xc
1571 # define CEXT   l
1572 # define NOTRUNC 1
1573 #elif defined(L_multc3) || defined(L_divtc3)
1574 # define MTYPE  TFtype
1575 # define CTYPE  TCtype
1576 # define MODE   tc
1577 # define CEXT   l
1578 # define NOTRUNC 1
1579 #else
1580 # error
1581 #endif
1582
1583 #define CONCAT3(A,B,C)  _CONCAT3(A,B,C)
1584 #define _CONCAT3(A,B,C) A##B##C
1585
1586 #define CONCAT2(A,B)    _CONCAT2(A,B)
1587 #define _CONCAT2(A,B)   A##B
1588
1589 /* All of these would be present in a full C99 implementation of <math.h>
1590    and <complex.h>.  Our problem is that only a few systems have such full
1591    implementations.  Further, libgcc_s.so isn't currently linked against
1592    libm.so, and even for systems that do provide full C99, the extra overhead
1593    of all programs using libgcc having to link against libm.  So avoid it.  */
1594
1595 #define isnan(x)        __builtin_expect ((x) != (x), 0)
1596 #define isfinite(x)     __builtin_expect (!isnan((x) - (x)), 1)
1597 #define isinf(x)        __builtin_expect (!isnan(x) & !isfinite(x), 0)
1598
1599 #define INFINITY        CONCAT2(__builtin_inf, CEXT) ()
1600 #define I               1i
1601
1602 /* Helpers to make the following code slightly less gross.  */
1603 #define COPYSIGN        CONCAT2(__builtin_copysign, CEXT)
1604 #define FABS            CONCAT2(__builtin_fabs, CEXT)
1605
1606 /* Verify that MTYPE matches up with CEXT.  */
1607 extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
1608
1609 /* Ensure that we've lost any extra precision.  */
1610 #if NOTRUNC
1611 # define TRUNC(x)
1612 #else
1613 # define TRUNC(x)       __asm__ ("" : "=m"(x) : "m"(x))
1614 #endif
1615
1616 #if defined(L_mulsc3) || defined(L_muldc3) \
1617     || defined(L_mulxc3) || defined(L_multc3)
1618
1619 CTYPE
1620 CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
1621 {
1622   MTYPE ac, bd, ad, bc, x, y;
1623
1624   ac = a * c;
1625   bd = b * d;
1626   ad = a * d;
1627   bc = b * c;
1628
1629   TRUNC (ac);
1630   TRUNC (bd);
1631   TRUNC (ad);
1632   TRUNC (bc);
1633
1634   x = ac - bd;
1635   y = ad + bc;
1636
1637   if (isnan (x) && isnan (y))
1638     {
1639       /* Recover infinities that computed as NaN + iNaN.  */
1640       _Bool recalc = 0;
1641       if (isinf (a) || isinf (b))
1642         {
1643           /* z is infinite.  "Box" the infinity and change NaNs in
1644              the other factor to 0.  */
1645           a = COPYSIGN (isinf (a) ? 1 : 0, a);
1646           b = COPYSIGN (isinf (b) ? 1 : 0, b);
1647           if (isnan (c)) c = COPYSIGN (0, c);
1648           if (isnan (d)) d = COPYSIGN (0, d);
1649           recalc = 1;
1650         }
1651      if (isinf (c) || isinf (d))
1652         {
1653           /* w is infinite.  "Box" the infinity and change NaNs in
1654              the other factor to 0.  */
1655           c = COPYSIGN (isinf (c) ? 1 : 0, c);
1656           d = COPYSIGN (isinf (d) ? 1 : 0, d);
1657           if (isnan (a)) a = COPYSIGN (0, a);
1658           if (isnan (b)) b = COPYSIGN (0, b);
1659           recalc = 1;
1660         }
1661      if (!recalc
1662           && (isinf (ac) || isinf (bd)
1663               || isinf (ad) || isinf (bc)))
1664         {
1665           /* Recover infinities from overflow by changing NaNs to 0.  */
1666           if (isnan (a)) a = COPYSIGN (0, a);
1667           if (isnan (b)) b = COPYSIGN (0, b);
1668           if (isnan (c)) c = COPYSIGN (0, c);
1669           if (isnan (d)) d = COPYSIGN (0, d);
1670           recalc = 1;
1671         }
1672       if (recalc)
1673         {
1674           x = INFINITY * (a * c - b * d);
1675           y = INFINITY * (a * d + b * c);
1676         }
1677     }
1678
1679   return x + I * y;
1680 }
1681 #endif /* complex multiply */
1682
1683 #if defined(L_divsc3) || defined(L_divdc3) \
1684     || defined(L_divxc3) || defined(L_divtc3)
1685
1686 CTYPE
1687 CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
1688 {
1689   MTYPE denom, ratio, x, y;
1690
1691   /* ??? We can get better behavior from logarithmic scaling instead of
1692      the division.  But that would mean starting to link libgcc against
1693      libm.  We could implement something akin to ldexp/frexp as gcc builtins
1694      fairly easily...  */
1695   if (FABS (c) < FABS (d))
1696     {
1697       ratio = c / d;
1698       denom = (c * ratio) + d;
1699       x = ((a * ratio) + b) / denom;
1700       y = ((b * ratio) - a) / denom;
1701     }
1702   else
1703     {
1704       ratio = d / c;
1705       denom = (d * ratio) + c;
1706       x = ((b * ratio) + a) / denom;
1707       y = (b - (a * ratio)) / denom;
1708     }
1709
1710   /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
1711      are nonzero/zero, infinite/finite, and finite/infinite.  */
1712   if (isnan (x) && isnan (y))
1713     {
1714       if (denom == 0.0 && (!isnan (a) || !isnan (b)))
1715         {
1716           x = COPYSIGN (INFINITY, c) * a;
1717           y = COPYSIGN (INFINITY, c) * b;
1718         }
1719       else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d))
1720         {
1721           a = COPYSIGN (isinf (a) ? 1 : 0, a);
1722           b = COPYSIGN (isinf (b) ? 1 : 0, b);
1723           x = INFINITY * (a * c + b * d);
1724           y = INFINITY * (b * c - a * d);
1725         }
1726       else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b))
1727         {
1728           c = COPYSIGN (isinf (c) ? 1 : 0, c);
1729           d = COPYSIGN (isinf (d) ? 1 : 0, d);
1730           x = 0.0 * (a * c + b * d);
1731           y = 0.0 * (b * c - a * d);
1732         }
1733     }
1734
1735   return x + I * y;
1736 }
1737 #endif /* complex divide */
1738
1739 #endif /* all complex float routines */
1740 \f
1741 /* From here on down, the routines use normal data types.  */
1742
1743 #define SItype bogus_type
1744 #define USItype bogus_type
1745 #define DItype bogus_type
1746 #define UDItype bogus_type
1747 #define SFtype bogus_type
1748 #define DFtype bogus_type
1749 #undef Wtype
1750 #undef UWtype
1751 #undef HWtype
1752 #undef UHWtype
1753 #undef DWtype
1754 #undef UDWtype
1755
1756 #undef char
1757 #undef short
1758 #undef int
1759 #undef long
1760 #undef unsigned
1761 #undef float
1762 #undef double
1763 \f
1764 #ifdef L__gcc_bcmp
1765
1766 /* Like bcmp except the sign is meaningful.
1767    Result is negative if S1 is less than S2,
1768    positive if S1 is greater, 0 if S1 and S2 are equal.  */
1769
1770 int
1771 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1772 {
1773   while (size > 0)
1774     {
1775       const unsigned char c1 = *s1++, c2 = *s2++;
1776       if (c1 != c2)
1777         return c1 - c2;
1778       size--;
1779     }
1780   return 0;
1781 }
1782
1783 #endif
1784 \f
1785 /* __eprintf used to be used by GCC's private version of <assert.h>.
1786    We no longer provide that header, but this routine remains in libgcc.a
1787    for binary backward compatibility.  Note that it is not included in
1788    the shared version of libgcc.  */
1789 #ifdef L_eprintf
1790 #ifndef inhibit_libc
1791
1792 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1793 #include <stdio.h>
1794
1795 void
1796 __eprintf (const char *string, const char *expression,
1797            unsigned int line, const char *filename)
1798 {
1799   fprintf (stderr, string, expression, line, filename);
1800   fflush (stderr);
1801   abort ();
1802 }
1803
1804 #endif
1805 #endif
1806
1807 \f
1808 #ifdef L_clear_cache
1809 /* Clear part of an instruction cache.  */
1810
1811 void
1812 __clear_cache (char *beg __attribute__((__unused__)),
1813                char *end __attribute__((__unused__)))
1814 {
1815 #ifdef CLEAR_INSN_CACHE
1816   CLEAR_INSN_CACHE (beg, end);
1817 #endif /* CLEAR_INSN_CACHE */
1818 }
1819
1820 #endif /* L_clear_cache */
1821 \f
1822 #ifdef L_enable_execute_stack
1823 /* Attempt to turn on execute permission for the stack.  */
1824
1825 #ifdef ENABLE_EXECUTE_STACK
1826   ENABLE_EXECUTE_STACK
1827 #else
1828 void
1829 __enable_execute_stack (void *addr __attribute__((__unused__)))
1830 {}
1831 #endif /* ENABLE_EXECUTE_STACK */
1832
1833 #endif /* L_enable_execute_stack */
1834 \f
1835 #ifdef L_trampoline
1836
1837 /* Jump to a trampoline, loading the static chain address.  */
1838
1839 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1840
1841 int
1842 getpagesize (void)
1843 {
1844 #ifdef _ALPHA_
1845   return 8192;
1846 #else
1847   return 4096;
1848 #endif
1849 }
1850
1851 #ifdef __i386__
1852 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1853 #endif
1854
1855 int
1856 mprotect (char *addr, int len, int prot)
1857 {
1858   int np, op;
1859
1860   if (prot == 7)
1861     np = 0x40;
1862   else if (prot == 5)
1863     np = 0x20;
1864   else if (prot == 4)
1865     np = 0x10;
1866   else if (prot == 3)
1867     np = 0x04;
1868   else if (prot == 1)
1869     np = 0x02;
1870   else if (prot == 0)
1871     np = 0x01;
1872
1873   if (VirtualProtect (addr, len, np, &op))
1874     return 0;
1875   else
1876     return -1;
1877 }
1878
1879 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1880
1881 #ifdef TRANSFER_FROM_TRAMPOLINE
1882 TRANSFER_FROM_TRAMPOLINE
1883 #endif
1884 #endif /* L_trampoline */
1885 \f
1886 #ifndef __CYGWIN__
1887 #ifdef L__main
1888
1889 #include "gbl-ctors.h"
1890
1891 /* Some systems use __main in a way incompatible with its use in gcc, in these
1892    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1893    give the same symbol without quotes for an alternative entry point.  You
1894    must define both, or neither.  */
1895 #ifndef NAME__MAIN
1896 #define NAME__MAIN "__main"
1897 #define SYMBOL__MAIN __main
1898 #endif
1899
1900 #if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP)
1901 #undef HAS_INIT_SECTION
1902 #define HAS_INIT_SECTION
1903 #endif
1904
1905 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1906
1907 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1908    code to run constructors.  In that case, we need to handle EH here, too.  */
1909
1910 #ifdef EH_FRAME_SECTION_NAME
1911 #include "unwind-dw2-fde.h"
1912 extern unsigned char __EH_FRAME_BEGIN__[];
1913 #endif
1914
1915 /* Run all the global destructors on exit from the program.  */
1916
1917 void
1918 __do_global_dtors (void)
1919 {
1920 #ifdef DO_GLOBAL_DTORS_BODY
1921   DO_GLOBAL_DTORS_BODY;
1922 #else
1923   static func_ptr *p = __DTOR_LIST__ + 1;
1924   while (*p)
1925     {
1926       p++;
1927       (*(p-1)) ();
1928     }
1929 #endif
1930 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1931   {
1932     static int completed = 0;
1933     if (! completed)
1934       {
1935         completed = 1;
1936         __deregister_frame_info (__EH_FRAME_BEGIN__);
1937       }
1938   }
1939 #endif
1940 }
1941 #endif
1942
1943 #ifndef HAS_INIT_SECTION
1944 /* Run all the global constructors on entry to the program.  */
1945
1946 void
1947 __do_global_ctors (void)
1948 {
1949 #ifdef EH_FRAME_SECTION_NAME
1950   {
1951     static struct object object;
1952     __register_frame_info (__EH_FRAME_BEGIN__, &object);
1953   }
1954 #endif
1955   DO_GLOBAL_CTORS_BODY;
1956   atexit (__do_global_dtors);
1957 }
1958 #endif /* no HAS_INIT_SECTION */
1959
1960 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1961 /* Subroutine called automatically by `main'.
1962    Compiling a global function named `main'
1963    produces an automatic call to this function at the beginning.
1964
1965    For many systems, this routine calls __do_global_ctors.
1966    For systems which support a .init section we use the .init section
1967    to run __do_global_ctors, so we need not do anything here.  */
1968
1969 extern void SYMBOL__MAIN (void);
1970 void
1971 SYMBOL__MAIN (void)
1972 {
1973   /* Support recursive calls to `main': run initializers just once.  */
1974   static int initialized;
1975   if (! initialized)
1976     {
1977       initialized = 1;
1978       __do_global_ctors ();
1979     }
1980 }
1981 #endif /* no HAS_INIT_SECTION or INVOKE__main */
1982
1983 #endif /* L__main */
1984 #endif /* __CYGWIN__ */
1985 \f
1986 #ifdef L_ctors
1987
1988 #include "gbl-ctors.h"
1989
1990 /* Provide default definitions for the lists of constructors and
1991    destructors, so that we don't get linker errors.  These symbols are
1992    intentionally bss symbols, so that gld and/or collect will provide
1993    the right values.  */
1994
1995 /* We declare the lists here with two elements each,
1996    so that they are valid empty lists if no other definition is loaded.
1997
1998    If we are using the old "set" extensions to have the gnu linker
1999    collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2000    must be in the bss/common section.
2001
2002    Long term no port should use those extensions.  But many still do.  */
2003 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2004 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2005 func_ptr __CTOR_LIST__[2] = {0, 0};
2006 func_ptr __DTOR_LIST__[2] = {0, 0};
2007 #else
2008 func_ptr __CTOR_LIST__[2];
2009 func_ptr __DTOR_LIST__[2];
2010 #endif
2011 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2012 #endif /* L_ctors */