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.
5 This file is part of GNU CC.
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)
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.
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. */
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. */
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
37 /* Don't use `fancy_abort' here even if config.h says to use it. */
42 /* In the first part of this file, we are interfacing to calls generated
43 by the compiler itself. These calls pass values into these routines
44 which have very specific modes (rather than very specific types), and
45 these compiler-generated calls also expect any return values to have
46 very specific modes (rather than very specific types). Thus, we need
47 to avoid using regular C language type names in this part of the file
48 because the sizes for those types can be configured to be anything.
49 Instead we use the following special type names. */
51 typedef unsigned int UQItype __attribute__ ((mode (QI)));
52 typedef int SItype __attribute__ ((mode (SI)));
53 typedef unsigned int USItype __attribute__ ((mode (SI)));
54 typedef int DItype __attribute__ ((mode (DI)));
55 typedef unsigned int UDItype __attribute__ ((mode (DI)));
56 typedef float SFtype __attribute__ ((mode (SF)));
57 typedef float DFtype __attribute__ ((mode (DF)));
58 #if LONG_DOUBLE_TYPE_SIZE == 96
59 typedef float XFtype __attribute__ ((mode (XF)));
61 #if LONG_DOUBLE_TYPE_SIZE == 128
62 typedef float TFtype __attribute__ ((mode (TF)));
66 typedef int word_type __attribute__ ((mode (HI)));
69 typedef int word_type __attribute__ ((mode (SI)));
72 typedef int word_type __attribute__ ((mode (DI)));
75 /* Make sure that we don't accidentally use any normal C language built-in
76 type names in the first part of this file. Instead we want to use *only*
77 the type names defined above. The following macro definitions insure
78 that if we *do* accidentally use some normal C language built-in type name,
79 we will get a syntax error. */
81 #define char bogus_type
82 #define short bogus_type
83 #define int bogus_type
84 #define long bogus_type
85 #define unsigned bogus_type
86 #define float bogus_type
87 #define double bogus_type
89 #define SI_TYPE_SIZE (sizeof (SItype) * BITS_PER_UNIT)
91 /* DIstructs are pairs of SItype values in the order determined by
95 struct DIstruct {SItype high, low;};
97 struct DIstruct {SItype low, high;};
100 /* We need this union to unpack/pack DImode values, since we don't have
101 any arithmetic yet. Incoming DImode parameters are stored into the
102 `ll' field, and the unpacked result is read from the struct `s'. */
110 #if defined (L_udivmoddi4) || defined (L_muldi3) || defined (L_udiv_w_sdiv)
112 #include "longlong.h"
114 #endif /* udiv or mul */
116 extern DItype __fixunssfdi (SFtype a);
117 extern DItype __fixunsdfdi (DFtype a);
119 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
120 #if defined (L_divdi3) || defined (L_moddi3)
133 w.s.high = -uu.s.high - ((USItype) w.s.low > 0);
154 bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
158 w.s.high = (USItype)uu.s.low << -bm;
162 USItype carries = (USItype)uu.s.low >> bm;
163 w.s.low = (USItype)uu.s.low << b;
164 w.s.high = ((USItype)uu.s.high << b) | carries;
186 bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
190 w.s.low = (USItype)uu.s.high >> -bm;
194 USItype carries = (USItype)uu.s.high << bm;
195 w.s.high = (USItype)uu.s.high >> b;
196 w.s.low = ((USItype)uu.s.low >> b) | carries;
218 bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
222 w.s.high = (USItype)uu.s.low << -bm;
226 USItype carries = (USItype)uu.s.low >> bm;
227 w.s.low = (USItype)uu.s.low << b;
228 w.s.high = ((USItype)uu.s.high << b) | carries;
250 bm = (sizeof (SItype) * BITS_PER_UNIT) - b;
253 /* w.s.high = 1..1 or 0..0 */
254 w.s.high = uu.s.high >> (sizeof (SItype) * BITS_PER_UNIT - 1);
255 w.s.low = uu.s.high >> -bm;
259 USItype carries = (USItype)uu.s.high << bm;
260 w.s.high = uu.s.high >> b;
261 w.s.low = ((USItype)uu.s.low >> b) | carries;
276 w.s.low = ffs (uu.s.low);
279 w.s.low = ffs (uu.s.high);
282 w.s.low += BITS_PER_UNIT * sizeof (SItype);
300 w.ll = __umulsidi3 (uu.s.low, vv.s.low);
301 w.s.high += ((USItype) uu.s.low * (USItype) vv.s.high
302 + (USItype) uu.s.high * (USItype) vv.s.low);
310 __udiv_w_sdiv (rp, a1, a0, d)
311 USItype *rp, a1, a0, d;
318 if (a1 < d - a1 - (a0 >> (SI_TYPE_SIZE - 1)))
320 /* dividend, divisor, and quotient are nonnegative */
321 sdiv_qrnnd (q, r, a1, a0, d);
325 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
326 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (SI_TYPE_SIZE - 1));
327 /* Divide (c1*2^32 + c0) by d */
328 sdiv_qrnnd (q, r, c1, c0, d);
329 /* Add 2^31 to quotient */
330 q += (USItype) 1 << (SI_TYPE_SIZE - 1);
335 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
336 c1 = a1 >> 1; /* A/2 */
337 c0 = (a1 << (SI_TYPE_SIZE - 1)) + (a0 >> 1);
339 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
341 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
343 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
360 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
363 c0 = ~c0; /* logical NOT */
365 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
367 q = ~q; /* (A/2)/b1 */
370 r = 2*r + (a0 & 1); /* A/(2*b1) */
388 else /* Implies c1 = b1 */
389 { /* Hence a1 = d - 1 = 2*b1 - 1 */
409 static const UQItype __clz_tab[] =
411 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,
412 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,
413 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,
414 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,
415 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,
416 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,
417 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,
418 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,
422 __udivmoddi4 (n, d, rp)
429 USItype d0, d1, n0, n1, n2;
441 #if !UDIV_NEEDS_NORMALIZATION
448 udiv_qrnnd (q0, n0, n1, n0, d0);
451 /* Remainder in n0. */
458 d0 = 1 / d0; /* Divide intentionally by zero. */
460 udiv_qrnnd (q1, n1, 0, n1, d0);
461 udiv_qrnnd (q0, n0, n1, n0, d0);
463 /* Remainder in n0. */
474 #else /* UDIV_NEEDS_NORMALIZATION */
482 count_leading_zeros (bm, d0);
486 /* Normalize, i.e. make the most significant bit of the
490 n1 = (n1 << bm) | (n0 >> (SI_TYPE_SIZE - bm));
494 udiv_qrnnd (q0, n0, n1, n0, d0);
497 /* Remainder in n0 >> bm. */
504 d0 = 1 / d0; /* Divide intentionally by zero. */
506 count_leading_zeros (bm, d0);
510 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
511 conclude (the most significant bit of n1 is set) /\ (the
512 leading quotient digit q1 = 1).
514 This special case is necessary, not an optimization.
515 (Shifts counts of SI_TYPE_SIZE are undefined.) */
524 b = SI_TYPE_SIZE - bm;
528 n1 = (n1 << bm) | (n0 >> b);
531 udiv_qrnnd (q1, n1, n2, n1, d0);
536 udiv_qrnnd (q0, n0, n1, n0, d0);
538 /* Remainder in n0 >> bm. */
548 #endif /* UDIV_NEEDS_NORMALIZATION */
559 /* Remainder in n1n0. */
571 count_leading_zeros (bm, d1);
574 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
575 conclude (the most significant bit of n1 is set) /\ (the
576 quotient digit q0 = 0 or 1).
578 This special case is necessary, not an optimization. */
580 /* The condition on the next line takes advantage of that
581 n1 >= d1 (true due to program flow). */
582 if (n1 > d1 || n0 >= d0)
585 sub_ddmmss (n1, n0, n1, n0, d1, d0);
604 b = SI_TYPE_SIZE - bm;
606 d1 = (d1 << bm) | (d0 >> b);
609 n1 = (n1 << bm) | (n0 >> b);
612 udiv_qrnnd (q0, n1, n2, n1, d1);
613 umul_ppmm (m1, m0, q0, d0);
615 if (m1 > n1 || (m1 == n1 && m0 > n0))
618 sub_ddmmss (m1, m0, m1, m0, d1, d0);
623 /* Remainder in (n1n0 - m1m0) >> bm. */
626 sub_ddmmss (n1, n0, n1, n0, m1, m0);
627 rr.s.low = (n1 << b) | (n0 >> bm);
628 rr.s.high = n1 >> bm;
642 UDItype __udivmoddi4 ();
656 uu.ll = __negdi2 (uu.ll);
659 vv.ll = __negdi2 (vv.ll);
661 w = __udivmoddi4 (uu.ll, vv.ll, (UDItype *) 0);
670 UDItype __udivmoddi4 ();
684 uu.ll = __negdi2 (uu.ll);
686 vv.ll = __negdi2 (vv.ll);
688 (void) __udivmoddi4 (uu.ll, vv.ll, &w);
697 UDItype __udivmoddi4 ();
704 (void) __udivmoddi4 (u, v, &w);
711 UDItype __udivmoddi4 ();
716 return __udivmoddi4 (n, d, (UDItype *) 0);
727 au.ll = a, bu.ll = b;
729 if (au.s.high < bu.s.high)
731 else if (au.s.high > bu.s.high)
733 if ((USItype) au.s.low < (USItype) bu.s.low)
735 else if ((USItype) au.s.low > (USItype) bu.s.low)
748 au.ll = a, bu.ll = b;
750 if ((USItype) au.s.high < (USItype) bu.s.high)
752 else if ((USItype) au.s.high > (USItype) bu.s.high)
754 if ((USItype) au.s.low < (USItype) bu.s.low)
756 else if ((USItype) au.s.low > (USItype) bu.s.low)
762 #if defined(L_fixunstfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
763 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
764 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
776 /* Compute high word of result, as a flonum. */
777 b = (a / HIGH_WORD_COEFF);
778 /* Convert that to fixed (but not to DItype!),
779 and shift it into the high word. */
782 /* Remove high part from the TFtype, leaving the low part as flonum. */
784 /* Convert that to fixed (but not to DItype!) and add it in.
785 Sometimes A comes out negative. This is significant, since
786 A has more bits than a long int does. */
788 v -= (USItype) (- a);
795 #if defined(L_fixtfdi) && (LONG_DOUBLE_TYPE_SIZE == 128)
801 return - __fixunstfdi (-a);
802 return __fixunstfdi (a);
806 #if defined(L_fixunsxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
807 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
808 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
820 /* Compute high word of result, as a flonum. */
821 b = (a / HIGH_WORD_COEFF);
822 /* Convert that to fixed (but not to DItype!),
823 and shift it into the high word. */
826 /* Remove high part from the XFtype, leaving the low part as flonum. */
828 /* Convert that to fixed (but not to DItype!) and add it in.
829 Sometimes A comes out negative. This is significant, since
830 A has more bits than a long int does. */
832 v -= (USItype) (- a);
839 #if defined(L_fixxfdi) && (LONG_DOUBLE_TYPE_SIZE == 96)
845 return - __fixunsxfdi (-a);
846 return __fixunsxfdi (a);
851 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
852 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
864 /* Compute high word of result, as a flonum. */
865 b = (a / HIGH_WORD_COEFF);
866 /* Convert that to fixed (but not to DItype!),
867 and shift it into the high word. */
870 /* Remove high part from the DFtype, leaving the low part as flonum. */
872 /* Convert that to fixed (but not to DItype!) and add it in.
873 Sometimes A comes out negative. This is significant, since
874 A has more bits than a long int does. */
876 v -= (USItype) (- a);
889 return - __fixunsdfdi (-a);
890 return __fixunsdfdi (a);
895 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
896 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
899 __fixunssfdi (SFtype original_a)
901 /* Convert the SFtype to a DFtype, because that is surely not going
902 to lose any bits. Some day someone else can write a faster version
903 that avoids converting to DFtype, and verify it really works right. */
904 DFtype a = original_a;
911 /* Compute high word of result, as a flonum. */
912 b = (a / HIGH_WORD_COEFF);
913 /* Convert that to fixed (but not to DItype!),
914 and shift it into the high word. */
917 /* Remove high part from the DFtype, leaving the low part as flonum. */
919 /* Convert that to fixed (but not to DItype!) and add it in.
920 Sometimes A comes out negative. This is significant, since
921 A has more bits than a long int does. */
923 v -= (USItype) (- a);
935 return - __fixunssfdi (-a);
936 return __fixunssfdi (a);
940 #if defined(L_floatdixf) && (LONG_DOUBLE_TYPE_SIZE == 96)
941 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
942 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
943 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
955 d = (USItype) (u >> WORD_SIZE);
956 d *= HIGH_HALFWORD_COEFF;
957 d *= HIGH_HALFWORD_COEFF;
958 d += (USItype) (u & (HIGH_WORD_COEFF - 1));
960 return (negate ? -d : d);
964 #if defined(L_floatditf) && (LONG_DOUBLE_TYPE_SIZE == 128)
965 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
966 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
967 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
979 d = (USItype) (u >> WORD_SIZE);
980 d *= HIGH_HALFWORD_COEFF;
981 d *= HIGH_HALFWORD_COEFF;
982 d += (USItype) (u & (HIGH_WORD_COEFF - 1));
984 return (negate ? -d : d);
989 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
990 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
991 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
1003 d = (USItype) (u >> WORD_SIZE);
1004 d *= HIGH_HALFWORD_COEFF;
1005 d *= HIGH_HALFWORD_COEFF;
1006 d += (USItype) (u & (HIGH_WORD_COEFF - 1));
1008 return (negate ? -d : d);
1013 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
1014 #define HIGH_HALFWORD_COEFF (((UDItype) 1) << (WORD_SIZE / 2))
1015 #define HIGH_WORD_COEFF (((UDItype) 1) << WORD_SIZE)
1021 /* Do the calculation in DFmode
1022 so that we don't lose any of the precision of the high word
1023 while multiplying it. */
1030 f = (USItype) (u >> WORD_SIZE);
1031 f *= HIGH_HALFWORD_COEFF;
1032 f *= HIGH_HALFWORD_COEFF;
1033 f += (USItype) (u & (HIGH_WORD_COEFF - 1));
1035 return (SFtype) (negate ? -f : f);
1039 #if defined(L_fixunsxfsi) && LONG_DOUBLE_TYPE_SIZE == 96
1040 #include "glimits.h"
1046 if (a >= - (DFtype) LONG_MIN)
1047 return (SItype) (a + LONG_MIN) - LONG_MIN;
1053 #include "glimits.h"
1059 if (a >= - (DFtype) LONG_MIN)
1060 return (SItype) (a + LONG_MIN) - LONG_MIN;
1066 #include "glimits.h"
1069 __fixunssfsi (SFtype a)
1071 if (a >= - (SFtype) LONG_MIN)
1072 return (SItype) (a + LONG_MIN) - LONG_MIN;
1077 /* From here on down, the routines use normal data types. */
1079 #define SItype bogus_type
1080 #define USItype bogus_type
1081 #define DItype bogus_type
1082 #define UDItype bogus_type
1083 #define SFtype bogus_type
1084 #define DFtype bogus_type
1096 /* Like bcmp except the sign is meaningful.
1097 Reult is negative if S1 is less than S2,
1098 positive if S1 is greater, 0 if S1 and S2 are equal. */
1101 __gcc_bcmp (s1, s2, size)
1102 unsigned char *s1, *s2;
1107 unsigned char c1 = *s1++, c2 = *s2++;
1119 #if defined(__svr4__) || defined(__alliant__)
1123 /* The Alliant needs the added underscore. */
1124 asm (".globl __builtin_saveregs");
1125 asm ("__builtin_saveregs:");
1126 asm (".globl ___builtin_saveregs");
1127 asm ("___builtin_saveregs:");
1129 asm (" andnot 0x0f,%sp,%sp"); /* round down to 16-byte boundary */
1130 asm (" adds -96,%sp,%sp"); /* allocate stack space for reg save
1131 area and also for a new va_list
1133 /* Save all argument registers in the arg reg save area. The
1134 arg reg save area must have the following layout (according
1146 asm (" fst.q %f8, 0(%sp)"); /* save floating regs (f8-f15) */
1147 asm (" fst.q %f12,16(%sp)");
1149 asm (" st.l %r16,32(%sp)"); /* save integer regs (r16-r27) */
1150 asm (" st.l %r17,36(%sp)");
1151 asm (" st.l %r18,40(%sp)");
1152 asm (" st.l %r19,44(%sp)");
1153 asm (" st.l %r20,48(%sp)");
1154 asm (" st.l %r21,52(%sp)");
1155 asm (" st.l %r22,56(%sp)");
1156 asm (" st.l %r23,60(%sp)");
1157 asm (" st.l %r24,64(%sp)");
1158 asm (" st.l %r25,68(%sp)");
1159 asm (" st.l %r26,72(%sp)");
1160 asm (" st.l %r27,76(%sp)");
1162 asm (" adds 80,%sp,%r16"); /* compute the address of the new
1163 va_list structure. Put in into
1164 r16 so that it will be returned
1167 /* Initialize all fields of the new va_list structure. This
1168 structure looks like:
1171 unsigned long ireg_used;
1172 unsigned long freg_used;
1178 asm (" st.l %r0, 0(%r16)"); /* nfixed */
1179 asm (" st.l %r0, 4(%r16)"); /* nfloating */
1180 asm (" st.l %sp, 8(%r16)"); /* __va_ctl points to __va_struct. */
1181 asm (" bri %r1"); /* delayed return */
1182 asm (" st.l %r28,12(%r16)"); /* pointer to overflow args */
1184 #else /* not __svr4__ */
1188 asm (".globl ___builtin_saveregs");
1189 asm ("___builtin_saveregs:");
1190 asm (" mov sp,r30");
1191 asm (" andnot 0x0f,sp,sp");
1192 asm (" adds -96,sp,sp"); /* allocate sufficient space on the stack */
1194 /* Fill in the __va_struct. */
1195 asm (" st.l r16, 0(sp)"); /* save integer regs (r16-r27) */
1196 asm (" st.l r17, 4(sp)"); /* int fixed[12] */
1197 asm (" st.l r18, 8(sp)");
1198 asm (" st.l r19,12(sp)");
1199 asm (" st.l r20,16(sp)");
1200 asm (" st.l r21,20(sp)");
1201 asm (" st.l r22,24(sp)");
1202 asm (" st.l r23,28(sp)");
1203 asm (" st.l r24,32(sp)");
1204 asm (" st.l r25,36(sp)");
1205 asm (" st.l r26,40(sp)");
1206 asm (" st.l r27,44(sp)");
1208 asm (" fst.q f8, 48(sp)"); /* save floating regs (f8-f15) */
1209 asm (" fst.q f12,64(sp)"); /* int floating[8] */
1211 /* Fill in the __va_ctl. */
1212 asm (" st.l sp, 80(sp)"); /* __va_ctl points to __va_struct. */
1213 asm (" st.l r28,84(sp)"); /* pointer to more args */
1214 asm (" st.l r0, 88(sp)"); /* nfixed */
1215 asm (" st.l r0, 92(sp)"); /* nfloating */
1217 asm (" adds 80,sp,r16"); /* return address of the __va_ctl. */
1219 asm (" mov r30,sp");
1220 /* recover stack and pass address to start
1222 #endif /* not __svr4__ */
1223 #else /* not __i860__ */
1225 asm (".global __builtin_saveregs");
1226 asm ("__builtin_saveregs:");
1227 asm (".global ___builtin_saveregs");
1228 asm ("___builtin_saveregs:");
1229 #ifdef NEED_PROC_COMMAND
1232 asm ("st %i0,[%fp+68]");
1233 asm ("st %i1,[%fp+72]");
1234 asm ("st %i2,[%fp+76]");
1235 asm ("st %i3,[%fp+80]");
1236 asm ("st %i4,[%fp+84]");
1238 asm ("st %i5,[%fp+88]");
1239 #ifdef NEED_TYPE_COMMAND
1240 asm (".type __builtin_saveregs,#function");
1241 asm (".size __builtin_saveregs,.-__builtin_saveregs");
1243 #else /* not __sparc__ */
1244 #if defined(__MIPSEL__) | defined(__R3000__) | defined(__R2000__) | defined(__mips__)
1247 asm (" .ent __builtin_saveregs");
1248 asm (" .globl __builtin_saveregs");
1249 asm ("__builtin_saveregs:");
1250 asm (" sw $4,0($30)");
1251 asm (" sw $5,4($30)");
1252 asm (" sw $6,8($30)");
1253 asm (" sw $7,12($30)");
1255 asm (" .end __builtin_saveregs");
1256 #else /* not __mips__, etc. */
1257 __builtin_saveregs ()
1261 #endif /* not __mips__ */
1262 #endif /* not __sparc__ */
1263 #endif /* not __i860__ */
1267 #ifndef inhibit_libc
1269 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1271 /* This is used by the `assert' macro. */
1273 __eprintf (string, expression, line, filename)
1275 const char *expression;
1277 const char *filename;
1279 fprintf (stderr, string, expression, line, filename);
1288 /* Avoid warning from ranlib about empty object file. */
1290 __bb_avoid_warning ()
1293 #if defined (__sun__) && defined (__mc68000__)
1304 extern int ___tcov_init;
1306 __bb_init_func (blocks)
1310 ___tcov_init_func ();
1312 ___bb_link (blocks->filename, blocks->counts, blocks->ncounts);
1318 /* frills for C++ */
1321 typedef void (*vfp)(void);
1323 extern vfp __new_handler;
1325 /* void * operator new (size_t sz) */
1327 __builtin_new (size_t sz)
1331 /* malloc (0) is unpredictable; avoid it. */
1334 p = (void *) malloc (sz);
1336 (*__new_handler) ();
1339 #endif /* L_op_new */
1341 #ifdef L_new_handler
1343 #ifndef inhibit_libc
1344 /* This gets us __GNU_LIBRARY__. */
1345 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1348 #ifdef __GNU_LIBRARY__
1349 /* Avoid forcing the library's meaning of `write' on the user program
1350 by using the "internal" name (for use within the library) */
1351 #define write(fd, buf, n) __write((fd), (buf), (n))
1353 #endif /* inhibit_libc */
1355 typedef void (*vfp)(void);
1357 extern void *__builtin_new (size_t);
1358 static void default_new_handler (void);
1360 vfp __new_handler = default_new_handler;
1363 __set_new_handler (handler)
1368 prev_handler = __new_handler;
1369 if (handler == 0) handler = default_new_handler;
1370 __new_handler = handler;
1371 return prev_handler;
1375 set_new_handler (handler)
1378 return __set_new_handler (handler);
1381 #define MESSAGE "Virtual memory exceeded in `new'\n"
1384 default_new_handler ()
1386 /* don't use fprintf (stderr, ...) because it may need to call malloc. */
1387 /* This should really print the name of the program, but that is hard to
1388 do. We need a standard, clean way to get at the name. */
1389 write (2, MESSAGE, sizeof (MESSAGE));
1390 /* don't call exit () because that may call global destructors which
1391 may cause a loop. */
1397 /* void operator delete (void *ptr) */
1399 __builtin_delete (void *ptr)
1407 unsigned int __shtab[] = {
1408 0x00000001, 0x00000002, 0x00000004, 0x00000008,
1409 0x00000010, 0x00000020, 0x00000040, 0x00000080,
1410 0x00000100, 0x00000200, 0x00000400, 0x00000800,
1411 0x00001000, 0x00002000, 0x00004000, 0x00008000,
1412 0x00010000, 0x00020000, 0x00040000, 0x00080000,
1413 0x00100000, 0x00200000, 0x00400000, 0x00800000,
1414 0x01000000, 0x02000000, 0x04000000, 0x08000000,
1415 0x10000000, 0x20000000, 0x40000000, 0x80000000
1419 #ifdef L_clear_cache
1420 /* Clear part of an instruction cache. */
1422 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1425 __clear_cache (beg, end)
1428 #ifdef INSN_CACHE_SIZE
1429 static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1430 static int initialized = 0;
1434 typedef (*function_ptr) ();
1436 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1437 /* It's cheaper to clear the whole cache.
1438 Put in a series of jump instructions so that calling the beginning
1439 of the cache will clear the whole thing. */
1443 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1444 & -INSN_CACHE_LINE_WIDTH);
1445 int end_ptr = ptr + INSN_CACHE_SIZE;
1447 while (ptr < end_ptr)
1449 *(INSTRUCTION_TYPE *)ptr
1450 = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1451 ptr += INSN_CACHE_LINE_WIDTH;
1453 *(INSTRUCTION_TYPE *)(ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1458 /* Call the beginning of the sequence. */
1459 (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1460 & -INSN_CACHE_LINE_WIDTH))
1463 #else /* Cache is large. */
1467 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1468 & -INSN_CACHE_LINE_WIDTH);
1470 while (ptr < (int) array + sizeof array)
1472 *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1473 ptr += INSN_CACHE_LINE_WIDTH;
1479 /* Find the location in array that occupies the same cache line as BEG. */
1481 offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1482 start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1483 & -INSN_CACHE_PLANE_SIZE)
1486 /* Compute the cache alignment of the place to stop clearing. */
1487 #if 0 /* This is not needed for gcc's purposes. */
1488 /* If the block to clear is bigger than a cache plane,
1489 we clear the entire cache, and OFFSET is already correct. */
1490 if (end < beg + INSN_CACHE_PLANE_SIZE)
1492 offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1493 & -INSN_CACHE_LINE_WIDTH)
1494 & (INSN_CACHE_PLANE_SIZE - 1));
1496 #if INSN_CACHE_DEPTH > 1
1497 end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1498 if (end_addr <= start_addr)
1499 end_addr += INSN_CACHE_PLANE_SIZE;
1501 for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1503 int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1504 int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1506 while (addr != stop)
1508 /* Call the return instruction at ADDR. */
1509 ((function_ptr) addr) ();
1511 addr += INSN_CACHE_LINE_WIDTH;
1514 #else /* just one plane */
1517 /* Call the return instruction at START_ADDR. */
1518 ((function_ptr) start_addr) ();
1520 start_addr += INSN_CACHE_LINE_WIDTH;
1522 while ((start_addr % INSN_CACHE_SIZE) != offset);
1523 #endif /* just one plane */
1524 #endif /* Cache is large */
1525 #endif /* Cache exists */
1528 #endif /* L_clear_cache */
1532 /* Jump to a trampoline, loading the static chain address. */
1534 #ifdef TRANSFER_FROM_TRAMPOLINE
1535 TRANSFER_FROM_TRAMPOLINE
1540 /* Make stack executable so we can call trampolines on stack.
1541 This is called from INITIALIZE_TRAMPOLINE in convex.h. */
1543 #include <sys/mman.h>
1544 #include <sys/vmparam.h>
1545 #include <machine/machparam.h>
1548 __enable_execute_stack ()
1551 static unsigned lowest = USRSTACK;
1552 unsigned current = (unsigned) &fp & -NBPG;
1554 if (lowest > current)
1556 unsigned len = lowest - current;
1557 mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1561 /* Clear instruction cache in case an old trampoline is in it. */
1564 #endif /* __convex__ */
1568 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1570 #include <sys/mman.h>
1571 #include <sys/types.h>
1572 #include <sys/param.h>
1573 #include <sys/vmmac.h>
1575 /* Modified from the convex -code above.
1576 mremap promises to clear the i-cache. */
1579 __enable_execute_stack ()
1582 if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1583 PROT_READ|PROT_WRITE|PROT_EXEC))
1585 perror ("mprotect in __enable_execute_stack");
1590 #endif /* __pyr__ */
1591 #endif /* L_trampoline */
1595 #include "gbl-ctors.h"
1596 /* Some systems use __main in a way incompatible with its use in gcc, in these
1597 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1598 give the same symbol without quotes for an alternative entry point. You
1599 must define both, or niether. */
1601 #define NAME__MAIN "__main"
1602 #define SYMBOL__MAIN __main
1605 /* Run all the global destructors on exit from the program. */
1608 __do_global_dtors ()
1610 #ifdef DO_GLOBAL_DTORS_BODY
1611 DO_GLOBAL_DTORS_BODY;
1613 unsigned nptrs = (unsigned HOST_WIDE_INT) __DTOR_LIST__[0];
1616 /* Some systems place the number of pointers
1617 in the first word of the table.
1618 On other systems, that word is -1.
1619 In all cases, the table is null-terminated. */
1621 /* If the length is not recorded, count up to the null. */
1623 for (nptrs = 0; __DTOR_LIST__[nptrs + 1] != 0; nptrs++);
1625 /* GNU LD format. */
1626 for (i = nptrs; i >= 1; i--)
1627 __DTOR_LIST__[i] ();
1631 #ifndef INIT_SECTION_ASM_OP
1632 /* Run all the global constructors on entry to the program. */
1635 #define ON_EXIT(a, b)
1637 /* Make sure the exit routine is pulled in to define the globals as
1638 bss symbols, just in case the linker does not automatically pull
1639 bss definitions from the library. */
1641 extern int _exit_dummy_decl;
1642 int *_exit_dummy_ref = &_exit_dummy_decl;
1643 #endif /* ON_EXIT */
1646 __do_global_ctors ()
1648 DO_GLOBAL_CTORS_BODY;
1649 ON_EXIT (__do_global_dtors, 0);
1651 #endif /* no INIT_SECTION_ASM_OP */
1653 #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main)
1654 /* Subroutine called automatically by `main'.
1655 Compiling a global function named `main'
1656 produces an automatic call to this function at the beginning.
1658 For many systems, this routine calls __do_global_ctors.
1659 For systems which support a .init section we use the .init section
1660 to run __do_global_ctors, so we need not do anything here. */
1665 /* Support recursive calls to `main': run initializers just once. */
1666 static int initialized = 0;
1670 __do_global_ctors ();
1673 #endif /* no INIT_SECTION_ASM_OP or INVOKE__main */
1675 #endif /* L__main */
1679 #include "gbl-ctors.h"
1681 /* Provide default definitions for the lists of constructors and
1682 destructors, so that we don't get linker errors. These symbols are
1683 intentionally bss symbols, so that gld and/or collect will provide
1684 the right values. */
1686 /* We declare the lists here with two elements each,
1687 so that they are valid empty lists if no other definition is loaded. */
1688 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1690 /* After 2.3, try this definition on all systems. */
1691 func_ptr __CTOR_LIST__[2] = {0, 0};
1692 func_ptr __DTOR_LIST__[2] = {0, 0};
1694 func_ptr __CTOR_LIST__[2];
1695 func_ptr __DTOR_LIST__[2];
1697 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1698 #endif /* L_ctors */
1702 #include "gbl-ctors.h"
1706 /* If we have no known way of registering our own __do_global_dtors
1707 routine so that it will be invoked at program exit time, then we
1708 have to define our own exit routine which will get this to happen. */
1710 extern void __do_global_dtors ();
1711 extern void _cleanup ();
1712 extern volatile void _exit ();
1718 __do_global_dtors ();
1728 int _exit_dummy_decl = 0; /* prevent compiler & linker warnings */
1733 /* In a.out systems, we need to have these dummy constructor and destructor
1734 lists in the library.
1736 When using `collect', the first link will resolve __CTOR_LIST__
1737 and __DTOR_LIST__ to these symbols. We will then run "nm" on the
1738 result, build the correct __CTOR_LIST__ and __DTOR_LIST__, and relink.
1739 Since we don't do the second link if no constructors existed, these
1740 dummies must be fully functional empty lists.
1742 When using `gnu ld', these symbols will be used if there are no
1743 constructors. If there are constructors, the N_SETV symbol defined
1744 by the linker from the N_SETT's in input files will define __CTOR_LIST__
1745 and __DTOR_LIST__ rather than its being allocated as common storage
1746 by the definitions below.
1748 When using a linker that supports constructor and destructor segments,
1749 these definitions will not be used, since crtbegin.o and crtend.o
1750 (from crtstuff.c) will have already defined __CTOR_LIST__ and
1751 __DTOR_LIST__. The crt*.o files are passed directly to the linker
1752 on its command line, by gcc. */
1754 /* The list needs two elements: one is ignored (the old count); the
1755 second is the terminating zero. Since both values are zero, this
1756 declaration is not initialized, and it becomes `common'. */
1759 #include "gbl-ctors.h"
1760 func_ptr __CTOR_LIST__[2];
1764 #include "gbl-ctors.h"
1765 func_ptr __DTOR_LIST__[2];