home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / libgcc2.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  53KB  |  2,300 lines
  1. /* More subroutines needed by GCC output code on some machines.  */
  2. /* Compile this one with gcc.  */
  3. /* Copyright (C) 1989, 1992, 1993, 1994 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 other files,
  22.    some of which are compiled with GCC, to produce an executable,
  23.    this library does not by itself cause the resulting executable
  24.    to be covered by the GNU General Public License.
  25.    This exception does not however invalidate any other reasons why
  26.    the executable file might be covered by the GNU General Public License.  */
  27.  
  28. /* It is incorrect to include config.h here, because this file is being
  29.    compiled for the target, and hence definitions concerning only the host
  30.    do not apply.  */
  31.  
  32. #include "tconfig.h"
  33. #include "machmode.h"
  34. #ifndef L_trampoline
  35. #include <stddef.h>
  36. #endif
  37.  
  38. /* Don't use `fancy_abort' here even if config.h says to use it.  */
  39. #ifdef abort
  40. #undef abort
  41. #endif
  42.  
  43. /* In the first part of this file, we are interfacing to calls generated
  44.    by the compiler itself.  These calls pass values into these routines
  45.    which have very specific modes (rather than very specific types), and
  46.    these compiler-generated calls also expect any return values to have
  47.    very specific modes (rather than very specific types).  Thus, we need
  48.    to avoid using regular C language type names in this part of the file
  49.    because the sizes for those types can be configured to be anything.
  50.    Instead we use the following special type names.  */
  51.  
  52. typedef unsigned int UQItype    __attribute__ ((mode (QI)));
  53. typedef      int SItype    __attribute__ ((mode (SI)));
  54. typedef unsigned int USItype    __attribute__ ((mode (SI)));
  55. typedef         int DItype    __attribute__ ((mode (DI)));
  56. typedef unsigned int UDItype    __attribute__ ((mode (DI)));
  57. typedef     float SFtype    __attribute__ ((mode (SF)));
  58. typedef        float DFtype    __attribute__ ((mode (DF)));
  59. #if LONG_DOUBLE_TYPE_SIZE == 96
  60. typedef        float XFtype    __attribute__ ((mode (XF)));
  61. #endif
  62. #if LONG_DOUBLE_TYPE_SIZE == 128
  63. typedef        float TFtype    __attribute__ ((mode (TF)));
  64. #endif
  65.  
  66. #if BITS_PER_WORD==16
  67. typedef int word_type __attribute__ ((mode (HI)));
  68. #endif
  69. #if BITS_PER_WORD==32
  70. typedef int word_type __attribute__ ((mode (SI)));
  71. #endif
  72. #if BITS_PER_WORD==64
  73. typedef int word_type __attribute__ ((mode (DI)));
  74. #endif
  75.  
  76. /* Make sure that we don't accidentally use any normal C language built-in
  77.    type names in the first part of this file.  Instead we want to use *only*
  78.    the type names defined above.  The following macro definitions insure
  79.    that if we *do* accidentally use some normal C language built-in type name,
  80.    we will get a syntax error.  */
  81.  
  82. #define char bogus_type
  83. #define short bogus_type
  84. #define int bogus_type
  85. #define long bogus_type
  86. #define unsigned bogus_type
  87. #define float bogus_type
  88. #define double bogus_type
  89.  
  90. #define SI_TYPE_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  91.  
  92. /* DIstructs are pairs of SItype values in the order determined by
  93.    WORDS_BIG_ENDIAN.  */
  94.  
  95. #if WORDS_BIG_ENDIAN
  96.   struct DIstruct {SItype high, low;};
  97. #else
  98.   struct DIstruct {SItype low, high;};
  99. #endif
  100.  
  101. /* We need this union to unpack/pack DImode values, since we don't have
  102.    any arithmetic yet.  Incoming DImode parameters are stored into the
  103.    `ll' field, and the unpacked result is read from the struct `s'.  */
  104.  
  105. typedef union
  106. {
  107.   struct DIstruct s;
  108.   DItype ll;
  109. } DIunion;
  110.  
  111. #if defined (L_udivmoddi4) || defined (L_muldi3) || defined (L_udiv_w_sdiv)
  112.  
  113. #include "longlong.h"
  114.  
  115. #endif /* udiv or mul */
  116.  
  117. extern DItype __fixunssfdi (SFtype a);
  118. extern DItype __fixunsdfdi (DFtype a);
  119. #if LONG_DOUBLE_TYPE_SIZE == 96
  120. extern DItype __fixunsxfdi (XFtype a);
  121. #endif
  122. #if LONG_DOUBLE_TYPE_SIZE == 128
  123. extern DItype __fixunstfdi (TFtype a);
  124. #endif
  125.  
  126. #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
  127. #if defined (L_divdi3) || defined (L_moddi3)
  128. static inline
  129. #endif
  130. DItype
  131. __negdi2 (u)
  132.      DItype u;
  133. {
  134.   DIunion w;
  135.   DIunion uu;
  136.  
  137.   uu.ll = u;
  138.  
  139.   w.s.low = -uu.s.low;
  140.   w.s.high = -uu.s.high - ((USItype) w.s.low > 0);
  141.  
  142.   return w.ll;
  143. }
  144. #endif
  145.  
  146. #ifdef L_lshldi3
  147. DItype
  148. __lshldi3 (u, b)
  149.      DItype u;
  150.      SItype b;
  151. {
  152.   DIunion w;
  153.   SItype bm;
  154.   DIunion uu;
  155.  
  156.   if (b == 0)
  157.     return u;
  158.  
  159.   uu.ll = u;
  160.  
  161.   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
  162.   if (bm <= 0)
  163.     {
  164.       w.s.low = 0;
  165.       w.s.high = (USItype)uu.s.low << -bm;
  166.     }
  167.   else
  168.     {
  169.       USItype carries = (USItype)uu.s.low >> bm;
  170.       w.s.low = (USItype)uu.s.low << b;
  171.       w.s.high = ((USItype)uu.s.high << b) | carries;
  172.     }
  173.  
  174.   return w.ll;
  175. }
  176. #endif
  177.  
  178. #ifdef L_lshrdi3
  179. DItype
  180. __lshrdi3 (u, b)
  181.      DItype u;
  182.      SItype b;
  183. {
  184.   DIunion w;
  185.   SItype bm;
  186.   DIunion uu;
  187.  
  188.   if (b == 0)
  189.     return u;
  190.  
  191.   uu.ll = u;
  192.  
  193.   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
  194.   if (bm <= 0)
  195.     {
  196.       w.s.high = 0;
  197.       w.s.low = (USItype)uu.s.high >> -bm;
  198.     }
  199.   else
  200.     {
  201.       USItype carries = (USItype)uu.s.high << bm;
  202.       w.s.high = (USItype)uu.s.high >> b;
  203.       w.s.low = ((USItype)uu.s.low >> b) | carries;
  204.     }
  205.  
  206.   return w.ll;
  207. }
  208. #endif
  209.  
  210. #ifdef L_ashldi3
  211. DItype
  212. __ashldi3 (u, b)
  213.      DItype u;
  214.      SItype b;
  215. {
  216.   DIunion w;
  217.   SItype bm;
  218.   DIunion uu;
  219.  
  220.   if (b == 0)
  221.     return u;
  222.  
  223.   uu.ll = u;
  224.  
  225.   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
  226.   if (bm <= 0)
  227.     {
  228.       w.s.low = 0;
  229.       w.s.high = (USItype)uu.s.low << -bm;
  230.     }
  231.   else
  232.     {
  233.       USItype carries = (USItype)uu.s.low >> bm;
  234.       w.s.low = (USItype)uu.s.low << b;
  235.       w.s.high = ((USItype)uu.s.high << b) | carries;
  236.     }
  237.  
  238.   return w.ll;
  239. }
  240. #endif
  241.  
  242. #ifdef L_ashrdi3
  243. DItype
  244. __ashrdi3 (u, b)
  245.      DItype u;
  246.      SItype b;
  247. {
  248.   DIunion w;
  249.   SItype bm;
  250.   DIunion uu;
  251.  
  252.   if (b == 0)
  253.     return u;
  254.  
  255.   uu.ll = u;
  256.  
  257.   bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
  258.   if (bm <= 0)
  259.     {
  260.       /* w.s.high = 1..1 or 0..0 */
  261.       w.s.high = uu.s.high >> (sizeof (SItype) * BITS_PER_UNIT - 1);
  262.       w.s.low = uu.s.high >> -bm;
  263.     }
  264.   else
  265.     {
  266.       USItype carries = (USItype)uu.s.high << bm;
  267.       w.s.high = uu.s.high >> b;
  268.       w.s.low = ((USItype)uu.s.low >> b) | carries;
  269.     }
  270.  
  271.   return w.ll;
  272. }
  273. #endif
  274.  
  275. #ifdef L_ffsdi2
  276. DItype
  277. __ffsdi2 (u)
  278.      DItype u;
  279. {
  280.   DIunion uu, w;
  281.   uu.ll = u;
  282.   w.s.high = 0;
  283.   w.s.low = ffs (uu.s.low);
  284.   if (w.s.low != 0)
  285.     return w.ll;
  286.   w.s.low = ffs (uu.s.high);
  287.   if (w.s.low != 0)
  288.     {
  289.       w.s.low += BITS_PER_UNIT * sizeof (SItype);
  290.       return w.ll;
  291.     }
  292.   return w.ll;
  293. }
  294. #endif
  295.  
  296. #ifdef L_muldi3
  297. DItype
  298. __muldi3 (u, v)
  299.      DItype u, v;
  300. {
  301.   DIunion w;
  302.   DIunion uu, vv;
  303.  
  304.   uu.ll = u,
  305.   vv.ll = v;
  306.  
  307.   w.ll = __umulsidi3 (uu.s.low, vv.s.low);
  308.   w.s.high += ((USItype) uu.s.low * (USItype) vv.s.high
  309.            + (USItype) uu.s.high * (USItype) vv.s.low);
  310.  
  311.   return w.ll;
  312. }
  313. #endif
  314.  
  315. #ifdef L_udiv_w_sdiv
  316. USItype
  317. __udiv_w_sdiv (rp, a1, a0, d)
  318.      USItype *rp, a1, a0, d;
  319. {
  320.   USItype q, r;
  321.   USItype c0, c1, b1;
  322.  
  323.   if ((SItype) d >= 0)
  324.     {
  325.       if (a1 < d - a1 - (a0 >> (SI_TYPE_SIZE - 1)))
  326.     {
  327.       /* dividend, divisor, and quotient are nonnegative */
  328.       sdiv_qrnnd (q, r, a1, a0, d);
  329.     }
  330.       else
  331.     {
  332.       /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
  333.       sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (SI_TYPE_SIZE - 1));
  334.       /* Divide (c1*2^32 + c0) by d */
  335.       sdiv_qrnnd (q, r, c1, c0, d);
  336.       /* Add 2^31 to quotient */
  337.       q += (USItype) 1 << (SI_TYPE_SIZE - 1);
  338.     }
  339.     }
  340.   else
  341.     {
  342.       b1 = d >> 1;            /* d/2, between 2^30 and 2^31 - 1 */
  343.       c1 = a1 >> 1;            /* A/2 */
  344.       c0 = (a1 << (SI_TYPE_SIZE - 1)) + (a0 >> 1);
  345.  
  346.       if (a1 < b1)            /* A < 2^32*b1, so A/2 < 2^31*b1 */
  347.     {
  348.       sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
  349.  
  350.       r = 2*r + (a0 & 1);        /* Remainder from A/(2*b1) */
  351.       if ((d & 1) != 0)
  352.         {
  353.           if (r >= q)
  354.         r = r - q;
  355.           else if (q - r <= d)
  356.         {
  357.           r = r - q + d;
  358.           q--;
  359.         }
  360.           else
  361.         {
  362.           r = r - q + 2*d;
  363.           q -= 2;
  364.         }
  365.         }
  366.     }
  367.       else if (c1 < b1)            /* So 2^31 <= (A/2)/b1 < 2^32 */
  368.     {
  369.       c1 = (b1 - 1) - c1;
  370.       c0 = ~c0;            /* logical NOT */
  371.  
  372.       sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
  373.  
  374.       q = ~q;            /* (A/2)/b1 */
  375.       r = (b1 - 1) - r;
  376.  
  377.       r = 2*r + (a0 & 1);        /* A/(2*b1) */
  378.  
  379.       if ((d & 1) != 0)
  380.         {
  381.           if (r >= q)
  382.         r = r - q;
  383.           else if (q - r <= d)
  384.         {
  385.           r = r - q + d;
  386.           q--;
  387.         }
  388.           else
  389.         {
  390.           r = r - q + 2*d;
  391.           q -= 2;
  392.         }
  393.         }
  394.     }
  395.       else                /* Implies c1 = b1 */
  396.     {                /* Hence a1 = d - 1 = 2*b1 - 1 */
  397.       if (a0 >= -d)
  398.         {
  399.           q = -1;
  400.           r = a0 + d;
  401.         }
  402.       else
  403.         {
  404.           q = -2;
  405.           r = a0 + 2*d;
  406.         }
  407.     }
  408.     }
  409.  
  410.   *rp = r;
  411.   return q;
  412. }
  413. #endif
  414.  
  415. #ifdef L_udivmoddi4
  416. static const UQItype __clz_tab[] =
  417. {
  418.   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,
  419.   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,
  420.   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,
  421.   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,
  422.   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,
  423.   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,
  424.   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,
  425.   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,
  426. };
  427.  
  428. UDItype
  429. __udivmoddi4 (n, d, rp)
  430.      UDItype n, d;
  431.      UDItype *rp;
  432. {
  433.   DIunion ww;
  434.   DIunion nn, dd;
  435.   DIunion rr;
  436.   USItype d0, d1, n0, n1, n2;
  437.   USItype q0, q1;
  438.   USItype b, bm;
  439.  
  440.   nn.ll = n;
  441.   dd.ll = d;
  442.  
  443.   d0 = dd.s.low;
  444.   d1 = dd.s.high;
  445.   n0 = nn.s.low;
  446.   n1 = nn.s.high;
  447.  
  448. #if !UDIV_NEEDS_NORMALIZATION
  449.   if (d1 == 0)
  450.     {
  451.       if (d0 > n1)
  452.     {
  453.       /* 0q = nn / 0D */
  454.  
  455.       udiv_qrnnd (q0, n0, n1, n0, d0);
  456.       q1 = 0;
  457.  
  458.       /* Remainder in n0.  */
  459.     }
  460.       else
  461.     {
  462.       /* qq = NN / 0d */
  463.  
  464.       if (d0 == 0)
  465.         d0 = 1 / d0;    /* Divide intentionally by zero.  */
  466.  
  467.       udiv_qrnnd (q1, n1, 0, n1, d0);
  468.       udiv_qrnnd (q0, n0, n1, n0, d0);
  469.  
  470.       /* Remainder in n0.  */
  471.     }
  472.  
  473.       if (rp != 0)
  474.     {
  475.       rr.s.low = n0;
  476.       rr.s.high = 0;
  477.       *rp = rr.ll;
  478.     }
  479.     }
  480.  
  481. #else /* UDIV_NEEDS_NORMALIZATION */
  482.  
  483.   if (d1 == 0)
  484.     {
  485.       if (d0 > n1)
  486.     {
  487.       /* 0q = nn / 0D */
  488.  
  489.       count_leading_zeros (bm, d0);
  490.  
  491.       if (bm != 0)
  492.         {
  493.           /* Normalize, i.e. make the most significant bit of the
  494.          denominator set.  */
  495.  
  496.           d0 = d0 << bm;
  497.           n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm));
  498.           n0 = n0 << bm;
  499.         }
  500.  
  501.       udiv_qrnnd (q0, n0, n1, n0, d0);
  502.       q1 = 0;
  503.  
  504.       /* Remainder in n0 >> bm.  */
  505.     }
  506.       else
  507.     {
  508.       /* qq = NN / 0d */
  509.  
  510.       if (d0 == 0)
  511.         d0 = 1 / d0;    /* Divide intentionally by zero.  */
  512.  
  513.       count_leading_zeros (bm, d0);
  514.  
  515.       if (bm == 0)
  516.         {
  517.           /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
  518.          conclude (the most significant bit of n1 is set) /\ (the
  519.          leading quotient digit q1 = 1).
  520.  
  521.          This special case is necessary, not an optimization.
  522.          (Shifts counts of SI_TYPE_SIZE are undefined.)  */
  523.  
  524.           n1 -= d0;
  525.           q1 = 1;
  526.         }
  527.       else
  528.         {
  529.           /* Normalize.  */
  530.  
  531.           b = SI_TYPE_SIZE - bm;
  532.  
  533.           d0 = d0 << bm;
  534.           n2 = n1 >> b;
  535.           n1 = (n1 << bm) | (n0 >> b);
  536.           n0 = n0 << bm;
  537.  
  538.           udiv_qrnnd (q1, n1, n2, n1, d0);
  539.         }
  540.  
  541.       /* n1 != d0... */
  542.  
  543.       udiv_qrnnd (q0, n0, n1, n0, d0);
  544.  
  545.       /* Remainder in n0 >> bm.  */
  546.     }
  547.  
  548.       if (rp != 0)
  549.     {
  550.       rr.s.low = n0 >> bm;
  551.       rr.s.high = 0;
  552.       *rp = rr.ll;
  553.     }
  554.     }
  555. #endif /* UDIV_NEEDS_NORMALIZATION */
  556.  
  557.   else
  558.     {
  559.       if (d1 > n1)
  560.     {
  561.       /* 00 = nn / DD */
  562.  
  563.       q0 = 0;
  564.       q1 = 0;
  565.  
  566.       /* Remainder in n1n0.  */
  567.       if (rp != 0)
  568.         {
  569.           rr.s.low = n0;
  570.           rr.s.high = n1;
  571.           *rp = rr.ll;
  572.         }
  573.     }
  574.       else
  575.     {
  576.       /* 0q = NN / dd */
  577.  
  578.       count_leading_zeros (bm, d1);
  579.       if (bm == 0)
  580.         {
  581.           /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
  582.          conclude (the most significant bit of n1 is set) /\ (the
  583.          quotient digit q0 = 0 or 1).
  584.  
  585.          This special case is necessary, not an optimization.  */
  586.  
  587.           /* The condition on the next line takes advantage of that
  588.          n1 >= d1 (true due to program flow).  */
  589.           if (n1 > d1 || n0 >= d0)
  590.         {
  591.           q0 = 1;
  592.           sub_ddmmss (n1, n0, n1, n0, d1, d0);
  593.         }
  594.           else
  595.         q0 = 0;
  596.  
  597.           q1 = 0;
  598.  
  599.           if (rp != 0)
  600.         {
  601.           rr.s.low = n0;
  602.           rr.s.high = n1;
  603.           *rp = rr.ll;
  604.         }
  605.         }
  606.       else
  607.         {
  608.           USItype m1, m0;
  609.           /* Normalize.  */
  610.  
  611.           b = SI_TYPE_SIZE - bm;
  612.  
  613.           d1 = (d1 << bm) | (d0 >> b);
  614.           d0 = d0 << bm;
  615.           n2 = n1 >> b;
  616.           n1 = (n1 << bm) | (n0 >> b);
  617.           n0 = n0 << bm;
  618.  
  619.           udiv_qrnnd (q0, n1, n2, n1, d1);
  620.           umul_ppmm (m1, m0, q0, d0);
  621.  
  622.           if (m1 > n1 || (m1 == n1 && m0 > n0))
  623.         {
  624.           q0--;
  625.           sub_ddmmss (m1, m0, m1, m0, d1, d0);
  626.         }
  627.  
  628.           q1 = 0;
  629.  
  630.           /* Remainder in (n1n0 - m1m0) >> bm.  */
  631.           if (rp != 0)
  632.         {
  633.           sub_ddmmss (n1, n0, n1, n0, m1, m0);
  634.           rr.s.low = (n1 << b) | (n0 >> bm);
  635.           rr.s.high = n1 >> bm;
  636.           *rp = rr.ll;
  637.         }
  638.         }
  639.     }
  640.     }
  641.  
  642.   ww.s.low = q0;
  643.   ww.s.high = q1;
  644.   return ww.ll;
  645. }
  646. #endif
  647.  
  648. #ifdef L_divdi3
  649. UDItype __udivmoddi4 ();
  650.  
  651. DItype
  652. __divdi3 (u, v)
  653.      DItype u, v;
  654. {
  655.   SItype c = 0;
  656.   DIunion uu, vv;
  657.   DItype w;
  658.  
  659.   uu.ll = u;
  660.   vv.ll = v;
  661.  
  662.   if (uu.s.high < 0)
  663.     c = ~c,
  664.     uu.ll = __negdi2 (uu.ll);
  665.   if (vv.s.high < 0)
  666.     c = ~c,
  667.     vv.ll = __negdi2 (vv.ll);
  668.  
  669.   w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0);
  670.   if (c)
  671.     w = __negdi2 (w);
  672.  
  673.   return w;
  674. }
  675. #endif
  676.  
  677. #ifdef L_moddi3
  678. UDItype __udivmoddi4 ();
  679. DItype
  680. __moddi3 (u, v)
  681.      DItype u, v;
  682. {
  683.   SItype c = 0;
  684.   DIunion uu, vv;
  685.   DItype w;
  686.  
  687.   uu.ll = u;
  688.   vv.ll = v;
  689.  
  690.   if (uu.s.high < 0)
  691.     c = ~c,
  692.     uu.ll = __negdi2 (uu.ll);
  693.   if (vv.s.high < 0)
  694.     vv.ll = __negdi2 (vv.ll);
  695.  
  696.   (void) __udivmoddi4 (uu.ll, vv.ll, &w);
  697.   if (c)
  698.     w = __negdi2 (w);
  699.  
  700.   return w;
  701. }
  702. #endif
  703.  
  704. #ifdef L_umoddi3
  705. UDItype __udivmoddi4 ();
  706. UDItype
  707. __umoddi3 (u, v)
  708.      UDItype u, v;
  709. {
  710.   UDItype w;
  711.  
  712.   (void) __udivmoddi4 (u, v, &w);
  713.  
  714.   return w;
  715. }
  716. #endif
  717.  
  718. #ifdef L_udivdi3
  719. UDItype __udivmoddi4 ();
  720. UDItype
  721. __udivdi3 (n, d)
  722.      UDItype n, d;
  723. {
  724.   return __udivmoddi4 (n, d, (UDItype *) 0);
  725. }
  726. #endif
  727.  
  728. #ifdef L_cmpdi2
  729. word_type
  730. __cmpdi2 (a, b)
  731.      DItype a, b;
  732. {
  733.   DIunion au, bu;
  734.  
  735.   au.ll = a, bu.ll = b;
  736.  
  737.   if (au.s.high < bu.s.high)
  738.     return 0;
  739.   else if (au.s.high > bu.s.high)
  740.     return 2;
  741.   if ((USItype) au.s.low < (USItype) bu.s.low)
  742.     return 0;
  743.   else if ((USItype) au.s.low > (USItype) bu.s.low)
  744.     return 2;
  745.   return 1;
  746. }
  747. #endif
  748.  
  749. #ifdef L_ucmpdi2
  750. word_type
  751. __ucmpdi2 (a, b)
  752.      DItype a, b;
  753. {
  754.   DIunion au, bu;
  755.  
  756.   au.ll = a, bu.ll = b;
  757.  
  758.   if ((USItype) au.s.high < (USItype) bu.s.high)
  759.     return 0;
  760.   else if ((USItype) au.s.high > (USItype) bu.s.high)
  761.     return 2;
  762.   if ((USItype) au.s.low < (USItype) bu.s.low)
  763.     return 0;
  764.   else if ((USItype) au.s.low > (USItype) bu.s.low)
  765.     return 2;
  766.   return 1;
  767. }
  768. #endif
  769.  
  770. #if defined(L_fixunstfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
  771. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  772. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  773.  
  774. DItype
  775. __fixunstfdi (a)
  776.      TFtype a;
  777. {
  778.   TFtype b;
  779.   UDItype v;
  780.  
  781.   if (a < 0)
  782.     return 0;
  783.  
  784.   /* Compute high word of result, as a flonum.  */
  785.   b = (a / HIGH_WORD_COEFF);
  786.   /* Convert that to fixed (but not to DItype!),
  787.      and shift it into the high word.  */
  788.   v = (USItype) b;
  789.   v <<= WORD_SIZE;
  790.   /* Remove high part from the TFtype, leaving the low part as flonum.  */
  791.   a -= (TFtype)v;
  792.   /* Convert that to fixed (but not to DItype!) and add it in.
  793.      Sometimes A comes out negative.  This is significant, since
  794.      A has more bits than a long int does.  */
  795.   if (a < 0)
  796.     v -= (USItype) (- a);
  797.   else
  798.     v += (USItype) a;
  799.   return v;
  800. }
  801. #endif
  802.  
  803. #if defined(L_fixtfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
  804. DItype
  805. __fixtfdi (a)
  806.      TFtype a;
  807. {
  808.   if (a < 0)
  809.     return - __fixunstfdi (-a);
  810.   return __fixunstfdi (a);
  811. }
  812. #endif
  813.  
  814. #if defined(L_fixunsxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
  815. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  816. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  817.  
  818. DItype
  819. __fixunsxfdi (a)
  820.      XFtype a;
  821. {
  822.   XFtype b;
  823.   UDItype v;
  824.  
  825.   if (a < 0)
  826.     return 0;
  827.  
  828.   /* Compute high word of result, as a flonum.  */
  829.   b = (a / HIGH_WORD_COEFF);
  830.   /* Convert that to fixed (but not to DItype!),
  831.      and shift it into the high word.  */
  832.   v = (USItype) b;
  833.   v <<= WORD_SIZE;
  834.   /* Remove high part from the XFtype, leaving the low part as flonum.  */
  835.   a -= (XFtype)v;
  836.   /* Convert that to fixed (but not to DItype!) and add it in.
  837.      Sometimes A comes out negative.  This is significant, since
  838.      A has more bits than a long int does.  */
  839.   if (a < 0)
  840.     v -= (USItype) (- a);
  841.   else
  842.     v += (USItype) a;
  843.   return v;
  844. }
  845. #endif
  846.  
  847. #if defined(L_fixxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
  848. DItype
  849. __fixxfdi (a)
  850.      XFtype a;
  851. {
  852.   if (a < 0)
  853.     return - __fixunsxfdi (-a);
  854.   return __fixunsxfdi (a);
  855. }
  856. #endif
  857.  
  858. #ifdef L_fixunsdfdi
  859. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  860. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  861.  
  862. DItype
  863. __fixunsdfdi (a)
  864.      DFtype a;
  865. {
  866.   DFtype b;
  867.   UDItype v;
  868.  
  869.   if (a < 0)
  870.     return 0;
  871.  
  872.   /* Compute high word of result, as a flonum.  */
  873.   b = (a / HIGH_WORD_COEFF);
  874.   /* Convert that to fixed (but not to DItype!),
  875.      and shift it into the high word.  */
  876.   v = (USItype) b;
  877.   v <<= WORD_SIZE;
  878.   /* Remove high part from the DFtype, leaving the low part as flonum.  */
  879.   a -= (DFtype)v;
  880.   /* Convert that to fixed (but not to DItype!) and add it in.
  881.      Sometimes A comes out negative.  This is significant, since
  882.      A has more bits than a long int does.  */
  883.   if (a < 0)
  884.     v -= (USItype) (- a);
  885.   else
  886.     v += (USItype) a;
  887.   return v;
  888. }
  889. #endif
  890.  
  891. #ifdef L_fixdfdi
  892. DItype
  893. __fixdfdi (a)
  894.      DFtype a;
  895. {
  896.   if (a < 0)
  897.     return - __fixunsdfdi (-a);
  898.   return __fixunsdfdi (a);
  899. }
  900. #endif
  901.  
  902. #ifdef L_fixunssfdi
  903. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  904. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  905.  
  906. DItype
  907. __fixunssfdi (SFtype original_a)
  908. {
  909.   /* Convert the SFtype to a DFtype, because that is surely not going
  910.      to lose any bits.  Some day someone else can write a faster version
  911.      that avoids converting to DFtype, and verify it really works right.  */
  912.   DFtype a = original_a;
  913.   DFtype b;
  914.   UDItype v;
  915.  
  916.   if (a < 0)
  917.     return 0;
  918.  
  919.   /* Compute high word of result, as a flonum.  */
  920.   b = (a / HIGH_WORD_COEFF);
  921.   /* Convert that to fixed (but not to DItype!),
  922.      and shift it into the high word.  */
  923.   v = (USItype) b;
  924.   v <<= WORD_SIZE;
  925.   /* Remove high part from the DFtype, leaving the low part as flonum.  */
  926.   a -= (DFtype)v;
  927.   /* Convert that to fixed (but not to DItype!) and add it in.
  928.      Sometimes A comes out negative.  This is significant, since
  929.      A has more bits than a long int does.  */
  930.   if (a < 0)
  931.     v -= (USItype) (- a);
  932.   else
  933.     v += (USItype) a;
  934.   return v;
  935. }
  936. #endif
  937.  
  938. #ifdef L_fixsfdi
  939. DItype
  940. __fixsfdi (SFtype a)
  941. {
  942.   if (a < 0)
  943.     return - __fixunssfdi (-a);
  944.   return __fixunssfdi (a);
  945. }
  946. #endif
  947.  
  948. #if defined(L_floatdixf) && (LONG_DOUBLE_TYPE_SIZE == 96)
  949. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  950. #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
  951. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  952.  
  953. XFtype
  954. __floatdixf (u)
  955.      DItype u;
  956. {
  957.   XFtype d;
  958.   SItype negate = 0;
  959.  
  960.   if (u < 0)
  961.     u = -u, negate = 1;
  962.  
  963.   d = (USItype) (u >> WORD_SIZE);
  964.   d *= HIGH_HALFWORD_COEFF;
  965.   d *= HIGH_HALFWORD_COEFF;
  966.   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
  967.  
  968.   return (negate ? -d : d);
  969. }
  970. #endif
  971.  
  972. #if defined(L_floatditf) && (LONG_DOUBLE_TYPE_SIZE == 128)
  973. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  974. #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
  975. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  976.  
  977. TFtype
  978. __floatditf (u)
  979.      DItype u;
  980. {
  981.   TFtype d;
  982.   SItype negate = 0;
  983.  
  984.   if (u < 0)
  985.     u = -u, negate = 1;
  986.  
  987.   d = (USItype) (u >> WORD_SIZE);
  988.   d *= HIGH_HALFWORD_COEFF;
  989.   d *= HIGH_HALFWORD_COEFF;
  990.   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
  991.  
  992.   return (negate ? -d : d);
  993. }
  994. #endif
  995.  
  996. #ifdef L_floatdidf
  997. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  998. #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
  999. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  1000.  
  1001. DFtype
  1002. __floatdidf (u)
  1003.      DItype u;
  1004. {
  1005.   DFtype d;
  1006.   SItype negate = 0;
  1007.  
  1008.   if (u < 0)
  1009.     u = -u, negate = 1;
  1010.  
  1011.   d = (USItype) (u >> WORD_SIZE);
  1012.   d *= HIGH_HALFWORD_COEFF;
  1013.   d *= HIGH_HALFWORD_COEFF;
  1014.   d += (USItype) (u & (HIGH_WORD_COEFF - 1));
  1015.  
  1016.   return (negate ? -d : d);
  1017. }
  1018. #endif
  1019.  
  1020. #ifdef L_floatdisf
  1021. #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
  1022. #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
  1023. #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
  1024. #define DI_SIZE (sizeof (DItype) * BITS_PER_UNIT)
  1025. #if TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
  1026. #define DF_SIZE 53
  1027. #define SF_SIZE 24
  1028. #else
  1029. #if TARGET_FLOAT_FORMAT == IBM_FLOAT_FORMAT
  1030. #define DF_SIZE 56
  1031. #define SF_SIZE 24
  1032. #else
  1033. #if TARGET_FLOAT_FORMAT == VAX_FLOAT_FORMAT
  1034. #define DF_SIZE 56
  1035. #define SF_SIZE 24
  1036. #else
  1037. #define DF_SIZE 0
  1038. #define SF_SIZE 0
  1039. #endif
  1040. #endif
  1041. #endif
  1042.  
  1043.  
  1044. SFtype
  1045. __floatdisf (u)
  1046.      DItype u;
  1047. {
  1048.   /* Do the calculation in DFmode
  1049.      so that we don't lose any of the precision of the high word
  1050.      while multiplying it.  */
  1051.   DFtype f;
  1052.   SItype negate = 0;
  1053.  
  1054.   if (u < 0)
  1055.     u = -u, negate = 1;
  1056.  
  1057.   /* Protect against double-rounding error.
  1058.      Represent any low-order bits, that might be truncated in DFmode,
  1059.      by a bit that won't be lost.  The bit can go in anywhere below the
  1060.      rounding position of the SFmode.  A fixed mask and bit position
  1061.      handles all usual configurations.  It doesn't handle the case
  1062.      of 128-bit DImode, however.  */
  1063.   if (DF_SIZE < DI_SIZE
  1064.       && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
  1065.     {
  1066. #define REP_BIT ((USItype) 1 << (DI_SIZE - DF_SIZE))
  1067.       if (u >= ((UDItype) 1 << DF_SIZE))
  1068.     {
  1069.       if ((USItype) u & (REP_BIT - 1))
  1070.         u |= REP_BIT;
  1071.     }
  1072.     }
  1073.   f = (USItype) (u >> WORD_SIZE);
  1074.   f *= HIGH_HALFWORD_COEFF;
  1075.   f *= HIGH_HALFWORD_COEFF;
  1076.   f += (USItype) (u & (HIGH_WORD_COEFF - 1));
  1077.  
  1078.   return (SFtype) (negate ? -f : f);
  1079. }
  1080. #endif
  1081.  
  1082. #if defined(L_fixunsxfsi) && LONG_DOUBLE_TYPE_SIZE == 96
  1083. #include "glimits.h"
  1084.  
  1085. USItype
  1086. __fixunsxfsi (a)
  1087.      XFtype a;
  1088. {
  1089.   if (a >= - (DFtype) LONG_MIN)
  1090.     return (SItype) (a + LONG_MIN) - LONG_MIN;
  1091.   return (SItype) a;
  1092. }
  1093. #endif
  1094.  
  1095. #ifdef L_fixunsdfsi
  1096. #include "glimits.h"
  1097.  
  1098. USItype
  1099. __fixunsdfsi (a)
  1100.      DFtype a;
  1101. {
  1102.   if (a >= - (DFtype) LONG_MIN)
  1103.     return (SItype) (a + LONG_MIN) - LONG_MIN;
  1104.   return (SItype) a;
  1105. }
  1106. #endif
  1107.  
  1108. #ifdef L_fixunssfsi
  1109. #include "glimits.h"
  1110.  
  1111. USItype
  1112. __fixunssfsi (SFtype a)
  1113. {
  1114.   if (a >= - (SFtype) LONG_MIN)
  1115.     return (SItype) (a + LONG_MIN) - LONG_MIN;
  1116.   return (SItype) a;
  1117. }
  1118. #endif
  1119.  
  1120. /* From here on down, the routines use normal data types.  */
  1121.  
  1122. #define SItype bogus_type
  1123. #define USItype bogus_type
  1124. #define DItype bogus_type
  1125. #define UDItype bogus_type
  1126. #define SFtype bogus_type
  1127. #define DFtype bogus_type
  1128.  
  1129. #undef char
  1130. #undef short
  1131. #undef int
  1132. #undef long
  1133. #undef unsigned
  1134. #undef float
  1135. #undef double
  1136.  
  1137. #ifdef L__gcc_bcmp
  1138.  
  1139. /* Like bcmp except the sign is meaningful.
  1140.    Reult is negative if S1 is less than S2,
  1141.    positive if S1 is greater, 0 if S1 and S2 are equal.  */
  1142.  
  1143. int
  1144. __gcc_bcmp (s1, s2, size)
  1145.      unsigned char *s1, *s2;
  1146.      size_t size;
  1147. {
  1148.   while (size > 0)
  1149.     {
  1150.       unsigned char c1 = *s1++, c2 = *s2++;
  1151.       if (c1 != c2)
  1152.     return c1 - c2;
  1153.       size--;
  1154.     }
  1155.   return 0;
  1156. }
  1157.  
  1158. #endif
  1159.  
  1160. #ifdef L_varargs
  1161. #ifdef __i860__
  1162. #if defined(__svr4__) || defined(__alliant__)
  1163.     asm ("    .text");
  1164.     asm ("    .align    4");
  1165.  
  1166. /* The Alliant needs the added underscore.  */
  1167.     asm (".globl    __builtin_saveregs");
  1168. asm ("__builtin_saveregs:");
  1169.     asm (".globl    ___builtin_saveregs");
  1170. asm ("___builtin_saveregs:");
  1171.  
  1172.         asm ("    andnot    0x0f,%sp,%sp");    /* round down to 16-byte boundary */
  1173.     asm ("    adds    -96,%sp,%sp");  /* allocate stack space for reg save
  1174.                        area and also for a new va_list
  1175.                        structure */
  1176.     /* Save all argument registers in the arg reg save area.  The
  1177.        arg reg save area must have the following layout (according
  1178.        to the svr4 ABI):
  1179.  
  1180.         struct {
  1181.           union  {
  1182.             float freg[8];
  1183.             double dreg[4];
  1184.           } float_regs;
  1185.           long    ireg[12];
  1186.         };
  1187.     */
  1188.  
  1189.     asm ("    fst.q    %f8,  0(%sp)"); /* save floating regs (f8-f15)  */
  1190.     asm ("    fst.q    %f12,16(%sp)"); 
  1191.  
  1192.     asm ("    st.l    %r16,32(%sp)"); /* save integer regs (r16-r27) */
  1193.     asm ("    st.l    %r17,36(%sp)"); 
  1194.     asm ("    st.l    %r18,40(%sp)");
  1195.     asm ("    st.l    %r19,44(%sp)");
  1196.     asm ("    st.l    %r20,48(%sp)");
  1197.     asm ("    st.l    %r21,52(%sp)");
  1198.     asm ("    st.l    %r22,56(%sp)");
  1199.     asm ("    st.l    %r23,60(%sp)");
  1200.     asm ("    st.l    %r24,64(%sp)");
  1201.     asm ("    st.l    %r25,68(%sp)");
  1202.     asm ("    st.l    %r26,72(%sp)");
  1203.     asm ("    st.l    %r27,76(%sp)");
  1204.  
  1205.     asm ("    adds    80,%sp,%r16");  /* compute the address of the new
  1206.                        va_list structure.  Put in into
  1207.                        r16 so that it will be returned
  1208.                        to the caller.  */
  1209.  
  1210.     /* Initialize all fields of the new va_list structure.  This
  1211.        structure looks like:
  1212.  
  1213.         typedef struct {
  1214.             unsigned long    ireg_used;
  1215.             unsigned long    freg_used;
  1216.             long        *reg_base;
  1217.             long        *mem_ptr;
  1218.         } va_list;
  1219.     */
  1220.  
  1221.     asm ("    st.l    %r0, 0(%r16)"); /* nfixed */
  1222.     asm ("    st.l    %r0, 4(%r16)"); /* nfloating */
  1223.     asm ("  st.l    %sp, 8(%r16)"); /* __va_ctl points to __va_struct.  */
  1224.     asm ("    bri    %r1");        /* delayed return */
  1225.     asm ("    st.l    %r28,12(%r16)"); /* pointer to overflow args */
  1226.  
  1227. #else /* not __svr4__ */
  1228. #if defined(__PARAGON__)
  1229.     /*
  1230.      *    we'll use SVR4-ish varargs but need SVR3.2 assembler syntax,
  1231.      *    and we stand a better chance of hooking into libraries
  1232.      *    compiled by PGI.  [andyp@ssd.intel.com]
  1233.      */
  1234.     asm ("    .text");
  1235.     asm ("    .align    4");
  1236.     asm (".globl    __builtin_saveregs");
  1237. asm ("__builtin_saveregs:");
  1238.     asm (".globl    ___builtin_saveregs");
  1239. asm ("___builtin_saveregs:");
  1240.  
  1241.         asm ("    andnot    0x0f,sp,sp");    /* round down to 16-byte boundary */
  1242.     asm ("    adds    -96,sp,sp");    /* allocate stack space for reg save
  1243.                        area and also for a new va_list
  1244.                        structure */
  1245.     /* Save all argument registers in the arg reg save area.  The
  1246.        arg reg save area must have the following layout (according
  1247.        to the svr4 ABI):
  1248.  
  1249.         struct {
  1250.           union  {
  1251.             float freg[8];
  1252.             double dreg[4];
  1253.           } float_regs;
  1254.           long    ireg[12];
  1255.         };
  1256.     */
  1257.  
  1258.     asm ("    fst.q    f8,  0(sp)");
  1259.     asm ("    fst.q    f12,16(sp)"); 
  1260.     asm ("    st.l    r16,32(sp)");
  1261.     asm ("    st.l    r17,36(sp)"); 
  1262.     asm ("    st.l    r18,40(sp)");
  1263.     asm ("    st.l    r19,44(sp)");
  1264.     asm ("    st.l    r20,48(sp)");
  1265.     asm ("    st.l    r21,52(sp)");
  1266.     asm ("    st.l    r22,56(sp)");
  1267.     asm ("    st.l    r23,60(sp)");
  1268.     asm ("    st.l    r24,64(sp)");
  1269.     asm ("    st.l    r25,68(sp)");
  1270.     asm ("    st.l    r26,72(sp)");
  1271.     asm ("    st.l    r27,76(sp)");
  1272.  
  1273.     asm ("    adds    80,sp,r16");  /* compute the address of the new
  1274.                        va_list structure.  Put in into
  1275.                        r16 so that it will be returned
  1276.                        to the caller.  */
  1277.  
  1278.     /* Initialize all fields of the new va_list structure.  This
  1279.        structure looks like:
  1280.  
  1281.         typedef struct {
  1282.             unsigned long    ireg_used;
  1283.             unsigned long    freg_used;
  1284.             long        *reg_base;
  1285.             long        *mem_ptr;
  1286.         } va_list;
  1287.     */
  1288.  
  1289.     asm ("    st.l    r0, 0(r16)"); /* nfixed */
  1290.     asm ("    st.l    r0, 4(r16)"); /* nfloating */
  1291.     asm ("  st.l    sp, 8(r16)"); /* __va_ctl points to __va_struct.  */
  1292.     asm ("    bri    r1");        /* delayed return */
  1293.     asm ("     st.l    r28,12(r16)"); /* pointer to overflow args */
  1294. #else /* not __PARAGON__ */
  1295.     asm ("    .text");
  1296.     asm ("    .align    4");
  1297.  
  1298.     asm (".globl    ___builtin_saveregs");
  1299.     asm ("___builtin_saveregs:");
  1300.     asm ("    mov    sp,r30");
  1301.     asm ("    andnot    0x0f,sp,sp");
  1302.     asm ("    adds    -96,sp,sp");  /* allocate sufficient space on the stack */
  1303.  
  1304. /* Fill in the __va_struct.  */
  1305.     asm ("    st.l    r16, 0(sp)"); /* save integer regs (r16-r27) */
  1306.     asm ("    st.l    r17, 4(sp)"); /* int    fixed[12] */
  1307.     asm ("    st.l    r18, 8(sp)");
  1308.     asm ("    st.l    r19,12(sp)");
  1309.     asm ("    st.l    r20,16(sp)");
  1310.     asm ("    st.l    r21,20(sp)");
  1311.     asm ("    st.l    r22,24(sp)");
  1312.     asm ("    st.l    r23,28(sp)");
  1313.     asm ("    st.l    r24,32(sp)");
  1314.     asm ("    st.l    r25,36(sp)");
  1315.     asm ("    st.l    r26,40(sp)");
  1316.     asm ("    st.l    r27,44(sp)");
  1317.  
  1318.     asm ("    fst.q    f8, 48(sp)"); /* save floating regs (f8-f15) */
  1319.     asm ("    fst.q    f12,64(sp)"); /* int floating[8] */
  1320.  
  1321. /* Fill in the __va_ctl.  */
  1322.     asm ("  st.l    sp, 80(sp)"); /* __va_ctl points to __va_struct.  */
  1323.     asm ("    st.l    r28,84(sp)"); /* pointer to more args */
  1324.     asm ("    st.l    r0, 88(sp)"); /* nfixed */
  1325.     asm ("    st.l    r0, 92(sp)"); /* nfloating */
  1326.  
  1327.     asm ("    adds    80,sp,r16");  /* return address of the __va_ctl.  */
  1328.     asm ("    bri    r1");
  1329.     asm ("    mov    r30,sp");
  1330.                 /* recover stack and pass address to start 
  1331.                    of data.  */
  1332. #endif /* not __PARAGON__ */
  1333. #endif /* not __svr4__ */
  1334. #else /* not __i860__ */
  1335. #ifdef __sparc__
  1336.     asm (".global __builtin_saveregs");
  1337.     asm ("__builtin_saveregs:");
  1338.     asm (".global ___builtin_saveregs");
  1339.     asm ("___builtin_saveregs:");
  1340. #ifdef NEED_PROC_COMMAND
  1341.     asm (".proc 020");
  1342. #endif
  1343.     asm ("st %i0,[%fp+68]");
  1344.     asm ("st %i1,[%fp+72]");
  1345.     asm ("st %i2,[%fp+76]");
  1346.     asm ("st %i3,[%fp+80]");
  1347.     asm ("st %i4,[%fp+84]");
  1348.     asm ("retl");
  1349.     asm ("st %i5,[%fp+88]");
  1350. #ifdef NEED_TYPE_COMMAND
  1351.     asm (".type __builtin_saveregs,#function");
  1352.     asm (".size __builtin_saveregs,.-__builtin_saveregs");
  1353. #endif
  1354. #else /* not __sparc__ */
  1355. #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
  1356.  
  1357.   asm ("    .text");
  1358.   asm ("    .ent __builtin_saveregs");
  1359.   asm ("    .globl __builtin_saveregs");
  1360.   asm ("__builtin_saveregs:");
  1361.   asm ("    sw    $4,0($30)");
  1362.   asm ("    sw    $5,4($30)");
  1363.   asm ("    sw    $6,8($30)");
  1364.   asm ("    sw    $7,12($30)");
  1365.   asm ("    j    $31");
  1366.   asm ("    .end __builtin_saveregs");
  1367. #else /* not __mips__, etc. */
  1368.  
  1369. void *
  1370. __builtin_saveregs ()
  1371. {
  1372.   abort ();
  1373. }
  1374.  
  1375. #endif /* not __mips__ */
  1376. #endif /* not __sparc__ */
  1377. #endif /* not __i860__ */
  1378. #endif
  1379.  
  1380. #ifdef L_eprintf
  1381. #ifndef inhibit_libc
  1382.  
  1383. #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
  1384. #include <stdio.h>
  1385. /* This is used by the `assert' macro.  */
  1386. void
  1387. __eprintf (string, expression, line, filename)
  1388.      const char *string;
  1389.      const char *expression;
  1390.      int line;
  1391.      const char *filename;
  1392. {
  1393.   fprintf (stderr, string, expression, line, filename);
  1394.   fflush (stderr);
  1395.   abort ();
  1396. }
  1397.  
  1398. #endif
  1399. #endif
  1400.  
  1401. #ifdef L_bb
  1402.  
  1403. /* Structure emitted by -a  */
  1404. struct bb
  1405. {
  1406.   long zero_word;
  1407.   const char *filename;
  1408.   long *counts;
  1409.   long ncounts;
  1410.   struct bb *next;
  1411.   const unsigned long *addresses;
  1412.  
  1413.   /* Older GCC's did not emit these fields.  */
  1414.   long nwords;
  1415.   const char **functions;
  1416.   const long *line_nums;
  1417.   const char **filenames;
  1418. };
  1419.  
  1420. #ifdef BLOCK_PROFILER_CODE
  1421. BLOCK_PROFILER_CODE
  1422. #else
  1423. #ifndef inhibit_libc
  1424.  
  1425. /* Simple minded basic block profiling output dumper for
  1426.    systems that don't provde tcov support.  At present,
  1427.    it requires atexit and stdio.  */
  1428.  
  1429. #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
  1430. #include <stdio.h>
  1431. char *ctime ();
  1432.  
  1433. #ifdef HAVE_ATEXIT
  1434. extern void atexit (void (*) (void));
  1435. #define ON_EXIT(FUNC,ARG) atexit ((FUNC))
  1436. #else
  1437. #ifdef sun
  1438. extern void on_exit (void*, void*);
  1439. #define ON_EXIT(FUNC,ARG) on_exit ((FUNC), (ARG))
  1440. #endif
  1441. #endif
  1442.  
  1443. static struct bb *bb_head = (struct bb *)0;
  1444.  
  1445. /* Return the number of digits needed to print a value */
  1446. /* __inline__ */ static int num_digits (long value, int base)
  1447. {
  1448.   int minus = (value < 0 && base != 16);
  1449.   unsigned long v = (minus) ? -value : value;
  1450.   int ret = minus;
  1451.  
  1452.   do
  1453.     {
  1454.       v /= base;
  1455.       ret++;
  1456.     }
  1457.   while (v);
  1458.  
  1459.   return ret;
  1460. }
  1461.  
  1462. void
  1463. __bb_exit_func (void)
  1464. {
  1465.   FILE *file = fopen ("bb.out", "a");
  1466.   long time_value;
  1467.  
  1468.   if (!file)
  1469.     perror ("bb.out");
  1470.  
  1471.   else
  1472.     {
  1473.       struct bb *ptr;
  1474.  
  1475.       /* This is somewhat type incorrect, but it avoids worrying about
  1476.      exactly where time.h is included from.  It should be ok unless
  1477.      a void * differs from other pointer formats, or if sizeof(long)
  1478.      is < sizeof (time_t).  It would be nice if we could assume the
  1479.      use of rationale standards here.  */
  1480.  
  1481.       time((void *) &time_value);
  1482.       fprintf (file, "Basic block profiling finished on %s\n", ctime ((void *) &time_value));
  1483.  
  1484.       /* We check the length field explicitly in order to allow compatibility
  1485.      with older GCC's which did not provide it.  */
  1486.  
  1487.       for (ptr = bb_head; ptr != (struct bb *)0; ptr = ptr->next)
  1488.     {
  1489.       int i;
  1490.       int func_p    = (ptr->nwords >= sizeof (struct bb) && ptr->nwords <= 1000);
  1491.       int line_p    = (func_p && ptr->line_nums);
  1492.       int file_p    = (func_p && ptr->filenames);
  1493.       long ncounts    = ptr->ncounts;
  1494.       long cnt_max  = 0;
  1495.       long line_max = 0;
  1496.       long addr_max = 0;
  1497.       int file_len    = 0;
  1498.       int func_len    = 0;
  1499.       int blk_len    = num_digits (ncounts, 10);
  1500.       int cnt_len;
  1501.       int line_len;
  1502.       int addr_len;
  1503.  
  1504.       fprintf (file, "File %s, %ld basic blocks \n\n",
  1505.            ptr->filename, ncounts);
  1506.  
  1507.       /* Get max values for each field.  */
  1508.       for (i = 0; i < ncounts; i++)
  1509.         {
  1510.           const char *p;
  1511.           int len;
  1512.  
  1513.           if (cnt_max < ptr->counts[i])
  1514.         cnt_max = ptr->counts[i];
  1515.  
  1516.           if (addr_max < ptr->addresses[i])
  1517.         addr_max = ptr->addresses[i];
  1518.  
  1519.           if (line_p && line_max < ptr->line_nums[i])
  1520.         line_max = ptr->line_nums[i];
  1521.  
  1522.           if (func_p)
  1523.         {
  1524.           p = (ptr->functions[i]) ? (ptr->functions[i]) : "<none>";
  1525.           len = strlen (p);
  1526.           if (func_len < len)
  1527.             func_len = len;
  1528.         }
  1529.  
  1530.           if (file_p)
  1531.         {
  1532.           p = (ptr->filenames[i]) ? (ptr->filenames[i]) : "<none>";
  1533.           len = strlen (p);
  1534.           if (file_len < len)
  1535.             file_len = len;
  1536.         }
  1537.         }
  1538.  
  1539.       addr_len = num_digits (addr_max, 16);
  1540.       cnt_len  = num_digits (cnt_max, 10);
  1541.       line_len = num_digits (line_max, 10);
  1542.  
  1543.       /* Now print out the basic block information.  */
  1544.       for (i = 0; i < ncounts; i++)
  1545.         {
  1546.           fprintf (file,
  1547.                "    Block #%*d: executed %*ld time(s) address= 0x%.*lx",
  1548.                blk_len, i+1,
  1549.                cnt_len, ptr->counts[i],
  1550.                addr_len, ptr->addresses[i]);
  1551.  
  1552.           if (func_p)
  1553.         fprintf (file, " function= %-*s", func_len,
  1554.              (ptr->functions[i]) ? ptr->functions[i] : "<none>");
  1555.  
  1556.           if (line_p)
  1557.         fprintf (file, " line= %*ld", line_len, ptr->line_nums[i]);
  1558.  
  1559.           if (file_p)
  1560.         fprintf (file, " file= %s",
  1561.              (ptr->filenames[i]) ? ptr->filenames[i] : "<none>");
  1562.  
  1563.           fprintf (file, "\n");
  1564.         }
  1565.  
  1566.       fprintf (file, "\n");
  1567.       fflush (file);
  1568.     }
  1569.  
  1570.       fprintf (file, "\n\n");
  1571.       fclose (file);
  1572.     }
  1573. }
  1574.  
  1575. void
  1576. __bb_init_func (struct bb *blocks)
  1577. {
  1578.   /* User is supposed to check whether the first word is non-0,
  1579.      but just in case.... */
  1580.  
  1581.   if (blocks->zero_word)
  1582.     return;
  1583.  
  1584. #ifdef ON_EXIT
  1585.   /* Initialize destructor.  */
  1586.   if (!bb_head)
  1587.     ON_EXIT (__bb_exit_func, 0);
  1588. #endif
  1589.  
  1590.   /* Set up linked list.  */
  1591.   blocks->zero_word = 1;
  1592.   blocks->next = bb_head;
  1593.   bb_head = blocks;
  1594. }
  1595.  
  1596. #endif /* not inhibit_libc */
  1597. #endif /* not BLOCK_PROFILER_CODE */
  1598. #endif /* L_bb */
  1599.  
  1600. /* Default free-store management functions for C++, per sections 12.5 and
  1601.    17.3.3 of the Working Paper. */
  1602.  
  1603. #ifdef L_op_new
  1604. /* operator new (size_t), described in 17.3.3.5.  This function is used by
  1605.    C++ programs to allocate a block of memory to hold a single object. */
  1606.  
  1607. typedef void (*vfp)(void);
  1608. extern vfp __new_handler;
  1609.  
  1610. void *
  1611. __builtin_new (size_t sz)
  1612. {
  1613.   void *p;
  1614.  
  1615.   /* malloc (0) is unpredictable; avoid it.  */
  1616.   if (sz == 0)
  1617.     sz = 1;
  1618.   p = (void *) malloc (sz);
  1619.   while (p == 0)
  1620.     {
  1621.       (*__new_handler) ();
  1622.       p = (void *) malloc (sz);
  1623.     }
  1624.   
  1625.   return p;
  1626. }
  1627. #endif /* L_op_new */
  1628.  
  1629. #ifdef L_op_vnew
  1630. /* void * operator new [] (size_t), described in 17.3.3.6.  This function
  1631.    is used by C++ programs to allocate a block of memory for an array.  */
  1632.  
  1633. extern void * __builtin_new (size_t);
  1634.  
  1635. void *
  1636. __builtin_vec_new (size_t sz)
  1637. {
  1638.   return __builtin_new (sz);
  1639. }
  1640. #endif /* L_op_vnew */
  1641.  
  1642. #ifdef L_new_handler
  1643. /* set_new_handler (fvoid_t *) and the default new handler, described in
  1644.    17.3.3.2 and 17.3.3.5.  These functions define the result of a failure
  1645.    to allocate the amount of memory requested from operator new or new []. */
  1646.  
  1647. #ifndef inhibit_libc
  1648. /* This gets us __GNU_LIBRARY__.  */
  1649. #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
  1650. #include <stdio.h>
  1651.  
  1652. #ifdef __GNU_LIBRARY__
  1653.   /* Avoid forcing the library's meaning of `write' on the user program
  1654.      by using the "internal" name (for use within the library)  */
  1655. #define write(fd, buf, n)    __write((fd), (buf), (n))
  1656. #endif
  1657. #endif /* inhibit_libc */
  1658.  
  1659. typedef void (*vfp)(void);
  1660. void __default_new_handler (void);
  1661.  
  1662. vfp __new_handler = __default_new_handler;
  1663.  
  1664. vfp
  1665. set_new_handler (vfp handler)
  1666. {
  1667.   vfp prev_handler;
  1668.  
  1669.   prev_handler = __new_handler;
  1670.   if (handler == 0) handler = __default_new_handler;
  1671.   __new_handler = handler;
  1672.   return prev_handler;
  1673. }
  1674.  
  1675. #define MESSAGE "Virtual memory exceeded in `new'\n"
  1676.  
  1677. void
  1678. __default_new_handler ()
  1679. {
  1680.   /* don't use fprintf (stderr, ...) because it may need to call malloc.  */
  1681.   /* This should really print the name of the program, but that is hard to
  1682.      do.  We need a standard, clean way to get at the name.  */
  1683.   write (2, MESSAGE, sizeof (MESSAGE));
  1684.   /* don't call exit () because that may call global destructors which
  1685.      may cause a loop.  */
  1686.   _exit (-1);
  1687. }
  1688. #endif
  1689.  
  1690. #ifdef L_op_delete
  1691. /* operator delete (void *), described in 17.3.3.3.  This function is used
  1692.    by C++ programs to return to the free store a block of memory allocated
  1693.    as a single object. */
  1694.  
  1695. void
  1696. __builtin_delete (void *ptr)
  1697. {
  1698.   if (ptr)
  1699.     free (ptr);
  1700. }
  1701. #endif
  1702.  
  1703. #ifdef L_op_vdel
  1704. /* operator delete [] (void *), described in 17.3.3.4.  This function is
  1705.    used by C++ programs to return to the free store a block of memory
  1706.    allocated as an array. */
  1707.  
  1708. extern void __builtin_delete (void *);
  1709.  
  1710. void
  1711. __builtin_vec_delete (void *ptr)
  1712. {
  1713.   __builtin_delete (ptr);
  1714. }
  1715. #endif
  1716.  
  1717. /* End of C++ free-store management functions */
  1718.  
  1719. #ifdef L_shtab
  1720. unsigned int __shtab[] = {
  1721.     0x00000001, 0x00000002, 0x00000004, 0x00000008,
  1722.     0x00000010, 0x00000020, 0x00000040, 0x00000080,
  1723.     0x00000100, 0x00000200, 0x00000400, 0x00000800,
  1724.     0x00001000, 0x00002000, 0x00004000, 0x00008000,
  1725.     0x00010000, 0x00020000, 0x00040000, 0x00080000,
  1726.     0x00100000, 0x00200000, 0x00400000, 0x00800000,
  1727.     0x01000000, 0x02000000, 0x04000000, 0x08000000,
  1728.     0x10000000, 0x20000000, 0x40000000, 0x80000000
  1729.   };
  1730. #endif
  1731.  
  1732. #ifdef L_clear_cache
  1733. /* Clear part of an instruction cache.  */
  1734.  
  1735. #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
  1736.  
  1737. void
  1738. __clear_cache (beg, end)
  1739.      char *beg, *end;
  1740. {
  1741. #ifdef CLEAR_INSN_CACHE 
  1742.   CLEAR_INSN_CACHE (beg, end);
  1743. #else
  1744. #ifdef INSN_CACHE_SIZE
  1745.   static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
  1746.   static int initialized = 0;
  1747.   int offset;
  1748.   void *start_addr
  1749.   void *end_addr;
  1750.   typedef (*function_ptr) ();
  1751.  
  1752. #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
  1753.   /* It's cheaper to clear the whole cache.
  1754.      Put in a series of jump instructions so that calling the beginning
  1755.      of the cache will clear the whole thing.  */
  1756.  
  1757.   if (! initialized)
  1758.     {
  1759.       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
  1760.          & -INSN_CACHE_LINE_WIDTH);
  1761.       int end_ptr = ptr + INSN_CACHE_SIZE;
  1762.  
  1763.       while (ptr < end_ptr)
  1764.     {
  1765.       *(INSTRUCTION_TYPE *)ptr
  1766.         = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
  1767.       ptr += INSN_CACHE_LINE_WIDTH;
  1768.     }
  1769.       *(INSTRUCTION_TYPE *)(ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
  1770.  
  1771.       initialized = 1;
  1772.     }
  1773.  
  1774.   /* Call the beginning of the sequence.  */
  1775.   (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
  1776.             & -INSN_CACHE_LINE_WIDTH))
  1777.    ());
  1778.  
  1779. #else /* Cache is large.  */
  1780.  
  1781.   if (! initialized)
  1782.     {
  1783.       int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
  1784.          & -INSN_CACHE_LINE_WIDTH);
  1785.  
  1786.       while (ptr < (int) array + sizeof array)
  1787.     {
  1788.       *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
  1789.       ptr += INSN_CACHE_LINE_WIDTH;
  1790.     }
  1791.  
  1792.       initialized = 1;
  1793.     }
  1794.  
  1795.   /* Find the location in array that occupies the same cache line as BEG.  */
  1796.  
  1797.   offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
  1798.   start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
  1799.          & -INSN_CACHE_PLANE_SIZE)
  1800.         + offset);
  1801.  
  1802.   /* Compute the cache alignment of the place to stop clearing.  */
  1803. #if 0  /* This is not needed for gcc's purposes.  */
  1804.   /* If the block to clear is bigger than a cache plane,
  1805.      we clear the entire cache, and OFFSET is already correct.  */ 
  1806.   if (end < beg + INSN_CACHE_PLANE_SIZE)
  1807. #endif
  1808.     offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
  1809.            & -INSN_CACHE_LINE_WIDTH)
  1810.           & (INSN_CACHE_PLANE_SIZE - 1));
  1811.  
  1812. #if INSN_CACHE_DEPTH > 1
  1813.   end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
  1814.   if (end_addr <= start_addr)
  1815.     end_addr += INSN_CACHE_PLANE_SIZE;
  1816.  
  1817.   for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
  1818.     {
  1819.       int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
  1820.       int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
  1821.  
  1822.       while (addr != stop)
  1823.     {
  1824.       /* Call the return instruction at ADDR.  */
  1825.       ((function_ptr) addr) ();
  1826.  
  1827.       addr += INSN_CACHE_LINE_WIDTH;
  1828.     }
  1829.     }
  1830. #else /* just one plane */
  1831.   do
  1832.     {
  1833.       /* Call the return instruction at START_ADDR.  */
  1834.       ((function_ptr) start_addr) ();
  1835.  
  1836.       start_addr += INSN_CACHE_LINE_WIDTH;
  1837.     }
  1838.   while ((start_addr % INSN_CACHE_SIZE) != offset);
  1839. #endif /* just one plane */
  1840. #endif /* Cache is large */
  1841. #endif /* Cache exists */
  1842. #endif /* CLEAR_INSN_CACHE */
  1843. }
  1844.  
  1845. #endif /* L_clear_cache */
  1846.  
  1847. #ifdef L_trampoline
  1848.  
  1849. /* Jump to a trampoline, loading the static chain address.  */
  1850.  
  1851. #ifdef TRANSFER_FROM_TRAMPOLINE 
  1852. TRANSFER_FROM_TRAMPOLINE 
  1853. #endif
  1854.  
  1855. #if defined (NeXT) && defined (__MACH__)
  1856.  
  1857. /* Make stack executable so we can call trampolines on stack.
  1858.    This is called from INITIALIZE_TRAMPOLINE in next.h.  */
  1859. #ifdef NeXTStep21
  1860.  #include <mach.h>
  1861. #else
  1862.  #include <mach/mach.h>
  1863. #endif
  1864.  
  1865. void
  1866. __enable_execute_stack (addr)
  1867.      char *addr;
  1868. {
  1869.   kern_return_t r;
  1870.   char *eaddr = addr + TRAMPOLINE_SIZE;
  1871.   vm_address_t a = (vm_address_t) addr;
  1872.  
  1873.   /* turn on execute access on stack */
  1874.   r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
  1875.   if (r != KERN_SUCCESS)
  1876.     {
  1877.       mach_error("vm_protect VM_PROT_ALL", r);
  1878.       exit(1);
  1879.     }
  1880.  
  1881.   /* We inline the i-cache invalidation for speed */
  1882.  
  1883. #ifdef CLEAR_INSN_CACHE
  1884.   CLEAR_INSN_CACHE (addr, eaddr);
  1885. #else
  1886.   __clear_cache ((int) addr, (int) eaddr);
  1887. #endif
  1888. } 
  1889.  
  1890. #endif /* defined (NeXT) && defined (__MACH__) */
  1891.  
  1892. #ifdef __convex__
  1893.  
  1894. /* Make stack executable so we can call trampolines on stack.
  1895.    This is called from INITIALIZE_TRAMPOLINE in convex.h.  */
  1896.  
  1897. #include <sys/mman.h>
  1898. #include <sys/vmparam.h>
  1899. #include <machine/machparam.h>
  1900.  
  1901. void
  1902. __enable_execute_stack ()
  1903. {
  1904.   int fp;
  1905.   static unsigned lowest = USRSTACK;
  1906.   unsigned current = (unsigned) &fp & -NBPG;
  1907.  
  1908.   if (lowest > current)
  1909.     {
  1910.       unsigned len = lowest - current;
  1911.       mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
  1912.       lowest = current;
  1913.     }
  1914.  
  1915.   /* Clear instruction cache in case an old trampoline is in it. */
  1916.   asm ("pich");
  1917. }
  1918. #endif /* __convex__ */
  1919.  
  1920. #ifdef __DOLPHIN__
  1921.  
  1922. /* Modified from the convex -code above. */
  1923.  
  1924. #include <sys/param.h>
  1925. #include <errno.h>
  1926. #include <sys/m88kbcs.h>
  1927.  
  1928. void
  1929. __enable_execute_stack ()
  1930. {
  1931.   int save_errno;
  1932.   static unsigned long lowest = USRSTACK;
  1933.   unsigned long current = (unsigned long) &save_errno & -NBPC;
  1934.   
  1935.   /* Ignore errno being set. memctl sets errno to EINVAL whenever the
  1936.      address is seen as 'negative'. That is the case with the stack.   */
  1937.  
  1938.   save_errno=errno;
  1939.   if (lowest > current)
  1940.     {
  1941.       unsigned len=lowest-current;
  1942.       memctl(current,len,MCT_TEXT);
  1943.       lowest = current;
  1944.     }
  1945.   else
  1946.     memctl(current,NBPC,MCT_TEXT);
  1947.   errno=save_errno;
  1948. }
  1949.  
  1950. #endif /* __DOLPHIN__ */
  1951.  
  1952. #ifdef __pyr__
  1953.  
  1954. #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
  1955. #include <stdio.h>
  1956. #include <sys/mman.h>
  1957. #include <sys/types.h>
  1958. #include <sys/param.h>
  1959. #include <sys/vmmac.h>
  1960.  
  1961. /* Modified from the convex -code above.
  1962.    mremap promises to clear the i-cache. */
  1963.  
  1964. void
  1965. __enable_execute_stack ()
  1966. {
  1967.   int fp;
  1968.   if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
  1969.         PROT_READ|PROT_WRITE|PROT_EXEC))
  1970.     {
  1971.       perror ("mprotect in __enable_execute_stack");
  1972.       fflush (stderr);
  1973.       abort ();
  1974.     }
  1975. }
  1976. #endif /* __pyr__ */
  1977. #endif /* L_trampoline */
  1978.  
  1979. #ifdef L__main
  1980.  
  1981. #include "gbl-ctors.h"
  1982. /* Some systems use __main in a way incompatible with its use in gcc, in these
  1983.    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
  1984.    give the same symbol without quotes for an alternative entry point.  You
  1985.    must define both, or niether. */
  1986. #ifndef NAME__MAIN
  1987. #define NAME__MAIN "__main"
  1988. #define SYMBOL__MAIN __main
  1989. #endif
  1990.  
  1991. /* Run all the global destructors on exit from the program.  */
  1992.  
  1993. void
  1994. __do_global_dtors ()
  1995. {
  1996. #ifdef DO_GLOBAL_DTORS_BODY
  1997.   DO_GLOBAL_DTORS_BODY;
  1998. #else
  1999.   func_ptr *p;
  2000.   for (p = __DTOR_LIST__ + 1; *p; )
  2001.     (*p++) ();
  2002. #endif
  2003. }
  2004.  
  2005. #ifndef INIT_SECTION_ASM_OP
  2006. /* Run all the global constructors on entry to the program.  */
  2007.  
  2008. #ifndef ON_EXIT
  2009. #define ON_EXIT(a, b)
  2010. #else
  2011. /* Make sure the exit routine is pulled in to define the globals as
  2012.    bss symbols, just in case the linker does not automatically pull
  2013.    bss definitions from the library.  */
  2014.  
  2015. extern int _exit_dummy_decl;
  2016. int *_exit_dummy_ref = &_exit_dummy_decl;
  2017. #endif /* ON_EXIT */
  2018.  
  2019. void
  2020. __do_global_ctors ()
  2021. {
  2022.   DO_GLOBAL_CTORS_BODY;
  2023.   ON_EXIT (__do_global_dtors, 0);
  2024. }
  2025. #endif /* no INIT_SECTION_ASM_OP */
  2026.  
  2027. #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main)
  2028. /* Subroutine called automatically by `main'.
  2029.    Compiling a global function named `main'
  2030.    produces an automatic call to this function at the beginning.
  2031.  
  2032.    For many systems, this routine calls __do_global_ctors.
  2033.    For systems which support a .init section we use the .init section
  2034.    to run __do_global_ctors, so we need not do anything here.  */
  2035.  
  2036. void
  2037. SYMBOL__MAIN ()
  2038. {
  2039.   /* Support recursive calls to `main': run initializers just once.  */
  2040.   static int initialized = 0;
  2041.   if (! initialized)
  2042.     {
  2043.       initialized = 1;
  2044.       __do_global_ctors ();
  2045.     }
  2046. }
  2047. #endif /* no INIT_SECTION_ASM_OP or INVOKE__main */
  2048.  
  2049. #endif /* L__main */
  2050.  
  2051. #ifdef L_ctors
  2052.  
  2053. #include "gbl-ctors.h"
  2054.  
  2055. /* Provide default definitions for the lists of constructors and
  2056.    destructors, so that we don't get linker errors.  These symbols are
  2057.    intentionally bss symbols, so that gld and/or collect will provide
  2058.    the right values.  */
  2059.  
  2060. /* We declare the lists here with two elements each,
  2061.    so that they are valid empty lists if no other definition is loaded.  */
  2062. #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
  2063. #ifdef __NeXT__
  2064. /* After 2.3, try this definition on all systems.  */
  2065. func_ptr __CTOR_LIST__[2] = {0, 0};
  2066. func_ptr __DTOR_LIST__[2] = {0, 0};
  2067. #else
  2068. func_ptr __CTOR_LIST__[2];
  2069. func_ptr __DTOR_LIST__[2];
  2070. #endif
  2071. #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
  2072. #endif /* L_ctors */
  2073.  
  2074. #ifdef L_exit
  2075.  
  2076. #include "gbl-ctors.h"
  2077.  
  2078. #ifndef ON_EXIT
  2079.  
  2080. /* If we have no known way of registering our own __do_global_dtors
  2081.    routine so that it will be invoked at program exit time, then we
  2082.    have to define our own exit routine which will get this to happen.  */
  2083.  
  2084. extern void __do_global_dtors ();
  2085. extern void _cleanup ();
  2086. extern void _exit () __attribute__ ((noreturn));
  2087.  
  2088. void 
  2089. exit (status)
  2090.      int status;
  2091. {
  2092.   __do_global_dtors ();
  2093. #ifdef EXIT_BODY
  2094.   EXIT_BODY;
  2095. #else
  2096.   _cleanup ();
  2097. #endif
  2098.   _exit (status);
  2099. }
  2100.  
  2101. #else
  2102. int _exit_dummy_decl = 0;    /* prevent compiler & linker warnings */
  2103. #endif
  2104.  
  2105. #endif /* L_exit */
  2106.  
  2107. /* In a.out systems, we need to have these dummy constructor and destructor
  2108.    lists in the library.
  2109.  
  2110.    When using `collect', the first link will resolve __CTOR_LIST__
  2111.    and __DTOR_LIST__ to these symbols.  We will then run "nm" on the
  2112.    result, build the correct __CTOR_LIST__ and __DTOR_LIST__, and relink.
  2113.    Since we don't do the second link if no constructors existed, these
  2114.    dummies must be fully functional empty lists.
  2115.  
  2116.    When using `gnu ld', these symbols will be used if there are no
  2117.    constructors.  If there are constructors, the N_SETV symbol defined
  2118.    by the linker from the N_SETT's in input files will define __CTOR_LIST__
  2119.    and __DTOR_LIST__ rather than its being allocated as common storage
  2120.    by the definitions below.
  2121.  
  2122.    When using a linker that supports constructor and destructor segments,
  2123.    these definitions will not be used, since crtbegin.o and crtend.o
  2124.    (from crtstuff.c) will have already defined __CTOR_LIST__ and
  2125.     __DTOR_LIST__.  The crt*.o files are passed directly to the linker
  2126.    on its command line, by gcc.  */
  2127.  
  2128. /* The list needs two elements:  one is ignored (the old count); the
  2129.    second is the terminating zero.  Since both values are zero, this
  2130.    declaration is not initialized, and it becomes `common'.  */
  2131.  
  2132. #ifdef L_ctor_list
  2133. #include "gbl-ctors.h"
  2134. func_ptr __CTOR_LIST__[2];
  2135. #endif
  2136.  
  2137. #ifdef L_dtor_list
  2138. #include "gbl-ctors.h"
  2139. func_ptr __DTOR_LIST__[2];
  2140. #endif
  2141.  
  2142. #ifdef L_eh
  2143. typedef struct {
  2144.   void *start;
  2145.   void *end;
  2146.   void *exception_handler;
  2147. } exception_table;
  2148.  
  2149. struct exception_table_node {
  2150.   exception_table *table;
  2151.   void *start;
  2152.   void *end;
  2153.   struct exception_table_node *next;
  2154. };
  2155.  
  2156. static int except_table_pos = 0;
  2157. static void *except_pc = (void *)0;
  2158. static struct exception_table_node *exception_table_list = 0;
  2159.  
  2160. static exception_table *
  2161. find_exception_table (pc)
  2162.      void* pc;
  2163. {
  2164.   register struct exception_table_node *table = exception_table_list;
  2165.   for ( ; table != 0; table = table->next)
  2166.     {
  2167.       if (table->start <= pc && table->end > pc)
  2168.     return table->table;
  2169.     }
  2170.   return 0;
  2171. }
  2172.  
  2173. /* this routine takes a pc, and the address of the exception handler associated
  2174.    with the closest exception table handler entry associated with that PC,
  2175.    or 0 if there are no table entries the PC fits in.  The algorithm works
  2176.    something like this:
  2177.  
  2178.     while(current_entry exists) {
  2179.         if(current_entry.start < pc )
  2180.             current_entry = next_entry;
  2181.         else {
  2182.             if(prev_entry.start <= pc && prev_entry.end > pc) {
  2183.                 save pointer to prev_entry;
  2184.                 return prev_entry.exception_handler;
  2185.              }
  2186.             else return 0;
  2187.          }
  2188.      }
  2189.     return 0;
  2190.  
  2191.    Assuming a correctly sorted table (ascending order) this routine should
  2192.    return the tighest match...
  2193.  
  2194.    In the advent of a tie, we have to give the last entry, as it represents
  2195.    an inner block.
  2196.  */
  2197.  
  2198.  
  2199. void *
  2200. __find_first_exception_table_match(pc)
  2201. void *pc;
  2202. {
  2203.   exception_table *table = find_exception_table (pc);
  2204.   int pos = 0;
  2205.   int best = 0;
  2206.   if (table == 0)
  2207.     return (void*)0;
  2208. #if 0
  2209.   printf("find_first_exception_table_match(): pc = %x!\n",pc);
  2210. #endif
  2211.  
  2212.   except_pc = pc;
  2213.  
  2214. #if 0
  2215.   /* We can't do this yet, as we don't know that the table is sorted.  */
  2216.   do {
  2217.     ++pos;
  2218.     if (table[pos].start > except_pc)
  2219.       /* found the first table[pos].start > except_pc, so the previous
  2220.      entry better be the one we want! */
  2221.       break;
  2222.   } while(table[pos].exception_handler != (void*)-1);
  2223.  
  2224.   --pos;
  2225.   if (table[pos].start <= except_pc && table[pos].end > except_pc)
  2226.     {
  2227.       except_table_pos = pos;
  2228. #if 0
  2229.       printf("find_first_eh_table_match(): found match: %x\n",table[pos].exception_handler);
  2230. #endif
  2231.       return table[pos].exception_handler;
  2232.     }
  2233. #else
  2234.   while (table[++pos].exception_handler != (void*)-1) {
  2235.     if (table[pos].start <= except_pc && table[pos].end > except_pc)
  2236.       {
  2237.     /* This can apply.  Make sure it is better or as good as the previous
  2238.        best.  */
  2239.     /* The best one ends first. */
  2240.     if (best == 0 || (table[pos].end <= table[best].end
  2241.               /* The best one starts last.  */
  2242.               && table[pos].start >= table[best].start))
  2243.       best = pos;
  2244.       }
  2245.   }
  2246.   if (best != 0)
  2247.     return table[best].exception_handler;
  2248. #endif
  2249.  
  2250. #if 0
  2251.   printf("find_first_eh_table_match(): else: returning NULL!\n");
  2252. #endif
  2253.   return (void*)0;
  2254. }
  2255.  
  2256. int
  2257. __throw_type_match (const char *catch_type, const char *throw_type)
  2258. {
  2259. #if 0
  2260.  printf("__throw_type_match (): catch_type = %s, throw_type = %s\n",
  2261.     catch_type, throw_type);
  2262. #endif
  2263.  return strcmp (catch_type, throw_type);
  2264. }
  2265.  
  2266. void
  2267. __register_exceptions (exception_table *table)
  2268. {
  2269.   struct exception_table_node *node = (struct exception_table_node*)
  2270.       malloc (sizeof (struct exception_table_node));
  2271.   exception_table *range = table + 1;
  2272.   node->table = table;
  2273.  
  2274.   /* This look can be optimized away either if the table
  2275.      is sorted, or if we pass in extra parameters. */
  2276.   node->start = range->start;
  2277.   node->end = range->end;
  2278.   for (range++ ; range->start != (void*)(-1); range++)
  2279.     {
  2280.       if (range->start < node->start)
  2281.     node->start = range->start;
  2282.       if (range->end < node->end)
  2283.     node->end = range->end;
  2284.     }
  2285.  
  2286.   node->next = exception_table_list;
  2287.   exception_table_list = node;
  2288. }
  2289. #endif /* L_eh */
  2290.  
  2291. #ifdef L_pure
  2292. #define MESSAGE "pure virtual method called\n"
  2293. void
  2294. __pure_virtual ()
  2295. {
  2296.   write (2, MESSAGE, sizeof (MESSAGE) - 1);
  2297.   _exit (-1);
  2298. }
  2299. #endif
  2300.