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 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* As a special exception, if you link this library with files
  22    compiled with GCC to produce an executable, this does not cause
  23    the resulting executable to be covered by the GNU General Public License.
  24    This exception does not however invalidate any other reasons why
  25    the executable file might be covered by the GNU General Public License.  */
  26
  27 /* It is incorrect to include config.h here, because this file is being
  28    compiled for the target, and hence definitions concerning only the host
  29    do not apply.  */
  30
  31 #include "tm.h"
  32 #ifndef L_trampoline
  33 #include "gstddef.h"
  34 #endif
  35
  36 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  37 #ifdef abort
  38 #undef abort
  39 #endif
  40
  41 /* Need to undef this because LONG_TYPE_SIZE may rely upon GCC's
  42    internal `target_flags' variable.  */
  43 #undef LONG_TYPE_SIZE
  44
  45 #define LONG_TYPE_SIZE (sizeof (long) * BITS_PER_UNIT)
  46
  47 #ifndef SItype
  48 #define SItype long int
  49 #endif
  50
  51 /* long long ints are pairs of long ints in the order determined by
  52    WORDS_BIG_ENDIAN.  */
  53
  54 #if WORDS_BIG_ENDIAN
  55   struct longlong {long high, low;};
  56 #else
  57   struct longlong {long low, high;};
  58 #endif
  59
  60 /* We need this union to unpack/pack longlongs, since we don't have
  61    any arithmetic yet.  Incoming long long parameters are stored
  62    into the `ll' field, and the unpacked result is read from the struct
  63    longlong.  */
  64
  65 typedef union
  66 {
  67   struct longlong s;
  68   long long ll;
  69 } long_long;
  70
  71 #if defined (L_udivmoddi4) || defined (L_muldi3)
  72
  73 #include "longlong.h"
  74
  75 #endif /* udiv or mul */
  76
  77 extern long long __fixunssfdi (float a);
  78 extern long long __fixunsdfdi (double a);
  79 \f
  80 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
  81 #if defined (L_divdi3) || defined (L_moddi3)
  82 static inline
  83 #endif
  84 long long
  85 __negdi2 (u)
  86      long long u;
  87 {
  88   long_long w;
  89   long_long uu;
  90
  91   uu.ll = u;
  92
  93   w.s.low = -uu.s.low;
  94   w.s.high = -uu.s.high - ((unsigned long) w.s.low > 0);
  95
  96   return w.ll;
  97 }
  98 #endif
  99 \f
 100 #ifdef L_lshldi3
 101 long long
 102 __lshldi3 (u, b)
 103      long long u;
 104      int b;
 105 {
 106   long_long w;
 107   long bm;
 108   long_long uu;
 109
 110   if (b == 0)
 111     return u;
 112
 113   uu.ll = u;
 114
 115   bm = (sizeof (long) * BITS_PER_UNIT) - b;
 116   if (bm <= 0)
 117     {
 118       w.s.low = 0;
 119       w.s.high = (unsigned long)uu.s.low << -bm;
 120     }
 121   else
 122     {
 123       unsigned long carries = (unsigned long)uu.s.low >> bm;
 124       w.s.low = (unsigned long)uu.s.low << b;
 125       w.s.high = ((unsigned long)uu.s.high << b) | carries;
 126     }
 127
 128   return w.ll;
 129 }
 130 #endif
 131
 132 #ifdef L_lshrdi3
 133 long long
 134 __lshrdi3 (u, b)
 135      long long u;
 136      int b;
 137 {
 138   long_long w;
 139   long bm;
 140   long_long uu;
 141
 142   if (b == 0)
 143     return u;
 144
 145   uu.ll = u;
 146
 147   bm = (sizeof (long) * BITS_PER_UNIT) - b;
 148   if (bm <= 0)
 149     {
 150       w.s.high = 0;
 151       w.s.low = (unsigned long)uu.s.high >> -bm;
 152     }
 153   else
 154     {
 155       unsigned long carries = (unsigned long)uu.s.high << bm;
 156       w.s.high = (unsigned long)uu.s.high >> b;
 157       w.s.low = ((unsigned long)uu.s.low >> b) | carries;
 158     }
 159
 160   return w.ll;
 161 }
 162 #endif
 163
 164 #ifdef L_ashldi3
 165 long long
 166 __ashldi3 (u, b)
 167      long long u;
 168      int b;
 169 {
 170   long_long w;
 171   long bm;
 172   long_long uu;
 173
 174   if (b == 0)
 175     return u;
 176
 177   uu.ll = u;
 178
 179   bm = (sizeof (long) * BITS_PER_UNIT) - b;
 180   if (bm <= 0)
 181     {
 182       w.s.low = 0;
 183       w.s.high = (unsigned long)uu.s.low << -bm;
 184     }
 185   else
 186     {
 187       unsigned long carries = (unsigned long)uu.s.low >> bm;
 188       w.s.low = (unsigned long)uu.s.low << b;
 189       w.s.high = ((unsigned long)uu.s.high << b) | carries;
 190     }
 191
 192   return w.ll;
 193 }
 194 #endif
 195
 196 #ifdef L_ashrdi3
 197 long long
 198 __ashrdi3 (u, b)
 199      long long u;
 200      int b;
 201 {
 202   long_long w;
 203   long bm;
 204   long_long uu;
 205
 206   if (b == 0)
 207     return u;
 208
 209   uu.ll = u;
 210
 211   bm = (sizeof (long) * BITS_PER_UNIT) - b;
 212   if (bm <= 0)
 213     {
 214       /* w.s.high = 1..1 or 0..0 */
 215       w.s.high = uu.s.high >> (sizeof (long) * BITS_PER_UNIT - 1);
 216       w.s.low = uu.s.high >> -bm;
 217     }
 218   else
 219     {
 220       unsigned long carries = (unsigned long)uu.s.high << bm;
 221       w.s.high = uu.s.high >> b;
 222       w.s.low = ((unsigned long)uu.s.low >> b) | carries;
 223     }
 224
 225   return w.ll;
 226 }
 227 #endif
 228 \f
 229 #ifdef L_muldi3
 230 long long
 231 __muldi3 (u, v)
 232      long long u, v;
 233 {
 234   long_long w;
 235   long_long uu, vv;
 236
 237   uu.ll = u,
 238   vv.ll = v;
 239
 240   w.ll = __umulsidi3 (uu.s.low, vv.s.low);
 241   w.s.high += ((unsigned long) uu.s.low * (unsigned long) vv.s.high
 242                + (unsigned long) uu.s.high * (unsigned long) vv.s.low);
 243
 244   return w.ll;
 245 }
 246 #endif
 247 \f
 248 #ifdef L_udivmoddi4
 249 static const unsigned char __clz_tab[] =
 250 {
 251   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,
 252   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,
 253   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,
 254   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,
 255   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,
 256   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,
 257   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,
 258   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,
 259 };
 260
 261 unsigned long long
 262 __udivmoddi4 (n, d, rp)
 263      unsigned long long n, d;
 264      unsigned long long int *rp;
 265 {
 266   long_long ww;
 267   long_long nn, dd;
 268   long_long rr;
 269   unsigned long d0, d1, n0, n1, n2;
 270   unsigned long q0, q1;
 271   unsigned b, bm;
 272
 273   nn.ll = n;
 274   dd.ll = d;
 275
 276   d0 = dd.s.low;
 277   d1 = dd.s.high;
 278   n0 = nn.s.low;
 279   n1 = nn.s.high;
 280
 281 #if !UDIV_NEEDS_NORMALIZATION
 282   if (d1 == 0)
 283     {
 284       if (d0 > n1)
 285         {
 286           /* 0q = nn / 0D */
 287
 288           udiv_qrnnd (q0, n0, n1, n0, d0);
 289           q1 = 0;
 290
 291           /* Remainder in n0.  */
 292         }
 293       else
 294         {
 295           /* qq = NN / 0d */
 296
 297           if (d0 == 0)
 298             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 299
 300           udiv_qrnnd (q1, n1, 0, n1, d0);
 301           udiv_qrnnd (q0, n0, n1, n0, d0);
 302
 303           /* Remainder in n0.  */
 304         }
 305
 306       if (rp != 0)
 307         {
 308           rr.s.low = n0;
 309           rr.s.high = 0;
 310           *rp = rr.ll;
 311         }
 312     }
 313
 314 #else /* UDIV_NEEDS_NORMALIZATION */
 315
 316   if (d1 == 0)
 317     {
 318       if (d0 > n1)
 319         {
 320           /* 0q = nn / 0D */
 321
 322           count_leading_zeros (bm, d0);
 323
 324           if (bm != 0)
 325             {
 326               /* Normalize, i.e. make the most significant bit of the
 327                  denominator set.  */
 328
 329               d0 = d0 << bm;
 330               n1 = (n1 << bm) | (n0 >> (LONG_TYPE_SIZE - bm));
 331               n0 = n0 << bm;
 332             }
 333
 334           udiv_qrnnd (q0, n0, n1, n0, d0);
 335           q1 = 0;
 336
 337           /* Remainder in n0 >> bm.  */
 338         }
 339       else
 340         {
 341           /* qq = NN / 0d */
 342
 343           if (d0 == 0)
 344             d0 = 1 / d0;        /* Divide intentionally by zero.  */
 345
 346           count_leading_zeros (bm, d0);
 347
 348           if (bm == 0)
 349             {
 350               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
 351                  conclude (the most significant bit of n1 is set) /\ (the
 352                  leading quotient digit q1 = 1).
 353
 354                  This special case is necessary, not an optimization.
 355                  (Shifts counts of LONG_TYPE_SIZE are undefined.)  */
 356
 357               n1 -= d0;
 358               q1 = 1;
 359             }
 360           else
 361             {
 362               /* Normalize.  */
 363
 364               b = LONG_TYPE_SIZE - bm;
 365
 366               d0 = d0 << bm;
 367               n2 = n1 >> b;
 368               n1 = (n1 << bm) | (n0 >> b);
 369               n0 = n0 << bm;
 370
 371               udiv_qrnnd (q1, n1, n2, n1, d0);
 372             }
 373
 374           /* n1 != d0... */
 375
 376           udiv_qrnnd (q0, n0, n1, n0, d0);
 377
 378           /* Remainder in n0 >> bm.  */
 379         }
 380
 381       if (rp != 0)
 382         {
 383           rr.s.low = n0 >> bm;
 384           rr.s.high = 0;
 385           *rp = rr.ll;
 386         }
 387     }
 388 #endif /* UDIV_NEEDS_NORMALIZATION */
 389
 390   else
 391     {
 392       if (d1 > n1)
 393         {
 394           /* 00 = nn / DD */
 395
 396           q0 = 0;
 397           q1 = 0;
 398
 399           /* Remainder in n1n0.  */
 400           if (rp != 0)
 401             {
 402               rr.s.low = n0;
 403               rr.s.high = n1;
 404               *rp = rr.ll;
 405             }
 406         }
 407       else
 408         {
 409           /* 0q = NN / dd */
 410
 411           count_leading_zeros (bm, d1);
 412           if (bm == 0)
 413             {
 414               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
 415                  conclude (the most significant bit of n1 is set) /\ (the
 416                  quotient digit q0 = 0 or 1).
 417
 418                  This special case is necessary, not an optimization.  */
 419
 420               /* The condition on the next line takes advantage of that
 421                  n1 >= d1 (true due to program flow).  */
 422               if (n1 > d1 || n0 >= d0)
 423                 {
 424                   q0 = 1;
 425                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
 426                 }
 427               else
 428                 q0 = 0;
 429
 430               q1 = 0;
 431
 432               if (rp != 0)
 433                 {
 434                   rr.s.low = n0;
 435                   rr.s.high = n1;
 436                   *rp = rr.ll;
 437                 }
 438             }
 439           else
 440             {
 441               unsigned long m1, m0;
 442               /* Normalize.  */
 443
 444               b = LONG_TYPE_SIZE - bm;
 445
 446               d1 = (d1 << bm) | (d0 >> b);
 447               d0 = d0 << bm;
 448               n2 = n1 >> b;
 449               n1 = (n1 << bm) | (n0 >> b);
 450               n0 = n0 << bm;
 451
 452               udiv_qrnnd (q0, n1, n2, n1, d1);
 453               umul_ppmm (m1, m0, q0, d0);
 454
 455               if (m1 > n1 || (m1 == n1 && m0 > n0))
 456                 {
 457                   q0--;
 458                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
 459                 }
 460
 461               q1 = 0;
 462
 463               /* Remainder in (n1n0 - m1m0) >> bm.  */
 464               if (rp != 0)
 465                 {
 466                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
 467                   rr.s.low = (n1 << b) | (n0 >> bm);
 468                   rr.s.high = n1 >> bm;
 469                   *rp = rr.ll;
 470                 }
 471             }
 472         }
 473     }
 474
 475   ww.s.low = q0;
 476   ww.s.high = q1;
 477   return ww.ll;
 478 }
 479 #endif
 480
 481 #ifdef L_divdi3
 482 unsigned long long __udivmoddi4 ();
 483 long long
 484 __divdi3 (u, v)
 485      long long u, v;
 486 {
 487   int c = 0;
 488   long_long uu, vv;
 489   long long w;
 490
 491   uu.ll = u;
 492   vv.ll = v;
 493
 494   if (uu.s.high < 0)
 495     c = ~c,
 496     uu.ll = __negdi2 (uu.ll);
 497   if (vv.s.high < 0)
 498     c = ~c,
 499     vv.ll = __negdi2 (vv.ll);
 500
 501   w = __udivmoddi4 (uu.ll, vv.ll, (unsigned long long *) 0);
 502   if (c)
 503     w = __negdi2 (w);
 504
 505   return w;
 506 }
 507 #endif
 508
 509 #ifdef L_moddi3
 510 unsigned long long __udivmoddi4 ();
 511 long long
 512 __moddi3 (u, v)
 513      long long u, v;
 514 {
 515   int c = 0;
 516   long_long uu, vv;
 517   long long w;
 518
 519   uu.ll = u;
 520   vv.ll = v;
 521
 522   if (uu.s.high < 0)
 523     c = ~c,
 524     uu.ll = __negdi2 (uu.ll);
 525   if (vv.s.high < 0)
 526     vv.ll = __negdi2 (vv.ll);
 527
 528   (void) __udivmoddi4 (uu.ll, vv.ll, &w);
 529   if (c)
 530     w = __negdi2 (w);
 531
 532   return w;
 533 }
 534 #endif
 535
 536 #ifdef L_umoddi3
 537 unsigned long long __udivmoddi4 ();
 538 unsigned long long
 539 __umoddi3 (u, v)
 540      unsigned long long u, v;
 541 {
 542   long long w;
 543
 544   (void) __udivmoddi4 (u, v, &w);
 545
 546   return w;
 547 }
 548 #endif
 549
 550 #ifdef L_udivdi3
 551 unsigned long long __udivmoddi4 ();
 552 unsigned long long
 553 __udivdi3 (n, d)
 554      unsigned long long n, d;
 555 {
 556   return __udivmoddi4 (n, d, (unsigned long long *) 0);
 557 }
 558 #endif
 559 \f
 560 #ifdef L_cmpdi2
 561 SItype
 562 __cmpdi2 (a, b)
 563      long long a, b;
 564 {
 565   long_long au, bu;
 566
 567   au.ll = a, bu.ll = b;
 568
 569   if (au.s.high < bu.s.high)
 570     return 0;
 571   else if (au.s.high > bu.s.high)
 572     return 2;
 573   if ((unsigned long) au.s.low < (unsigned long) bu.s.low)
 574     return 0;
 575   else if ((unsigned long) au.s.low > (unsigned long) bu.s.low)
 576     return 2;
 577   return 1;
 578 }
 579 #endif
 580
 581 #ifdef L_ucmpdi2
 582 SItype
 583 __ucmpdi2 (a, b)
 584      long long a, b;
 585 {
 586   long_long au, bu;
 587
 588   au.ll = a, bu.ll = b;
 589
 590   if ((unsigned long) au.s.high < (unsigned long) bu.s.high)
 591     return 0;
 592   else if ((unsigned long) au.s.high > (unsigned long) bu.s.high)
 593     return 2;
 594   if ((unsigned long) au.s.low < (unsigned long) bu.s.low)
 595     return 0;
 596   else if ((unsigned long) au.s.low > (unsigned long) bu.s.low)
 597     return 2;
 598   return 1;
 599 }
 600 #endif
 601 \f
 602 #ifdef L_fixunsdfdi
 603 #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
 604 #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
 605
 606 long long
 607 __fixunsdfdi (a)
 608      double a;
 609 {
 610   double b;
 611   unsigned long long v;
 612
 613   if (a < 0)
 614     return 0;
 615
 616   /* Compute high word of result, as a flonum.  */
 617   b = (a / HIGH_WORD_COEFF);
 618   /* Convert that to fixed (but not to long long!),
 619      and shift it into the high word.  */
 620   v = (unsigned long int) b;
 621   v <<= WORD_SIZE;
 622   /* Remove high part from the double, leaving the low part as flonum.  */
 623   a -= (double)v;
 624   /* Convert that to fixed (but not to long long!) and add it in.
 625      Sometimes A comes out negative.  This is significant, since
 626      A has more bits than a long int does.  */
 627   if (a < 0)
 628     v -= (unsigned long int) (- a);
 629   else
 630     v += (unsigned long int) a;
 631   return v;
 632 }
 633 #endif
 634
 635 #ifdef L_fixdfdi
 636 long long
 637 __fixdfdi (a)
 638      double a;
 639 {
 640   if (a < 0)
 641     return - __fixunsdfdi (-a);
 642   return __fixunsdfdi (a);
 643 }
 644 #endif
 645
 646 #ifdef L_fixunssfdi
 647 #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
 648 #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
 649
 650 long long
 651 __fixunssfdi (float original_a)
 652 {
 653   /* Convert the float to a double, because that is surely not going
 654      to lose any bits.  Some day someone else can write a faster version
 655      that avoids converting to double, and verify it really works right.  */
 656   double a = original_a;
 657   double b;
 658   unsigned long long v;
 659
 660   if (a < 0)
 661     return 0;
 662
 663   /* Compute high word of result, as a flonum.  */
 664   b = (a / HIGH_WORD_COEFF);
 665   /* Convert that to fixed (but not to long long!),
 666      and shift it into the high word.  */
 667   v = (unsigned long int) b;
 668   v <<= WORD_SIZE;
 669   /* Remove high part from the double, leaving the low part as flonum.  */
 670   a -= (double)v;
 671   /* Convert that to fixed (but not to long long!) and add it in.
 672      Sometimes A comes out negative.  This is significant, since
 673      A has more bits than a long int does.  */
 674   if (a < 0)
 675     v -= (unsigned long int) (- a);
 676   else
 677     v += (unsigned long int) a;
 678   return v;
 679 }
 680 #endif
 681
 682 #ifdef L_fixsfdi
 683 long long
 684 __fixsfdi (float a)
 685 {
 686   if (a < 0)
 687     return - __fixunssfdi (-a);
 688   return __fixunssfdi (a);
 689 }
 690 #endif
 691
 692 #ifdef L_floatdidf
 693 #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
 694 #define HIGH_HALFWORD_COEFF (((long long) 1) << (WORD_SIZE / 2))
 695 #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
 696
 697 double
 698 __floatdidf (u)
 699      long long u;
 700 {
 701   double d;
 702   int negate = 0;
 703
 704   if (u < 0)
 705     u = -u, negate = 1;
 706
 707   d = (unsigned int) (u >> WORD_SIZE);
 708   d *= HIGH_HALFWORD_COEFF;
 709   d *= HIGH_HALFWORD_COEFF;
 710   d += (unsigned int) (u & (HIGH_WORD_COEFF - 1));
 711
 712   return (negate ? -d : d);
 713 }
 714 #endif
 715
 716 #ifdef L_floatdisf
 717 #define WORD_SIZE (sizeof (long) * BITS_PER_UNIT)
 718 #define HIGH_HALFWORD_COEFF (((long long) 1) << (WORD_SIZE / 2))
 719 #define HIGH_WORD_COEFF (((long long) 1) << WORD_SIZE)
 720
 721 float
 722 __floatdisf (u)
 723      long long u;
 724 {
 725   float f;
 726   int negate = 0;
 727
 728   if (u < 0)
 729     u = -u, negate = 1;
 730
 731   f = (unsigned int) (u >> WORD_SIZE);
 732   f *= HIGH_HALFWORD_COEFF;
 733   f *= HIGH_HALFWORD_COEFF;
 734   f += (unsigned int) (u & (HIGH_WORD_COEFF - 1));
 735
 736   return (negate ? -f : f);
 737 }
 738 #endif
 739
 740 #ifdef L_fixunsdfsi
 741 #include "limits.h"
 742
 743 unsigned SItype
 744 __fixunsdfsi (a)
 745      double a;
 746 {
 747   if (a >= - (double) LONG_MIN)
 748     return (SItype) (a + LONG_MIN) - LONG_MIN;
 749   return (SItype) a;
 750 }
 751 #endif
 752
 753 #ifdef L_fixunssfsi
 754 #include "limits.h"
 755
 756 unsigned SItype
 757 __fixunssfsi (float a)
 758 {
 759   if (a >= - (float) LONG_MIN)
 760     return (SItype) (a + LONG_MIN) - LONG_MIN;
 761   return (SItype) a;
 762 }
 763 #endif
 764 \f
 765 #ifdef L_varargs
 766 #ifdef __i860__
 767 #if defined(SVR4) || defined(__alliant__)
 768         asm ("  .text");
 769         asm ("  .align  4");
 770
 771 /* The Alliant needs the added underscore.  */
 772         asm (".globl    __builtin_saveregs");
 773 asm ("__builtin_saveregs:");
 774         asm (".globl    ___builtin_saveregs");
 775 asm ("___builtin_saveregs:");
 776
 777         asm ("  andnot  0x0f,%sp,%sp"); /* round down to 16-byte boundary */
 778         asm ("  adds    -96,%sp,%sp");  /* allocate stack space for reg save
 779                                            area and also for a new va_list
 780                                            structure */
 781         /* Save all argument registers in the arg reg save area.  The
 782            arg reg save area must have the following layout (according
 783            to the svr4 ABI):
 784
 785                 struct {
 786                   union  {
 787                     float freg[8];
 788                     double dreg[4];
 789                   } float_regs;
 790                   long  ireg[12];
 791                 };
 792         */
 793
 794         asm ("  fst.q   %f8,  0(%sp)"); /* save floating regs (f8-f15)  */
 795         asm ("  fst.q   %f12,16(%sp)");
 796
 797         asm ("  st.l    %r16,32(%sp)"); /* save integer regs (r16-r27) */
 798         asm ("  st.l    %r17,36(%sp)");
 799         asm ("  st.l    %r18,40(%sp)");
 800         asm ("  st.l    %r19,44(%sp)");
 801         asm ("  st.l    %r20,48(%sp)");
 802         asm ("  st.l    %r21,52(%sp)");
 803         asm ("  st.l    %r22,56(%sp)");
 804         asm ("  st.l    %r23,60(%sp)");
 805         asm ("  st.l    %r24,64(%sp)");
 806         asm ("  st.l    %r25,68(%sp)");
 807         asm ("  st.l    %r26,72(%sp)");
 808         asm ("  st.l    %r27,76(%sp)");
 809
 810         asm ("  adds    80,%sp,%r16");  /* compute the address of the new
 811                                            va_list structure.  Put in into
 812                                            r16 so that it will be returned
 813                                            to the caller.  */
 814
 815         /* Initialize all fields of the new va_list structure.  This
 816            structure looks like:
 817
 818                 typedef struct {
 819                     unsigned long       ireg_used;
 820                     unsigned long       freg_used;
 821                     long                *reg_base;
 822                     long                *mem_ptr;
 823                 } va_list;
 824         */
 825
 826         asm ("  st.l    %r0, 0(%r16)"); /* nfixed */
 827         asm ("  st.l    %r0, 4(%r16)"); /* nfloating */
 828         asm ("  st.l    %sp, 8(%r16)"); /* __va_ctl points to __va_struct.  */
 829         asm ("  bri     %r1");          /* delayed return */
 830         asm ("  st.l    %r28,12(%r16)"); /* pointer to overflow args */
 831
 832 #else /* not SVR4 */
 833         asm ("  .text");
 834         asm ("  .align  4");
 835
 836         asm (".globl    ___builtin_saveregs");
 837         asm ("___builtin_saveregs:");
 838         asm ("  mov     sp,r30");
 839         asm ("  andnot  0x0f,sp,sp");
 840         asm ("  adds    -96,sp,sp");  /* allocate sufficient space on the stack */
 841
 842 /* Fill in the __va_struct.  */
 843         asm ("  st.l    r16, 0(sp)"); /* save integer regs (r16-r27) */
 844         asm ("  st.l    r17, 4(sp)"); /* int    fixed[12] */
 845         asm ("  st.l    r18, 8(sp)");
 846         asm ("  st.l    r19,12(sp)");
 847         asm ("  st.l    r20,16(sp)");
 848         asm ("  st.l    r21,20(sp)");
 849         asm ("  st.l    r22,24(sp)");
 850         asm ("  st.l    r23,28(sp)");
 851         asm ("  st.l    r24,32(sp)");
 852         asm ("  st.l    r25,36(sp)");
 853         asm ("  st.l    r26,40(sp)");
 854         asm ("  st.l    r27,44(sp)");
 855
 856         asm ("  fst.q   f8, 48(sp)"); /* save floating regs (f8-f15) */
 857         asm ("  fst.q   f12,64(sp)"); /* int floating[8] */
 858
 859 /* Fill in the __va_ctl.  */
 860         asm ("  st.l    sp, 80(sp)"); /* __va_ctl points to __va_struct.  */
 861         asm ("  st.l    r28,84(sp)"); /* pointer to more args */
 862         asm ("  st.l    r0, 88(sp)"); /* nfixed */
 863         asm ("  st.l    r0, 92(sp)"); /* nfloating */
 864
 865         asm ("  adds    80,sp,r16");  /* return address of the __va_ctl.  */
 866         asm ("  bri     r1");
 867         asm ("  mov     r30,sp");
 868                                 /* recover stack and pass address to start
 869                                    of data.  */
 870 #endif /* not SVR4 */
 871 #else /* not __i860__ */
 872 #ifdef __sparc__
 873         asm (".global __builtin_saveregs");
 874         asm ("__builtin_saveregs:");
 875         asm (".global ___builtin_saveregs");
 876         asm ("___builtin_saveregs:");
 877 #ifdef NEED_PROC_COMMAND
 878         asm (".proc 020");
 879 #endif
 880         asm ("st %i0,[%fp+68]");
 881         asm ("st %i1,[%fp+72]");
 882         asm ("st %i2,[%fp+76]");
 883         asm ("st %i3,[%fp+80]");
 884         asm ("st %i4,[%fp+84]");
 885         asm ("retl");
 886         asm ("st %i5,[%fp+88]");
 887 #ifdef NEED_TYPE_COMMAND
 888         asm (".type __builtin_saveregs,#function");
 889         asm (".size __builtin_saveregs,.-__builtin_saveregs");
 890 #endif
 891 #else /* not __sparc__ */
 892 #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
 893
 894   asm ("        .text");
 895   asm ("        .ent __builtin_saveregs");
 896   asm ("        .globl __builtin_saveregs");
 897   asm ("__builtin_saveregs:");
 898   asm ("        sw      $4,0($30)");
 899   asm ("        sw      $5,4($30)");
 900   asm ("        sw      $6,8($30)");
 901   asm ("        sw      $7,12($30)");
 902   asm ("        j       $31");
 903   asm ("        .end __builtin_saveregs");
 904 #else /* not __mips__, etc. */
 905 __builtin_saveregs ()
 906 {
 907   abort ();
 908 }
 909 #endif /* not __mips__ */
 910 #endif /* not __sparc__ */
 911 #endif /* not __i860__ */
 912 #endif
 913 \f
 914 #ifdef L_eprintf
 915 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
 916 #include <stdio.h>
 917 /* This is used by the `assert' macro.  */
 918 void
 919 __eprintf (string, expression, line, filename)
 920      const char *string;
 921      const char *expression;
 922      int line;
 923      const char *filename;
 924 {
 925   fprintf (stderr, string, expression, line, filename);
 926   fflush (stderr);
 927   abort ();
 928 }
 929 #endif
 930
 931 #ifdef L_bb
 932 /* Avoid warning from ranlib about empty object file.  */
 933 void
 934 __bb_avoid_warning ()
 935 {}
 936
 937 #if defined (__sun__) && defined (__mc68000__)
 938 struct bb
 939 {
 940   int initialized;
 941   char *filename;
 942   int *counts;
 943   int ncounts;
 944   int zero_word;
 945   int *addresses;
 946 };
 947
 948 extern int ___tcov_init;
 949
 950 __bb_init_func (blocks)
 951         struct bb *blocks;
 952 {
 953   if (! ___tcov_init)
 954     ___tcov_init_func ();
 955
 956   ___bb_link (blocks->filename, blocks->counts, blocks->ncounts);
 957 }
 958
 959 #endif
 960 #endif
 961 \f
 962 /* frills for C++ */
 963
 964 #ifdef L_builtin_new
 965 typedef void (*vfp)(void);
 966
 967 extern vfp __new_handler;
 968 extern void *malloc ();
 969
 970 void *
 971 __builtin_new (sz)
 972      size_t sz;
 973 {
 974   void *p;
 975
 976   p = malloc (sz);
 977   if (p == 0)
 978     (*__new_handler) ();
 979   return p;
 980 }
 981 #endif
 982
 983 #ifdef L_builtin_New
 984 typedef void (*vfp)(void);
 985
 986 extern void *__builtin_new (size_t);
 987 static void default_new_handler (void);
 988
 989 vfp __new_handler = default_new_handler;
 990
 991 void *
 992 __builtin_vec_new (p, maxindex, size, ctor)
 993      void *p;
 994      size_t maxindex;
 995      size_t size;
 996      void (*ctor)(void *);
 997 {
 998   size_t i;
 999   size_t nelts = maxindex + 1;
1000   void *rval;
1001
1002   if (p == 0)
1003     p = __builtin_new (nelts * size);
1004
1005   rval = p;
1006
1007   for (i = 0; i < nelts; i++)
1008     {
1009       (*ctor) (p);
1010       p += size;
1011     }
1012
1013   return rval;
1014 }
1015
1016 vfp
1017 __set_new_handler (handler)
1018      vfp handler;
1019 {
1020   vfp prev_handler;
1021
1022   prev_handler = __new_handler;
1023   if (handler == 0) handler = default_new_handler;
1024   __new_handler = handler;
1025   return prev_handler;
1026 }
1027
1028 vfp
1029 set_new_handler (handler)
1030      vfp handler;
1031 {
1032   return __set_new_handler (handler);
1033 }
1034
1035 #define MESSAGE "Virtual memory exceeded in `new'\n"
1036
1037 static void
1038 default_new_handler ()
1039 {
1040   /* don't use fprintf (stderr, ...) because it may need to call malloc.  */
1041   /* This should really print the name of the program, but that is hard to
1042      do.  We need a standard, clean way to get at the name.  */
1043   write (2, MESSAGE, sizeof (MESSAGE));
1044   /* don't call exit () because that may call global destructors which
1045      may cause a loop.  */
1046   _exit (-1);
1047 }
1048 #endif
1049 \f
1050 #ifdef L_builtin_del
1051 typedef void (*vfp)(void);
1052
1053 void
1054 __builtin_delete (ptr)
1055      void *ptr;
1056 {
1057   if (ptr)
1058     free (ptr);
1059 }
1060
1061 void
1062 __builtin_vec_delete (ptr, maxindex, size, dtor, auto_delete_vec, auto_delete)
1063      void *ptr;
1064      size_t maxindex;
1065      size_t size;
1066      void (*dtor)(void *, int);
1067      int auto_delete;
1068 {
1069   size_t i;
1070   size_t nelts = maxindex + 1;
1071   void *p = ptr;
1072
1073   ptr += nelts * size;
1074
1075   for (i = 0; i < nelts; i++)
1076     {
1077       ptr -= size;
1078       (*dtor) (ptr, auto_delete);
1079     }
1080
1081   if (auto_delete_vec)
1082     __builtin_delete (p);
1083 }
1084
1085 #endif
1086
1087 #ifdef L_shtab
1088 unsigned int __shtab[] = {
1089     0x00000001, 0x00000002, 0x00000004, 0x00000008,
1090     0x00000010, 0x00000020, 0x00000040, 0x00000080,
1091     0x00000100, 0x00000200, 0x00000400, 0x00000800,
1092     0x00001000, 0x00002000, 0x00004000, 0x00008000,
1093     0x00010000, 0x00020000, 0x00040000, 0x00080000,
1094     0x00100000, 0x00200000, 0x00400000, 0x00800000,
1095     0x01000000, 0x02000000, 0x04000000, 0x08000000,
1096     0x10000000, 0x20000000, 0x40000000, 0x80000000
1097   };
1098 #endif
1099 \f
1100 #ifdef L_clear_cache
1101 /* Clear part of an instruction cache.  */
1102
1103 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1104
1105 void
1106 __clear_cache (beg, end)
1107      char *beg, *end;
1108 {
1109 #ifdef INSN_CACHE_SIZE
1110   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1111   static int initialized = 0;
1112   int offset;
1113   void *start_addr
1114   void *end_addr;
1115   typedef (*function_ptr) ();
1116
1117 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1118   /* It's cheaper to clear the whole cache.
1119      Put in a series of jump instructions so that calling the beginning
1120      of the cache will clear the whole thing.  */
1121
1122   if (! initialized)
1123     {
1124       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1125                  & -INSN_CACHE_LINE_WIDTH);
1126       int end_ptr = ptr + INSN_CACHE_SIZE;
1127
1128       while (ptr < end_ptr)
1129         {
1130           *(INSTRUCTION_TYPE *)ptr
1131             = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1132           ptr += INSN_CACHE_LINE_WIDTH;
1133         }
1134       *(INSTRUCTION_TYPE *)(ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1135
1136       initialized = 1;
1137     }
1138
1139   /* Call the beginning of the sequence.  */
1140   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1141                     & -INSN_CACHE_LINE_WIDTH))
1142    ());
1143
1144 #else /* Cache is large.  */
1145
1146   if (! initialized)
1147     {
1148       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1149                  & -INSN_CACHE_LINE_WIDTH);
1150
1151       while (ptr < (int) array + sizeof array)
1152         {
1153           *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1154           ptr += INSN_CACHE_LINE_WIDTH;
1155         }
1156
1157       initialized = 1;
1158     }
1159
1160   /* Find the location in array that occupies the same cache line as BEG.  */
1161
1162   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1163   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1164                  & -INSN_CACHE_PLANE_SIZE)
1165                 + offset);
1166
1167   /* Compute the cache alignment of the place to stop clearing.  */
1168 #if 0  /* This is not needed for gcc's purposes.  */
1169   /* If the block to clear is bigger than a cache plane,
1170      we clear the entire cache, and OFFSET is already correct.  */
1171   if (end < beg + INSN_CACHE_PLANE_SIZE)
1172 #endif
1173     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1174                & -INSN_CACHE_LINE_WIDTH)
1175               & (INSN_CACHE_PLANE_SIZE - 1));
1176
1177 #if INSN_CACHE_DEPTH > 1
1178   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1179   if (end_addr <= start_addr)
1180     end_addr += INSN_CACHE_PLANE_SIZE;
1181
1182   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1183     {
1184       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1185       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1186
1187       while (addr != stop)
1188         {
1189           /* Call the return instruction at ADDR.  */
1190           ((function_ptr) addr) ();
1191
1192           addr += INSN_CACHE_LINE_WIDTH;
1193         }
1194     }
1195 #else /* just one plane */
1196   do
1197     {
1198       /* Call the return instruction at START_ADDR.  */
1199       ((function_ptr) start_addr) ();
1200
1201       start_addr += INSN_CACHE_LINE_WIDTH;
1202     }
1203   while ((start_addr % INSN_CACHE_SIZE) != offset);
1204 #endif /* just one plane */
1205 #endif /* Cache is large */
1206 #endif /* Cache exists */
1207 }
1208
1209 #endif /* L_clear_cache */
1210 \f
1211 #ifdef L_trampoline
1212
1213 /* Jump to a trampoline, loading the static chain address.  */
1214
1215 #ifdef TRANSFER_FROM_TRAMPOLINE
1216 TRANSFER_FROM_TRAMPOLINE
1217 #endif
1218
1219 #ifdef __convex__
1220
1221 /* Make stack executable so we can call trampolines on stack.
1222    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
1223
1224 #include <sys/mman.h>
1225 #include <sys/vmparam.h>
1226 #include <machine/machparam.h>
1227
1228 void
1229 __enable_execute_stack ()
1230 {
1231   int fp;
1232   static unsigned lowest = USRSTACK;
1233   unsigned current = (unsigned) &fp & -NBPG;
1234
1235   if (lowest > current)
1236     {
1237       unsigned len = lowest - current;
1238       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1239       lowest = current;
1240     }
1241
1242   /* Clear instruction cache in case an old trampoline is in it. */
1243   asm ("pich");
1244 }
1245 #endif /* __convex__ */
1246
1247 #ifdef __pyr__
1248
1249 #include <stdio.h>
1250 #include <sys/mman.h>
1251 #include <sys/types.h>
1252 #include <sys/param.h>
1253 #include <sys/vmmac.h>
1254
1255 /* Modified from the convex -code above.
1256    mremap promises to clear the i-cache. */
1257
1258 void
1259 __enable_execute_stack ()
1260 {
1261   int fp;
1262   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1263                 PROT_READ|PROT_WRITE|PROT_EXEC))
1264     {
1265       perror ("mprotect in __enable_execute_stack");
1266       fflush (stderr);
1267       abort ();
1268     }
1269 }
1270 #endif /* __pyr__ */
1271 #endif /* L_trampoline */
1272 \f
1273 #ifdef L__main
1274
1275 #include "gbl-ctors.h"
1276
1277 /* Run all the global destructors on exit from the program.  */
1278
1279 void
1280 __do_global_dtors ()
1281 {
1282 #ifdef DO_GLOBAL_DTORS_BODY
1283   DO_GLOBAL_DTORS_BODY;
1284 #else
1285   unsigned nptrs = (unsigned) __DTOR_LIST__[0];
1286   unsigned i;
1287
1288   /* Some systems place the number of pointers
1289      in the first word of the table.
1290      On other systems, that word is -1.
1291      In all cases, the table is null-terminated.  */
1292
1293   /* If the length is not recorded, count up to the null.  */
1294   if (nptrs == -1)
1295     for (nptrs = 0; __DTOR_LIST__[nptrs + 1] != 0; nptrs++);
1296
1297   /* GNU LD format.  */
1298   for (i = nptrs; i >= 1; i--)
1299     __DTOR_LIST__[i] ();
1300 #endif
1301 }
1302
1303 #ifndef INIT_SECTION_ASM_OP
1304 /* Run all the global constructors on entry to the program.  */
1305
1306 #ifndef ON_EXIT
1307 #define ON_EXIT(a, b)
1308 #else
1309 /* Make sure the exit routine is pulled in to define the globals as
1310    bss symbols, just in case the linker does not automatically pull
1311    bss definitions from the library.  */
1312
1313 extern int _exit_dummy_decl;
1314 int *_exit_dummy_ref = &_exit_dummy_decl;
1315 #endif /* ON_EXIT */
1316
1317 void
1318 __do_global_ctors ()
1319 {
1320   DO_GLOBAL_CTORS_BODY;
1321   ON_EXIT (__do_global_dtors, 0);
1322 }
1323 #endif /* no INIT_SECTION_ASM_OP */
1324
1325 #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main)
1326 /* Subroutine called automatically by `main'.
1327    Compiling a global function named `main'
1328    produces an automatic call to this function at the beginning.
1329
1330    For many systems, this routine calls __do_global_ctors.
1331    For systems which support a .init section we use the .init section
1332    to run __do_global_ctors, so we need not do anything here.  */
1333
1334 void
1335 __main ()
1336 {
1337   /* Support recursive calls to `main': run initializers just once.  */
1338   static int initialized = 0;
1339   if (! initialized)
1340     {
1341       initialized = 1;
1342       __do_global_ctors ();
1343     }
1344 }
1345 #endif /* no INIT_SECTION_ASM_OP or INVOKE__main */
1346
1347 #endif /* L__main */
1348 \f
1349 #ifdef L_exit
1350
1351 #include "gbl-ctors.h"
1352
1353 /* Provide default definitions for the lists of constructors and
1354    destructors, so that we don't get linker errors.  These symbols are
1355    intentionally bss symbols, so that gld and/or collect will provide
1356    the right values.  */
1357
1358 /* We declare the lists here with two elements each,
1359    so that they are valid empty lists if no other definition is loaded.  */
1360 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1361 func_ptr __CTOR_LIST__[2];
1362 func_ptr __DTOR_LIST__[2];
1363 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1364
1365 #ifndef ON_EXIT
1366
1367 /* If we have no known way of registering our own __do_global_dtors
1368    routine so that it will be invoked at program exit time, then we
1369    have to define our own exit routine which will get this to happen.  */
1370
1371 extern void __do_global_dtors ();
1372 extern void _cleanup ();
1373 extern void _exit ();
1374
1375 void
1376 exit (status)
1377      int status;
1378 {
1379   __do_global_dtors ();
1380 #ifdef EXIT_BODY
1381   EXIT_BODY;
1382 #else
1383   _cleanup ();
1384 #endif
1385   _exit (status);
1386 }
1387
1388 #else
1389 int _exit_dummy_decl = 0;       /* prevent compiler & linker warnings */
1390 #endif
1391
1392 #endif /* L_exit */
1393 \f
1394 /* In a.out systems, we need to have these dummy constructor and destructor
1395    lists in the library.
1396
1397    When using `collect', the first link will resolve __CTOR_LIST__
1398    and __DTOR_LIST__ to these symbols.  We will then run "nm" on the
1399    result, build the correct __CTOR_LIST__ and __DTOR_LIST__, and relink.
1400    Since we don't do the second link if no constructors existed, these
1401    dummies must be fully functional empty lists.
1402
1403    When using `gnu ld', these symbols will be used if there are no
1404    constructors.  If there are constructors, the N_SETV symbol defined
1405    by the linker from the N_SETT's in input files will define __CTOR_LIST__
1406    and __DTOR_LIST__ rather than its being allocated as common storage
1407    by the definitions below.
1408
1409    When using a linker that supports constructor and destructor segments,
1410    these definitions will not be used, since crtbegin.o and crtend.o
1411    (from crtstuff.c) will have already defined __CTOR_LIST__ and
1412     __DTOR_LIST__.  The crt*.o files are passed directly to the linker
1413    on its command line, by gcc.  */
1414
1415 /* The list needs two elements:  one is ignored (the old count); the
1416    second is the terminating zero.  Since both values are zero, this
1417    declaration is not initialized, and it becomes `common'.  */
1418
1419 #ifdef L_ctor_list
1420 #include "gbl-ctors.h"
1421 func_ptr __CTOR_LIST__[2];
1422 #endif
1423
1424 #ifdef L_dtor_list
1425 #include "gbl-ctors.h"
1426 func_ptr __DTOR_LIST__[2];
1427 #endif