1 /* More subroutines needed by GCC output code on some machines. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2000, 2001 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 In addition to the permissions in the GNU General Public License, the
14 Free Software Foundation gives you unlimited permission to link the
15 compiled version of this file into combinations with other programs,
16 and to distribute those combinations without any restriction coming
17 from the use of this file. (The General Public License restrictions
18 do apply in other respects; for example, they cover modification of
19 the file, and distribution when not linked into a combine
22 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
23 WARRANTY; without even the implied warranty of MERCHANTABILITY or
24 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
27 You should have received a copy of the GNU General Public License
28 along with GCC; see the file COPYING. If not, write to the Free
29 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
34 /* It is incorrect to include config.h here, because this file is being
35 compiled for the target, and hence definitions concerning only the host
43 /* Don't use `fancy_abort' here even if config.h says to use it. */
50 #if defined (L_negdi2) || defined (L_divdi3) || defined (L_moddi3)
51 #if defined (L_divdi3) || defined (L_moddi3)
63 w.s.high = -uu.s.high - ((UWtype) w.s.low > 0);
71 __addvsi3 (Wtype a, Wtype b)
77 if (b >= 0 ? w < a : w > a)
86 __addvdi3 (DWtype a, DWtype b)
92 if (b >= 0 ? w < a : w > a)
101 __subvsi3 (Wtype a, Wtype b)
104 return __addvsi3 (a, (-b));
110 if (b >= 0 ? w > a : w < a)
120 __subvdi3 (DWtype a, DWtype b)
129 if (b >= 0 ? w > a : w < a)
139 __mulvsi3 (Wtype a, Wtype b)
145 if (((a >= 0) == (b >= 0)) ? w < 0 : w > 0)
160 if (a >= 0 ? w > 0 : w < 0)
175 if (a >= 0 ? w > 0 : w < 0)
224 __mulvdi3 (DWtype u, DWtype v)
230 if (((u >= 0) == (v >= 0)) ? w < 0 : w > 0)
238 /* Unless shift functions are defined whith full ANSI prototypes,
239 parameter b will be promoted to int if word_type is smaller than an int. */
242 __lshrdi3 (DWtype u, word_type b)
253 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
257 w.s.low = (UWtype) uu.s.high >> -bm;
261 UWtype carries = (UWtype) uu.s.high << bm;
263 w.s.high = (UWtype) uu.s.high >> b;
264 w.s.low = ((UWtype) uu.s.low >> b) | carries;
273 __ashldi3 (DWtype u, word_type b)
284 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
288 w.s.high = (UWtype) uu.s.low << -bm;
292 UWtype carries = (UWtype) uu.s.low >> bm;
294 w.s.low = (UWtype) uu.s.low << b;
295 w.s.high = ((UWtype) uu.s.high << b) | carries;
304 __ashrdi3 (DWtype u, word_type b)
315 bm = (sizeof (Wtype) * BITS_PER_UNIT) - b;
318 /* w.s.high = 1..1 or 0..0 */
319 w.s.high = uu.s.high >> (sizeof (Wtype) * BITS_PER_UNIT - 1);
320 w.s.low = uu.s.high >> -bm;
324 UWtype carries = (UWtype) uu.s.high << bm;
326 w.s.high = uu.s.high >> b;
327 w.s.low = ((UWtype) uu.s.low >> b) | carries;
339 UWtype word, count, add;
343 word = uu.s.low, add = 0;
344 else if (uu.s.high != 0)
345 word = uu.s.high, add = BITS_PER_UNIT * sizeof (Wtype);
349 count_trailing_zeros (count, word);
350 return count + add + 1;
356 __muldi3 (DWtype u, DWtype v)
364 w.ll = __umulsidi3 (uu.s.low, vv.s.low);
365 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
366 + (UWtype) uu.s.high * (UWtype) vv.s.low);
373 #if defined (sdiv_qrnnd)
375 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
382 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
384 /* dividend, divisor, and quotient are nonnegative */
385 sdiv_qrnnd (q, r, a1, a0, d);
389 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
390 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
391 /* Divide (c1*2^32 + c0) by d */
392 sdiv_qrnnd (q, r, c1, c0, d);
393 /* Add 2^31 to quotient */
394 q += (UWtype) 1 << (W_TYPE_SIZE - 1);
399 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
400 c1 = a1 >> 1; /* A/2 */
401 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
403 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
405 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
407 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
424 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
427 c0 = ~c0; /* logical NOT */
429 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
431 q = ~q; /* (A/2)/b1 */
434 r = 2*r + (a0 & 1); /* A/(2*b1) */
452 else /* Implies c1 = b1 */
453 { /* Hence a1 = d - 1 = 2*b1 - 1 */
471 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
473 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
474 UWtype a1 __attribute__ ((__unused__)),
475 UWtype a0 __attribute__ ((__unused__)),
476 UWtype d __attribute__ ((__unused__)))
483 #if (defined (L_udivdi3) || defined (L_divdi3) || \
484 defined (L_umoddi3) || defined (L_moddi3))
489 const UQItype __clz_tab[] =
491 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,
492 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,
493 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,
494 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,
495 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
496 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
497 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,
498 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,
504 #if (defined (L_udivdi3) || defined (L_divdi3) || \
505 defined (L_umoddi3) || defined (L_moddi3))
509 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
514 UWtype d0, d1, n0, n1, n2;
526 #if !UDIV_NEEDS_NORMALIZATION
533 udiv_qrnnd (q0, n0, n1, n0, d0);
536 /* Remainder in n0. */
543 d0 = 1 / d0; /* Divide intentionally by zero. */
545 udiv_qrnnd (q1, n1, 0, n1, d0);
546 udiv_qrnnd (q0, n0, n1, n0, d0);
548 /* Remainder in n0. */
559 #else /* UDIV_NEEDS_NORMALIZATION */
567 count_leading_zeros (bm, d0);
571 /* Normalize, i.e. make the most significant bit of the
575 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
579 udiv_qrnnd (q0, n0, n1, n0, d0);
582 /* Remainder in n0 >> bm. */
589 d0 = 1 / d0; /* Divide intentionally by zero. */
591 count_leading_zeros (bm, d0);
595 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
596 conclude (the most significant bit of n1 is set) /\ (the
597 leading quotient digit q1 = 1).
599 This special case is necessary, not an optimization.
600 (Shifts counts of W_TYPE_SIZE are undefined.) */
609 b = W_TYPE_SIZE - bm;
613 n1 = (n1 << bm) | (n0 >> b);
616 udiv_qrnnd (q1, n1, n2, n1, d0);
621 udiv_qrnnd (q0, n0, n1, n0, d0);
623 /* Remainder in n0 >> bm. */
633 #endif /* UDIV_NEEDS_NORMALIZATION */
644 /* Remainder in n1n0. */
656 count_leading_zeros (bm, d1);
659 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
660 conclude (the most significant bit of n1 is set) /\ (the
661 quotient digit q0 = 0 or 1).
663 This special case is necessary, not an optimization. */
665 /* The condition on the next line takes advantage of that
666 n1 >= d1 (true due to program flow). */
667 if (n1 > d1 || n0 >= d0)
670 sub_ddmmss (n1, n0, n1, n0, d1, d0);
689 b = W_TYPE_SIZE - bm;
691 d1 = (d1 << bm) | (d0 >> b);
694 n1 = (n1 << bm) | (n0 >> b);
697 udiv_qrnnd (q0, n1, n2, n1, d1);
698 umul_ppmm (m1, m0, q0, d0);
700 if (m1 > n1 || (m1 == n1 && m0 > n0))
703 sub_ddmmss (m1, m0, m1, m0, d1, d0);
708 /* Remainder in (n1n0 - m1m0) >> bm. */
711 sub_ddmmss (n1, n0, n1, n0, m1, m0);
712 rr.s.low = (n1 << b) | (n0 >> bm);
713 rr.s.high = n1 >> bm;
728 __divdi3 (DWtype u, DWtype v)
739 uu.ll = __negdi2 (uu.ll);
742 vv.ll = __negdi2 (vv.ll);
744 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
754 __moddi3 (DWtype u, DWtype v)
765 uu.ll = __negdi2 (uu.ll);
767 vv.ll = __negdi2 (vv.ll);
769 (void) __udivmoddi4 (uu.ll, vv.ll, &w);
779 __umoddi3 (UDWtype u, UDWtype v)
783 (void) __udivmoddi4 (u, v, &w);
791 __udivdi3 (UDWtype n, UDWtype d)
793 return __udivmoddi4 (n, d, (UDWtype *) 0);
799 __cmpdi2 (DWtype a, DWtype b)
803 au.ll = a, bu.ll = b;
805 if (au.s.high < bu.s.high)
807 else if (au.s.high > bu.s.high)
809 if ((UWtype) au.s.low < (UWtype) bu.s.low)
811 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
819 __ucmpdi2 (DWtype a, DWtype b)
823 au.ll = a, bu.ll = b;
825 if ((UWtype) au.s.high < (UWtype) bu.s.high)
827 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
829 if ((UWtype) au.s.low < (UWtype) bu.s.low)
831 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
837 #if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
838 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
839 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
842 __fixunstfDI (TFtype a)
850 /* Compute high word of result, as a flonum. */
851 b = (a / HIGH_WORD_COEFF);
852 /* Convert that to fixed (but not to DWtype!),
853 and shift it into the high word. */
856 /* Remove high part from the TFtype, leaving the low part as flonum. */
858 /* Convert that to fixed (but not to DWtype!) and add it in.
859 Sometimes A comes out negative. This is significant, since
860 A has more bits than a long int does. */
869 #if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
874 return - __fixunstfDI (-a);
875 return __fixunstfDI (a);
879 #if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
880 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
881 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
884 __fixunsxfDI (XFtype a)
892 /* Compute high word of result, as a flonum. */
893 b = (a / HIGH_WORD_COEFF);
894 /* Convert that to fixed (but not to DWtype!),
895 and shift it into the high word. */
898 /* Remove high part from the XFtype, leaving the low part as flonum. */
900 /* Convert that to fixed (but not to DWtype!) and add it in.
901 Sometimes A comes out negative. This is significant, since
902 A has more bits than a long int does. */
911 #if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
916 return - __fixunsxfDI (-a);
917 return __fixunsxfDI (a);
922 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
923 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
926 __fixunsdfDI (DFtype a)
934 /* Compute high word of result, as a flonum. */
935 b = (a / HIGH_WORD_COEFF);
936 /* Convert that to fixed (but not to DWtype!),
937 and shift it into the high word. */
940 /* Remove high part from the DFtype, leaving the low part as flonum. */
942 /* Convert that to fixed (but not to DWtype!) and add it in.
943 Sometimes A comes out negative. This is significant, since
944 A has more bits than a long int does. */
958 return - __fixunsdfDI (-a);
959 return __fixunsdfDI (a);
964 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
965 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
968 __fixunssfDI (SFtype original_a)
970 /* Convert the SFtype to a DFtype, because that is surely not going
971 to lose any bits. Some day someone else can write a faster version
972 that avoids converting to DFtype, and verify it really works right. */
973 DFtype a = original_a;
980 /* Compute high word of result, as a flonum. */
981 b = (a / HIGH_WORD_COEFF);
982 /* Convert that to fixed (but not to DWtype!),
983 and shift it into the high word. */
986 /* Remove high part from the DFtype, leaving the low part as flonum. */
988 /* Convert that to fixed (but not to DWtype!) and add it in.
989 Sometimes A comes out negative. This is significant, since
990 A has more bits than a long int does. */
1001 __fixsfdi (SFtype a)
1004 return - __fixunssfDI (-a);
1005 return __fixunssfDI (a);
1009 #if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
1010 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1011 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1012 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1015 __floatdixf (DWtype u)
1019 d = (Wtype) (u >> WORD_SIZE);
1020 d *= HIGH_HALFWORD_COEFF;
1021 d *= HIGH_HALFWORD_COEFF;
1022 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1028 #if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
1029 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1030 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1031 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1034 __floatditf (DWtype u)
1038 d = (Wtype) (u >> WORD_SIZE);
1039 d *= HIGH_HALFWORD_COEFF;
1040 d *= HIGH_HALFWORD_COEFF;
1041 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1048 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1049 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1050 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1053 __floatdidf (DWtype u)
1057 d = (Wtype) (u >> WORD_SIZE);
1058 d *= HIGH_HALFWORD_COEFF;
1059 d *= HIGH_HALFWORD_COEFF;
1060 d += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1067 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1068 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1069 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1070 #define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
1072 /* Define codes for all the float formats that we know of. Note
1073 that this is copied from real.h. */
1075 #define UNKNOWN_FLOAT_FORMAT 0
1076 #define IEEE_FLOAT_FORMAT 1
1077 #define VAX_FLOAT_FORMAT 2
1078 #define IBM_FLOAT_FORMAT 3
1080 /* Default to IEEE float if not specified. Nearly all machines use it. */
1081 #ifndef HOST_FLOAT_FORMAT
1082 #define HOST_FLOAT_FORMAT IEEE_FLOAT_FORMAT
1085 #if HOST_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
1090 #if HOST_FLOAT_FORMAT == IBM_FLOAT_FORMAT
1095 #if HOST_FLOAT_FORMAT == VAX_FLOAT_FORMAT
1101 __floatdisf (DWtype u)
1103 /* Do the calculation in DFmode
1104 so that we don't lose any of the precision of the high word
1105 while multiplying it. */
1108 /* Protect against double-rounding error.
1109 Represent any low-order bits, that might be truncated in DFmode,
1110 by a bit that won't be lost. The bit can go in anywhere below the
1111 rounding position of the SFmode. A fixed mask and bit position
1112 handles all usual configurations. It doesn't handle the case
1113 of 128-bit DImode, however. */
1114 if (DF_SIZE < DI_SIZE
1115 && DF_SIZE > (DI_SIZE - DF_SIZE + SF_SIZE))
1117 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1118 if (! (- ((DWtype) 1 << DF_SIZE) < u
1119 && u < ((DWtype) 1 << DF_SIZE)))
1121 if ((UDWtype) u & (REP_BIT - 1))
1125 f = (Wtype) (u >> WORD_SIZE);
1126 f *= HIGH_HALFWORD_COEFF;
1127 f *= HIGH_HALFWORD_COEFF;
1128 f += (UWtype) (u & (HIGH_WORD_COEFF - 1));
1134 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1135 /* Reenable the normal types, in case limits.h needs them. */
1148 __fixunsxfSI (XFtype a)
1150 if (a >= - (DFtype) Wtype_MIN)
1151 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1157 /* Reenable the normal types, in case limits.h needs them. */
1170 __fixunsdfSI (DFtype a)
1172 if (a >= - (DFtype) Wtype_MIN)
1173 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1179 /* Reenable the normal types, in case limits.h needs them. */
1192 __fixunssfSI (SFtype a)
1194 if (a >= - (SFtype) Wtype_MIN)
1195 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1200 /* From here on down, the routines use normal data types. */
1202 #define SItype bogus_type
1203 #define USItype bogus_type
1204 #define DItype bogus_type
1205 #define UDItype bogus_type
1206 #define SFtype bogus_type
1207 #define DFtype bogus_type
1225 /* Like bcmp except the sign is meaningful.
1226 Result is negative if S1 is less than S2,
1227 positive if S1 is greater, 0 if S1 and S2 are equal. */
1230 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
1234 unsigned char c1 = *s1++, c2 = *s2++;
1244 /* __eprintf used to be used by GCC's private version of <assert.h>.
1245 We no longer provide that header, but this routine remains in libgcc.a
1246 for binary backward compatibility. Note that it is not included in
1247 the shared version of libgcc. */
1249 #ifndef inhibit_libc
1251 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1255 __eprintf (const char *string, const char *expression,
1256 unsigned int line, const char *filename)
1258 fprintf (stderr, string, expression, line, filename);
1268 #if LONG_TYPE_SIZE == GCOV_TYPE_SIZE
1269 typedef long gcov_type;
1271 typedef long long gcov_type;
1275 /* Structure emitted by -a */
1279 const char *filename;
1283 const unsigned long *addresses;
1285 /* Older GCC's did not emit these fields. */
1287 const char **functions;
1288 const long *line_nums;
1289 const char **filenames;
1293 #ifdef BLOCK_PROFILER_CODE
1296 #ifndef inhibit_libc
1298 /* Simple minded basic block profiling output dumper for
1299 systems that don't provide tcov support. At present,
1300 it requires atexit and stdio. */
1302 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1305 #include "gbl-ctors.h"
1306 #include "gcov-io.h"
1308 #ifdef TARGET_HAS_F_SETLKW
1313 static struct bb *bb_head;
1316 __bb_exit_func (void)
1325 i = strlen (bb_head->filename) - 3;
1328 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1332 /* Make sure the output file exists -
1333 but don't clobber exiting data. */
1334 if ((da_file = fopen (ptr->filename, "a")) != 0)
1337 /* Need to re-open in order to be able to write from the start. */
1338 da_file = fopen (ptr->filename, "r+b");
1339 /* Some old systems might not allow the 'b' mode modifier.
1340 Therefore, try to open without it. This can lead to a race
1341 condition so that when you delete and re-create the file, the
1342 file might be opened in text mode, but then, you shouldn't
1343 delete the file in the first place. */
1345 da_file = fopen (ptr->filename, "r+");
1348 fprintf (stderr, "arc profiling: Can't open output file %s.\n",
1353 /* After a fork, another process might try to read and/or write
1354 the same file simultanously. So if we can, lock the file to
1355 avoid race conditions. */
1356 #if defined (TARGET_HAS_F_SETLKW)
1358 struct flock s_flock;
1360 s_flock.l_type = F_WRLCK;
1361 s_flock.l_whence = SEEK_SET;
1362 s_flock.l_start = 0;
1364 s_flock.l_pid = getpid ();
1366 while (fcntl (fileno (da_file), F_SETLKW, &s_flock)
1371 /* If the file is not empty, and the number of counts in it is the
1372 same, then merge them in. */
1373 firstchar = fgetc (da_file);
1374 if (firstchar == EOF)
1376 if (ferror (da_file))
1378 fprintf (stderr, "arc profiling: Can't read output file ");
1379 perror (ptr->filename);
1386 if (ungetc (firstchar, da_file) == EOF)
1388 if (__read_long (&n_counts, da_file, 8) != 0)
1390 fprintf (stderr, "arc profiling: Can't read output file %s.\n",
1395 if (n_counts == ptr->ncounts)
1399 for (i = 0; i < n_counts; i++)
1403 if (__read_gcov_type (&v, da_file, 8) != 0)
1406 "arc profiling: Can't read output file %s.\n",
1410 ptr->counts[i] += v;
1418 /* ??? Should first write a header to the file. Preferably, a 4 byte
1419 magic number, 4 bytes containing the time the program was
1420 compiled, 4 bytes containing the last modification time of the
1421 source file, and 4 bytes indicating the compiler options used.
1423 That way we can easily verify that the proper source/executable/
1424 data file combination is being used from gcov. */
1426 if (__write_gcov_type (ptr->ncounts, da_file, 8) != 0)
1429 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1435 gcov_type *count_ptr = ptr->counts;
1437 for (j = ptr->ncounts; j > 0; j--)
1439 if (__write_gcov_type (*count_ptr, da_file, 8) != 0)
1447 fprintf (stderr, "arc profiling: Error writing output file %s.\n",
1451 if (fclose (da_file) == EOF)
1452 fprintf (stderr, "arc profiling: Error closing output file %s.\n",
1460 __bb_init_func (struct bb *blocks)
1462 /* User is supposed to check whether the first word is non-0,
1463 but just in case.... */
1465 if (blocks->zero_word)
1468 /* Initialize destructor. */
1470 atexit (__bb_exit_func);
1472 /* Set up linked list. */
1473 blocks->zero_word = 1;
1474 blocks->next = bb_head;
1478 /* Called before fork or exec - write out profile information gathered so
1479 far and reset it to zero. This avoids duplication or loss of the
1480 profile information gathered so far. */
1482 __bb_fork_func (void)
1487 for (ptr = bb_head; ptr != (struct bb *) 0; ptr = ptr->next)
1490 for (i = ptr->ncounts - 1; i >= 0; i--)
1495 #endif /* not inhibit_libc */
1496 #endif /* not BLOCK_PROFILER_CODE */
1499 #ifdef L_clear_cache
1500 /* Clear part of an instruction cache. */
1502 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1505 __clear_cache (char *beg __attribute__((__unused__)),
1506 char *end __attribute__((__unused__)))
1508 #ifdef CLEAR_INSN_CACHE
1509 CLEAR_INSN_CACHE (beg, end);
1511 #ifdef INSN_CACHE_SIZE
1512 static char array[INSN_CACHE_SIZE + INSN_CACHE_PLANE_SIZE + INSN_CACHE_LINE_WIDTH];
1513 static int initialized;
1517 typedef (*function_ptr) (void);
1519 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1520 /* It's cheaper to clear the whole cache.
1521 Put in a series of jump instructions so that calling the beginning
1522 of the cache will clear the whole thing. */
1526 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1527 & -INSN_CACHE_LINE_WIDTH);
1528 int end_ptr = ptr + INSN_CACHE_SIZE;
1530 while (ptr < end_ptr)
1532 *(INSTRUCTION_TYPE *)ptr
1533 = JUMP_AHEAD_INSTRUCTION + INSN_CACHE_LINE_WIDTH;
1534 ptr += INSN_CACHE_LINE_WIDTH;
1536 *(INSTRUCTION_TYPE *) (ptr - INSN_CACHE_LINE_WIDTH) = RETURN_INSTRUCTION;
1541 /* Call the beginning of the sequence. */
1542 (((function_ptr) (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1543 & -INSN_CACHE_LINE_WIDTH))
1546 #else /* Cache is large. */
1550 int ptr = (((int) array + INSN_CACHE_LINE_WIDTH - 1)
1551 & -INSN_CACHE_LINE_WIDTH);
1553 while (ptr < (int) array + sizeof array)
1555 *(INSTRUCTION_TYPE *)ptr = RETURN_INSTRUCTION;
1556 ptr += INSN_CACHE_LINE_WIDTH;
1562 /* Find the location in array that occupies the same cache line as BEG. */
1564 offset = ((int) beg & -INSN_CACHE_LINE_WIDTH) & (INSN_CACHE_PLANE_SIZE - 1);
1565 start_addr = (((int) (array + INSN_CACHE_PLANE_SIZE - 1)
1566 & -INSN_CACHE_PLANE_SIZE)
1569 /* Compute the cache alignment of the place to stop clearing. */
1570 #if 0 /* This is not needed for gcc's purposes. */
1571 /* If the block to clear is bigger than a cache plane,
1572 we clear the entire cache, and OFFSET is already correct. */
1573 if (end < beg + INSN_CACHE_PLANE_SIZE)
1575 offset = (((int) (end + INSN_CACHE_LINE_WIDTH - 1)
1576 & -INSN_CACHE_LINE_WIDTH)
1577 & (INSN_CACHE_PLANE_SIZE - 1));
1579 #if INSN_CACHE_DEPTH > 1
1580 end_addr = (start_addr & -INSN_CACHE_PLANE_SIZE) + offset;
1581 if (end_addr <= start_addr)
1582 end_addr += INSN_CACHE_PLANE_SIZE;
1584 for (plane = 0; plane < INSN_CACHE_DEPTH; plane++)
1586 int addr = start_addr + plane * INSN_CACHE_PLANE_SIZE;
1587 int stop = end_addr + plane * INSN_CACHE_PLANE_SIZE;
1589 while (addr != stop)
1591 /* Call the return instruction at ADDR. */
1592 ((function_ptr) addr) ();
1594 addr += INSN_CACHE_LINE_WIDTH;
1597 #else /* just one plane */
1600 /* Call the return instruction at START_ADDR. */
1601 ((function_ptr) start_addr) ();
1603 start_addr += INSN_CACHE_LINE_WIDTH;
1605 while ((start_addr % INSN_CACHE_SIZE) != offset);
1606 #endif /* just one plane */
1607 #endif /* Cache is large */
1608 #endif /* Cache exists */
1609 #endif /* CLEAR_INSN_CACHE */
1612 #endif /* L_clear_cache */
1616 /* Jump to a trampoline, loading the static chain address. */
1618 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1631 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1635 mprotect (char *addr, int len, int prot)
1652 if (VirtualProtect (addr, len, np, &op))
1658 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1660 #ifdef TRANSFER_FROM_TRAMPOLINE
1661 TRANSFER_FROM_TRAMPOLINE
1664 #if defined (NeXT) && defined (__MACH__)
1666 /* Make stack executable so we can call trampolines on stack.
1667 This is called from INITIALIZE_TRAMPOLINE in next.h. */
1671 #include <mach/mach.h>
1675 __enable_execute_stack (char *addr)
1678 char *eaddr = addr + TRAMPOLINE_SIZE;
1679 vm_address_t a = (vm_address_t) addr;
1681 /* turn on execute access on stack */
1682 r = vm_protect (task_self (), a, TRAMPOLINE_SIZE, FALSE, VM_PROT_ALL);
1683 if (r != KERN_SUCCESS)
1685 mach_error("vm_protect VM_PROT_ALL", r);
1689 /* We inline the i-cache invalidation for speed */
1691 #ifdef CLEAR_INSN_CACHE
1692 CLEAR_INSN_CACHE (addr, eaddr);
1694 __clear_cache ((int) addr, (int) eaddr);
1698 #endif /* defined (NeXT) && defined (__MACH__) */
1702 /* Make stack executable so we can call trampolines on stack.
1703 This is called from INITIALIZE_TRAMPOLINE in convex.h. */
1705 #include <sys/mman.h>
1706 #include <sys/vmparam.h>
1707 #include <machine/machparam.h>
1710 __enable_execute_stack (void)
1713 static unsigned lowest = USRSTACK;
1714 unsigned current = (unsigned) &fp & -NBPG;
1716 if (lowest > current)
1718 unsigned len = lowest - current;
1719 mremap (current, &len, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE);
1723 /* Clear instruction cache in case an old trampoline is in it. */
1726 #endif /* __convex__ */
1730 /* Modified from the convex -code above. */
1732 #include <sys/param.h>
1734 #include <sys/m88kbcs.h>
1737 __enable_execute_stack (void)
1740 static unsigned long lowest = USRSTACK;
1741 unsigned long current = (unsigned long) &save_errno & -NBPC;
1743 /* Ignore errno being set. memctl sets errno to EINVAL whenever the
1744 address is seen as 'negative'. That is the case with the stack. */
1747 if (lowest > current)
1749 unsigned len=lowest-current;
1750 memctl(current,len,MCT_TEXT);
1754 memctl(current,NBPC,MCT_TEXT);
1758 #endif /* __sysV88__ */
1762 #include <sys/signal.h>
1765 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
1766 so define it here, because we need it in __clear_insn_cache below */
1767 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
1768 hence we enable this stuff only if MCT_TEXT is #define'd. */
1783 /* Clear instruction cache so we can call trampolines on stack.
1784 This is called from FINALIZE_TRAMPOLINE in mot3300.h. */
1787 __clear_insn_cache (void)
1792 /* Preserve errno, because users would be surprised to have
1793 errno changing without explicitly calling any system-call. */
1796 /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
1797 No need to use an address derived from _start or %sp, as 0 works also. */
1798 memctl(0, 4096, MCT_TEXT);
1803 #endif /* __sysV68__ */
1807 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1809 #include <sys/mman.h>
1810 #include <sys/types.h>
1811 #include <sys/param.h>
1812 #include <sys/vmmac.h>
1814 /* Modified from the convex -code above.
1815 mremap promises to clear the i-cache. */
1818 __enable_execute_stack (void)
1821 if (mprotect (((unsigned int)&fp/PAGSIZ)*PAGSIZ, PAGSIZ,
1822 PROT_READ|PROT_WRITE|PROT_EXEC))
1824 perror ("mprotect in __enable_execute_stack");
1829 #endif /* __pyr__ */
1831 #if defined (sony_news) && defined (SYSTYPE_BSD)
1834 #include <sys/types.h>
1835 #include <sys/param.h>
1836 #include <syscall.h>
1837 #include <machine/sysnews.h>
1839 /* cacheflush function for NEWS-OS 4.2.
1840 This function is called from trampoline-initialize code
1841 defined in config/mips/mips.h. */
1844 cacheflush (char *beg, int size, int flag)
1846 if (syscall (SYS_sysnews, NEWS_CACHEFLUSH, beg, size, FLUSH_BCACHE))
1848 perror ("cache_flush");
1854 #endif /* sony_news */
1855 #endif /* L_trampoline */
1860 #include "gbl-ctors.h"
1861 /* Some systems use __main in a way incompatible with its use in gcc, in these
1862 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1863 give the same symbol without quotes for an alternative entry point. You
1864 must define both, or neither. */
1866 #define NAME__MAIN "__main"
1867 #define SYMBOL__MAIN __main
1870 #ifdef INIT_SECTION_ASM_OP
1871 #undef HAS_INIT_SECTION
1872 #define HAS_INIT_SECTION
1875 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1877 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1878 code to run constructors. In that case, we need to handle EH here, too. */
1880 #ifdef EH_FRAME_SECTION_NAME
1881 #include "unwind-dw2-fde.h"
1882 extern unsigned char __EH_FRAME_BEGIN__[];
1885 /* Run all the global destructors on exit from the program. */
1888 __do_global_dtors (void)
1890 #ifdef DO_GLOBAL_DTORS_BODY
1891 DO_GLOBAL_DTORS_BODY;
1893 static func_ptr *p = __DTOR_LIST__ + 1;
1900 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1902 static int completed = 0;
1906 __deregister_frame_info (__EH_FRAME_BEGIN__);
1913 #ifndef HAS_INIT_SECTION
1914 /* Run all the global constructors on entry to the program. */
1917 __do_global_ctors (void)
1919 #ifdef EH_FRAME_SECTION_NAME
1921 static struct object object;
1922 __register_frame_info (__EH_FRAME_BEGIN__, &object);
1925 DO_GLOBAL_CTORS_BODY;
1926 atexit (__do_global_dtors);
1928 #endif /* no HAS_INIT_SECTION */
1930 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1931 /* Subroutine called automatically by `main'.
1932 Compiling a global function named `main'
1933 produces an automatic call to this function at the beginning.
1935 For many systems, this routine calls __do_global_ctors.
1936 For systems which support a .init section we use the .init section
1937 to run __do_global_ctors, so we need not do anything here. */
1942 /* Support recursive calls to `main': run initializers just once. */
1943 static int initialized;
1947 __do_global_ctors ();
1950 #endif /* no HAS_INIT_SECTION or INVOKE__main */
1952 #endif /* L__main */
1953 #endif /* __CYGWIN__ */
1957 #include "gbl-ctors.h"
1959 /* Provide default definitions for the lists of constructors and
1960 destructors, so that we don't get linker errors. These symbols are
1961 intentionally bss symbols, so that gld and/or collect will provide
1962 the right values. */
1964 /* We declare the lists here with two elements each,
1965 so that they are valid empty lists if no other definition is loaded.
1967 If we are using the old "set" extensions to have the gnu linker
1968 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
1969 must be in the bss/common section.
1971 Long term no port should use those extensions. But many still do. */
1972 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1973 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
1974 func_ptr __CTOR_LIST__[2] = {0, 0};
1975 func_ptr __DTOR_LIST__[2] = {0, 0};
1977 func_ptr __CTOR_LIST__[2];
1978 func_ptr __DTOR_LIST__[2];
1980 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1981 #endif /* L_ctors */
1985 #include "gbl-ctors.h"
1993 static func_ptr *atexit_chain = 0;
1994 static long atexit_chain_length = 0;
1995 static volatile long last_atexit_chain_slot = -1;
1998 atexit (func_ptr func)
2000 if (++last_atexit_chain_slot == atexit_chain_length)
2002 atexit_chain_length += 32;
2004 atexit_chain = (func_ptr *) realloc (atexit_chain, atexit_chain_length
2005 * sizeof (func_ptr));
2007 atexit_chain = (func_ptr *) malloc (atexit_chain_length
2008 * sizeof (func_ptr));
2011 atexit_chain_length = 0;
2012 last_atexit_chain_slot = -1;
2017 atexit_chain[last_atexit_chain_slot] = func;
2021 extern void _cleanup (void);
2022 extern void _exit (int) __attribute__ ((__noreturn__));
2029 for ( ; last_atexit_chain_slot-- >= 0; )
2031 (*atexit_chain[last_atexit_chain_slot + 1]) ();
2032 atexit_chain[last_atexit_chain_slot + 1] = 0;
2034 free (atexit_chain);
2047 /* Simple; we just need a wrapper for ON_EXIT. */
2049 atexit (func_ptr func)
2051 return ON_EXIT (func);
2054 #endif /* ON_EXIT */
2055 #endif /* NEED_ATEXIT */