gcc/libgcc2.c

   1 /* More subroutines needed by GCC output code on some machines.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4    2000, 2001  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 In addition to the permissions in the GNU General Public License, the
  14 Free Software Foundation gives you unlimited permission to link the
  15 compiled version of this file into combinations with other programs,
  16 and to distribute those combinations without any restriction coming
  17 from the use of this file.  (The General Public License restrictions
  18 do apply in other respects; for example, they cover modification of
  19 the file, and distribution when not linked into a combine
  20 executable.)
  21
  22 GNU CC is distributed in the hope that it will be useful,
  23 but WITHOUT ANY WARRANTY; without even the implied warranty of
  24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25 GNU General Public License for more details.
  26
  27 You should have received a copy of the GNU General Public License
  28 along with GNU CC; see the file COPYING.  If not, write to
  29 the Free Software Foundation, 59 Temple Place - Suite 330,
  30 Boston, MA 02111-1307, USA.  */
  31
  32 /* It is incorrect to include config.h here, because this file is being
  33    compiled for the target, and hence definitions concerning only the host
  34    do not apply.  */
  35
  36 #include "tconfig.h"
  37 #include "tsystem.h"
  38
  39 #include "machmode.h"
  40
  41 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  42 #ifdef abort
  43 #undef abort
  44 #endif
  45
  46 #include "libgcc2.h"
  47 \f
  48 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
  49 #if defined (L_divdi3) || defined (L_moddi3)
  50 static inline
  51 #endif
  52 DWtype
  53 __negdi2 (DWtype u)
  54 {
  55   DWunion w;
  56   DWunion uu;
  57
  58   uu.ll = u;
  59
  60   w.s.low = -uu.s.low;
  61   w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
  62
  63   return w.ll;
  64 }
  65 #endif
  66
  67 #ifdef L_addvsi3
  68 Wtype
  69 __addvsi3 (Wtype a, Wtype b)
  70 {
  71   Wtype w;
  72
  73   w = a + b;
  74
  75   if (b >= 0 ? w < a : w > a)
  76     abort ();
  77
  78   return w;
  79 }
  80 #endif
  81 \f
  82 #ifdef L_addvdi3
  83 DWtype
  84 __addvdi3 (DWtype a, DWtype b)
  85 {
  86   DWtype w;
  87
  88   w = a + b;
  89
  90   if (b >= 0 ? w < a : w > a)
  91     abort ();
  92
  93   return w;
  94 }
  95 #endif
  96 \f
  97 #ifdef L_subvsi3
  98 Wtype
  99 __subvsi3 (Wtype a, Wtype b)
 100 {
 101 #ifdef L_addvsi3
 102   return __addvsi3 (a, (-b));
 103 #else
 104   DWtype w;
 105
 106   w = a - b;
 107
 108   if (b >= 0 ? w > a : w < a)
 109     abort ();
 110
 111   return w;
 112 #endif
 113 }
 114 #endif
 115 \f
 116 #ifdef L_subvdi3
 117 DWtype
 118 __subvdi3 (DWtype a, DWtype b)
 119 {
 120 #ifdef L_addvdi3
 121   return (a, (-b));
 122 #else
 123   DWtype w;
 124
 125   w = a - b;
 126
 127   if (b >= 0 ? w > a : w < a)
 128     abort ();
 129
 130   return w;
 131 #endif
 132 }
 133 #endif
 134 \f
 135 #ifdef L_mulvsi3
 136 Wtype
 137 __mulvsi3 (Wtype a, Wtype b)
 138 {
 139   DWtype w;
 140
 141   w = a * b;
 142
 143   if (((a >= 0) == (b >= 0)) ? w < 0 : w > 0)
 144     abort ();
 145
 146   return w;
 147 }
 148 #endif
 149 \f
 150 #ifdef L_negvsi2
 151 Wtype
 152 __negvsi2 (Wtype a)
 153 {
 154    Wtype w;
 155
 156    w  = -a;
 157
 158   if (a >= 0 ? w > 0 : w < 0)
 159     abort ();
 160
 161    return w;
 162 }
 163 #endif
 164 \f
 165 #ifdef L_negvdi2
 166 DWtype
 167 __negvdi2 (DWtype a)
 168 {
 169    DWtype w;
 170
 171    w  = -a;
 172
 173   if (a >= 0 ? w > 0 : w < 0)
 174     abort ();
 175
 176    return w;
 177 }
 178 #endif
 179 \f
 180 #ifdef L_absvsi2
 181 Wtype
 182 __absvsi2 (Wtype a)
 183 {
 184    Wtype w = a;
 185
 186    if (a < 0)
 187 #ifdef L_negvsi2
 188      w = __negvsi2 (a);
 189 #else
 190      w = -a;
 191
 192    if (w < 0)
 193      abort ();
 194 #endif
 195
 196    return w;
 197 }
 198 #endif
 199 \f
 200 #ifdef L_absvdi2
 201 DWtype
 202 __absvdi2 (DWtype a)
 203 {
 204    DWtype w = a;
 205
 206    if (a < 0)
 207 #ifdef L_negvsi2
 208      w = __negvsi2 (a);
 209 #else
 210      w = -a;
 211
 212    if (w < 0)
 213      abort ();
 214 #endif
 215
 216    return w;
 217 }
 218 #endif
 219 \f
 220 #ifdef L_mulvdi3
 221 DWtype
 222 __mulvdi3 (DWtype u, DWtype v)
 223 {
 224    DWtype w;
 225
 226   w = u * v;
 227
 228   if (((u >= 0) == (v >= 0)) ? w < 0 : w > 0)
 229     abort ();
 230
 231   return w;
 232 }
 233 #endif
 234 \f
 235
 236 /* Unless shift functions are defined whith full ANSI prototypes,
 237    parameter b will be promoted to int if word_type is smaller than an int.  */
 238 #ifdef L_lshrdi3
 239 DWtype
 240 __lshrdi3 (DWtype u, word_type b)
 241 {
 242   DWunion w;
 243   word_type bm;
 244   DWunion uu;
 245
 246   if (b == 0)
 247     return u;
 248
 249   uu.ll = u;
 250
 251   bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 252   if (bm <= 0)
 253     {
 254       w.s.high = 0;
 255       w.s.low = (UWtype) uu.s.high >> -bm;
 256     }
 257   else
 258     {
 259       UWtype carries = (UWtype) uu.s.high << bm;
 260
 261       w.s.high = (UWtype) uu.s.high >> b;
 262       w.s.low = ((UWtype) uu.s.low >> b) | carries;
 263     }
 264
 265   return w.ll;
 266 }
 267 #endif
 268
 269 #ifdef L_ashldi3
 270 DWtype
 271 __ashldi3 (DWtype u, word_type b)
 272 {
 273   DWunion w;
 274   word_type bm;
 275   DWunion uu;
 276
 277   if (b == 0)
 278     return u;
 279
 280   uu.ll = u;
 281
 282   bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 283   if (bm <= 0)
 284     {
 285       w.s.low = 0;
 286       w.s.high = (UWtype) uu.s.low << -bm;
 287     }
 288   else
 289     {
 290       UWtype carries = (UWtype) uu.s.low >> bm;
 291
 292       w.s.low = (UWtype) uu.s.low << b;
 293       w.s.high = ((UWtype) uu.s.high << b) | carries;
 294     }
 295
 296   return w.ll;
 297 }
 298 #endif
 299
 300 #ifdef L_ashrdi3
 301 DWtype
 302 __ashrdi3 (DWtype u, word_type b)
 303 {
 304   DWunion w;
 305   word_type bm;
 306   DWunion uu;
 307
 308   if (b == 0)
 309     return u;
 310
 311   uu.ll = u;
 312
 313   bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 314   if (bm <= 0)
 315     {
 316       /* w.s.high = 1..1 or 0..0 */
 317       w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
 318       w.s.low = uu.s.high >> -bm;
 319     }
 320   else
 321     {
 322       UWtype carries = (UWtype) uu.s.high << bm;
 323
 324       w.s.high = uu.s.high >> b;
 325       w.s.low = ((UWtype) uu.s.low >> b) | carries;
 326     }
 327
 328   return w.ll;
 329 }
 330 #endif
 331 \f
 332 #ifdef L_ffsdi2
 333 DWtype
 334 __ffsdi2 (DWtype u)
 335 {
 336   DWunion uu;
 337   UWtype word, count, add;
 338
 339   uu.ll = u;
 340   if (uu.s.low != 0)
 341     word = uu.s.low, add = 0;
 342   else if (uu.s.high != 0)
 343     word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
 344   else
 345     return 0;
 346
 347   count_trailing_zeros (count, word);
 348   return count + add + 1;
 349 }
 350 #endif
 351 \f
 352 #ifdef L_muldi3
 353 DWtype
 354 __muldi3 (DWtype u, DWtype v)
 355 {
 356   DWunion w;
 357   DWunion uu, vv;
 358
 359   uu.ll = u,
 360   vv.ll = v;
 361
 362   w.ll = __umulsidi3 (uu.s.low, vv.s.low);
 363   w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
 364                + (UWtype) uu.s.high * (UWtype) vv.s.low);
 365
 366   return w.ll;
 367 }
 368 #endif
 369 \f
 370 #ifdef L_udiv_w_sdiv
 371 #if defined (sdiv_qrnnd)
 372 UWtype
 373 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
 374 {
 375   UWtype q, r;
 376   UWtype c0, c1, b1;
 377
 378   if ((Wtype) d >= 0)
 379     {
 380       if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
 381         {
 382           /* dividend, divisor, and quotient are nonnegative */
 383           sdiv_qrnnd (q, r, a1, a0, d);
 384         }
 385       else
 386         {
 387           /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
 388           sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
 389           /* Divide (c1*2^32 + c0) by d */
 390           sdiv_qrnnd (q, r, c1, c0, d);
 391           /* Add 2^31 to quotient */
 392           q += (UWtype) 1 << (W_TYPE_SIZE - 1);
 393         }
 394     }
 395   else
 396     {
 397       b1 = d >> 1;                      /* d/2, between 2^30 and 2^31 - 1 */
 398       c1 = a1 >> 1;                     /* A/2 */
 399       c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
 400
 401       if (a1 < b1)                      /* A < 2^32*b1, so A/2 < 2^31*b1 */
 402         {
 403           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 404
 405           r = 2*r + (a0 & 1);           /* Remainder from A/(2*b1) */
 406           if ((d & 1) != 0)
 407             {
 408               if (r >= q)
 409                 r = r - q;
 410               else if (q - r <= d)
 411                 {
 412                   r = r - q + d;
 413                   q--;
 414                 }
 415               else
 416                 {
 417                   r = r - q + 2*d;
 418                   q -= 2;
 419                 }
 420             }
 421         }
 422       else if (c1 < b1)                 /* So 2^31 <= (A/2)/b1 < 2^32 */
 423         {
 424           c1 = (b1 - 1) - c1;
 425           c0 = ~c0;                     /* logical NOT */
 426
 427           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 428
 429           q = ~q;                       /* (A/2)/b1 */
 430           r = (b1 - 1) - r;
 431
 432           r = 2*r + (a0 & 1);           /* A/(2*b1) */
 433
 434           if ((d & 1) != 0)
 435             {
 436               if (r >= q)
 437                 r = r - q;
 438               else if (q - r <= d)
 439                 {
 440                   r = r - q + d;
 441                   q--;
 442                 }
 443               else
 444                 {
 445                   r = r - q + 2*d;
 446                   q -= 2;
 447                 }
 448             }
 449         }
 450       else                              /* Implies c1 = b1 */
 451         {                               /* Hence a1 = d - 1 = 2*b1 - 1 */
 452           if (a0 >= -d)
 453             {
 454               q = -1;
 455               r = a0 + d;
 456             }
 457           else
 458             {
 459               q = -2;
 460               r = a0 + 2*d;
 461             }
 462         }
 463     }
 464
 465   *rp = r;
 466   return q;
 467 }
 468 #else
 469 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv.  */
 470 UWtype
 471 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
 472                UWtype a1 __attribute__ ((__unused__)),
 473                UWtype a0 __attribute__ ((__unused__)),
 474                UWtype d __attribute__ ((__unused__)))
 475 {
 476   return 0;
 477 }
 478 #endif
 479 #endif
 480 \f
 481 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 482      defined (L_umoddi3) || defined (L_moddi3))
 483 #define L_udivmoddi4
 484 #endif
 485
 486 #ifdef L_clz
 487 const UQItype __clz_tab[] =
 488 {
 489   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,
 490   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,
 491   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,
 492   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,
 493   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,
 494   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,
 495   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,
 496   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,
 497 };
 498 #endif
 499
 500 #ifdef L_udivmoddi4
 501
 502 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 503      defined (L_umoddi3) || defined (L_moddi3))
 504 static inline
 505 #endif
 506 UDWtype
 507 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
 508 {
 509   DWunion ww;
 510   DWunion nn, dd;
 511   DWunion rr;
 512   UWtype d0, d1, n0, n1, n2;
 513   UWtype q0, q1;
 514   UWtype b, bm;
 515
 516   nn.ll = n;
 517   dd.ll = d;
 518
 519   d0 = dd.s.low;
 520   d1 = dd.s.high;
 521   n0 = nn.s.low;
 522   n1 = nn.s.high;
 523
 524 #if !UDIV_NEEDS_NORMALIZATION
 525   if (d1 == 0)
 526     {
 527       if (d0 > n1)
 528         {
 529           /* 0q = nn / 0D */
 530
 531           udiv_qrnnd (q0, n0, n1, n0, d0);
 532           q1 = 0;
 533
 534           /* Remainder in n0.  */
 535         }
 536       else
 537         {
 538           /* qq = NN / 0d */
 539
 540           if (d0 == 0)
 541             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 542
 543           udiv_qrnnd (q1, n1, 0, n1, d0);
 544           udiv_qrnnd (q0, n0, n1, n0, d0);
 545
 546           /* Remainder in n0.  */
 547         }
 548
 549       if (rp != 0)
 550         {
 551           rr.s.low = n0;
 552           rr.s.high = 0;
 553           *rp = rr.ll;
 554         }
 555     }
 556
 557 #else /* UDIV_NEEDS_NORMALIZATION */
 558
 559   if (d1 == 0)
 560     {
 561       if (d0 > n1)
 562         {
 563           /* 0q = nn / 0D */
 564
 565           count_leading_zeros (bm, d0);
 566
 567           if (bm != 0)
 568             {
 569               /* Normalize, i.e. make the most significant bit of the
 570                  denominator set.  */
 571
 572               d0 = d0 << bm;
 573               n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
 574               n0 = n0 << bm;
 575             }
 576
 577           udiv_qrnnd (q0, n0, n1, n0, d0);
 578           q1 = 0;
 579
 580           /* Remainder in n0 >> bm.  */
 581         }
 582       else
 583         {
 584           /* qq = NN / 0d */
 585
 586           if (d0 == 0)
 587             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 588
 589           count_leading_zeros (bm, d0);
 590
 591           if (bm == 0)
 592             {
 593               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 594                  conclude (the most significant bit of n1 is set) /\ (the
 595                  leading quotient digit q1 = 1).
 596
 597                  This special case is necessary, not an optimization.
 598                  (Shifts counts of W_TYPE_SIZE are undefined.)  */
 599
 600               n1 -= d0;
 601               q1 = 1;
 602             }
 603           else
 604             {
 605               /* Normalize.  */
 606
 607               b = W_TYPE_SIZE - bm;
 608
 609               d0 = d0 << bm;
 610               n2 = n1 >> b;
 611               n1 = (n1 << bm) | (n0 >> b);
 612               n0 = n0 << bm;
 613
 614               udiv_qrnnd (q1, n1, n2, n1, d0);
 615             }
 616
 617           /* n1 != d0...  */
 618
 619           udiv_qrnnd (q0, n0, n1, n0, d0);
 620
 621           /* Remainder in n0 >> bm.  */
 622         }
 623
 624       if (rp != 0)
 625         {
 626           rr.s.low = n0 >> bm;
 627           rr.s.high = 0;
 628           *rp = rr.ll;
 629         }
 630     }
 631 #endif /* UDIV_NEEDS_NORMALIZATION */
 632
 633   else
 634     {
 635       if (d1 > n1)
 636         {
 637           /* 00 = nn / DD */
 638
 639           q0 = 0;
 640           q1 = 0;
 641
 642           /* Remainder in n1n0.  */
 643           if (rp != 0)
 644             {
 645               rr.s.low = n0;
 646               rr.s.high = n1;
 647               *rp = rr.ll;
 648             }
 649         }
 650       else
 651         {
 652           /* 0q = NN / dd */
 653
 654           count_leading_zeros (bm, d1);
 655           if (bm == 0)
 656             {
 657               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 658                  conclude (the most significant bit of n1 is set) /\ (the
 659                  quotient digit q0 = 0 or 1).
 660
 661                  This special case is necessary, not an optimization.  */
 662
 663               /* The condition on the next line takes advantage of that
 664                  n1 >= d1 (true due to program flow).  */
 665               if (n1 > d1 || n0 >= d0)
 666                 {
 667                   q0 = 1;
 668                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 669                 }
 670               else
 671                 q0 = 0;
 672
 673               q1 = 0;
 674
 675               if (rp != 0)
 676                 {
 677                   rr.s.low = n0;
 678                   rr.s.high = n1;
 679                   *rp = rr.ll;
 680                 }
 681             }
 682           else
 683             {
 684               UWtype m1, m0;
 685               /* Normalize.  */
 686
 687               b = W_TYPE_SIZE - bm;
 688
 689               d1 = (d1 << bm) | (d0 >> b);
 690               d0 = d0 << bm;
 691               n2 = n1 >> b;
 692               n1 = (n1 << bm) | (n0 >> b);
 693               n0 = n0 << bm;
 694
 695               udiv_qrnnd (q0, n1, n2, n1, d1);
 696               umul_ppmm (m1, m0, q0, d0);
 697
 698               if (m1 > n1 || (m1 == n1 && m0 > n0))
 699                 {
 700                   q0--;
 701                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
 702                 }
 703
 704               q1 = 0;
 705
 706               /* Remainder in (n1n0 - m1m0) >> bm.  */
 707               if (rp != 0)
 708                 {
 709                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
 710                   rr.s.low = (n1 << b) | (n0 >> bm);
 711                   rr.s.high = n1 >> bm;
 712                   *rp = rr.ll;
 713                 }
 714             }
 715         }
 716     }
 717
 718   ww.s.low = q0;
 719   ww.s.high = q1;
 720   return ww.ll;
 721 }
 722 #endif
 723
 724 #ifdef L_divdi3
 725 DWtype
 726 __divdi3 (DWtype u, DWtype v)
 727 {
 728   word_type c = 0;
 729   DWunion uu, vv;
 730   DWtype w;
 731
 732   uu.ll = u;
 733   vv.ll = v;
 734
 735   if (uu.s.high < 0)
 736     c = ~c,
 737     uu.ll = __negdi2 (uu.ll);
 738   if (vv.s.high < 0)
 739     c = ~c,
 740     vv.ll = __negdi2 (vv.ll);
 741
 742   w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
 743   if (c)
 744     w = __negdi2 (w);
 745
 746   return w;
 747 }
 748 #endif
 749
 750 #ifdef L_moddi3
 751 DWtype
 752 __moddi3 (DWtype u, DWtype v)
 753 {
 754   word_type c = 0;
 755   DWunion uu, vv;
 756   DWtype w;
 757
 758   uu.ll = u;
 759   vv.ll = v;
 760
 761   if (uu.s.high < 0)
 762     c = ~c,
 763     uu.ll = __negdi2 (uu.ll);
 764   if (vv.s.high < 0)
 765     vv.ll = __negdi2 (vv.ll);
 766
 767   (void) __udivmoddi4 (uu.ll, vv.ll, &w);
 768   if (c)
 769     w = __negdi2 (w);
 770
 771   return w;
 772 }
 773 #endif
 774
 775 #ifdef L_umoddi3
 776 UDWtype
 777 __umoddi3 (UDWtype u, UDWtype v)
 778 {
 779   UDWtype w;
 780
 781   (void) __udivmoddi4 (u, v, &w);
 782
 783   return w;
 784 }
 785 #endif
 786
 787 #ifdef L_udivdi3
 788 UDWtype
 789 __udivdi3 (UDWtype n, UDWtype d)
 790 {
 791   return __udivmoddi4 (n, d, (UDWtype *) 0);
 792 }
 793 #endif
 794 \f
 795 #ifdef L_cmpdi2
 796 word_type
 797 __cmpdi2 (DWtype a, DWtype b)
 798 {
 799   DWunion au, bu;
 800
 801   au.ll = a, bu.ll = b;
 802
 803   if (au.s.high < bu.s.high)
 804     return 0;
 805   else if (au.s.high > bu.s.high)
 806     return 2;
 807   if ((UWtype) au.s.low < (UWtype) bu.s.low)
 808     return 0;
 809   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
 810     return 2;
 811   return 1;
 812 }
 813 #endif
 814
 815 #ifdef L_ucmpdi2
 816 word_type
 817 __ucmpdi2 (DWtype a, DWtype b)
 818 {
 819   DWunion au, bu;
 820
 821   au.ll = a, bu.ll = b;
 822
 823   if ((UWtype) au.s.high < (UWtype) bu.s.high)
 824     return 0;
 825   else if ((UWtype) au.s.high > (UWtype) bu.s.high)
 826     return 2;
 827   if ((UWtype) au.s.low < (UWtype) bu.s.low)
 828     return 0;
 829   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
 830     return 2;
 831   return 1;
 832 }
 833 #endif
 834 \f
 835 #if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
 836 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 837 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 838
 839 DWtype
 840 __fixunstfDI (TFtype a)
 841 {
 842   TFtype b;
 843   UDWtype v;
 844
 845   if (a < 0)
 846     return 0;
 847
 848   /* Compute high word of result, as a flonum.  */
 849   b = (a / HIGH_WORD_COEFF);
 850   /* Convert that to fixed (but not to DWtype!),
 851      and shift it into the high word.  */
 852   v = (UWtype) b;
 853   v <<= WORD_SIZE;
 854   /* Remove high part from the TFtype, leaving the low part as flonum.  */
 855   a -= (TFtype)v;
 856   /* Convert that to fixed (but not to DWtype!) and add it in.
 857      Sometimes A comes out negative.  This is significant, since
 858      A has more bits than a long int does.  */
 859   if (a < 0)
 860     v -= (UWtype) (- a);
 861   else
 862     v += (UWtype) a;
 863   return v;
 864 }
 865 #endif
 866
 867 #if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
 868 DWtype
 869 __fixtfdi (TFtype a)
 870 {
 871   if (a < 0)
 872     return - __fixunstfDI (-a);
 873   return __fixunstfDI (a);
 874 }
 875 #endif
 876
 877 #if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
 878 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 879 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 880
 881 DWtype
 882 __fixunsxfDI (XFtype a)
 883 {
 884   XFtype b;
 885   UDWtype v;
 886
 887   if (a < 0)
 888     return 0;
 889
 890   /* Compute high word of result, as a flonum.  */
 891   b = (a / HIGH_WORD_COEFF);
 892   /* Convert that to fixed (but not to DWtype!),
 893      and shift it into the high word.  */
 894   v = (UWtype) b;
 895   v <<= WORD_SIZE;
 896   /* Remove high part from the XFtype, leaving the low part as flonum.  */
 897   a -= (XFtype)v;
 898   /* Convert that to fixed (but not to DWtype!) and add it in.
 899      Sometimes A comes out negative.  This is significant, since
 900      A has more bits than a long int does.  */
 901   if (a < 0)
 902     v -= (UWtype) (- a);
 903   else
 904     v += (UWtype) a;
 905   return v;
 906 }
 907 #endif
 908
 909 #if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
 910 DWtype
 911 __fixxfdi (XFtype a)
 912 {
 913   if (a < 0)
 914     return - __fixunsxfDI (-a);
 915   return __fixunsxfDI (a);
 916 }
 917 #endif
 918
 919 #ifdef L_fixunsdfdi
 920 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 921 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 922
 923 DWtype
 924 __fixunsdfDI (DFtype a)
 925 {
 926   DFtype b;
 927   UDWtype v;
 928
 929   if (a < 0)
 930     return 0;
 931
 932   /* Compute high word of result, as a flonum.  */
 933   b = (a / HIGH_WORD_COEFF);
 934   /* Convert that to fixed (but not to DWtype!),
 935      and shift it into the high word.  */
 936   v = (UWtype) b;
 937   v <<= WORD_SIZE;
 938   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 939   a -= (DFtype)v;
 940   /* Convert that to fixed (but not to DWtype!) and add it in.
 941      Sometimes A comes out negative.  This is significant, since
 942      A has more bits than a long int does.  */
 943   if (a < 0)
 944     v -= (UWtype) (- a);
 945   else
 946     v += (UWtype) a;
 947   return v;
 948 }
 949 #endif
 950
 951 #ifdef L_fixdfdi
 952 DWtype
 953 __fixdfdi (DFtype a)
 954 {
 955   if (a < 0)
 956     return - __fixunsdfDI (-a);
 957   return __fixunsdfDI (a);
 958 }
 959 #endif
 960
 961 #ifdef L_fixunssfdi
 962 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 963 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 964
 965 DWtype
 966 __fixunssfDI (SFtype original_a)
 967 {
 968   /* Convert the SFtype to a DFtype, because that is surely not going
 969      to lose any bits.  Some day someone else can write a faster version
 970      that avoids converting to DFtype, and verify it really works right.  */
 971   DFtype a = original_a;
 972   DFtype b;
 973   UDWtype v;
 974
 975   if (a < 0)
 976     return 0;
 977
 978   /* Compute high word of result, as a flonum.  */
 979   b = (a / HIGH_WORD_COEFF);
 980   /* Convert that to fixed (but not to DWtype!),
 981      and shift it into the high word.  */
 982   v = (UWtype) b;
 983   v <<= WORD_SIZE;
 984   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 985   a -= (DFtype) v;
 986   /* Convert that to fixed (but not to DWtype!) and add it in.
 987      Sometimes A comes out negative.  This is significant, since
 988      A has more bits than a long int does.  */
 989   if (a < 0)
 990     v -= (UWtype) (- a);
 991   else
 992     v += (UWtype) a;
 993   return v;
 994 }
 995 #endif
 996
 997 #ifdef L_fixsfdi
 998 DWtype
 999 __fixsfdi (SFtype a)
