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 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* As a special exception, if you link this library with other files,
  22    some of which are compiled with GCC, to produce an executable,
  23    this library does not by itself cause the resulting executable
  24    to be covered by the GNU General Public License.
  25    This exception does not however invalidate any other reasons why
  26    the executable file might be covered by the GNU General Public License.  */
  27
  28 /* It is incorrect to include config.h here, because this file is being
  29    compiled for the target, and hence definitions concerning only the host
  30    do not apply.  */
  31
  32 #include "tconfig.h"
  33 #include "machmode.h"
  34 #ifndef L_trampoline
  35 #include <stddef.h>
  36 #endif
  37
  38 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  39 #ifdef abort
  40 #undef abort
  41 #endif
  42
  43 /* In the first part of this file, we are interfacing to calls generated
  44    by the compiler itself.  These calls pass values into these routines
  45    which have very specific modes (rather than very specific types), and
  46    these compiler-generated calls also expect any return values to have
  47    very specific modes (rather than very specific types).  Thus, we need
  48    to avoid using regular C language type names in this part of the file
  49    because the sizes for those types can be configured to be anything.
  50    Instead we use the following special type names.  */
  51
  52 typedef unsigned int UQItype    __attribute__ ((mode (QI)));
  53 typedef          int SItype     __attribute__ ((mode (SI)));
  54 typedef unsigned int USItype    __attribute__ ((mode (SI)));
  55 typedef          int DItype     __attribute__ ((mode (DI)));
  56 typedef unsigned int UDItype    __attribute__ ((mode (DI)));
  57 typedef         float SFtype    __attribute__ ((mode (SF)));
  58 typedef         float DFtype    __attribute__ ((mode (DF)));
  59 #if LONG_DOUBLE_TYPE_SIZE == 96
  60 typedef         float XFtype    __attribute__ ((mode (XF)));
  61 #endif
  62 #if LONG_DOUBLE_TYPE_SIZE == 128
  63 typedef         float TFtype    __attribute__ ((mode (TF)));
  64 #endif
  65
  66 #if BITS_PER_WORD==16
  67 typedef int word_type __attribute__ ((mode (HI)));
  68 #endif
  69 #if BITS_PER_WORD==32
  70 typedef int word_type __attribute__ ((mode (SI)));
  71 #endif
  72 #if BITS_PER_WORD==64
  73 typedef int word_type __attribute__ ((mode (DI)));
  74 #endif
  75
  76 /* Make sure that we don't accidentally use any normal C language built-in
  77    type names in the first part of this file.  Instead we want to use *only*
  78    the type names defined above.  The following macro definitions insure
  79    that if we *do* accidentally use some normal C language built-in type name,
  80    we will get a syntax error.  */
  81
  82 #define char bogus_type
  83 #define short bogus_type
  84 #define int bogus_type
  85 #define long bogus_type
  86 #define unsigned bogus_type
  87 #define float bogus_type
  88 #define double bogus_type
  89
  90 #define SI_TYPE_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  91
  92 /* DIstructs are pairs of SItype values in the order determined by
  93    WORDS_BIG_ENDIAN.  */
  94
  95 #if WORDS_BIG_ENDIAN
  96   struct DIstruct {SItype high, low;};
  97 #else
  98   struct DIstruct {SItype low, high;};
  99 #endif
 100
 101 /* We need this union to unpack/pack DImode values, since we don't have
 102    any arithmetic yet.  Incoming DImode parameters are stored into the
 103    `ll' field, and the unpacked result is read from the struct `s'.  */
 104
 105 typedef union
 106 {
 107   struct DIstruct s;
 108   DItype ll;
 109 } DIunion;
 110
 111 #if defined (L_udivmoddi4) || defined (L_muldi3) || defined (L_udiv_w_sdiv)
 112
 113 #include "longlong.h"
 114
 115 #endif /* udiv or mul */
 116
 117 extern DItype __fixunssfdi (SFtype a);
 118 extern DItype __fixunsdfdi (DFtype a);
 119 #if LONG_DOUBLE_TYPE_SIZE == 96
 120 extern DItype __fixunsxfdi (XFtype a);
 121 #endif
 122 #if LONG_DOUBLE_TYPE_SIZE == 128
 123 extern DItype __fixunstfdi (TFtype a);
 124 #endif
 125 \f
 126 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
 127 #if defined (L_divdi3) || defined (L_moddi3)
 128 static inline
 129 #endif
 130 DItype
 131 __negdi2 (u)
 132      DItype u;
 133 {
 134   DIunion w;
 135   DIunion uu;
 136
 137   uu.ll = u;
 138
 139   w.s.low = -uu.s.low;
 140   w.s.high = -uu.s.high - ((USItype) w.s.low > 0);
 141
 142   return w.ll;
 143 }
 144 #endif
 145 \f
 146 #ifdef L_lshldi3
 147 DItype
 148 __lshldi3 (u, b)
 149      DItype u;
 150      SItype b;
 151 {
 152   DIunion w;
 153   SItype bm;
 154   DIunion uu;
 155
 156   if (b == 0)
 157     return u;
 158
 159   uu.ll = u;
 160
 161   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 162   if (bm <= 0)
 163     {
 164       w.s.low = 0;
 165       w.s.high = (USItype)uu.s.low << -bm;
 166     }
 167   else
 168     {
 169       USItype carries = (USItype)uu.s.low >> bm;
 170       w.s.low = (USItype)uu.s.low << b;
 171       w.s.high = ((USItype)uu.s.high << b) | carries;
 172     }
 173
 174   return w.ll;
 175 }
 176 #endif
 177
 178 #ifdef L_lshrdi3
 179 DItype
 180 __lshrdi3 (u, b)
 181      DItype u;
 182      SItype b;
 183 {
 184   DIunion w;
 185   SItype bm;
 186   DIunion uu;
 187
 188   if (b == 0)
 189     return u;
 190
 191   uu.ll = u;
 192
 193   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 194   if (bm <= 0)
 195     {
 196       w.s.high = 0;
 197       w.s.low = (USItype)uu.s.high >> -bm;
 198     }
 199   else
 200     {
 201       USItype carries = (USItype)uu.s.high << bm;
 202       w.s.high = (USItype)uu.s.high >> b;
 203       w.s.low = ((USItype)uu.s.low >> b) | carries;
 204     }
 205
 206   return w.ll;
 207 }
 208 #endif
 209
 210 #ifdef L_ashldi3
 211 DItype
 212 __ashldi3 (u, b)
 213      DItype u;
 214      SItype b;
 215 {
 216   DIunion w;
 217   SItype bm;
 218   DIunion uu;
 219
 220   if (b == 0)
 221     return u;
 222
 223   uu.ll = u;
 224
 225   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 226   if (bm <= 0)
 227     {
 228       w.s.low = 0;
 229       w.s.high = (USItype)uu.s.low << -bm;
 230     }
 231   else
 232     {
 233       USItype carries = (USItype)uu.s.low >> bm;
 234       w.s.low = (USItype)uu.s.low << b;
 235       w.s.high = ((USItype)uu.s.high << b) | carries;
 236     }
 237
 238   return w.ll;
 239 }
 240 #endif
 241
 242 #ifdef L_ashrdi3
 243 DItype
 244 __ashrdi3 (u, b)
 245      DItype u;
 246      SItype b;
 247 {
 248   DIunion w;
 249   SItype bm;
 250   DIunion uu;
 251
 252   if (b == 0)
 253     return u;
 254
 255   uu.ll = u;
 256
 257   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 258   if (bm <= 0)
 259     {
 260       /* w.s.high = 1..1 or 0..0 */
 261       w.s.high = uu.s.high >> (sizeof (SItype) * BITS_PER_UNIT - 1);
 262       w.s.low = uu.s.high >> -bm;
 263     }
 264   else
 265     {
 266       USItype carries = (USItype)uu.s.high << bm;
 267       w.s.high = uu.s.high >> b;
 268       w.s.low = ((USItype)uu.s.low >> b) | carries;
 269     }
 270
 271   return w.ll;
 272 }
 273 #endif
 274 \f
 275 #ifdef L_ffsdi2
 276 DItype
 277 __ffsdi2 (u)
 278      DItype u;
 279 {
 280   DIunion uu, w;
 281   uu.ll = u;
 282   w.s.high = 0;
 283   w.s.low = ffs (uu.s.low);
 284   if (w.s.low != 0)
 285     return w.ll;
 286   w.s.low = ffs (uu.s.high);
 287   if (w.s.low != 0)
 288     {
 289       w.s.low += BITS_PER_UNIT * sizeof (SItype);
 290       return w.ll;
 291     }
 292   return w.ll;
 293 }
 294 #endif
 295 \f
 296 #ifdef L_muldi3
 297 DItype
 298 __muldi3 (u, v)
 299      DItype u, v;
 300 {
 301   DIunion w;
 302   DIunion uu, vv;
 303
 304   uu.ll = u,
 305   vv.ll = v;
 306
 307   w.ll = __umulsidi3 (uu.s.low, vv.s.low);
 308   w.s.high += ((USItype) uu.s.low * (USItype) vv.s.high
 309                + (USItype) uu.s.high * (USItype) vv.s.low);
 310
 311   return w.ll;
 312 }
 313 #endif
 314 \f
 315 #ifdef L_udiv_w_sdiv
 316 USItype
 317 __udiv_w_sdiv (rp, a1, a0, d)
 318      USItype *rp, a1, a0, d;
 319 {
 320   USItype q, r;
 321   USItype c0, c1, b1;
 322
 323   if ((SItype) d >= 0)
 324     {
 325       if (a1 < d - a1 - (a0 >> (SI_TYPE_SIZE - 1)))
 326         {
 327           /* dividend, divisor, and quotient are nonnegative */
 328           sdiv_qrnnd (q, r, a1, a0, d);
 329         }
 330       else
 331         {
 332           /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
 333           sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (SI_TYPE_SIZE - 1));
 334           /* Divide (c1*2^32 + c0) by d */
 335           sdiv_qrnnd (q, r, c1, c0, d);
 336           /* Add 2^31 to quotient */
 337           q += (USItype) 1 << (SI_TYPE_SIZE - 1);
 338         }
 339     }
 340   else
 341     {
 342       b1 = d >> 1;                      /* d/2, between 2^30 and 2^31 - 1 */
 343       c1 = a1 >> 1;                     /* A/2 */
 344       c0 = (a1 << (SI_TYPE_SIZE - 1)) + (a0 >> 1);
 345
 346       if (a1 < b1)                      /* A < 2^32*b1, so A/2 < 2^31*b1 */
 347         {
 348           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 349
 350           r = 2*r + (a0 & 1);           /* Remainder from A/(2*b1) */
 351           if ((d & 1) != 0)
 352             {
 353               if (r >= q)
 354                 r = r - q;
 355               else if (q - r <= d)
 356                 {
 357                   r = r - q + d;
 358                   q--;
 359                 }
 360               else
 361                 {
 362                   r = r - q + 2*d;
 363                   q -= 2;
 364                 }
 365             }
 366         }
 367       else if (c1 < b1)                 /* So 2^31 <= (A/2)/b1 < 2^32 */
 368         {
 369           c1 = (b1 - 1) - c1;
 370           c0 = ~c0;                     /* logical NOT */
 371
 372           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 373
 374           q = ~q;                       /* (A/2)/b1 */
 375           r = (b1 - 1) - r;
 376
 377           r = 2*r + (a0 & 1);           /* A/(2*b1) */
 378
 379           if ((d & 1) != 0)
 380             {
 381               if (r >= q)
 382                 r = r - q;
 383               else if (q - r <= d)
 384                 {
 385                   r = r - q + d;
 386                   q--;
 387                 }
 388               else
 389                 {
 390                   r = r - q + 2*d;
 391                   q -= 2;
 392                 }
 393             }
 394         }
 395       else                              /* Implies c1 = b1 */
 396         {                               /* Hence a1 = d - 1 = 2*b1 - 1 */
 397           if (a0 >= -d)
 398             {
 399               q = -1;
 400               r = a0 + d;
 401             }
 402           else
 403             {
 404               q = -2;
 405               r = a0 + 2*d;
 406             }
 407         }
 408     }
 409
 410   *rp = r;
 411   return q;
 412 }
 413 #endif
 414 \f
 415 #ifdef L_udivmoddi4
 416 static const UQItype __clz_tab[] =
 417 {
 418   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,
 419   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,
 420   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,
 421   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,
 422   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,
 423   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,
 424   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,
 425   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,
 426 };
 427
 428 UDItype
 429 __udivmoddi4 (n, d, rp)
 430      UDItype n, d;
 431      UDItype *rp;
 432 {
 433   DIunion ww;
 434   DIunion nn, dd;
 435   DIunion rr;
 436   USItype d0, d1, n0, n1, n2;
 437   USItype q0, q1;
 438   USItype b, bm;
 439
 440   nn.ll = n;
 441   dd.ll = d;
 442
 443   d0 = dd.s.low;
 444   d1 = dd.s.high;
 445   n0 = nn.s.low;
 446   n1 = nn.s.high;
 447
 448 #if !UDIV_NEEDS_NORMALIZATION
 449   if (d1 == 0)
 450     {
 451       if (d0 > n1)
 452         {
 453           /* 0q = nn / 0D */
 454
 455           udiv_qrnnd (q0, n0, n1, n0, d0);
 456           q1 = 0;
 457
 458           /* Remainder in n0.  */
 459         }
 460       else
 461         {
 462           /* qq = NN / 0d */
 463
 464           if (d0 == 0)
 465             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 466
 467           udiv_qrnnd (q1, n1, 0, n1, d0);
 468           udiv_qrnnd (q0, n0, n1, n0, d0);
 469
 470           /* Remainder in n0.  */
 471         }
 472
 473       if (rp != 0)
 474         {
 475           rr.s.low = n0;
 476           rr.s.high = 0;
 477           *rp = rr.ll;
 478         }
 479     }
 480
 481 #else /* UDIV_NEEDS_NORMALIZATION */
 482
 483   if (d1 == 0)
 484     {
 485       if (d0 > n1)
 486         {
 487           /* 0q = nn / 0D */
 488
 489           count_leading_zeros (bm, d0);
 490
 491           if (bm != 0)
 492             {
 493               /* Normalize, i.e. make the most significant bit of the
 494                  denominator set.  */
 495
 496               d0 = d0 << bm;
 497               n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm));
 498               n0 = n0 << bm;
 499             }
 500
 501           udiv_qrnnd (q0, n0, n1, n0, d0);
 502           q1 = 0;
 503
 504           /* Remainder in n0 >> bm.  */
 505         }
 506       else
 507         {
 508           /* qq = NN / 0d */
 509
 510           if (d0 == 0)
 511             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 512
 513           count_leading_zeros (bm, d0);
 514
 515           if (bm == 0)
 516             {
 517               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 518                  conclude (the most significant bit of n1 is set) /\ (the
 519                  leading quotient digit q1 = 1).
 520
 521                  This special case is necessary, not an optimization.
 522                  (Shifts counts of SI_TYPE_SIZE are undefined.)  */
 523
 524               n1 -= d0;
 525               q1 = 1;
 526             }
 527           else
 528             {
 529               /* Normalize.  */
 530
 531               b = SI_TYPE_SIZE - bm;
 532
 533               d0 = d0 << bm;
 534               n2 = n1 >> b;
 535               n1 = (n1 << bm) | (n0 >> b);
 536               n0 = n0 << bm;
 537
 538               udiv_qrnnd (q1, n1, n2, n1, d0);
 539             }
 540
 541           /* n1 != d0... */
 542
 543           udiv_qrnnd (q0, n0, n1, n0, d0);
 544
 545           /* Remainder in n0 >> bm.  */
 546         }
 547
 548       if (rp != 0)
 549         {
 550           rr.s.low = n0 >> bm;
 551           rr.s.high = 0;
 552           *rp = rr.ll;
 553         }
 554     }
 555 #endif /* UDIV_NEEDS_NORMALIZATION */
 556
 557   else
 558     {
 559       if (d1 > n1)
 560         {
 561           /* 00 = nn / DD */
 562
 563           q0 = 0;
 564           q1 = 0;
 565
 566           /* Remainder in n1n0.  */
 567           if (rp != 0)
 568             {
 569               rr.s.low = n0;
 570               rr.s.high = n1;
 571               *rp = rr.ll;
 572             }
 573         }
 574       else
 575         {
 576           /* 0q = NN / dd */
 577
 578           count_leading_zeros (bm, d1);
 579           if (bm == 0)
 580             {
 581               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 582                  conclude (the most significant bit of n1 is set) /\ (the
 583                  quotient digit q0 = 0 or 1).
 584
 585                  This special case is necessary, not an optimization.  */
 586
 587               /* The condition on the next line takes advantage of that
 588                  n1 >= d1 (true due to program flow).  */
 589               if (n1 > d1 || n0 >= d0)
 590                 {
 591                   q0 = 1;
 592                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 593                 }
 594               else
 595                 q0 = 0;
 596
 597               q1 = 0;
 598
 599               if (rp != 0)
 600                 {
 601                   rr.s.low = n0;
 602                   rr.s.high = n1;
 603                   *rp = rr.ll;
 604                 }
 605             }
 606           else
 607             {
 608               USItype m1, m0;
 609               /* Normalize.  */
 610
 611               b = SI_TYPE_SIZE - bm;
 612
 613               d1 = (d1 << bm) | (d0 >> b);
 614               d0 = d0 << bm;
 615               n2 = n1 >> b;
 616               n1 = (n1 << bm) | (n0 >> b);
 617               n0 = n0 << bm;
 618
 619               udiv_qrnnd (q0, n1, n2, n1, d1);
 620               umul_ppmm (m1, m0, q0, d0);
 621
 622               if (m1 > n1 || (m1 == n1 && m0 > n0))
 623                 {
 624                   q0--;
 625                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
 626                 }
 627
 628               q1 = 0;
 629
 630               /* Remainder in (n1n0 - m1m0) >> bm.  */
 631               if (rp != 0)
 632                 {
 633                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
 634                   rr.s.low = (n1 << b) | (n0 >> bm);
 635                   rr.s.high = n1 >> bm;
 636                   *rp = rr.ll;
 637                 }
 638             }
 639         }
 640     }
 641
 642   ww.s.low = q0;
 643   ww.s.high = q1;
 644   return ww.ll;
 645 }
 646 #endif
 647
 648 #ifdef L_divdi3
 649 UDItype __udivmoddi4 ();
 650
 651 DItype
 652 __divdi3 (u, v)
 653      DItype u, v;
 654 {
 655   SItype c = 0;
 656   DIunion uu, vv;
 657   DItype w;
 658
 659   uu.ll = u;
 660   vv.ll = v;
 661
 662   if (uu.s.high < 0)
 663     c = ~c,
 664     uu.ll = __negdi2 (uu.ll);
 665   if (vv.s.high < 0)
 666     c = ~c,
 667     vv.ll = __negdi2 (vv.ll);
 668
 669   w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0);
 670   if (c)
 671     w = __negdi2 (w);
 672
 673   return w;
 674 }
 675 #endif
 676
 677 #ifdef L_moddi3
 678 UDItype __udivmoddi4 ();
 679 DItype
 680 __moddi3 (u, v)
 681      DItype u, v;
 682 {
 683   SItype c = 0;
 684   DIunion uu, vv;
 685   DItype w;
 686
 687   uu.ll = u;
 688   vv.ll = v;
 689
 690   if (uu.s.high < 0)
 691     c = ~c,
 692     uu.ll = __negdi2 (uu.ll);
 693   if (vv.s.high < 0)
 694     vv.ll = __negdi2 (vv.ll);
 695
 696   (void) __udivmoddi4 (uu.ll, vv.ll, &w);
 697   if (c)
 698     w = __negdi2 (w);
 699
 700   return w;
 701 }
 702 #endif
 703
 704 #ifdef L_umoddi3
 705 UDItype __udivmoddi4 ();
 706 UDItype
 707 __umoddi3 (u, v)
 708      UDItype u, v;
 709 {
 710   UDItype w;
 711
 712   (void) __udivmoddi4 (u, v, &w);
 713
 714   return w;
 715 }
 716 #endif
 717
 718 #ifdef L_udivdi3
 719 UDItype __udivmoddi4 ();
 720 UDItype
 721 __udivdi3 (n, d)
 722      UDItype n, d;
 723 {
 724   return __udivmoddi4 (n, d, (UDItype *) 0);
 725 }
 726 #endif
 727 \f
 728 #ifdef L_cmpdi2
 729 word_type
 730 __cmpdi2 (a, b)
 731      DItype a, b;
 732 {
 733   DIunion au, bu;
 734
 735   au.ll = a, bu.ll = b;
 736
 737   if (au.s.high < bu.s.high)
 738     return 0;
 739   else if (au.s.high > bu.s.high)
 740     return 2;
 741   if ((USItype) au.s.low < (USItype) bu.s.low)
 742     return 0;
 743   else if ((USItype) au.s.low > (USItype) bu.s.low)
 744     return 2;
 745   return 1;
 746 }
 747 #endif
 748
 749 #ifdef L_ucmpdi2
 750 word_type
 751 __ucmpdi2 (a, b)
 752      DItype a, b;
 753 {
 754   DIunion au, bu;
 755
 756   au.ll = a, bu.ll = b;
 757
 758   if ((USItype) au.s.high < (USItype) bu.s.high)
 759     return 0;
 760   else if ((USItype) au.s.high > (USItype) bu.s.high)
 761     return 2;
 762   if ((USItype) au.s.low < (USItype) bu.s.low)
 763     return 0;
 764   else if ((USItype) au.s.low > (USItype) bu.s.low)
 765     return 2;
 766   return 1;
 767 }
 768 #endif
 769 \f
 770 #if defined(L_fixunstfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
 771 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 772 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 773
 774 DItype
 775 __fixunstfdi (a)
 776      TFtype a;
 777 {
 778   TFtype b;
 779   UDItype v;
 780
 781   if (a < 0)
 782     return 0;
 783
 784   /* Compute high word of result, as a flonum.  */
 785   b = (a / HIGH_WORD_COEFF);
 786   /* Convert that to fixed (but not to DItype!),
 787      and shift it into the high word.  */
 788   v = (USItype) b;
 789   v <<= WORD_SIZE;
 790   /* Remove high part from the TFtype, leaving the low part as flonum.  */
 791   a -= (TFtype)v;
 792   /* Convert that to fixed (but not to DItype!) and add it in.
 793      Sometimes A comes out negative.  This is significant, since
 794      A has more bits than a long int does.  */
 795   if (a < 0)
 796     v -= (USItype) (- a);
 797   else
 798     v += (USItype) a;
 799   return v;
 800 }
 801 #endif
 802
 803 #if defined(L_fixtfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
 804 DItype
 805 __fixtfdi (a)
 806      TFtype a;
 807 {
 808   if (a < 0)
 809     return - __fixunstfdi (-a);
 810   return __fixunstfdi (a);
 811 }
 812 #endif
 813
 814 #if defined(L_fixunsxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
 815 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 816 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 817
 818 DItype
 819 __fixunsxfdi (a)
 820      XFtype a;
 821 {
 822   XFtype b;
 823   UDItype v;
 824
 825   if (a < 0)
 826     return 0;
 827
 828   /* Compute high word of result, as a flonum.  */
 829   b = (a / HIGH_WORD_COEFF);
 830   /* Convert that to fixed (but not to DItype!),
 831      and shift it into the high word.  */
 832   v = (USItype) b;
 833   v <<= WORD_SIZE;
 834   /* Remove high part from the XFtype, leaving the low part as flonum.  */
 835   a -= (XFtype)v;
 836   /* Convert that to fixed (but not to DItype!) and add it in.
 837      Sometimes A comes out negative.  This is significant, since
 838      A has more bits than a long int does.  */
 839   if (a < 0)
 840     v -= (USItype) (- a);
 841   else
 842     v += (USItype) a;
 843   return v;
 844 }
 845 #endif
 846
 847 #if defined(L_fixxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
 848 DItype
 849 __fixxfdi (a)
 850      XFtype a;
 851 {
 852   if (a < 0)
 853     return - __fixunsxfdi (-a);
 854   return __fixunsxfdi (a);
 855 }
 856 #endif
 857
 858 #ifdef L_fixunsdfdi
 859 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 860 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 861
 862 DItype
 863 __fixunsdfdi (a)
 864      DFtype a;
 865 {
 866   DFtype b;
 867   UDItype v;
 868
 869   if (a < 0)
 870     return 0;
 871
 872   /* Compute high word of result, as a flonum.  */
 873   b = (a / HIGH_WORD_COEFF);
 874   /* Convert that to fixed (but not to DItype!),
 875      and shift it into the high word.  */
 876   v = (USItype) b;
 877   v <<= WORD_SIZE;
 878   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 879   a -= (DFtype)v;
 880   /* Convert that to fixed (but not to DItype!) and add it in.
 881      Sometimes A comes out negative.  This is significant, since
 882      A has more bits than a long int does.  */
 883   if (a < 0)
 884     v -= (USItype) (- a);
 885   else
 886     v += (USItype) a;
 887   return v;
 888 }
 889 #endif
 890
 891 #ifdef L_fixdfdi
 892 DItype
 893 __fixdfdi (a)
 894      DFtype a;
 895 {
 896   if (a < 0)
 897     return - __fixunsdfdi (-a);
 898   return __fixunsdfdi (a);
 899 }
 900 #endif
 901
 902 #ifdef L_fixunssfdi
 903 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 904 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 905
 906 DItype
 907 __fixunssfdi (SFtype original_a)
 908 {
 909   /* Convert the SFtype to a DFtype, because that is surely not going
 910      to lose any bits.  Some day someone else can write a faster version
 911      that avoids converting to DFtype, and verify it really works right.  */
 912   DFtype a = original_a;
 913   DFtype b;
 914   UDItype v;
 915
 916   if (a < 0)
 917     return 0;
 918
 919   /* Compute high word of result, as a flonum.  */
 920   b = (a / HIGH_WORD_COEFF);
 921   /* Convert that to fixed (but not to DItype!),
 922      and shift it into the high word.  */
 923   v = (USItype) b;
 924   v <<= WORD_SIZE;
 925   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 926   a -= (DFtype)v;
 927   /* Convert that to fixed (but not to DItype!) and add it in.
 928      Sometimes A comes out negative.  This is significant, since
 929      A has more bits than a long int does.  */
 930   if (a < 0)
 931     v -= (USItype) (- a);
 932   else
 933     v += (USItype) a;
 934   return v;
 935 }
 936 #endif
 937
 938 #ifdef L_fixsfdi
 939 DItype
 940 __fixsfdi (SFtype a)
 941 {
 942   if (a < 0)
 943     return - __fixunssfdi (-a);
 944   return __fixunssfdi (a);
 945 }
 946 #endif
 947
 948 #if defined(L_floatdixf) && (LONG_DOUBLE_TYPE_SIZE == 96)
 949 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 950 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
 951 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 952
 953 XFtype
 954 __floatdixf (u)
 955      DItype u;
 956 {
 957   XFtype d;
 958   SItype negate = 0;
 959
 960   if (u < 0)
 961     u = -u, negate = 1;
 962
 963   d = (USItype) (u >> WORD_SIZE);
 964   d *= HIGH_HALFWORD_COEFF;
 965   d *= HIGH_HALFWORD_COEFF;
 966   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
 967
 968   return (negate ? -d : d);
 969 }
 970 #endif
 971
 972 #if defined(L_floatditf) && (LONG_DOUBLE_TYPE_SIZE == 128)
 973 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 974 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
 975 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 976
 977 TFtype
 978 __floatditf (u)
 979      DItype u;
 980 {
 981   TFtype d;
 982   SItype negate = 0;
 983
 984   if (u < 0)
 985     u = -u, negate = 1;
 986
 987   d = (USItype) (u >> WORD_SIZE);
 988   d *= HIGH_HALFWORD_COEFF;
 989   d *= HIGH_HALFWORD_COEFF;
 990   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
 991
 992   return (negate ? -d : d);
 993 }
 994 #endif
 995
 996 #ifdef L_floatdidf
 997 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 998 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
 999 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
