1 /* More subroutines needed by GCC output code on some machines. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2013 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
28 #include "coretypes.h"
30 #include "libgcc_tm.h"
32 #ifdef HAVE_GAS_HIDDEN
33 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
35 #define ATTRIBUTE_HIDDEN
38 /* Work out the largest "word" size that we can deal with on this target. */
39 #if MIN_UNITS_PER_WORD > 4
40 # define LIBGCC2_MAX_UNITS_PER_WORD 8
41 #elif (MIN_UNITS_PER_WORD > 2 \
42 || (MIN_UNITS_PER_WORD > 1 && __SIZEOF_LONG_LONG__ > 4))
43 # define LIBGCC2_MAX_UNITS_PER_WORD 4
45 # define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD
48 /* Work out what word size we are using for this compilation.
49 The value can be set on the command line. */
50 #ifndef LIBGCC2_UNITS_PER_WORD
51 #define LIBGCC2_UNITS_PER_WORD LIBGCC2_MAX_UNITS_PER_WORD
54 #if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
58 #ifdef DECLARE_LIBRARY_RENAMES
59 DECLARE_LIBRARY_RENAMES
62 #if defined (L_negdi2)
66 const DWunion uu
= {.ll
= u
};
67 const DWunion w
= { {.low
= -uu
.s
.low
,
68 .high
= -uu
.s
.high
- ((UWtype
) -uu
.s
.low
> 0) } };
76 __addvSI3 (Wtype a
, Wtype b
)
78 const Wtype w
= (UWtype
) a
+ (UWtype
) b
;
80 if (b
>= 0 ? w
< a
: w
> a
)
85 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
87 __addvsi3 (SItype a
, SItype b
)
89 const SItype w
= (USItype
) a
+ (USItype
) b
;
91 if (b
>= 0 ? w
< a
: w
> a
)
96 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
101 __addvDI3 (DWtype a
, DWtype b
)
103 const DWtype w
= (UDWtype
) a
+ (UDWtype
) b
;
105 if (b
>= 0 ? w
< a
: w
> a
)
114 __subvSI3 (Wtype a
, Wtype b
)
116 const Wtype w
= (UWtype
) a
- (UWtype
) b
;
118 if (b
>= 0 ? w
> a
: w
< a
)
123 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
125 __subvsi3 (SItype a
, SItype b
)
127 const SItype w
= (USItype
) a
- (USItype
) b
;
129 if (b
>= 0 ? w
> a
: w
< a
)
134 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
139 __subvDI3 (DWtype a
, DWtype b
)
141 const DWtype w
= (UDWtype
) a
- (UDWtype
) b
;
143 if (b
>= 0 ? w
> a
: w
< a
)
152 __mulvSI3 (Wtype a
, Wtype b
)
154 const DWtype w
= (DWtype
) a
* (DWtype
) b
;
156 if ((Wtype
) (w
>> W_TYPE_SIZE
) != (Wtype
) w
>> (W_TYPE_SIZE
- 1))
161 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
163 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
165 __mulvsi3 (SItype a
, SItype b
)
167 const DItype w
= (DItype
) a
* (DItype
) b
;
169 if ((SItype
) (w
>> WORD_SIZE
) != (SItype
) w
>> (WORD_SIZE
-1))
174 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
181 const Wtype w
= -(UWtype
) a
;
183 if (a
>= 0 ? w
> 0 : w
< 0)
188 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
192 const SItype w
= -(USItype
) a
;
194 if (a
>= 0 ? w
> 0 : w
< 0)
199 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
206 const DWtype w
= -(UDWtype
) a
;
208 if (a
>= 0 ? w
> 0 : w
< 0)
233 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
251 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
276 __mulvDI3 (DWtype u
, DWtype v
)
278 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
279 but the checked multiplication needs only two. */
280 const DWunion uu
= {.ll
= u
};
281 const DWunion vv
= {.ll
= v
};
283 if (__builtin_expect (uu
.s
.high
== uu
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
285 /* u fits in a single Wtype. */
286 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
288 /* v fits in a single Wtype as well. */
289 /* A single multiplication. No overflow risk. */
290 return (DWtype
) uu
.s
.low
* (DWtype
) vv
.s
.low
;
294 /* Two multiplications. */
295 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
296 * (UDWtype
) (UWtype
) vv
.s
.low
};
297 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
298 * (UDWtype
) (UWtype
) vv
.s
.high
};
301 w1
.s
.high
-= uu
.s
.low
;
304 w1
.ll
+= (UWtype
) w0
.s
.high
;
305 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
307 w0
.s
.high
= w1
.s
.low
;
314 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
316 /* v fits into a single Wtype. */
317 /* Two multiplications. */
318 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
319 * (UDWtype
) (UWtype
) vv
.s
.low
};
320 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.high
321 * (UDWtype
) (UWtype
) vv
.s
.low
};
324 w1
.s
.high
-= vv
.s
.low
;
327 w1
.ll
+= (UWtype
) w0
.s
.high
;
328 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
330 w0
.s
.high
= w1
.s
.low
;
336 /* A few sign checks and a single multiplication. */
341 if (uu
.s
.high
== 0 && vv
.s
.high
== 0)
343 const DWtype w
= (UDWtype
) (UWtype
) uu
.s
.low
344 * (UDWtype
) (UWtype
) vv
.s
.low
;
345 if (__builtin_expect (w
>= 0, 1))
351 if (uu
.s
.high
== 0 && vv
.s
.high
== (Wtype
) -1)
353 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
354 * (UDWtype
) (UWtype
) vv
.s
.low
};
356 ww
.s
.high
-= uu
.s
.low
;
357 if (__builtin_expect (ww
.s
.high
< 0, 1))
366 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== 0)
368 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
369 * (UDWtype
) (UWtype
) vv
.s
.low
};
371 ww
.s
.high
-= vv
.s
.low
;
372 if (__builtin_expect (ww
.s
.high
< 0, 1))
378 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== (Wtype
) - 1)
380 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
381 * (UDWtype
) (UWtype
) vv
.s
.low
};
383 ww
.s
.high
-= uu
.s
.low
;
384 ww
.s
.high
-= vv
.s
.low
;
385 if (__builtin_expect (ww
.s
.high
>= 0, 1))
399 /* Unless shift functions are defined with full ANSI prototypes,
400 parameter b will be promoted to int if shift_count_type is smaller than an int. */
403 __lshrdi3 (DWtype u
, shift_count_type b
)
408 const DWunion uu
= {.ll
= u
};
409 const shift_count_type bm
= W_TYPE_SIZE
- b
;
415 w
.s
.low
= (UWtype
) uu
.s
.high
>> -bm
;
419 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
421 w
.s
.high
= (UWtype
) uu
.s
.high
>> b
;
422 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
431 __ashldi3 (DWtype u
, shift_count_type b
)
436 const DWunion uu
= {.ll
= u
};
437 const shift_count_type bm
= W_TYPE_SIZE
- b
;
443 w
.s
.high
= (UWtype
) uu
.s
.low
<< -bm
;
447 const UWtype carries
= (UWtype
) uu
.s
.low
>> bm
;
449 w
.s
.low
= (UWtype
) uu
.s
.low
<< b
;
450 w
.s
.high
= ((UWtype
) uu
.s
.high
<< b
) | carries
;
459 __ashrdi3 (DWtype u
, shift_count_type b
)
464 const DWunion uu
= {.ll
= u
};
465 const shift_count_type bm
= W_TYPE_SIZE
- b
;
470 /* w.s.high = 1..1 or 0..0 */
471 w
.s
.high
= uu
.s
.high
>> (W_TYPE_SIZE
- 1);
472 w
.s
.low
= uu
.s
.high
>> -bm
;
476 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
478 w
.s
.high
= uu
.s
.high
>> b
;
479 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
488 __bswapsi2 (SItype u
)
490 return ((((u
) & 0xff000000) >> 24)
491 | (((u
) & 0x00ff0000) >> 8)
492 | (((u
) & 0x0000ff00) << 8)
493 | (((u
) & 0x000000ff) << 24));
498 __bswapdi2 (DItype u
)
500 return ((((u
) & 0xff00000000000000ull
) >> 56)
501 | (((u
) & 0x00ff000000000000ull
) >> 40)
502 | (((u
) & 0x0000ff0000000000ull
) >> 24)
503 | (((u
) & 0x000000ff00000000ull
) >> 8)
504 | (((u
) & 0x00000000ff000000ull
) << 8)
505 | (((u
) & 0x0000000000ff0000ull
) << 24)
506 | (((u
) & 0x000000000000ff00ull
) << 40)
507 | (((u
) & 0x00000000000000ffull
) << 56));
520 count_trailing_zeros (count
, u
);
530 const DWunion uu
= {.ll
= u
};
531 UWtype word
, count
, add
;
534 word
= uu
.s
.low
, add
= 0;
535 else if (uu
.s
.high
!= 0)
536 word
= uu
.s
.high
, add
= W_TYPE_SIZE
;
540 count_trailing_zeros (count
, word
);
541 return count
+ add
+ 1;
547 __muldi3 (DWtype u
, DWtype v
)
549 const DWunion uu
= {.ll
= u
};
550 const DWunion vv
= {.ll
= v
};
551 DWunion w
= {.ll
= __umulsidi3 (uu
.s
.low
, vv
.s
.low
)};
553 w
.s
.high
+= ((UWtype
) uu
.s
.low
* (UWtype
) vv
.s
.high
554 + (UWtype
) uu
.s
.high
* (UWtype
) vv
.s
.low
);
560 #if (defined (L_udivdi3) || defined (L_divdi3) || \
561 defined (L_umoddi3) || defined (L_moddi3))
562 #if defined (sdiv_qrnnd)
563 #define L_udiv_w_sdiv
568 #if defined (sdiv_qrnnd)
569 #if (defined (L_udivdi3) || defined (L_divdi3) || \
570 defined (L_umoddi3) || defined (L_moddi3))
571 static inline __attribute__ ((__always_inline__
))
574 __udiv_w_sdiv (UWtype
*rp
, UWtype a1
, UWtype a0
, UWtype d
)
581 if (a1
< d
- a1
- (a0
>> (W_TYPE_SIZE
- 1)))
583 /* Dividend, divisor, and quotient are nonnegative. */
584 sdiv_qrnnd (q
, r
, a1
, a0
, d
);
588 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
589 sub_ddmmss (c1
, c0
, a1
, a0
, d
>> 1, d
<< (W_TYPE_SIZE
- 1));
590 /* Divide (c1*2^32 + c0) by d. */
591 sdiv_qrnnd (q
, r
, c1
, c0
, d
);
592 /* Add 2^31 to quotient. */
593 q
+= (UWtype
) 1 << (W_TYPE_SIZE
- 1);
598 b1
= d
>> 1; /* d/2, between 2^30 and 2^31 - 1 */
599 c1
= a1
>> 1; /* A/2 */
600 c0
= (a1
<< (W_TYPE_SIZE
- 1)) + (a0
>> 1);
602 if (a1
< b1
) /* A < 2^32*b1, so A/2 < 2^31*b1 */
604 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
606 r
= 2*r
+ (a0
& 1); /* Remainder from A/(2*b1) */
623 else if (c1
< b1
) /* So 2^31 <= (A/2)/b1 < 2^32 */
626 c0
= ~c0
; /* logical NOT */
628 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
630 q
= ~q
; /* (A/2)/b1 */
633 r
= 2*r
+ (a0
& 1); /* A/(2*b1) */
651 else /* Implies c1 = b1 */
652 { /* Hence a1 = d - 1 = 2*b1 - 1 */
670 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
672 __udiv_w_sdiv (UWtype
*rp
__attribute__ ((__unused__
)),
673 UWtype a1
__attribute__ ((__unused__
)),
674 UWtype a0
__attribute__ ((__unused__
)),
675 UWtype d
__attribute__ ((__unused__
)))
682 #if (defined (L_udivdi3) || defined (L_divdi3) || \
683 defined (L_umoddi3) || defined (L_moddi3))
688 const UQItype __clz_tab
[256] =
690 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,
691 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,
692 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,
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 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,
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
708 count_leading_zeros (ret
, x
);
719 const DWunion uu
= {.ll
= x
};
724 word
= uu
.s
.high
, add
= 0;
726 word
= uu
.s
.low
, add
= W_TYPE_SIZE
;
728 count_leading_zeros (ret
, word
);
740 count_trailing_zeros (ret
, x
);
751 const DWunion uu
= {.ll
= x
};
756 word
= uu
.s
.low
, add
= 0;
758 word
= uu
.s
.high
, add
= W_TYPE_SIZE
;
760 count_trailing_zeros (ret
, word
);
775 return W_TYPE_SIZE
- 1;
776 count_leading_zeros (ret
, x
);
784 __clrsbDI2 (DWtype x
)
786 const DWunion uu
= {.ll
= x
};
791 word
= uu
.s
.low
, add
= W_TYPE_SIZE
;
792 else if (uu
.s
.high
== -1)
793 word
= ~uu
.s
.low
, add
= W_TYPE_SIZE
;
794 else if (uu
.s
.high
>= 0)
795 word
= uu
.s
.high
, add
= 0;
797 word
= ~uu
.s
.high
, add
= 0;
802 count_leading_zeros (ret
, word
);
804 return ret
+ add
- 1;
808 #ifdef L_popcount_tab
809 const UQItype __popcount_tab
[256] =
811 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,
812 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,
813 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,
814 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,
815 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,
816 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,
817 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,
818 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
825 __popcountSI2 (UWtype x
)
829 for (i
= 0; i
< W_TYPE_SIZE
; i
+= 8)
830 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
839 __popcountDI2 (UDWtype x
)
843 for (i
= 0; i
< 2*W_TYPE_SIZE
; i
+= 8)
844 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
853 __paritySI2 (UWtype x
)
856 # error "fill out the table"
867 return (0x6996 >> x
) & 1;
874 __parityDI2 (UDWtype x
)
876 const DWunion uu
= {.ll
= x
};
877 UWtype nx
= uu
.s
.low
^ uu
.s
.high
;
880 # error "fill out the table"
891 return (0x6996 >> nx
) & 1;
897 #if (defined (L_udivdi3) || defined (L_divdi3) || \
898 defined (L_umoddi3) || defined (L_moddi3))
899 static inline __attribute__ ((__always_inline__
))
902 __udivmoddi4 (UDWtype n
, UDWtype d
, UDWtype
*rp
)
904 const DWunion nn
= {.ll
= n
};
905 const DWunion dd
= {.ll
= d
};
907 UWtype d0
, d1
, n0
, n1
, n2
;
916 #if !UDIV_NEEDS_NORMALIZATION
923 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
926 /* Remainder in n0. */
933 d0
= 1 / d0
; /* Divide intentionally by zero. */
935 udiv_qrnnd (q1
, n1
, 0, n1
, d0
);
936 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
938 /* Remainder in n0. */
949 #else /* UDIV_NEEDS_NORMALIZATION */
957 count_leading_zeros (bm
, d0
);
961 /* Normalize, i.e. make the most significant bit of the
965 n1
= (n1
<< bm
) | (n0
>> (W_TYPE_SIZE
- bm
));
969 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
972 /* Remainder in n0 >> bm. */
979 d0
= 1 / d0
; /* Divide intentionally by zero. */
981 count_leading_zeros (bm
, d0
);
985 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
986 conclude (the most significant bit of n1 is set) /\ (the
987 leading quotient digit q1 = 1).
989 This special case is necessary, not an optimization.
990 (Shifts counts of W_TYPE_SIZE are undefined.) */
999 b
= W_TYPE_SIZE
- bm
;
1003 n1
= (n1
<< bm
) | (n0
>> b
);
1006 udiv_qrnnd (q1
, n1
, n2
, n1
, d0
);
1011 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
1013 /* Remainder in n0 >> bm. */
1018 rr
.s
.low
= n0
>> bm
;
1023 #endif /* UDIV_NEEDS_NORMALIZATION */
1034 /* Remainder in n1n0. */
1046 count_leading_zeros (bm
, d1
);
1049 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
1050 conclude (the most significant bit of n1 is set) /\ (the
1051 quotient digit q0 = 0 or 1).
1053 This special case is necessary, not an optimization. */
1055 /* The condition on the next line takes advantage of that
1056 n1 >= d1 (true due to program flow). */
1057 if (n1
> d1
|| n0
>= d0
)
1060 sub_ddmmss (n1
, n0
, n1
, n0
, d1
, d0
);
1079 b
= W_TYPE_SIZE
- bm
;
1081 d1
= (d1
<< bm
) | (d0
>> b
);
1084 n1
= (n1
<< bm
) | (n0
>> b
);
1087 udiv_qrnnd (q0
, n1
, n2
, n1
, d1
);
1088 umul_ppmm (m1
, m0
, q0
, d0
);
1090 if (m1
> n1
|| (m1
== n1
&& m0
> n0
))
1093 sub_ddmmss (m1
, m0
, m1
, m0
, d1
, d0
);
1098 /* Remainder in (n1n0 - m1m0) >> bm. */
1101 sub_ddmmss (n1
, n0
, n1
, n0
, m1
, m0
);
1102 rr
.s
.low
= (n1
<< b
) | (n0
>> bm
);
1103 rr
.s
.high
= n1
>> bm
;
1110 const DWunion ww
= {{.low
= q0
, .high
= q1
}};
1117 __divdi3 (DWtype u
, DWtype v
)
1120 DWunion uu
= {.ll
= u
};
1121 DWunion vv
= {.ll
= v
};
1131 w
= __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*) 0);
1141 __moddi3 (DWtype u
, DWtype v
)
1144 DWunion uu
= {.ll
= u
};
1145 DWunion vv
= {.ll
= v
};
1154 (void) __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*)&w
);
1164 __umoddi3 (UDWtype u
, UDWtype v
)
1168 (void) __udivmoddi4 (u
, v
, &w
);
1176 __udivdi3 (UDWtype n
, UDWtype d
)
1178 return __udivmoddi4 (n
, d
, (UDWtype
*) 0);
1184 __cmpdi2 (DWtype a
, DWtype b
)
1186 const DWunion au
= {.ll
= a
};
1187 const DWunion bu
= {.ll
= b
};
1189 if (au
.s
.high
< bu
.s
.high
)
1191 else if (au
.s
.high
> bu
.s
.high
)
1193 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
1195 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
1203 __ucmpdi2 (DWtype a
, DWtype b
)
1205 const DWunion au
= {.ll
= a
};
1206 const DWunion bu
= {.ll
= b
};
1208 if ((UWtype
) au
.s
.high
< (UWtype
) bu
.s
.high
)
1210 else if ((UWtype
) au
.s
.high
> (UWtype
) bu
.s
.high
)
1212 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
1214 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
1220 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1222 __fixunstfDI (TFtype a
)
1227 /* Compute high word of result, as a flonum. */
1228 const TFtype b
= (a
/ Wtype_MAXp1_F
);
1229 /* Convert that to fixed (but not to DWtype!),
1230 and shift it into the high word. */
1231 UDWtype v
= (UWtype
) b
;
1233 /* Remove high part from the TFtype, leaving the low part as flonum. */
1235 /* Convert that to fixed (but not to DWtype!) and add it in.
1236 Sometimes A comes out negative. This is significant, since
1237 A has more bits than a long int does. */
1239 v
-= (UWtype
) (- a
);
1246 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1248 __fixtfdi (TFtype a
)
1251 return - __fixunstfDI (-a
);
1252 return __fixunstfDI (a
);
1256 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1258 __fixunsxfDI (XFtype a
)
1263 /* Compute high word of result, as a flonum. */
1264 const XFtype b
= (a
/ Wtype_MAXp1_F
);
1265 /* Convert that to fixed (but not to DWtype!),
1266 and shift it into the high word. */
1267 UDWtype v
= (UWtype
) b
;
1269 /* Remove high part from the XFtype, leaving the low part as flonum. */
1271 /* Convert that to fixed (but not to DWtype!) and add it in.
1272 Sometimes A comes out negative. This is significant, since
1273 A has more bits than a long int does. */
1275 v
-= (UWtype
) (- a
);
1282 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1284 __fixxfdi (XFtype a
)
1287 return - __fixunsxfDI (-a
);
1288 return __fixunsxfDI (a
);
1292 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1294 __fixunsdfDI (DFtype a
)
1296 /* Get high part of result. The division here will just moves the radix
1297 point and will not cause any rounding. Then the conversion to integral
1298 type chops result as desired. */
1299 const UWtype hi
= a
/ Wtype_MAXp1_F
;
1301 /* Get low part of result. Convert `hi' to floating type and scale it back,
1302 then subtract this from the number being converted. This leaves the low
1303 part. Convert that to integral type. */
1304 const UWtype lo
= a
- (DFtype
) hi
* Wtype_MAXp1_F
;
1306 /* Assemble result from the two parts. */
1307 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
1311 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1313 __fixdfdi (DFtype a
)
1316 return - __fixunsdfDI (-a
);
1317 return __fixunsdfDI (a
);
1321 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1323 __fixunssfDI (SFtype a
)
1325 #if LIBGCC2_HAS_DF_MODE
1326 /* Convert the SFtype to a DFtype, because that is surely not going
1327 to lose any bits. Some day someone else can write a faster version
1328 that avoids converting to DFtype, and verify it really works right. */
1329 const DFtype dfa
= a
;
1331 /* Get high part of result. The division here will just moves the radix
1332 point and will not cause any rounding. Then the conversion to integral
1333 type chops result as desired. */
1334 const UWtype hi
= dfa
/ Wtype_MAXp1_F
;
1336 /* Get low part of result. Convert `hi' to floating type and scale it back,
1337 then subtract this from the number being converted. This leaves the low
1338 part. Convert that to integral type. */
1339 const UWtype lo
= dfa
- (DFtype
) hi
* Wtype_MAXp1_F
;
1341 /* Assemble result from the two parts. */
1342 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
1343 #elif FLT_MANT_DIG < W_TYPE_SIZE
1346 if (a
< Wtype_MAXp1_F
)
1348 if (a
< Wtype_MAXp1_F
* Wtype_MAXp1_F
)
1350 /* Since we know that there are fewer significant bits in the SFmode
1351 quantity than in a word, we know that we can convert out all the
1352 significant bits in one step, and thus avoid losing bits. */
1354 /* ??? This following loop essentially performs frexpf. If we could
1355 use the real libm function, or poke at the actual bits of the fp
1356 format, it would be significantly faster. */
1358 UWtype shift
= 0, counter
;
1362 for (counter
= W_TYPE_SIZE
/ 2; counter
!= 0; counter
>>= 1)
1364 SFtype counterf
= (UWtype
)1 << counter
;
1372 /* Rescale into the range of one word, extract the bits of that
1373 one word, and shift the result into position. */
1376 return (DWtype
)counter
<< shift
;
1385 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1387 __fixsfdi (SFtype a
)
1390 return - __fixunssfDI (-a
);
1391 return __fixunssfDI (a
);
1395 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1397 __floatdixf (DWtype u
)
1399 #if W_TYPE_SIZE > XF_SIZE
1402 XFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1409 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
1411 __floatundixf (UDWtype u
)
1413 #if W_TYPE_SIZE > XF_SIZE
1416 XFtype d
= (UWtype
) (u
>> W_TYPE_SIZE
);
1423 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1425 __floatditf (DWtype u
)
1427 #if W_TYPE_SIZE > TF_SIZE
1430 TFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1437 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
1439 __floatunditf (UDWtype u
)
1441 #if W_TYPE_SIZE > TF_SIZE
1444 TFtype d
= (UWtype
) (u
>> W_TYPE_SIZE
);
1451 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
1452 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
1453 #define DI_SIZE (W_TYPE_SIZE * 2)
1454 #define F_MODE_OK(SIZE) \
1456 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1457 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1458 #if defined(L_floatdisf)
1459 #define FUNC __floatdisf
1460 #define FSTYPE SFtype
1461 #define FSSIZE SF_SIZE
1463 #define FUNC __floatdidf
1464 #define FSTYPE DFtype
1465 #define FSSIZE DF_SIZE
1471 #if FSSIZE >= W_TYPE_SIZE
1472 /* When the word size is small, we never get any rounding error. */
1473 FSTYPE f
= (Wtype
) (u
>> W_TYPE_SIZE
);
1477 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
1478 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
1479 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1481 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
1482 # define FSIZE DF_SIZE
1483 # define FTYPE DFtype
1484 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
1485 # define FSIZE XF_SIZE
1486 # define FTYPE XFtype
1487 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1488 # define FSIZE TF_SIZE
1489 # define FTYPE TFtype
1494 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1496 /* Protect against double-rounding error.
1497 Represent any low-order bits, that might be truncated by a bit that
1498 won't be lost. The bit can go in anywhere below the rounding position
1499 of the FSTYPE. A fixed mask and bit position handles all usual
1501 if (! (- ((DWtype
) 1 << FSIZE
) < u
1502 && u
< ((DWtype
) 1 << FSIZE
)))
1504 if ((UDWtype
) u
& (REP_BIT
- 1))
1506 u
&= ~ (REP_BIT
- 1);
1511 /* Do the calculation in a wider type so that we don't lose any of
1512 the precision of the high word while multiplying it. */
1513 FTYPE f
= (Wtype
) (u
>> W_TYPE_SIZE
);
1518 #if FSSIZE >= W_TYPE_SIZE - 2
1521 /* Finally, the word size is larger than the number of bits in the
1522 required FSTYPE, and we've got no suitable wider type. The only
1523 way to avoid double rounding is to special case the
1526 /* If there are no high bits set, fall back to one conversion. */
1528 return (FSTYPE
)(Wtype
)u
;
1530 /* Otherwise, find the power of two. */
1531 Wtype hi
= u
>> W_TYPE_SIZE
;
1535 UWtype count
, shift
;
1536 count_leading_zeros (count
, hi
);
1538 /* No leading bits means u == minimum. */
1540 return -(Wtype_MAXp1_F
* (Wtype_MAXp1_F
/ 2));
1542 shift
= 1 + W_TYPE_SIZE
- count
;
1544 /* Shift down the most significant bits. */
1547 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1548 if ((UWtype
)u
<< (W_TYPE_SIZE
- shift
))
1551 /* Convert the one word of data, and rescale. */
1553 if (shift
== W_TYPE_SIZE
)
1555 /* The following two cases could be merged if we knew that the target
1556 supported a native unsigned->float conversion. More often, we only
1557 have a signed conversion, and have to add extra fixup code. */
1558 else if (shift
== W_TYPE_SIZE
- 1)
1559 e
= Wtype_MAXp1_F
/ 2;
1561 e
= (Wtype
)1 << shift
;
1567 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
1568 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
1569 #define DI_SIZE (W_TYPE_SIZE * 2)
1570 #define F_MODE_OK(SIZE) \
1572 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1573 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1574 #if defined(L_floatundisf)
1575 #define FUNC __floatundisf
1576 #define FSTYPE SFtype
1577 #define FSSIZE SF_SIZE
1579 #define FUNC __floatundidf
1580 #define FSTYPE DFtype
1581 #define FSSIZE DF_SIZE
1587 #if FSSIZE >= W_TYPE_SIZE
1588 /* When the word size is small, we never get any rounding error. */
1589 FSTYPE f
= (UWtype
) (u
>> W_TYPE_SIZE
);
1593 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
1594 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
1595 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1597 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
1598 # define FSIZE DF_SIZE
1599 # define FTYPE DFtype
1600 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
1601 # define FSIZE XF_SIZE
1602 # define FTYPE XFtype
1603 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1604 # define FSIZE TF_SIZE
1605 # define FTYPE TFtype
1610 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1612 /* Protect against double-rounding error.
1613 Represent any low-order bits, that might be truncated by a bit that
1614 won't be lost. The bit can go in anywhere below the rounding position
1615 of the FSTYPE. A fixed mask and bit position handles all usual
1617 if (u
>= ((UDWtype
) 1 << FSIZE
))
1619 if ((UDWtype
) u
& (REP_BIT
- 1))
1621 u
&= ~ (REP_BIT
- 1);
1626 /* Do the calculation in a wider type so that we don't lose any of
1627 the precision of the high word while multiplying it. */
1628 FTYPE f
= (UWtype
) (u
>> W_TYPE_SIZE
);
1633 #if FSSIZE == W_TYPE_SIZE - 1
1636 /* Finally, the word size is larger than the number of bits in the
1637 required FSTYPE, and we've got no suitable wider type. The only
1638 way to avoid double rounding is to special case the
1641 /* If there are no high bits set, fall back to one conversion. */
1643 return (FSTYPE
)(UWtype
)u
;
1645 /* Otherwise, find the power of two. */
1646 UWtype hi
= u
>> W_TYPE_SIZE
;
1648 UWtype count
, shift
;
1649 count_leading_zeros (count
, hi
);
1651 shift
= W_TYPE_SIZE
- count
;
1653 /* Shift down the most significant bits. */
1656 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1657 if ((UWtype
)u
<< (W_TYPE_SIZE
- shift
))
1660 /* Convert the one word of data, and rescale. */
1662 if (shift
== W_TYPE_SIZE
)
1664 /* The following two cases could be merged if we knew that the target
1665 supported a native unsigned->float conversion. More often, we only
1666 have a signed conversion, and have to add extra fixup code. */
1667 else if (shift
== W_TYPE_SIZE
- 1)
1668 e
= Wtype_MAXp1_F
/ 2;
1670 e
= (Wtype
)1 << shift
;
1676 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1677 /* Reenable the normal types, in case limits.h needs them. */
1690 __fixunsxfSI (XFtype a
)
1692 if (a
>= - (DFtype
) Wtype_MIN
)
1693 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1698 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1699 /* Reenable the normal types, in case limits.h needs them. */
1712 __fixunsdfSI (DFtype a
)
1714 if (a
>= - (DFtype
) Wtype_MIN
)
1715 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1720 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1721 /* Reenable the normal types, in case limits.h needs them. */
1734 __fixunssfSI (SFtype a
)
1736 if (a
>= - (SFtype
) Wtype_MIN
)
1737 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1742 /* Integer power helper used from __builtin_powi for non-constant
1745 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1746 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1747 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1748 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1749 # if defined(L_powisf2)
1750 # define TYPE SFtype
1751 # define NAME __powisf2
1752 # elif defined(L_powidf2)
1753 # define TYPE DFtype
1754 # define NAME __powidf2
1755 # elif defined(L_powixf2)
1756 # define TYPE XFtype
1757 # define NAME __powixf2
1758 # elif defined(L_powitf2)
1759 # define TYPE TFtype
1760 # define NAME __powitf2
1766 NAME (TYPE x
, int m
)
1768 unsigned int n
= m
< 0 ? -m
: m
;
1769 TYPE y
= n
% 2 ? x
: 1;
1776 return m
< 0 ? 1/y
: y
;
1781 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1782 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1783 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1784 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1790 #if defined(L_mulsc3) || defined(L_divsc3)
1791 # define MTYPE SFtype
1792 # define CTYPE SCtype
1795 # define NOTRUNC __FLT_EVAL_METHOD__ == 0
1796 #elif defined(L_muldc3) || defined(L_divdc3)
1797 # define MTYPE DFtype
1798 # define CTYPE DCtype
1800 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1805 # define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1
1807 #elif defined(L_mulxc3) || defined(L_divxc3)
1808 # define MTYPE XFtype
1809 # define CTYPE XCtype
1813 #elif defined(L_multc3) || defined(L_divtc3)
1814 # define MTYPE TFtype
1815 # define CTYPE TCtype
1817 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
1820 # define CEXT LIBGCC2_TF_CEXT
1827 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
1828 #define _CONCAT3(A,B,C) A##B##C
1830 #define CONCAT2(A,B) _CONCAT2(A,B)
1831 #define _CONCAT2(A,B) A##B
1833 /* All of these would be present in a full C99 implementation of <math.h>
1834 and <complex.h>. Our problem is that only a few systems have such full
1835 implementations. Further, libgcc_s.so isn't currently linked against
1836 libm.so, and even for systems that do provide full C99, the extra overhead
1837 of all programs using libgcc having to link against libm. So avoid it. */
1839 #define isnan(x) __builtin_expect ((x) != (x), 0)
1840 #define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
1841 #define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
1843 #define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
1846 /* Helpers to make the following code slightly less gross. */
1847 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
1848 #define FABS CONCAT2(__builtin_fabs, CEXT)
1850 /* Verify that MTYPE matches up with CEXT. */
1851 extern void *compile_type_assert
[sizeof(INFINITY
) == sizeof(MTYPE
) ? 1 : -1];
1853 /* Ensure that we've lost any extra precision. */
1857 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
1860 #if defined(L_mulsc3) || defined(L_muldc3) \
1861 || defined(L_mulxc3) || defined(L_multc3)
1864 CONCAT3(__mul
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
1866 MTYPE ac
, bd
, ad
, bc
, x
, y
;
1882 if (isnan (x
) && isnan (y
))
1884 /* Recover infinities that computed as NaN + iNaN. */
1886 if (isinf (a
) || isinf (b
))
1888 /* z is infinite. "Box" the infinity and change NaNs in
1889 the other factor to 0. */
1890 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
1891 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
1892 if (isnan (c
)) c
= COPYSIGN (0, c
);
1893 if (isnan (d
)) d
= COPYSIGN (0, d
);
1896 if (isinf (c
) || isinf (d
))
1898 /* w is infinite. "Box" the infinity and change NaNs in
1899 the other factor to 0. */
1900 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
1901 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
1902 if (isnan (a
)) a
= COPYSIGN (0, a
);
1903 if (isnan (b
)) b
= COPYSIGN (0, b
);
1907 && (isinf (ac
) || isinf (bd
)
1908 || isinf (ad
) || isinf (bc
)))
1910 /* Recover infinities from overflow by changing NaNs to 0. */
1911 if (isnan (a
)) a
= COPYSIGN (0, a
);
1912 if (isnan (b
)) b
= COPYSIGN (0, b
);
1913 if (isnan (c
)) c
= COPYSIGN (0, c
);
1914 if (isnan (d
)) d
= COPYSIGN (0, d
);
1919 x
= INFINITY
* (a
* c
- b
* d
);
1920 y
= INFINITY
* (a
* d
+ b
* c
);
1928 #endif /* complex multiply */
1930 #if defined(L_divsc3) || defined(L_divdc3) \
1931 || defined(L_divxc3) || defined(L_divtc3)
1934 CONCAT3(__div
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
1936 MTYPE denom
, ratio
, x
, y
;
1939 /* ??? We can get better behavior from logarithmic scaling instead of
1940 the division. But that would mean starting to link libgcc against
1941 libm. We could implement something akin to ldexp/frexp as gcc builtins
1943 if (FABS (c
) < FABS (d
))
1946 denom
= (c
* ratio
) + d
;
1947 x
= ((a
* ratio
) + b
) / denom
;
1948 y
= ((b
* ratio
) - a
) / denom
;
1953 denom
= (d
* ratio
) + c
;
1954 x
= ((b
* ratio
) + a
) / denom
;
1955 y
= (b
- (a
* ratio
)) / denom
;
1958 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
1959 are nonzero/zero, infinite/finite, and finite/infinite. */
1960 if (isnan (x
) && isnan (y
))
1962 if (c
== 0.0 && d
== 0.0 && (!isnan (a
) || !isnan (b
)))
1964 x
= COPYSIGN (INFINITY
, c
) * a
;
1965 y
= COPYSIGN (INFINITY
, c
) * b
;
1967 else if ((isinf (a
) || isinf (b
)) && isfinite (c
) && isfinite (d
))
1969 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
1970 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
1971 x
= INFINITY
* (a
* c
+ b
* d
);
1972 y
= INFINITY
* (b
* c
- a
* d
);
1974 else if ((isinf (c
) || isinf (d
)) && isfinite (a
) && isfinite (b
))
1976 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
1977 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
1978 x
= 0.0 * (a
* c
+ b
* d
);
1979 y
= 0.0 * (b
* c
- a
* d
);
1987 #endif /* complex divide */
1989 #endif /* all complex float routines */
1991 /* From here on down, the routines use normal data types. */
1993 #define SItype bogus_type
1994 #define USItype bogus_type
1995 #define DItype bogus_type
1996 #define UDItype bogus_type
1997 #define SFtype bogus_type
1998 #define DFtype bogus_type
2016 /* Like bcmp except the sign is meaningful.
2017 Result is negative if S1 is less than S2,
2018 positive if S1 is greater, 0 if S1 and S2 are equal. */
2021 __gcc_bcmp (const unsigned char *s1
, const unsigned char *s2
, size_t size
)
2025 const unsigned char c1
= *s1
++, c2
= *s2
++;
2035 /* __eprintf used to be used by GCC's private version of <assert.h>.
2036 We no longer provide that header, but this routine remains in libgcc.a
2037 for binary backward compatibility. Note that it is not included in
2038 the shared version of libgcc. */
2040 #ifndef inhibit_libc
2042 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2046 __eprintf (const char *string
, const char *expression
,
2047 unsigned int line
, const char *filename
)
2049 fprintf (stderr
, string
, expression
, line
, filename
);
2058 #ifdef L_clear_cache
2059 /* Clear part of an instruction cache. */
2062 __clear_cache (char *beg
__attribute__((__unused__
)),
2063 char *end
__attribute__((__unused__
)))
2065 #ifdef CLEAR_INSN_CACHE
2066 CLEAR_INSN_CACHE (beg
, end
);
2067 #endif /* CLEAR_INSN_CACHE */
2070 #endif /* L_clear_cache */
2074 /* Jump to a trampoline, loading the static chain address. */
2076 #if defined(WINNT) && ! defined(__CYGWIN__)
2077 #include <windows.h>
2078 int getpagesize (void);
2079 int mprotect (char *,int, int);
2092 mprotect (char *addr
, int len
, int prot
)
2111 if (VirtualProtect (addr
, len
, np
, &op
))
2117 #endif /* WINNT && ! __CYGWIN__ */
2119 #ifdef TRANSFER_FROM_TRAMPOLINE
2120 TRANSFER_FROM_TRAMPOLINE
2122 #endif /* L_trampoline */
2127 #include "gbl-ctors.h"
2129 /* Some systems use __main in a way incompatible with its use in gcc, in these
2130 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2131 give the same symbol without quotes for an alternative entry point. You
2132 must define both, or neither. */
2134 #define NAME__MAIN "__main"
2135 #define SYMBOL__MAIN __main
2138 #if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP)
2139 #undef HAS_INIT_SECTION
2140 #define HAS_INIT_SECTION
2143 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2145 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2146 code to run constructors. In that case, we need to handle EH here, too. */
2148 #ifdef EH_FRAME_SECTION_NAME
2149 #include "unwind-dw2-fde.h"
2150 extern unsigned char __EH_FRAME_BEGIN__
[];
2153 /* Run all the global destructors on exit from the program. */
2156 __do_global_dtors (void)
2158 #ifdef DO_GLOBAL_DTORS_BODY
2159 DO_GLOBAL_DTORS_BODY
;
2161 static func_ptr
*p
= __DTOR_LIST__
+ 1;
2168 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
2170 static int completed
= 0;
2174 __deregister_frame_info (__EH_FRAME_BEGIN__
);
2181 #ifndef HAS_INIT_SECTION
2182 /* Run all the global constructors on entry to the program. */
2185 __do_global_ctors (void)
2187 #ifdef EH_FRAME_SECTION_NAME
2189 static struct object object
;
2190 __register_frame_info (__EH_FRAME_BEGIN__
, &object
);
2193 DO_GLOBAL_CTORS_BODY
;
2194 atexit (__do_global_dtors
);
2196 #endif /* no HAS_INIT_SECTION */
2198 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2199 /* Subroutine called automatically by `main'.
2200 Compiling a global function named `main'
2201 produces an automatic call to this function at the beginning.
2203 For many systems, this routine calls __do_global_ctors.
2204 For systems which support a .init section we use the .init section
2205 to run __do_global_ctors, so we need not do anything here. */
2207 extern void SYMBOL__MAIN (void);
2211 /* Support recursive calls to `main': run initializers just once. */
2212 static int initialized
;
2216 __do_global_ctors ();
2219 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2221 #endif /* L__main */
2222 #endif /* __CYGWIN__ */
2226 #include "gbl-ctors.h"
2228 /* Provide default definitions for the lists of constructors and
2229 destructors, so that we don't get linker errors. These symbols are
2230 intentionally bss symbols, so that gld and/or collect will provide
2231 the right values. */
2233 /* We declare the lists here with two elements each,
2234 so that they are valid empty lists if no other definition is loaded.
2236 If we are using the old "set" extensions to have the gnu linker
2237 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2238 must be in the bss/common section.
2240 Long term no port should use those extensions. But many still do. */
2241 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2242 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2243 func_ptr __CTOR_LIST__
[2] = {0, 0};
2244 func_ptr __DTOR_LIST__
[2] = {0, 0};
2246 func_ptr __CTOR_LIST__
[2];
2247 func_ptr __DTOR_LIST__
[2];
2249 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2250 #endif /* L_ctors */
2251 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */