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, 2002 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 --profile-arcs */
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 /* Arc profile dumper. Requires atexit and stdio. */
1264 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1267 #include "gcov-io.h"
1269 #ifdef TARGET_HAS_F_SETLKW
1274 /* Chain of per-object file bb structures. */
1275 static struct bb
*bb_head
;
1277 /* Dump the coverage counts. We merge with existing counts when
1278 possible, to avoid growing the .da files ad infinitum. */
1281 __bb_exit_func (void)
1285 gcov_type program_sum
= 0;
1286 gcov_type program_max
= 0;
1287 long program_arcs
= 0;
1288 gcov_type merged_sum
= 0;
1289 gcov_type merged_max
= 0;
1290 long merged_arcs
= 0;
1292 #if defined (TARGET_HAS_F_SETLKW)
1293 struct flock s_flock
;
1295 s_flock
.l_type
= F_WRLCK
;
1296 s_flock
.l_whence
= SEEK_SET
;
1297 s_flock
.l_start
= 0;
1298 s_flock
.l_len
= 0; /* Until EOF. */
1299 s_flock
.l_pid
= getpid ();
1302 /* Non-merged stats for this program. */
1303 for (ptr
= bb_head
; ptr
; ptr
= ptr
->next
)
1305 for (i
= 0; i
< ptr
->ncounts
; i
++)
1307 program_sum
+= ptr
->counts
[i
];
1309 if (ptr
->counts
[i
] > program_max
)
1310 program_max
= ptr
->counts
[i
];
1312 program_arcs
+= ptr
->ncounts
;
1315 for (ptr
= bb_head
; ptr
; ptr
= ptr
->next
)
1318 gcov_type object_max
= 0;
1319 gcov_type object_sum
= 0;
1320 long object_functions
= 0;
1323 struct bb_function_info
*fn_info
;
1324 gcov_type
*count_ptr
;
1326 /* Open for modification */
1327 da_file
= fopen (ptr
->filename
, "r+b");
1333 /* Try for appending */
1334 da_file
= fopen (ptr
->filename
, "ab");
1335 /* Some old systems might not allow the 'b' mode modifier.
1336 Therefore, try to open without it. This can lead to a
1337 race condition so that when you delete and re-create the
1338 file, the file might be opened in text mode, but then,
1339 you shouldn't delete the file in the first place. */
1341 da_file
= fopen (ptr
->filename
, "a");
1346 fprintf (stderr
, "arc profiling: Can't open output file %s.\n",
1352 #if defined (TARGET_HAS_F_SETLKW)
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 while (fcntl (fileno (da_file
), F_SETLKW
, &s_flock
)
1360 for (fn_info
= ptr
->function_infos
; fn_info
->arc_count
!= -1; fn_info
++)
1365 /* Merge data from file. */
1370 (__read_long (&tmp_long
, da_file
, 4) || tmp_long
!= -123l)
1371 /* functions in object file. */
1372 || (__read_long (&tmp_long
, da_file
, 4)
1373 || tmp_long
!= object_functions
)
1374 /* extension block, skipped */
1375 || (__read_long (&tmp_long
, da_file
, 4)
1376 || fseek (da_file
, tmp_long
, SEEK_CUR
)))
1379 fprintf (stderr
, "arc profiling: Error merging output file %s.\n",
1385 /* Merge execution counts for each function. */
1386 count_ptr
= ptr
->counts
;
1388 for (fn_info
= ptr
->function_infos
; fn_info
->arc_count
!= -1;
1391 if (/* function name delim */
1392 (__read_long (&tmp_long
, da_file
, 4)
1394 /* function name length */
1395 || (__read_long (&tmp_long
, da_file
, 4)
1396 || tmp_long
!= (long) strlen (fn_info
->name
))
1398 || fseek (da_file
, ((tmp_long
+ 1) + 3) & ~3, SEEK_CUR
)
1399 /* function name delim */
1400 || (__read_long (&tmp_long
, da_file
, 4)
1404 if (/* function checksum */
1405 (__read_long (&tmp_long
, da_file
, 4)
1406 || tmp_long
!= fn_info
->checksum
)
1408 || (__read_long (&tmp_long
, da_file
, 4)
1409 || tmp_long
!= fn_info
->arc_count
))
1412 for (i
= fn_info
->arc_count
; i
> 0; i
--, count_ptr
++)
1413 if (__read_gcov_type (&tmp_gcov
, da_file
, 8))
1416 *count_ptr
+= tmp_gcov
;
1419 fseek (da_file
, 0, SEEK_SET
);
1422 /* Calculate the per-object statistics. */
1423 for (i
= 0; i
< ptr
->ncounts
; i
++)
1425 object_sum
+= ptr
->counts
[i
];
1427 if (ptr
->counts
[i
] > object_max
)
1428 object_max
= ptr
->counts
[i
];
1430 merged_sum
+= object_sum
;
1431 if (merged_max
< object_max
)
1432 merged_max
= object_max
;
1433 merged_arcs
+= ptr
->ncounts
;
1435 /* Write out the data. */
1437 __write_long (-123, da_file
, 4)
1438 /* number of functions in object file. */
1439 || __write_long (object_functions
, da_file
, 4)
1440 /* length of extra data in bytes. */
1441 || __write_long ((4 + 8 + 8) + (4 + 8 + 8), da_file
, 4)
1443 /* whole program statistics. If merging write per-object
1444 now, rewrite later */
1445 /* number of instrumented arcs. */
1446 || __write_long (merging
? ptr
->ncounts
: program_arcs
, da_file
, 4)
1447 /* sum of counters. */
1448 || __write_gcov_type (merging
? object_sum
: program_sum
, da_file
, 8)
1449 /* maximal counter. */
1450 || __write_gcov_type (merging
? object_max
: program_max
, da_file
, 8)
1452 /* per-object statistics. */
1453 /* number of counters. */
1454 || __write_long (ptr
->ncounts
, da_file
, 4)
1455 /* sum of counters. */
1456 || __write_gcov_type (object_sum
, da_file
, 8)
1457 /* maximal counter. */
1458 || __write_gcov_type (object_max
, da_file
, 8))
1461 fprintf (stderr
, "arc profiling: Error writing output file %s.\n",
1467 /* Write execution counts for each function. */
1468 count_ptr
= ptr
->counts
;
1470 for (fn_info
= ptr
->function_infos
; fn_info
->arc_count
!= -1;
1473 if (__write_gcov_string (fn_info
->name
,
1474 strlen (fn_info
->name
), da_file
, -1)
1475 || __write_long (fn_info
->checksum
, da_file
, 4)
1476 || __write_long (fn_info
->arc_count
, da_file
, 4))
1479 for (i
= fn_info
->arc_count
; i
> 0; i
--, count_ptr
++)
1480 if (__write_gcov_type (*count_ptr
, da_file
, 8))
1481 goto write_error
; /* RIP Edsger Dijkstra */
1485 if (fclose (da_file
))
1487 fprintf (stderr
, "arc profiling: Error closing output file %s.\n",
1491 if (error
|| !merging
)
1495 /* Upate whole program statistics. */
1496 for (ptr
= bb_head
; ptr
; ptr
= ptr
->next
)
1501 da_file
= fopen (ptr
->filename
, "r+b");
1504 fprintf (stderr
, "arc profiling: Cannot reopen %s.\n",
1509 #if defined (TARGET_HAS_F_SETLKW)
1510 while (fcntl (fileno (da_file
), F_SETLKW
, &s_flock
)
1515 if (fseek (da_file
, 4 * 3, SEEK_SET
)
1516 /* number of instrumented arcs. */
1517 || __write_long (merged_arcs
, da_file
, 4)
1518 /* sum of counters. */
1519 || __write_gcov_type (merged_sum
, da_file
, 8)
1520 /* maximal counter. */
1521 || __write_gcov_type (merged_max
, da_file
, 8))
1522 fprintf (stderr
, "arc profiling: Error updating program header %s.\n",
1524 if (fclose (da_file
))
1525 fprintf (stderr
, "arc profiling: Error reclosing %s\n",
1530 /* Add a new object file onto the bb chain. Invoked automatically
1531 when running an object file's global ctors. */
1534 __bb_init_func (struct bb
*blocks
)
1536 if (blocks
->zero_word
)
1539 /* Initialize destructor and per-thread data. */
1541 atexit (__bb_exit_func
);
1543 /* Set up linked list. */
1544 blocks
->zero_word
= 1;
1545 blocks
->next
= bb_head
;
1549 /* Called before fork or exec - write out profile information gathered so
1550 far and reset it to zero. This avoids duplication or loss of the
1551 profile information gathered so far. */
1554 __bb_fork_func (void)
1559 for (ptr
= bb_head
; ptr
!= (struct bb
*) 0; ptr
= ptr
->next
)
1562 for (i
= ptr
->ncounts
- 1; i
>= 0; i
--)
1567 #endif /* not inhibit_libc */
1570 #ifdef L_clear_cache
1571 /* Clear part of an instruction cache. */
1573 #define INSN_CACHE_PLANE_SIZE (INSN_CACHE_SIZE / INSN_CACHE_DEPTH)
1576 __clear_cache (char *beg
__attribute__((__unused__
)),
1577 char *end
__attribute__((__unused__
)))
1579 #ifdef CLEAR_INSN_CACHE
1580 CLEAR_INSN_CACHE (beg
, end
);
1582 #ifdef INSN_CACHE_SIZE
1583 static char array
[INSN_CACHE_SIZE
+ INSN_CACHE_PLANE_SIZE
+ INSN_CACHE_LINE_WIDTH
];
1584 static int initialized
;
1588 typedef (*function_ptr
) (void);
1590 #if (INSN_CACHE_SIZE / INSN_CACHE_LINE_WIDTH) < 16
1591 /* It's cheaper to clear the whole cache.
1592 Put in a series of jump instructions so that calling the beginning
1593 of the cache will clear the whole thing. */
1597 int ptr
= (((int) array
+ INSN_CACHE_LINE_WIDTH
- 1)
1598 & -INSN_CACHE_LINE_WIDTH
);
1599 int end_ptr
= ptr
+ INSN_CACHE_SIZE
;
1601 while (ptr
< end_ptr
)
1603 *(INSTRUCTION_TYPE
*)ptr
1604 = JUMP_AHEAD_INSTRUCTION
+ INSN_CACHE_LINE_WIDTH
;
1605 ptr
+= INSN_CACHE_LINE_WIDTH
;
1607 *(INSTRUCTION_TYPE
*) (ptr
- INSN_CACHE_LINE_WIDTH
) = RETURN_INSTRUCTION
;
1612 /* Call the beginning of the sequence. */
1613 (((function_ptr
) (((int) array
+ INSN_CACHE_LINE_WIDTH
- 1)
1614 & -INSN_CACHE_LINE_WIDTH
))
1617 #else /* Cache is large. */
1621 int ptr
= (((int) array
+ INSN_CACHE_LINE_WIDTH
- 1)
1622 & -INSN_CACHE_LINE_WIDTH
);
1624 while (ptr
< (int) array
+ sizeof array
)
1626 *(INSTRUCTION_TYPE
*)ptr
= RETURN_INSTRUCTION
;
1627 ptr
+= INSN_CACHE_LINE_WIDTH
;
1633 /* Find the location in array that occupies the same cache line as BEG. */
1635 offset
= ((int) beg
& -INSN_CACHE_LINE_WIDTH
) & (INSN_CACHE_PLANE_SIZE
- 1);
1636 start_addr
= (((int) (array
+ INSN_CACHE_PLANE_SIZE
- 1)
1637 & -INSN_CACHE_PLANE_SIZE
)
1640 /* Compute the cache alignment of the place to stop clearing. */
1641 #if 0 /* This is not needed for gcc's purposes. */
1642 /* If the block to clear is bigger than a cache plane,
1643 we clear the entire cache, and OFFSET is already correct. */
1644 if (end
< beg
+ INSN_CACHE_PLANE_SIZE
)
1646 offset
= (((int) (end
+ INSN_CACHE_LINE_WIDTH
- 1)
1647 & -INSN_CACHE_LINE_WIDTH
)
1648 & (INSN_CACHE_PLANE_SIZE
- 1));
1650 #if INSN_CACHE_DEPTH > 1
1651 end_addr
= (start_addr
& -INSN_CACHE_PLANE_SIZE
) + offset
;
1652 if (end_addr
<= start_addr
)
1653 end_addr
+= INSN_CACHE_PLANE_SIZE
;
1655 for (plane
= 0; plane
< INSN_CACHE_DEPTH
; plane
++)
1657 int addr
= start_addr
+ plane
* INSN_CACHE_PLANE_SIZE
;
1658 int stop
= end_addr
+ plane
* INSN_CACHE_PLANE_SIZE
;
1660 while (addr
!= stop
)
1662 /* Call the return instruction at ADDR. */
1663 ((function_ptr
) addr
) ();
1665 addr
+= INSN_CACHE_LINE_WIDTH
;
1668 #else /* just one plane */
1671 /* Call the return instruction at START_ADDR. */
1672 ((function_ptr
) start_addr
) ();
1674 start_addr
+= INSN_CACHE_LINE_WIDTH
;
1676 while ((start_addr
% INSN_CACHE_SIZE
) != offset
);
1677 #endif /* just one plane */
1678 #endif /* Cache is large */
1679 #endif /* Cache exists */
1680 #endif /* CLEAR_INSN_CACHE */
1683 #endif /* L_clear_cache */
1687 /* Jump to a trampoline, loading the static chain address. */
1689 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1702 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1706 mprotect (char *addr
, int len
, int prot
)
1723 if (VirtualProtect (addr
, len
, np
, &op
))
1729 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1731 #ifdef TRANSFER_FROM_TRAMPOLINE
1732 TRANSFER_FROM_TRAMPOLINE
1737 #include <sys/signal.h>
1740 /* Motorola forgot to put memctl.o in the libp version of libc881.a,
1741 so define it here, because we need it in __clear_insn_cache below */
1742 /* On older versions of this OS, no memctl or MCT_TEXT are defined;
1743 hence we enable this stuff only if MCT_TEXT is #define'd. */
1758 /* Clear instruction cache so we can call trampolines on stack.
1759 This is called from FINALIZE_TRAMPOLINE in mot3300.h. */
1762 __clear_insn_cache (void)
1767 /* Preserve errno, because users would be surprised to have
1768 errno changing without explicitly calling any system-call. */
1771 /* Keep it simple : memctl (MCT_TEXT) always fully clears the insn cache.
1772 No need to use an address derived from _start or %sp, as 0 works also. */
1773 memctl(0, 4096, MCT_TEXT
);
1778 #endif /* __sysV68__ */
1779 #endif /* L_trampoline */
1784 #include "gbl-ctors.h"
1785 /* Some systems use __main in a way incompatible with its use in gcc, in these
1786 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1787 give the same symbol without quotes for an alternative entry point. You
1788 must define both, or neither. */
1790 #define NAME__MAIN "__main"
1791 #define SYMBOL__MAIN __main
1794 #ifdef INIT_SECTION_ASM_OP
1795 #undef HAS_INIT_SECTION
1796 #define HAS_INIT_SECTION
1799 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1801 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1802 code to run constructors. In that case, we need to handle EH here, too. */
1804 #ifdef EH_FRAME_SECTION_NAME
1805 #include "unwind-dw2-fde.h"
1806 extern unsigned char __EH_FRAME_BEGIN__
[];
1809 /* Run all the global destructors on exit from the program. */
1812 __do_global_dtors (void)
1814 #ifdef DO_GLOBAL_DTORS_BODY
1815 DO_GLOBAL_DTORS_BODY
;
1817 static func_ptr
*p
= __DTOR_LIST__
+ 1;
1824 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1826 static int completed
= 0;
1830 __deregister_frame_info (__EH_FRAME_BEGIN__
);
1837 #ifndef HAS_INIT_SECTION
1838 /* Run all the global constructors on entry to the program. */
1841 __do_global_ctors (void)
1843 #ifdef EH_FRAME_SECTION_NAME
1845 static struct object object
;
1846 __register_frame_info (__EH_FRAME_BEGIN__
, &object
);
1849 DO_GLOBAL_CTORS_BODY
;
1850 atexit (__do_global_dtors
);
1852 #endif /* no HAS_INIT_SECTION */
1854 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1855 /* Subroutine called automatically by `main'.
1856 Compiling a global function named `main'
1857 produces an automatic call to this function at the beginning.
1859 For many systems, this routine calls __do_global_ctors.
1860 For systems which support a .init section we use the .init section
1861 to run __do_global_ctors, so we need not do anything here. */
1866 /* Support recursive calls to `main': run initializers just once. */
1867 static int initialized
;
1871 __do_global_ctors ();
1874 #endif /* no HAS_INIT_SECTION or INVOKE__main */
1876 #endif /* L__main */
1877 #endif /* __CYGWIN__ */
1881 #include "gbl-ctors.h"
1883 /* Provide default definitions for the lists of constructors and
1884 destructors, so that we don't get linker errors. These symbols are
1885 intentionally bss symbols, so that gld and/or collect will provide
1886 the right values. */
1888 /* We declare the lists here with two elements each,
1889 so that they are valid empty lists if no other definition is loaded.
1891 If we are using the old "set" extensions to have the gnu linker
1892 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
1893 must be in the bss/common section.
1895 Long term no port should use those extensions. But many still do. */
1896 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
1897 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
1898 func_ptr __CTOR_LIST__
[2] = {0, 0};
1899 func_ptr __DTOR_LIST__
[2] = {0, 0};
1901 func_ptr __CTOR_LIST__
[2];
1902 func_ptr __DTOR_LIST__
[2];
1904 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
1905 #endif /* L_ctors */
1909 #include "gbl-ctors.h"
1917 static func_ptr
*atexit_chain
= 0;
1918 static long atexit_chain_length
= 0;
1919 static volatile long last_atexit_chain_slot
= -1;
1922 atexit (func_ptr func
)
1924 if (++last_atexit_chain_slot
== atexit_chain_length
)
1926 atexit_chain_length
+= 32;
1928 atexit_chain
= (func_ptr
*) realloc (atexit_chain
, atexit_chain_length
1929 * sizeof (func_ptr
));
1931 atexit_chain
= (func_ptr
*) malloc (atexit_chain_length
1932 * sizeof (func_ptr
));
1935 atexit_chain_length
= 0;
1936 last_atexit_chain_slot
= -1;
1941 atexit_chain
[last_atexit_chain_slot
] = func
;
1945 extern void _cleanup (void);
1946 extern void _exit (int) __attribute__ ((__noreturn__
));
1953 for ( ; last_atexit_chain_slot
-- >= 0; )
1955 (*atexit_chain
[last_atexit_chain_slot
+ 1]) ();
1956 atexit_chain
[last_atexit_chain_slot
+ 1] = 0;
1958 free (atexit_chain
);
1971 /* Simple; we just need a wrapper for ON_EXIT. */
1973 atexit (func_ptr func
)
1975 return ON_EXIT (func
);
1978 #endif /* ON_EXIT */
1979 #endif /* NEED_ATEXIT */