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, 2002  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 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  40 #ifdef abort
  41 #undef abort
  42 #endif
  43
  44 #include "libgcc2.h"
  45 \f
  46 #ifdef DECLARE_LIBRARY_RENAMES
  47   DECLARE_LIBRARY_RENAMES
  48 #endif
  49
  50 #if defined (L_negdi2)
  51 DWtype
  52 __negdi2 (DWtype u)
  53 {
  54   DWunion w;
  55   DWunion uu;
  56
  57   uu.ll = u;
  58
  59   w.s.low = -uu.s.low;
  60   w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
  61
  62   return w.ll;
  63 }
  64 #endif
  65
  66 #ifdef L_addvsi3
  67 Wtype
  68 __addvsi3 (Wtype a, Wtype b)
  69 {
  70   Wtype w;
  71
  72   w = a + b;
  73
  74   if (b >= 0 ? w < a : w > a)
  75     abort ();
  76
  77   return w;
  78 }
  79 #endif
  80 \f
  81 #ifdef L_addvdi3
  82 DWtype
  83 __addvdi3 (DWtype a, DWtype b)
  84 {
  85   DWtype w;
  86
  87   w = a + b;
  88
  89   if (b >= 0 ? w < a : w > a)
  90     abort ();
  91
  92   return w;
  93 }
  94 #endif
  95 \f
  96 #ifdef L_subvsi3
  97 Wtype
  98 __subvsi3 (Wtype a, Wtype b)
  99 {
 100 #ifdef L_addvsi3
 101   return __addvsi3 (a, (-b));
 102 #else
 103   DWtype w;
 104
 105   w = a - b;
 106
 107   if (b >= 0 ? w > a : w < a)
 108     abort ();
 109
 110   return w;
 111 #endif
 112 }
 113 #endif
 114 \f
 115 #ifdef L_subvdi3
 116 DWtype
 117 __subvdi3 (DWtype a, DWtype b)
 118 {
 119 #ifdef L_addvdi3
 120   return (a, (-b));
 121 #else
 122   DWtype w;
 123
 124   w = a - b;
 125
 126   if (b >= 0 ? w > a : w < a)
 127     abort ();
 128
 129   return w;
 130 #endif
 131 }
 132 #endif
 133 \f
 134 #ifdef L_mulvsi3
 135 Wtype
 136 __mulvsi3 (Wtype a, Wtype b)
 137 {
 138   DWtype w;
 139
 140   w = a * b;
 141
 142   if (((a >= 0) == (b >= 0)) ? w < 0 : w > 0)
 143     abort ();
 144
 145   return w;
 146 }
 147 #endif
 148 \f
 149 #ifdef L_negvsi2
 150 Wtype
 151 __negvsi2 (Wtype a)
 152 {
 153   Wtype w;
 154
 155   w  = -a;
 156
 157   if (a >= 0 ? w > 0 : w < 0)
 158     abort ();
 159
 160    return w;
 161 }
 162 #endif
 163 \f
 164 #ifdef L_negvdi2
 165 DWtype
 166 __negvdi2 (DWtype a)
 167 {
 168   DWtype w;
 169
 170   w  = -a;
 171
 172   if (a >= 0 ? w > 0 : w < 0)
 173     abort ();
 174
 175   return w;
 176 }
 177 #endif
 178 \f
 179 #ifdef L_absvsi2
 180 Wtype
 181 __absvsi2 (Wtype a)
 182 {
 183   Wtype w = a;
 184
 185   if (a < 0)
 186 #ifdef L_negvsi2
 187     w = __negvsi2 (a);
 188 #else
 189     w = -a;
 190
 191   if (w < 0)
 192     abort ();
 193 #endif
 194
 195    return w;
 196 }
 197 #endif
 198 \f
 199 #ifdef L_absvdi2
 200 DWtype
 201 __absvdi2 (DWtype a)
 202 {
 203   DWtype w = a;
 204
 205   if (a < 0)
 206 #ifdef L_negvsi2
 207     w = __negvsi2 (a);
 208 #else
 209     w = -a;
 210
 211   if (w < 0)
 212     abort ();
 213 #endif
 214
 215   return w;
 216 }
 217 #endif
 218 \f
 219 #ifdef L_mulvdi3
 220 DWtype
 221 __mulvdi3 (DWtype u, DWtype v)
 222 {
 223   DWtype w;
 224
 225   w = u * v;
 226
 227   if (((u >= 0) == (v >= 0)) ? w < 0 : w > 0)
 228     abort ();
 229
 230   return w;
 231 }
 232 #endif
 233 \f
 234
 235 /* Unless shift functions are defined whith full ANSI prototypes,
 236    parameter b will be promoted to int if word_type is smaller than an int.  */
 237 #ifdef L_lshrdi3
 238 DWtype
 239 __lshrdi3 (DWtype u, word_type b)
 240 {
 241   DWunion w;
 242   word_type bm;
 243   DWunion uu;
 244
 245   if (b == 0)
 246     return u;
 247
 248   uu.ll = u;
 249
 250   bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 251   if (bm <= 0)
 252     {
 253       w.s.high = 0;
 254       w.s.low = (UWtype) uu.s.high >> -bm;
 255     }
 256   else
 257     {
 258       UWtype carries = (UWtype) uu.s.high << bm;
 259
 260       w.s.high = (UWtype) uu.s.high >> b;
 261       w.s.low = ((UWtype) uu.s.low >> b) | carries;
 262     }
 263
 264   return w.ll;
 265 }
 266 #endif
 267
 268 #ifdef L_ashldi3
 269 DWtype
 270 __ashldi3 (DWtype u, word_type b)
 271 {
 272   DWunion w;
 273   word_type bm;
 274   DWunion uu;
 275
 276   if (b == 0)
 277     return u;
 278
 279   uu.ll = u;
 280
 281   bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 282   if (bm <= 0)
 283     {
 284       w.s.low = 0;
 285       w.s.high = (UWtype) uu.s.low << -bm;
 286     }
 287   else
 288     {
 289       UWtype carries = (UWtype) uu.s.low >> bm;
 290
 291       w.s.low = (UWtype) uu.s.low << b;
 292       w.s.high = ((UWtype) uu.s.high << b) | carries;
 293     }
 294
 295   return w.ll;
 296 }
 297 #endif
 298
 299 #ifdef L_ashrdi3
 300 DWtype
 301 __ashrdi3 (DWtype u, word_type b)
 302 {
 303   DWunion w;
 304   word_type bm;
 305   DWunion uu;
 306
 307   if (b == 0)
 308     return u;
 309
 310   uu.ll = u;
 311
 312   bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
 313   if (bm <= 0)
 314     {
 315       /* w.s.high = 1..1 or 0..0 */
 316       w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
 317       w.s.low = uu.s.high >> -bm;
 318     }
 319   else
 320     {
 321       UWtype carries = (UWtype) uu.s.high << bm;
 322
 323       w.s.high = uu.s.high >> b;
 324       w.s.low = ((UWtype) uu.s.low >> b) | carries;
 325     }
 326
 327   return w.ll;
 328 }
 329 #endif
 330 \f
 331 #ifdef L_ffsdi2
 332 DWtype
 333 __ffsdi2 (DWtype u)
 334 {
 335   DWunion uu;
 336   UWtype word, count, add;
 337
 338   uu.ll = u;
 339   if (uu.s.low != 0)
 340     word = uu.s.low, add = 0;
 341   else if (uu.s.high != 0)
 342     word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
 343   else
 344     return 0;
 345
 346   count_trailing_zeros (count, word);
 347   return count + add + 1;
 348 }
 349 #endif
 350 \f
 351 #ifdef L_muldi3
 352 DWtype
 353 __muldi3 (DWtype u, DWtype v)
 354 {
 355   DWunion w;
 356   DWunion uu, vv;
 357
 358   uu.ll = u,
 359   vv.ll = v;
 360
 361   w.ll = __umulsidi3 (uu.s.low, vv.s.low);
 362   w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
 363                + (UWtype) uu.s.high * (UWtype) vv.s.low);
 364
 365   return w.ll;
 366 }
 367 #endif
 368 \f
 369 #ifdef L_udiv_w_sdiv
 370 #if defined (sdiv_qrnnd)
 371 UWtype
 372 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
 373 {
 374   UWtype q, r;
 375   UWtype c0, c1, b1;
 376
 377   if ((Wtype) d >= 0)
 378     {
 379       if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
 380         {
 381           /* dividend, divisor, and quotient are nonnegative */
 382           sdiv_qrnnd (q, r, a1, a0, d);
 383         }
 384       else
 385         {
 386           /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
 387           sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
 388           /* Divide (c1*2^32 + c0) by d */
 389           sdiv_qrnnd (q, r, c1, c0, d);
 390           /* Add 2^31 to quotient */
 391           q += (UWtype) 1 << (W_TYPE_SIZE - 1);
 392         }
 393     }
 394   else
 395     {
 396       b1 = d >> 1;                      /* d/2, between 2^30 and 2^31 - 1 */
 397       c1 = a1 >> 1;                     /* A/2 */
 398       c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
 399
 400       if (a1 < b1)                      /* A < 2^32*b1, so A/2 < 2^31*b1 */
 401         {
 402           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 403
 404           r = 2*r + (a0 & 1);           /* Remainder from A/(2*b1) */
 405           if ((d & 1) != 0)
 406             {
 407               if (r >= q)
 408                 r = r - q;
 409               else if (q - r <= d)
 410                 {
 411                   r = r - q + d;
 412                   q--;
 413                 }
 414               else
 415                 {
 416                   r = r - q + 2*d;
 417                   q -= 2;
 418                 }
 419             }
 420         }
 421       else if (c1 < b1)                 /* So 2^31 <= (A/2)/b1 < 2^32 */
 422         {
 423           c1 = (b1 - 1) - c1;
 424           c0 = ~c0;                     /* logical NOT */
 425
 426           sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
 427
 428           q = ~q;                       /* (A/2)/b1 */
 429           r = (b1 - 1) - r;
 430
 431           r = 2*r + (a0 & 1);           /* A/(2*b1) */
 432
 433           if ((d & 1) != 0)
 434             {
 435               if (r >= q)
 436                 r = r - q;
 437               else if (q - r <= d)
 438                 {
 439                   r = r - q + d;
 440                   q--;
 441                 }
 442               else
 443                 {
 444                   r = r - q + 2*d;
 445                   q -= 2;
 446                 }
 447             }
 448         }
 449       else                              /* Implies c1 = b1 */
 450         {                               /* Hence a1 = d - 1 = 2*b1 - 1 */
 451           if (a0 >= -d)
 452             {
 453               q = -1;
 454               r = a0 + d;
 455             }
 456           else
 457             {
 458               q = -2;
 459               r = a0 + 2*d;
 460             }
 461         }
 462     }
 463
 464   *rp = r;
 465   return q;
 466 }
 467 #else
 468 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv.  */
 469 UWtype
 470 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
 471                UWtype a1 __attribute__ ((__unused__)),
 472                UWtype a0 __attribute__ ((__unused__)),
 473                UWtype d __attribute__ ((__unused__)))
 474 {
 475   return 0;
 476 }
 477 #endif
 478 #endif
 479 \f
 480 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 481      defined (L_umoddi3) || defined (L_moddi3))
 482 #define L_udivmoddi4
 483 #endif
 484
 485 #ifdef L_clz
 486 const UQItype __clz_tab[] =
 487 {
 488   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,
 489   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,
 490   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,
 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   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,
 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 };
 497 #endif
 498
 499 #ifdef L_udivmoddi4
 500
 501 #if (defined (L_udivdi3) || defined (L_divdi3) || \
 502      defined (L_umoddi3) || defined (L_moddi3))
 503 static inline
 504 #endif
 505 UDWtype
 506 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
 507 {
 508   DWunion ww;
 509   DWunion nn, dd;
 510   DWunion rr;
 511   UWtype d0, d1, n0, n1, n2;
 512   UWtype q0, q1;
 513   UWtype b, bm;
 514
 515   nn.ll = n;
 516   dd.ll = d;
 517
 518   d0 = dd.s.low;
 519   d1 = dd.s.high;
 520   n0 = nn.s.low;
 521   n1 = nn.s.high;
 522
 523 #if !UDIV_NEEDS_NORMALIZATION
 524   if (d1 == 0)
 525     {
 526       if (d0 > n1)
 527         {
 528           /* 0q = nn / 0D */
 529
 530           udiv_qrnnd (q0, n0, n1, n0, d0);
 531           q1 = 0;
 532
 533           /* Remainder in n0.  */
 534         }
 535       else
 536         {
 537           /* qq = NN / 0d */
 538
 539           if (d0 == 0)
 540             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 541
 542           udiv_qrnnd (q1, n1, 0, n1, d0);
 543           udiv_qrnnd (q0, n0, n1, n0, d0);
 544
 545           /* Remainder in n0.  */
 546         }
 547
 548       if (rp != 0)
 549         {
 550           rr.s.low = n0;
 551           rr.s.high = 0;
 552           *rp = rr.ll;
 553         }
 554     }
 555
 556 #else /* UDIV_NEEDS_NORMALIZATION */
 557
 558   if (d1 == 0)
 559     {
 560       if (d0 > n1)
 561         {
 562           /* 0q = nn / 0D */
 563
 564           count_leading_zeros (bm, d0);
 565
 566           if (bm != 0)
 567             {
 568               /* Normalize, i.e. make the most significant bit of the
 569                  denominator set.  */
 570
 571               d0 = d0 << bm;
 572               n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
 573               n0 = n0 << bm;
 574             }
 575
 576           udiv_qrnnd (q0, n0, n1, n0, d0);
 577           q1 = 0;
 578
 579           /* Remainder in n0 >> bm.  */
 580         }
 581       else
 582         {
 583           /* qq = NN / 0d */
 584
 585           if (d0 == 0)
 586             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 587
 588           count_leading_zeros (bm, d0);
 589
 590           if (bm == 0)
 591             {
 592               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 593                  conclude (the most significant bit of n1 is set) /\ (the
 594                  leading quotient digit q1 = 1).
 595
 596                  This special case is necessary, not an optimization.
 597                  (Shifts counts of W_TYPE_SIZE are undefined.)  */
 598
 599               n1 -= d0;
 600               q1 = 1;
 601             }
 602           else
 603             {
 604               /* Normalize.  */
 605
 606               b = W_TYPE_SIZE - bm;
 607
 608               d0 = d0 << bm;
 609               n2 = n1 >> b;
 610               n1 = (n1 << bm) | (n0 >> b);
 611               n0 = n0 << bm;
 612
 613               udiv_qrnnd (q1, n1, n2, n1, d0);
 614             }
 615
 616           /* n1 != d0...  */
 617
 618           udiv_qrnnd (q0, n0, n1, n0, d0);
 619
 620           /* Remainder in n0 >> bm.  */
 621         }
 622
 623       if (rp != 0)
 624         {
 625           rr.s.low = n0 >> bm;
 626           rr.s.high = 0;
 627           *rp = rr.ll;
 628         }
 629     }
 630 #endif /* UDIV_NEEDS_NORMALIZATION */
 631
 632   else
 633     {
 634       if (d1 > n1)
 635         {
 636           /* 00 = nn / DD */
 637
 638           q0 = 0;
 639           q1 = 0;
 640
 641           /* Remainder in n1n0.  */
 642           if (rp != 0)
 643             {
 644               rr.s.low = n0;
 645               rr.s.high = n1;
 646               *rp = rr.ll;
 647             }
 648         }
 649       else
 650         {
 651           /* 0q = NN / dd */
 652
 653           count_leading_zeros (bm, d1);
 654           if (bm == 0)
 655             {
 656               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 657                  conclude (the most significant bit of n1 is set) /\ (the
 658                  quotient digit q0 = 0 or 1).
 659
 660                  This special case is necessary, not an optimization.  */
 661
 662               /* The condition on the next line takes advantage of that
 663                  n1 >= d1 (true due to program flow).  */
 664               if (n1 > d1 || n0 >= d0)
 665                 {
 666                   q0 = 1;
 667                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 668                 }
 669               else
 670                 q0 = 0;
 671
 672               q1 = 0;
 673
 674               if (rp != 0)
 675                 {
 676                   rr.s.low = n0;
 677                   rr.s.high = n1;
 678                   *rp = rr.ll;
 679                 }
 680             }
 681           else
 682             {
 683               UWtype m1, m0;
 684               /* Normalize.  */
 685
 686               b = W_TYPE_SIZE - bm;
 687
 688               d1 = (d1 << bm) | (d0 >> b);
 689               d0 = d0 << bm;
 690               n2 = n1 >> b;
 691               n1 = (n1 << bm) | (n0 >> b);
 692               n0 = n0 << bm;
 693
 694               udiv_qrnnd (q0, n1, n2, n1, d1);
 695               umul_ppmm (m1, m0, q0, d0);
 696
 697               if (m1 > n1 || (m1 == n1 && m0 > n0))
 698                 {
 699                   q0--;
 700                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
 701                 }
 702
 703               q1 = 0;
 704
 705               /* Remainder in (n1n0 - m1m0) >> bm.  */
 706               if (rp != 0)
 707                 {
 708                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
 709                   rr.s.low = (n1 << b) | (n0 >> bm);
 710                   rr.s.high = n1 >> bm;
 711                   *rp = rr.ll;
 712                 }
 713             }
 714         }
 715     }
 716
 717   ww.s.low = q0;
 718   ww.s.high = q1;
 719   return ww.ll;
 720 }
 721 #endif
 722
 723 #ifdef L_divdi3
 724 DWtype
 725 __divdi3 (DWtype u, DWtype v)
 726 {
 727   word_type c = 0;
 728   DWunion uu, vv;
 729   DWtype w;
 730
 731   uu.ll = u;
 732   vv.ll = v;
 733
 734   if (uu.s.high < 0)
 735     c = ~c,
 736     uu.ll = -uu.ll;
 737   if (vv.s.high < 0)
 738     c = ~c,
 739     vv.ll = -vv.ll;
 740
 741   w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
 742   if (c)
 743     w = -w;
 744
 745   return w;
 746 }
 747 #endif
 748
 749 #ifdef L_moddi3
 750 DWtype
 751 __moddi3 (DWtype u, DWtype v)
 752 {
 753   word_type c = 0;
 754   DWunion uu, vv;
 755   DWtype w;
 756
 757   uu.ll = u;
 758   vv.ll = v;
 759
 760   if (uu.s.high < 0)
 761     c = ~c,
 762     uu.ll = -uu.ll;
 763   if (vv.s.high < 0)
 764     vv.ll = -vv.ll;
 765
 766   (void) __udivmoddi4 (uu.ll, vv.ll, &w);
 767   if (c)
 768     w = -w;
 769
 770   return w;
 771 }
 772 #endif
 773
 774 #ifdef L_umoddi3
 775 UDWtype
 776 __umoddi3 (UDWtype u, UDWtype v)
 777 {
 778   UDWtype w;
 779
 780   (void) __udivmoddi4 (u, v, &w);
 781
 782   return w;
 783 }
 784 #endif
 785
 786 #ifdef L_udivdi3
 787 UDWtype
 788 __udivdi3 (UDWtype n, UDWtype d)
 789 {
 790   return __udivmoddi4 (n, d, (UDWtype *) 0);
 791 }
 792 #endif
 793 \f
 794 #ifdef L_cmpdi2
 795 word_type
 796 __cmpdi2 (DWtype a, DWtype b)
 797 {
 798   DWunion au, bu;
 799
 800   au.ll = a, bu.ll = b;
 801
 802   if (au.s.high < bu.s.high)
 803     return 0;
 804   else if (au.s.high > bu.s.high)
 805     return 2;
 806   if ((UWtype) au.s.low < (UWtype) bu.s.low)
 807     return 0;
 808   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
 809     return 2;
 810   return 1;
 811 }
 812 #endif
 813
 814 #ifdef L_ucmpdi2
 815 word_type
 816 __ucmpdi2 (DWtype a, DWtype b)
 817 {
 818   DWunion au, bu;
 819
 820   au.ll = a, bu.ll = b;
 821
 822   if ((UWtype) au.s.high < (UWtype) bu.s.high)
 823     return 0;
 824   else if ((UWtype) au.s.high > (UWtype) bu.s.high)
 825     return 2;
 826   if ((UWtype) au.s.low < (UWtype) bu.s.low)
 827     return 0;
 828   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
 829     return 2;
 830   return 1;
 831 }
 832 #endif
 833 \f
 834 #if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
 835 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 836 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 837
 838 DWtype
 839 __fixunstfDI (TFtype a)
 840 {
 841   TFtype b;
 842   UDWtype v;
 843
 844   if (a < 0)
 845     return 0;
 846
 847   /* Compute high word of result, as a flonum.  */
 848   b = (a / HIGH_WORD_COEFF);
 849   /* Convert that to fixed (but not to DWtype!),
 850      and shift it into the high word.  */
 851   v = (UWtype) b;
 852   v <<= WORD_SIZE;
 853   /* Remove high part from the TFtype, leaving the low part as flonum.  */
 854   a -= (TFtype)v;
 855   /* Convert that to fixed (but not to DWtype!) and add it in.
 856      Sometimes A comes out negative.  This is significant, since
 857      A has more bits than a long int does.  */
 858   if (a < 0)
 859     v -= (UWtype) (- a);
 860   else
 861     v += (UWtype) a;
 862   return v;
 863 }
 864 #endif
 865
 866 #if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
 867 DWtype
 868 __fixtfdi (TFtype a)
 869 {
 870   if (a < 0)
 871     return - __fixunstfDI (-a);
 872   return __fixunstfDI (a);
 873 }
 874 #endif
 875
 876 #if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
 877 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 878 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 879
 880 DWtype
 881 __fixunsxfDI (XFtype a)
 882 {
 883   XFtype b;
 884   UDWtype v;
 885
 886   if (a < 0)
 887     return 0;
 888
 889   /* Compute high word of result, as a flonum.  */
 890   b = (a / HIGH_WORD_COEFF);
 891   /* Convert that to fixed (but not to DWtype!),
 892      and shift it into the high word.  */
 893   v = (UWtype) b;
 894   v <<= WORD_SIZE;
 895   /* Remove high part from the XFtype, leaving the low part as flonum.  */
 896   a -= (XFtype)v;
 897   /* Convert that to fixed (but not to DWtype!) and add it in.
 898      Sometimes A comes out negative.  This is significant, since
 899      A has more bits than a long int does.  */
 900   if (a < 0)
 901     v -= (UWtype) (- a);
 902   else
 903     v += (UWtype) a;
 904   return v;
 905 }
 906 #endif
 907
 908 #if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
 909 DWtype
 910 __fixxfdi (XFtype a)
 911 {
 912   if (a < 0)
 913     return - __fixunsxfDI (-a);
 914   return __fixunsxfDI (a);
 915 }
 916 #endif
 917
 918 #ifdef L_fixunsdfdi
 919 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 920 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 921
 922 DWtype
 923 __fixunsdfDI (DFtype a)
 924 {
 925   DFtype b;
 926   UDWtype v;
 927
 928   if (a < 0)
 929     return 0;
 930
 931   /* Compute high word of result, as a flonum.  */
 932   b = (a / HIGH_WORD_COEFF);
 933   /* Convert that to fixed (but not to DWtype!),
 934      and shift it into the high word.  */
 935   v = (UWtype) b;
 936   v <<= WORD_SIZE;
 937   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 938   a -= (DFtype)v;
 939   /* Convert that to fixed (but not to DWtype!) and add it in.
 940      Sometimes A comes out negative.  This is significant, since
 941      A has more bits than a long int does.  */
 942   if (a < 0)
 943     v -= (UWtype) (- a);
 944   else
 945     v += (UWtype) a;
 946   return v;
 947 }
 948 #endif
 949
 950 #ifdef L_fixdfdi
 951 DWtype
 952 __fixdfdi (DFtype a)
 953 {
 954   if (a < 0)
 955     return - __fixunsdfDI (-a);
 956   return __fixunsdfDI (a);
 957 }
 958 #endif
 959
 960 #ifdef L_fixunssfdi
 961 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
 962 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
 963
 964 DWtype
 965 __fixunssfDI (SFtype original_a)
 966 {
 967   /* Convert the SFtype to a DFtype, because that is surely not going
 968      to lose any bits.  Some day someone else can write a faster version
 969      that avoids converting to DFtype, and verify it really works right.  */
 970   DFtype a = original_a;
 971   DFtype b;
 972   UDWtype v;
 973
 974   if (a < 0)
 975     return 0;
 976
 977   /* Compute high word of result, as a flonum.  */
 978   b = (a / HIGH_WORD_COEFF);
 979   /* Convert that to fixed (but not to DWtype!),
 980      and shift it into the high word.  */
 981   v = (UWtype) b;
 982   v <<= WORD_SIZE;
 983   /* Remove high part from the DFtype, leaving the low part as flonum.  */
 984   a -= (DFtype) v;
 985   /* Convert that to fixed (but not to DWtype!) and add it in.
 986      Sometimes A comes out negative.  This is significant, since
 987      A has more bits than a long int does.  */
 988   if (a < 0)
 989     v -= (UWtype) (- a);
 990   else
 991     v += (UWtype) a;
 992   return v;
 993 }
 994 #endif
 995
 996 #ifdef L_fixsfdi
 997 DWtype
 998 __fixsfdi (SFtype a)
 999 {
1000   if (a < 0)
1001     return - __fixunssfDI (-a);
1002   return __fixunssfDI (a);
1003 }
1004 #endif
1005
1006 #if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
1007 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1008 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1009 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1010
1011 XFtype
1012 __floatdixf (DWtype u)
1013 {
1014   XFtype d;
1015
1016   d = (Wtype) (u >> WORD_SIZE);
1017   d *= HIGH_HALFWORD_COEFF;
1018   d *= HIGH_HALFWORD_COEFF;
1019   d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1020
1021   return d;
1022 }
1023 #endif
1024
1025 #if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
1026 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1027 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1028 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1029
1030 TFtype
1031 __floatditf (DWtype u)
1032 {
1033   TFtype d;
1034
1035   d = (Wtype) (u >> WORD_SIZE);
1036   d *= HIGH_HALFWORD_COEFF;
1037   d *= HIGH_HALFWORD_COEFF;
1038   d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1039
1040   return d;
1041 }
1042 #endif
1043
1044 #ifdef L_floatdidf
1045 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1046 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1047 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1048
1049 DFtype
1050 __floatdidf (DWtype u)
1051 {
1052   DFtype d;
1053
1054   d = (Wtype) (u >> WORD_SIZE);
1055   d *= HIGH_HALFWORD_COEFF;
1056   d *= HIGH_HALFWORD_COEFF;
1057   d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1058
1059   return d;
1060 }
1061 #endif
1062
1063 #ifdef L_floatdisf
1064 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1065 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1066 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1067
1068 #define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
1069 #define DF_SIZE DBL_MANT_DIG
1070 #define SF_SIZE FLT_MANT_DIG
1071
1072 SFtype
1073 __floatdisf (DWtype u)
1074 {
1075   /* Do the calculation in DFmode
1076      so that we don't lose any of the precision of the high word
1077      while multiplying it.  */
1078   DFtype f;
1079
1080   /* Protect against double-rounding error.
1081      Represent any low-order bits, that might be truncated in DFmode,
1082      by a bit that won't be lost.  The bit can go in anywhere below the
1083      rounding position of the SFmode.  A fixed mask and bit position
1084      handles all usual configurations.  It doesn't handle the case
1085      of 128-bit DImode, however.  */
1086   if (DF_SIZE < DI_SIZE
1087       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1088     {
1089 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1090       if (! (- ((DWtype) 1 << DF_SIZE) < u
1091              && u < ((DWtype) 1 << DF_SIZE)))
1092         {
1093           if ((UDWtype) u & (REP_BIT - 1))
1094             u |= REP_BIT;
1095         }
1096     }
1097   f = (Wtype) (u >> WORD_SIZE);
1098   f *= HIGH_HALFWORD_COEFF;
1099   f *= HIGH_HALFWORD_COEFF;
1100   f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1101
1102   return (SFtype) f;
1103 }
1104 #endif
1105
1106 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1107 /* Reenable the normal types, in case limits.h needs them.  */
1108 #undef char
1109 #undef short
1110 #undef int
1111 #undef long
1112 #undef unsigned
1113 #undef float
1114 #undef double
1115 #undef MIN
1116 #undef MAX
1117 #include <limits.h>
1118
1119 UWtype
1120 __fixunsxfSI (XFtype a)
1121 {
1122   if (a >= - (DFtype) Wtype_MIN)
1123     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1124   return (Wtype) a;
1125 }
1126 #endif
1127
1128 #ifdef L_fixunsdfsi
1129 /* Reenable the normal types, in case limits.h needs them.  */
1130 #undef char
1131 #undef short
1132 #undef int
1133 #undef long
1134 #undef unsigned
1135 #undef float
1136 #undef double
1137 #undef MIN
1138 #undef MAX
1139 #include <limits.h>
1140
1141 UWtype
1142 __fixunsdfSI (DFtype a)
1143 {
1144   if (a >= - (DFtype) Wtype_MIN)
1145     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1146   return (Wtype) a;
1147 }
1148 #endif
1149
1150 #ifdef L_fixunssfsi
1151 /* Reenable the normal types, in case limits.h needs them.  */
1152 #undef char
1153 #undef short
1154 #undef int
1155 #undef long
1156 #undef unsigned
1157 #undef float
1158 #undef double
1159 #undef MIN
1160 #undef MAX
1161 #include <limits.h>
1162
1163 UWtype
1164 __fixunssfSI (SFtype a)
1165 {
1166   if (a >= - (SFtype) Wtype_MIN)
1167     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1168   return (Wtype) a;
1169 }
1170 #endif
1171 \f
1172 /* From here on down, the routines use normal data types.  */
1173
1174 #define SItype bogus_type
1175 #define USItype bogus_type
1176 #define DItype bogus_type
1177 #define UDItype bogus_type
1178 #define SFtype bogus_type
1179 #define DFtype bogus_type
1180 #undef Wtype
1181 #undef UWtype
1182 #undef HWtype
1183 #undef UHWtype
1184 #undef DWtype
1185 #undef UDWtype
1186
1187 #undef char
1188 #undef short
1189 #undef int
1190 #undef long
1191 #undef unsigned
1192 #undef float
1193 #undef double
1194 \f
1195 #ifdef L__gcc_bcmp
1196
1197 /* Like bcmp except the sign is meaningful.
1198    Result is negative if S1 is less than S2,
1199    positive if S1 is greater, 0 if S1 and S2 are equal.  */
1200
1201 int
1202 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1203 {
1204   while (size > 0)
1205     {
1206       unsigned char c1 = *s1++, c2 = *s2++;
1207       if (c1 != c2)
1208         return c1 - c2;
1209       size--;
1210     }
1211   return 0;
1212 }
1213
1214 #endif
1215 \f
1216 /* __eprintf used to be used by GCC's private version of <assert.h>.
1217    We no longer provide that header, but this routine remains in libgcc.a
1218    for binary backward compatibility.  Note that it is not included in
1219    the shared version of libgcc.  */
1220 #ifdef L_eprintf
1221 #ifndef inhibit_libc
1222
1223 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1224 #include <stdio.h>
1225
1226 void
1227 __eprintf (const char *string, const char *expression,
1228            unsigned int line, const char *filename)
1229 {
1230   fprintf (stderr, string, expression, line, filename);
1231   fflush (stderr);
1232   abort ();
1233 }
1234
1235 #endif
1236 #endif
1237
1238 #ifdef L_bb
1239
1240 struct bb_function_info {
1241   long checksum;
1242   int arc_count;
1243   const char *name;
1244 };
1245
1246 /* Structure emitted by --profile-arcs  */
1247 struct bb
1248 {
1249   long zero_word;
1250   const char *filename;
1251   gcov_type *counts;
1252   long ncounts;
1253   struct bb *next;
1254
1255   /* Older GCC's did not emit these fields.  */
1256   long sizeof_bb;
1257   struct bb_function_info *function_infos;
1258 };
1259
1260 #ifndef inhibit_libc
1261
1262 /* Arc profile dumper. Requires atexit and stdio.  */
1263
1264 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1265 #include <stdio.h>
1266
1267 #include "gcov-io.h"
1268 #include <string.h>
1269 #ifdef TARGET_HAS_F_SETLKW
1270 #include <fcntl.h>
1271 #include <errno.h>
1272 #endif
1273
1274 /* Chain of per-object file bb structures. */
1275 static struct bb *bb_head;
1276
1277 /* Dump the coverage counts. We merge with existing counts when
1278    possible, to avoid growing the .da files ad infinitum.  */
1279
1280 void
1281 __bb_exit_func (void)
1282 {
1283   struct bb *ptr;
1284   int i;
1285   gcov_type program_sum = 0;
1286   gcov_type program_max = 0;
1287   long program_arcs = 0;
1288   gcov_type merged_sum = 0;
1289   gcov_type merged_max = 0;
1290   long merged_arcs = 0;
1291
1292 #if defined (TARGET_HAS_F_SETLKW)
1293   struct flock s_flock;
1294
1295   s_flock.l_type = F_WRLCK;
1296   s_flock.l_whence = SEEK_SET;
1297   s_flock.l_start = 0;
1298   s_flock.l_len = 0; /* Until EOF. */
1299   s_flock.l_pid = getpid ();
1300 #endif
1301
1302   /* Non-merged stats for this program.  */
1303   for (ptr = bb_head; ptr; ptr = ptr->next)
1304     {
1305       for (i = 0; i < ptr->ncounts; i++)
1306         {
1307           program_sum += ptr->counts[i];
1308
1309           if (ptr->counts[i] > program_max)
1310             program_max = ptr->counts[i];
1311         }
1312       program_arcs += ptr->ncounts;
1313     }
1314
1315   for (ptr = bb_head; ptr; ptr = ptr->next)
1316     {
1317       FILE *da_file;
1318       gcov_type object_max = 0;
1319       gcov_type object_sum = 0;
1320       long object_functions = 0;
1321       int merging = 0;
1322       int error = 0;
1323       struct bb_function_info *fn_info;
1324       gcov_type *count_ptr;
1325
1326       /* Open for modification */
1327       da_file = fopen (ptr->filename, "r+b");
1328
1329       if (da_file)
1330         merging = 1;
1331       else
1332         {
1333           /* Try for appending */
1334           da_file = fopen (ptr->filename, "ab");
1335           /* Some old systems might not allow the 'b' mode modifier.
1336              Therefore, try to open without it.  This can lead to a
1337              race condition so that when you delete and re-create the
1338              file, the file might be opened in text mode, but then,
1339              you shouldn't delete the file in the first place.  */
1340           if (!da_file)
1341             da_file = fopen (ptr->filename, "a");
1342         }
1343
1344       if (!da_file)
1345         {
1346           fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1347                    ptr->filename);
1348           ptr->filename = 0;
1349           continue;
1350         }
1351
1352 #if defined (TARGET_HAS_F_SETLKW)
1353       /* After a fork, another process might try to read and/or write
1354          the same file simultanously.  So if we can, lock the file to
1355          avoid race conditions.  */
1356       while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1357              && errno == EINTR)
1358         continue;
1359 #endif
1360       for (fn_info = ptr->function_infos; fn_info->arc_count != -1; fn_info++)
1361         object_functions++;
1362
1363       if (merging)
1364         {
1365           /* Merge data from file.  */
1366           long tmp_long;
1367           gcov_type tmp_gcov;
1368
1369           if (/* magic */
1370               (__read_long (&tmp_long, da_file, 4) || tmp_long != -123l)
1371               /* functions in object file.  */
1372               || (__read_long (&tmp_long, da_file, 4)
1373                   || tmp_long != object_functions)
1374               /* extension block, skipped */
1375               || (__read_long (&tmp_long, da_file, 4)
1376                   || fseek (da_file, tmp_long, SEEK_CUR)))
1377             {
1378             read_error:;
1379               fprintf (stderr, "arc profiling: Error merging output file %s.\n",
1380                        ptr->filename);
1381               clearerr (da_file);
1382             }
1383           else
1384             {
1385               /* Merge execution counts for each function.  */
1386               count_ptr = ptr->counts;
1387
1388               for (fn_info = ptr->function_infos; fn_info->arc_count != -1;
1389                    fn_info++)
1390                 {
1391                   if (/* function name delim */
1392                       (__read_long (&tmp_long, da_file, 4)
1393                        || tmp_long != -1)
1394                       /* function name length */
1395                       || (__read_long (&tmp_long, da_file, 4)
1396                           || tmp_long != (long) strlen (fn_info->name))
1397                       /* skip string */
1398                       || fseek (da_file, ((tmp_long + 1) + 3) & ~3, SEEK_CUR)
1399                       /* function name delim */
1400                       || (__read_long (&tmp_long, da_file, 4)
1401                           || tmp_long != -1))
1402                     goto read_error;
1403
1404                   if (/* function checksum */
1405                       (__read_long (&tmp_long, da_file, 4)
1406                        || tmp_long != fn_info->checksum)
1407                       /* arc count */
1408                       || (__read_long (&tmp_long, da_file, 4)
1409                           || tmp_long != fn_info->arc_count))
1410                     goto read_error;
1411
1412                   for (i = fn_info->arc_count; i > 0; i--, count_ptr++)
1413                     if (__read_gcov_type (&tmp_gcov, da_file, 8))
1414                       goto read_error;
1415                     else
1416                       *count_ptr += tmp_gcov;
1417                 }
1418             }
1419           fseek (da_file, 0, SEEK_SET);
1420         }
1421
1422       /* Calculate the per-object statistics.  */
1423       for (i = 0; i < ptr->ncounts; i++)
1424         {
1425           object_sum += ptr->counts[i];
1426
1427           if (ptr->counts[i] > object_max)
1428             object_max = ptr->counts[i];
1429         }
1430       merged_sum += object_sum;
1431       if (merged_max < object_max)
1432         merged_max = object_max;
1433       merged_arcs += ptr->ncounts;
1434
1435       /* Write out the data. */
1436       if (/* magic */
1437           __write_long (-123, da_file, 4)
1438           /* number of functions in object file.  */
1439           || __write_long (object_functions, da_file, 4)
1440           /* length of extra data in bytes.  */
1441           || __write_long ((4 + 8 + 8) + (4 + 8 + 8), da_file, 4)
1442
1443           /* whole program statistics. If merging write per-object
1444              now, rewrite later */
1445           /* number of instrumented arcs.  */
1446           || __write_long (merging ? ptr->ncounts : program_arcs, da_file, 4)
1447           /* sum of counters.  */
1448           || __write_gcov_type (merging ? object_sum : program_sum, da_file, 8)
1449           /* maximal counter.  */
1450           || __write_gcov_type (merging ? object_max : program_max, da_file, 8)
1451
1452           /* per-object statistics.  */
1453           /* number of counters.  */
1454           || __write_long (ptr->ncounts, da_file, 4)
1455           /* sum of counters.  */
1456           || __write_gcov_type (object_sum, da_file, 8)
1457           /* maximal counter.  */
1458           || __write_gcov_type (object_max, da_file, 8))
1459         {
1460         write_error:;
1461           fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1462                    ptr->filename);
1463           error = 1;
1464         }
1465       else
1466         {
1467           /* Write execution counts for each function.  */
1468           count_ptr = ptr->counts;
1469
1470           for (fn_info = ptr->function_infos; fn_info->arc_count != -1;
1471                fn_info++)
1472             {
1473               if (__write_gcov_string (fn_info->name,
1474                                        strlen (fn_info->name), da_file, -1)
1475                   || __write_long (fn_info->checksum, da_file, 4)
1476                   || __write_long (fn_info->arc_count, da_file, 4))
1477                 goto write_error;
1478
1479               for (i = fn_info->arc_count; i > 0; i--, count_ptr++)
1480                 if (__write_gcov_type (*count_ptr, da_file, 8))
1481                   goto write_error; /* RIP Edsger Dijkstra */
1482             }
1483         }
1484
1485       if (fclose (da_file))
1486         {
1487           fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1488                    ptr->filename);
1489           error = 1;
1490         }
1491       if (error || !merging)
1492         ptr->filename = 0;
1493     }
1494
1495   /* Upate whole program statistics.  */
1496   for (ptr = bb_head; ptr; ptr = ptr->next)
1497     if (ptr->filename)
1498       {
1499         FILE *da_file;
1500
1501         da_file = fopen (ptr->filename, "r+b");
1502         if (!da_file)
1503           {
1504             fprintf (stderr, "arc profiling: Cannot reopen %s.\n",
1505                      ptr->filename);
1506             continue;
1507           }
1508
1509 #if defined (TARGET_HAS_F_SETLKW)
1510         while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1511                && errno == EINTR)
1512           continue;
1513 #endif
1514
1515         if (fseek (da_file, 4 * 3, SEEK_SET)
1516             /* number of instrumented arcs.  */
1517             || __write_long (program_arcs, da_file, 4)
1518             /* sum of counters.  */
1519             || __write_gcov_type (program_sum, da_file, 8)
1520             /* maximal counter.  */
1521             || __write_gcov_type (program_max, da_file, 8))
1522           fprintf (stderr, "arc profiling: Error updating program header %s.\n",
1523                    ptr->filename);
1524         if (fclose (da_file))
1525           fprintf (stderr, "arc profiling: Error reclosing %s\n",
1526                    ptr->filename);
1527       }
1528 }
1529
1530 /* Add a new object file onto the bb chain.  Invoked automatically
1531    when running an object file's global ctors.  */
1532
1533 void
1534 __bb_init_func (struct bb *blocks)
1535 {
1536   if (blocks->zero_word)
1537     return;
1538
1539   /* Initialize destructor and per-thread data.  */
1540   if (!bb_head)
1541     atexit (__bb_exit_func);
1542
1543   /* Set up linked list.  */
1544   blocks->zero_word = 1;
1545   blocks->next = bb_head;
1546   bb_head = blocks;
1547 }
1548
1549 /* Called before fork or exec - write out profile information gathered so
1550    far and reset it to zero.  This avoids duplication or loss of the
1551    profile information gathered so far.  */
1552
1553 void
1554 __bb_fork_func (void)
1555 {
1556   struct bb *ptr;
1557
1558   __bb_exit_func ();
1559   for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1560     {
1561       long i;
1562       for (i = ptr->ncounts - 1; i >= 0; i--)
1563         ptr->counts[i] = 0;
1564     }
1565 }
1566
1567 #endif /* not inhibit_libc */
1568 #endif /* L_bb */
1569 \f
1570 #ifdef L_clear_cache
1571 /* Clear part of an instruction cache.  */
1572
1573 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1574
1575 void
1576 __clear_cache (char *beg __attribute__((__unused__)),
1577                char *end __attribute__((__unused__)))
1578 {
1579 #ifdef CLEAR_INSN_CACHE
1580   CLEAR_INSN_CACHE (beg, end);
1581 #else
1582 #ifdef INSN_CACHE_SIZE
1583   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1584   static int initialized;
1585   int offset;
1586   void *start_addr
1587   void *end_addr;
1588   typedef (*function_ptr) (void);
1589
1590 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1591   /* It's cheaper to clear the whole cache.
1592      Put in a series of jump instructions so that calling the beginning
1593      of the cache will clear the whole thing.  */
1594
1595   if (! initialized)
1596     {
1597       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1598                  & -INSN_CACHE_LINE_WIDTH);
1599       int end_ptr = ptr + INSN_CACHE_SIZE;
1600
1601       while (ptr < end_ptr)
1602         {
1603           *(INSTRUCTION_TYPE *)ptr
1604             = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1605           ptr += INSN_CACHE_LINE_WIDTH;
1606         }
1607       *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1608
1609       initialized = 1;
1610     }
1611
1612   /* Call the beginning of the sequence.  */
1613   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1614                     & -INSN_CACHE_LINE_WIDTH))
1615    ());
1616
1617 #else /* Cache is large.  */
1618
1619   if (! initialized)
1620     {
1621       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1622                  & -INSN_CACHE_LINE_WIDTH);
1623
1624       while (ptr < (int) array + sizeof array)
1625         {
1626           *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1627           ptr += INSN_CACHE_LINE_WIDTH;
1628         }
1629
1630       initialized = 1;
1631     }
1632
1633   /* Find the location in array that occupies the same cache line as BEG.  */
1634
1635   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1636   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1637                  & -INSN_CACHE_PLANE_SIZE)
1638                 + offset);
1639
1640   /* Compute the cache alignment of the place to stop clearing.  */
1641 #if 0  /* This is not needed for gcc's purposes.  */
1642   /* If the block to clear is bigger than a cache plane,
1643      we clear the entire cache, and OFFSET is already correct.  */
1644   if (end < beg + INSN_CACHE_PLANE_SIZE)
1645 #endif
1646     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1647                & -INSN_CACHE_LINE_WIDTH)
1648               & (INSN_CACHE_PLANE_SIZE - 1));
1649
1650 #if INSN_CACHE_DEPTH > 1
1651   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1652   if (end_addr <= start_addr)
1653     end_addr += INSN_CACHE_PLANE_SIZE;
1654
1655   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1656     {
1657       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1658       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1659
1660       while (addr != stop)
1661         {
1662           /* Call the return instruction at ADDR.  */
1663           ((function_ptr) addr) ();
1664
1665           addr += INSN_CACHE_LINE_WIDTH;
1666         }
1667     }
1668 #else /* just one plane */
1669   do
1670     {
1671       /* Call the return instruction at START_ADDR.  */
1672       ((function_ptr) start_addr) ();
1673
1674       start_addr += INSN_CACHE_LINE_WIDTH;
1675     }
1676   while ((start_addr % INSN_CACHE_SIZE) != offset);
1677 #endif /* just one plane */
1678 #endif /* Cache is large */
1679 #endif /* Cache exists */
1680 #endif /* CLEAR_INSN_CACHE */
1681 }
1682
1683 #endif /* L_clear_cache */
1684 \f
1685 #ifdef L_trampoline
1686
1687 /* Jump to a trampoline, loading the static chain address.  */
1688
1689 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1690
1691 long
1692 getpagesize (void)
1693 {
1694 #ifdef _ALPHA_
1695   return 8192;
1696 #else
1697   return 4096;
1698 #endif
1699 }
1700
1701 #ifdef __i386__
1702 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1703 #endif
1704
1705 int
1706 mprotect (char *addr, int len, int prot)
1707 {
1708   int np, op;
1709
1710   if (prot == 7)
1711     np = 0x40;
1712   else if (prot == 5)
1713     np = 0x20;
1714   else if (prot == 4)
1715     np = 0x10;
1716   else if (prot == 3)
1717     np = 0x04;
1718   else if (prot == 1)
1719     np = 0x02;
1720   else if (prot == 0)
1721     np = 0x01;
1722
1723   if (VirtualProtect (addr, len, np, &op))
1724     return 0;
1725   else
1726     return -1;
1727 }
1728
1729 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1730
1731 #ifdef TRANSFER_FROM_TRAMPOLINE
1732 TRANSFER_FROM_TRAMPOLINE
1733 #endif
1734
1735 #if defined (NeXT) && defined (__MACH__)
1736
1737 /* Make stack executable so we can call trampolines on stack.
1738    This is called from INITIALIZE_TRAMPOLINE in next.h.  */
1739 #ifdef NeXTStep21
1740  #include <mach.h>
1741 #else
1742  #include <mach/mach.h>
1743 #endif
1744
1745 void
1746 __enable_execute_stack (char *addr)
1747 {
1748   kern_return_t r;
1749   char *eaddr = addr + TRAMPOLINE_SIZE;
1750   vm_address_t a = (vm_address_t) addr;
1751
1752   /* turn on execute access on stack */
1753   r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
1754   if (r != KERN_SUCCESS)
1755     {
1756       mach_error("vm_protect VM_PROT_ALL", r);
1757       exit(1);
1758     }
1759
1760   /* We inline the i-cache invalidation for speed */
1761
1762 #ifdef CLEAR_INSN_CACHE
1763   CLEAR_INSN_CACHE (addr, eaddr);
1764 #else
1765   __clear_cache ((int) addr, (int) eaddr);
1766 #endif
1767 }
1768
1769 #endif /* defined (NeXT) && defined (__MACH__) */
1770
1771 #ifdef __convex__
1772
1773 /* Make stack executable so we can call trampolines on stack.
1774    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
1775
1776 #include <sys/mman.h>
1777 #include <sys/vmparam.h>
1778 #include <machine/machparam.h>
1779
1780 void
1781 __enable_execute_stack (void)
1782 {
1783   int fp;
1784   static unsigned lowest = USRSTACK;
1785   unsigned current = (unsigned) &fp & -NBPG;
1786
1787   if (lowest > current)
1788     {
1789       unsigned len = lowest - current;
1790       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1791       lowest = current;
1792     }
1793
1794   /* Clear instruction cache in case an old trampoline is in it.  */
1795   asm ("pich");
1796 }
1797 #endif /* __convex__ */
1798
1799 #ifdef __sysV88__
1800
1801 /* Modified from the convex -code above.  */
1802
1803 #include <sys/param.h>
1804 #include <errno.h>
1805 #include <sys/m88kbcs.h>
1806
1807 void
1808 __enable_execute_stack (void)
1809 {
1810   int save_errno;
1811   static unsigned long lowest = USRSTACK;
1812   unsigned long current = (unsigned long) &save_errno & -NBPC;
1813
1814   /* Ignore errno being set. memctl sets errno to EINVAL whenever the
1815      address is seen as 'negative'. That is the case with the stack.  */
1816
1817   save_errno=errno;
1818   if (lowest > current)
1819     {
1820       unsigned len=lowest-current;
1821       memctl(current,len,MCT_TEXT);
1822       lowest = current;
1823     }
1824   else
1825     memctl(current,NBPC,MCT_TEXT);
1826   errno=save_errno;
1827 }
1828
1829 #endif /* __sysV88__ */
1830
1831 #ifdef __sysV68__
1832
1833 #include <sys/signal.h>
1834 #include <errno.h>
1835
1836 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
1837    so define it here, because we need it in __clear_insn_cache below */
1838 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
1839    hence we enable this stuff only if MCT_TEXT is #define'd.  */
1840
1841 #ifdef MCT_TEXT
1842 asm("\n\
1843         global memctl\n\
1844 memctl:\n\
1845         movq &75,%d0\n\
1846         trap &0\n\
1847         bcc.b noerror\n\
1848         jmp cerror%\n\
1849 noerror:\n\
1850         movq &0,%d0\n\
1851         rts");
1852 #endif
1853
1854 /* Clear instruction cache so we can call trampolines on stack.
1855    This is called from FINALIZE_TRAMPOLINE in mot3300.h.  */
1856
1857 void
1858 __clear_insn_cache (void)
1859 {
1860 #ifdef MCT_TEXT
1861   int save_errno;
1862
1863   /* Preserve errno, because users would be surprised to have
1864   errno changing without explicitly calling any system-call.  */
1865   save_errno = errno;
1866
1867   /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
1868      No need to use an address derived from _start or %sp, as 0 works also.  */
1869   memctl(0, 4096, MCT_TEXT);
1870   errno = save_errno;
1871 #endif
1872 }
1873
1874 #endif /* __sysV68__ */
1875
1876 #ifdef __pyr__
1877
1878 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
1879 #include <stdio.h>
1880 #include <sys/mman.h>
1881 #include <sys/types.h>
1882 #include <sys/param.h>
1883 #include <sys/vmmac.h>
1884
1885 /* Modified from the convex -code above.
1886    mremap promises to clear the i-cache.  */
1887
1888 void
1889 __enable_execute_stack (void)
1890 {
1891   int fp;
1892   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1893                 PROT_READ|PROT_WRITE|PROT_EXEC))
1894     {
1895       perror ("mprotect in __enable_execute_stack");
1896       fflush (stderr);
1897       abort ();
1898     }
1899 }
1900 #endif /* __pyr__ */
1901
1902 #if defined (sony_news) && defined (SYSTYPE_BSD)
1903
1904 #include <stdio.h>
1905 #include <sys/types.h>
1906 #include <sys/param.h>
1907 #include <syscall.h>
1908 #include <machine/sysnews.h>
1909
1910 /* cacheflush function for NEWS-OS 4.2.
1911    This function is called from trampoline-initialize code
1912    defined in config/mips/mips.h.  */
1913
1914 void
1915 cacheflush (char *beg, int size, int flag)
1916 {
1917   if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
1918     {
1919       perror ("cache_flush");
1920       fflush (stderr);
1921       abort ();
1922     }
1923 }
1924
1925 #endif /* sony_news */
1926 #endif /* L_trampoline */
1927 \f
1928 #ifndef __CYGWIN__
1929 #ifdef L__main
1930
1931 #include "gbl-ctors.h"
1932 /* Some systems use __main in a way incompatible with its use in gcc, in these
1933    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1934    give the same symbol without quotes for an alternative entry point.  You
1935    must define both, or neither.  */
1936 #ifndef NAME__MAIN
1937 #define NAME__MAIN "__main"
1938 #define SYMBOL__MAIN __main
1939 #endif
1940
1941 #ifdef INIT_SECTION_ASM_OP
1942 #undef HAS_INIT_SECTION
1943 #define HAS_INIT_SECTION
1944 #endif
1945
1946 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1947
1948 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1949    code to run constructors.  In that case, we need to handle EH here, too.  */
1950
1951 #ifdef EH_FRAME_SECTION_NAME
1952 #include "unwind-dw2-fde.h"
1953 extern unsigned char __EH_FRAME_BEGIN__[];
1954 #endif
1955
1956 /* Run all the global destructors on exit from the program.  */
1957
1958 void
1959 __do_global_dtors (void)
1960 {
1961 #ifdef DO_GLOBAL_DTORS_BODY
1962   DO_GLOBAL_DTORS_BODY;
1963 #else
1964   static func_ptr *p = __DTOR_LIST__ + 1;
1965   while (*p)
1966     {
1967       p++;
1968       (*(p-1)) ();
1969     }
1970 #endif
1971 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1972   {
1973     static int completed = 0;
1974     if (! completed)
1975       {
1976         completed = 1;
1977         __deregister_frame_info (__EH_FRAME_BEGIN__);
1978       }
1979   }
1980 #endif
1981 }
1982 #endif
1983
1984 #ifndef HAS_INIT_SECTION
1985 /* Run all the global constructors on entry to the program.  */
1986
1987 void
1988 __do_global_ctors (void)
1989 {
1990 #ifdef EH_FRAME_SECTION_NAME
1991   {
1992     static struct object object;
1993     __register_frame_info (__EH_FRAME_BEGIN__, &object);
1994   }
1995 #endif
1996   DO_GLOBAL_CTORS_BODY;
1997   atexit (__do_global_dtors);
1998 }
1999 #endif /* no HAS_INIT_SECTION */
2000
2001 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2002 /* Subroutine called automatically by `main'.
2003    Compiling a global function named `main'
2004    produces an automatic call to this function at the beginning.
2005
2006    For many systems, this routine calls __do_global_ctors.
2007    For systems which support a .init section we use the .init section
2008    to run __do_global_ctors, so we need not do anything here.  */
2009
2010 void
2011 SYMBOL__MAIN ()
2012 {
2013   /* Support recursive calls to `main': run initializers just once.  */
2014   static int initialized;
2015   if (! initialized)
2016     {
2017       initialized = 1;
2018       __do_global_ctors ();
2019     }
2020 }
2021 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2022
2023 #endif /* L__main */
2024 #endif /* __CYGWIN__ */
2025 \f
2026 #ifdef L_ctors
2027
2028 #include "gbl-ctors.h"
2029
2030 /* Provide default definitions for the lists of constructors and
2031    destructors, so that we don't get linker errors.  These symbols are
2032    intentionally bss symbols, so that gld and/or collect will provide
2033    the right values.  */
2034
2035 /* We declare the lists here with two elements each,
2036    so that they are valid empty lists if no other definition is loaded.
2037
2038    If we are using the old "set" extensions to have the gnu linker
2039    collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2040    must be in the bss/common section.
2041
2042    Long term no port should use those extensions.  But many still do.  */
2043 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2044 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2045 func_ptr __CTOR_LIST__[2] = {0, 0};
2046 func_ptr __DTOR_LIST__[2] = {0, 0};
2047 #else
2048 func_ptr __CTOR_LIST__[2];
2049 func_ptr __DTOR_LIST__[2];
2050 #endif
2051 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2052 #endif /* L_ctors */
2053 \f
2054 #ifdef L_exit
2055
2056 #include "gbl-ctors.h"
2057
2058 #ifdef NEED_ATEXIT
2059
2060 #ifndef ON_EXIT
2061
2062 # include <errno.h>
2063
2064 static func_ptr *atexit_chain = 0;
2065 static long atexit_chain_length = 0;
2066 static volatile long last_atexit_chain_slot = -1;
2067
2068 int
2069 atexit (func_ptr func)
2070 {
2071   if (++last_atexit_chain_slot == atexit_chain_length)
2072     {
2073       atexit_chain_length += 32;
2074       if (atexit_chain)
2075         atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
2076                                              * sizeof (func_ptr));
2077       else
2078         atexit_chain = (func_ptr *) malloc (atexit_chain_length
2079                                             * sizeof (func_ptr));
2080       if (! atexit_chain)
2081         {
2082           atexit_chain_length = 0;
2083           last_atexit_chain_slot = -1;
2084           errno = ENOMEM;
2085           return (-1);
2086         }
2087     }
2088   atexit_chain[last_atexit_chain_slot] = func;
2089   return (0);
2090 }
2091
2092 extern void _cleanup (void);
2093 extern void _exit (int) __attribute__ ((__noreturn__));
2094
2095 void
2096 exit (int status)
2097 {
2098   if (atexit_chain)
2099     {
2100       for ( ; last_atexit_chain_slot-- >= 0; )
2101         {
2102           (*atexit_chain[last_atexit_chain_slot + 1]) ();
2103           atexit_chain[last_atexit_chain_slot + 1] = 0;
2104         }
2105       free (atexit_chain);
2106       atexit_chain = 0;
2107     }
2108 #ifdef EXIT_BODY
2109   EXIT_BODY;
2110 #else
2111   _cleanup ();
2112 #endif
2113   _exit (status);
2114 }
2115
2116 #else /* ON_EXIT */
2117
2118 /* Simple; we just need a wrapper for ON_EXIT.  */
2119 int
2120 atexit (func_ptr func)
2121 {
2122   return ON_EXIT (func);
2123 }
2124
2125 #endif /* ON_EXIT */
2126 #endif /* NEED_ATEXIT */
2127
2128 #endif /* L_exit */