1000 {
1001   if (a < 0)
1002     return - __fixunssfDI (-a);
1003   return __fixunssfDI (a);
1004 }
1005 #endif
1006
1007 #if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
1008 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1009 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1010 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1011
1012 XFtype
1013 __floatdixf (DWtype u)
1014 {
1015   XFtype d;
1016
1017   d = (Wtype) (u >> WORD_SIZE);
1018   d *= HIGH_HALFWORD_COEFF;
1019   d *= HIGH_HALFWORD_COEFF;
1020   d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1021
1022   return d;
1023 }
1024 #endif
1025
1026 #if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
1027 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1028 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1029 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1030
1031 TFtype
1032 __floatditf (DWtype u)
1033 {
1034   TFtype d;
1035
1036   d = (Wtype) (u >> WORD_SIZE);
1037   d *= HIGH_HALFWORD_COEFF;
1038   d *= HIGH_HALFWORD_COEFF;
1039   d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1040
1041   return d;
1042 }
1043 #endif
1044
1045 #ifdef L_floatdidf
1046 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1047 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1048 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1049
1050 DFtype
1051 __floatdidf (DWtype u)
1052 {
1053   DFtype d;
1054
1055   d = (Wtype) (u >> WORD_SIZE);
1056   d *= HIGH_HALFWORD_COEFF;
1057   d *= HIGH_HALFWORD_COEFF;
1058   d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1059
1060   return d;
1061 }
1062 #endif
1063
1064 #ifdef L_floatdisf
1065 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1066 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1067 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1068 #define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
1069
1070 /* Define codes for all the float formats that we know of.  Note
1071    that this is copied from real.h.  */
1072
1073 #define UNKNOWN_FLOAT_FORMAT 0
1074 #define IEEE_FLOAT_FORMAT 1
1075 #define VAX_FLOAT_FORMAT 2
1076 #define IBM_FLOAT_FORMAT 3
1077
1078 /* Default to IEEE float if not specified.  Nearly all machines use it.  */
1079 #ifndef HOST_FLOAT_FORMAT
1080 #define HOST_FLOAT_FORMAT       IEEE_FLOAT_FORMAT
1081 #endif
1082
1083 #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1084 #define DF_SIZE 53
1085 #define SF_SIZE 24
1086 #endif
1087
1088 #if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
1089 #define DF_SIZE 56
1090 #define SF_SIZE 24
1091 #endif
1092
1093 #if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
1094 #define DF_SIZE 56
1095 #define SF_SIZE 24
1096 #endif
1097
1098 SFtype
1099 __floatdisf (DWtype u)
1100 {
1101   /* Do the calculation in DFmode
1102      so that we don't lose any of the precision of the high word
1103      while multiplying it.  */
1104   DFtype f;
1105
1106   /* Protect against double-rounding error.
1107      Represent any low-order bits, that might be truncated in DFmode,
1108      by a bit that won't be lost.  The bit can go in anywhere below the
1109      rounding position of the SFmode.  A fixed mask and bit position
1110      handles all usual configurations.  It doesn't handle the case
1111      of 128-bit DImode, however.  */
1112   if (DF_SIZE < DI_SIZE
1113       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1114     {
1115 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1116       if (! (- ((DWtype) 1 << DF_SIZE) < u
1117              && u < ((DWtype) 1 << DF_SIZE)))
1118         {
1119           if ((UDWtype) u & (REP_BIT - 1))
1120             u |= REP_BIT;
1121         }
1122     }
1123   f = (Wtype) (u >> WORD_SIZE);
1124   f *= HIGH_HALFWORD_COEFF;
1125   f *= HIGH_HALFWORD_COEFF;
1126   f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1127
1128   return (SFtype) f;
1129 }
1130 #endif
1131
1132 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1133 /* Reenable the normal types, in case limits.h needs them.  */
1134 #undef char
1135 #undef short
1136 #undef int
1137 #undef long
1138 #undef unsigned
1139 #undef float
1140 #undef double
1141 #undef MIN
1142 #undef MAX
1143 #include <limits.h>
1144
1145 UWtype
1146 __fixunsxfSI (XFtype a)
1147 {
1148   if (a >= - (DFtype) Wtype_MIN)
1149     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1150   return (Wtype) a;
1151 }
1152 #endif
1153
1154 #ifdef L_fixunsdfsi
1155 /* Reenable the normal types, in case limits.h needs them.  */
1156 #undef char
1157 #undef short
1158 #undef int
1159 #undef long
1160 #undef unsigned
1161 #undef float
1162 #undef double
1163 #undef MIN
1164 #undef MAX
1165 #include <limits.h>
1166
1167 UWtype
1168 __fixunsdfSI (DFtype a)
1169 {
1170   if (a >= - (DFtype) Wtype_MIN)
1171     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1172   return (Wtype) a;
1173 }
1174 #endif
1175
1176 #ifdef L_fixunssfsi
1177 /* Reenable the normal types, in case limits.h needs them.  */
1178 #undef char
1179 #undef short
1180 #undef int
1181 #undef long
1182 #undef unsigned
1183 #undef float
1184 #undef double
1185 #undef MIN
1186 #undef MAX
1187 #include <limits.h>
1188
1189 UWtype
1190 __fixunssfSI (SFtype a)
1191 {
1192   if (a >= - (SFtype) Wtype_MIN)
1193     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1194   return (Wtype) a;
1195 }
1196 #endif
1197 \f
1198 /* From here on down, the routines use normal data types.  */
1199
1200 #define SItype bogus_type
1201 #define USItype bogus_type
1202 #define DItype bogus_type
1203 #define UDItype bogus_type
1204 #define SFtype bogus_type
1205 #define DFtype bogus_type
1206 #undef Wtype
1207 #undef UWtype
1208 #undef HWtype
1209 #undef UHWtype
1210 #undef DWtype
1211 #undef UDWtype
1212
1213 #undef char
1214 #undef short
1215 #undef int
1216 #undef long
1217 #undef unsigned
1218 #undef float
1219 #undef double
1220 \f
1221 #ifdef L__gcc_bcmp
1222
1223 /* Like bcmp except the sign is meaningful.
1224    Result is negative if S1 is less than S2,
1225    positive if S1 is greater, 0 if S1 and S2 are equal.  */
1226
1227 int
1228 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1229 {
1230   while (size > 0)
1231     {
1232       unsigned char c1 = *s1++, c2 = *s2++;
1233       if (c1 != c2)
1234         return c1 - c2;
1235       size--;
1236     }
1237   return 0;
1238 }
1239
1240 #endif
1241 \f
1242 #ifdef L_eprintf
1243 #ifndef inhibit_libc
1244
1245 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1246 #include <stdio.h>
1247 /* This is used by the `assert' macro.  */
1248 void
1249 __eprintf (const char *string, const char *expression,
1250            unsigned int line, const char *filename)
1251 {
1252   fprintf (stderr, string, expression, line, filename);
1253   fflush (stderr);
1254   abort ();
1255 }
1256
1257 #endif
1258 #endif
1259
1260 #ifdef L_bb
1261
1262 /* Structure emitted by -a  */
1263 struct bb
1264 {
1265   long zero_word;
1266   const char *filename;
1267   long *counts;
1268   long ncounts;
1269   struct bb *next;
1270   const unsigned long *addresses;
1271
1272   /* Older GCC's did not emit these fields.  */
1273   long nwords;
1274   const char **functions;
1275   const long *line_nums;
1276   const char **filenames;
1277   char *flags;
1278 };
1279
1280 #ifdef BLOCK_PROFILER_CODE
1281 BLOCK_PROFILER_CODE
1282 #else
1283 #ifndef inhibit_libc
1284
1285 /* Simple minded basic block profiling output dumper for
1286    systems that don't provide tcov support.  At present,
1287    it requires atexit and stdio.  */
1288
1289 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1290 #include <stdio.h>
1291 char *ctime PARAMS ((const time_t *));
1292
1293 #include "gbl-ctors.h"
1294 #include "gcov-io.h"
1295 #include <string.h>
1296 #ifdef TARGET_HAS_F_SETLKW
1297 #include <fcntl.h>
1298 #include <errno.h>
1299 #endif
1300
1301 static struct bb *bb_head;
1302
1303 static int num_digits (long value, int base) __attribute__ ((const));
1304
1305 /* Return the number of digits needed to print a value */
1306 /* __inline__ */ static int num_digits (long value, int base)
1307 {
1308   int minus = (value < 0 && base != 16);
1309   unsigned long v = (minus) ? -value : value;
1310   int ret = minus;
1311
1312   do
1313     {
1314       v /= base;
1315       ret++;
1316     }
1317   while (v);
1318
1319   return ret;
1320 }
1321
1322 void
1323 __bb_exit_func (void)
1324 {
1325   FILE *da_file, *file;
1326   long time_value;
1327   int i;
1328
1329   if (bb_head == 0)
1330     return;
1331
1332   i = strlen (bb_head->filename) - 3;
1333
1334   if (!strcmp (bb_head->filename+i, ".da"))
1335     {
1336       /* Must be -fprofile-arcs not -a.
1337          Dump data in a form that gcov expects.  */
1338
1339       struct bb *ptr;
1340
1341       for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1342         {
1343           int firstchar;
1344
1345           /* Make sure the output file exists -
1346              but don't clobber exiting data.  */
1347           if ((da_file = fopen (ptr->filename, "a")) != 0)
1348             fclose (da_file);
1349
1350           /* Need to re-open in order to be able to write from the start.  */
1351           da_file = fopen (ptr->filename, "r+b");
1352           /* Some old systems might not allow the 'b' mode modifier.
1353              Therefore, try to open without it.  This can lead to a race
1354              condition so that when you delete and re-create the file, the
1355              file might be opened in text mode, but then, you shouldn't
1356              delete the file in the first place.  */
1357           if (da_file == 0)
1358             da_file = fopen (ptr->filename, "r+");
1359           if (da_file == 0)
1360             {
1361               fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1362                        ptr->filename);
1363               continue;
1364             }
1365
1366           /* After a fork, another process might try to read and/or write
1367              the same file simultanously.  So if we can, lock the file to
1368              avoid race conditions.  */
1369 #if defined (TARGET_HAS_F_SETLKW)
1370           {
1371             struct flock s_flock;
1372
1373             s_flock.l_type = F_WRLCK;
1374             s_flock.l_whence = SEEK_SET;
1375             s_flock.l_start = 0;
1376             s_flock.l_len = 1;
1377             s_flock.l_pid = getpid ();
1378
1379             while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1380                    && errno == EINTR);
1381           }
1382 #endif
1383
1384           /* If the file is not empty, and the number of counts in it is the
1385              same, then merge them in.  */
1386           firstchar = fgetc (da_file);
1387           if (firstchar == EOF)
1388             {
1389               if (ferror (da_file))
1390                 {
1391                   fprintf (stderr, "arc profiling: Can't read output file ");
1392                   perror (ptr->filename);
1393                 }
1394             }
1395           else
1396             {
1397               long n_counts = 0;
1398
1399               if (ungetc (firstchar, da_file) == EOF)
1400                 rewind (da_file);
1401               if (__read_long (&n_counts, da_file, 8) != 0)
1402                 {
1403                   fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1404                            ptr->filename);
1405                   continue;
1406                 }
1407
1408               if (n_counts == ptr->ncounts)
1409                 {
1410                   int i;
1411
1412                   for (i = 0; i < n_counts; i++)
1413                     {
1414                       long v = 0;
1415
1416                       if (__read_long (&v, da_file, 8) != 0)
1417                         {
1418                           fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1419                                    ptr->filename);
1420                           break;
1421                         }
1422                       ptr->counts[i] += v;
1423                     }
1424                 }
1425
1426             }
1427
1428           rewind (da_file);
1429
1430           /* ??? Should first write a header to the file.  Preferably, a 4 byte
1431              magic number, 4 bytes containing the time the program was
1432              compiled, 4 bytes containing the last modification time of the
1433              source file, and 4 bytes indicating the compiler options used.
1434
1435              That way we can easily verify that the proper source/executable/
1436              data file combination is being used from gcov.  */
1437
1438           if (__write_long (ptr->ncounts, da_file, 8) != 0)
1439             {
1440
1441               fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1442                        ptr->filename);
1443             }
1444           else
1445             {
1446               int j;
1447               long *count_ptr = ptr->counts;
1448               int ret = 0;
1449               for (j = ptr->ncounts; j > 0; j--)
1450                 {
1451                   if (__write_long (*count_ptr, da_file, 8) != 0)
1452                     {
1453                       ret=1;
1454                       break;
1455                     }
1456                   count_ptr++;
1457                 }
1458               if (ret)
1459                 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1460                          ptr->filename);
1461             }
1462
1463           if (fclose (da_file) == EOF)
1464             fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1465                      ptr->filename);
1466         }
1467
1468       return;
1469     }
1470
1471   /* Must be basic block profiling.  Emit a human readable output file.  */
1472
1473   file = fopen ("bb.out", "a");
1474
1475   if (!file)
1476     perror ("bb.out");
1477
1478   else
1479     {
1480       struct bb *ptr;
1481
1482       /* This is somewhat type incorrect, but it avoids worrying about
1483          exactly where time.h is included from.  It should be ok unless
1484          a void * differs from other pointer formats, or if sizeof (long)
1485          is < sizeof (time_t).  It would be nice if we could assume the
1486          use of rationale standards here.  */
1487
1488       time ((void *) &time_value);
1489       fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));
1490
1491       /* We check the length field explicitly in order to allow compatibility
1492          with older GCC's which did not provide it.  */
1493
1494       for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1495         {
1496           int i;
1497           int func_p    = (ptr->nwords >= (long) sizeof (struct bb)
1498                            && ptr->nwords <= 1000
1499                            && ptr->functions);
1500           int line_p    = (func_p && ptr->line_nums);
1501           int file_p    = (func_p && ptr->filenames);
1502           int addr_p    = (ptr->addresses != 0);
1503           long ncounts  = ptr->ncounts;
1504           long cnt_max  = 0;
1505           long line_max = 0;
1506           long addr_max = 0;
1507           int file_len  = 0;
1508           int func_len  = 0;
1509           int blk_len   = num_digits (ncounts, 10);
1510           int cnt_len;
1511           int line_len;
1512           int addr_len;
1513
1514           fprintf (file, "File %s, %ld basic blocks \n\n",
1515                    ptr->filename, ncounts);
1516
1517           /* Get max values for each field.  */
1518           for (i = 0; i < ncounts; i++)
1519             {
1520               const char *p;
1521               int len;
1522
1523               if (cnt_max < ptr->counts[i])
1524                 cnt_max = ptr->counts[i];
1525
1526               if (addr_p && (unsigned long) addr_max < ptr->addresses[i])
1527                 addr_max = ptr->addresses[i];
1528
1529               if (line_p && line_max < ptr->line_nums[i])
1530                 line_max = ptr->line_nums[i];
1531
1532               if (func_p)
1533                 {
1534                   p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
1535                   len = strlen (p);
1536                   if (func_len < len)
1537                     func_len = len;
1538                 }
1539
1540               if (file_p)
1541                 {
1542                   p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
1543                   len = strlen (p);
1544                   if (file_len < len)
1545                     file_len = len;
1546                 }
1547             }
1548
1549           addr_len = num_digits (addr_max, 16);
1550           cnt_len  = num_digits (cnt_max, 10);
1551           line_len = num_digits (line_max, 10);
1552
1553           /* Now print out the basic block information.  */
1554           for (i = 0; i < ncounts; i++)
1555             {
1556               fprintf (file,
1557                        "    Block #%*d: executed %*ld time(s)",
1558                        blk_len, i+1,
1559                        cnt_len, ptr->counts[i]);
1560
1561               if (addr_p)
1562                 fprintf (file, " address= 0x%.*lx", addr_len,
1563                          ptr->addresses[i]);
1564
1565               if (func_p)
1566                 fprintf (file, " function= %-*s", func_len,
1567                          (ptr->functions[i]) ? ptr->functions[i] : "<none>");
1568
1569               if (line_p)
1570                 fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);
1571
1572               if (file_p)
1573                 fprintf (file, " file= %s",
1574                          (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");
1575
1576               fprintf (file, "\n");
1577             }
1578
1579           fprintf (file, "\n");
1580           fflush (file);
1581         }
1582
1583       fprintf (file, "\n\n");
1584       fclose (file);
1585     }
1586 }
1587
1588 void
1589 __bb_init_func (struct bb *blocks)
1590 {
1591   /* User is supposed to check whether the first word is non-0,
1592      but just in case....  */
1593
1594   if (blocks->zero_word)
1595     return;
1596
1597   /* Initialize destructor.  */
1598   if (!bb_head)
1599     atexit (__bb_exit_func);
1600
1601   /* Set up linked list.  */
1602   blocks->zero_word = 1;
1603   blocks->next = bb_head;
1604   bb_head = blocks;
1605 }
1606
1607 /* Called before fork or exec - write out profile information gathered so
1608    far and reset it to zero.  This avoids duplication or loss of the
1609    profile information gathered so far.  */
1610 void
1611 __bb_fork_func (void)
1612 {
1613   struct bb *ptr;
1614
1615   __bb_exit_func ();
1616   for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1617     {
1618       long i;
1619       for (i = ptr->ncounts - 1; i >= 0; i--)
1620         ptr->counts[i] = 0;
1621     }
1622 }
1623
1624 #ifndef MACHINE_STATE_SAVE
1625 #define MACHINE_STATE_SAVE(ID)
1626 #endif
1627 #ifndef MACHINE_STATE_RESTORE
1628 #define MACHINE_STATE_RESTORE(ID)
1629 #endif
1630
1631 /* Number of buckets in hashtable of basic block addresses.  */
1632
1633 #define BB_BUCKETS 311
1634
1635 /* Maximum length of string in file bb.in.  */
1636
1637 #define BBINBUFSIZE 500
1638
1639 struct bb_edge
1640 {
1641   struct bb_edge *next;
1642   unsigned long src_addr;
1643   unsigned long dst_addr;
1644   unsigned long count;
1645 };
1646
1647 enum bb_func_mode
1648 {
1649   TRACE_KEEP = 0, TRACE_ON = 1, TRACE_OFF = 2
1650 };
1651
1652 struct bb_func
1653 {
1654   struct bb_func *next;
1655   char *funcname;
1656   char *filename;
1657   enum bb_func_mode mode;
1658 };
1659
1660 /* This is the connection to the outside world.
1661    The BLOCK_PROFILER macro must set __bb.blocks
1662    and __bb.blockno.  */
1663
1664 struct {
1665   unsigned long blockno;
1666   struct bb *blocks;
1667 } __bb;
1668
1669 /* Vars to store addrs of source and destination basic blocks
1670    of a jump.  */
1671
1672 static unsigned long bb_src = 0;
1673 static unsigned long bb_dst = 0;
1674
1675 static FILE *bb_tracefile = (FILE *) 0;
1676 static struct bb_edge **bb_hashbuckets = (struct bb_edge **) 0;
1677 static struct bb_func *bb_func_head = (struct bb_func *) 0;
1678 static unsigned long bb_callcount = 0;
1679 static int bb_mode = 0;
1680
1681 static unsigned long *bb_stack = (unsigned long *) 0;
1682 static size_t bb_stacksize = 0;
1683
1684 static int reported = 0;
1685
1686 /* Trace modes:
1687 Always             :   Print execution frequencies of basic blocks
1688                        to file bb.out.
1689 bb_mode & 1 != 0   :   Dump trace of basic blocks to file bbtrace[.gz]
1690 bb_mode & 2 != 0   :   Print jump frequencies to file bb.out.
1691 bb_mode & 4 != 0   :   Cut call instructions from basic block flow.
1692 bb_mode & 8 != 0   :   Insert return instructions in basic block flow.
1693 */
1694
1695 #ifdef HAVE_POPEN
1696
1697 /*#include <sys/types.h>*/
1698 #include <sys/stat.h>
1699 /*#include <malloc.h>*/
1700
1701 /* Commands executed by gopen.  */
1702
1703 #define GOPENDECOMPRESS "gzip -cd "
1704 #define GOPENCOMPRESS "gzip -c >"
1705
1706 /* Like fopen but pipes through gzip.  mode may only be "r" or "w".
1707    If it does not compile, simply replace gopen by fopen and delete
1708    '.gz' from any first parameter to gopen.  */
1709
1710 static FILE *
1711 gopen (char *fn, char *mode)
1712 {
1713   int use_gzip;
1714   char *p;
1715
1716   if (mode[1])
1717     return (FILE *) 0;
1718
1719   if (mode[0] != 'r' && mode[0] != 'w')
1720     return (FILE *) 0;
1721
1722   p = fn + strlen (fn)-1;
1723   use_gzip = ((p[-1] == '.' && (p[0] == 'Z' || p[0] == 'z'))
1724               || (p[-2] == '.' && p[-1] == 'g' && p[0] == 'z'));
1725
1726   if (use_gzip)
1727     {
1728       if (mode[0]=='r')
1729         {
1730           FILE *f;
1731           char *s = (char *) malloc (sizeof (char) * strlen (fn)
1732                                      + sizeof (GOPENDECOMPRESS));
1733           strcpy (s, GOPENDECOMPRESS);
1734           strcpy (s + (sizeof (GOPENDECOMPRESS)-1), fn);
1735           f = popen (s, mode);
1736           free (s);
1737           return f;
1738         }
1739
1740       else
1741         {
1742           FILE *f;
1743           char *s = (char *) malloc (sizeof (char) * strlen (fn)
1744                                      + sizeof (GOPENCOMPRESS));
1745           strcpy (s, GOPENCOMPRESS);
1746           strcpy (s + (sizeof (GOPENCOMPRESS)-1), fn);
1747           if (!(f = popen (s, mode)))
1748             f = fopen (s, mode);
1749           free (s);
1750           return f;
1751         }
1752     }
1753
1754   else
1755     return fopen (fn, mode);
1756 }
1757
1758 static int
1759 gclose (FILE *f)
1760 {
1761   struct stat buf;
1762
1763   if (f != 0)
1764     {
1765       if (!fstat (fileno (f), &buf) && S_ISFIFO (buf.st_mode))
1766         return pclose (f);
1767
1768       return fclose (f);
1769     }
1770   return 0;
1771 }
1772
1773 #endif /* HAVE_POPEN */
1774
1775 /* Called once per program.  */
1776
1777 static void
1778 __bb_exit_trace_func (void)
1779 {
1780   FILE *file = fopen ("bb.out", "a");
1781   struct bb_func *f;
1782   struct bb *b;
1783
1784   if (!file)
1785     perror ("bb.out");
1786
1787   if (bb_mode & 1)
1788     {
1789       if (!bb_tracefile)
1790         perror ("bbtrace");
1791       else
1792 #ifdef HAVE_POPEN
1793         gclose (bb_tracefile);
1794 #else
1795         fclose (bb_tracefile);
1796 #endif /* HAVE_POPEN */
1797     }
1798
1799   /* Check functions in `bb.in'.  */
1800
1801   if (file)
1802     {
1803       long time_value;
1804       const struct bb_func *p;
1805       int printed_something = 0;
1806       struct bb *ptr;
1807       long blk;
1808
1809       /* This is somewhat type incorrect.  */
1810       time ((void *) &time_value);
1811
1812       for (p = bb_func_head; p != (struct bb_func *) 0; p = p->next)
1813         {
1814           for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1815             {
1816               if (!ptr->filename || (p->filename != (char *) 0 && strcmp (p->filename, ptr->filename)))
1817                 continue;
1818               for (blk = 0; blk < ptr->ncounts; blk++)
1819                 {
1820                   if (!strcmp (p->funcname, ptr->functions[blk]))
1821                     goto found;
1822                 }
1823             }
1824
1825           if (!printed_something)
1826             {
1827               fprintf (file, "Functions in `bb.in' not executed during basic block profiling on %s\n", ctime ((void *) &time_value));
1828               printed_something = 1;
1829             }
1830
1831           fprintf (file, "\tFunction %s", p->funcname);
1832           if (p->filename)
1833               fprintf (file, " of file %s", p->filename);
1834           fprintf (file, "\n" );
1835
1836 found:        ;
1837         }
1838
1839       if (printed_something)
1840        fprintf (file, "\n");
1841
1842     }
1843
1844   if (bb_mode & 2)
1845     {
1846       if (!bb_hashbuckets)
1847         {
1848           if (!reported)
1849             {
1850               fprintf (stderr, "Profiler: out of memory\n");
1851               reported = 1;
1852             }
1853           return;
1854         }
1855
1856       else if (file)
1857         {
1858           long time_value;
1859           int i;
1860           unsigned long addr_max = 0;
1861           unsigned long cnt_max  = 0;
1862           int cnt_len;
1863           int addr_len;
1864
1865           /* This is somewhat type incorrect, but it avoids worrying about
1866              exactly where time.h is included from.  It should be ok unless
1867              a void * differs from other pointer formats, or if sizeof (long)
1868              is < sizeof (time_t).  It would be nice if we could assume the
1869              use of rationale standards here.  */
1870
1871           time ((void *) &time_value);
1872           fprintf (file, "Basic block jump tracing");
1873
1874           switch (bb_mode & 12)
1875             {
1876               case 0:
1877                 fprintf (file, " (with call)");
1878               break;
1879
1880               case 4:
1881                 /* Print nothing.  */
1882               break;
1883
1884               case 8:
1885                 fprintf (file, " (with call & ret)");
1886               break;
1887
1888               case 12:
1889                 fprintf (file, " (with ret)");
1890               break;
1891             }
1892
1893           fprintf (file, " finished on %s\n", ctime ((void *) &time_value));
1894
1895           for (i = 0; i < BB_BUCKETS; i++)
1896             {
1897                struct bb_edge *bucket = bb_hashbuckets[i];
1898                for ( ; bucket; bucket = bucket->next )
1899                  {
1900                    if (addr_max < bucket->src_addr)
1901                      addr_max = bucket->src_addr;
1902                    if (addr_max < bucket->dst_addr)
1903                      addr_max = bucket->dst_addr;
1904                    if (cnt_max < bucket->count)
1905                      cnt_max = bucket->count;
1906                  }
1907             }
1908           addr_len = num_digits (addr_max, 16);
1909           cnt_len  = num_digits (cnt_max, 10);
1910
1911           for ( i = 0; i < BB_BUCKETS; i++)
1912             {
1913                struct bb_edge *bucket = bb_hashbuckets[i];
1914                for ( ; bucket; bucket = bucket->next )
1915                  {
1916                    fprintf (file,
1917         "Jump from block 0x%.*lx to block 0x%.*lx executed %*lu time(s)\n",
1918                             addr_len, bucket->src_addr,
1919                             addr_len, bucket->dst_addr,
1920                             cnt_len, bucket->count);
1921                  }
1922             }
1923
1924           fprintf (file, "\n");
1925
1926         }
1927     }
1928
1929    if (file)
1930      fclose (file);
1931
1932    /* Free allocated memory.  */
1933
1934    f = bb_func_head;
1935    while (f)
1936      {
1937        struct bb_func *old = f;
1938
1939        f = f->next;
1940        if (old->funcname) free (old->funcname);
1941        if (old->filename) free (old->filename);
1942        free (old);
1943      }
1944
1945    if (bb_stack)
1946      free (bb_stack);
1947
1948    if (bb_hashbuckets)
1949      {
1950        int i;
1951
1952        for (i = 0; i < BB_BUCKETS; i++)
1953          {
1954            struct bb_edge *old, *bucket = bb_hashbuckets[i];
1955
1956            while (bucket)
1957              {
1958                old = bucket;
1959                bucket = bucket->next;
1960                free (old);
1961              }
1962          }
1963        free (bb_hashbuckets);
1964      }
1965
1966    for (b = bb_head; b; b = b->next)
1967      if (b->flags) free (b->flags);
1968 }
1969
1970 /* Called once per program.  */
1971
1972 static void
1973 __bb_init_prg (void)
1974 {
1975   FILE *file;
1976   char buf[BBINBUFSIZE];
1977   const char *p;
1978   const char *pos;
1979   enum bb_func_mode m;
1980   int i;
1981
1982   /* Initialize destructor.  */
1983   atexit (__bb_exit_func);
1984
1985   if (!(file = fopen ("bb.in", "r")))
1986     return;
1987
1988   while(fgets (buf, BBINBUFSIZE, file) != 0)
1989     {
1990       i = strlen (buf);
1991       if (buf[i] == '\n')
1992         buf[i--] = '\0';
1993
1994       p = buf;
1995       if (*p == '-')
1996         {
1997           m = TRACE_OFF;
1998           p++;
1999         }
2000       else
2001         {
2002           m = TRACE_ON;
2003         }
2004       if (!strcmp (p, "__bb_trace__"))
2005         bb_mode |= 1;
2006       else if (!strcmp (p, "__bb_jumps__"))
2007         bb_mode |= 2;
2008       else if (!strcmp (p, "__bb_hidecall__"))
2009         bb_mode |= 4;
2010       else if (!strcmp (p, "__bb_showret__"))
2011         bb_mode |= 8;
2012       else
2013         {
2014           struct bb_func *f = (struct bb_func *) malloc (sizeof (struct bb_func));
2015           if (f)
2016             {
2017               unsigned long l;
2018               f->next = bb_func_head;
2019               if ((pos = strchr (p, ':')))
2020                 {
2021                   if (!(f->funcname = (char *) malloc (strlen (pos+1)+1)))
2022                     continue;
2023                   strcpy (f->funcname, pos+1);
2024                   l = pos-p;
2025                   if ((f->filename = (char *) malloc (l+1)))
2026                     {
2027                       strncpy (f->filename, p, l);
2028                       f->filename[l] = '\0';
2029                     }
2030                   else
2031                     f->filename = (char *) 0;
2032                 }
2033               else
2034                 {
2035                   if (!(f->funcname = (char *) malloc (strlen (p)+1)))
2036                     continue;
2037                   strcpy (f->funcname, p);
2038                   f->filename = (char *) 0;
2039                 }
2040               f->mode = m;
2041               bb_func_head = f;
2042             }
2043          }
2044     }
2045   fclose (file);
2046
2047 #ifdef HAVE_POPEN
2048
2049   if (bb_mode & 1)
2050       bb_tracefile = gopen ("bbtrace.gz", "w");
2051
2052 #else
2053
2054   if (bb_mode & 1)
2055       bb_tracefile = fopen ("bbtrace", "w");
2056
2057 #endif /* HAVE_POPEN */
2058
2059   if (bb_mode & 2)
2060     {
2061       bb_hashbuckets = (struct bb_edge **)
2062                    malloc (BB_BUCKETS * sizeof (struct bb_edge *));
2063       if (bb_hashbuckets)
2064         /* Use a loop here rather than calling bzero to avoid having to
2065            conditionalize its existance.  */
2066         for (i = 0; i < BB_BUCKETS; i++)
2067           bb_hashbuckets[i] = 0;
2068     }
2069
2070   if (bb_mode & 12)
2071     {
2072       bb_stacksize = 10;
2073       bb_stack = (unsigned long *) malloc (bb_stacksize * sizeof (*bb_stack));
2074     }
2075
2076   /* Initialize destructor.  */
2077   atexit (__bb_exit_trace_func);
2078 }
2079
2080 /* Called upon entering a basic block.  */
2081
2082 void
2083 __bb_trace_func (void)
2084 {
2085   struct bb_edge *bucket;
2086
2087   MACHINE_STATE_SAVE("1")
2088
2089   if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
2090     goto skip;
2091
2092   bb_dst = __bb.blocks->addresses[__bb.blockno];
2093   __bb.blocks->counts[__bb.blockno]++;
2094
2095   if (bb_tracefile)
2096     {
2097       fwrite (&bb_dst, sizeof (unsigned long), 1, bb_tracefile);
2098     }
2099
2100   if (bb_hashbuckets)
2101     {
2102       struct bb_edge **startbucket, **oldnext;
2103
2104       oldnext = startbucket
2105         = & bb_hashbuckets[ (((int) bb_src*8) ^ (int) bb_dst) % BB_BUCKETS ];
2106       bucket = *startbucket;
2107
2108       for (bucket = *startbucket; bucket;
2109            oldnext = &(bucket->next), bucket = *oldnext)
2110         {
2111           if (bucket->src_addr == bb_src
2112               && bucket->dst_addr == bb_dst)
2113             {
2114               bucket->count++;
2115               *oldnext = bucket->next;
2116               bucket->next = *startbucket;
2117               *startbucket = bucket;
2118               goto ret;
2119             }
2120         }
2121
2122       bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));
2123
2124       if (!bucket)
2125         {
2126           if (!reported)
2127             {
2128               fprintf (stderr, "Profiler: out of memory\n");
2129               reported = 1;
2130             }
2131         }
2132
2133       else
2134         {
2135           bucket->src_addr = bb_src;
2136           bucket->dst_addr = bb_dst;
2137           bucket->next = *startbucket;
2138           *startbucket = bucket;
2139           bucket->count = 1;
2140         }
2141     }
2142
2143 ret:
2144   bb_src = bb_dst;
2145
2146 skip:
2147   ;
2148
2149   MACHINE_STATE_RESTORE("1")
2150
2151 }
2152
2153 /* Called when returning from a function and `__bb_showret__' is set.  */
2154
2155 static void
2156 __bb_trace_func_ret (void)
2157 {
2158   struct bb_edge *bucket;
2159
2160   if (!bb_callcount || (__bb.blocks->flags && (__bb.blocks->flags[__bb.blockno] & TRACE_OFF)))
2161     goto skip;
2162
2163   if (bb_hashbuckets)
2164     {
2165       struct bb_edge **startbucket, **oldnext;
2166
2167       oldnext = startbucket
2168         = & bb_hashbuckets[ (((int) bb_dst * 8) ^ (int) bb_src) % BB_BUCKETS ];
2169       bucket = *startbucket;
2170
2171       for (bucket = *startbucket; bucket;
2172            oldnext = &(bucket->next), bucket = *oldnext)
2173         {
2174           if (bucket->src_addr == bb_dst
2175                && bucket->dst_addr == bb_src)
2176             {
2177               bucket->count++;
2178               *oldnext = bucket->next;
2179               bucket->next = *startbucket;
2180               *startbucket = bucket;
2181               goto ret;
2182             }
2183         }
2184
2185       bucket = (struct bb_edge *) malloc (sizeof (struct bb_edge));
2186
2187       if (!bucket)
2188         {
2189           if (!reported)
2190             {
2191               fprintf (stderr, "Profiler: out of memory\n");
2192               reported = 1;
2193             }
2194         }
2195
2196       else
2197         {
2198           bucket->src_addr = bb_dst;
2199           bucket->dst_addr = bb_src;
2200           bucket->next = *startbucket;
2201           *startbucket = bucket;
2202           bucket->count = 1;
2203         }
2204     }
2205
2206 ret:
2207   bb_dst = bb_src;
2208
2209 skip:
2210   ;
2211
2212 }
2213
2214 /* Called upon entering the first function of a file.  */
2215
2216 static void
2217 __bb_init_file (struct bb *blocks)
2218 {
2219
2220   const struct bb_func *p;
2221   long blk, ncounts = blocks->ncounts;
2222   const char **functions = blocks->functions;
2223
2224   /* Set up linked list.  */
2225   blocks->zero_word = 1;
2226   blocks->next = bb_head;
2227   bb_head = blocks;
2228
2229   blocks->flags = 0;
2230   if (!bb_func_head
2231       || !(blocks->flags = (char *) malloc (sizeof (char) * blocks->ncounts)))
2232     return;
2233
2234   for (blk = 0; blk < ncounts; blk++)
2235     blocks->flags[blk] = 0;
2236
2237   for (blk = 0; blk < ncounts; blk++)
2238     {
2239       for (p = bb_func_head; p; p = p->next)
2240         {
2241           if (!strcmp (p->funcname, functions[blk])
2242               && (!p->filename || !strcmp (p->filename, blocks->filename)))
2243             {
2244               blocks->flags[blk] |= p->mode;
2245             }
2246         }
2247     }
2248
2249 }
2250
2251 /* Called when exiting from a function.  */
2252
2253 void
2254 __bb_trace_ret (void)
2255 {
2256
2257   MACHINE_STATE_SAVE("2")
2258
2259   if (bb_callcount)
2260     {
2261       if ((bb_mode & 12) && bb_stacksize > bb_callcount)
2262         {
2263           bb_src = bb_stack[bb_callcount];
2264           if (bb_mode & 8)
2265             __bb_trace_func_ret ();
2266         }
2267
2268       bb_callcount -= 1;
2269     }
2270
2271   MACHINE_STATE_RESTORE("2")
2272
2273 }
2274
2275 /* Called when entering a function.  */
2276
2277 void
2278 __bb_init_trace_func (struct bb *blocks, unsigned long blockno)
2279 {
2280   static int trace_init = 0;
2281
2282   MACHINE_STATE_SAVE("3")
2283
2284   if (!blocks->zero_word)
2285     {
2286       if (!trace_init)
2287         {
2288           trace_init = 1;
2289           __bb_init_prg ();
2290         }
2291       __bb_init_file (blocks);
2292     }
2293
2294   if (bb_callcount)
2295     {
2296
2297       bb_callcount += 1;
2298
2299       if (bb_mode & 12)
2300         {
2301           if (bb_callcount >= bb_stacksize)
2302             {
2303               size_t newsize = bb_callcount + 100;
2304
2305               bb_stack = (unsigned long *) realloc (bb_stack, newsize);
2306               if (! bb_stack)
2307                 {
2308                   if (!reported)
2309                     {
2310                       fprintf (stderr, "Profiler: out of memory\n");
2311                       reported = 1;
2312                     }
2313                   bb_stacksize = 0;
2314                   goto stack_overflow;
2315                 }
2316               bb_stacksize = newsize;
2317             }
2318           bb_stack[bb_callcount] = bb_src;
2319
2320           if (bb_mode & 4)
2321             bb_src = 0;
2322
2323         }
2324
2325 stack_overflow:;
2326
2327     }
2328
2329   else if (blocks->flags && (blocks->flags[blockno] & TRACE_ON))
2330     {
2331       bb_callcount = 1;
2332       bb_src = 0;
2333
2334       if (bb_stack)
2335           bb_stack[bb_callcount] = bb_src;
2336     }
2337
2338   MACHINE_STATE_RESTORE("3")
2339 }
2340
2341 #endif /* not inhibit_libc */
2342 #endif /* not BLOCK_PROFILER_CODE */
2343 #endif /* L_bb */
2344 \f
2345 #ifdef L_clear_cache
2346 /* Clear part of an instruction cache.  */
2347
2348 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
2349
2350 void
2351 __clear_cache (char *beg __attribute__((__unused__)),
2352                char *end __attribute__((__unused__)))
2353 {
2354 #ifdef CLEAR_INSN_CACHE
2355   CLEAR_INSN_CACHE (beg, end);
2356 #else
2357 #ifdef INSN_CACHE_SIZE
2358   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
2359   static int initialized;
2360   int offset;
2361   void *start_addr
2362   void *end_addr;
2363   typedef (*function_ptr) (void);
2364
2365 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
2366   /* It's cheaper to clear the whole cache.
2367      Put in a series of jump instructions so that calling the beginning
2368      of the cache will clear the whole thing.  */
2369
2370   if (! initialized)
2371     {
2372       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2373                  & -INSN_CACHE_LINE_WIDTH);
2374       int end_ptr = ptr + INSN_CACHE_SIZE;
2375
2376       while (ptr < end_ptr)
2377         {
2378           *(INSTRUCTION_TYPE *)ptr
2379             = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
2380           ptr += INSN_CACHE_LINE_WIDTH;
2381         }
2382       *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
2383
2384       initialized = 1;
2385     }
2386
2387   /* Call the beginning of the sequence.  */
2388   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2389                     & -INSN_CACHE_LINE_WIDTH))
2390    ());
2391
2392 #else /* Cache is large.  */
2393
2394   if (! initialized)
2395     {
2396       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
2397                  & -INSN_CACHE_LINE_WIDTH);
2398
2399       while (ptr < (int) array + sizeof array)
2400         {
2401           *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
2402           ptr += INSN_CACHE_LINE_WIDTH;
2403         }
2404
2405       initialized = 1;
2406     }
2407
2408   /* Find the location in array that occupies the same cache line as BEG.  */
2409
2410   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
2411   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
2412                  & -INSN_CACHE_PLANE_SIZE)
2413                 + offset);
2414
2415   /* Compute the cache alignment of the place to stop clearing.  */
2416 #if 0  /* This is not needed for gcc's purposes.  */
2417   /* If the block to clear is bigger than a cache plane,
2418      we clear the entire cache, and OFFSET is already correct.  */
2419   if (end < beg + INSN_CACHE_PLANE_SIZE)
2420 #endif
2421     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
2422                & -INSN_CACHE_LINE_WIDTH)
2423               & (INSN_CACHE_PLANE_SIZE - 1));
2424
2425 #if INSN_CACHE_DEPTH > 1
2426   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
2427   if (end_addr <= start_addr)
2428     end_addr += INSN_CACHE_PLANE_SIZE;
2429
2430   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
2431     {
2432       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
2433       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
2434
2435       while (addr != stop)
2436         {
2437           /* Call the return instruction at ADDR.  */
2438           ((function_ptr) addr) ();
2439
2440           addr += INSN_CACHE_LINE_WIDTH;
2441         }
2442     }
2443 #else /* just one plane */
2444   do
2445     {
2446       /* Call the return instruction at START_ADDR.  */
2447       ((function_ptr) start_addr) ();
2448
2449       start_addr += INSN_CACHE_LINE_WIDTH;
2450     }
2451   while ((start_addr % INSN_CACHE_SIZE) != offset);
2452 #endif /* just one plane */
2453 #endif /* Cache is large */
2454 #endif /* Cache exists */
2455 #endif /* CLEAR_INSN_CACHE */
2456 }
2457
2458 #endif /* L_clear_cache */
2459 \f
2460 #ifdef L_trampoline
2461
2462 /* Jump to a trampoline, loading the static chain address.  */
2463
2464 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
2465
2466 long
2467 getpagesize (void)
2468 {
2469 #ifdef _ALPHA_
2470   return 8192;
2471 #else
2472   return 4096;
2473 #endif
2474 }
2475
2476 #ifdef __i386__
2477 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
2478 #endif
2479
2480 int
2481 mprotect (char *addr, int len, int prot)
2482 {
2483   int np, op;
2484
2485   if (prot == 7)
2486     np = 0x40;
2487   else if (prot == 5)
2488     np = 0x20;
2489   else if (prot == 4)
2490     np = 0x10;
2491   else if (prot == 3)
2492     np = 0x04;
2493   else if (prot == 1)
2494     np = 0x02;
2495   else if (prot == 0)
2496     np = 0x01;
2497
2498   if (VirtualProtect (addr, len, np, &op))
2499     return 0;
2500   else
2501     return -1;
2502 }
2503
2504 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
2505
2506 #ifdef TRANSFER_FROM_TRAMPOLINE
2507 TRANSFER_FROM_TRAMPOLINE
2508 #endif
2509
2510 #if defined (NeXT) && defined (__MACH__)
2511
2512 /* Make stack executable so we can call trampolines on stack.
2513    This is called from INITIALIZE_TRAMPOLINE in next.h.  */
2514 #ifdef NeXTStep21
2515  #include <mach.h>
2516 #else
2517  #include <mach/mach.h>
2518 #endif
2519
2520 void
2521 __enable_execute_stack (char *addr)
2522 {
2523   kern_return_t r;
2524   char *eaddr = addr + TRAMPOLINE_SIZE;
2525   vm_address_t a = (vm_address_t) addr;
2526
2527   /* turn on execute access on stack */
2528   r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
2529   if (r != KERN_SUCCESS)
2530     {
2531       mach_error("vm_protect VM_PROT_ALL", r);
2532       exit(1);
2533     }
2534
2535   /* We inline the i-cache invalidation for speed */
2536
2537 #ifdef CLEAR_INSN_CACHE
2538   CLEAR_INSN_CACHE (addr, eaddr);
2539 #else
2540   __clear_cache ((int) addr, (int) eaddr);
2541 #endif
2542 }
2543
2544 #endif /* defined (NeXT) && defined (__MACH__) */
2545
2546 #ifdef __convex__
2547
2548 /* Make stack executable so we can call trampolines on stack.
2549    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
2550
2551 #include <sys/mman.h>
2552 #include <sys/vmparam.h>
2553 #include <machine/machparam.h>
2554
2555 void
2556 __enable_execute_stack (void)
2557 {
2558   int fp;
2559   static unsigned lowest = USRSTACK;
2560   unsigned current = (unsigned) &fp & -NBPG;
2561
2562   if (lowest > current)
2563     {
2564       unsigned len = lowest - current;
2565       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
2566       lowest = current;
2567     }
2568
2569   /* Clear instruction cache in case an old trampoline is in it.  */
2570   asm ("pich");
2571 }
2572 #endif /* __convex__ */
2573
2574 #ifdef __sysV88__
2575
2576 /* Modified from the convex -code above.  */
2577
2578 #include <sys/param.h>
2579 #include <errno.h>
2580 #include <sys/m88kbcs.h>
2581
2582 void
2583 __enable_execute_stack (void)
2584 {
2585   int save_errno;
2586   static unsigned long lowest = USRSTACK;
2587   unsigned long current = (unsigned long) &save_errno & -NBPC;
2588
2589   /* Ignore errno being set. memctl sets errno to EINVAL whenever the
2590      address is seen as 'negative'. That is the case with the stack.   */
2591
2592   save_errno=errno;
2593   if (lowest > current)
2594     {
2595       unsigned len=lowest-current;
2596       memctl(current,len,MCT_TEXT);
2597       lowest = current;
2598     }
2599   else
2600     memctl(current,NBPC,MCT_TEXT);
2601   errno=save_errno;
2602 }
2603
2604 #endif /* __sysV88__ */
2605
2606 #ifdef __sysV68__
2607
2608 #include <sys/signal.h>
2609 #include <errno.h>
2610
2611 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
2612    so define it here, because we need it in __clear_insn_cache below */
2613 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
2614    hence we enable this stuff only if MCT_TEXT is #define'd.  */
2615
2616 #ifdef MCT_TEXT
2617 asm("\n\
2618         global memctl\n\
2619 memctl:\n\
2620         movq &75,%d0\n\
2621         trap &0\n\
2622         bcc.b noerror\n\
2623         jmp cerror%\n\
2624 noerror:\n\
2625         movq &0,%d0\n\
2626         rts");
2627 #endif
2628
2629 /* Clear instruction cache so we can call trampolines on stack.
2630    This is called from FINALIZE_TRAMPOLINE in mot3300.h.  */
2631
2632 void
2633 __clear_insn_cache (void)
2634 {
2635 #ifdef MCT_TEXT
2636   int save_errno;
2637
2638   /* Preserve errno, because users would be surprised to have
2639   errno changing without explicitly calling any system-call. */
2640   save_errno = errno;
2641
2642   /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
2643      No need to use an address derived from _start or %sp, as 0 works also. */
2644   memctl(0, 4096, MCT_TEXT);
2645   errno = save_errno;
2646 #endif
2647 }
2648
2649 #endif /* __sysV68__ */
2650
2651 #ifdef __pyr__
2652
2653 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
2654 #include <stdio.h>
2655 #include <sys/mman.h>
2656 #include <sys/types.h>
2657 #include <sys/param.h>
2658 #include <sys/vmmac.h>
2659
2660 /* Modified from the convex -code above.
2661    mremap promises to clear the i-cache.  */
2662
2663 void
2664 __enable_execute_stack (void)
2665 {
2666   int fp;
2667   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
2668                 PROT_READ|PROT_WRITE|PROT_EXEC))
2669     {
2670       perror ("mprotect in __enable_execute_stack");
2671       fflush (stderr);
2672       abort ();
2673     }
2674 }
2675 #endif /* __pyr__ */
2676
2677 #if defined (sony_news) && defined (SYSTYPE_BSD)
2678
2679 #include <stdio.h>
2680 #include <sys/types.h>
2681 #include <sys/param.h>
2682 #include <syscall.h>
2683 #include <machine/sysnews.h>
2684
2685 /* cacheflush function for NEWS-OS 4.2.
2686    This function is called from trampoline-initialize code
2687    defined in config/mips/mips.h.  */
2688
2689 void
2690 cacheflush (char *beg, int size, int flag)
2691 {
2692   if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
2693     {
2694       perror ("cache_flush");
2695       fflush (stderr);
2696       abort ();
2697     }
2698 }
2699
2700 #endif /* sony_news */
2701 #endif /* L_trampoline */
2702 \f
2703 #ifndef __CYGWIN__
2704 #ifdef L__main
2705
2706 #include "gbl-ctors.h"
2707 /* Some systems use __main in a way incompatible with its use in gcc, in these
2708    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2709    give the same symbol without quotes for an alternative entry point.  You
2710    must define both, or neither.  */
2711 #ifndef NAME__MAIN
2712 #define NAME__MAIN "__main"
2713 #define SYMBOL__MAIN __main
2714 #endif
2715
2716 #ifdef INIT_SECTION_ASM_OP
2717 #undef HAS_INIT_SECTION
2718 #define HAS_INIT_SECTION
2719 #endif
2720
2721 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2722
2723 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2724    code to run constructors.  In that case, we need to handle EH here, too.  */
2725
2726 #ifdef EH_FRAME_SECTION
2727 #include "unwind-dw2-fde.h"
2728 extern unsigned char __EH_FRAME_BEGIN__[];
2729 #endif
2730
2731 /* Run all the global destructors on exit from the program.  */
2732
2733 void
2734 __do_global_dtors (void)
2735 {
2736 #ifdef DO_GLOBAL_DTORS_BODY
2737   DO_GLOBAL_DTORS_BODY;
2738 #else
2739   static func_ptr *p = __DTOR_LIST__ + 1;
2740   while (*p)
2741     {
2742       p++;
2743       (*(p-1)) ();
2744     }
2745 #endif
2746 #if defined (EH_FRAME_SECTION) && !defined (HAS_INIT_SECTION)
2747   {
2748     static int completed = 0;
2749     if (! completed)
2750       {
2751         completed = 1;
2752         __deregister_frame_info (__EH_FRAME_BEGIN__);
2753       }
2754   }
2755 #endif
2756 }
2757 #endif
2758
2759 #ifndef HAS_INIT_SECTION
2760 /* Run all the global constructors on entry to the program.  */
2761
2762 void
2763 __do_global_ctors (void)
2764 {
2765 #ifdef EH_FRAME_SECTION
2766   {
2767     static struct object object;
2768     __register_frame_info (__EH_FRAME_BEGIN__, &object);
2769   }
2770 #endif
2771   DO_GLOBAL_CTORS_BODY;
2772   atexit (__do_global_dtors);
2773 }
2774 #endif /* no HAS_INIT_SECTION */
2775
2776 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2777 /* Subroutine called automatically by `main'.
2778    Compiling a global function named `main'
2779    produces an automatic call to this function at the beginning.
2780
2781    For many systems, this routine calls __do_global_ctors.
2782    For systems which support a .init section we use the .init section
2783    to run __do_global_ctors, so we need not do anything here.  */
2784
2785 void
2786 SYMBOL__MAIN ()
2787 {
2788   /* Support recursive calls to `main': run initializers just once.  */
2789   static int initialized;
2790   if (! initialized)
2791     {
2792       initialized = 1;
2793       __do_global_ctors ();
2794     }
2795 }
2796 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2797
2798 #endif /* L__main */
2799 #endif /* __CYGWIN__ */
2800 \f
2801 #ifdef L_ctors
2802
2803 #include "gbl-ctors.h"
2804
2805 /* Provide default definitions for the lists of constructors and
2806    destructors, so that we don't get linker errors.  These symbols are
2807    intentionally bss symbols, so that gld and/or collect will provide
2808    the right values.  */
2809
2810 /* We declare the lists here with two elements each,
2811    so that they are valid empty lists if no other definition is loaded.
2812
2813    If we are using the old "set" extensions to have the gnu linker
2814    collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2815    must be in the bss/common section.
2816
2817    Long term no port should use those extensions.  But many still do.  */
2818 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2819 #if defined (ASM_OUTPUT_CONSTRUCTOR) || defined (USE_COLLECT2)
2820 func_ptr __CTOR_LIST__[2] = {0, 0};
2821 func_ptr __DTOR_LIST__[2] = {0, 0};
2822 #else
2823 func_ptr __CTOR_LIST__[2];
2824 func_ptr __DTOR_LIST__[2];
2825 #endif
2826 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2827 #endif /* L_ctors */
2828 \f
2829 #ifdef L_exit
2830
2831 #include "gbl-ctors.h"
2832
2833 #ifdef NEED_ATEXIT
2834
2835 #ifndef ON_EXIT
2836
2837 # include <errno.h>
2838
2839 static func_ptr *atexit_chain = 0;
2840 static long atexit_chain_length = 0;
2841 static volatile long last_atexit_chain_slot = -1;
2842
2843 int
2844 atexit (func_ptr func)
2845 {
2846   if (++last_atexit_chain_slot == atexit_chain_length)
2847     {
2848       atexit_chain_length += 32;
2849       if (atexit_chain)
2850         atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
2851                                              * sizeof (func_ptr));
2852       else
2853         atexit_chain = (func_ptr *) malloc (atexit_chain_length
2854                                             * sizeof (func_ptr));
2855       if (! atexit_chain)
2856         {
2857           atexit_chain_length = 0;
2858           last_atexit_chain_slot = -1;
2859           errno = ENOMEM;
2860           return (-1);
2861         }
2862     }
2863   atexit_chain[last_atexit_chain_slot] = func;
2864   return (0);
2865 }
2866
2867 extern void _cleanup (void);
2868 extern void _exit (int) __attribute__ ((__noreturn__));
2869
2870 void
2871 exit (int status)
2872 {
2873   if (atexit_chain)
2874     {
2875       for ( ; last_atexit_chain_slot-- >= 0; )
2876         {
2877           (*atexit_chain[last_atexit_chain_slot + 1]) ();
2878           atexit_chain[last_atexit_chain_slot + 1] = 0;
2879         }
2880       free (atexit_chain);
2881       atexit_chain = 0;
2882     }
2883 #ifdef EXIT_BODY
2884   EXIT_BODY;
2885 #else
2886   _cleanup ();
2887 #endif
2888   _exit (status);
2889 }
2890
2891 #else /* ON_EXIT */
2892
2893 /* Simple; we just need a wrapper for ON_EXIT.  */
2894 int
2895 atexit (func_ptr func)
2896 {
2897   return ON_EXIT (func);
2898 }
2899
2900 #endif /* ON_EXIT */
2901 #endif /* NEED_ATEXIT */
2902
2903 #endif /* L_exit */