1000
1001 DFtype
1002 __floatdidf (u)
1003      DItype u;
1004 {
1005   DFtype d;
1006   SItype negate = 0;
1007
1008   if (u < 0)
1009     u = -u, negate = 1;
1010
1011   d = (USItype) (u >> WORD_SIZE);
1012   d *= HIGH_HALFWORD_COEFF;
1013   d *= HIGH_HALFWORD_COEFF;
1014   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
1015
1016   return (negate ? -d : d);
1017 }
1018 #endif
1019
1020 #ifdef L_floatdisf
1021 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
1022 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
1023 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
1024 #define DI_SIZE (sizeof (DItype) * BITS_PER_UNIT)
1025 #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1026 #define DF_SIZE 53
1027 #define SF_SIZE 24
1028 #else
1029 #if TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT
1030 #define DF_SIZE 56
1031 #define SF_SIZE 24
1032 #else
1033 #if TARGET_FLOAT_FORMAT == VAX_FLOAT_FORMAT
1034 #define DF_SIZE 56
1035 #define SF_SIZE 24
1036 #else
1037 #define DF_SIZE 0
1038 #define SF_SIZE 0
1039 #endif
1040 #endif
1041 #endif
1042
1043
1044 SFtype
1045 __floatdisf (u)
1046      DItype u;
1047 {
1048   /* Do the calculation in DFmode
1049      so that we don't lose any of the precision of the high word
1050      while multiplying it.  */
1051   DFtype f;
1052   SItype negate = 0;
1053
1054   if (u < 0)
1055     u = -u, negate = 1;
1056
1057   /* Protect against double-rounding error.
1058      Represent any low-order bits, that might be truncated in DFmode,
1059      by a bit that won't be lost.  The bit can go in anywhere below the
1060      rounding position of the SFmode.  A fixed mask and bit position
1061      handles all usual configurations.  It doesn't handle the case
1062      of 128-bit DImode, however.  */
1063   if (DF_SIZE < DI_SIZE
1064       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1065     {
1066 #define REP_BIT ((USItype) 1 << (DI_SIZE - DF_SIZE))
1067       if (u >= ((UDItype) 1 << DF_SIZE))
1068         {
1069           if ((USItype) u & (REP_BIT - 1))
1070             u |= REP_BIT;
1071         }
1072     }
1073   f = (USItype) (u >> WORD_SIZE);
1074   f *= HIGH_HALFWORD_COEFF;
1075   f *= HIGH_HALFWORD_COEFF;
1076   f += (USItype) (u & (HIGH_WORD_COEFF - 1));
1077
1078   return (SFtype) (negate ? -f : f);
1079 }
1080 #endif
1081
1082 #if defined(L_fixunsxfsi) && LONG_DOUBLE_TYPE_SIZE == 96
1083 #include "glimits.h"
1084
1085 USItype
1086 __fixunsxfsi (a)
1087      XFtype a;
1088 {
1089   if (a >= - (DFtype) LONG_MIN)
1090     return (SItype) (a + LONG_MIN) - LONG_MIN;
1091   return (SItype) a;
1092 }
1093 #endif
1094
1095 #ifdef L_fixunsdfsi
1096 #include "glimits.h"
1097
1098 USItype
1099 __fixunsdfsi (a)
1100      DFtype a;
1101 {
1102   if (a >= - (DFtype) LONG_MIN)
1103     return (SItype) (a + LONG_MIN) - LONG_MIN;
1104   return (SItype) a;
1105 }
1106 #endif
1107
1108 #ifdef L_fixunssfsi
1109 #include "glimits.h"
1110
1111 USItype
1112 __fixunssfsi (SFtype a)
1113 {
1114   if (a >= - (SFtype) LONG_MIN)
1115     return (SItype) (a + LONG_MIN) - LONG_MIN;
1116   return (SItype) a;
1117 }
1118 #endif
1119 \f
1120 /* From here on down, the routines use normal data types.  */
1121
1122 #define SItype bogus_type
1123 #define USItype bogus_type
1124 #define DItype bogus_type
1125 #define UDItype bogus_type
1126 #define SFtype bogus_type
1127 #define DFtype bogus_type
1128
1129 #undef char
1130 #undef short
1131 #undef int
1132 #undef long
1133 #undef unsigned
1134 #undef float
1135 #undef double
1136 \f
1137 #ifdef L__gcc_bcmp
1138
1139 /* Like bcmp except the sign is meaningful.
1140    Reult is negative if S1 is less than S2,
1141    positive if S1 is greater, 0 if S1 and S2 are equal.  */
1142
1143 int
1144 __gcc_bcmp (s1, s2, size)
1145      unsigned char *s1, *s2;
1146      size_t size;
1147 {
1148   while (size > 0)
1149     {
1150       unsigned char c1 = *s1++, c2 = *s2++;
1151       if (c1 != c2)
1152         return c1 - c2;
1153       size--;
1154     }
1155   return 0;
1156 }
1157
1158 #endif
1159 \f\f
1160 #ifdef L_varargs
1161 #ifdef __i860__
1162 #if defined(__svr4__) || defined(__alliant__)
1163         asm ("  .text");
1164         asm ("  .align  4");
1165
1166 /* The Alliant needs the added underscore.  */
1167         asm (".globl    __builtin_saveregs");
1168 asm ("__builtin_saveregs:");
1169         asm (".globl    ___builtin_saveregs");
1170 asm ("___builtin_saveregs:");
1171
1172         asm ("  andnot  0x0f,%sp,%sp"); /* round down to 16-byte boundary */
1173         asm ("  adds    -96,%sp,%sp");  /* allocate stack space for reg save
1174                                            area and also for a new va_list
1175                                            structure */
1176         /* Save all argument registers in the arg reg save area.  The
1177            arg reg save area must have the following layout (according
1178            to the svr4 ABI):
1179
1180                 struct {
1181                   union  {
1182                     float freg[8];
1183                     double dreg[4];
1184                   } float_regs;
1185                   long  ireg[12];
1186                 };
1187         */
1188
1189         asm ("  fst.q   %f8,  0(%sp)"); /* save floating regs (f8-f15)  */
1190         asm ("  fst.q   %f12,16(%sp)");
1191
1192         asm ("  st.l    %r16,32(%sp)"); /* save integer regs (r16-r27) */
1193         asm ("  st.l    %r17,36(%sp)");
1194         asm ("  st.l    %r18,40(%sp)");
1195         asm ("  st.l    %r19,44(%sp)");
1196         asm ("  st.l    %r20,48(%sp)");
1197         asm ("  st.l    %r21,52(%sp)");
1198         asm ("  st.l    %r22,56(%sp)");
1199         asm ("  st.l    %r23,60(%sp)");
1200         asm ("  st.l    %r24,64(%sp)");
1201         asm ("  st.l    %r25,68(%sp)");
1202         asm ("  st.l    %r26,72(%sp)");
1203         asm ("  st.l    %r27,76(%sp)");
1204
1205         asm ("  adds    80,%sp,%r16");  /* compute the address of the new
1206                                            va_list structure.  Put in into
1207                                            r16 so that it will be returned
1208                                            to the caller.  */
1209
1210         /* Initialize all fields of the new va_list structure.  This
1211            structure looks like:
1212
1213                 typedef struct {
1214                     unsigned long       ireg_used;
1215                     unsigned long       freg_used;
1216                     long                *reg_base;
1217                     long                *mem_ptr;
1218                 } va_list;
1219         */
1220
1221         asm ("  st.l    %r0, 0(%r16)"); /* nfixed */
1222         asm ("  st.l    %r0, 4(%r16)"); /* nfloating */
1223         asm ("  st.l    %sp, 8(%r16)"); /* __va_ctl points to __va_struct.  */
1224         asm ("  bri     %r1");          /* delayed return */
1225         asm ("  st.l    %r28,12(%r16)"); /* pointer to overflow args */
1226
1227 #else /* not __svr4__ */
1228 #if defined(__PARAGON__)
1229         /*
1230          *      we'll use SVR4-ish varargs but need SVR3.2 assembler syntax,
1231          *      and we stand a better chance of hooking into libraries
1232          *      compiled by PGI.  [andyp@ssd.intel.com]
1233          */
1234         asm ("  .text");
1235         asm ("  .align  4");
1236         asm (".globl    __builtin_saveregs");
1237 asm ("__builtin_saveregs:");
1238         asm (".globl    ___builtin_saveregs");
1239 asm ("___builtin_saveregs:");
1240
1241         asm ("  andnot  0x0f,sp,sp");   /* round down to 16-byte boundary */
1242         asm ("  adds    -96,sp,sp");    /* allocate stack space for reg save
1243                                            area and also for a new va_list
1244                                            structure */
1245         /* Save all argument registers in the arg reg save area.  The
1246            arg reg save area must have the following layout (according
1247            to the svr4 ABI):
1248
1249                 struct {
1250                   union  {
1251                     float freg[8];
1252                     double dreg[4];
1253                   } float_regs;
1254                   long  ireg[12];
1255                 };
1256         */
1257
1258         asm ("  fst.q   f8,  0(sp)");
1259         asm ("  fst.q   f12,16(sp)");
1260         asm ("  st.l    r16,32(sp)");
1261         asm ("  st.l    r17,36(sp)");
1262         asm ("  st.l    r18,40(sp)");
1263         asm ("  st.l    r19,44(sp)");
1264         asm ("  st.l    r20,48(sp)");
1265         asm ("  st.l    r21,52(sp)");
1266         asm ("  st.l    r22,56(sp)");
1267         asm ("  st.l    r23,60(sp)");
1268         asm ("  st.l    r24,64(sp)");
1269         asm ("  st.l    r25,68(sp)");
1270         asm ("  st.l    r26,72(sp)");
1271         asm ("  st.l    r27,76(sp)");
1272
1273         asm ("  adds    80,sp,r16");  /* compute the address of the new
1274                                            va_list structure.  Put in into
1275                                            r16 so that it will be returned
1276                                            to the caller.  */
1277
1278         /* Initialize all fields of the new va_list structure.  This
1279            structure looks like:
1280
1281                 typedef struct {
1282                     unsigned long       ireg_used;
1283                     unsigned long       freg_used;
1284                     long                *reg_base;
1285                     long                *mem_ptr;
1286                 } va_list;
1287         */
1288
1289         asm ("  st.l    r0, 0(r16)"); /* nfixed */
1290         asm ("  st.l    r0, 4(r16)"); /* nfloating */
1291         asm ("  st.l    sp, 8(r16)"); /* __va_ctl points to __va_struct.  */
1292         asm ("  bri     r1");           /* delayed return */
1293         asm ("   st.l   r28,12(r16)"); /* pointer to overflow args */
1294 #else /* not __PARAGON__ */
1295         asm ("  .text");
1296         asm ("  .align  4");
1297
1298         asm (".globl    ___builtin_saveregs");
1299         asm ("___builtin_saveregs:");
1300         asm ("  mov     sp,r30");
1301         asm ("  andnot  0x0f,sp,sp");
1302         asm ("  adds    -96,sp,sp");  /* allocate sufficient space on the stack */
1303
1304 /* Fill in the __va_struct.  */
1305         asm ("  st.l    r16, 0(sp)"); /* save integer regs (r16-r27) */
1306         asm ("  st.l    r17, 4(sp)"); /* int    fixed[12] */
1307         asm ("  st.l    r18, 8(sp)");
1308         asm ("  st.l    r19,12(sp)");
1309         asm ("  st.l    r20,16(sp)");
1310         asm ("  st.l    r21,20(sp)");
1311         asm ("  st.l    r22,24(sp)");
1312         asm ("  st.l    r23,28(sp)");
1313         asm ("  st.l    r24,32(sp)");
1314         asm ("  st.l    r25,36(sp)");
1315         asm ("  st.l    r26,40(sp)");
1316         asm ("  st.l    r27,44(sp)");
1317
1318         asm ("  fst.q   f8, 48(sp)"); /* save floating regs (f8-f15) */
1319         asm ("  fst.q   f12,64(sp)"); /* int floating[8] */
1320
1321 /* Fill in the __va_ctl.  */
1322         asm ("  st.l    sp, 80(sp)"); /* __va_ctl points to __va_struct.  */
1323         asm ("  st.l    r28,84(sp)"); /* pointer to more args */
1324         asm ("  st.l    r0, 88(sp)"); /* nfixed */
1325         asm ("  st.l    r0, 92(sp)"); /* nfloating */
1326
1327         asm ("  adds    80,sp,r16");  /* return address of the __va_ctl.  */
1328         asm ("  bri     r1");
1329         asm ("  mov     r30,sp");
1330                                 /* recover stack and pass address to start
1331                                    of data.  */
1332 #endif /* not __PARAGON__ */
1333 #endif /* not __svr4__ */
1334 #else /* not __i860__ */
1335 #ifdef __sparc__
1336         asm (".global __builtin_saveregs");
1337         asm ("__builtin_saveregs:");
1338         asm (".global ___builtin_saveregs");
1339         asm ("___builtin_saveregs:");
1340 #ifdef NEED_PROC_COMMAND
1341         asm (".proc 020");
1342 #endif
1343         asm ("st %i0,[%fp+68]");
1344         asm ("st %i1,[%fp+72]");
1345         asm ("st %i2,[%fp+76]");
1346         asm ("st %i3,[%fp+80]");
1347         asm ("st %i4,[%fp+84]");
1348         asm ("retl");
1349         asm ("st %i5,[%fp+88]");
1350 #ifdef NEED_TYPE_COMMAND
1351         asm (".type __builtin_saveregs,#function");
1352         asm (".size __builtin_saveregs,.-__builtin_saveregs");
1353 #endif
1354 #else /* not __sparc__ */
1355 #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
1356
1357   asm ("        .text");
1358   asm ("        .ent __builtin_saveregs");
1359   asm ("        .globl __builtin_saveregs");
1360   asm ("__builtin_saveregs:");
1361   asm ("        sw      $4,0($30)");
1362   asm ("        sw      $5,4($30)");
1363   asm ("        sw      $6,8($30)");
1364   asm ("        sw      $7,12($30)");
1365   asm ("        j       $31");
1366   asm ("        .end __builtin_saveregs");
1367 #else /* not __mips__, etc. */
1368
1369 void *
1370 __builtin_saveregs ()
1371 {
1372   abort ();
1373 }
1374
1375 #endif /* not __mips__ */
1376 #endif /* not __sparc__ */
1377 #endif /* not __i860__ */
1378 #endif
1379 \f
1380 #ifdef L_eprintf
1381 #ifndef inhibit_libc
1382
1383 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1384 #include <stdio.h>
1385 /* This is used by the `assert' macro.  */
1386 void
1387 __eprintf (string, expression, line, filename)
1388      const char *string;
1389      const char *expression;
1390      int line;
1391      const char *filename;
1392 {
1393   fprintf (stderr, string, expression, line, filename);
1394   fflush (stderr);
1395   abort ();
1396 }
1397
1398 #endif
1399 #endif
1400
1401 #ifdef L_bb
1402
1403 /* Structure emitted by -a  */
1404 struct bb
1405 {
1406   long zero_word;
1407   const char *filename;
1408   long *counts;
1409   long ncounts;
1410   struct bb *next;
1411   const unsigned long *addresses;
1412
1413   /* Older GCC's did not emit these fields.  */
1414   long nwords;
1415   const char **functions;
1416   const long *line_nums;
1417   const char **filenames;
1418 };
1419
1420 #ifdef BLOCK_PROFILER_CODE
1421 BLOCK_PROFILER_CODE
1422 #else
1423 #ifndef inhibit_libc
1424
1425 /* Simple minded basic block profiling output dumper for
1426    systems that don't provde tcov support.  At present,
1427    it requires atexit and stdio.  */
1428
1429 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1430 #include <stdio.h>
1431 char *ctime ();
1432
1433 #ifdef HAVE_ATEXIT
1434 extern void atexit (void (*) (void));
1435 #define ON_EXIT(FUNC,ARG) atexit ((FUNC))
1436 #else
1437 #ifdef sun
1438 extern void on_exit (void*, void*);
1439 #define ON_EXIT(FUNC,ARG) on_exit ((FUNC), (ARG))
1440 #endif
1441 #endif
1442
1443 static struct bb *bb_head = (struct bb *)0;
1444
1445 /* Return the number of digits needed to print a value */
1446 /* __inline__ */ static int num_digits (long value, int base)
1447 {
1448   int minus = (value < 0 && base != 16);
1449   unsigned long v = (minus) ? -value : value;
1450   int ret = minus;
1451
1452   do
1453     {
1454       v /= base;
1455       ret++;
1456     }
1457   while (v);
1458
1459   return ret;
1460 }
1461
1462 void
1463 __bb_exit_func (void)
1464 {
1465   FILE *file = fopen ("bb.out", "a");
1466   long time_value;
1467
1468   if (!file)
1469     perror ("bb.out");
1470
1471   else
1472     {
1473       struct bb *ptr;
1474
1475       /* This is somewhat type incorrect, but it avoids worrying about
1476          exactly where time.h is included from.  It should be ok unless
1477          a void * differs from other pointer formats, or if sizeof(long)
1478          is < sizeof (time_t).  It would be nice if we could assume the
1479          use of rationale standards here.  */
1480
1481       time((void *) &time_value);
1482       fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));
1483
1484       /* We check the length field explicitly in order to allow compatibility
1485          with older GCC's which did not provide it.  */
1486
1487       for (ptr = bb_head; ptr != (struct bb *)0; ptr = ptr->next)
1488         {
1489           int i;
1490           int func_p    = (ptr->nwords >= sizeof (struct bb) && ptr->nwords <= 1000);
1491           int line_p    = (func_p && ptr->line_nums);
1492           int file_p    = (func_p && ptr->filenames);
1493           long ncounts  = ptr->ncounts;
1494           long cnt_max  = 0;
1495           long line_max = 0;
1496           long addr_max = 0;
1497           int file_len  = 0;
1498           int func_len  = 0;
1499           int blk_len   = num_digits (ncounts, 10);
1500           int cnt_len;
1501           int line_len;
1502           int addr_len;
1503
1504           fprintf (file, "File %s, %ld basic blocks \n\n",
1505                    ptr->filename, ncounts);
1506
1507           /* Get max values for each field.  */
1508           for (i = 0; i < ncounts; i++)
1509             {
1510               const char *p;
1511               int len;
1512
1513               if (cnt_max < ptr->counts[i])
1514                 cnt_max = ptr->counts[i];
1515
1516               if (addr_max < ptr->addresses[i])
1517                 addr_max = ptr->addresses[i];
1518
1519               if (line_p && line_max < ptr->line_nums[i])
1520                 line_max = ptr->line_nums[i];
1521
1522               if (func_p)
1523                 {
1524                   p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
1525                   len = strlen (p);
1526                   if (func_len < len)
1527                     func_len = len;
1528                 }
1529
1530               if (file_p)
1531                 {
1532                   p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
1533                   len = strlen (p);
1534                   if (file_len < len)
1535                     file_len = len;
1536                 }
1537             }
1538
1539           addr_len = num_digits (addr_max, 16);
1540           cnt_len  = num_digits (cnt_max, 10);
1541           line_len = num_digits (line_max, 10);
1542
1543           /* Now print out the basic block information.  */
1544           for (i = 0; i < ncounts; i++)
1545             {
1546               fprintf (file,
1547                        "    Block #%*d: executed %*ld time(s) address= 0x%.*lx",
1548                        blk_len, i+1,
1549                        cnt_len, ptr->counts[i],
1550                        addr_len, ptr->addresses[i]);
1551
1552               if (func_p)
1553                 fprintf (file, " function= %-*s", func_len,
1554                          (ptr->functions[i]) ? ptr->functions[i] : "<none>");
1555
1556               if (line_p)
1557                 fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);
1558
1559               if (file_p)
1560                 fprintf (file, " file= %s",
1561                          (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");
1562
1563               fprintf (file, "\n");
1564             }
1565
1566           fprintf (file, "\n");
1567           fflush (file);
1568         }
1569
1570       fprintf (file, "\n\n");
1571       fclose (file);
1572     }
1573 }
1574
1575 void
1576 __bb_init_func (struct bb *blocks)
1577 {
1578   /* User is supposed to check whether the first word is non-0,
1579      but just in case.... */
1580
1581   if (blocks->zero_word)
1582     return;
1583
1584 #ifdef ON_EXIT
1585   /* Initialize destructor.  */
1586   if (!bb_head)
1587     ON_EXIT (__bb_exit_func, 0);
1588 #endif
1589
1590   /* Set up linked list.  */
1591   blocks->zero_word = 1;
1592   blocks->next = bb_head;
1593   bb_head = blocks;
1594 }
1595
1596 #endif /* not inhibit_libc */
1597 #endif /* not BLOCK_PROFILER_CODE */
1598 #endif /* L_bb */
1599 \f
1600 /* Default free-store management functions for C++, per sections 12.5 and
1601    17.3.3 of the Working Paper. */
1602
1603 #ifdef L_op_new
1604 /* operator new (size_t), described in 17.3.3.5.  This function is used by
1605    C++ programs to allocate a block of memory to hold a single object. */
1606
1607 typedef void (*vfp)(void);
1608 extern vfp __new_handler;
1609
1610 void *
1611 __builtin_new (size_t sz)
1612 {
1613   void *p;
1614
1615   /* malloc (0) is unpredictable; avoid it.  */
1616   if (sz == 0)
1617     sz = 1;
1618   p = (void *) malloc (sz);
1619   while (p == 0)
1620     {
1621       (*__new_handler) ();
1622       p = (void *) malloc (sz);
1623     }
1624
1625   return p;
1626 }
1627 #endif /* L_op_new */
1628
1629 #ifdef L_op_vnew
1630 /* void * operator new [] (size_t), described in 17.3.3.6.  This function
1631    is used by C++ programs to allocate a block of memory for an array.  */
1632
1633 extern void * __builtin_new (size_t);
1634
1635 void *
1636 __builtin_vec_new (size_t sz)
1637 {
1638   return __builtin_new (sz);
1639 }
1640 #endif /* L_op_vnew */
1641
1642 #ifdef L_new_handler
1643 /* set_new_handler (fvoid_t *) and the default new handler, described in
1644    17.3.3.2 and 17.3.3.5.  These functions define the result of a failure
1645    to allocate the amount of memory requested from operator new or new []. */
1646
1647 #ifndef inhibit_libc
1648 /* This gets us __GNU_LIBRARY__.  */
1649 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1650 #include <stdio.h>
1651
1652 #ifdef __GNU_LIBRARY__
1653   /* Avoid forcing the library's meaning of `write' on the user program
1654      by using the "internal" name (for use within the library)  */
1655 #define write(fd, buf, n)       __write((fd), (buf), (n))
1656 #endif
1657 #endif /* inhibit_libc */
1658
1659 typedef void (*vfp)(void);
1660 void __default_new_handler (void);
1661
1662 vfp __new_handler = __default_new_handler;
1663
1664 vfp
1665 set_new_handler (vfp handler)
1666 {
1667   vfp prev_handler;
1668
1669   prev_handler = __new_handler;
1670   if (handler == 0) handler = __default_new_handler;
1671   __new_handler = handler;
1672   return prev_handler;
1673 }
1674
1675 #define MESSAGE "Virtual memory exceeded in `new'\n"
1676
1677 void
1678 __default_new_handler ()
1679 {
1680   /* don't use fprintf (stderr, ...) because it may need to call malloc.  */
1681   /* This should really print the name of the program, but that is hard to
1682      do.  We need a standard, clean way to get at the name.  */
1683   write (2, MESSAGE, sizeof (MESSAGE));
1684   /* don't call exit () because that may call global destructors which
1685      may cause a loop.  */
1686   _exit (-1);
1687 }
1688 #endif
1689
1690 #ifdef L_op_delete
1691 /* operator delete (void *), described in 17.3.3.3.  This function is used
1692    by C++ programs to return to the free store a block of memory allocated
1693    as a single object. */
1694
1695 void
1696 __builtin_delete (void *ptr)
1697 {
1698   if (ptr)
1699     free (ptr);
1700 }
1701 #endif
1702
1703 #ifdef L_op_vdel
1704 /* operator delete [] (void *), described in 17.3.3.4.  This function is
1705    used by C++ programs to return to the free store a block of memory
1706    allocated as an array. */
1707
1708 extern void __builtin_delete (void *);
1709
1710 void
1711 __builtin_vec_delete (void *ptr)
1712 {
1713   __builtin_delete (ptr);
1714 }
1715 #endif
1716
1717 /* End of C++ free-store management functions */
1718 \f
1719 #ifdef L_shtab
1720 unsigned int __shtab[] = {
1721     0x00000001, 0x00000002, 0x00000004, 0x00000008,
1722     0x00000010, 0x00000020, 0x00000040, 0x00000080,
1723     0x00000100, 0x00000200, 0x00000400, 0x00000800,
1724     0x00001000, 0x00002000, 0x00004000, 0x00008000,
1725     0x00010000, 0x00020000, 0x00040000, 0x00080000,
1726     0x00100000, 0x00200000, 0x00400000, 0x00800000,
1727     0x01000000, 0x02000000, 0x04000000, 0x08000000,
1728     0x10000000, 0x20000000, 0x40000000, 0x80000000
1729   };
1730 #endif
1731 \f
1732 #ifdef L_clear_cache
1733 /* Clear part of an instruction cache.  */
1734
1735 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1736
1737 void
1738 __clear_cache (beg, end)
1739      char *beg, *end;
1740 {
1741 #ifdef CLEAR_INSN_CACHE
1742   CLEAR_INSN_CACHE (beg, end);
1743 #else
1744 #ifdef INSN_CACHE_SIZE
1745   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1746   static int initialized = 0;
1747   int offset;
1748   void *start_addr
1749   void *end_addr;
1750   typedef (*function_ptr) ();
1751
1752 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1753   /* It's cheaper to clear the whole cache.
1754      Put in a series of jump instructions so that calling the beginning
1755      of the cache will clear the whole thing.  */
1756
1757   if (! initialized)
1758     {
1759       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1760                  & -INSN_CACHE_LINE_WIDTH);
1761       int end_ptr = ptr + INSN_CACHE_SIZE;
1762
1763       while (ptr < end_ptr)
1764         {
1765           *(INSTRUCTION_TYPE *)ptr
1766             = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1767           ptr += INSN_CACHE_LINE_WIDTH;
1768         }
1769       *(INSTRUCTION_TYPE *)(ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1770
1771       initialized = 1;
1772     }
1773
1774   /* Call the beginning of the sequence.  */
1775   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1776                     & -INSN_CACHE_LINE_WIDTH))
1777    ());
1778
1779 #else /* Cache is large.  */
1780
1781   if (! initialized)
1782     {
1783       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1784                  & -INSN_CACHE_LINE_WIDTH);
1785
1786       while (ptr < (int) array + sizeof array)
1787         {
1788           *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1789           ptr += INSN_CACHE_LINE_WIDTH;
1790         }
1791
1792       initialized = 1;
1793     }
1794
1795   /* Find the location in array that occupies the same cache line as BEG.  */
1796
1797   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1798   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1799                  & -INSN_CACHE_PLANE_SIZE)
1800                 + offset);
1801
1802   /* Compute the cache alignment of the place to stop clearing.  */
1803 #if 0  /* This is not needed for gcc's purposes.  */
1804   /* If the block to clear is bigger than a cache plane,
1805      we clear the entire cache, and OFFSET is already correct.  */
1806   if (end < beg + INSN_CACHE_PLANE_SIZE)
1807 #endif
1808     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1809                & -INSN_CACHE_LINE_WIDTH)
1810               & (INSN_CACHE_PLANE_SIZE - 1));
1811
1812 #if INSN_CACHE_DEPTH > 1
1813   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1814   if (end_addr <= start_addr)
1815     end_addr += INSN_CACHE_PLANE_SIZE;
1816
1817   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1818     {
1819       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1820       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1821
1822       while (addr != stop)
1823         {
1824           /* Call the return instruction at ADDR.  */
1825           ((function_ptr) addr) ();
1826
1827           addr += INSN_CACHE_LINE_WIDTH;
1828         }
1829     }
1830 #else /* just one plane */
1831   do
1832     {
1833       /* Call the return instruction at START_ADDR.  */
1834       ((function_ptr) start_addr) ();
1835
1836       start_addr += INSN_CACHE_LINE_WIDTH;
1837     }
1838   while ((start_addr % INSN_CACHE_SIZE) != offset);
1839 #endif /* just one plane */
1840 #endif /* Cache is large */
1841 #endif /* Cache exists */
1842 #endif /* CLEAR_INSN_CACHE */
1843 }
1844
1845 #endif /* L_clear_cache */
1846 \f
1847 #ifdef L_trampoline
1848
1849 /* Jump to a trampoline, loading the static chain address.  */
1850
1851 #ifdef TRANSFER_FROM_TRAMPOLINE
1852 TRANSFER_FROM_TRAMPOLINE
1853 #endif
1854
1855 #if defined (NeXT) && defined (__MACH__)
1856
1857 /* Make stack executable so we can call trampolines on stack.
1858    This is called from INITIALIZE_TRAMPOLINE in next.h.  */
1859 #ifdef NeXTStep21
1860  #include <mach.h>
1861 #else
1862  #include <mach/mach.h>
1863 #endif
1864
1865 void
1866 __enable_execute_stack (addr)
1867      char *addr;
1868 {
1869   kern_return_t r;
1870   char *eaddr = addr + TRAMPOLINE_SIZE;
1871   vm_address_t a = (vm_address_t) addr;
1872
1873   /* turn on execute access on stack */
1874   r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
1875   if (r != KERN_SUCCESS)
1876     {
1877       mach_error("vm_protect VM_PROT_ALL", r);
1878       exit(1);
1879     }
1880
1881   /* We inline the i-cache invalidation for speed */
1882
1883 #ifdef CLEAR_INSN_CACHE
1884   CLEAR_INSN_CACHE (addr, eaddr);
1885 #else
1886   __clear_cache ((int) addr, (int) eaddr);
1887 #endif
1888 }
1889
1890 #endif /* defined (NeXT) && defined (__MACH__) */
1891
1892 #ifdef __convex__
1893
1894 /* Make stack executable so we can call trampolines on stack.
1895    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
1896
1897 #include <sys/mman.h>
1898 #include <sys/vmparam.h>
1899 #include <machine/machparam.h>
1900
1901 void
1902 __enable_execute_stack ()
1903 {
1904   int fp;
1905   static unsigned lowest = USRSTACK;
1906   unsigned current = (unsigned) &fp & -NBPG;
1907
1908   if (lowest > current)
1909     {
1910       unsigned len = lowest - current;
1911       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1912       lowest = current;
1913     }
1914
1915   /* Clear instruction cache in case an old trampoline is in it. */
1916   asm ("pich");
1917 }
1918 #endif /* __convex__ */
1919
1920 #ifdef __DOLPHIN__
1921
1922 /* Modified from the convex -code above. */
1923
1924 #include <sys/param.h>
1925 #include <errno.h>
1926 #include <sys/m88kbcs.h>
1927
1928 void
1929 __enable_execute_stack ()
1930 {
1931   int save_errno;
1932   static unsigned long lowest = USRSTACK;
1933   unsigned long current = (unsigned long) &save_errno & -NBPC;
1934
1935   /* Ignore errno being set. memctl sets errno to EINVAL whenever the
1936      address is seen as 'negative'. That is the case with the stack.   */
1937
1938   save_errno=errno;
1939   if (lowest > current)
1940     {
1941       unsigned len=lowest-current;
1942       memctl(current,len,MCT_TEXT);
1943       lowest = current;
1944     }
1945   else
1946     memctl(current,NBPC,MCT_TEXT);
1947   errno=save_errno;
1948 }
1949
1950 #endif /* __DOLPHIN__ */
1951
1952 #ifdef __pyr__
1953
1954 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1955 #include <stdio.h>
1956 #include <sys/mman.h>
1957 #include <sys/types.h>
1958 #include <sys/param.h>
1959 #include <sys/vmmac.h>
1960
1961 /* Modified from the convex -code above.
1962    mremap promises to clear the i-cache. */
1963
1964 void
1965 __enable_execute_stack ()
1966 {
1967   int fp;
1968   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1969                 PROT_READ|PROT_WRITE|PROT_EXEC))
1970     {
1971       perror ("mprotect in __enable_execute_stack");
1972       fflush (stderr);
1973       abort ();
1974     }
1975 }
1976 #endif /* __pyr__ */
1977 #endif /* L_trampoline */
1978 \f
1979 #ifdef L__main
1980
1981 #include "gbl-ctors.h"
1982 /* Some systems use __main in a way incompatible with its use in gcc, in these
1983    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1984    give the same symbol without quotes for an alternative entry point.  You
1985    must define both, or niether. */
1986 #ifndef NAME__MAIN
1987 #define NAME__MAIN "__main"
1988 #define SYMBOL__MAIN __main
1989 #endif
1990
1991 /* Run all the global destructors on exit from the program.  */
1992
1993 void
1994 __do_global_dtors ()
1995 {
1996 #ifdef DO_GLOBAL_DTORS_BODY
1997   DO_GLOBAL_DTORS_BODY;
1998 #else
1999   func_ptr *p;
2000   for (p = __DTOR_LIST__ + 1; *p; )
2001     (*p++) ();
2002 #endif
2003 }
2004
2005 #ifndef INIT_SECTION_ASM_OP
2006 /* Run all the global constructors on entry to the program.  */
2007
2008 #ifndef ON_EXIT
2009 #define ON_EXIT(a, b)
2010 #else
2011 /* Make sure the exit routine is pulled in to define the globals as
2012    bss symbols, just in case the linker does not automatically pull
2013    bss definitions from the library.  */
2014
2015 extern int _exit_dummy_decl;
2016 int *_exit_dummy_ref = &_exit_dummy_decl;
2017 #endif /* ON_EXIT */
2018
2019 void
2020 __do_global_ctors ()
2021 {
2022   DO_GLOBAL_CTORS_BODY;
2023   ON_EXIT (__do_global_dtors, 0);
2024 }
2025 #endif /* no INIT_SECTION_ASM_OP */
2026
2027 #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main)
2028 /* Subroutine called automatically by `main'.
2029    Compiling a global function named `main'
2030    produces an automatic call to this function at the beginning.
2031
2032    For many systems, this routine calls __do_global_ctors.
2033    For systems which support a .init section we use the .init section
2034    to run __do_global_ctors, so we need not do anything here.  */
2035
2036 void
2037 SYMBOL__MAIN ()
2038 {
2039   /* Support recursive calls to `main': run initializers just once.  */
2040   static int initialized = 0;
2041   if (! initialized)
2042     {
2043       initialized = 1;
2044       __do_global_ctors ();
2045     }
2046 }
2047 #endif /* no INIT_SECTION_ASM_OP or INVOKE__main */
2048
2049 #endif /* L__main */
2050 \f
2051 #ifdef L_ctors
2052
2053 #include "gbl-ctors.h"
2054
2055 /* Provide default definitions for the lists of constructors and
2056    destructors, so that we don't get linker errors.  These symbols are
2057    intentionally bss symbols, so that gld and/or collect will provide
2058    the right values.  */
2059
2060 /* We declare the lists here with two elements each,
2061    so that they are valid empty lists if no other definition is loaded.  */
2062 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2063 #ifdef __NeXT__
2064 /* After 2.3, try this definition on all systems.  */
2065 func_ptr __CTOR_LIST__[2] = {0, 0};
2066 func_ptr __DTOR_LIST__[2] = {0, 0};
2067 #else
2068 func_ptr __CTOR_LIST__[2];
2069 func_ptr __DTOR_LIST__[2];
2070 #endif
2071 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2072 #endif /* L_ctors */
2073 \f
2074 #ifdef L_exit
2075
2076 #include "gbl-ctors.h"
2077
2078 #ifndef ON_EXIT
2079
2080 /* If we have no known way of registering our own __do_global_dtors
2081    routine so that it will be invoked at program exit time, then we
2082    have to define our own exit routine which will get this to happen.  */
2083
2084 extern void __do_global_dtors ();
2085 extern void _cleanup ();
2086 extern void _exit () __attribute__ ((noreturn));
2087
2088 void
2089 exit (status)
2090      int status;
2091 {
2092   __do_global_dtors ();
2093 #ifdef EXIT_BODY
2094   EXIT_BODY;
2095 #else
2096   _cleanup ();
2097 #endif
2098   _exit (status);
2099 }
2100
2101 #else
2102 int _exit_dummy_decl = 0;       /* prevent compiler & linker warnings */
2103 #endif
2104
2105 #endif /* L_exit */
2106 \f
2107 /* In a.out systems, we need to have these dummy constructor and destructor
2108    lists in the library.
2109
2110    When using `collect', the first link will resolve __CTOR_LIST__
2111    and __DTOR_LIST__ to these symbols.  We will then run "nm" on the
2112    result, build the correct __CTOR_LIST__ and __DTOR_LIST__, and relink.
2113    Since we don't do the second link if no constructors existed, these
2114    dummies must be fully functional empty lists.
2115
2116    When using `gnu ld', these symbols will be used if there are no
2117    constructors.  If there are constructors, the N_SETV symbol defined
2118    by the linker from the N_SETT's in input files will define __CTOR_LIST__
2119    and __DTOR_LIST__ rather than its being allocated as common storage
2120    by the definitions below.
2121
2122    When using a linker that supports constructor and destructor segments,
2123    these definitions will not be used, since crtbegin.o and crtend.o
2124    (from crtstuff.c) will have already defined __CTOR_LIST__ and
2125     __DTOR_LIST__.  The crt*.o files are passed directly to the linker
2126    on its command line, by gcc.  */
2127
2128 /* The list needs two elements:  one is ignored (the old count); the
2129    second is the terminating zero.  Since both values are zero, this
2130    declaration is not initialized, and it becomes `common'.  */
2131
2132 #ifdef L_ctor_list
2133 #include "gbl-ctors.h"
2134 func_ptr __CTOR_LIST__[2];
2135 #endif
2136
2137 #ifdef L_dtor_list
2138 #include "gbl-ctors.h"
2139 func_ptr __DTOR_LIST__[2];
2140 #endif