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