gcc/libgcc2.c

   1 /* More subroutines needed by GCC output code on some machines.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989, 92, 93, 94, 95, 96, 1997 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, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* As a special exception, if you link this library with other files,
  23    some of which are compiled with GCC, to produce an executable,
  24    this library does not by itself cause the resulting executable
  25    to be covered by the GNU General Public License.
  26    This exception does not however invalidate any other reasons why
  27    the executable file might be covered by the GNU General Public License.  */
  28
  29 /* It is incorrect to include config.h here, because this file is being
  30    compiled for the target, and hence definitions concerning only the host
  31    do not apply.  */
  32
  33 #include "tconfig.h"
  34 #include "machmode.h"
  35 #include "defaults.h"
  36 #ifndef L_trampoline
  37 #include <stddef.h>
  38 #endif
  39
  40 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  41 #ifdef abort
  42 #undef abort
  43 #endif
  44
  45 #if (SUPPORTS_WEAK == 1) && (defined (ASM_OUTPUT_DEF) || defined (ASM_OUTPUT_WEAK_ALIAS))
  46 #define WEAK_ALIAS
  47 #endif
  48
  49 /* In a cross-compilation situation, default to inhibiting compilation
  50    of routines that use libc.  */
  51
  52 #if defined(CROSS_COMPILE) && !defined(inhibit_libc)
  53 #define inhibit_libc
  54 #endif
  55
  56 /* Permit the tm.h file to select the endianness to use just for this
  57    file.  This is used when the endianness is determined when the
  58    compiler is run.  */
  59
  60 #ifndef LIBGCC2_WORDS_BIG_ENDIAN
  61 #define LIBGCC2_WORDS_BIG_ENDIAN WORDS_BIG_ENDIAN
  62 #endif
  63
  64 /* In the first part of this file, we are interfacing to calls generated
  65    by the compiler itself.  These calls pass values into these routines
  66    which have very specific modes (rather than very specific types), and
  67    these compiler-generated calls also expect any return values to have
  68    very specific modes (rather than very specific types).  Thus, we need
  69    to avoid using regular C language type names in this part of the file
  70    because the sizes for those types can be configured to be anything.
  71    Instead we use the following special type names.  */
  72
  73 typedef unsigned int UQItype    __attribute__ ((mode (QI)));
  74 typedef          int SItype     __attribute__ ((mode (SI)));
  75 typedef unsigned int USItype    __attribute__ ((mode (SI)));
  76 typedef          int DItype     __attribute__ ((mode (DI)));
  77 typedef unsigned int UDItype    __attribute__ ((mode (DI)));
  78
  79 typedef         float SFtype    __attribute__ ((mode (SF)));
  80 typedef         float DFtype    __attribute__ ((mode (DF)));
  81
  82 #if LONG_DOUBLE_TYPE_SIZE == 96
  83 typedef         float XFtype    __attribute__ ((mode (XF)));
  84 #endif
  85 #if LONG_DOUBLE_TYPE_SIZE == 128
  86 typedef         float TFtype    __attribute__ ((mode (TF)));
  87 #endif
  88
  89 typedef int word_type __attribute__ ((mode (__word__)));
  90
  91 /* Make sure that we don't accidentally use any normal C language built-in
  92    type names in the first part of this file.  Instead we want to use *only*
  93    the type names defined above.  The following macro definitions insure
  94    that if we *do* accidentally use some normal C language built-in type name,
  95    we will get a syntax error.  */
  96
  97 #define char bogus_type
  98 #define short bogus_type
  99 #define int bogus_type
 100 #define long bogus_type
 101 #define unsigned bogus_type
 102 #define float bogus_type
 103 #define double bogus_type
 104
 105 #define SI_TYPE_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 106
 107 /* DIstructs are pairs of SItype values in the order determined by
 108    LIBGCC2_WORDS_BIG_ENDIAN.  */
 109
 110 #if LIBGCC2_WORDS_BIG_ENDIAN
 111   struct DIstruct {SItype high, low;};
 112 #else
 113   struct DIstruct {SItype low, high;};
 114 #endif
 115
 116 /* We need this union to unpack/pack DImode values, since we don't have
 117    any arithmetic yet.  Incoming DImode parameters are stored into the
 118    `ll' field, and the unpacked result is read from the struct `s'.  */
 119
 120 typedef union
 121 {
 122   struct DIstruct s;
 123   DItype ll;
 124 } DIunion;
 125
 126 #if (defined (L_udivmoddi4) || defined (L_muldi3) || defined (L_udiv_w_sdiv)\
 127      || defined (L_divdi3) || defined (L_udivdi3) \
 128      || defined (L_moddi3) || defined (L_umoddi3))
 129
 130 #include "longlong.h"
 131
 132 #endif /* udiv or mul */
 133
 134 extern DItype __fixunssfdi (SFtype a);
 135 extern DItype __fixunsdfdi (DFtype a);
 136 #if LONG_DOUBLE_TYPE_SIZE == 96
 137 extern DItype __fixunsxfdi (XFtype a);
 138 #endif
 139 #if LONG_DOUBLE_TYPE_SIZE == 128
 140 extern DItype __fixunstfdi (TFtype a);
 141 #endif
 142 \f
 143 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
 144 #if defined (L_divdi3) || defined (L_moddi3)
 145 static inline
 146 #endif
 147 DItype
 148 __negdi2 (DItype u)
 149 {
 150   DIunion w;
 151   DIunion uu;
 152
 153   uu.ll = u;
 154
 155   w.s.low = -uu.s.low;
 156   w.s.high = -uu.s.high - ((USItype) w.s.low > 0);
 157
 158   return w.ll;
 159 }
 160 #endif
 161 \f
 162 /* Unless shift functions are defined whith full ANSI prototypes,
 163    parameter b will be promoted to int if word_type is smaller than an int.  */
 164 #ifdef L_lshrdi3
 165 DItype
 166 __lshrdi3 (DItype u, word_type b)
 167 {
 168   DIunion w;
 169   word_type bm;
 170   DIunion uu;
 171
 172   if (b == 0)
 173     return u;
 174
 175   uu.ll = u;
 176
 177   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 178   if (bm <= 0)
 179     {
 180       w.s.high = 0;
 181       w.s.low = (USItype)uu.s.high >> -bm;
 182     }
 183   else
 184     {
 185       USItype carries = (USItype)uu.s.high << bm;
 186       w.s.high = (USItype)uu.s.high >> b;
 187       w.s.low = ((USItype)uu.s.low >> b) | carries;
 188     }
 189
 190   return w.ll;
 191 }
 192 #endif
 193
 194 #ifdef L_ashldi3
 195 DItype
 196 __ashldi3 (DItype u, word_type b)
 197 {
 198   DIunion w;
 199   word_type bm;
 200   DIunion uu;
 201
 202   if (b == 0)
 203     return u;
 204
 205   uu.ll = u;
 206
 207   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 208   if (bm <= 0)
 209     {
 210       w.s.low = 0;
 211       w.s.high = (USItype)uu.s.low << -bm;
 212     }
 213   else
 214     {
 215       USItype carries = (USItype)uu.s.low >> bm;
 216       w.s.low = (USItype)uu.s.low << b;
 217       w.s.high = ((USItype)uu.s.high << b) | carries;
 218     }
 219
 220   return w.ll;
 221 }
 222 #endif
 223
 224 #ifdef L_ashrdi3
 225 DItype
 226 __ashrdi3 (DItype u, word_type b)
 227 {
 228   DIunion w;
 229   word_type bm;
 230   DIunion uu;
 231
 232   if (b == 0)
 233     return u;
 234
 235   uu.ll = u;
 236
 237   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
 238   if (bm <= 0)
 239     {
 240       /* w.s.high = 1..1 or 0..0 */
 241       w.s.high = uu.s.high >> (sizeof (SItype) * BITS_PER_UNIT - 1);
 242       w.s.low = uu.s.high >> -bm;
 243     }
 244   else
 245     {
 246       USItype carries = (USItype)uu.s.high << bm;
 247       w.s.high = uu.s.high >> b;
 248       w.s.low = ((USItype)uu.s.low >> b) | carries;
 249     }
 250
 251   return w.ll;
 252 }
 253 #endif
 254 \f
 255 #ifdef L_ffsdi2
 256 DItype
 257 __ffsdi2 (DItype u)
 258 {
 259   DIunion uu, w;
 260   uu.ll = u;
 261   w.s.high = 0;
 262   w.s.low = ffs (uu.s.low);
 263   if (w.s.low != 0)
 264     return w.ll;
 265   w.s.low = ffs (uu.s.high);
 266   if (w.s.low != 0)
 267     {
 268       w.s.low += BITS_PER_UNIT * sizeof (SItype);
 269       return w.ll;
 270     }
 271   return w.ll;
 272 }
 273 #endif
 274 \f
 275 #ifdef L_muldi3
 276 DItype
 277 __muldi3 (DItype u, DItype v)
 278 {
 279   DIunion w;
 280   DIunion uu, vv;
 281
 282   uu.ll = u,
 283   vv.ll = v;
 284
 285   w.ll = __umulsidi3 (uu.s.low, vv.s.low);
 286   w.s.high += ((USItype) uu.s.low * (USItype) vv.s.high
 287                + (USItype) uu.s.high * (USItype) vv.s.low);
 288
 289   return w.ll;
 290 }
 291 #endif
 292 \f
 293 #ifdef L_udiv_w_sdiv
 294 #if defined (sdiv_qrnnd)
 295 USItype
 296 __udiv_w_sdiv (USItype *rp, USItype a1, USItype a0, USItype d)
 297 {
 298   USItype q, r;
 299   USItype c0, c1, b1;
 300
 301   if ((SItype) d >= 0)
 302     {
 303       if (a1 < d - a1 - (a0 >> (SI_TYPE_SIZE - 1)))
 304         {
 305           /* dividend, divisor, and quotient are nonnegative */
 306           sdiv_qrnnd (q, r, a1, a0, d);
 307         }
 308       else
 309         {
 310           /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
 311           sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (SI_TYPE_SIZE - 1));
 312           /* Divide (c1*2^32 + c0) by d */
 313           sdiv_qrnnd (q, r, c1, c0, d);
 314           /* Add 2^31 to quotient */
 315           q += (USItype) 1 << (SI_TYPE_SIZE - 1);
 316         }
 317     }
 318   else
 319     {
 320       b1 = d >> 1;                      /* d/2, between 2^30 and 2^31 - 1 */
 321       c1 = a1 >> 1;                     /* A/2 */
 322       c0 = (a1 << (SI_TYPE_SIZE - 1)) + (a0 >> 1);
 323
 324       if (a1 < b1)                      /* A < 2^32*b1, so A/2 < 2^31*b1 */
 325         {
 326           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 327
 328           r = 2*r + (a0 & 1);           /* Remainder from A/(2*b1) */
 329           if ((d & 1) != 0)
 330             {
 331               if (r >= q)
 332                 r = r - q;
 333               else if (q - r <= d)
 334                 {
 335                   r = r - q + d;
 336                   q--;
 337                 }
 338               else
 339                 {
 340                   r = r - q + 2*d;
 341                   q -= 2;
 342                 }
 343             }
 344         }
 345       else if (c1 < b1)                 /* So 2^31 <= (A/2)/b1 < 2^32 */
 346         {
 347           c1 = (b1 - 1) - c1;
 348           c0 = ~c0;                     /* logical NOT */
 349
 350           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 351
 352           q = ~q;                       /* (A/2)/b1 */
 353           r = (b1 - 1) - r;
 354
 355           r = 2*r + (a0 & 1);           /* A/(2*b1) */
 356
 357           if ((d & 1) != 0)
 358             {
 359               if (r >= q)
 360                 r = r - q;
 361               else if (q - r <= d)
 362                 {
 363                   r = r - q + d;
 364                   q--;
 365                 }
 366               else
 367                 {
 368                   r = r - q + 2*d;
 369                   q -= 2;
 370                 }
 371             }
 372         }
 373       else                              /* Implies c1 = b1 */
 374         {                               /* Hence a1 = d - 1 = 2*b1 - 1 */
 375           if (a0 >= -d)
 376             {
 377               q = -1;
 378               r = a0 + d;
 379             }
 380           else
 381             {
 382               q = -2;
 383               r = a0 + 2*d;
 384             }
 385         }
 386     }
 387
 388   *rp = r;
 389   return q;
 390 }
 391 #else
 392 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv.  */
 393 USItype
 394 __udiv_w_sdiv (USItype *rp, USItype a1, USItype a0, USItype d)
 395 {}
 396 #endif
 397 #endif
 398 \f
 399 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 400      defined (L_umoddi3) || defined (L_moddi3))
 401 #define L_udivmoddi4
 402 #endif
 403
 404 #ifdef L_udivmoddi4
 405 static const UQItype __clz_tab[] =
 406 {
 407   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,
 408   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,
 409   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,
 410   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,
 411   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,
 412   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,
 413   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,
 414   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,
 415 };
 416
 417 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 418      defined (L_umoddi3) || defined (L_moddi3))
 419 static inline
 420 #endif
 421 UDItype
 422 __udivmoddi4 (UDItype n, UDItype d, UDItype *rp)
 423 {
 424   DIunion ww;
 425   DIunion nn, dd;
 426   DIunion rr;
 427   USItype d0, d1, n0, n1, n2;
 428   USItype q0, q1;
 429   USItype b, bm;
 430
 431   nn.ll = n;
 432   dd.ll = d;
 433
 434   d0 = dd.s.low;
 435   d1 = dd.s.high;
 436   n0 = nn.s.low;
 437   n1 = nn.s.high;
 438
 439 #if !UDIV_NEEDS_NORMALIZATION
 440   if (d1 == 0)
 441     {
 442       if (d0 > n1)
 443         {
 444           /* 0q = nn / 0D */
 445
 446           udiv_qrnnd (q0, n0, n1, n0, d0);
 447           q1 = 0;
 448
 449           /* Remainder in n0.  */
 450         }
 451       else
 452         {
 453           /* qq = NN / 0d */
 454
 455           if (d0 == 0)
 456             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 457
 458           udiv_qrnnd (q1, n1, 0, n1, d0);
 459           udiv_qrnnd (q0, n0, n1, n0, d0);
 460
 461           /* Remainder in n0.  */
 462         }
 463
 464       if (rp != 0)
 465         {
 466           rr.s.low = n0;
 467           rr.s.high = 0;
 468           *rp = rr.ll;
 469         }
 470     }
 471
 472 #else /* UDIV_NEEDS_NORMALIZATION */
 473
 474   if (d1 == 0)
 475     {
 476       if (d0 > n1)
 477         {
 478           /* 0q = nn / 0D */
 479
 480           count_leading_zeros (bm, d0);
 481
 482           if (bm != 0)
 483             {
 484               /* Normalize, i.e. make the most significant bit of the
 485                  denominator set.  */
 486
 487               d0 = d0 << bm;
 488               n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm));
 489               n0 = n0 << bm;
 490             }
 491
 492           udiv_qrnnd (q0, n0, n1, n0, d0);
 493           q1 = 0;
 494
 495           /* Remainder in n0 >> bm.  */
 496         }
 497       else
 498         {
 499           /* qq = NN / 0d */
 500
 501           if (d0 == 0)
 502             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 503
 504           count_leading_zeros (bm, d0);
 505
 506           if (bm == 0)
 507             {
 508               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 509                  conclude (the most significant bit of n1 is set) /\ (the
 510                  leading quotient digit q1 = 1).
 511
 512                  This special case is necessary, not an optimization.
 513                  (Shifts counts of SI_TYPE_SIZE are undefined.)  */
 514
 515               n1 -= d0;
 516               q1 = 1;
 517             }
 518           else
 519             {
 520               /* Normalize.  */
 521
 522               b = SI_TYPE_SIZE - bm;
 523
 524               d0 = d0 << bm;
 525               n2 = n1 >> b;
 526               n1 = (n1 << bm) | (n0 >> b);
 527               n0 = n0 << bm;
 528
 529               udiv_qrnnd (q1, n1, n2, n1, d0);
 530             }
 531
 532           /* n1 != d0...  */
 533
 534           udiv_qrnnd (q0, n0, n1, n0, d0);
 535
 536           /* Remainder in n0 >> bm.  */
 537         }
 538
 539       if (rp != 0)
 540         {
 541           rr.s.low = n0 >> bm;
 542           rr.s.high = 0;
 543           *rp = rr.ll;
 544         }
 545     }
 546 #endif /* UDIV_NEEDS_NORMALIZATION */
 547
 548   else
 549     {
 550       if (d1 > n1)
 551         {
 552           /* 00 = nn / DD */
 553
 554           q0 = 0;
 555           q1 = 0;
 556
 557           /* Remainder in n1n0.  */
 558           if (rp != 0)
 559             {
 560               rr.s.low = n0;
 561               rr.s.high = n1;
 562               *rp = rr.ll;
 563             }
 564         }
 565       else
 566         {
 567           /* 0q = NN / dd */
 568
 569           count_leading_zeros (bm, d1);
 570           if (bm == 0)
 571             {
 572               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 573                  conclude (the most significant bit of n1 is set) /\ (the
 574                  quotient digit q0 = 0 or 1).
 575
 576                  This special case is necessary, not an optimization.  */
 577
 578               /* The condition on the next line takes advantage of that
 579                  n1 >= d1 (true due to program flow).  */
 580               if (n1 > d1 || n0 >= d0)
 581                 {
 582                   q0 = 1;
 583                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 584                 }
 585               else
 586                 q0 = 0;
 587
 588               q1 = 0;
 589
 590               if (rp != 0)
 591                 {
 592                   rr.s.low = n0;
 593                   rr.s.high = n1;
 594                   *rp = rr.ll;
 595                 }
 596             }
 597           else
 598             {
 599               USItype m1, m0;
 600               /* Normalize.  */
 601
 602               b = SI_TYPE_SIZE - bm;
 603
 604               d1 = (d1 << bm) | (d0 >> b);
 605               d0 = d0 << bm;
 606               n2 = n1 >> b;
 607               n1 = (n1 << bm) | (n0 >> b);
 608               n0 = n0 << bm;
 609
 610               udiv_qrnnd (q0, n1, n2, n1, d1);
 611               umul_ppmm (m1, m0, q0, d0);
 612
 613               if (m1 > n1 || (m1 == n1 && m0 > n0))
 614                 {
 615                   q0--;
 616                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
 617                 }
 618
 619               q1 = 0;
 620
 621               /* Remainder in (n1n0 - m1m0) >> bm.  */
 622               if (rp != 0)
 623                 {
 624                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
 625                   rr.s.low = (n1 << b) | (n0 >> bm);
 626                   rr.s.high = n1 >> bm;
 627                   *rp = rr.ll;
 628                 }
 629             }
 630         }
 631     }
 632
 633   ww.s.low = q0;
 634   ww.s.high = q1;
 635   return ww.ll;
 636 }
 637 #endif
 638
 639 #ifdef L_divdi3
 640 UDItype __udivmoddi4 ();
 641
 642 DItype
 643 __divdi3 (DItype u, DItype v)
 644 {
 645   word_type c = 0;
 646   DIunion uu, vv;
 647   DItype w;
 648
 649   uu.ll = u;
 650   vv.ll = v;
 651
 652   if (uu.s.high < 0)
 653     c = ~c,
 654     uu.ll = __negdi2 (uu.ll);
 655   if (vv.s.high < 0)
 656     c = ~c,
 657     vv.ll = __negdi2 (vv.ll);
 658
 659   w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0);
 660   if (c)
 661     w = __negdi2 (w);
 662
 663   return w;
 664 }
 665 #endif
 666
 667 #ifdef L_moddi3
 668 UDItype __udivmoddi4 ();
 669 DItype
 670 __moddi3 (DItype u, DItype v)
 671 {
 672   word_type c = 0;
 673   DIunion uu, vv;
 674   DItype w;
 675
 676   uu.ll = u;
 677   vv.ll = v;
 678
 679   if (uu.s.high < 0)
 680     c = ~c,
 681     uu.ll = __negdi2 (uu.ll);
 682   if (vv.s.high < 0)
 683     vv.ll = __negdi2 (vv.ll);
 684
 685   (void) __udivmoddi4 (uu.ll, vv.ll, &w);
 686   if (c)
 687     w = __negdi2 (w);
 688
 689   return w;
 690 }
 691 #endif
 692
 693 #ifdef L_umoddi3
 694 UDItype __udivmoddi4 ();
 695 UDItype
 696 __umoddi3 (UDItype u, UDItype v)
 697 {
 698   UDItype w;
 699
 700   (void) __udivmoddi4 (u, v, &w);
 701
 702   return w;
 703 }
 704 #endif
 705
 706 #ifdef L_udivdi3
 707 UDItype __udivmoddi4 ();
 708 UDItype
 709 __udivdi3 (UDItype n, UDItype d)
 710 {
 711   return __udivmoddi4 (n, d, (UDItype *) 0);
 712 }
 713 #endif
 714 \f
 715 #ifdef L_cmpdi2
 716 word_type
 717 __cmpdi2 (DItype a, DItype b)
 718 {
 719   DIunion au, bu;
 720
 721   au.ll = a, bu.ll = b;
 722
 723   if (au.s.high < bu.s.high)
 724     return 0;
 725   else if (au.s.high > bu.s.high)
 726     return 2;
 727   if ((USItype) au.s.low < (USItype) bu.s.low)
 728     return 0;
 729   else if ((USItype) au.s.low > (USItype) bu.s.low)
 730     return 2;
 731   return 1;
 732 }
 733 #endif
 734
 735 #ifdef L_ucmpdi2
 736 word_type
 737 __ucmpdi2 (DItype a, DItype b)
 738 {
 739   DIunion au, bu;
 740
 741   au.ll = a, bu.ll = b;
 742
 743   if ((USItype) au.s.high < (USItype) bu.s.high)
 744     return 0;
 745   else if ((USItype) au.s.high > (USItype) bu.s.high)
 746     return 2;
 747   if ((USItype) au.s.low < (USItype) bu.s.low)
 748     return 0;
 749   else if ((USItype) au.s.low > (USItype) bu.s.low)
 750     return 2;
 751   return 1;
 752 }
 753 #endif
 754 \f
 755 #if defined(L_fixunstfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
 756 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 757 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 758
 759 DItype
 760 __fixunstfdi (TFtype a)
 761 {
 762   TFtype b;
 763   UDItype v;
 764
 765   if (a < 0)
 766     return 0;
 767
 768   /* Compute high word of result, as a flonum.  */
 769   b = (a / HIGH_WORD_COEFF);
 770   /* Convert that to fixed (but not to DItype!),
 771      and shift it into the high word.  */
 772   v = (USItype) b;
 773   v <<= WORD_SIZE;
 774   /* Remove high part from the TFtype, leaving the low part as flonum.  */
 775   a -= (TFtype)v;
 776   /* Convert that to fixed (but not to DItype!) and add it in.
 777      Sometimes A comes out negative.  This is significant, since
 778      A has more bits than a long int does.  */
 779   if (a < 0)
 780     v -= (USItype) (- a);
 781   else
 782     v += (USItype) a;
 783   return v;
 784 }
 785 #endif
 786
 787 #if defined(L_fixtfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
 788 DItype
 789 __fixtfdi (TFtype a)
 790 {
 791   if (a < 0)
 792     return - __fixunstfdi (-a);
 793   return __fixunstfdi (a);
 794 }
 795 #endif
 796
 797 #if defined(L_fixunsxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
 798 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 799 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 800
 801 DItype
 802 __fixunsxfdi (XFtype a)
 803 {
 804   XFtype b;
 805   UDItype v;
 806
 807   if (a < 0)
 808     return 0;
 809
 810   /* Compute high word of result, as a flonum.  */
 811   b = (a / HIGH_WORD_COEFF);
 812   /* Convert that to fixed (but not to DItype!),
 813      and shift it into the high word.  */
 814   v = (USItype) b;
 815   v <<= WORD_SIZE;
 816   /* Remove high part from the XFtype, leaving the low part as flonum.  */
 817   a -= (XFtype)v;
 818   /* Convert that to fixed (but not to DItype!) and add it in.
 819      Sometimes A comes out negative.  This is significant, since
 820      A has more bits than a long int does.  */
 821   if (a < 0)
 822     v -= (USItype) (- a);
 823   else
 824     v += (USItype) a;
 825   return v;
 826 }
 827 #endif
 828
 829 #if defined(L_fixxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
 830 DItype
 831 __fixxfdi (XFtype a)
 832 {
 833   if (a < 0)
 834     return - __fixunsxfdi (-a);
 835   return __fixunsxfdi (a);
 836 }
 837 #endif
 838
 839 #ifdef L_fixunsdfdi
 840 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 841 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 842
 843 DItype
 844 __fixunsdfdi (DFtype a)
 845 {
 846   DFtype b;
 847   UDItype v;
 848
 849   if (a < 0)
 850     return 0;
 851
 852   /* Compute high word of result, as a flonum.  */
 853   b = (a / HIGH_WORD_COEFF);
 854   /* Convert that to fixed (but not to DItype!),
 855      and shift it into the high word.  */
 856   v = (USItype) b;
 857   v <<= WORD_SIZE;
 858   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 859   a -= (DFtype)v;
 860   /* Convert that to fixed (but not to DItype!) and add it in.
 861      Sometimes A comes out negative.  This is significant, since
 862      A has more bits than a long int does.  */
 863   if (a < 0)
 864     v -= (USItype) (- a);
 865   else
 866     v += (USItype) a;
 867   return v;
 868 }
 869 #endif
 870
 871 #ifdef L_fixdfdi
 872 DItype
 873 __fixdfdi (DFtype a)
 874 {
 875   if (a < 0)
 876     return - __fixunsdfdi (-a);
 877   return __fixunsdfdi (a);
 878 }
 879 #endif
 880
 881 #ifdef L_fixunssfdi
 882 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 883 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 884
 885 DItype
 886 __fixunssfdi (SFtype original_a)
 887 {
 888   /* Convert the SFtype to a DFtype, because that is surely not going
 889      to lose any bits.  Some day someone else can write a faster version
 890      that avoids converting to DFtype, and verify it really works right.  */
 891   DFtype a = original_a;
 892   DFtype b;
 893   UDItype v;
 894
 895   if (a < 0)
 896     return 0;
 897
 898   /* Compute high word of result, as a flonum.  */
 899   b = (a / HIGH_WORD_COEFF);
 900   /* Convert that to fixed (but not to DItype!),
 901      and shift it into the high word.  */
 902   v = (USItype) b;
 903   v <<= WORD_SIZE;
 904   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 905   a -= (DFtype)v;
 906   /* Convert that to fixed (but not to DItype!) and add it in.
 907      Sometimes A comes out negative.  This is significant, since
 908      A has more bits than a long int does.  */
 909   if (a < 0)
 910     v -= (USItype) (- a);
 911   else
 912     v += (USItype) a;
 913   return v;
 914 }
 915 #endif
 916
 917 #ifdef L_fixsfdi
 918 DItype
 919 __fixsfdi (SFtype a)
 920 {
 921   if (a < 0)
 922     return - __fixunssfdi (-a);
 923   return __fixunssfdi (a);
 924 }
 925 #endif
 926
 927 #if defined(L_floatdixf) && (LONG_DOUBLE_TYPE_SIZE == 96)
 928 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 929 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
 930 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 931
 932 XFtype
 933 __floatdixf (DItype u)
 934 {
 935   XFtype d;
 936   SItype negate = 0;
 937
 938   if (u < 0)
 939     u = -u, negate = 1;
 940
 941   d = (USItype) (u >> WORD_SIZE);
 942   d *= HIGH_HALFWORD_COEFF;
 943   d *= HIGH_HALFWORD_COEFF;
 944   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
 945
 946   return (negate ? -d : d);
 947 }
 948 #endif
 949
 950 #if defined(L_floatditf) && (LONG_DOUBLE_TYPE_SIZE == 128)
 951 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 952 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
 953 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 954
 955 TFtype
 956 __floatditf (DItype u)
 957 {
 958   TFtype d;
 959   SItype negate = 0;
 960
 961   if (u < 0)
 962     u = -u, negate = 1;
 963
 964   d = (USItype) (u >> WORD_SIZE);
 965   d *= HIGH_HALFWORD_COEFF;
 966   d *= HIGH_HALFWORD_COEFF;
 967   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
 968
 969   return (negate ? -d : d);
 970 }
 971 #endif
 972
 973 #ifdef L_floatdidf
 974 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
 975 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
 976 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
 977
 978 DFtype
 979 __floatdidf (DItype u)
 980 {
 981   DFtype 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_floatdisf
 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 #define DI_SIZE (sizeof (DItype) * BITS_PER_UNIT)
1001
1002 /* Define codes for all the float formats that we know of.  Note
1003    that this is copied from real.h.  */
1004
1005 #define UNKNOWN_FLOAT_FORMAT 0
1006 #define IEEE_FLOAT_FORMAT 1
1007 #define VAX_FLOAT_FORMAT 2
1008 #define IBM_FLOAT_FORMAT 3
1009
1010 /* Default to IEEE float if not specified.  Nearly all machines use it.  */
1011 #ifndef HOST_FLOAT_FORMAT
1012 #define HOST_FLOAT_FORMAT       IEEE_FLOAT_FORMAT
1013 #endif
1014
1015 #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1016 #define DF_SIZE 53
1017 #define SF_SIZE 24
1018 #endif
1019
1020 #if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
1021 #define DF_SIZE 56
1022 #define SF_SIZE 24
1023 #endif
1024
1025 #if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
1026 #define DF_SIZE 56
1027 #define SF_SIZE 24
1028 #endif
1029
1030 SFtype
1031 __floatdisf (DItype u)
1032 {
1033   /* Do the calculation in DFmode
1034      so that we don't lose any of the precision of the high word
1035      while multiplying it.  */
1036   DFtype f;
1037   SItype negate = 0;
1038
1039   if (u < 0)
1040     u = -u, negate = 1;
1041
1042   /* Protect against double-rounding error.
1043      Represent any low-order bits, that might be truncated in DFmode,
1044      by a bit that won't be lost.  The bit can go in anywhere below the
1045      rounding position of the SFmode.  A fixed mask and bit position
1046      handles all usual configurations.  It doesn't handle the case
1047      of 128-bit DImode, however.  */
1048   if (DF_SIZE < DI_SIZE
1049       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1050     {
1051 #define REP_BIT ((USItype) 1 << (DI_SIZE - DF_SIZE))
1052       if (u >= ((UDItype) 1 << DF_SIZE))
1053         {
1054           if ((USItype) u & (REP_BIT - 1))
1055             u |= REP_BIT;
1056         }
1057     }
1058   f = (USItype) (u >> WORD_SIZE);
1059   f *= HIGH_HALFWORD_COEFF;
1060   f *= HIGH_HALFWORD_COEFF;
1061   f += (USItype) (u & (HIGH_WORD_COEFF - 1));
1062
1063   return (SFtype) (negate ? -f : f);
1064 }
1065 #endif
1066
1067 #if defined(L_fixunsxfsi) && LONG_DOUBLE_TYPE_SIZE == 96
1068 /* Reenable the normal types, in case limits.h needs them.  */
1069 #undef char
1070 #undef short
1071 #undef int
1072 #undef long
1073 #undef unsigned
1074 #undef float
1075 #undef double
1076 #undef MIN
1077 #undef MAX
1078 #include <limits.h>
1079
1080 USItype
1081 __fixunsxfsi (XFtype a)
1082 {
1083   if (a >= - (DFtype) LONG_MIN)
1084     return (SItype) (a + LONG_MIN) - LONG_MIN;
1085   return (SItype) a;
1086 }
1087 #endif
1088
1089 #ifdef L_fixunsdfsi
1090 /* Reenable the normal types, in case limits.h needs them.  */
1091 #undef char
1092 #undef short
1093 #undef int
1094 #undef long
1095 #undef unsigned
1096 #undef float
1097 #undef double
1098 #undef MIN
1099 #undef MAX
1100 #include <limits.h>
1101
1102 USItype
1103 __fixunsdfsi (DFtype a)
1104 {
1105   if (a >= - (DFtype) LONG_MIN)
1106     return (SItype) (a + LONG_MIN) - LONG_MIN;
1107   return (SItype) a;
1108 }
1109 #endif
1110
1111 #ifdef L_fixunssfsi
1112 /* Reenable the normal types, in case limits.h needs them.  */
1113 #undef char
1114 #undef short
1115 #undef int
1116 #undef long
1117 #undef unsigned
1118 #undef float
1119 #undef double
1120 #undef MIN
1121 #undef MAX
1122 #include <limits.h>
1123
1124 USItype
1125 __fixunssfsi (SFtype a)
1126 {
1127   if (a >= - (SFtype) LONG_MIN)
1128     return (SItype) (a + LONG_MIN) - LONG_MIN;
1129   return (SItype) a;
1130 }
1131 #endif
1132 \f
1133 /* From here on down, the routines use normal data types.  */
1134
1135 #define SItype bogus_type
1136 #define USItype bogus_type
1137 #define DItype bogus_type
1138 #define UDItype bogus_type
1139 #define SFtype bogus_type
1140 #define DFtype bogus_type
1141
1142 #undef char
1143 #undef short
1144 #undef int
1145 #undef long
1146 #undef unsigned
1147 #undef float
1148 #undef double
1149 \f
1150 #ifdef L__gcc_bcmp
1151
1152 /* Like bcmp except the sign is meaningful.
1153    Result is negative if S1 is less than S2,
1154    positive if S1 is greater, 0 if S1 and S2 are equal.  */
1155
1156 int
1157 __gcc_bcmp (unsigned char *s1, unsigned char *s2, size_t size)
1158 {
1159   while (size > 0)
1160     {
1161       unsigned char c1 = *s1++, c2 = *s2++;
1162       if (c1 != c2)
1163         return c1 - c2;
1164       size--;
1165     }
1166   return 0;
1167 }
1168
1169 #endif
1170 \f\f
1171 #ifdef L__dummy
1172 void
1173 __dummy () {}
1174 #endif
1175
1176 #ifdef L_varargs
1177 #ifdef __i860__
1178 #if defined(__svr4__) || defined(__alliant__)
1179         asm ("  .text");
1180         asm ("  .align  4");
1181
1182 /* The Alliant needs the added underscore.  */
1183         asm (".globl    __builtin_saveregs");
1184 asm ("__builtin_saveregs:");
1185         asm (".globl    ___builtin_saveregs");
1186 asm ("___builtin_saveregs:");
1187
1188         asm ("  andnot  0x0f,%sp,%sp"); /* round down to 16-byte boundary */
1189         asm ("  adds    -96,%sp,%sp");  /* allocate stack space for reg save
1190                                            area and also for a new va_list
1191                                            structure */
1192         /* Save all argument registers in the arg reg save area.  The
1193            arg reg save area must have the following layout (according
1194            to the svr4 ABI):
1195
1196                 struct {
1197                   union  {
1198                     float freg[8];
1199                     double dreg[4];
1200                   } float_regs;
1201                   long  ireg[12];
1202                 };
1203         */
1204
1205         asm ("  fst.q   %f8,  0(%sp)"); /* save floating regs (f8-f15)  */
1206         asm ("  fst.q   %f12,16(%sp)");
1207
1208         asm ("  st.l    %r16,32(%sp)"); /* save integer regs (r16-r27) */
1209         asm ("  st.l    %r17,36(%sp)");
1210         asm ("  st.l    %r18,40(%sp)");
1211         asm ("  st.l    %r19,44(%sp)");
1212         asm ("  st.l    %r20,48(%sp)");
1213         asm ("  st.l    %r21,52(%sp)");
1214         asm ("  st.l    %r22,56(%sp)");
1215         asm ("  st.l    %r23,60(%sp)");
1216         asm ("  st.l    %r24,64(%sp)");
1217         asm ("  st.l    %r25,68(%sp)");
1218         asm ("  st.l    %r26,72(%sp)");
1219         asm ("  st.l    %r27,76(%sp)");
1220
1221         asm ("  adds    80,%sp,%r16");  /* compute the address of the new
1222                                            va_list structure.  Put in into
1223                                            r16 so that it will be returned
1224                                            to the caller.  */
1225
1226         /* Initialize all fields of the new va_list structure.  This
1227            structure looks like:
1228
1229                 typedef struct {
1230                     unsigned long       ireg_used;
1231                     unsigned long       freg_used;
1232                     long                *reg_base;
1233                     long                *mem_ptr;
1234                 } va_list;
1235         */
1236
1237         asm ("  st.l    %r0, 0(%r16)"); /* nfixed */
1238         asm ("  st.l    %r0, 4(%r16)"); /* nfloating */
1239         asm ("  st.l    %sp, 8(%r16)"); /* __va_ctl points to __va_struct.  */
1240         asm ("  bri     %r1");          /* delayed return */
1241         asm ("  st.l    %r28,12(%r16)"); /* pointer to overflow args */
1242
1243 #else /* not __svr4__ */
1244 #if defined(__PARAGON__)
1245         /*
1246          *      we'll use SVR4-ish varargs but need SVR3.2 assembler syntax,
1247          *      and we stand a better chance of hooking into libraries
1248          *      compiled by PGI.  [andyp@ssd.intel.com]
1249          */
1250         asm ("  .text");
1251         asm ("  .align  4");
1252         asm (".globl    __builtin_saveregs");
1253 asm ("__builtin_saveregs:");
1254         asm (".globl    ___builtin_saveregs");
1255 asm ("___builtin_saveregs:");
1256
1257         asm ("  andnot  0x0f,sp,sp");   /* round down to 16-byte boundary */
1258         asm ("  adds    -96,sp,sp");    /* allocate stack space for reg save
1259                                            area and also for a new va_list
1260                                            structure */
1261         /* Save all argument registers in the arg reg save area.  The
1262            arg reg save area must have the following layout (according
1263            to the svr4 ABI):
1264
1265                 struct {
1266                   union  {
1267                     float freg[8];
1268                     double dreg[4];
1269                   } float_regs;
1270                   long  ireg[12];
1271                 };
1272         */
1273
1274         asm ("  fst.q   f8,  0(sp)");
1275         asm ("  fst.q   f12,16(sp)");
1276         asm ("  st.l    r16,32(sp)");
1277         asm ("  st.l    r17,36(sp)");
1278         asm ("  st.l    r18,40(sp)");
1279         asm ("  st.l    r19,44(sp)");
1280         asm ("  st.l    r20,48(sp)");
1281         asm ("  st.l    r21,52(sp)");
1282         asm ("  st.l    r22,56(sp)");
1283         asm ("  st.l    r23,60(sp)");
1284         asm ("  st.l    r24,64(sp)");
1285         asm ("  st.l    r25,68(sp)");
1286         asm ("  st.l    r26,72(sp)");
1287         asm ("  st.l    r27,76(sp)");
1288
1289         asm ("  adds    80,sp,r16");  /* compute the address of the new
1290                                            va_list structure.  Put in into
1291                                            r16 so that it will be returned
1292                                            to the caller.  */
1293
1294         /* Initialize all fields of the new va_list structure.  This
1295            structure looks like:
1296
1297                 typedef struct {
1298                     unsigned long       ireg_used;
1299                     unsigned long       freg_used;
1300                     long                *reg_base;
1301                     long                *mem_ptr;
1302                 } va_list;
1303         */
1304
1305         asm ("  st.l    r0, 0(r16)"); /* nfixed */
1306         asm ("  st.l    r0, 4(r16)"); /* nfloating */
1307         asm ("  st.l    sp, 8(r16)"); /* __va_ctl points to __va_struct.  */
1308         asm ("  bri     r1");           /* delayed return */
1309         asm ("   st.l   r28,12(r16)"); /* pointer to overflow args */
1310 #else /* not __PARAGON__ */
1311         asm ("  .text");
1312         asm ("  .align  4");
1313
1314         asm (".globl    ___builtin_saveregs");
1315         asm ("___builtin_saveregs:");
1316         asm ("  mov     sp,r30");
1317         asm ("  andnot  0x0f,sp,sp");
1318         asm ("  adds    -96,sp,sp");  /* allocate sufficient space on the stack */
1319
1320 /* Fill in the __va_struct.  */
1321         asm ("  st.l    r16, 0(sp)"); /* save integer regs (r16-r27) */
1322         asm ("  st.l    r17, 4(sp)"); /* int    fixed[12] */
1323         asm ("  st.l    r18, 8(sp)");
1324         asm ("  st.l    r19,12(sp)");
1325         asm ("  st.l    r20,16(sp)");
1326         asm ("  st.l    r21,20(sp)");
1327         asm ("  st.l    r22,24(sp)");
1328         asm ("  st.l    r23,28(sp)");
1329         asm ("  st.l    r24,32(sp)");
1330         asm ("  st.l    r25,36(sp)");
1331         asm ("  st.l    r26,40(sp)");
1332         asm ("  st.l    r27,44(sp)");
1333
1334         asm ("  fst.q   f8, 48(sp)"); /* save floating regs (f8-f15) */
1335         asm ("  fst.q   f12,64(sp)"); /* int floating[8] */
1336
1337 /* Fill in the __va_ctl.  */
1338         asm ("  st.l    sp, 80(sp)"); /* __va_ctl points to __va_struct.  */
1339         asm ("  st.l    r28,84(sp)"); /* pointer to more args */
1340         asm ("  st.l    r0, 88(sp)"); /* nfixed */
1341         asm ("  st.l    r0, 92(sp)"); /* nfloating */
1342
1343         asm ("  adds    80,sp,r16");  /* return address of the __va_ctl.  */
1344         asm ("  bri     r1");
1345         asm ("  mov     r30,sp");
1346                                 /* recover stack and pass address to start
1347                                    of data.  */
1348 #endif /* not __PARAGON__ */
1349 #endif /* not __svr4__ */
1350 #else /* not __i860__ */
1351 #ifdef __sparc__
1352         asm (".global __builtin_saveregs");
1353         asm ("__builtin_saveregs:");
1354         asm (".global ___builtin_saveregs");
1355         asm ("___builtin_saveregs:");
1356 #ifdef NEED_PROC_COMMAND
1357         asm (".proc 020");
1358 #endif
1359         asm ("st %i0,[%fp+68]");
1360         asm ("st %i1,[%fp+72]");
1361         asm ("st %i2,[%fp+76]");
1362         asm ("st %i3,[%fp+80]");
1363         asm ("st %i4,[%fp+84]");
1364         asm ("retl");
1365         asm ("st %i5,[%fp+88]");
1366 #ifdef NEED_TYPE_COMMAND
1367         asm (".type __builtin_saveregs,#function");
1368         asm (".size __builtin_saveregs,.-__builtin_saveregs");
1369 #endif
1370 #else /* not __sparc__ */
1371 #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
1372
1373   asm ("        .text");
1374 #ifdef __mips16
1375   asm ("        .set nomips16");
1376 #endif
1377   asm ("        .ent __builtin_saveregs");
1378   asm ("        .globl __builtin_saveregs");
1379   asm ("__builtin_saveregs:");
1380   asm ("        sw      $4,0($30)");
1381   asm ("        sw      $5,4($30)");
1382   asm ("        sw      $6,8($30)");
1383   asm ("        sw      $7,12($30)");
1384   asm ("        j       $31");
1385   asm ("        .end __builtin_saveregs");
1386 #else /* not __mips__, etc.  */
1387
1388 void *
1389 __builtin_saveregs ()
1390 {
1391   abort ();
1392 }
1393
1394 #endif /* not __mips__ */
1395 #endif /* not __sparc__ */
1396 #endif /* not __i860__ */
1397 #endif
1398 \f
1399 #ifdef L_eprintf
1400 #ifndef inhibit_libc
1401
1402 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1403 #include <stdio.h>
1404 /* This is used by the `assert' macro.  */
1405 void
1406 __eprintf (const char *string, const char *expression,
1407            int line, const char *filename)
1408 {
1409   fprintf (stderr, string, expression, line, filename);
1410   fflush (stderr);
1411   abort ();
1412 }
1413
1414 #endif
1415 #endif
1416
1417 #ifdef L_bb
1418
1419 /* Structure emitted by -a  */
1420 struct bb
1421 {
1422   long zero_word;
1423   const char *filename;
1424   long *counts;
1425   long ncounts;
1426   struct bb *next;
1427   const unsigned long *addresses;
1428
1429   /* Older GCC's did not emit these fields.  */
1430   long nwords;
1431   const char **functions;
1432   const long *line_nums;
1433   const char **filenames;
1434   char *flags;
1435 };
1436
1437 #ifdef BLOCK_PROFILER_CODE
1438 BLOCK_PROFILER_CODE
1439 #else
1440 #ifndef inhibit_libc
1441
1442 /* Simple minded basic block profiling output dumper for
1443    systems that don't provide tcov support.  At present,
1444    it requires atexit and stdio.  */
1445
1446 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1447 #include <stdio.h>
1448 char *ctime ();
1449
1450 #include "gbl-ctors.h"
1451 #include "gcov-io.h"
1452 #include <string.h>
1453
1454 static struct bb *bb_head;
1455
1456 /* Return the number of digits needed to print a value */
1457 /* __inline__ */ static int num_digits (long value, int base)
1458 {
1459   int minus = (value < 0 && base != 16);
1460   unsigned long v = (minus) ? -value : value;
1461   int ret = minus;
1462
1463   do
1464     {
1465       v /= base;
1466       ret++;
1467     }
1468   while (v);
1469
1470   return ret;
1471 }
1472
1473 void
1474 __bb_exit_func (void)
1475 {
1476   FILE *da_file, *file;
1477   long time_value;
1478   int i;
1479
1480   if (bb_head == 0)
1481     return;
1482
1483   i = strlen (bb_head->filename) - 3;
1484
1485   if (!strcmp (bb_head->filename+i, ".da"))
1486     {
1487       /* Must be -fprofile-arcs not -a.
1488          Dump data in a form that gcov expects.  */
1489
1490       struct bb *ptr;
1491
1492       for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1493         {
1494           /* If the file exists, and the number of counts in it is the same,
1495              then merge them in.  */
1496
1497           if ((da_file = fopen (ptr->filename, "r")) != 0)
1498             {
1499               long n_counts = 0;
1500               unsigned char tmp;
1501               int i;
1502               int ret = 0;
1503
1504
1505               if (__read_long (&n_counts, da_file, 8) != 0)
1506                 {
1507                   fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1508                            ptr->filename);
1509                   continue;
1510                 }
1511
1512               if (n_counts == ptr->ncounts)
1513                 {
1514                   int i;
1515
1516                   for (i = 0; i < n_counts; i++)
1517                     {
1518                       long v = 0;
1519                       unsigned char tmp;
1520                       int j;
1521                       int ret = 0;
1522
1523                       if (__read_long (&v, da_file, 8) != 0)
1524                         {
1525                           fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1526                                    ptr->filename);
1527                           break;
1528                         }
1529                       ptr->counts[i] += v;
1530                     }
1531                 }
1532
1533               if (fclose (da_file) == EOF)
1534                 fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1535                          ptr->filename);
1536             }
1537           if ((da_file = fopen (ptr->filename, "w")) == 0)
1538             {
1539               fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1540                        ptr->filename);
1541               continue;
1542             }
1543
1544           /* ??? Should first write a header to the file.  Preferably, a 4 byte
1545              magic number, 4 bytes containing the time the program was
1546              compiled, 4 bytes containing the last modification time of the
1547              source file, and 4 bytes indicating the compiler options used.
1548
1549              That way we can easily verify that the proper source/executable/
1550              data file combination is being used from gcov.  */
1551
1552           if (__write_long (ptr->ncounts, da_file, 8) != 0)
1553             {
1554
1555               fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1556                        ptr->filename);
1557             }
1558           else
1559             {
1560               int j;
1561               long *count_ptr = ptr->counts;
1562               int ret = 0;
1563               for (j = ptr->ncounts; j > 0; j--)
1564                 {
1565                   if (__write_long (*count_ptr, da_file, 8) != 0)
1566                     {
1567                       ret=1;
1568                       break;
1569                     }
1570                   count_ptr++;
1571                 }
1572               if (ret)
1573                 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1574                          ptr->filename);
1575             }
1576
1577           if (fclose (da_file) == EOF)
1578             fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1579                      ptr->filename);
1580         }
1581
1582       return;
1583     }
1584
1585   /* Must be basic block profiling.  Emit a human readable output file.  */
1586
1587   file = fopen ("bb.out", "a");
1588
1589   if (!file)
1590     perror ("bb.out");
1591
1592   else
1593     {
1594       struct bb *ptr;
1595
1596       /* This is somewhat type incorrect, but it avoids worrying about
1597          exactly where time.h is included from.  It should be ok unless
1598          a void * differs from other pointer formats, or if sizeof (long)
1599          is < sizeof (time_t).  It would be nice if we could assume the
1600          use of rationale standards here.  */
1601
1602       time ((void *) &time_value);
1603       fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));
1604
1605       /* We check the length field explicitly in order to allow compatibility
1606          with older GCC's which did not provide it.  */
1607
1608       for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1609         {
1610           int i;
1611           int func_p    = (ptr->nwords >= sizeof (struct bb)
1612                            && ptr->nwords <= 1000
1613                            && ptr->functions);
1614           int line_p    = (func_p && ptr->line_nums);
1615           int file_p    = (func_p && ptr->filenames);
1616           int addr_p    = (ptr->addresses != 0);
1617           long ncounts  = ptr->ncounts;
1618           long cnt_max  = 0;
1619           long line_max = 0;
1620           long addr_max = 0;
1621           int file_len  = 0;
1622           int func_len  = 0;
1623           int blk_len   = num_digits (ncounts, 10);
1624           int cnt_len;
1625           int line_len;
1626           int addr_len;
1627
1628           fprintf (file, "File %s, %ld basic blocks \n\n",
1629                    ptr->filename, ncounts);
1630
1631           /* Get max values for each field.  */
1632           for (i = 0; i < ncounts; i++)
1633             {
1634               const char *p;
1635               int len;
1636
1637               if (cnt_max < ptr->counts[i])
1638                 cnt_max = ptr->counts[i];
1639
1640               if (addr_p && addr_max < ptr->addresses[i])
1641                 addr_max = ptr->addresses[i];
1642
1643               if (line_p && line_max < ptr->line_nums[i])
1644                 line_max = ptr->line_nums[i];
1645
1646               if (func_p)
1647                 {
1648                   p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
1649                   len = strlen (p);
1650                   if (func_len < len)
1651                     func_len = len;
1652                 }
1653
1654               if (file_p)
1655                 {
1656                   p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
1657                   len = strlen (p);
1658                   if (file_len < len)
1659                     file_len = len;
1660                 }
1661             }
1662
1663           addr_len = num_digits (addr_max, 16);
1664           cnt_len  = num_digits (cnt_max, 10);
1665           line_len = num_digits (line_max, 10);
1666
1667           /* Now print out the basic block information.  */
1668           for (i = 0; i < ncounts; i++)
1669             {
1670               fprintf (file,
1671                        "    Block #%*d: executed %*ld time(s)",
1672                        blk_len, i+1,
1673                        cnt_len, ptr->counts[i]);
1674
1675               if (addr_p)
1676                 fprintf (file, " address= 0x%.*lx", addr_len,
1677                          ptr->addresses[i]);
1678
1679               if (func_p)
1680                 fprintf (file, " function= %-*s", func_len,
1681                          (ptr->functions[i]) ? ptr->functions[i] : "<none>");
1682
1683               if (line_p)
1684                 fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);
1685
1686               if (file_p)
1687                 fprintf (file, " file= %s",
1688                          (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");
1689
1690               fprintf (file, "\n");
1691             }
1692
1693           fprintf (file, "\n");
1694           fflush (file);
1695         }
1696
1697       fprintf (file, "\n\n");
1698       fclose (file);
1699     }
1700 }
1701
1702 void
1703 __bb_init_func (struct bb *blocks)
1704 {
1705   /* User is supposed to check whether the first word is non-0,
1706      but just in case....  */
1707
1708   if (blocks->zero_word)
1709     return;
1710
1711 #ifdef ON_EXIT
1712   /* Initialize destructor.  */
1713   if (!bb_head)
1714     ON_EXIT (__bb_exit_func, 0);
1715 #endif
1716
1717   /* Set up linked list.  */
1718   blocks->zero_word = 1;
1719   blocks->next = bb_head;
1720   bb_head = blocks;
1721 }
1722
1723 #ifndef MACHINE_STATE_SAVE
1724 #define MACHINE_STATE_SAVE(ID)
1725 #endif
1726 #ifndef MACHINE_STATE_RESTORE
1727 #define MACHINE_STATE_RESTORE(ID)
1728 #endif
1729
1730 /* Number of buckets in hashtable of basic block addresses.  */
1731
1732 #define BB_BUCKETS 311
1733
1734 /* Maximum length of string in file bb.in.  */
1735
1736 #define BBINBUFSIZE 500
1737
1738 /* BBINBUFSIZE-1 with double quotes. We could use #BBINBUFSIZE or
1739    "BBINBUFSIZE" but want to avoid trouble with preprocessors.  */
1740
1741 #define BBINBUFSIZESTR "499"
1742
1743 struct bb_edge
1744 {
1745   struct bb_edge *next;
1746   unsigned long src_addr;
1747   unsigned long dst_addr;
1748   unsigned long count;
1749 };
1750
1751 enum bb_func_mode
1752 {
1753   TRACE_KEEP = 0, TRACE_ON = 1, TRACE_OFF = 2
1754 };
1755
1756 struct bb_func
1757 {
1758   struct bb_func *next;
1759   char *funcname;
1760   char *filename;
1761   enum bb_func_mode mode;
1762 };
1763
1764 /* This is the connection to the outside world.
1765    The BLOCK_PROFILER macro must set __bb.blocks
1766    and __bb.blockno.  */
1767
1768 struct {
1769   unsigned long blockno;
1770   struct bb *blocks;
1771 } __bb;
1772
1773 /* Vars to store addrs of source and destination basic blocks
1774    of a jump.  */
1775
1776 static unsigned long bb_src = 0;
1777 static unsigned long bb_dst = 0;
1778
1779 static FILE *bb_tracefile = (FILE *) 0;
1780 static struct bb_edge **bb_hashbuckets = (struct bb_edge **) 0;
1781 static struct bb_func *bb_func_head = (struct bb_func *) 0;
1782 static unsigned long bb_callcount = 0;
1783 static int bb_mode = 0;
1784
1785 static unsigned long *bb_stack = (unsigned long *) 0;
1786 static size_t bb_stacksize = 0;
1787
1788 static int reported = 0;
1789
1790 /* Trace modes:
1791 Always             :   Print execution frequencies of basic blocks
1792                        to file bb.out.
1793 bb_mode & 1 != 0   :   Dump trace of basic blocks to file bbtrace[.gz]
1794 bb_mode & 2 != 0   :   Print jump frequencies to file bb.out.
1795 bb_mode & 4 != 0   :   Cut call instructions from basic block flow.
1796 bb_mode & 8 != 0   :   Insert return instructions in basic block flow.
1797 */
1798
1799 #ifdef HAVE_POPEN
1800
1801 /*#include <sys/types.h>*/
1802 #include <sys/stat.h>
1803 /*#include <malloc.h>*/
1804
1805 /* Commands executed by gopen.  */
1806
1807 #define GOPENDECOMPRESS "gzip -cd "
1808 #define GOPENCOMPRESS "gzip -c >"
1809
1810 /* Like fopen but pipes through gzip.  mode may only be "r" or "w".
1811    If it does not compile, simply replace gopen by fopen and delete
1812    '.gz' from any first parameter to gopen.  */
1813
1814 static FILE *
1815 gopen (char *fn, char *mode)
1816 {
1817   int use_gzip;
1818   char *p;
1819
1820   if (mode[1])
1821     return (FILE *) 0;
1822
1823   if (mode[0] != 'r' && mode[0] != 'w')
1824     return (FILE *) 0;
1825
1826   p = fn + strlen (fn)-1;
1827   use_gzip = ((p[-1] == '.' && (p[0] == 'Z' || p[0] == 'z'))
1828               || (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));
1829
1830   if (use_gzip)
1831     {
1832       if (mode[0]=='r')
1833         {
1834           FILE *f;
1835           char *s = (char *) malloc (sizeof (char) * strlen (fn)
1836                                      + sizeof (GOPENDECOMPRESS));
1837           strcpy (s, GOPENDECOMPRESS);
1838           strcpy (s + (sizeof (GOPENDECOMPRESS)-1), fn);
1839           f = popen (s, mode);
1840           free (s);
1841           return f;
1842         }
1843
1844       else
1845         {
1846           FILE *f;
1847           char *s = (char *) malloc (sizeof (char) * strlen (fn)
1848                                      + sizeof (GOPENCOMPRESS));
1849           strcpy (s, GOPENCOMPRESS);
1850           strcpy (s + (sizeof (GOPENCOMPRESS)-1), fn);
1851           if (!(f = popen (s, mode)))
1852             f = fopen (s, mode);
1853           free (s);
1854           return f;
1855         }
1856     }
1857
1858   else
1859     return fopen (fn, mode);
1860 }
1861
1862 static int
1863 gclose (FILE *f)
1864 {
1865   struct stat buf;
1866
1867   if (f != 0)
1868     {
1869       if (!fstat (fileno (f), &buf) && S_ISFIFO (buf.st_mode))
1870         return pclose (f);
1871
1872       return fclose (f);
1873     }
1874   return 0;
1875 }
1876
1877 #endif /* HAVE_POPEN */
1878
1879 /* Called once per program.  */
1880
1881 static void
1882 __bb_exit_trace_func ()
1883 {
1884   FILE *file = fopen ("bb.out", "a");
1885   struct bb_func *f;
1886   struct bb_edge *e;
1887   struct bb *b;
1888
1889   if (!file)
1890     perror ("bb.out");
1891
1892   if (bb_mode & 1)
1893     {
1894       if (!bb_tracefile)
1895         perror ("bbtrace");
1896       else
1897 #ifdef HAVE_POPEN
1898         gclose (bb_tracefile);
1899 #else
1900         fclose (bb_tracefile);
1901 #endif /* HAVE_POPEN */
1902     }
1903
1904   /* Check functions in `bb.in'.  */
1905
1906   if (file)
1907     {
1908       long time_value;
1909       const struct bb_func *p;
1910       int printed_something = 0;
1911       struct bb *ptr;
1912       long blk;
1913
1914       /* This is somewhat type incorrect.  */
1915       time ((void *) &time_value);
1916
1917       for (p = bb_func_head; p != (struct bb_func *) 0; p = p->next)
1918         {
1919           for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1920             {
1921               if (!ptr->filename || p->filename != (char *) 0 && strcmp (p->filename, ptr->filename))
1922                 continue;
1923               for (blk = 0; blk < ptr->ncounts; blk++)
1924                 {
1925                   if (!strcmp (p->funcname, ptr->functions[blk]))
1926                     goto found;
1927                 }
1928             }
1929
1930           if (!printed_something)
1931             {
1932               fprintf (file, "Functions in `bb.in' not executed during basic block profiling on %s\n", ctime ((void *) &time_value));
1933               printed_something = 1;
1934             }
1935
1936           fprintf (file, "\tFunction %s", p->funcname);
1937           if (p->filename)
1938               fprintf (file, " of file %s", p->filename);
1939           fprintf (file, "\n" );
1940
1941 found:        ;
1942         }
1943
1944       if (printed_something)
1945        fprintf (file, "\n");
1946
1947     }
1948
1949   if (bb_mode & 2)
1950     {
1951       if (!bb_hashbuckets)
1952         {
1953           if (!reported)
1954             {
1955               fprintf (stderr, "Profiler: out of memory\n");
1956               reported = 1;
1957             }
1958           return;
1959         }
1960
1961       else if (file)
1962         {
1963           long time_value;
1964           int i;
1965           unsigned long addr_max = 0;
1966           unsigned long cnt_max  = 0;
1967           int cnt_len;
1968           int addr_len;
1969
1970           /* This is somewhat type incorrect, but it avoids worrying about
1971              exactly where time.h is included from.  It should be ok unless
1972              a void * differs from other pointer formats, or if sizeof (long)
1973              is < sizeof (time_t).  It would be nice if we could assume the
1974              use of rationale standards here.  */
1975
1976           time ((void *) &time_value);
1977           fprintf (file, "Basic block jump tracing");
1978
1979           switch (bb_mode & 12)
1980             {
1981               case 0:
1982                 fprintf (file, " (with call)");
1983               break;
1984
1985               case 4:
1986                 /* Print nothing.  */
1987               break;
1988
1989               case 8:
1990                 fprintf (file, " (with call & ret)");
1991               break;
1992
1993               case 12:
1994                 fprintf (file, " (with ret)");
1995               break;
1996             }
1997
1998           fprintf (file, " finished on %s\n", ctime ((void *) &time_value));
1999
2000           for (i = 0; i < BB_BUCKETS; i++)
2001             {
2002                struct bb_edge *bucket = bb_hashbuckets[i];
2003                for ( ; bucket; bucket = bucket->next )
2004                  {
2005                    if (addr_max < bucket->src_addr)
2006                      addr_max = bucket->src_addr;
2007                    if (addr_max < bucket->dst_addr)
2008                      addr_max = bucket->dst_addr;
2009                    if (cnt_max < bucket->count)
2010                      cnt_max = bucket->count;
2011                  }
2012             }
2013           addr_len = num_digits (addr_max, 16);
2014           cnt_len  = num_digits (cnt_max, 10);
2015
2016           for ( i = 0; i < BB_BUCKETS; i++)
2017             {
2018                struct bb_edge *bucket = bb_hashbuckets[i];
2019                for ( ; bucket; bucket = bucket->next )
2020                  {
2021                    fprintf (file, "Jump from block 0x%.*lx to "
2022                                   "block 0x%.*lx executed %*d time(s)\n",
2023                             addr_len, bucket->src_addr,
2024                             addr_len, bucket->dst_addr,
2025                             cnt_len, bucket->count);
2026                  }
2027             }
2028
2029           fprintf (file, "\n");
2030
2031         }
2032     }
2033
2034    if (file)
2035      fclose (file);
2036
2037    /* Free allocated memory.  */
2038
2039    f = bb_func_head;
2040    while (f)
2041      {
2042        struct bb_func *old = f;
2043
2044        f = f->next;
2045        if (old->funcname) free (old->funcname);
2046        if (old->filename) free (old->filename);
2047        free (old);
2048      }
2049
2050    if (bb_stack)
2051      free (bb_stack);
2052
2053    if (bb_hashbuckets)
2054      {
2055        int i;
2056
2057        for (i = 0; i < BB_BUCKETS; i++)
2058          {
2059            struct bb_edge *old, *bucket = bb_hashbuckets[i];
2060
2061            while (bucket)
2062              {
2063                old = bucket;
2064                bucket = bucket->next;
2065                free (old);
2066              }
2067          }
2068        free (bb_hashbuckets);
2069      }
2070
2071    for (b = bb_head; b; b = b->next)
2072      if (b->flags) free (b->flags);
2073 }
2074
2075 /* Called once per program.  */
2076
2077 static void
2078 __bb_init_prg ()
2079 {
2080
2081   FILE *file;
2082   char buf[BBINBUFSIZE];
2083   const char *p;
2084   const char *pos;
2085   enum bb_func_mode m;
2086
2087 #ifdef ON_EXIT
2088   /* Initialize destructor.  */
2089   ON_EXIT (__bb_exit_func, 0);
2090 #endif
2091
2092   if (!(file = fopen ("bb.in", "r")))
2093     return;
2094
2095   while(fscanf (file, " %" BBINBUFSIZESTR "s ", buf) != EOF)
2096     {
2097       p = buf;
2098       if (*p == '-')
2099         {
2100           m = TRACE_OFF;
2101           p++;
2102         }
2103       else
2104         {
2105           m = TRACE_ON;
2106         }
2107       if (!strcmp (p, "__bb_trace__"))
2108         bb_mode |= 1;
2109       else if (!strcmp (p, "__bb_jumps__"))
2110         bb_mode |= 2;
2111       else if (!strcmp (p, "__bb_hidecall__"))
2112         bb_mode |= 4;
2113       else if (!strcmp (p, "__bb_showret__"))
2114         bb_mode |= 8;
2115       else
2116         {
2117           struct bb_func *f = (struct bb_func *) malloc (sizeof (struct bb_func));
2118           if (f)
2119             {
2120               unsigned long l;
2121               f->next = bb_func_head;
2122               if (pos = strchr (p, ':'))
2123                 {
2124                   if (!(f->funcname = (char *) malloc (strlen (pos+1)+1)))
2125                     continue;
2126                   strcpy (f->funcname, pos+1);
2127                   l = pos-p;
2128                   if ((f->filename = (char *) malloc (l+1)))
2129                     {
2130                       strncpy (f->filename, p, l);
2131                       f->filename[l] = '\0';
2132                     }
2133                   else
2134                     f->filename = (char *) 0;
2135                 }
2136               else
2137                 {
2138                   if (!(f->funcname = (char *) malloc (strlen (p)+1)))
2139                     continue;
2140                   strcpy (f->funcname, p);
2141                   f->filename = (char *) 0;
2142                 }
2143               f->mode = m;
2144               bb_func_head = f;
2145             }
2146          }
2147     }
2148   fclose (file);
2149
2150 #ifdef HAVE_POPEN
2151
2152   if (bb_mode & 1)
2153       bb_tracefile = gopen ("bbtrace.gz", "w");
2154
2155 #else
2156
2157   if (bb_mode & 1)
2158       bb_tracefile = fopen ("bbtrace", "w");
2159
2160 #endif /* HAVE_POPEN */
2161
2162   if (bb_mode & 2)
2163     {
2164       bb_hashbuckets = (struct bb_edge **)
2165                    malloc (BB_BUCKETS * sizeof (struct bb_edge *));
2166       if (bb_hashbuckets)
2167         bzero ((char *) bb_hashbuckets, BB_BUCKETS);
2168     }
2169
2170   if (bb_mode & 12)
2171     {
2172       bb_stacksize = 10;
2173       bb_stack = (unsigned long *) malloc (bb_stacksize * sizeof (*bb_stack));
2174     }
2175
2176 #ifdef ON_EXIT
2177       /* Initialize destructor.  */
2178       ON_EXIT (__bb_exit_trace_func, 0);
2179 #endif
2180
2181 }
2182
2183 /* Called upon entering a basic block.  */
2184
2185 void
2186 __bb_trace_func ()
2187 {
2188   struct bb_edge *bucket;
2189
2190   MACHINE_STATE_SAVE("1")
2191
2192   if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
2193     goto skip;
2194
2195   bb_dst = __bb.blocks->addresses[__bb.blockno];
2196   __bb.blocks->counts[__bb.blockno]++;
2197
2198   if (bb_tracefile)
2199     {
2200       fwrite (&bb_dst, sizeof (unsigned long), 1, bb_tracefile);
2201     }
2202
2203   if (bb_hashbuckets)
2204     {
2205       struct bb_edge **startbucket, **oldnext;
2206
2207       oldnext = startbucket
2208         = & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
2209       bucket = *startbucket;
2210
2211       for (bucket = *startbucket; bucket;
2212            oldnext = &(bucket->next), bucket = *oldnext)
2213         {
2214           if (bucket->src_addr == bb_src
2215               && bucket->dst_addr == bb_dst)
2216             {
2217               bucket->count++;
2218               *oldnext = bucket->next;
2219               bucket->next = *startbucket;
2220               *startbucket = bucket;
2221               goto ret;
2222             }
2223         }
2224
2225       bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));
2226
2227       if (!bucket)
2228         {
2229           if (!reported)
2230             {
2231               fprintf (stderr, "Profiler: out of memory\n");
2232               reported = 1;
2233             }
2234         }
2235
2236       else
2237         {
2238           bucket->src_addr = bb_src;
2239           bucket->dst_addr = bb_dst;
2240           bucket->next = *startbucket;
2241           *startbucket = bucket;
2242           bucket->count = 1;
2243         }
2244     }
2245
2246 ret:
2247   bb_src = bb_dst;
2248
2249 skip:
2250   ;
2251
2252   MACHINE_STATE_RESTORE("1")
2253
2254 }
2255
2256 /* Called when returning from a function and `__bb_showret__' is set.  */
2257
2258 static void
2259 __bb_trace_func_ret ()
2260 {
2261   struct bb_edge *bucket;
2262
2263   if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
2264     goto skip;
2265
2266   if (bb_hashbuckets)
2267     {
2268       struct bb_edge **startbucket, **oldnext;
2269
2270       oldnext = startbucket
2271         = & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
2272       bucket = *startbucket;
2273
2274       for (bucket = *startbucket; bucket;
2275            oldnext = &(bucket->next), bucket = *oldnext)
2276         {
2277           if (bucket->src_addr == bb_dst
2278                && bucket->dst_addr == bb_src)
2279             {
2280               bucket->count++;
2281               *oldnext = bucket->next;
2282               bucket->next = *startbucket;
2283               *startbucket = bucket;
2284               goto ret;
2285             }
2286         }
2287
2288       bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));
2289
2290       if (!bucket)
2291         {
2292           if (!reported)
2293             {
2294               fprintf (stderr, "Profiler: out of memory\n");
2295               reported = 1;
2296             }
2297         }
2298
2299       else
2300         {
2301           bucket->src_addr = bb_dst;
2302           bucket->dst_addr = bb_src;
2303           bucket->next = *startbucket;
2304           *startbucket = bucket;
2305           bucket->count = 1;
2306         }
2307     }
2308
2309 ret:
2310   bb_dst = bb_src;
2311
2312 skip:
2313   ;
2314
2315 }
2316
2317 /* Called upon entering the first function of a file.  */
2318
2319 static void
2320 __bb_init_file (struct bb *blocks)
2321 {
2322
2323   const struct bb_func *p;
2324   long blk, ncounts = blocks->ncounts;
2325   const char **functions = blocks->functions;
2326
2327   /* Set up linked list.  */
2328   blocks->zero_word = 1;
2329   blocks->next = bb_head;
2330   bb_head = blocks;
2331
2332   blocks->flags = 0;
2333   if (!bb_func_head
2334       || !(blocks->flags = (char *) malloc (sizeof (char) * blocks->ncounts)))
2335     return;
2336
2337   for (blk = 0; blk < ncounts; blk++)
2338     blocks->flags[blk] = 0;
2339
2340   for (blk = 0; blk < ncounts; blk++)
2341     {
2342       for (p = bb_func_head; p; p = p->next)
2343         {
2344           if (!strcmp (p->funcname, functions[blk])
2345               && (!p->filename || !strcmp (p->filename, blocks->filename)))
2346             {
2347               blocks->flags[blk] |= p->mode;
2348             }
2349         }
2350     }
2351
2352 }
2353
2354 /* Called when exiting from a function.  */
2355
2356 void
2357 __bb_trace_ret ()
2358 {
2359
2360   MACHINE_STATE_SAVE("2")
2361
2362   if (bb_callcount)
2363     {
2364       if ((bb_mode & 12) && bb_stacksize > bb_callcount)
2365         {
2366           bb_src = bb_stack[bb_callcount];
2367           if (bb_mode & 8)
2368             __bb_trace_func_ret ();
2369         }
2370
2371       bb_callcount -= 1;
2372     }
2373
2374   MACHINE_STATE_RESTORE("2")
2375
2376 }
2377
2378 /* Called when entering a function.  */
2379
2380 void
2381 __bb_init_trace_func (struct bb *blocks, unsigned long blockno)
2382 {
2383   static int trace_init = 0;
2384
2385   MACHINE_STATE_SAVE("3")
2386
2387   if (!blocks->zero_word)
2388     {
2389       if (!trace_init)
2390         {
2391           trace_init = 1;
2392           __bb_init_prg ();
2393         }
2394       __bb_init_file (blocks);
2395     }
2396
2397   if (bb_callcount)
2398     {
2399
2400       bb_callcount += 1;
2401
2402       if (bb_mode & 12)
2403         {
2404           if (bb_callcount >= bb_stacksize)
2405             {
2406               size_t newsize = bb_callcount + 100;
2407
2408               bb_stack = (unsigned long *) realloc (bb_stack, newsize);
2409               if (! bb_stack)
2410                 {
2411                   if (!reported)
2412                     {
2413                       fprintf (stderr, "Profiler: out of memory\n");
2414                       reported = 1;
2415                     }
2416                   bb_stacksize = 0;
2417                   goto stack_overflow;
2418                 }
2419               bb_stacksize = newsize;
2420             }
2421           bb_stack[bb_callcount] = bb_src;
2422
2423           if (bb_mode & 4)
2424             bb_src = 0;
2425
2426         }
2427
2428 stack_overflow:;
2429
2430     }
2431
2432   else if (blocks->flags && (blocks->flags[blockno] & TRACE_ON))
2433     {
2434       bb_callcount = 1;
2435       bb_src = 0;
2436
2437       if (bb_stack)
2438           bb_stack[bb_callcount] = bb_src;
2439     }
2440
2441   MACHINE_STATE_RESTORE("3")
2442 }
2443
2444 #endif /* not inhibit_libc */
2445 #endif /* not BLOCK_PROFILER_CODE */
2446 #endif /* L_bb */
2447 \f
2448 #ifdef L_shtab
2449 unsigned int __shtab[] = {
2450     0x00000001, 0x00000002, 0x00000004, 0x00000008,
2451     0x00000010, 0x00000020, 0x00000040, 0x00000080,
2452     0x00000100, 0x00000200, 0x00000400, 0x00000800,
2453     0x00001000, 0x00002000, 0x00004000, 0x00008000,
2454     0x00010000, 0x00020000, 0x00040000, 0x00080000,
2455     0x00100000, 0x00200000, 0x00400000, 0x00800000,
2456     0x01000000, 0x02000000, 0x04000000, 0x08000000,
2457     0x10000000, 0x20000000, 0x40000000, 0x80000000
2458   };
2459 #endif
2460 \f
2461 #ifdef L_clear_cache
2462 /* Clear part of an instruction cache.  */
2463
2464 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
2465
2466 void
2467 __clear_cache (char *beg, char *end)
2468 {
2469 #ifdef CLEAR_INSN_CACHE
2470   CLEAR_INSN_CACHE (beg, end);
2471 #else
2472 #ifdef INSN_CACHE_SIZE
2473   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
2474   static int initialized;
2475   int offset;
2476   void *start_addr
2477   void *end_addr;
2478   typedef (*function_ptr) ();
2479
2480 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
2481   /* It's cheaper to clear the whole cache.
2482      Put in a series of jump instructions so that calling the beginning
2483      of the cache will clear the whole thing.  */
2484
2485   if (! initialized)
2486     {
2487       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2488                  & -INSN_CACHE_LINE_WIDTH);
2489       int end_ptr = ptr + INSN_CACHE_SIZE;
2490
2491       while (ptr < end_ptr)
2492         {
2493           *(INSTRUCTION_TYPE *)ptr
2494             = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
2495           ptr += INSN_CACHE_LINE_WIDTH;
2496         }
2497       *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
2498
2499       initialized = 1;
2500     }
2501
2502   /* Call the beginning of the sequence.  */
2503   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2504                     & -INSN_CACHE_LINE_WIDTH))
2505    ());
2506
2507 #else /* Cache is large.  */
2508
2509   if (! initialized)
2510     {
2511       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2512                  & -INSN_CACHE_LINE_WIDTH);
2513
2514       while (ptr < (int) array + sizeof array)
2515         {
2516           *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
2517           ptr += INSN_CACHE_LINE_WIDTH;
2518         }
2519
2520       initialized = 1;
2521     }
2522
2523   /* Find the location in array that occupies the same cache line as BEG.  */
2524
2525   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
2526   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
2527                  & -INSN_CACHE_PLANE_SIZE)
2528                 + offset);
2529
2530   /* Compute the cache alignment of the place to stop clearing.  */
2531 #if 0  /* This is not needed for gcc's purposes.  */
2532   /* If the block to clear is bigger than a cache plane,
2533      we clear the entire cache, and OFFSET is already correct.  */
2534   if (end < beg + INSN_CACHE_PLANE_SIZE)
2535 #endif
2536     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
2537                & -INSN_CACHE_LINE_WIDTH)
2538               & (INSN_CACHE_PLANE_SIZE - 1));
2539
2540 #if INSN_CACHE_DEPTH > 1
2541   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
2542   if (end_addr <= start_addr)
2543     end_addr += INSN_CACHE_PLANE_SIZE;
2544
2545   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
2546     {
2547       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
2548       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
2549
2550       while (addr != stop)
2551         {
2552           /* Call the return instruction at ADDR.  */
2553           ((function_ptr) addr) ();
2554
2555           addr += INSN_CACHE_LINE_WIDTH;
2556         }
2557     }
2558 #else /* just one plane */
2559   do
2560     {
2561       /* Call the return instruction at START_ADDR.  */
2562       ((function_ptr) start_addr) ();
2563
2564       start_addr += INSN_CACHE_LINE_WIDTH;
2565     }
2566   while ((start_addr % INSN_CACHE_SIZE) != offset);
2567 #endif /* just one plane */
2568 #endif /* Cache is large */
2569 #endif /* Cache exists */
2570 #endif /* CLEAR_INSN_CACHE */
2571 }
2572
2573 #endif /* L_clear_cache */
2574 \f
2575 #ifdef L_trampoline
2576
2577 /* Jump to a trampoline, loading the static chain address.  */
2578
2579 #if defined(WINNT) && ! defined(__CYGWIN32__)
2580
2581 long getpagesize()
2582 {
2583 #ifdef _ALPHA_
2584   return 8192;
2585 #else
2586   return 4096;
2587 #endif
2588 }
2589
2590 #ifdef i386
2591 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
2592 #endif
2593
2594 int
2595 mprotect (char *addr, int len, int prot)
2596 {
2597   int np, op;
2598
2599   if (prot == 7)
2600     np = 0x40;
2601   else if (prot == 5)
2602     np = 0x20;
2603   else if (prot == 4)
2604     np = 0x10;
2605   else if (prot == 3)
2606     np = 0x04;
2607   else if (prot == 1)
2608     np = 0x02;
2609   else if (prot == 0)
2610     np = 0x01;
2611
2612   if (VirtualProtect (addr, len, np, &op))
2613     return 0;
2614   else
2615     return -1;
2616 }
2617
2618 #endif
2619
2620 #ifdef TRANSFER_FROM_TRAMPOLINE
2621 TRANSFER_FROM_TRAMPOLINE
2622 #endif
2623
2624 #if defined (NeXT) && defined (__MACH__)
2625
2626 /* Make stack executable so we can call trampolines on stack.
2627    This is called from INITIALIZE_TRAMPOLINE in next.h.  */
2628 #ifdef NeXTStep21
2629  #include <mach.h>
2630 #else
2631  #include <mach/mach.h>
2632 #endif
2633
2634 void
2635 __enable_execute_stack (char *addr)
2636 {
2637   kern_return_t r;
2638   char *eaddr = addr + TRAMPOLINE_SIZE;
2639   vm_address_t a = (vm_address_t) addr;
2640
2641   /* turn on execute access on stack */
2642   r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
2643   if (r != KERN_SUCCESS)
2644     {
2645       mach_error("vm_protect VM_PROT_ALL", r);
2646       exit(1);
2647     }
2648
2649   /* We inline the i-cache invalidation for speed */
2650
2651 #ifdef CLEAR_INSN_CACHE
2652   CLEAR_INSN_CACHE (addr, eaddr);
2653 #else
2654   __clear_cache ((int) addr, (int) eaddr);
2655 #endif
2656 }
2657
2658 #endif /* defined (NeXT) && defined (__MACH__) */
2659
2660 #ifdef __convex__
2661
2662 /* Make stack executable so we can call trampolines on stack.
2663    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
2664
2665 #include <sys/mman.h>
2666 #include <sys/vmparam.h>
2667 #include <machine/machparam.h>
2668
2669 void
2670 __enable_execute_stack ()
2671 {
2672   int fp;
2673   static unsigned lowest = USRSTACK;
2674   unsigned current = (unsigned) &fp & -NBPG;
2675
2676   if (lowest > current)
2677     {
2678       unsigned len = lowest - current;
2679       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
2680       lowest = current;
2681     }
2682
2683   /* Clear instruction cache in case an old trampoline is in it.  */
2684   asm ("pich");
2685 }
2686 #endif /* __convex__ */
2687
2688 #ifdef __sysV88__
2689
2690 /* Modified from the convex -code above.  */
2691
2692 #include <sys/param.h>
2693 #include <errno.h>
2694 #include <sys/m88kbcs.h>
2695
2696 void
2697 __enable_execute_stack ()
2698 {
2699   int save_errno;
2700   static unsigned long lowest = USRSTACK;
2701   unsigned long current = (unsigned long) &save_errno & -NBPC;
2702
2703   /* Ignore errno being set. memctl sets errno to EINVAL whenever the
2704      address is seen as 'negative'. That is the case with the stack.   */
2705
2706   save_errno=errno;
2707   if (lowest > current)
2708     {
2709       unsigned len=lowest-current;
2710       memctl(current,len,MCT_TEXT);
2711       lowest = current;
2712     }
2713   else
2714     memctl(current,NBPC,MCT_TEXT);
2715   errno=save_errno;
2716 }
2717
2718 #endif /* __sysV88__ */
2719
2720 #ifdef __pyr__
2721
2722 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
2723 #include <stdio.h>
2724 #include <sys/mman.h>
2725 #include <sys/types.h>
2726 #include <sys/param.h>
2727 #include <sys/vmmac.h>
2728
2729 /* Modified from the convex -code above.
2730    mremap promises to clear the i-cache.  */
2731
2732 void
2733 __enable_execute_stack ()
2734 {
2735   int fp;
2736   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
2737                 PROT_READ|PROT_WRITE|PROT_EXEC))
2738     {
2739       perror ("mprotect in __enable_execute_stack");
2740       fflush (stderr);
2741       abort ();
2742     }
2743 }
2744 #endif /* __pyr__ */
2745
2746 #if defined (sony_news) && defined (SYSTYPE_BSD)
2747
2748 #include <stdio.h>
2749 #include <sys/types.h>
2750 #include <sys/param.h>
2751 #include <syscall.h>
2752 #include <machine/sysnews.h>
2753
2754 /* cacheflush function for NEWS-OS 4.2.
2755    This function is called from trampoline-initialize code
2756    defined in config/mips/mips.h.  */
2757
2758 void
2759 cacheflush (char *beg, int size, int flag)
2760 {
2761   if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
2762     {
2763       perror ("cache_flush");
2764       fflush (stderr);
2765       abort ();
2766     }
2767 }
2768
2769 #endif /* sony_news */
2770 #endif /* L_trampoline */
2771 \f
2772 #ifdef L__main
2773
2774 #include "gbl-ctors.h"
2775 /* Some systems use __main in a way incompatible with its use in gcc, in these
2776    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2777    give the same symbol without quotes for an alternative entry point.  You
2778    must define both, or neither.  */
2779 #ifndef NAME__MAIN
2780 #define NAME__MAIN "__main"
2781 #define SYMBOL__MAIN __main
2782 #endif
2783
2784 #ifdef INIT_SECTION_ASM_OP
2785 #undef HAS_INIT_SECTION
2786 #define HAS_INIT_SECTION
2787 #endif
2788
2789 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2790 /* Run all the global destructors on exit from the program.  */
2791
2792 void
2793 __do_global_dtors ()
2794 {
2795 #ifdef DO_GLOBAL_DTORS_BODY
2796   DO_GLOBAL_DTORS_BODY;
2797 #else
2798   static func_ptr *p = __DTOR_LIST__ + 1;
2799   while (*p)
2800     {
2801       p++;
2802       (*(p-1)) ();
2803     }
2804 #endif
2805 }
2806 #endif
2807
2808 #ifndef HAS_INIT_SECTION
2809 /* Run all the global constructors on entry to the program.  */
2810
2811 #ifndef ON_EXIT
2812 #define ON_EXIT(a, b)
2813 #else
2814 /* Make sure the exit routine is pulled in to define the globals as
2815    bss symbols, just in case the linker does not automatically pull
2816    bss definitions from the library.  */
2817
2818 extern int _exit_dummy_decl;
2819 int *_exit_dummy_ref = &_exit_dummy_decl;
2820 #endif /* ON_EXIT */
2821
2822 void
2823 __do_global_ctors ()
2824 {
2825   DO_GLOBAL_CTORS_BODY;
2826   ON_EXIT (__do_global_dtors, 0);
2827 }
2828 #endif /* no HAS_INIT_SECTION */
2829
2830 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2831 /* Subroutine called automatically by `main'.
2832    Compiling a global function named `main'
2833    produces an automatic call to this function at the beginning.
2834
2835    For many systems, this routine calls __do_global_ctors.
2836    For systems which support a .init section we use the .init section
2837    to run __do_global_ctors, so we need not do anything here.  */
2838
2839 void
2840 SYMBOL__MAIN ()
2841 {
2842   /* Support recursive calls to `main': run initializers just once.  */
2843   static int initialized;
2844   if (! initialized)
2845     {
2846       initialized = 1;
2847       __do_global_ctors ();
2848     }
2849 }
2850 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2851
2852 #endif /* L__main */
2853 \f
2854 #ifdef L_ctors
2855
2856 #include "gbl-ctors.h"
2857
2858 /* Provide default definitions for the lists of constructors and
2859    destructors, so that we don't get linker errors.  These symbols are
2860    intentionally bss symbols, so that gld and/or collect will provide
2861    the right values.  */
2862
2863 /* We declare the lists here with two elements each,
2864    so that they are valid empty lists if no other definition is loaded.  */
2865 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2866 #if defined(__NeXT__) || defined(_AIX)
2867 /* After 2.3, try this definition on all systems.  */
2868 func_ptr __CTOR_LIST__[2] = {0, 0};
2869 func_ptr __DTOR_LIST__[2] = {0, 0};
2870 #else
2871 func_ptr __CTOR_LIST__[2];
2872 func_ptr __DTOR_LIST__[2];
2873 #endif
2874 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2875 #endif /* L_ctors */
2876 \f
2877 #ifdef L_exit
2878
2879 #include "gbl-ctors.h"
2880
2881 #ifdef NEED_ATEXIT
2882 # ifdef ON_EXIT
2883 #  undef ON_EXIT
2884 # endif
2885 int _exit_dummy_decl = 0;       /* prevent compiler & linker warnings */
2886 #endif
2887
2888 #ifndef ON_EXIT
2889
2890 #ifdef NEED_ATEXIT
2891 # include <errno.h>
2892
2893 static func_ptr *atexit_chain = 0;
2894 static long atexit_chain_length = 0;
2895 static volatile long last_atexit_chain_slot = -1;
2896
2897 int atexit (func_ptr func)
2898 {
2899   if (++last_atexit_chain_slot == atexit_chain_length)
2900     {
2901       atexit_chain_length += 32;
2902       if (atexit_chain)
2903         atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
2904                                              * sizeof (func_ptr));
2905       else
2906         atexit_chain = (func_ptr *) malloc (atexit_chain_length
2907                                             * sizeof (func_ptr));
2908       if (! atexit_chain)
2909         {
2910           atexit_chain_length = 0;
2911           last_atexit_chain_slot = -1;
2912           errno = ENOMEM;
2913           return (-1);
2914         }
2915     }
2916   atexit_chain[last_atexit_chain_slot] = func;
2917   return (0);
2918 }
2919 #endif /* NEED_ATEXIT */
2920
2921 /* If we have no known way of registering our own __do_global_dtors
2922    routine so that it will be invoked at program exit time, then we
2923    have to define our own exit routine which will get this to happen.  */
2924
2925 extern void __do_global_dtors ();
2926 extern void __bb_exit_func ();
2927 extern void _cleanup ();
2928 extern void _exit () __attribute__ ((noreturn));
2929
2930 void
2931 exit (int status)
2932 {
2933 #if !defined (INIT_SECTION_ASM_OP) || !defined (OBJECT_FORMAT_ELF)
2934 #ifdef NEED_ATEXIT
2935   if (atexit_chain)
2936     {
2937       for ( ; last_atexit_chain_slot-- >= 0; )
2938         {
2939           (*atexit_chain[last_atexit_chain_slot + 1]) ();
2940           atexit_chain[last_atexit_chain_slot + 1] = 0;
2941         }
2942       free (atexit_chain);
2943       atexit_chain = 0;
2944     }
2945 #else /* No NEED_ATEXIT */
2946   __do_global_dtors ();
2947 #endif /* No NEED_ATEXIT */
2948 #endif
2949 #ifndef inhibit_libc
2950   __bb_exit_func ();
2951 #endif
2952 #ifdef EXIT_BODY
2953   EXIT_BODY;
2954 #else
2955   _cleanup ();
2956 #endif
2957   _exit (status);
2958 }
2959
2960 #else
2961 int _exit_dummy_decl = 0;       /* prevent compiler & linker warnings */
2962 #endif
2963
2964 #endif /* L_exit */
2965 \f
2966 #ifdef L_eh
2967
2968 #include "gthr.h"
2969
2970 /* Shared exception handling support routines.  */
2971
2972 void
2973 __default_terminate ()
2974 {
2975   abort ();
2976 }
2977
2978 void (*__terminate_func)() = __default_terminate;
2979
2980 void
2981 __terminate ()
2982 {
2983   (*__terminate_func)();
2984 }
2985
2986 void *
2987 __throw_type_match (void *catch_type, void *throw_type, void *obj)
2988 {
2989 #if 0
2990  printf ("__throw_type_match (): catch_type = %s, throw_type = %s\n",
2991          catch_type, throw_type);
2992 #endif
2993  if (strcmp ((const char *)catch_type, (const char *)throw_type) == 0)
2994    return obj;
2995  return 0;
2996 }
2997
2998 void
2999 __empty ()
3000 {
3001 }
3002 \f
3003 /* EH context structure. */
3004
3005 struct eh_context
3006 {
3007   void **dynamic_handler_chain;
3008   /* This is language dependent part of the eh context. */
3009   void *info;
3010 };
3011
3012 /* This is a safeguard for dynamic handler chain. */
3013
3014 static void *top_elt[2];
3015
3016 /* Allocate and return a new EH context structure. */
3017
3018 extern void __throw ();
3019
3020 static void *
3021 new_eh_context ()
3022 {
3023   struct eh_context *eh = (struct eh_context *) malloc (sizeof *eh);
3024   if (! eh)
3025     __terminate ();
3026
3027   memset (eh, 0, sizeof *eh);
3028
3029   eh->dynamic_handler_chain = top_elt;
3030
3031   return eh;
3032 }
3033
3034 #if __GTHREADS
3035 static __gthread_key_t eh_context_key;
3036
3037 /* Destructor for struct eh_context. */
3038 static void
3039 eh_context_free (void *ptr)
3040 {
3041   __gthread_key_dtor (eh_context_key, ptr);
3042   if (ptr)
3043     free (ptr);
3044 }
3045 #endif
3046
3047 /* Pointer to function to return EH context. */
3048
3049 static struct eh_context *eh_context_initialize ();
3050 static struct eh_context *eh_context_static ();
3051 #if __GTHREADS
3052 static struct eh_context *eh_context_specific ();
3053 #endif
3054
3055 static struct eh_context *(*get_eh_context) () = &eh_context_initialize;
3056
3057 /* Routine to get EH context.
3058    This one will simply call the function pointer. */
3059
3060 void *
3061 __get_eh_context ()
3062 {
3063   return (void *) (*get_eh_context) ();
3064 }
3065
3066 /* Get and set the language specific info pointer. */
3067
3068 void **
3069 __get_eh_info ()
3070 {
3071   struct eh_context *eh = (*get_eh_context) ();
3072   return &eh->info;
3073 }
3074 \f
3075 #if __GTHREADS
3076 static void
3077 eh_threads_initialize ()
3078 {
3079   /* Try to create the key.  If it fails, revert to static method,
3080      otherwise start using thread specific EH contexts. */
3081   if (__gthread_key_create (&eh_context_key, &eh_context_free) == 0)
3082     get_eh_context = &eh_context_specific;
3083   else
3084     get_eh_context = &eh_context_static;
3085 }
3086 #endif /* no __GTHREADS */
3087
3088 /* Initialize EH context.
3089    This will be called only once, since we change GET_EH_CONTEXT
3090    pointer to another routine. */
3091
3092 static struct eh_context *
3093 eh_context_initialize ()
3094 {
3095 #if __GTHREADS
3096
3097   static __gthread_once_t once = __GTHREAD_ONCE_INIT;
3098   if (__gthread_once (&once, eh_threads_initialize) == -1)
3099     {
3100       /* Use static version of EH context. */
3101       get_eh_context = &eh_context_static;
3102     }
3103
3104 #else /* no __GTHREADS */
3105
3106   /* Use static version of EH context. */
3107   get_eh_context = &eh_context_static;
3108
3109 #endif /* no __GTHREADS */
3110
3111   return (*get_eh_context) ();
3112 }
3113
3114 /* Return a static EH context. */
3115
3116 static struct eh_context *
3117 eh_context_static ()
3118 {
3119   static struct eh_context *eh;
3120   if (! eh)
3121     eh = new_eh_context ();
3122   return eh;
3123 }
3124
3125 #if __GTHREADS
3126 /* Return a thread specific EH context. */
3127
3128 static struct eh_context *
3129 eh_context_specific ()
3130 {
3131   struct eh_context *eh;
3132   eh = (struct eh_context *) __gthread_getspecific (eh_context_key);
3133   if (! eh)
3134     {
3135       eh = new_eh_context ();
3136       if (__gthread_setspecific (eh_context_key, (void *) eh) != 0)
3137         __terminate ();
3138     }
3139
3140   return eh;
3141 }
3142 #endif __GTHREADS
3143 \f
3144 /* Support routines for setjmp/longjmp exception handling.  */
3145
3146 /* Calls to __sjthrow are generated by the compiler when an exception
3147    is raised when using the setjmp/longjmp exception handling codegen
3148    method.  */
3149
3150 #ifdef DONT_USE_BUILTIN_SETJMP
3151 extern void longjmp (void *, int);
3152 #endif
3153
3154 /* Routine to get the head of the current thread's dynamic handler chain
3155    use for exception handling. */
3156
3157 void ***
3158 __get_dynamic_handler_chain ()
3159 {
3160   struct eh_context *eh = (*get_eh_context) ();
3161   return &eh->dynamic_handler_chain;
3162 }
3163
3164 /* This is used to throw an exception when the setjmp/longjmp codegen
3165    method is used for exception handling.
3166
3167    We call __terminate if there are no handlers left.  Otherwise we run the
3168    cleanup actions off the dynamic cleanup stack, and pop the top of the
3169    dynamic handler chain, and use longjmp to transfer back to the associated
3170    handler.  */
3171
3172 void
3173 __sjthrow ()
3174 {
3175   struct eh_context *eh = (*get_eh_context) ();
3176   void ***dhc = &eh->dynamic_handler_chain;
3177   void *jmpbuf;
3178   void (*func)(void *, int);
3179   void *arg;
3180   void ***cleanup;
3181
3182   /* The cleanup chain is one word into the buffer.  Get the cleanup
3183      chain.  */
3184   cleanup = (void***)&(*dhc)[1];
3185
3186   /* If there are any cleanups in the chain, run them now.  */
3187   if (cleanup[0])
3188     {
3189       double store[200];
3190       void **buf = (void**)store;
3191       buf[1] = 0;
3192       buf[0] = (*dhc);
3193
3194       /* try { */
3195 #ifdef DONT_USE_BUILTIN_SETJMP
3196       if (! setjmp (&buf[2]))
3197 #else
3198       if (! __builtin_setjmp (&buf[2]))
3199 #endif
3200         {
3201           *dhc = buf;
3202           while (cleanup[0])
3203             {
3204               func = (void(*)(void*, int))cleanup[0][1];
3205               arg = (void*)cleanup[0][2];
3206
3207               /* Update this before running the cleanup.  */
3208               cleanup[0] = (void **)cleanup[0][0];
3209
3210               (*func)(arg, 2);
3211             }
3212           *dhc = buf[0];
3213         }
3214       /* catch (...) */
3215       else
3216         {
3217           __terminate ();
3218         }
3219     }
3220
3221   /* We must call terminate if we try and rethrow an exception, when
3222      there is no exception currently active and when there are no
3223      handlers left.  */
3224   if (! eh->info || (*dhc) == top_elt)
3225     __terminate ();
3226
3227   /* Find the jmpbuf associated with the top element of the dynamic
3228      handler chain.  The jumpbuf starts two words into the buffer.  */
3229   jmpbuf = &(*dhc)[2];
3230
3231   /* Then we pop the top element off the dynamic handler chain.  */
3232   *dhc = (void**)(*dhc)[0];
3233
3234   /* And then we jump to the handler.  */
3235
3236 #ifdef DONT_USE_BUILTIN_SETJMP
3237   longjmp (jmpbuf, 1);
3238 #else
3239   __builtin_longjmp (jmpbuf, 1);
3240 #endif
3241 }
3242
3243 /* Run cleanups on the dynamic cleanup stack for the current dynamic
3244    handler, then pop the handler off the dynamic handler stack, and
3245    then throw.  This is used to skip the first handler, and transfer
3246    control to the next handler in the dynamic handler stack.  */
3247
3248 void
3249 __sjpopnthrow ()
3250 {
3251   struct eh_context *eh = (*get_eh_context) ();
3252   void ***dhc = &eh->dynamic_handler_chain;
3253   void *jmpbuf;
3254   void (*func)(void *, int);
3255   void *arg;
3256   void ***cleanup;
3257
3258   /* The cleanup chain is one word into the buffer.  Get the cleanup
3259      chain.  */
3260   cleanup = (void***)&(*dhc)[1];
3261
3262   /* If there are any cleanups in the chain, run them now.  */
3263   if (cleanup[0])
3264     {
3265       double store[200];
3266       void **buf = (void**)store;
3267       buf[1] = 0;
3268       buf[0] = (*dhc);
3269
3270       /* try { */
3271 #ifdef DONT_USE_BUILTIN_SETJMP
3272       if (! setjmp (&buf[2]))
3273 #else
3274       if (! __builtin_setjmp (&buf[2]))
3275 #endif
3276         {
3277           *dhc = buf;
3278           while (cleanup[0])
3279             {
3280               func = (void(*)(void*, int))cleanup[0][1];
3281               arg = (void*)cleanup[0][2];
3282
3283               /* Update this before running the cleanup.  */
3284               cleanup[0] = (void **)cleanup[0][0];
3285
3286               (*func)(arg, 2);
3287             }
3288           *dhc = buf[0];
3289         }
3290       /* catch (...) */
3291       else
3292         {
3293           __terminate ();
3294         }
3295     }
3296
3297   /* Then we pop the top element off the dynamic handler chain.  */
3298   *dhc = (void**)(*dhc)[0];
3299
3300   __sjthrow ();
3301 }
3302 \f
3303 /* Support code for all exception region-based exception handling.  */
3304
3305 /* This value identifies the place from which an exception is being
3306    thrown.  */
3307
3308 #ifdef EH_TABLE_LOOKUP
3309
3310 EH_TABLE_LOOKUP
3311
3312 #else
3313
3314 typedef struct exception_table {
3315   void *start;
3316   void *end;
3317   void *exception_handler;
3318 } exception_table;
3319
3320 /* This routine takes a PC and a pointer to the exception region TABLE for
3321    its translation unit, and returns the address of the exception handler
3322    associated with the closest exception table handler entry associated
3323    with that PC, or 0 if there are no table entries the PC fits in.
3324
3325    In the advent of a tie, we have to give the last entry, as it represents
3326    an inner block.  */
3327
3328 static void *
3329 find_exception_handler (void *pc, exception_table *table)
3330 {
3331   if (table)
3332     {
3333       int pos;
3334       int best = -1;
3335
3336       /* We can't do a binary search because the table isn't guaranteed
3337          to be sorted from function to function.  */
3338       for (pos = 0; table[pos].exception_handler != (void *) -1; ++pos)
3339         {
3340           if (table[pos].start <= pc && table[pos].end > pc)
3341             {
3342               /* This can apply.  Make sure it is at least as small as
3343                  the previous best.  */
3344               if (best == -1 || (table[pos].end <= table[best].end
3345                                  && table[pos].start >= table[best].start))
3346                 best = pos;
3347             }
3348           /* But it is sorted by starting PC within a function.  */
3349           else if (best >= 0 && table[pos].start > pc)
3350             break;
3351         }
3352       if (best != -1)
3353         return table[best].exception_handler;
3354     }
3355
3356   return (void *) 0;
3357 }
3358 #endif /* EH_TABLE_LOOKUP */
3359 \f
3360 #ifdef DWARF2_UNWIND_INFO
3361 /* Support code for exception handling using static unwind information.  */
3362
3363 #include "frame.h"
3364
3365 /* This type is used in get_reg and put_reg to deal with ABIs where a void*
3366    is smaller than a word, such as the Irix 6 n32 ABI.  We cast twice to
3367    avoid a warning about casting between int and pointer of different
3368    sizes.  */
3369
3370 typedef int ptr_type __attribute__ ((mode (pointer)));
3371
3372 /* Get the value of register REG as saved in UDATA, where SUB_UDATA is a
3373    frame called by UDATA or 0.  */
3374
3375 static void*
3376 get_reg (unsigned reg, frame_state *udata, frame_state *sub_udata)
3377 {
3378   if (udata->saved[reg] == REG_SAVED_OFFSET)
3379     return (void *)(ptr_type)
3380       *(word_type *)(udata->cfa + udata->reg_or_offset[reg]);
3381   else if (udata->saved[reg] == REG_SAVED_REG && sub_udata)
3382     return get_reg (udata->reg_or_offset[reg], sub_udata, 0);
3383   else
3384     abort ();
3385 }
3386
3387 /* Overwrite the saved value for register REG in frame UDATA with VAL.  */
3388
3389 static void
3390 put_reg (unsigned reg, void *val, frame_state *udata)
3391 {
3392   if (udata->saved[reg] == REG_SAVED_OFFSET)
3393     *(word_type *)(udata->cfa + udata->reg_or_offset[reg])
3394       = (word_type)(ptr_type) val;
3395   else
3396     abort ();
3397 }
3398
3399 /* Copy the saved value for register REG from frame UDATA to frame
3400    TARGET_UDATA.  Unlike the previous two functions, this can handle
3401    registers that are not one word large.  */
3402
3403 static void
3404 copy_reg (unsigned reg, frame_state *udata, frame_state *target_udata)
3405 {
3406   if (udata->saved[reg] == REG_SAVED_OFFSET
3407       && target_udata->saved[reg] == REG_SAVED_OFFSET)
3408     memcpy (target_udata->cfa + target_udata->reg_or_offset[reg],
3409             udata->cfa + udata->reg_or_offset[reg],
3410             __builtin_dwarf_reg_size (reg));
3411   else
3412     abort ();
3413 }
3414
3415 /* Retrieve the return address for frame UDATA, where SUB_UDATA is a
3416    frame called by UDATA or 0.  */
3417
3418 static inline void *
3419 get_return_addr (frame_state *udata, frame_state *sub_udata)
3420 {
3421   return __builtin_extract_return_addr
3422     (get_reg (udata->retaddr_column, udata, sub_udata));
3423 }
3424
3425 /* Overwrite the return address for frame UDATA with VAL.  */
3426
3427 static inline void
3428 put_return_addr (void *val, frame_state *udata)
3429 {
3430   val = __builtin_frob_return_addr (val);
3431   put_reg (udata->retaddr_column, val, udata);
3432 }
3433
3434 /* Given the current frame UDATA and its return address PC, return the
3435    information about the calling frame in CALLER_UDATA.  */
3436
3437 static void *
3438 next_stack_level (void *pc, frame_state *udata, frame_state *caller_udata)
3439 {
3440   caller_udata = __frame_state_for (pc, caller_udata);
3441   if (! caller_udata)
3442     return 0;
3443
3444   /* Now go back to our caller's stack frame.  If our caller's CFA register
3445      was saved in our stack frame, restore it; otherwise, assume the CFA
3446      register is SP and restore it to our CFA value.  */
3447   if (udata->saved[caller_udata->cfa_reg])
3448     caller_udata->cfa = get_reg (caller_udata->cfa_reg, udata, 0);
3449   else
3450     caller_udata->cfa = udata->cfa;
3451   caller_udata->cfa += caller_udata->cfa_offset;
3452
3453   return caller_udata;
3454 }
3455
3456 #ifdef INCOMING_REGNO
3457 /* Is the saved value for register REG in frame UDATA stored in a register
3458    window in the previous frame?  */
3459
3460 static int
3461 in_reg_window (int reg, frame_state *udata)
3462 {
3463   if (udata->saved[reg] != REG_SAVED_OFFSET)
3464     return 0;
3465
3466 #ifdef STACK_GROWS_DOWNWARD
3467   return udata->reg_or_offset[reg] > 0;
3468 #else
3469   return udata->reg_or_offset[reg] < 0;
3470 #endif
3471 }
3472 #endif /* INCOMING_REGNO */
3473
3474 /* We first search for an exception handler, and if we don't find
3475    it, we call __terminate on the current stack frame so that we may
3476    use the debugger to walk the stack and understand why no handler
3477    was found.
3478
3479    If we find one, then we unwind the frames down to the one that
3480    has the handler and transfer control into the handler.  */
3481
3482 void
3483 __throw ()
3484 {
3485   struct eh_context *eh = (*get_eh_context) ();
3486   void *saved_pc, *pc, *handler, *retaddr;
3487   frame_state ustruct, ustruct2;
3488   frame_state *udata = &ustruct;
3489   frame_state *sub_udata = &ustruct2;
3490   frame_state my_ustruct, *my_udata = &my_ustruct;
3491   long args_size;
3492
3493   /* This is required for C++ semantics.  We must call terminate if we
3494      try and rethrow an exception, when there is no exception currently
3495      active.  */
3496   if (! eh->info)
3497     __terminate ();
3498
3499   /* Start at our stack frame.  */
3500 label:
3501   udata = __frame_state_for (&&label, udata);
3502   if (! udata)
3503     __terminate ();
3504
3505   /* We need to get the value from the CFA register.  At this point in
3506      compiling __throw we don't know whether or not we will use the frame
3507      pointer register for the CFA, so we check our unwind info.  */
3508   if (udata->cfa_reg == __builtin_dwarf_fp_regnum ())
3509     udata->cfa = __builtin_fp ();
3510   else
3511     udata->cfa = __builtin_sp ();
3512   udata->cfa += udata->cfa_offset;
3513
3514   memcpy (my_udata, udata, sizeof (*udata));
3515
3516   /* Do any necessary initialization to access arbitrary stack frames.
3517      On the SPARC, this means flushing the register windows.  */
3518   __builtin_unwind_init ();
3519
3520   /* Now reset pc to the right throw point.  */
3521   pc = __builtin_extract_return_addr (__builtin_return_address (0)) - 1;
3522   saved_pc = pc;
3523
3524   handler = 0;
3525   for (;;)
3526     {
3527       frame_state *p = udata;
3528       udata = next_stack_level (pc, udata, sub_udata);
3529       sub_udata = p;
3530
3531       /* If we couldn't find the next frame, we lose.  */
3532       if (! udata)
3533         break;
3534
3535       handler = find_exception_handler (pc, udata->eh_ptr);
3536
3537       /* If we found one, we can stop searching.  */
3538       if (handler)
3539         {
3540           args_size = udata->args_size;
3541           break;
3542         }
3543
3544       /* Otherwise, we continue searching.  We subtract 1 from PC to avoid
3545          hitting the beginning of the next region.  */
3546       pc = get_return_addr (udata, sub_udata) - 1;
3547     }
3548
3549   /* If we haven't found a handler by now, this is an unhandled
3550      exception.  */
3551   if (! handler)
3552     __terminate ();
3553
3554   if (pc == saved_pc)
3555     /* We found a handler in the throw context, no need to unwind.  */
3556     udata = my_udata;
3557   else
3558     {
3559       int i;
3560       void *val;
3561
3562       /* Unwind all the frames between this one and the handler by copying
3563          their saved register values into our register save slots.  */
3564
3565       /* Remember the PC where we found the handler.  */
3566       void *handler_pc = pc;
3567
3568       /* Start from the throw context again.  */
3569       pc = saved_pc;
3570       memcpy (udata, my_udata, sizeof (*udata));
3571
3572       while (pc != handler_pc)
3573         {
3574           frame_state *p = udata;
3575           udata = next_stack_level (pc, udata, sub_udata);
3576           sub_udata = p;
3577
3578           for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
3579             if (i != udata->retaddr_column && udata->saved[i])
3580               {
3581 #ifdef INCOMING_REGNO
3582                 /* If you modify the saved value of the return address
3583                    register on the SPARC, you modify the return address for
3584                    your caller's frame.  Don't do that here, as it will
3585                    confuse get_return_addr.  */
3586                 if (in_reg_window (i, udata)
3587                     && udata->saved[udata->retaddr_column] == REG_SAVED_REG
3588                     && udata->reg_or_offset[udata->retaddr_column] == i)
3589                   continue;
3590 #endif
3591                 copy_reg (i, udata, my_udata);
3592               }
3593
3594           pc = get_return_addr (udata, sub_udata) - 1;
3595         }
3596
3597 #ifdef INCOMING_REGNO
3598       /* But we do need to update the saved return address register from
3599          the last frame we unwind, or the handler frame will have the wrong
3600          return address.  */
3601       if (udata->saved[udata->retaddr_column] == REG_SAVED_REG)
3602         {
3603           i = udata->reg_or_offset[udata->retaddr_column];
3604           if (in_reg_window (i, udata))
3605             copy_reg (i, udata, my_udata);
3606         }
3607 #endif
3608     }
3609   /* udata now refers to the frame called by the handler frame.  */
3610
3611   /* Emit the stub to adjust sp and jump to the handler.  */
3612   retaddr = __builtin_eh_stub ();
3613
3614   /* And then set our return address to point to the stub.  */
3615   if (my_udata->saved[my_udata->retaddr_column] == REG_SAVED_OFFSET)
3616     put_return_addr (retaddr, my_udata);
3617   else
3618     __builtin_set_return_addr_reg (retaddr);
3619
3620   /* Set up the registers we use to communicate with the stub.
3621      We check STACK_GROWS_DOWNWARD so the stub can use adjust_stack.  */
3622   __builtin_set_eh_regs (handler,
3623 #ifdef STACK_GROWS_DOWNWARD
3624                          udata->cfa - my_udata->cfa
3625 #else
3626                          my_udata->cfa - udata->cfa
3627 #endif
3628                          + args_size
3629                          );
3630
3631   /* Epilogue:  restore the handler frame's register values and return
3632      to the stub.  */
3633 }
3634 #endif /* DWARF2_UNWIND_INFO */
3635
3636 #endif /* L_eh */
3637 \f
3638 #ifdef L_pure
3639 #ifndef inhibit_libc
3640 /* This gets us __GNU_LIBRARY__.  */
3641 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
3642 #include <stdio.h>
3643
3644 #ifdef __GNU_LIBRARY__
3645   /* Avoid forcing the library's meaning of `write' on the user program
3646      by using the "internal" name (for use within the library)  */
3647 #define write(fd, buf, n)       __write((fd), (buf), (n))
3648 #endif
3649 #endif /* inhibit_libc */
3650
3651 #define MESSAGE "pure virtual method called\n"
3652
3653 void
3654 __pure_virtual ()
3655 {
3656 #ifndef inhibit_libc
3657   write (2, MESSAGE, sizeof (MESSAGE) - 1);
3658 #endif
3659   _exit (-1);
3660 }
3661 #endif