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 GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 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 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  23 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  24 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  25 for more details.
  26
  27 You should have received a copy of the GNU General Public License
  28 along with GCC; see the file COPYING.  If not, write to the Free
  29 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  30 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 /* GCC guarantees this header exists at this point.  */
1071 #include <float.h>
1072
1073 #define DF_SIZE DBL_MANT_DIG
1074 #define SF_SIZE FLT_MANT_DIG
1075
1076 SFtype
1077 __floatdisf (DWtype u)
1078 {
1079   /* Do the calculation in DFmode
1080      so that we don't lose any of the precision of the high word
1081      while multiplying it.  */
1082   DFtype f;
1083
1084   /* Protect against double-rounding error.
1085      Represent any low-order bits, that might be truncated in DFmode,
1086      by a bit that won't be lost.  The bit can go in anywhere below the
1087      rounding position of the SFmode.  A fixed mask and bit position
1088      handles all usual configurations.  It doesn't handle the case
1089      of 128-bit DImode, however.  */
1090   if (DF_SIZE < DI_SIZE
1091       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1092     {
1093 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1094       if (! (- ((DWtype) 1 << DF_SIZE) < u
1095              && u < ((DWtype) 1 << DF_SIZE)))
1096         {
1097           if ((UDWtype) u & (REP_BIT - 1))
1098             u |= REP_BIT;
1099         }
1100     }
1101   f = (Wtype) (u >> WORD_SIZE);
1102   f *= HIGH_HALFWORD_COEFF;
1103   f *= HIGH_HALFWORD_COEFF;
1104   f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1105
1106   return (SFtype) f;
1107 }
1108 #endif
1109
1110 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1111 /* Reenable the normal types, in case limits.h needs them.  */
1112 #undef char
1113 #undef short
1114 #undef int
1115 #undef long
1116 #undef unsigned
1117 #undef float
1118 #undef double
1119 #undef MIN
1120 #undef MAX
1121 #include <limits.h>
1122
1123 UWtype
1124 __fixunsxfSI (XFtype a)
1125 {
1126   if (a >= - (DFtype) Wtype_MIN)
1127     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1128   return (Wtype) a;
1129 }
1130 #endif
1131
1132 #ifdef L_fixunsdfsi
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 __fixunsdfSI (DFtype 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_fixunssfsi
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 __fixunssfSI (SFtype a)
1169 {
1170   if (a >= - (SFtype) Wtype_MIN)
1171     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1172   return (Wtype) a;
1173 }
1174 #endif
1175 \f
1176 /* From here on down, the routines use normal data types.  */
1177
1178 #define SItype bogus_type
1179 #define USItype bogus_type
1180 #define DItype bogus_type
1181 #define UDItype bogus_type
1182 #define SFtype bogus_type
1183 #define DFtype bogus_type
1184 #undef Wtype
1185 #undef UWtype
1186 #undef HWtype
1187 #undef UHWtype
1188 #undef DWtype
1189 #undef UDWtype
1190
1191 #undef char
1192 #undef short
1193 #undef int
1194 #undef long
1195 #undef unsigned
1196 #undef float
1197 #undef double
1198 \f
1199 #ifdef L__gcc_bcmp
1200
1201 /* Like bcmp except the sign is meaningful.
1202    Result is negative if S1 is less than S2,
1203    positive if S1 is greater, 0 if S1 and S2 are equal.  */
1204
1205 int
1206 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1207 {
1208   while (size > 0)
1209     {
1210       unsigned char c1 = *s1++, c2 = *s2++;
1211       if (c1 != c2)
1212         return c1 - c2;
1213       size--;
1214     }
1215   return 0;
1216 }
1217
1218 #endif
1219 \f
1220 /* __eprintf used to be used by GCC's private version of <assert.h>.
1221    We no longer provide that header, but this routine remains in libgcc.a
1222    for binary backward compatibility.  Note that it is not included in
1223    the shared version of libgcc.  */
1224 #ifdef L_eprintf
1225 #ifndef inhibit_libc
1226
1227 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1228 #include <stdio.h>
1229
1230 void
1231 __eprintf (const char *string, const char *expression,
1232            unsigned int line, const char *filename)
1233 {
1234   fprintf (stderr, string, expression, line, filename);
1235   fflush (stderr);
1236   abort ();
1237 }
1238
1239 #endif
1240 #endif
1241
1242 #ifdef L_bb
1243
1244 #if LONG_TYPE_SIZE == GCOV_TYPE_SIZE
1245 typedef long gcov_type;
1246 #else
1247 typedef long long gcov_type;
1248 #endif
1249
1250
1251 /* Structure emitted by -a  */
1252 struct bb
1253 {
1254   long zero_word;
1255   const char *filename;
1256   gcov_type *counts;
1257   long ncounts;
1258   struct bb *next;
1259   const unsigned long *addresses;
1260
1261   /* Older GCC's did not emit these fields.  */
1262   long nwords;
1263   const char **functions;
1264   const long *line_nums;
1265   const char **filenames;
1266   char *flags;
1267 };
1268
1269 #ifdef BLOCK_PROFILER_CODE
1270 BLOCK_PROFILER_CODE
1271 #else
1272 #ifndef inhibit_libc
1273
1274 /* Simple minded basic block profiling output dumper for
1275    systems that don't provide tcov support.  At present,
1276    it requires atexit and stdio.  */
1277
1278 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1279 #include <stdio.h>
1280
1281 #include "gbl-ctors.h"
1282 #include "gcov-io.h"
1283 #include <string.h>
1284 #ifdef TARGET_HAS_F_SETLKW
1285 #include <fcntl.h>
1286 #include <errno.h>
1287 #endif
1288
1289 static struct bb *bb_head;
1290
1291 void
1292 __bb_exit_func (void)
1293 {
1294   FILE *da_file;
1295   int i;
1296   struct bb *ptr;
1297
1298   if (bb_head == 0)
1299     return;
1300
1301   i = strlen (bb_head->filename) - 3;
1302
1303
1304   for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1305     {
1306       int firstchar;
1307
1308       /* Make sure the output file exists -
1309          but don't clobber exiting data.  */
1310       if ((da_file = fopen (ptr->filename, "a")) != 0)
1311         fclose (da_file);
1312
1313       /* Need to re-open in order to be able to write from the start.  */
1314       da_file = fopen (ptr->filename, "r+b");
1315       /* Some old systems might not allow the 'b' mode modifier.
1316          Therefore, try to open without it.  This can lead to a race
1317          condition so that when you delete and re-create the file, the
1318          file might be opened in text mode, but then, you shouldn't
1319          delete the file in the first place.  */
1320       if (da_file == 0)
1321         da_file = fopen (ptr->filename, "r+");
1322       if (da_file == 0)
1323         {
1324           fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1325                    ptr->filename);
1326           continue;
1327         }
1328
1329       /* After a fork, another process might try to read and/or write
1330          the same file simultanously.  So if we can, lock the file to
1331          avoid race conditions.  */
1332 #if defined (TARGET_HAS_F_SETLKW)
1333       {
1334         struct flock s_flock;
1335
1336         s_flock.l_type = F_WRLCK;
1337         s_flock.l_whence = SEEK_SET;
1338         s_flock.l_start = 0;
1339         s_flock.l_len = 1;
1340         s_flock.l_pid = getpid ();
1341
1342         while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1343                && errno == EINTR);
1344       }
1345 #endif
1346
1347       /* If the file is not empty, and the number of counts in it is the
1348          same, then merge them in.  */
1349       firstchar = fgetc (da_file);
1350       if (firstchar == EOF)
1351         {
1352           if (ferror (da_file))
1353             {
1354               fprintf (stderr, "arc profiling: Can't read output file ");
1355               perror (ptr->filename);
1356             }
1357         }
1358       else
1359         {
1360           long n_counts = 0;
1361
1362           if (ungetc (firstchar, da_file) == EOF)
1363             rewind (da_file);
1364           if (__read_long (&n_counts, da_file, 8) != 0)
1365             {
1366               fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1367                        ptr->filename);
1368               continue;
1369             }
1370
1371           if (n_counts == ptr->ncounts)
1372             {
1373               int i;
1374
1375               for (i = 0; i < n_counts; i++)
1376                 {
1377                   gcov_type v = 0;
1378
1379                   if (__read_gcov_type (&v, da_file, 8) != 0)
1380                     {
1381                       fprintf (stderr,
1382                                "arc profiling: Can't read output file %s.\n",
1383                                ptr->filename);
1384                       break;
1385                     }
1386                   ptr->counts[i] += v;
1387                 }
1388             }
1389
1390         }
1391
1392       rewind (da_file);
1393
1394       /* ??? Should first write a header to the file.  Preferably, a 4 byte
1395          magic number, 4 bytes containing the time the program was
1396          compiled, 4 bytes containing the last modification time of the
1397          source file, and 4 bytes indicating the compiler options used.
1398
1399          That way we can easily verify that the proper source/executable/
1400          data file combination is being used from gcov.  */
1401
1402       if (__write_gcov_type (ptr->ncounts, da_file, 8) != 0)
1403         {
1404
1405           fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1406                    ptr->filename);
1407         }
1408       else
1409         {
1410           int j;
1411           gcov_type *count_ptr = ptr->counts;
1412           int ret = 0;
1413           for (j = ptr->ncounts; j > 0; j--)
1414             {
1415               if (__write_gcov_type (*count_ptr, da_file, 8) != 0)
1416                 {
1417                   ret = 1;
1418                   break;
1419                 }
1420               count_ptr++;
1421             }
1422           if (ret)
1423             fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1424                      ptr->filename);
1425         }
1426
1427       if (fclose (da_file) == EOF)
1428         fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1429                  ptr->filename);
1430     }
1431
1432   return;
1433 }
1434
1435 void
1436 __bb_init_func (struct bb *blocks)
1437 {
1438   /* User is supposed to check whether the first word is non-0,
1439      but just in case....  */
1440
1441   if (blocks->zero_word)
1442     return;
1443
1444   /* Initialize destructor.  */
1445   if (!bb_head)
1446     atexit (__bb_exit_func);
1447
1448   /* Set up linked list.  */
1449   blocks->zero_word = 1;
1450   blocks->next = bb_head;
1451   bb_head = blocks;
1452 }
1453
1454 /* Called before fork or exec - write out profile information gathered so
1455    far and reset it to zero.  This avoids duplication or loss of the
1456    profile information gathered so far.  */
1457 void
1458 __bb_fork_func (void)
1459 {
1460   struct bb *ptr;
1461
1462   __bb_exit_func ();
1463   for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1464     {
1465       long i;
1466       for (i = ptr->ncounts - 1; i >= 0; i--)
1467         ptr->counts[i] = 0;
1468     }
1469 }
1470
1471 #endif /* not inhibit_libc */
1472 #endif /* not BLOCK_PROFILER_CODE */
1473 #endif /* L_bb */
1474 \f
1475 #ifdef L_clear_cache
1476 /* Clear part of an instruction cache.  */
1477
1478 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1479
1480 void
1481 __clear_cache (char *beg __attribute__((__unused__)),
1482                char *end __attribute__((__unused__)))
1483 {
1484 #ifdef CLEAR_INSN_CACHE
1485   CLEAR_INSN_CACHE (beg, end);
1486 #else
1487 #ifdef INSN_CACHE_SIZE
1488   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1489   static int initialized;
1490   int offset;
1491   void *start_addr
1492   void *end_addr;
1493   typedef (*function_ptr) (void);
1494
1495 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1496   /* It's cheaper to clear the whole cache.
1497      Put in a series of jump instructions so that calling the beginning
1498      of the cache will clear the whole thing.  */
1499
1500   if (! initialized)
1501     {
1502       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1503                  & -INSN_CACHE_LINE_WIDTH);
1504       int end_ptr = ptr + INSN_CACHE_SIZE;
1505
1506       while (ptr < end_ptr)
1507         {
1508           *(INSTRUCTION_TYPE *)ptr
1509             = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1510           ptr += INSN_CACHE_LINE_WIDTH;
1511         }
1512       *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1513
1514       initialized = 1;
1515     }
1516
1517   /* Call the beginning of the sequence.  */
1518   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1519                     & -INSN_CACHE_LINE_WIDTH))
1520    ());
1521
1522 #else /* Cache is large.  */
1523
1524   if (! initialized)
1525     {
1526       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1527                  & -INSN_CACHE_LINE_WIDTH);
1528
1529       while (ptr < (int) array + sizeof array)
1530         {
1531           *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1532           ptr += INSN_CACHE_LINE_WIDTH;
1533         }
1534
1535       initialized = 1;
1536     }
1537
1538   /* Find the location in array that occupies the same cache line as BEG.  */
1539
1540   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1541   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1542                  & -INSN_CACHE_PLANE_SIZE)
1543                 + offset);
1544
1545   /* Compute the cache alignment of the place to stop clearing.  */
1546 #if 0  /* This is not needed for gcc's purposes.  */
1547   /* If the block to clear is bigger than a cache plane,
1548      we clear the entire cache, and OFFSET is already correct.  */
1549   if (end < beg + INSN_CACHE_PLANE_SIZE)
1550 #endif
1551     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1552                & -INSN_CACHE_LINE_WIDTH)
1553               & (INSN_CACHE_PLANE_SIZE - 1));
1554
1555 #if INSN_CACHE_DEPTH > 1
1556   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1557   if (end_addr <= start_addr)
1558     end_addr += INSN_CACHE_PLANE_SIZE;
1559
1560   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1561     {
1562       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1563       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1564
1565       while (addr != stop)
1566         {
1567           /* Call the return instruction at ADDR.  */
1568           ((function_ptr) addr) ();
1569
1570           addr += INSN_CACHE_LINE_WIDTH;
1571         }
1572     }
1573 #else /* just one plane */
1574   do
1575     {
1576       /* Call the return instruction at START_ADDR.  */
1577       ((function_ptr) start_addr) ();
1578
1579       start_addr += INSN_CACHE_LINE_WIDTH;
1580     }
1581   while ((start_addr % INSN_CACHE_SIZE) != offset);
1582 #endif /* just one plane */
1583 #endif /* Cache is large */
1584 #endif /* Cache exists */
1585 #endif /* CLEAR_INSN_CACHE */
1586 }
1587
1588 #endif /* L_clear_cache */
1589 \f
1590 #ifdef L_trampoline
1591
1592 /* Jump to a trampoline, loading the static chain address.  */
1593
1594 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1595
1596 long
1597 getpagesize (void)
1598 {
1599 #ifdef _ALPHA_
1600   return 8192;
1601 #else
1602   return 4096;
1603 #endif
1604 }
1605
1606 #ifdef __i386__
1607 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1608 #endif
1609
1610 int
1611 mprotect (char *addr, int len, int prot)
1612 {
1613   int np, op;
1614
1615   if (prot == 7)
1616     np = 0x40;
1617   else if (prot == 5)
1618     np = 0x20;
1619   else if (prot == 4)
1620     np = 0x10;
1621   else if (prot == 3)
1622     np = 0x04;
1623   else if (prot == 1)
1624     np = 0x02;
1625   else if (prot == 0)
1626     np = 0x01;
1627
1628   if (VirtualProtect (addr, len, np, &op))
1629     return 0;
1630   else
1631     return -1;
1632 }
1633
1634 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1635
1636 #ifdef TRANSFER_FROM_TRAMPOLINE
1637 TRANSFER_FROM_TRAMPOLINE
1638 #endif
1639
1640 #if defined (NeXT) && defined (__MACH__)
1641
1642 /* Make stack executable so we can call trampolines on stack.
1643    This is called from INITIALIZE_TRAMPOLINE in next.h.  */
1644 #ifdef NeXTStep21
1645  #include <mach.h>
1646 #else
1647  #include <mach/mach.h>
1648 #endif
1649
1650 void
1651 __enable_execute_stack (char *addr)
1652 {
1653   kern_return_t r;
1654   char *eaddr = addr + TRAMPOLINE_SIZE;
1655   vm_address_t a = (vm_address_t) addr;
1656
1657   /* turn on execute access on stack */
1658   r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
1659   if (r != KERN_SUCCESS)
1660     {
1661       mach_error("vm_protect VM_PROT_ALL", r);
1662       exit(1);
1663     }
1664
1665   /* We inline the i-cache invalidation for speed */
1666
1667 #ifdef CLEAR_INSN_CACHE
1668   CLEAR_INSN_CACHE (addr, eaddr);
1669 #else
1670   __clear_cache ((int) addr, (int) eaddr);
1671 #endif
1672 }
1673
1674 #endif /* defined (NeXT) && defined (__MACH__) */
1675
1676 #ifdef __convex__
1677
1678 /* Make stack executable so we can call trampolines on stack.
1679    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
1680
1681 #include <sys/mman.h>
1682 #include <sys/vmparam.h>
1683 #include <machine/machparam.h>
1684
1685 void
1686 __enable_execute_stack (void)
1687 {
1688   int fp;
1689   static unsigned lowest = USRSTACK;
1690   unsigned current = (unsigned) &fp & -NBPG;
1691
1692   if (lowest > current)
1693     {
1694       unsigned len = lowest - current;
1695       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1696       lowest = current;
1697     }
1698
1699   /* Clear instruction cache in case an old trampoline is in it.  */
1700   asm ("pich");
1701 }
1702 #endif /* __convex__ */
1703
1704 #ifdef __sysV88__
1705
1706 /* Modified from the convex -code above.  */
1707
1708 #include <sys/param.h>
1709 #include <errno.h>
1710 #include <sys/m88kbcs.h>
1711
1712 void
1713 __enable_execute_stack (void)
1714 {
1715   int save_errno;
1716   static unsigned long lowest = USRSTACK;
1717   unsigned long current = (unsigned long) &save_errno & -NBPC;
1718
1719   /* Ignore errno being set. memctl sets errno to EINVAL whenever the
1720      address is seen as 'negative'. That is the case with the stack.  */
1721
1722   save_errno=errno;
1723   if (lowest > current)
1724     {
1725       unsigned len=lowest-current;
1726       memctl(current,len,MCT_TEXT);
1727       lowest = current;
1728     }
1729   else
1730     memctl(current,NBPC,MCT_TEXT);
1731   errno=save_errno;
1732 }
1733
1734 #endif /* __sysV88__ */
1735
1736 #ifdef __sysV68__
1737
1738 #include <sys/signal.h>
1739 #include <errno.h>
1740
1741 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
1742    so define it here, because we need it in __clear_insn_cache below */
1743 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
1744    hence we enable this stuff only if MCT_TEXT is #define'd.  */
1745
1746 #ifdef MCT_TEXT
1747 asm("\n\
1748         global memctl\n\
1749 memctl:\n\
1750         movq &75,%d0\n\
1751         trap &0\n\
1752         bcc.b noerror\n\
1753         jmp cerror%\n\
1754 noerror:\n\
1755         movq &0,%d0\n\
1756         rts");
1757 #endif
1758
1759 /* Clear instruction cache so we can call trampolines on stack.
1760    This is called from FINALIZE_TRAMPOLINE in mot3300.h.  */
1761
1762 void
1763 __clear_insn_cache (void)
1764 {
1765 #ifdef MCT_TEXT
1766   int save_errno;
1767
1768   /* Preserve errno, because users would be surprised to have
1769   errno changing without explicitly calling any system-call.  */
1770   save_errno = errno;
1771
1772   /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
1773      No need to use an address derived from _start or %sp, as 0 works also.  */
1774   memctl(0, 4096, MCT_TEXT);
1775   errno = save_errno;
1776 #endif
1777 }
1778
1779 #endif /* __sysV68__ */
1780
1781 #ifdef __pyr__
1782
1783 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1784 #include <stdio.h>
1785 #include <sys/mman.h>
1786 #include <sys/types.h>
1787 #include <sys/param.h>
1788 #include <sys/vmmac.h>
1789
1790 /* Modified from the convex -code above.
1791    mremap promises to clear the i-cache.  */
1792
1793 void
1794 __enable_execute_stack (void)
1795 {
1796   int fp;
1797   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1798                 PROT_READ|PROT_WRITE|PROT_EXEC))
1799     {
1800       perror ("mprotect in __enable_execute_stack");
1801       fflush (stderr);
1802       abort ();
1803     }
1804 }
1805 #endif /* __pyr__ */
1806
1807 #if defined (sony_news) && defined (SYSTYPE_BSD)
1808
1809 #include <stdio.h>
1810 #include <sys/types.h>
1811 #include <sys/param.h>
1812 #include <syscall.h>
1813 #include <machine/sysnews.h>
1814
1815 /* cacheflush function for NEWS-OS 4.2.
1816    This function is called from trampoline-initialize code
1817    defined in config/mips/mips.h.  */
1818
1819 void
1820 cacheflush (char *beg, int size, int flag)
1821 {
1822   if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
1823     {
1824       perror ("cache_flush");
1825       fflush (stderr);
1826       abort ();
1827     }
1828 }
1829
1830 #endif /* sony_news */
1831 #endif /* L_trampoline */
1832 \f
1833 #ifndef __CYGWIN__
1834 #ifdef L__main
1835
1836 #include "gbl-ctors.h"
1837 /* Some systems use __main in a way incompatible with its use in gcc, in these
1838    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1839    give the same symbol without quotes for an alternative entry point.  You
1840    must define both, or neither.  */
1841 #ifndef NAME__MAIN
1842 #define NAME__MAIN "__main"
1843 #define SYMBOL__MAIN __main
1844 #endif
1845
1846 #ifdef INIT_SECTION_ASM_OP
1847 #undef HAS_INIT_SECTION
1848 #define HAS_INIT_SECTION
1849 #endif
1850
1851 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1852
1853 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1854    code to run constructors.  In that case, we need to handle EH here, too.  */
1855
1856 #ifdef EH_FRAME_SECTION_NAME
1857 #include "unwind-dw2-fde.h"
1858 extern unsigned char __EH_FRAME_BEGIN__[];
1859 #endif
1860
1861 /* Run all the global destructors on exit from the program.  */
1862
1863 void
1864 __do_global_dtors (void)
1865 {
1866 #ifdef DO_GLOBAL_DTORS_BODY
1867   DO_GLOBAL_DTORS_BODY;
1868 #else
1869   static func_ptr *p = __DTOR_LIST__ + 1;
1870   while (*p)
1871     {
1872       p++;
1873       (*(p-1)) ();
1874     }
1875 #endif
1876 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1877   {
1878     static int completed = 0;
1879     if (! completed)
1880       {
1881         completed = 1;
1882         __deregister_frame_info (__EH_FRAME_BEGIN__);
1883       }
1884   }
1885 #endif
1886 }
1887 #endif
1888
1889 #ifndef HAS_INIT_SECTION
1890 /* Run all the global constructors on entry to the program.  */
1891
1892 void
1893 __do_global_ctors (void)
1894 {
1895 #ifdef EH_FRAME_SECTION_NAME
1896   {
1897     static struct object object;
1898     __register_frame_info (__EH_FRAME_BEGIN__, &object);
1899   }
1900 #endif
1901   DO_GLOBAL_CTORS_BODY;
1902   atexit (__do_global_dtors);
1903 }
1904 #endif /* no HAS_INIT_SECTION */
1905
1906 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1907 /* Subroutine called automatically by `main'.
1908    Compiling a global function named `main'
1909    produces an automatic call to this function at the beginning.
1910
1911    For many systems, this routine calls __do_global_ctors.
1912    For systems which support a .init section we use the .init section
1913    to run __do_global_ctors, so we need not do anything here.  */
1914
1915 void
1916 SYMBOL__MAIN ()
1917 {
1918   /* Support recursive calls to `main': run initializers just once.  */
1919   static int initialized;
1920   if (! initialized)
1921     {
1922       initialized = 1;
1923       __do_global_ctors ();
1924     }
1925 }
1926 #endif /* no HAS_INIT_SECTION or INVOKE__main */
1927
1928 #endif /* L__main */
1929 #endif /* __CYGWIN__ */
1930 \f
1931 #ifdef L_ctors
1932
1933 #include "gbl-ctors.h"
1934
1935 /* Provide default definitions for the lists of constructors and
1936    destructors, so that we don't get linker errors.  These symbols are
1937    intentionally bss symbols, so that gld and/or collect will provide
1938    the right values.  */
1939
1940 /* We declare the lists here with two elements each,
1941    so that they are valid empty lists if no other definition is loaded.
1942
1943    If we are using the old "set" extensions to have the gnu linker
1944    collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
1945    must be in the bss/common section.
1946
1947    Long term no port should use those extensions.  But many still do.  */
1948 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1949 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
1950 func_ptr __CTOR_LIST__[2] = {0, 0};
1951 func_ptr __DTOR_LIST__[2] = {0, 0};
1952 #else
1953 func_ptr __CTOR_LIST__[2];
1954 func_ptr __DTOR_LIST__[2];
1955 #endif
1956 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1957 #endif /* L_ctors */
1958 \f
1959 #ifdef L_exit
1960
1961 #include "gbl-ctors.h"
1962
1963 #ifdef NEED_ATEXIT
1964
1965 #ifndef ON_EXIT
1966
1967 # include <errno.h>
1968
1969 static func_ptr *atexit_chain = 0;
1970 static long atexit_chain_length = 0;
1971 static volatile long last_atexit_chain_slot = -1;
1972
1973 int
1974 atexit (func_ptr func)
1975 {
1976   if (++last_atexit_chain_slot == atexit_chain_length)
1977     {
1978       atexit_chain_length += 32;
1979       if (atexit_chain)
1980         atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
1981                                              * sizeof (func_ptr));
1982       else
1983         atexit_chain = (func_ptr *) malloc (atexit_chain_length
1984                                             * sizeof (func_ptr));
1985       if (! atexit_chain)
1986         {
1987           atexit_chain_length = 0;
1988           last_atexit_chain_slot = -1;
1989           errno = ENOMEM;
1990           return (-1);
1991         }
1992     }
1993   atexit_chain[last_atexit_chain_slot] = func;
1994   return (0);
1995 }
1996
1997 extern void _cleanup (void);
1998 extern void _exit (int) __attribute__ ((__noreturn__));
1999
2000 void
2001 exit (int status)
2002 {
2003   if (atexit_chain)
2004     {
2005       for ( ; last_atexit_chain_slot-- >= 0; )
2006         {
2007           (*atexit_chain[last_atexit_chain_slot + 1]) ();
2008           atexit_chain[last_atexit_chain_slot + 1] = 0;
2009         }
2010       free (atexit_chain);
2011       atexit_chain = 0;
2012     }
2013 #ifdef EXIT_BODY
2014   EXIT_BODY;
2015 #else
2016   _cleanup ();
2017 #endif
2018   _exit (status);
2019 }
2020
2021 #else /* ON_EXIT */
2022
2023 /* Simple; we just need a wrapper for ON_EXIT.  */
2024 int
2025 atexit (func_ptr func)
2026 {
2027   return ON_EXIT (func);
2028 }
2029
2030 #endif /* ON_EXIT */
2031 #endif /* NEED_ATEXIT */
2032
2033 #endif /* L_exit */