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
32 /* It is incorrect to include config.h here, because this file is being
33 compiled for the target, and hence definitions concerning only the host
39 /* Don't use `fancy_abort' here even if config.h says to use it. */
46 #ifdef DECLARE_LIBRARY_RENAMES
47 DECLARE_LIBRARY_RENAMES
50 #if defined (L_negdi2)
60 w
.s
.high
= -uu
.s
.high
- ((UWtype
) w
.s
.low
> 0);
68 __addvsi3 (Wtype a
, Wtype b
)
74 if (b
>= 0 ? w
< a
: w
> a
)
83 __addvdi3 (DWtype a
, DWtype b
)
89 if (b
>= 0 ? w
< a
: w
> a
)
98 __subvsi3 (Wtype a
, Wtype b
)
101 return __addvsi3 (a
, (-b
));
107 if (b
>= 0 ? w
> a
: w
< a
)
117 __subvdi3 (DWtype a
, DWtype b
)
126 if (b
>= 0 ? w
> a
: w
< a
)
136 __mulvsi3 (Wtype a
, Wtype b
)
142 if (((a
>= 0) == (b
>= 0)) ? w
< 0 : w
> 0)
157 if (a
>= 0 ? w
> 0 : w
< 0)
172 if (a
>= 0 ? w
> 0 : w
< 0)
221 __mulvdi3 (DWtype u
, DWtype v
)
227 if (((u
>= 0) == (v
>= 0)) ? w
< 0 : w
> 0)
235 /* Unless shift functions are defined whith full ANSI prototypes,
236 parameter b will be promoted to int if word_type is smaller than an int. */
239 __lshrdi3 (DWtype u
, word_type b
)
250 bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
254 w
.s
.low
= (UWtype
) uu
.s
.high
>> -bm
;
258 UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
260 w
.s
.high
= (UWtype
) uu
.s
.high
>> b
;
261 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
270 __ashldi3 (DWtype u
, word_type b
)
281 bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
285 w
.s
.high
= (UWtype
) uu
.s
.low
<< -bm
;
289 UWtype carries
= (UWtype
) uu
.s
.low
>> bm
;
291 w
.s
.low
= (UWtype
) uu
.s
.low
<< b
;
292 w
.s
.high
= ((UWtype
) uu
.s
.high
<< b
) | carries
;
301 __ashrdi3 (DWtype u
, word_type b
)
312 bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
315 /* w.s.high = 1..1 or 0..0 */
316 w
.s
.high
= uu
.s
.high
>> (sizeof (Wtype
) * BITS_PER_UNIT
- 1);
317 w
.s
.low
= uu
.s
.high
>> -bm
;
321 UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
323 w
.s
.high
= uu
.s
.high
>> b
;
324 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
336 UWtype word
, count
, add
;
340 word
= uu
.s
.low
, add
= 0;
341 else if (uu
.s
.high
!= 0)
342 word
= uu
.s
.high
, add
= BITS_PER_UNIT
* sizeof (Wtype
);
346 count_trailing_zeros (count
, word
);
347 return count
+ add
+ 1;
353 __muldi3 (DWtype u
, DWtype v
)
361 w
.ll
= __umulsidi3 (uu
.s
.low
, vv
.s
.low
);
362 w
.s
.high
+= ((UWtype
) uu
.s
.low
* (UWtype
) vv
.s
.high
363 + (UWtype
) uu
.s
.high
* (UWtype
) vv
.s
.low
);
370 #if defined (sdiv_qrnnd)
372 __udiv_w_sdiv (UWtype
*rp
, UWtype a1
, UWtype a0
, UWtype d
)
379 if (a1
< d
- a1
- (a0
>> (W_TYPE_SIZE
- 1)))
381 /* dividend, divisor, and quotient are nonnegative */
382 sdiv_qrnnd (q
, r
, a1
, a0
, d
);
386 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d */
387 sub_ddmmss (c1
, c0
, a1
, a0
, d
>> 1, d
<< (W_TYPE_SIZE
- 1));
388 /* Divide (c1*2^32 + c0) by d */
389 sdiv_qrnnd (q
, r
, c1
, c0
, d
);
390 /* Add 2^31 to quotient */
391 q
+= (UWtype
) 1 << (W_TYPE_SIZE
- 1);
396 b1
= d
>> 1; /* d/2, between 2^30 and 2^31 - 1 */
397 c1
= a1
>> 1; /* A/2 */
398 c0
= (a1
<< (W_TYPE_SIZE
- 1)) + (a0
>> 1);
400 if (a1
< b1
) /* A < 2^32*b1, so A/2 < 2^31*b1 */
402 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
404 r
= 2*r
+ (a0
& 1); /* Remainder from A/(2*b1) */
421 else if (c1
< b1
) /* So 2^31 <= (A/2)/b1 < 2^32 */
424 c0
= ~c0
; /* logical NOT */
426 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
428 q
= ~q
; /* (A/2)/b1 */
431 r
= 2*r
+ (a0
& 1); /* A/(2*b1) */
449 else /* Implies c1 = b1 */
450 { /* Hence a1 = d - 1 = 2*b1 - 1 */
468 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
470 __udiv_w_sdiv (UWtype
*rp
__attribute__ ((__unused__
)),
471 UWtype a1
__attribute__ ((__unused__
)),
472 UWtype a0
__attribute__ ((__unused__
)),
473 UWtype d
__attribute__ ((__unused__
)))
480 #if (defined (L_udivdi3) || defined (L_divdi3) || \
481 defined (L_umoddi3) || defined (L_moddi3))
486 const UQItype __clz_tab
[] =
488 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
489 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
490 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
491 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
492 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
493 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
494 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
495 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
501 #if (defined (L_udivdi3) || defined (L_divdi3) || \
502 defined (L_umoddi3) || defined (L_moddi3))
506 __udivmoddi4 (UDWtype n
, UDWtype d
, UDWtype
*rp
)
511 UWtype d0
, d1
, n0
, n1
, n2
;
523 #if !UDIV_NEEDS_NORMALIZATION
530 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
533 /* Remainder in n0. */
540 d0
= 1 / d0
; /* Divide intentionally by zero. */
542 udiv_qrnnd (q1
, n1
, 0, n1
, d0
);
543 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
545 /* Remainder in n0. */
556 #else /* UDIV_NEEDS_NORMALIZATION */
564 count_leading_zeros (bm
, d0
);
568 /* Normalize, i.e. make the most significant bit of the
572 n1
= (n1
<< bm
) | (n0
>> (W_TYPE_SIZE
- bm
));
576 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
579 /* Remainder in n0 >> bm. */
586 d0
= 1 / d0
; /* Divide intentionally by zero. */
588 count_leading_zeros (bm
, d0
);
592 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
593 conclude (the most significant bit of n1 is set) /\ (the
594 leading quotient digit q1 = 1).
596 This special case is necessary, not an optimization.
597 (Shifts counts of W_TYPE_SIZE are undefined.) */
606 b
= W_TYPE_SIZE
- bm
;
610 n1
= (n1
<< bm
) | (n0
>> b
);
613 udiv_qrnnd (q1
, n1
, n2
, n1
, d0
);
618 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
620 /* Remainder in n0 >> bm. */
630 #endif /* UDIV_NEEDS_NORMALIZATION */
641 /* Remainder in n1n0. */
653 count_leading_zeros (bm
, d1
);
656 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
657 conclude (the most significant bit of n1 is set) /\ (the
658 quotient digit q0 = 0 or 1).
660 This special case is necessary, not an optimization. */
662 /* The condition on the next line takes advantage of that
663 n1 >= d1 (true due to program flow). */
664 if (n1
> d1
|| n0
>= d0
)
667 sub_ddmmss (n1
, n0
, n1
, n0
, d1
, d0
);
686 b
= W_TYPE_SIZE
- bm
;
688 d1
= (d1
<< bm
) | (d0
>> b
);
691 n1
= (n1
<< bm
) | (n0
>> b
);
694 udiv_qrnnd (q0
, n1
, n2
, n1
, d1
);
695 umul_ppmm (m1
, m0
, q0
, d0
);
697 if (m1
> n1
|| (m1
== n1
&& m0
> n0
))
700 sub_ddmmss (m1
, m0
, m1
, m0
, d1
, d0
);
705 /* Remainder in (n1n0 - m1m0) >> bm. */
708 sub_ddmmss (n1
, n0
, n1
, n0
, m1
, m0
);
709 rr
.s
.low
= (n1
<< b
) | (n0
>> bm
);
710 rr
.s
.high
= n1
>> bm
;
725 __divdi3 (DWtype u
, DWtype v
)
741 w
= __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*) 0);
751 __moddi3 (DWtype u
, DWtype v
)
766 (void) __udivmoddi4 (uu
.ll
, vv
.ll
, &w
);
776 __umoddi3 (UDWtype u
, UDWtype v
)
780 (void) __udivmoddi4 (u
, v
, &w
);
788 __udivdi3 (UDWtype n
, UDWtype d
)
790 return __udivmoddi4 (n
, d
, (UDWtype
*) 0);
796 __cmpdi2 (DWtype a
, DWtype b
)
800 au
.ll
= a
, bu
.ll
= b
;
802 if (au
.s
.high
< bu
.s
.high
)
804 else if (au
.s
.high
> bu
.s
.high
)
806 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
808 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
816 __ucmpdi2 (DWtype a
, DWtype b
)
820 au
.ll
= a
, bu
.ll
= b
;
822 if ((UWtype
) au
.s
.high
< (UWtype
) bu
.s
.high
)
824 else if ((UWtype
) au
.s
.high
> (UWtype
) bu
.s
.high
)
826 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
828 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
834 #if defined(L_fixunstfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
835 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
836 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
839 __fixunstfDI (TFtype a
)
847 /* Compute high word of result, as a flonum. */
848 b
= (a
/ HIGH_WORD_COEFF
);
849 /* Convert that to fixed (but not to DWtype!),
850 and shift it into the high word. */
853 /* Remove high part from the TFtype, leaving the low part as flonum. */
855 /* Convert that to fixed (but not to DWtype!) and add it in.
856 Sometimes A comes out negative. This is significant, since
857 A has more bits than a long int does. */
866 #if defined(L_fixtfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
871 return - __fixunstfDI (-a
);
872 return __fixunstfDI (a
);
876 #if defined(L_fixunsxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
877 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
878 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
881 __fixunsxfDI (XFtype a
)
889 /* Compute high word of result, as a flonum. */
890 b
= (a
/ HIGH_WORD_COEFF
);
891 /* Convert that to fixed (but not to DWtype!),
892 and shift it into the high word. */
895 /* Remove high part from the XFtype, leaving the low part as flonum. */
897 /* Convert that to fixed (but not to DWtype!) and add it in.
898 Sometimes A comes out negative. This is significant, since
899 A has more bits than a long int does. */
908 #if defined(L_fixxfdi) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
913 return - __fixunsxfDI (-a
);
914 return __fixunsxfDI (a
);
919 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
920 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
923 __fixunsdfDI (DFtype a
)
931 /* Compute high word of result, as a flonum. */
932 b
= (a
/ HIGH_WORD_COEFF
);
933 /* Convert that to fixed (but not to DWtype!),
934 and shift it into the high word. */
937 /* Remove high part from the DFtype, leaving the low part as flonum. */
939 /* Convert that to fixed (but not to DWtype!) and add it in.
940 Sometimes A comes out negative. This is significant, since
941 A has more bits than a long int does. */
955 return - __fixunsdfDI (-a
);
956 return __fixunsdfDI (a
);
961 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
962 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
965 __fixunssfDI (SFtype original_a
)
967 /* Convert the SFtype to a DFtype, because that is surely not going
968 to lose any bits. Some day someone else can write a faster version
969 that avoids converting to DFtype, and verify it really works right. */
970 DFtype a
= original_a
;
977 /* Compute high word of result, as a flonum. */
978 b
= (a
/ HIGH_WORD_COEFF
);
979 /* Convert that to fixed (but not to DWtype!),
980 and shift it into the high word. */
983 /* Remove high part from the DFtype, leaving the low part as flonum. */
985 /* Convert that to fixed (but not to DWtype!) and add it in.
986 Sometimes A comes out negative. This is significant, since
987 A has more bits than a long int does. */
1001 return - __fixunssfDI (-a
);
1002 return __fixunssfDI (a
);
1006 #if defined(L_floatdixf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96)
1007 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1008 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1009 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1012 __floatdixf (DWtype u
)
1016 d
= (Wtype
) (u
>> WORD_SIZE
);
1017 d
*= HIGH_HALFWORD_COEFF
;
1018 d
*= HIGH_HALFWORD_COEFF
;
1019 d
+= (UWtype
) (u
& (HIGH_WORD_COEFF
- 1));
1025 #if defined(L_floatditf) && (LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128)
1026 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1027 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1028 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1031 __floatditf (DWtype u
)
1035 d
= (Wtype
) (u
>> WORD_SIZE
);
1036 d
*= HIGH_HALFWORD_COEFF
;
1037 d
*= HIGH_HALFWORD_COEFF
;
1038 d
+= (UWtype
) (u
& (HIGH_WORD_COEFF
- 1));
1045 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1046 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1047 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1050 __floatdidf (DWtype u
)
1054 d
= (Wtype
) (u
>> WORD_SIZE
);
1055 d
*= HIGH_HALFWORD_COEFF
;
1056 d
*= HIGH_HALFWORD_COEFF
;
1057 d
+= (UWtype
) (u
& (HIGH_WORD_COEFF
- 1));
1064 #define WORD_SIZE (sizeof (Wtype) * BITS_PER_UNIT)
1065 #define HIGH_HALFWORD_COEFF (((UDWtype) 1) << (WORD_SIZE / 2))
1066 #define HIGH_WORD_COEFF (((UDWtype) 1) << WORD_SIZE)
1068 #define DI_SIZE (sizeof (DWtype) * BITS_PER_UNIT)
1069 #define DF_SIZE DBL_MANT_DIG
1070 #define SF_SIZE FLT_MANT_DIG
1073 __floatdisf (DWtype u
)
1075 /* Do the calculation in DFmode
1076 so that we don't lose any of the precision of the high word
1077 while multiplying it. */
1080 /* Protect against double-rounding error.
1081 Represent any low-order bits, that might be truncated in DFmode,
1082 by a bit that won't be lost. The bit can go in anywhere below the
1083 rounding position of the SFmode. A fixed mask and bit position
1084 handles all usual configurations. It doesn't handle the case
1085 of 128-bit DImode, however. */
1086 if (DF_SIZE
< DI_SIZE
1087 && DF_SIZE
> (DI_SIZE
- DF_SIZE
+ SF_SIZE
))
1089 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1090 if (! (- ((DWtype
) 1 << DF_SIZE
) < u
1091 && u
< ((DWtype
) 1 << DF_SIZE
)))
1093 if ((UDWtype
) u
& (REP_BIT
- 1))
1097 f
= (Wtype
) (u
>> WORD_SIZE
);
1098 f
*= HIGH_HALFWORD_COEFF
;
1099 f
*= HIGH_HALFWORD_COEFF
;
1100 f
+= (UWtype
) (u
& (HIGH_WORD_COEFF
- 1));
1106 #if defined(L_fixunsxfsi) && LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 96
1107 /* Reenable the normal types, in case limits.h needs them. */
1120 __fixunsxfSI (XFtype a
)
1122 if (a
>= - (DFtype
) Wtype_MIN
)
1123 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1129 /* Reenable the normal types, in case limits.h needs them. */
1142 __fixunsdfSI (DFtype a
)
1144 if (a
>= - (DFtype
) Wtype_MIN
)
1145 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1151 /* Reenable the normal types, in case limits.h needs them. */
1164 __fixunssfSI (SFtype a
)
1166 if (a
>= - (SFtype
) Wtype_MIN
)
1167 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1172 /* From here on down, the routines use normal data types. */
1174 #define SItype bogus_type
1175 #define USItype bogus_type
1176 #define DItype bogus_type
1177 #define UDItype bogus_type
1178 #define SFtype bogus_type
1179 #define DFtype bogus_type
1197 /* Like bcmp except the sign is meaningful.
1198 Result is negative if S1 is less than S2,
1199 positive if S1 is greater, 0 if S1 and S2 are equal. */
1202 __gcc_bcmp (const unsigned char *s1
, const unsigned char *s2
, size_t size
)
1206 unsigned char c1
= *s1
++, c2
= *s2
++;
1216 /* __eprintf used to be used by GCC's private version of <assert.h>.
1217 We no longer provide that header, but this routine remains in libgcc.a
1218 for binary backward compatibility. Note that it is not included in
1219 the shared version of libgcc. */
1221 #ifndef inhibit_libc
1223 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1227 __eprintf (const char *string
, const char *expression
,
1228 unsigned int line
, const char *filename
)
1230 fprintf (stderr
, string
, expression
, line
, filename
);
1240 struct bb_function_info
{
1246 /* Structure emitted by -a */
1250 const char *filename
;
1255 /* Older GCC's did not emit these fields. */
1257 struct bb_function_info
*function_infos
;
1260 #ifndef inhibit_libc
1262 /* Simple minded basic block profiling output dumper for
1263 systems that don't provide tcov support. At present,
1264 it requires atexit and stdio. */
1266 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1269 #include "gbl-ctors.h"
1270 #include "gcov-io.h"
1272 #ifdef TARGET_HAS_F_SETLKW
1279 static struct bb
*bb_head
;
1281 int __global_counters
= 0, __gthreads_active
= 0;
1284 __bb_exit_func (void)
1288 long n_counters_p
= 0;
1289 gcov_type max_counter_p
= 0;
1290 gcov_type sum_counters_p
= 0;
1295 /* Calculate overall "statistics". */
1297 for (ptr
= bb_head
; ptr
!= (struct bb
*) 0; ptr
= ptr
->next
)
1301 n_counters_p
+= ptr
->ncounts
;
1303 for (i
= 0; i
< ptr
->ncounts
; i
++)
1305 sum_counters_p
+= ptr
->counts
[i
];
1307 if (ptr
->counts
[i
] > max_counter_p
)
1308 max_counter_p
= ptr
->counts
[i
];
1312 for (ptr
= bb_head
; ptr
!= (struct bb
*) 0; ptr
= ptr
->next
)
1314 gcov_type max_counter_o
= 0;
1315 gcov_type sum_counters_o
= 0;
1318 /* Calculate the per-object statistics. */
1320 for (i
= 0; i
< ptr
->ncounts
; i
++)
1322 sum_counters_o
+= ptr
->counts
[i
];
1324 if (ptr
->counts
[i
] > max_counter_o
)
1325 max_counter_o
= ptr
->counts
[i
];
1328 /* open the file for appending, creating it if necessary. */
1329 da_file
= fopen (ptr
->filename
, "ab");
1330 /* Some old systems might not allow the 'b' mode modifier.
1331 Therefore, try to open without it. This can lead to a race
1332 condition so that when you delete and re-create the file, the
1333 file might be opened in text mode, but then, you shouldn't
1334 delete the file in the first place. */
1336 da_file
= fopen (ptr
->filename
, "a");
1339 fprintf (stderr
, "arc profiling: Can't open output file %s.\n",
1344 /* After a fork, another process might try to read and/or write
1345 the same file simultanously. So if we can, lock the file to
1346 avoid race conditions. */
1347 #if defined (TARGET_HAS_F_SETLKW)
1349 struct flock s_flock
;
1351 s_flock
.l_type
= F_WRLCK
;
1352 s_flock
.l_whence
= SEEK_SET
;
1353 s_flock
.l_start
= 0;
1355 s_flock
.l_pid
= getpid ();
1357 while (fcntl (fileno (da_file
), F_SETLKW
, &s_flock
)
1362 if (__write_long (-123, da_file
, 4) != 0) /* magic */
1364 fprintf (stderr
, "arc profiling: Error writing output file %s.\n",
1370 struct bb_function_info
*fn_info
;
1371 gcov_type
*count_ptr
= ptr
->counts
;
1373 int count_functions
= 0;
1375 for (fn_info
= ptr
->function_infos
; fn_info
->arc_count
!= -1;
1379 /* number of functions in this block. */
1380 __write_long (count_functions
, da_file
, 4);
1382 /* length of extra data in bytes. */
1383 __write_long ((4 + 8 + 8) + (4 + 8 + 8), da_file
, 4);
1385 /* overall statistics. */
1386 /* number of counters. */
1387 __write_long (n_counters_p
, da_file
, 4);
1388 /* sum of counters. */
1389 __write_gcov_type (sum_counters_p
, da_file
, 8);
1390 /* maximal counter. */
1391 __write_gcov_type (max_counter_p
, da_file
, 8);
1393 /* per-object statistics. */
1394 /* number of counters. */
1395 __write_long (ptr
->ncounts
, da_file
, 4);
1396 /* sum of counters. */
1397 __write_gcov_type (sum_counters_o
, da_file
, 8);
1398 /* maximal counter. */
1399 __write_gcov_type (max_counter_o
, da_file
, 8);
1401 /* write execution counts for each function. */
1403 for (fn_info
= ptr
->function_infos
; fn_info
->arc_count
!= -1;
1407 if (__write_gcov_string
1408 (fn_info
->name
, strlen (fn_info
->name
), da_file
, -1) != 0)
1411 "arc profiling: Error writing output file %s.\n",
1416 if (__write_long (fn_info
->checksum
, da_file
, 4) != 0)
1419 "arc profiling: Error writing output file %s.\n",
1424 if (__write_long (fn_info
->arc_count
, da_file
, 4) != 0)
1427 "arc profiling: Error writing output file %s.\n",
1432 for (i
= fn_info
->arc_count
; i
> 0; i
--, count_ptr
++)
1434 if (__write_gcov_type (*count_ptr
, da_file
, 8) != 0)
1438 if (i
) /* there was an error */
1441 "arc profiling: Error writing output file %s.\n",
1448 if (fclose (da_file
) != 0)
1449 fprintf (stderr
, "arc profiling: Error closing output file %s.\n",
1455 __bb_init_func (struct bb
*blocks
)
1457 /* User is supposed to check whether the first word is non-0,
1458 but just in case.... */
1460 if (blocks
->zero_word
)
1463 /* Initialize destructor and per-thread data. */
1465 atexit (__bb_exit_func
);
1467 /* Set up linked list. */
1468 blocks
->zero_word
= 1;
1469 blocks
->next
= bb_head
;
1473 /* Called before fork or exec - write out profile information gathered so
1474 far and reset it to zero. This avoids duplication or loss of the
1475 profile information gathered so far. */
1477 __bb_fork_func (void)
1482 for (ptr
= bb_head
; ptr
!= (struct bb
*) 0; ptr
= ptr
->next
)
1485 for (i
= ptr
->ncounts
- 1; i
>= 0; i
--)
1490 #endif /* not inhibit_libc */
1493 #ifdef L_clear_cache
1494 /* Clear part of an instruction cache. */
1496 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1499 __clear_cache (char *beg
__attribute__((__unused__
)),
1500 char *end
__attribute__((__unused__
)))
1502 #ifdef CLEAR_INSN_CACHE
1503 CLEAR_INSN_CACHE (beg
, end
);
1505 #ifdef INSN_CACHE_SIZE
1506 static char array
[INSN_CACHE_SIZE
+ INSN_CACHE_PLANE_SIZE
+ INSN_CACHE_LINE_WIDTH
];
1507 static int initialized
;
1511 typedef (*function_ptr
) (void);
1513 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1514 /* It's cheaper to clear the whole cache.
1515 Put in a series of jump instructions so that calling the beginning
1516 of the cache will clear the whole thing. */
1520 int ptr
= (((int) array
+ INSN_CACHE_LINE_WIDTH
- 1)
1521 & -INSN_CACHE_LINE_WIDTH
);
1522 int end_ptr
= ptr
+ INSN_CACHE_SIZE
;
1524 while (ptr
< end_ptr
)
1526 *(INSTRUCTION_TYPE
*)ptr
1527 = JUMP_AHEAD_INSTRUCTION
+ INSN_CACHE_LINE_WIDTH
;
1528 ptr
+= INSN_CACHE_LINE_WIDTH
;
1530 *(INSTRUCTION_TYPE
*) (ptr
- INSN_CACHE_LINE_WIDTH
) = RETURN_INSTRUCTION
;
1535 /* Call the beginning of the sequence. */
1536 (((function_ptr
) (((int) array
+ INSN_CACHE_LINE_WIDTH
- 1)
1537 & -INSN_CACHE_LINE_WIDTH
))
1540 #else /* Cache is large. */
1544 int ptr
= (((int) array
+ INSN_CACHE_LINE_WIDTH
- 1)
1545 & -INSN_CACHE_LINE_WIDTH
);
1547 while (ptr
< (int) array
+ sizeof array
)
1549 *(INSTRUCTION_TYPE
*)ptr
= RETURN_INSTRUCTION
;
1550 ptr
+= INSN_CACHE_LINE_WIDTH
;
1556 /* Find the location in array that occupies the same cache line as BEG. */
1558 offset
= ((int) beg
& -INSN_CACHE_LINE_WIDTH
) & (INSN_CACHE_PLANE_SIZE
- 1);
1559 start_addr
= (((int) (array
+ INSN_CACHE_PLANE_SIZE
- 1)
1560 & -INSN_CACHE_PLANE_SIZE
)
1563 /* Compute the cache alignment of the place to stop clearing. */
1564 #if 0 /* This is not needed for gcc's purposes. */
1565 /* If the block to clear is bigger than a cache plane,
1566 we clear the entire cache, and OFFSET is already correct. */
1567 if (end
< beg
+ INSN_CACHE_PLANE_SIZE
)
1569 offset
= (((int) (end
+ INSN_CACHE_LINE_WIDTH
- 1)
1570 & -INSN_CACHE_LINE_WIDTH
)
1571 & (INSN_CACHE_PLANE_SIZE
- 1));
1573 #if INSN_CACHE_DEPTH > 1
1574 end_addr
= (start_addr
& -INSN_CACHE_PLANE_SIZE
) + offset
;
1575 if (end_addr
<= start_addr
)
1576 end_addr
+= INSN_CACHE_PLANE_SIZE
;
1578 for (plane
= 0; plane
< INSN_CACHE_DEPTH
; plane
++)
1580 int addr
= start_addr
+ plane
* INSN_CACHE_PLANE_SIZE
;
1581 int stop
= end_addr
+ plane
* INSN_CACHE_PLANE_SIZE
;
1583 while (addr
!= stop
)
1585 /* Call the return instruction at ADDR. */
1586 ((function_ptr
) addr
) ();
1588 addr
+= INSN_CACHE_LINE_WIDTH
;
1591 #else /* just one plane */
1594 /* Call the return instruction at START_ADDR. */
1595 ((function_ptr
) start_addr
) ();
1597 start_addr
+= INSN_CACHE_LINE_WIDTH
;
1599 while ((start_addr
% INSN_CACHE_SIZE
) != offset
);
1600 #endif /* just one plane */
1601 #endif /* Cache is large */
1602 #endif /* Cache exists */
1603 #endif /* CLEAR_INSN_CACHE */
1606 #endif /* L_clear_cache */
1610 /* Jump to a trampoline, loading the static chain address. */
1612 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1625 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1629 mprotect (char *addr
, int len
, int prot
)
1646 if (VirtualProtect (addr
, len
, np
, &op
))
1652 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1654 #ifdef TRANSFER_FROM_TRAMPOLINE
1655 TRANSFER_FROM_TRAMPOLINE
1658 #if defined (NeXT) && defined (__MACH__)
1660 /* Make stack executable so we can call trampolines on stack.
1661 This is called from INITIALIZE_TRAMPOLINE in next.h. */
1665 #include <mach/mach.h>
1669 __enable_execute_stack (char *addr
)
1672 char *eaddr
= addr
+ TRAMPOLINE_SIZE
;
1673 vm_address_t a
= (vm_address_t
) addr
;
1675 /* turn on execute access on stack */
1676 r
= vm_protect (task_self (), a
, TRAMPOLINE_SIZE
, FALSE
, VM_PROT_ALL
);
1677 if (r
!= KERN_SUCCESS
)
1679 mach_error("vm_protect VM_PROT_ALL", r
);
1683 /* We inline the i-cache invalidation for speed */
1685 #ifdef CLEAR_INSN_CACHE
1686 CLEAR_INSN_CACHE (addr
, eaddr
);
1688 __clear_cache ((int) addr
, (int) eaddr
);
1692 #endif /* defined (NeXT) && defined (__MACH__) */
1696 /* Make stack executable so we can call trampolines on stack.
1697 This is called from INITIALIZE_TRAMPOLINE in convex.h. */
1699 #include <sys/mman.h>
1700 #include <sys/vmparam.h>
1701 #include <machine/machparam.h>
1704 __enable_execute_stack (void)
1707 static unsigned lowest
= USRSTACK
;
1708 unsigned current
= (unsigned) &fp
& -NBPG
;
1710 if (lowest
> current
)
1712 unsigned len
= lowest
- current
;
1713 mremap (current
, &len
, PROT_READ
| PROT_WRITE
| PROT_EXEC
, MAP_PRIVATE
);
1717 /* Clear instruction cache in case an old trampoline is in it. */
1720 #endif /* __convex__ */
1724 /* Modified from the convex -code above. */
1726 #include <sys/param.h>
1728 #include <sys/m88kbcs.h>
1731 __enable_execute_stack (void)
1734 static unsigned long lowest
= USRSTACK
;
1735 unsigned long current
= (unsigned long) &save_errno
& -NBPC
;
1737 /* Ignore errno being set. memctl sets errno to EINVAL whenever the
1738 address is seen as 'negative'. That is the case with the stack. */
1741 if (lowest
> current
)
1743 unsigned len
=lowest
-current
;
1744 memctl(current
,len
,MCT_TEXT
);
1748 memctl(current
,NBPC
,MCT_TEXT
);
1752 #endif /* __sysV88__ */
1756 #include <sys/signal.h>
1759 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
1760 so define it here, because we need it in __clear_insn_cache below */
1761 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
1762 hence we enable this stuff only if MCT_TEXT is #define'd. */
1777 /* Clear instruction cache so we can call trampolines on stack.
1778 This is called from FINALIZE_TRAMPOLINE in mot3300.h. */
1781 __clear_insn_cache (void)
1786 /* Preserve errno, because users would be surprised to have
1787 errno changing without explicitly calling any system-call. */
1790 /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
1791 No need to use an address derived from _start or %sp, as 0 works also. */
1792 memctl(0, 4096, MCT_TEXT
);
1797 #endif /* __sysV68__ */
1801 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1803 #include <sys/mman.h>
1804 #include <sys/types.h>
1805 #include <sys/param.h>
1806 #include <sys/vmmac.h>
1808 /* Modified from the convex -code above.
1809 mremap promises to clear the i-cache. */
1812 __enable_execute_stack (void)
1815 if (mprotect (((unsigned int)&fp
/PAGSIZ
)*PAGSIZ
, PAGSIZ
,
1816 PROT_READ
|PROT_WRITE
|PROT_EXEC
))
1818 perror ("mprotect in __enable_execute_stack");
1823 #endif /* __pyr__ */
1825 #if defined (sony_news) && defined (SYSTYPE_BSD)
1828 #include <sys/types.h>
1829 #include <sys/param.h>
1830 #include <syscall.h>
1831 #include <machine/sysnews.h>
1833 /* cacheflush function for NEWS-OS 4.2.
1834 This function is called from trampoline-initialize code
1835 defined in config/mips/mips.h. */
1838 cacheflush (char *beg
, int size
, int flag
)
1840 if (syscall (SYS_sysnews
, NEWS_CACHEFLUSH
, beg
, size
, FLUSH_BCACHE
))
1842 perror ("cache_flush");
1848 #endif /* sony_news */
1849 #endif /* L_trampoline */
1854 #include "gbl-ctors.h"
1855 /* Some systems use __main in a way incompatible with its use in gcc, in these
1856 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1857 give the same symbol without quotes for an alternative entry point. You
1858 must define both, or neither. */
1860 #define NAME__MAIN "__main"
1861 #define SYMBOL__MAIN __main
1864 #ifdef INIT_SECTION_ASM_OP
1865 #undef HAS_INIT_SECTION
1866 #define HAS_INIT_SECTION
1869 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1871 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1872 code to run constructors. In that case, we need to handle EH here, too. */
1874 #ifdef EH_FRAME_SECTION_NAME
1875 #include "unwind-dw2-fde.h"
1876 extern unsigned char __EH_FRAME_BEGIN__
[];
1879 /* Run all the global destructors on exit from the program. */
1882 __do_global_dtors (void)
1884 #ifdef DO_GLOBAL_DTORS_BODY
1885 DO_GLOBAL_DTORS_BODY
;
1887 static func_ptr
*p
= __DTOR_LIST__
+ 1;
1894 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1896 static int completed
= 0;
1900 __deregister_frame_info (__EH_FRAME_BEGIN__
);
1907 #ifndef HAS_INIT_SECTION
1908 /* Run all the global constructors on entry to the program. */
1911 __do_global_ctors (void)
1913 #ifdef EH_FRAME_SECTION_NAME
1915 static struct object object
;
1916 __register_frame_info (__EH_FRAME_BEGIN__
, &object
);
1919 DO_GLOBAL_CTORS_BODY
;
1920 atexit (__do_global_dtors
);
1922 #endif /* no HAS_INIT_SECTION */
1924 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1925 /* Subroutine called automatically by `main'.
1926 Compiling a global function named `main'
1927 produces an automatic call to this function at the beginning.
1929 For many systems, this routine calls __do_global_ctors.
1930 For systems which support a .init section we use the .init section
1931 to run __do_global_ctors, so we need not do anything here. */
1936 /* Support recursive calls to `main': run initializers just once. */
1937 static int initialized
;
1941 __do_global_ctors ();
1944 #endif /* no HAS_INIT_SECTION or INVOKE__main */
1946 #endif /* L__main */
1947 #endif /* __CYGWIN__ */
1951 #include "gbl-ctors.h"
1953 /* Provide default definitions for the lists of constructors and
1954 destructors, so that we don't get linker errors. These symbols are
1955 intentionally bss symbols, so that gld and/or collect will provide
1956 the right values. */
1958 /* We declare the lists here with two elements each,
1959 so that they are valid empty lists if no other definition is loaded.
1961 If we are using the old "set" extensions to have the gnu linker
1962 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
1963 must be in the bss/common section.
1965 Long term no port should use those extensions. But many still do. */
1966 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1967 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
1968 func_ptr __CTOR_LIST__
[2] = {0, 0};
1969 func_ptr __DTOR_LIST__
[2] = {0, 0};
1971 func_ptr __CTOR_LIST__
[2];
1972 func_ptr __DTOR_LIST__
[2];
1974 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1975 #endif /* L_ctors */
1979 #include "gbl-ctors.h"
1987 static func_ptr
*atexit_chain
= 0;
1988 static long atexit_chain_length
= 0;
1989 static volatile long last_atexit_chain_slot
= -1;
1992 atexit (func_ptr func
)
1994 if (++last_atexit_chain_slot
== atexit_chain_length
)
1996 atexit_chain_length
+= 32;
1998 atexit_chain
= (func_ptr
*) realloc (atexit_chain
, atexit_chain_length
1999 * sizeof (func_ptr
));
2001 atexit_chain
= (func_ptr
*) malloc (atexit_chain_length
2002 * sizeof (func_ptr
));
2005 atexit_chain_length
= 0;
2006 last_atexit_chain_slot
= -1;
2011 atexit_chain
[last_atexit_chain_slot
] = func
;
2015 extern void _cleanup (void);
2016 extern void _exit (int) __attribute__ ((__noreturn__
));
2023 for ( ; last_atexit_chain_slot
-- >= 0; )
2025 (*atexit_chain
[last_atexit_chain_slot
+ 1]) ();
2026 atexit_chain
[last_atexit_chain_slot
+ 1] = 0;
2028 free (atexit_chain
);
2041 /* Simple; we just need a wrapper for ON_EXIT. */
2043 atexit (func_ptr func
)
2045 return ON_EXIT (func
);
2048 #endif /* ON_EXIT */
2049 #endif /* NEED_ATEXIT */