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, 2003, 2004, 2005, 2007, 2008, 2009
5 Free Software Foundation, Inc.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 Under Section 7 of GPL version 3, you are granted additional
20 permissions described in the GCC Runtime Library Exception, version
21 3.1, as published by the Free Software Foundation.
23 You should have received a copy of the GNU General Public License and
24 a copy of the GCC Runtime Library Exception along with this program;
25 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
26 <http://www.gnu.org/licenses/>. */
30 #include "coretypes.h"
33 #ifdef HAVE_GAS_HIDDEN
34 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
36 #define ATTRIBUTE_HIDDEN
39 /* Work out the largest "word" size that we can deal with on this target. */
40 #if MIN_UNITS_PER_WORD > 4
41 # define LIBGCC2_MAX_UNITS_PER_WORD 8
42 #elif (MIN_UNITS_PER_WORD > 2 \
43 || (MIN_UNITS_PER_WORD > 1 && LONG_LONG_TYPE_SIZE > 32))
44 # define LIBGCC2_MAX_UNITS_PER_WORD 4
46 # define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD
49 /* Work out what word size we are using for this compilation.
50 The value can be set on the command line. */
51 #ifndef LIBGCC2_UNITS_PER_WORD
52 #define LIBGCC2_UNITS_PER_WORD LIBGCC2_MAX_UNITS_PER_WORD
55 #if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
59 #ifdef DECLARE_LIBRARY_RENAMES
60 DECLARE_LIBRARY_RENAMES
63 #if defined (L_negdi2)
67 const DWunion uu
= {.ll
= u
};
68 const DWunion w
= { {.low
= -uu
.s
.low
,
69 .high
= -uu
.s
.high
- ((UWtype
) -uu
.s
.low
> 0) } };
77 __addvSI3 (Wtype a
, Wtype b
)
79 const Wtype w
= (UWtype
) a
+ (UWtype
) b
;
81 if (b
>= 0 ? w
< a
: w
> a
)
86 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
88 __addvsi3 (SItype a
, SItype b
)
90 const SItype w
= (USItype
) a
+ (USItype
) b
;
92 if (b
>= 0 ? w
< a
: w
> a
)
97 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
102 __addvDI3 (DWtype a
, DWtype b
)
104 const DWtype w
= (UDWtype
) a
+ (UDWtype
) b
;
106 if (b
>= 0 ? w
< a
: w
> a
)
115 __subvSI3 (Wtype a
, Wtype b
)
117 const Wtype w
= (UWtype
) a
- (UWtype
) b
;
119 if (b
>= 0 ? w
> a
: w
< a
)
124 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
126 __subvsi3 (SItype a
, SItype b
)
128 const SItype w
= (USItype
) a
- (USItype
) b
;
130 if (b
>= 0 ? w
> a
: w
< a
)
135 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
140 __subvDI3 (DWtype a
, DWtype b
)
142 const DWtype w
= (UDWtype
) a
- (UDWtype
) b
;
144 if (b
>= 0 ? w
> a
: w
< a
)
153 __mulvSI3 (Wtype a
, Wtype b
)
155 const DWtype w
= (DWtype
) a
* (DWtype
) b
;
157 if ((Wtype
) (w
>> W_TYPE_SIZE
) != (Wtype
) w
>> (W_TYPE_SIZE
- 1))
162 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
164 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
166 __mulvsi3 (SItype a
, SItype b
)
168 const DItype w
= (DItype
) a
* (DItype
) b
;
170 if ((SItype
) (w
>> WORD_SIZE
) != (SItype
) w
>> (WORD_SIZE
-1))
175 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
182 const Wtype w
= -(UWtype
) a
;
184 if (a
>= 0 ? w
> 0 : w
< 0)
189 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
193 const SItype w
= -(USItype
) a
;
195 if (a
>= 0 ? w
> 0 : w
< 0)
200 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
207 const DWtype w
= -(UDWtype
) a
;
209 if (a
>= 0 ? w
> 0 : w
< 0)
234 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
252 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
277 __mulvDI3 (DWtype u
, DWtype v
)
279 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
280 but the checked multiplication needs only two. */
281 const DWunion uu
= {.ll
= u
};
282 const DWunion vv
= {.ll
= v
};
284 if (__builtin_expect (uu
.s
.high
== uu
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
286 /* u fits in a single Wtype. */
287 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
289 /* v fits in a single Wtype as well. */
290 /* A single multiplication. No overflow risk. */
291 return (DWtype
) uu
.s
.low
* (DWtype
) vv
.s
.low
;
295 /* Two multiplications. */
296 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
297 * (UDWtype
) (UWtype
) vv
.s
.low
};
298 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
299 * (UDWtype
) (UWtype
) vv
.s
.high
};
302 w1
.s
.high
-= uu
.s
.low
;
305 w1
.ll
+= (UWtype
) w0
.s
.high
;
306 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
308 w0
.s
.high
= w1
.s
.low
;
315 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
317 /* v fits into a single Wtype. */
318 /* Two multiplications. */
319 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
320 * (UDWtype
) (UWtype
) vv
.s
.low
};
321 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.high
322 * (UDWtype
) (UWtype
) vv
.s
.low
};
325 w1
.s
.high
-= vv
.s
.low
;
328 w1
.ll
+= (UWtype
) w0
.s
.high
;
329 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
331 w0
.s
.high
= w1
.s
.low
;
337 /* A few sign checks and a single multiplication. */
342 if (uu
.s
.high
== 0 && vv
.s
.high
== 0)
344 const DWtype w
= (UDWtype
) (UWtype
) uu
.s
.low
345 * (UDWtype
) (UWtype
) vv
.s
.low
;
346 if (__builtin_expect (w
>= 0, 1))
352 if (uu
.s
.high
== 0 && vv
.s
.high
== (Wtype
) -1)
354 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
355 * (UDWtype
) (UWtype
) vv
.s
.low
};
357 ww
.s
.high
-= uu
.s
.low
;
358 if (__builtin_expect (ww
.s
.high
< 0, 1))
367 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== 0)
369 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
370 * (UDWtype
) (UWtype
) vv
.s
.low
};
372 ww
.s
.high
-= vv
.s
.low
;
373 if (__builtin_expect (ww
.s
.high
< 0, 1))
379 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== (Wtype
) - 1)
381 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
382 * (UDWtype
) (UWtype
) vv
.s
.low
};
384 ww
.s
.high
-= uu
.s
.low
;
385 ww
.s
.high
-= vv
.s
.low
;
386 if (__builtin_expect (ww
.s
.high
>= 0, 1))
400 /* Unless shift functions are defined with full ANSI prototypes,
401 parameter b will be promoted to int if shift_count_type is smaller than an int. */
404 __lshrdi3 (DWtype u
, shift_count_type b
)
409 const DWunion uu
= {.ll
= u
};
410 const shift_count_type bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
416 w
.s
.low
= (UWtype
) uu
.s
.high
>> -bm
;
420 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
422 w
.s
.high
= (UWtype
) uu
.s
.high
>> b
;
423 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
432 __ashldi3 (DWtype u
, shift_count_type b
)
437 const DWunion uu
= {.ll
= u
};
438 const shift_count_type bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
444 w
.s
.high
= (UWtype
) uu
.s
.low
<< -bm
;
448 const UWtype carries
= (UWtype
) uu
.s
.low
>> bm
;
450 w
.s
.low
= (UWtype
) uu
.s
.low
<< b
;
451 w
.s
.high
= ((UWtype
) uu
.s
.high
<< b
) | carries
;
460 __ashrdi3 (DWtype u
, shift_count_type b
)
465 const DWunion uu
= {.ll
= u
};
466 const shift_count_type bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
471 /* w.s.high = 1..1 or 0..0 */
472 w
.s
.high
= uu
.s
.high
>> (sizeof (Wtype
) * BITS_PER_UNIT
- 1);
473 w
.s
.low
= uu
.s
.high
>> -bm
;
477 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
479 w
.s
.high
= uu
.s
.high
>> b
;
480 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
489 __bswapsi2 (SItype u
)
491 return ((((u
) & 0xff000000) >> 24)
492 | (((u
) & 0x00ff0000) >> 8)
493 | (((u
) & 0x0000ff00) << 8)
494 | (((u
) & 0x000000ff) << 24));
499 __bswapdi2 (DItype u
)
501 return ((((u
) & 0xff00000000000000ull
) >> 56)
502 | (((u
) & 0x00ff000000000000ull
) >> 40)
503 | (((u
) & 0x0000ff0000000000ull
) >> 24)
504 | (((u
) & 0x000000ff00000000ull
) >> 8)
505 | (((u
) & 0x00000000ff000000ull
) << 8)
506 | (((u
) & 0x0000000000ff0000ull
) << 24)
507 | (((u
) & 0x000000000000ff00ull
) << 40)
508 | (((u
) & 0x00000000000000ffull
) << 56));
521 count_trailing_zeros (count
, u
);
531 const DWunion uu
= {.ll
= u
};
532 UWtype word
, count
, add
;
535 word
= uu
.s
.low
, add
= 0;
536 else if (uu
.s
.high
!= 0)
537 word
= uu
.s
.high
, add
= BITS_PER_UNIT
* sizeof (Wtype
);
541 count_trailing_zeros (count
, word
);
542 return count
+ add
+ 1;
548 __muldi3 (DWtype u
, DWtype v
)
550 const DWunion uu
= {.ll
= u
};
551 const DWunion vv
= {.ll
= v
};
552 DWunion w
= {.ll
= __umulsidi3 (uu
.s
.low
, vv
.s
.low
)};
554 w
.s
.high
+= ((UWtype
) uu
.s
.low
* (UWtype
) vv
.s
.high
555 + (UWtype
) uu
.s
.high
* (UWtype
) vv
.s
.low
);
561 #if (defined (L_udivdi3) || defined (L_divdi3) || \
562 defined (L_umoddi3) || defined (L_moddi3))
563 #if defined (sdiv_qrnnd)
564 #define L_udiv_w_sdiv
569 #if defined (sdiv_qrnnd)
570 #if (defined (L_udivdi3) || defined (L_divdi3) || \
571 defined (L_umoddi3) || defined (L_moddi3))
572 static inline __attribute__ ((__always_inline__
))
575 __udiv_w_sdiv (UWtype
*rp
, UWtype a1
, UWtype a0
, UWtype d
)
582 if (a1
< d
- a1
- (a0
>> (W_TYPE_SIZE
- 1)))
584 /* Dividend, divisor, and quotient are nonnegative. */
585 sdiv_qrnnd (q
, r
, a1
, a0
, d
);
589 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
590 sub_ddmmss (c1
, c0
, a1
, a0
, d
>> 1, d
<< (W_TYPE_SIZE
- 1));
591 /* Divide (c1*2^32 + c0) by d. */
592 sdiv_qrnnd (q
, r
, c1
, c0
, d
);
593 /* Add 2^31 to quotient. */
594 q
+= (UWtype
) 1 << (W_TYPE_SIZE
- 1);
599 b1
= d
>> 1; /* d/2, between 2^30 and 2^31 - 1 */
600 c1
= a1
>> 1; /* A/2 */
601 c0
= (a1
<< (W_TYPE_SIZE
- 1)) + (a0
>> 1);
603 if (a1
< b1
) /* A < 2^32*b1, so A/2 < 2^31*b1 */
605 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
607 r
= 2*r
+ (a0
& 1); /* Remainder from A/(2*b1) */
624 else if (c1
< b1
) /* So 2^31 <= (A/2)/b1 < 2^32 */
627 c0
= ~c0
; /* logical NOT */
629 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
631 q
= ~q
; /* (A/2)/b1 */
634 r
= 2*r
+ (a0
& 1); /* A/(2*b1) */
652 else /* Implies c1 = b1 */
653 { /* Hence a1 = d - 1 = 2*b1 - 1 */
671 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
673 __udiv_w_sdiv (UWtype
*rp
__attribute__ ((__unused__
)),
674 UWtype a1
__attribute__ ((__unused__
)),
675 UWtype a0
__attribute__ ((__unused__
)),
676 UWtype d
__attribute__ ((__unused__
)))
683 #if (defined (L_udivdi3) || defined (L_divdi3) || \
684 defined (L_umoddi3) || defined (L_moddi3))
689 const UQItype __clz_tab
[256] =
691 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,
692 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,
693 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,
694 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,
695 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,
696 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,
697 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,
698 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
709 count_leading_zeros (ret
, x
);
720 const DWunion uu
= {.ll
= x
};
725 word
= uu
.s
.high
, add
= 0;
727 word
= uu
.s
.low
, add
= W_TYPE_SIZE
;
729 count_leading_zeros (ret
, word
);
741 count_trailing_zeros (ret
, x
);
752 const DWunion uu
= {.ll
= x
};
757 word
= uu
.s
.low
, add
= 0;
759 word
= uu
.s
.high
, add
= W_TYPE_SIZE
;
761 count_trailing_zeros (ret
, word
);
766 #ifdef L_popcount_tab
767 const UQItype __popcount_tab
[256] =
769 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
770 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
771 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
772 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
773 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
774 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
775 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
776 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
783 __popcountSI2 (UWtype x
)
787 for (i
= 0; i
< W_TYPE_SIZE
; i
+= 8)
788 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
797 __popcountDI2 (UDWtype x
)
801 for (i
= 0; i
< 2*W_TYPE_SIZE
; i
+= 8)
802 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
811 __paritySI2 (UWtype x
)
814 # error "fill out the table"
825 return (0x6996 >> x
) & 1;
832 __parityDI2 (UDWtype x
)
834 const DWunion uu
= {.ll
= x
};
835 UWtype nx
= uu
.s
.low
^ uu
.s
.high
;
838 # error "fill out the table"
849 return (0x6996 >> nx
) & 1;
855 #if (defined (L_udivdi3) || defined (L_divdi3) || \
856 defined (L_umoddi3) || defined (L_moddi3))
857 static inline __attribute__ ((__always_inline__
))
860 __udivmoddi4 (UDWtype n
, UDWtype d
, UDWtype
*rp
)
862 const DWunion nn
= {.ll
= n
};
863 const DWunion dd
= {.ll
= d
};
865 UWtype d0
, d1
, n0
, n1
, n2
;
874 #if !UDIV_NEEDS_NORMALIZATION
881 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
884 /* Remainder in n0. */
891 d0
= 1 / d0
; /* Divide intentionally by zero. */
893 udiv_qrnnd (q1
, n1
, 0, n1
, d0
);
894 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
896 /* Remainder in n0. */
907 #else /* UDIV_NEEDS_NORMALIZATION */
915 count_leading_zeros (bm
, d0
);
919 /* Normalize, i.e. make the most significant bit of the
923 n1
= (n1
<< bm
) | (n0
>> (W_TYPE_SIZE
- bm
));
927 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
930 /* Remainder in n0 >> bm. */
937 d0
= 1 / d0
; /* Divide intentionally by zero. */
939 count_leading_zeros (bm
, d0
);
943 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
944 conclude (the most significant bit of n1 is set) /\ (the
945 leading quotient digit q1 = 1).
947 This special case is necessary, not an optimization.
948 (Shifts counts of W_TYPE_SIZE are undefined.) */
957 b
= W_TYPE_SIZE
- bm
;
961 n1
= (n1
<< bm
) | (n0
>> b
);
964 udiv_qrnnd (q1
, n1
, n2
, n1
, d0
);
969 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
971 /* Remainder in n0 >> bm. */
981 #endif /* UDIV_NEEDS_NORMALIZATION */
992 /* Remainder in n1n0. */
1004 count_leading_zeros (bm
, d1
);
1007 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
1008 conclude (the most significant bit of n1 is set) /\ (the
1009 quotient digit q0 = 0 or 1).
1011 This special case is necessary, not an optimization. */
1013 /* The condition on the next line takes advantage of that
1014 n1 >= d1 (true due to program flow). */
1015 if (n1
> d1
|| n0
>= d0
)
1018 sub_ddmmss (n1
, n0
, n1
, n0
, d1
, d0
);
1037 b
= W_TYPE_SIZE
- bm
;
1039 d1
= (d1
<< bm
) | (d0
>> b
);
1042 n1
= (n1
<< bm
) | (n0
>> b
);
1045 udiv_qrnnd (q0
, n1
, n2
, n1
, d1
);
1046 umul_ppmm (m1
, m0
, q0
, d0
);
1048 if (m1
> n1
|| (m1
== n1
&& m0
> n0
))
1051 sub_ddmmss (m1
, m0
, m1
, m0
, d1
, d0
);
1056 /* Remainder in (n1n0 - m1m0) >> bm. */
1059 sub_ddmmss (n1
, n0
, n1
, n0
, m1
, m0
);
1060 rr
.s
.low
= (n1
<< b
) | (n0
>> bm
);
1061 rr
.s
.high
= n1
>> bm
;
1068 const DWunion ww
= {{.low
= q0
, .high
= q1
}};
1075 __divdi3 (DWtype u
, DWtype v
)
1078 DWunion uu
= {.ll
= u
};
1079 DWunion vv
= {.ll
= v
};
1089 w
= __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*) 0);
1099 __moddi3 (DWtype u
, DWtype v
)
1102 DWunion uu
= {.ll
= u
};
1103 DWunion vv
= {.ll
= v
};
1112 (void) __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*)&w
);
1122 __umoddi3 (UDWtype u
, UDWtype v
)
1126 (void) __udivmoddi4 (u
, v
, &w
);
1134 __udivdi3 (UDWtype n
, UDWtype d
)
1136 return __udivmoddi4 (n
, d
, (UDWtype
*) 0);
1142 __cmpdi2 (DWtype a
, DWtype b
)
1144 const DWunion au
= {.ll
= a
};
1145 const DWunion bu
= {.ll
= b
};
1147 if (au
.s
.high
< bu
.s
.high
)
1149 else if (au
.s
.high
> bu
.s
.high
)
1151 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
1153 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
1161 __ucmpdi2 (DWtype a
, DWtype b
)
1163 const DWunion au
= {.ll
= a
};
1164 const DWunion bu
= {.ll
= b
};
1166 if ((UWtype
) au
.s
.high
< (UWtype
) bu
.s
.high
)
1168 else if ((UWtype
) au
.s
.high
> (UWtype
) bu
.s
.high
)
1170 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
1172 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
1178 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1180 __fixunstfDI (TFtype a
)
1185 /* Compute high word of result, as a flonum. */
1186 const TFtype b
= (a
/ Wtype_MAXp1_F
);
1187 /* Convert that to fixed (but not to DWtype!),
1188 and shift it into the high word. */
1189 UDWtype v
= (UWtype
) b
;
1191 /* Remove high part from the TFtype, leaving the low part as flonum. */
1193 /* Convert that to fixed (but not to DWtype!) and add it in.
1194 Sometimes A comes out negative. This is significant, since
1195 A has more bits than a long int does. */
1197 v
-= (UWtype
) (- a
);
1204 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1206 __fixtfdi (TFtype a
)
1209 return - __fixunstfDI (-a
);
1210 return __fixunstfDI (a
);
1214 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1216 __fixunsxfDI (XFtype a
)
1221 /* Compute high word of result, as a flonum. */
1222 const XFtype b
= (a
/ Wtype_MAXp1_F
);
1223 /* Convert that to fixed (but not to DWtype!),
1224 and shift it into the high word. */
1225 UDWtype v
= (UWtype
) b
;
1227 /* Remove high part from the XFtype, leaving the low part as flonum. */
1229 /* Convert that to fixed (but not to DWtype!) and add it in.
1230 Sometimes A comes out negative. This is significant, since
1231 A has more bits than a long int does. */
1233 v
-= (UWtype
) (- a
);
1240 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1242 __fixxfdi (XFtype a
)
1245 return - __fixunsxfDI (-a
);
1246 return __fixunsxfDI (a
);
1250 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1252 __fixunsdfDI (DFtype a
)
1254 /* Get high part of result. The division here will just moves the radix
1255 point and will not cause any rounding. Then the conversion to integral
1256 type chops result as desired. */
1257 const UWtype hi
= a
/ Wtype_MAXp1_F
;
1259 /* Get low part of result. Convert `hi' to floating type and scale it back,
1260 then subtract this from the number being converted. This leaves the low
1261 part. Convert that to integral type. */
1262 const UWtype lo
= a
- (DFtype
) hi
* Wtype_MAXp1_F
;
1264 /* Assemble result from the two parts. */
1265 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
1269 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1271 __fixdfdi (DFtype a
)
1274 return - __fixunsdfDI (-a
);
1275 return __fixunsdfDI (a
);
1279 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1281 __fixunssfDI (SFtype a
)
1283 #if LIBGCC2_HAS_DF_MODE
1284 /* Convert the SFtype to a DFtype, because that is surely not going
1285 to lose any bits. Some day someone else can write a faster version
1286 that avoids converting to DFtype, and verify it really works right. */
1287 const DFtype dfa
= a
;
1289 /* Get high part of result. The division here will just moves the radix
1290 point and will not cause any rounding. Then the conversion to integral
1291 type chops result as desired. */
1292 const UWtype hi
= dfa
/ Wtype_MAXp1_F
;
1294 /* Get low part of result. Convert `hi' to floating type and scale it back,
1295 then subtract this from the number being converted. This leaves the low
1296 part. Convert that to integral type. */
1297 const UWtype lo
= dfa
- (DFtype
) hi
* Wtype_MAXp1_F
;
1299 /* Assemble result from the two parts. */
1300 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
1301 #elif FLT_MANT_DIG < W_TYPE_SIZE
1304 if (a
< Wtype_MAXp1_F
)
1306 if (a
< Wtype_MAXp1_F
* Wtype_MAXp1_F
)
1308 /* Since we know that there are fewer significant bits in the SFmode
1309 quantity than in a word, we know that we can convert out all the
1310 significant bits in one step, and thus avoid losing bits. */
1312 /* ??? This following loop essentially performs frexpf. If we could
1313 use the real libm function, or poke at the actual bits of the fp
1314 format, it would be significantly faster. */
1316 UWtype shift
= 0, counter
;
1320 for (counter
= W_TYPE_SIZE
/ 2; counter
!= 0; counter
>>= 1)
1322 SFtype counterf
= (UWtype
)1 << counter
;
1330 /* Rescale into the range of one word, extract the bits of that
1331 one word, and shift the result into position. */
1334 return (DWtype
)counter
<< shift
;
1343 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1345 __fixsfdi (SFtype a
)
1348 return - __fixunssfDI (-a
);
1349 return __fixunssfDI (a
);
1353 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1355 __floatdixf (DWtype u
)
1357 #if W_TYPE_SIZE > XF_SIZE
1360 XFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1367 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
1369 __floatundixf (UDWtype u
)
1371 #if W_TYPE_SIZE > XF_SIZE
1374 XFtype d
= (UWtype
) (u
>> W_TYPE_SIZE
);
1381 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1383 __floatditf (DWtype u
)
1385 #if W_TYPE_SIZE > TF_SIZE
1388 TFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1395 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
1397 __floatunditf (UDWtype u
)
1399 #if W_TYPE_SIZE > TF_SIZE
1402 TFtype d
= (UWtype
) (u
>> W_TYPE_SIZE
);
1409 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
1410 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
1411 #define DI_SIZE (W_TYPE_SIZE * 2)
1412 #define F_MODE_OK(SIZE) \
1414 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1415 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1416 #if defined(L_floatdisf)
1417 #define FUNC __floatdisf
1418 #define FSTYPE SFtype
1419 #define FSSIZE SF_SIZE
1421 #define FUNC __floatdidf
1422 #define FSTYPE DFtype
1423 #define FSSIZE DF_SIZE
1429 #if FSSIZE >= W_TYPE_SIZE
1430 /* When the word size is small, we never get any rounding error. */
1431 FSTYPE f
= (Wtype
) (u
>> W_TYPE_SIZE
);
1435 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
1436 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
1437 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1439 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
1440 # define FSIZE DF_SIZE
1441 # define FTYPE DFtype
1442 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
1443 # define FSIZE XF_SIZE
1444 # define FTYPE XFtype
1445 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1446 # define FSIZE TF_SIZE
1447 # define FTYPE TFtype
1452 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1454 /* Protect against double-rounding error.
1455 Represent any low-order bits, that might be truncated by a bit that
1456 won't be lost. The bit can go in anywhere below the rounding position
1457 of the FSTYPE. A fixed mask and bit position handles all usual
1459 if (! (- ((DWtype
) 1 << FSIZE
) < u
1460 && u
< ((DWtype
) 1 << FSIZE
)))
1462 if ((UDWtype
) u
& (REP_BIT
- 1))
1464 u
&= ~ (REP_BIT
- 1);
1469 /* Do the calculation in a wider type so that we don't lose any of
1470 the precision of the high word while multiplying it. */
1471 FTYPE f
= (Wtype
) (u
>> W_TYPE_SIZE
);
1476 #if FSSIZE >= W_TYPE_SIZE - 2
1479 /* Finally, the word size is larger than the number of bits in the
1480 required FSTYPE, and we've got no suitable wider type. The only
1481 way to avoid double rounding is to special case the
1484 /* If there are no high bits set, fall back to one conversion. */
1486 return (FSTYPE
)(Wtype
)u
;
1488 /* Otherwise, find the power of two. */
1489 Wtype hi
= u
>> W_TYPE_SIZE
;
1493 UWtype count
, shift
;
1494 count_leading_zeros (count
, hi
);
1496 /* No leading bits means u == minimum. */
1498 return -(Wtype_MAXp1_F
* (Wtype_MAXp1_F
/ 2));
1500 shift
= 1 + W_TYPE_SIZE
- count
;
1502 /* Shift down the most significant bits. */
1505 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1506 if ((UWtype
)u
<< (W_TYPE_SIZE
- shift
))
1509 /* Convert the one word of data, and rescale. */
1511 if (shift
== W_TYPE_SIZE
)
1513 /* The following two cases could be merged if we knew that the target
1514 supported a native unsigned->float conversion. More often, we only
1515 have a signed conversion, and have to add extra fixup code. */
1516 else if (shift
== W_TYPE_SIZE
- 1)
1517 e
= Wtype_MAXp1_F
/ 2;
1519 e
= (Wtype
)1 << shift
;
1525 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
1526 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
1527 #define DI_SIZE (W_TYPE_SIZE * 2)
1528 #define F_MODE_OK(SIZE) \
1530 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1531 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1532 #if defined(L_floatundisf)
1533 #define FUNC __floatundisf
1534 #define FSTYPE SFtype
1535 #define FSSIZE SF_SIZE
1537 #define FUNC __floatundidf
1538 #define FSTYPE DFtype
1539 #define FSSIZE DF_SIZE
1545 #if FSSIZE >= W_TYPE_SIZE
1546 /* When the word size is small, we never get any rounding error. */
1547 FSTYPE f
= (UWtype
) (u
>> W_TYPE_SIZE
);
1551 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
1552 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
1553 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1555 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
1556 # define FSIZE DF_SIZE
1557 # define FTYPE DFtype
1558 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
1559 # define FSIZE XF_SIZE
1560 # define FTYPE XFtype
1561 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1562 # define FSIZE TF_SIZE
1563 # define FTYPE TFtype
1568 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1570 /* Protect against double-rounding error.
1571 Represent any low-order bits, that might be truncated by a bit that
1572 won't be lost. The bit can go in anywhere below the rounding position
1573 of the FSTYPE. A fixed mask and bit position handles all usual
1575 if (u
>= ((UDWtype
) 1 << FSIZE
))
1577 if ((UDWtype
) u
& (REP_BIT
- 1))
1579 u
&= ~ (REP_BIT
- 1);
1584 /* Do the calculation in a wider type so that we don't lose any of
1585 the precision of the high word while multiplying it. */
1586 FTYPE f
= (UWtype
) (u
>> W_TYPE_SIZE
);
1591 #if FSSIZE == W_TYPE_SIZE - 1
1594 /* Finally, the word size is larger than the number of bits in the
1595 required FSTYPE, and we've got no suitable wider type. The only
1596 way to avoid double rounding is to special case the
1599 /* If there are no high bits set, fall back to one conversion. */
1601 return (FSTYPE
)(UWtype
)u
;
1603 /* Otherwise, find the power of two. */
1604 UWtype hi
= u
>> W_TYPE_SIZE
;
1606 UWtype count
, shift
;
1607 count_leading_zeros (count
, hi
);
1609 shift
= W_TYPE_SIZE
- count
;
1611 /* Shift down the most significant bits. */
1614 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1615 if ((UWtype
)u
<< (W_TYPE_SIZE
- shift
))
1618 /* Convert the one word of data, and rescale. */
1620 if (shift
== W_TYPE_SIZE
)
1622 /* The following two cases could be merged if we knew that the target
1623 supported a native unsigned->float conversion. More often, we only
1624 have a signed conversion, and have to add extra fixup code. */
1625 else if (shift
== W_TYPE_SIZE
- 1)
1626 e
= Wtype_MAXp1_F
/ 2;
1628 e
= (Wtype
)1 << shift
;
1634 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1635 /* Reenable the normal types, in case limits.h needs them. */
1648 __fixunsxfSI (XFtype a
)
1650 if (a
>= - (DFtype
) Wtype_MIN
)
1651 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1656 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1657 /* Reenable the normal types, in case limits.h needs them. */
1670 __fixunsdfSI (DFtype a
)
1672 if (a
>= - (DFtype
) Wtype_MIN
)
1673 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1678 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1679 /* Reenable the normal types, in case limits.h needs them. */
1692 __fixunssfSI (SFtype a
)
1694 if (a
>= - (SFtype
) Wtype_MIN
)
1695 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1700 /* Integer power helper used from __builtin_powi for non-constant
1703 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1704 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1705 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1706 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1707 # if defined(L_powisf2)
1708 # define TYPE SFtype
1709 # define NAME __powisf2
1710 # elif defined(L_powidf2)
1711 # define TYPE DFtype
1712 # define NAME __powidf2
1713 # elif defined(L_powixf2)
1714 # define TYPE XFtype
1715 # define NAME __powixf2
1716 # elif defined(L_powitf2)
1717 # define TYPE TFtype
1718 # define NAME __powitf2
1724 NAME (TYPE x
, int m
)
1726 unsigned int n
= m
< 0 ? -m
: m
;
1727 TYPE y
= n
% 2 ? x
: 1;
1734 return m
< 0 ? 1/y
: y
;
1739 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1740 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1741 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1742 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1748 #if defined(L_mulsc3) || defined(L_divsc3)
1749 # define MTYPE SFtype
1750 # define CTYPE SCtype
1753 # define NOTRUNC __FLT_EVAL_METHOD__ == 0
1754 #elif defined(L_muldc3) || defined(L_divdc3)
1755 # define MTYPE DFtype
1756 # define CTYPE DCtype
1758 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1763 # define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1
1765 #elif defined(L_mulxc3) || defined(L_divxc3)
1766 # define MTYPE XFtype
1767 # define CTYPE XCtype
1771 #elif defined(L_multc3) || defined(L_divtc3)
1772 # define MTYPE TFtype
1773 # define CTYPE TCtype
1775 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
1778 # define CEXT LIBGCC2_TF_CEXT
1785 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
1786 #define _CONCAT3(A,B,C) A##B##C
1788 #define CONCAT2(A,B) _CONCAT2(A,B)
1789 #define _CONCAT2(A,B) A##B
1791 /* All of these would be present in a full C99 implementation of <math.h>
1792 and <complex.h>. Our problem is that only a few systems have such full
1793 implementations. Further, libgcc_s.so isn't currently linked against
1794 libm.so, and even for systems that do provide full C99, the extra overhead
1795 of all programs using libgcc having to link against libm. So avoid it. */
1797 #define isnan(x) __builtin_expect ((x) != (x), 0)
1798 #define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
1799 #define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
1801 #define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
1804 /* Helpers to make the following code slightly less gross. */
1805 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
1806 #define FABS CONCAT2(__builtin_fabs, CEXT)
1808 /* Verify that MTYPE matches up with CEXT. */
1809 extern void *compile_type_assert
[sizeof(INFINITY
) == sizeof(MTYPE
) ? 1 : -1];
1811 /* Ensure that we've lost any extra precision. */
1815 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
1818 #if defined(L_mulsc3) || defined(L_muldc3) \
1819 || defined(L_mulxc3) || defined(L_multc3)
1822 CONCAT3(__mul
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
1824 MTYPE ac
, bd
, ad
, bc
, x
, y
;
1840 if (isnan (x
) && isnan (y
))
1842 /* Recover infinities that computed as NaN + iNaN. */
1844 if (isinf (a
) || isinf (b
))
1846 /* z is infinite. "Box" the infinity and change NaNs in
1847 the other factor to 0. */
1848 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
1849 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
1850 if (isnan (c
)) c
= COPYSIGN (0, c
);
1851 if (isnan (d
)) d
= COPYSIGN (0, d
);
1854 if (isinf (c
) || isinf (d
))
1856 /* w is infinite. "Box" the infinity and change NaNs in
1857 the other factor to 0. */
1858 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
1859 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
1860 if (isnan (a
)) a
= COPYSIGN (0, a
);
1861 if (isnan (b
)) b
= COPYSIGN (0, b
);
1865 && (isinf (ac
) || isinf (bd
)
1866 || isinf (ad
) || isinf (bc
)))
1868 /* Recover infinities from overflow by changing NaNs to 0. */
1869 if (isnan (a
)) a
= COPYSIGN (0, a
);
1870 if (isnan (b
)) b
= COPYSIGN (0, b
);
1871 if (isnan (c
)) c
= COPYSIGN (0, c
);
1872 if (isnan (d
)) d
= COPYSIGN (0, d
);
1877 x
= INFINITY
* (a
* c
- b
* d
);
1878 y
= INFINITY
* (a
* d
+ b
* c
);
1886 #endif /* complex multiply */
1888 #if defined(L_divsc3) || defined(L_divdc3) \
1889 || defined(L_divxc3) || defined(L_divtc3)
1892 CONCAT3(__div
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
1894 MTYPE denom
, ratio
, x
, y
;
1897 /* ??? We can get better behavior from logarithmic scaling instead of
1898 the division. But that would mean starting to link libgcc against
1899 libm. We could implement something akin to ldexp/frexp as gcc builtins
1901 if (FABS (c
) < FABS (d
))
1904 denom
= (c
* ratio
) + d
;
1905 x
= ((a
* ratio
) + b
) / denom
;
1906 y
= ((b
* ratio
) - a
) / denom
;
1911 denom
= (d
* ratio
) + c
;
1912 x
= ((b
* ratio
) + a
) / denom
;
1913 y
= (b
- (a
* ratio
)) / denom
;
1916 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
1917 are nonzero/zero, infinite/finite, and finite/infinite. */
1918 if (isnan (x
) && isnan (y
))
1920 if (c
== 0.0 && d
== 0.0 && (!isnan (a
) || !isnan (b
)))
1922 x
= COPYSIGN (INFINITY
, c
) * a
;
1923 y
= COPYSIGN (INFINITY
, c
) * b
;
1925 else if ((isinf (a
) || isinf (b
)) && isfinite (c
) && isfinite (d
))
1927 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
1928 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
1929 x
= INFINITY
* (a
* c
+ b
* d
);
1930 y
= INFINITY
* (b
* c
- a
* d
);
1932 else if ((isinf (c
) || isinf (d
)) && isfinite (a
) && isfinite (b
))
1934 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
1935 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
1936 x
= 0.0 * (a
* c
+ b
* d
);
1937 y
= 0.0 * (b
* c
- a
* d
);
1945 #endif /* complex divide */
1947 #endif /* all complex float routines */
1949 /* From here on down, the routines use normal data types. */
1951 #define SItype bogus_type
1952 #define USItype bogus_type
1953 #define DItype bogus_type
1954 #define UDItype bogus_type
1955 #define SFtype bogus_type
1956 #define DFtype bogus_type
1974 /* Like bcmp except the sign is meaningful.
1975 Result is negative if S1 is less than S2,
1976 positive if S1 is greater, 0 if S1 and S2 are equal. */
1979 __gcc_bcmp (const unsigned char *s1
, const unsigned char *s2
, size_t size
)
1983 const unsigned char c1
= *s1
++, c2
= *s2
++;
1993 /* __eprintf used to be used by GCC's private version of <assert.h>.
1994 We no longer provide that header, but this routine remains in libgcc.a
1995 for binary backward compatibility. Note that it is not included in
1996 the shared version of libgcc. */
1998 #ifndef inhibit_libc
2000 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2004 __eprintf (const char *string
, const char *expression
,
2005 unsigned int line
, const char *filename
)
2007 fprintf (stderr
, string
, expression
, line
, filename
);
2016 #ifdef L_clear_cache
2017 /* Clear part of an instruction cache. */
2020 __clear_cache (char *beg
__attribute__((__unused__
)),
2021 char *end
__attribute__((__unused__
)))
2023 #ifdef CLEAR_INSN_CACHE
2024 CLEAR_INSN_CACHE (beg
, end
);
2025 #endif /* CLEAR_INSN_CACHE */
2028 #endif /* L_clear_cache */
2030 #ifdef L_enable_execute_stack
2031 /* Attempt to turn on execute permission for the stack. */
2033 #ifdef ENABLE_EXECUTE_STACK
2034 ENABLE_EXECUTE_STACK
2037 __enable_execute_stack (void *addr
__attribute__((__unused__
)))
2039 #endif /* ENABLE_EXECUTE_STACK */
2041 #endif /* L_enable_execute_stack */
2045 /* Jump to a trampoline, loading the static chain address. */
2047 #if defined(WINNT) && ! defined(__CYGWIN__)
2048 int getpagesize (void);
2049 int mprotect (char *,int, int);
2062 mprotect (char *addr
, int len
, int prot
)
2081 if (VirtualProtect (addr
, len
, np
, &op
))
2087 #endif /* WINNT && ! __CYGWIN__ */
2089 #ifdef TRANSFER_FROM_TRAMPOLINE
2090 TRANSFER_FROM_TRAMPOLINE
2092 #endif /* L_trampoline */
2097 #include "gbl-ctors.h"
2099 /* Some systems use __main in a way incompatible with its use in gcc, in these
2100 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2101 give the same symbol without quotes for an alternative entry point. You
2102 must define both, or neither. */
2104 #define NAME__MAIN "__main"
2105 #define SYMBOL__MAIN __main
2108 #if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP)
2109 #undef HAS_INIT_SECTION
2110 #define HAS_INIT_SECTION
2113 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2115 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2116 code to run constructors. In that case, we need to handle EH here, too. */
2118 #ifdef EH_FRAME_SECTION_NAME
2119 #include "unwind-dw2-fde.h"
2120 extern unsigned char __EH_FRAME_BEGIN__
[];
2123 /* Run all the global destructors on exit from the program. */
2126 __do_global_dtors (void)
2128 #ifdef DO_GLOBAL_DTORS_BODY
2129 DO_GLOBAL_DTORS_BODY
;
2131 static func_ptr
*p
= __DTOR_LIST__
+ 1;
2138 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
2140 static int completed
= 0;
2144 __deregister_frame_info (__EH_FRAME_BEGIN__
);
2151 #ifndef HAS_INIT_SECTION
2152 /* Run all the global constructors on entry to the program. */
2155 __do_global_ctors (void)
2157 #ifdef EH_FRAME_SECTION_NAME
2159 static struct object object
;
2160 __register_frame_info (__EH_FRAME_BEGIN__
, &object
);
2163 DO_GLOBAL_CTORS_BODY
;
2164 atexit (__do_global_dtors
);
2166 #endif /* no HAS_INIT_SECTION */
2168 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2169 /* Subroutine called automatically by `main'.
2170 Compiling a global function named `main'
2171 produces an automatic call to this function at the beginning.
2173 For many systems, this routine calls __do_global_ctors.
2174 For systems which support a .init section we use the .init section
2175 to run __do_global_ctors, so we need not do anything here. */
2177 extern void SYMBOL__MAIN (void);
2181 /* Support recursive calls to `main': run initializers just once. */
2182 static int initialized
;
2186 __do_global_ctors ();
2189 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2191 #endif /* L__main */
2192 #endif /* __CYGWIN__ */
2196 #include "gbl-ctors.h"
2198 /* Provide default definitions for the lists of constructors and
2199 destructors, so that we don't get linker errors. These symbols are
2200 intentionally bss symbols, so that gld and/or collect will provide
2201 the right values. */
2203 /* We declare the lists here with two elements each,
2204 so that they are valid empty lists if no other definition is loaded.
2206 If we are using the old "set" extensions to have the gnu linker
2207 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2208 must be in the bss/common section.
2210 Long term no port should use those extensions. But many still do. */
2211 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2212 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2213 func_ptr __CTOR_LIST__
[2] = {0, 0};
2214 func_ptr __DTOR_LIST__
[2] = {0, 0};
2216 func_ptr __CTOR_LIST__
[2];
2217 func_ptr __DTOR_LIST__
[2];
2219 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2220 #endif /* L_ctors */
2221 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */