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