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 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, 51 Franklin Street, Fifth Floor, Boston, MA
34 #include "coretypes.h"
37 #ifdef HAVE_GAS_HIDDEN
38 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
40 #define ATTRIBUTE_HIDDEN
43 #ifndef MIN_UNITS_PER_WORD
44 #define MIN_UNITS_PER_WORD UNITS_PER_WORD
47 /* Work out the largest "word" size that we can deal with on this target. */
48 #if MIN_UNITS_PER_WORD > 4
49 # define LIBGCC2_MAX_UNITS_PER_WORD 8
50 #elif (MIN_UNITS_PER_WORD > 2 \
51 || (MIN_UNITS_PER_WORD > 1 && LONG_LONG_TYPE_SIZE > 32))
52 # define LIBGCC2_MAX_UNITS_PER_WORD 4
54 # define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD
57 /* Work out what word size we are using for this compilation.
58 The value can be set on the command line. */
59 #ifndef LIBGCC2_UNITS_PER_WORD
60 #define LIBGCC2_UNITS_PER_WORD LIBGCC2_MAX_UNITS_PER_WORD
63 #if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
67 #ifdef DECLARE_LIBRARY_RENAMES
68 DECLARE_LIBRARY_RENAMES
71 #if defined (L_negdi2)
75 const DWunion uu
= {.ll
= u
};
76 const DWunion w
= { {.low
= -uu
.s
.low
,
77 .high
= -uu
.s
.high
- ((UWtype
) -uu
.s
.low
> 0) } };
85 __addvSI3 (Wtype a
, Wtype b
)
87 const Wtype w
= a
+ b
;
89 if (b
>= 0 ? w
< a
: w
> a
)
94 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
96 __addvsi3 (SItype a
, SItype b
)
98 const SItype w
= a
+ b
;
100 if (b
>= 0 ? w
< a
: w
> a
)
105 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
110 __addvDI3 (DWtype a
, DWtype b
)
112 const DWtype w
= a
+ b
;
114 if (b
>= 0 ? w
< a
: w
> a
)
123 __subvSI3 (Wtype a
, Wtype b
)
125 const Wtype w
= a
- b
;
127 if (b
>= 0 ? w
> a
: w
< a
)
132 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
134 __subvsi3 (SItype a
, SItype b
)
136 const SItype w
= a
- b
;
138 if (b
>= 0 ? w
> a
: w
< a
)
143 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
148 __subvDI3 (DWtype a
, DWtype b
)
150 const DWtype w
= a
- b
;
152 if (b
>= 0 ? w
> a
: w
< a
)
161 __mulvSI3 (Wtype a
, Wtype b
)
163 const DWtype w
= (DWtype
) a
* (DWtype
) b
;
165 if ((Wtype
) (w
>> W_TYPE_SIZE
) != (Wtype
) w
>> (W_TYPE_SIZE
- 1))
170 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
172 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
174 __mulvsi3 (SItype a
, SItype b
)
176 const DItype w
= (DItype
) a
* (DItype
) b
;
178 if ((SItype
) (w
>> WORD_SIZE
) != (SItype
) w
>> (WORD_SIZE
-1))
183 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
192 if (a
>= 0 ? w
> 0 : w
< 0)
197 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
203 if (a
>= 0 ? w
> 0 : w
< 0)
208 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
217 if (a
>= 0 ? w
> 0 : w
< 0)
242 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
260 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
285 __mulvDI3 (DWtype u
, DWtype v
)
287 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
288 but the checked multiplication needs only two. */
289 const DWunion uu
= {.ll
= u
};
290 const DWunion vv
= {.ll
= v
};
292 if (__builtin_expect (uu
.s
.high
== uu
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
294 /* u fits in a single Wtype. */
295 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
297 /* v fits in a single Wtype as well. */
298 /* A single multiplication. No overflow risk. */
299 return (DWtype
) uu
.s
.low
* (DWtype
) vv
.s
.low
;
303 /* Two multiplications. */
304 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
305 * (UDWtype
) (UWtype
) vv
.s
.low
};
306 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
307 * (UDWtype
) (UWtype
) vv
.s
.high
};
310 w1
.s
.high
-= uu
.s
.low
;
313 w1
.ll
+= (UWtype
) w0
.s
.high
;
314 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
316 w0
.s
.high
= w1
.s
.low
;
323 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
325 /* v fits into a single Wtype. */
326 /* Two multiplications. */
327 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
328 * (UDWtype
) (UWtype
) vv
.s
.low
};
329 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.high
330 * (UDWtype
) (UWtype
) vv
.s
.low
};
333 w1
.s
.high
-= vv
.s
.low
;
336 w1
.ll
+= (UWtype
) w0
.s
.high
;
337 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
339 w0
.s
.high
= w1
.s
.low
;
345 /* A few sign checks and a single multiplication. */
350 if (uu
.s
.high
== 0 && vv
.s
.high
== 0)
352 const DWtype w
= (UDWtype
) (UWtype
) uu
.s
.low
353 * (UDWtype
) (UWtype
) vv
.s
.low
;
354 if (__builtin_expect (w
>= 0, 1))
360 if (uu
.s
.high
== 0 && vv
.s
.high
== (Wtype
) -1)
362 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
363 * (UDWtype
) (UWtype
) vv
.s
.low
};
365 ww
.s
.high
-= uu
.s
.low
;
366 if (__builtin_expect (ww
.s
.high
< 0, 1))
375 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== 0)
377 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
378 * (UDWtype
) (UWtype
) vv
.s
.low
};
380 ww
.s
.high
-= vv
.s
.low
;
381 if (__builtin_expect (ww
.s
.high
< 0, 1))
387 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== (Wtype
) - 1)
389 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
390 * (UDWtype
) (UWtype
) vv
.s
.low
};
392 ww
.s
.high
-= uu
.s
.low
;
393 ww
.s
.high
-= vv
.s
.low
;
394 if (__builtin_expect (ww
.s
.high
>= 0, 1))
408 /* Unless shift functions are defined with full ANSI prototypes,
409 parameter b will be promoted to int if word_type is smaller than an int. */
412 __lshrdi3 (DWtype u
, word_type b
)
417 const DWunion uu
= {.ll
= u
};
418 const word_type bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
424 w
.s
.low
= (UWtype
) uu
.s
.high
>> -bm
;
428 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
430 w
.s
.high
= (UWtype
) uu
.s
.high
>> b
;
431 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
440 __ashldi3 (DWtype u
, word_type b
)
445 const DWunion uu
= {.ll
= u
};
446 const word_type bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
452 w
.s
.high
= (UWtype
) uu
.s
.low
<< -bm
;
456 const UWtype carries
= (UWtype
) uu
.s
.low
>> bm
;
458 w
.s
.low
= (UWtype
) uu
.s
.low
<< b
;
459 w
.s
.high
= ((UWtype
) uu
.s
.high
<< b
) | carries
;
468 __ashrdi3 (DWtype u
, word_type b
)
473 const DWunion uu
= {.ll
= u
};
474 const word_type bm
= (sizeof (Wtype
) * BITS_PER_UNIT
) - b
;
479 /* w.s.high = 1..1 or 0..0 */
480 w
.s
.high
= uu
.s
.high
>> (sizeof (Wtype
) * BITS_PER_UNIT
- 1);
481 w
.s
.low
= uu
.s
.high
>> -bm
;
485 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
487 w
.s
.high
= uu
.s
.high
>> b
;
488 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
505 count_trailing_zeros (count
, u
);
515 const DWunion uu
= {.ll
= u
};
516 UWtype word
, count
, add
;
519 word
= uu
.s
.low
, add
= 0;
520 else if (uu
.s
.high
!= 0)
521 word
= uu
.s
.high
, add
= BITS_PER_UNIT
* sizeof (Wtype
);
525 count_trailing_zeros (count
, word
);
526 return count
+ add
+ 1;
532 __muldi3 (DWtype u
, DWtype v
)
534 const DWunion uu
= {.ll
= u
};
535 const DWunion vv
= {.ll
= v
};
536 DWunion w
= {.ll
= __umulsidi3 (uu
.s
.low
, vv
.s
.low
)};
538 w
.s
.high
+= ((UWtype
) uu
.s
.low
* (UWtype
) vv
.s
.high
539 + (UWtype
) uu
.s
.high
* (UWtype
) vv
.s
.low
);
545 #if (defined (L_udivdi3) || defined (L_divdi3) || \
546 defined (L_umoddi3) || defined (L_moddi3))
547 #if defined (sdiv_qrnnd)
548 #define L_udiv_w_sdiv
553 #if defined (sdiv_qrnnd)
554 #if (defined (L_udivdi3) || defined (L_divdi3) || \
555 defined (L_umoddi3) || defined (L_moddi3))
556 static inline __attribute__ ((__always_inline__
))
559 __udiv_w_sdiv (UWtype
*rp
, UWtype a1
, UWtype a0
, UWtype d
)
566 if (a1
< d
- a1
- (a0
>> (W_TYPE_SIZE
- 1)))
568 /* Dividend, divisor, and quotient are nonnegative. */
569 sdiv_qrnnd (q
, r
, a1
, a0
, d
);
573 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
574 sub_ddmmss (c1
, c0
, a1
, a0
, d
>> 1, d
<< (W_TYPE_SIZE
- 1));
575 /* Divide (c1*2^32 + c0) by d. */
576 sdiv_qrnnd (q
, r
, c1
, c0
, d
);
577 /* Add 2^31 to quotient. */
578 q
+= (UWtype
) 1 << (W_TYPE_SIZE
- 1);
583 b1
= d
>> 1; /* d/2, between 2^30 and 2^31 - 1 */
584 c1
= a1
>> 1; /* A/2 */
585 c0
= (a1
<< (W_TYPE_SIZE
- 1)) + (a0
>> 1);
587 if (a1
< b1
) /* A < 2^32*b1, so A/2 < 2^31*b1 */
589 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
591 r
= 2*r
+ (a0
& 1); /* Remainder from A/(2*b1) */
608 else if (c1
< b1
) /* So 2^31 <= (A/2)/b1 < 2^32 */
611 c0
= ~c0
; /* logical NOT */
613 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
615 q
= ~q
; /* (A/2)/b1 */
618 r
= 2*r
+ (a0
& 1); /* A/(2*b1) */
636 else /* Implies c1 = b1 */
637 { /* Hence a1 = d - 1 = 2*b1 - 1 */
655 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
657 __udiv_w_sdiv (UWtype
*rp
__attribute__ ((__unused__
)),
658 UWtype a1
__attribute__ ((__unused__
)),
659 UWtype a0
__attribute__ ((__unused__
)),
660 UWtype d
__attribute__ ((__unused__
)))
667 #if (defined (L_udivdi3) || defined (L_divdi3) || \
668 defined (L_umoddi3) || defined (L_moddi3))
673 const UQItype __clz_tab
[256] =
675 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,
676 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,
677 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,
678 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,
679 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,
680 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,
681 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,
682 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
693 count_leading_zeros (ret
, x
);
704 const DWunion uu
= {.ll
= x
};
709 word
= uu
.s
.high
, add
= 0;
711 word
= uu
.s
.low
, add
= W_TYPE_SIZE
;
713 count_leading_zeros (ret
, word
);
725 count_trailing_zeros (ret
, x
);
736 const DWunion uu
= {.ll
= x
};
741 word
= uu
.s
.low
, add
= 0;
743 word
= uu
.s
.high
, add
= W_TYPE_SIZE
;
745 count_trailing_zeros (ret
, word
);
750 #ifdef L_popcount_tab
751 const UQItype __popcount_tab
[256] =
753 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,
754 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,
755 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,
756 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,
757 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,
758 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,
759 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,
760 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
767 __popcountSI2 (UWtype x
)
771 for (i
= 0; i
< W_TYPE_SIZE
; i
+= 8)
772 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
781 __popcountDI2 (UDWtype x
)
785 for (i
= 0; i
< 2*W_TYPE_SIZE
; i
+= 8)
786 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
795 __paritySI2 (UWtype x
)
798 # error "fill out the table"
809 return (0x6996 >> x
) & 1;
816 __parityDI2 (UDWtype x
)
818 const DWunion uu
= {.ll
= x
};
819 UWtype nx
= uu
.s
.low
^ uu
.s
.high
;
822 # error "fill out the table"
833 return (0x6996 >> nx
) & 1;
839 #if (defined (L_udivdi3) || defined (L_divdi3) || \
840 defined (L_umoddi3) || defined (L_moddi3))
841 static inline __attribute__ ((__always_inline__
))
844 __udivmoddi4 (UDWtype n
, UDWtype d
, UDWtype
*rp
)
846 const DWunion nn
= {.ll
= n
};
847 const DWunion dd
= {.ll
= d
};
849 UWtype d0
, d1
, n0
, n1
, n2
;
858 #if !UDIV_NEEDS_NORMALIZATION
865 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
868 /* Remainder in n0. */
875 d0
= 1 / d0
; /* Divide intentionally by zero. */
877 udiv_qrnnd (q1
, n1
, 0, n1
, d0
);
878 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
880 /* Remainder in n0. */
891 #else /* UDIV_NEEDS_NORMALIZATION */
899 count_leading_zeros (bm
, d0
);
903 /* Normalize, i.e. make the most significant bit of the
907 n1
= (n1
<< bm
) | (n0
>> (W_TYPE_SIZE
- bm
));
911 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
914 /* Remainder in n0 >> bm. */
921 d0
= 1 / d0
; /* Divide intentionally by zero. */
923 count_leading_zeros (bm
, d0
);
927 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
928 conclude (the most significant bit of n1 is set) /\ (the
929 leading quotient digit q1 = 1).
931 This special case is necessary, not an optimization.
932 (Shifts counts of W_TYPE_SIZE are undefined.) */
941 b
= W_TYPE_SIZE
- bm
;
945 n1
= (n1
<< bm
) | (n0
>> b
);
948 udiv_qrnnd (q1
, n1
, n2
, n1
, d0
);
953 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
955 /* Remainder in n0 >> bm. */
965 #endif /* UDIV_NEEDS_NORMALIZATION */
976 /* Remainder in n1n0. */
988 count_leading_zeros (bm
, d1
);
991 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
992 conclude (the most significant bit of n1 is set) /\ (the
993 quotient digit q0 = 0 or 1).
995 This special case is necessary, not an optimization. */
997 /* The condition on the next line takes advantage of that
998 n1 >= d1 (true due to program flow). */
999 if (n1
> d1
|| n0
>= d0
)
1002 sub_ddmmss (n1
, n0
, n1
, n0
, d1
, d0
);
1021 b
= W_TYPE_SIZE
- bm
;
1023 d1
= (d1
<< bm
) | (d0
>> b
);
1026 n1
= (n1
<< bm
) | (n0
>> b
);
1029 udiv_qrnnd (q0
, n1
, n2
, n1
, d1
);
1030 umul_ppmm (m1
, m0
, q0
, d0
);
1032 if (m1
> n1
|| (m1
== n1
&& m0
> n0
))
1035 sub_ddmmss (m1
, m0
, m1
, m0
, d1
, d0
);
1040 /* Remainder in (n1n0 - m1m0) >> bm. */
1043 sub_ddmmss (n1
, n0
, n1
, n0
, m1
, m0
);
1044 rr
.s
.low
= (n1
<< b
) | (n0
>> bm
);
1045 rr
.s
.high
= n1
>> bm
;
1052 const DWunion ww
= {{.low
= q0
, .high
= q1
}};
1059 __divdi3 (DWtype u
, DWtype v
)
1062 DWunion uu
= {.ll
= u
};
1063 DWunion vv
= {.ll
= v
};
1073 w
= __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*) 0);
1083 __moddi3 (DWtype u
, DWtype v
)
1086 DWunion uu
= {.ll
= u
};
1087 DWunion vv
= {.ll
= v
};
1096 (void) __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*)&w
);
1106 __umoddi3 (UDWtype u
, UDWtype v
)
1110 (void) __udivmoddi4 (u
, v
, &w
);
1118 __udivdi3 (UDWtype n
, UDWtype d
)
1120 return __udivmoddi4 (n
, d
, (UDWtype
*) 0);
1126 __cmpdi2 (DWtype a
, DWtype b
)
1128 const DWunion au
= {.ll
= a
};
1129 const DWunion bu
= {.ll
= b
};
1131 if (au
.s
.high
< bu
.s
.high
)
1133 else if (au
.s
.high
> bu
.s
.high
)
1135 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
1137 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
1145 __ucmpdi2 (DWtype a
, DWtype b
)
1147 const DWunion au
= {.ll
= a
};
1148 const DWunion bu
= {.ll
= b
};
1150 if ((UWtype
) au
.s
.high
< (UWtype
) bu
.s
.high
)
1152 else if ((UWtype
) au
.s
.high
> (UWtype
) bu
.s
.high
)
1154 if ((UWtype
) au
.s
.low
< (UWtype
) bu
.s
.low
)
1156 else if ((UWtype
) au
.s
.low
> (UWtype
) bu
.s
.low
)
1162 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1164 __fixunstfDI (TFtype a
)
1169 /* Compute high word of result, as a flonum. */
1170 const TFtype b
= (a
/ Wtype_MAXp1_F
);
1171 /* Convert that to fixed (but not to DWtype!),
1172 and shift it into the high word. */
1173 UDWtype v
= (UWtype
) b
;
1175 /* Remove high part from the TFtype, leaving the low part as flonum. */
1177 /* Convert that to fixed (but not to DWtype!) and add it in.
1178 Sometimes A comes out negative. This is significant, since
1179 A has more bits than a long int does. */
1181 v
-= (UWtype
) (- a
);
1188 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1190 __fixtfdi (TFtype a
)
1193 return - __fixunstfDI (-a
);
1194 return __fixunstfDI (a
);
1198 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1200 __fixunsxfDI (XFtype a
)
1205 /* Compute high word of result, as a flonum. */
1206 const XFtype b
= (a
/ Wtype_MAXp1_F
);
1207 /* Convert that to fixed (but not to DWtype!),
1208 and shift it into the high word. */
1209 UDWtype v
= (UWtype
) b
;
1211 /* Remove high part from the XFtype, leaving the low part as flonum. */
1213 /* Convert that to fixed (but not to DWtype!) and add it in.
1214 Sometimes A comes out negative. This is significant, since
1215 A has more bits than a long int does. */
1217 v
-= (UWtype
) (- a
);
1224 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1226 __fixxfdi (XFtype a
)
1229 return - __fixunsxfDI (-a
);
1230 return __fixunsxfDI (a
);
1234 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1236 __fixunsdfDI (DFtype a
)
1238 /* Get high part of result. The division here will just moves the radix
1239 point and will not cause any rounding. Then the conversion to integral
1240 type chops result as desired. */
1241 const UWtype hi
= a
/ Wtype_MAXp1_F
;
1243 /* Get low part of result. Convert `hi' to floating type and scale it back,
1244 then subtract this from the number being converted. This leaves the low
1245 part. Convert that to integral type. */
1246 const UWtype lo
= a
- (DFtype
) hi
* Wtype_MAXp1_F
;
1248 /* Assemble result from the two parts. */
1249 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
1253 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1255 __fixdfdi (DFtype a
)
1258 return - __fixunsdfDI (-a
);
1259 return __fixunsdfDI (a
);
1263 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1265 __fixunssfDI (SFtype a
)
1267 #if LIBGCC2_HAS_DF_MODE
1268 /* Convert the SFtype to a DFtype, because that is surely not going
1269 to lose any bits. Some day someone else can write a faster version
1270 that avoids converting to DFtype, and verify it really works right. */
1271 const DFtype dfa
= a
;
1273 /* Get high part of result. The division here will just moves the radix
1274 point and will not cause any rounding. Then the conversion to integral
1275 type chops result as desired. */
1276 const UWtype hi
= dfa
/ Wtype_MAXp1_F
;
1278 /* Get low part of result. Convert `hi' to floating type and scale it back,
1279 then subtract this from the number being converted. This leaves the low
1280 part. Convert that to integral type. */
1281 const UWtype lo
= dfa
- (DFtype
) hi
* Wtype_MAXp1_F
;
1283 /* Assemble result from the two parts. */
1284 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
1285 #elif FLT_MANT_DIG < W_TYPE_SIZE
1288 if (a
< Wtype_MAXp1_F
)
1290 if (a
< Wtype_MAXp1_F
* Wtype_MAXp1_F
)
1292 /* Since we know that there are fewer significant bits in the SFmode
1293 quantity than in a word, we know that we can convert out all the
1294 significant bits in one step, and thus avoid losing bits. */
1296 /* ??? This following loop essentially performs frexpf. If we could
1297 use the real libm function, or poke at the actual bits of the fp
1298 format, it would be significantly faster. */
1300 UWtype shift
= 0, counter
;
1304 for (counter
= W_TYPE_SIZE
/ 2; counter
!= 0; counter
>>= 1)
1306 SFtype counterf
= (UWtype
)1 << counter
;
1314 /* Rescale into the range of one word, extract the bits of that
1315 one word, and shift the result into position. */
1318 return (DWtype
)counter
<< shift
;
1327 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1329 __fixsfdi (SFtype a
)
1332 return - __fixunssfDI (-a
);
1333 return __fixunssfDI (a
);
1337 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1339 __floatdixf (DWtype u
)
1341 XFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1348 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1350 __floatditf (DWtype u
)
1352 TFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1359 #if defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE
1361 __floatdidf (DWtype u
)
1363 DFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
1370 #if defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE
1371 #define DI_SIZE (W_TYPE_SIZE * 2)
1372 #define SF_SIZE FLT_MANT_DIG
1375 __floatdisf (DWtype u
)
1377 #if SF_SIZE >= W_TYPE_SIZE
1378 /* When the word size is small, we never get any rounding error. */
1379 SFtype f
= (Wtype
) (u
>> W_TYPE_SIZE
);
1383 #elif LIBGCC2_HAS_DF_MODE
1385 #if LIBGCC2_DOUBLE_TYPE_SIZE == 64
1386 #define DF_SIZE DBL_MANT_DIG
1387 #elif LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1388 #define DF_SIZE LDBL_MANT_DIG
1393 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - DF_SIZE))
1395 /* Protect against double-rounding error.
1396 Represent any low-order bits, that might be truncated by a bit that
1397 won't be lost. The bit can go in anywhere below the rounding position
1398 of the SFmode. A fixed mask and bit position handles all usual
1399 configurations. It doesn't handle the case of 128-bit DImode, however. */
1400 if (DF_SIZE
< DI_SIZE
1401 && DF_SIZE
> (DI_SIZE
- DF_SIZE
+ SF_SIZE
))
1403 if (! (- ((DWtype
) 1 << DF_SIZE
) < u
1404 && u
< ((DWtype
) 1 << DF_SIZE
)))
1406 if ((UDWtype
) u
& (REP_BIT
- 1))
1408 u
&= ~ (REP_BIT
- 1);
1414 /* Do the calculation in DFmode so that we don't lose any of the
1415 precision of the high word while multiplying it. */
1416 DFtype f
= (Wtype
) (u
>> W_TYPE_SIZE
);
1421 /* Finally, the word size is larger than the number of bits in SFmode,
1422 and we've got no DFmode. The only way to avoid double rounding is
1423 to special case the extraction. */
1425 /* If there are no high bits set, fall back to one conversion. */
1427 return (SFtype
)(Wtype
)u
;
1429 /* Otherwise, find the power of two. */
1430 Wtype hi
= u
>> W_TYPE_SIZE
;
1434 UWtype count
, shift
;
1435 count_leading_zeros (count
, hi
);
1437 /* No leading bits means u == minimum. */
1439 return -(Wtype_MAXp1_F
* Wtype_MAXp1_F
/ 2);
1441 shift
= W_TYPE_SIZE
- count
;
1443 /* Shift down the most significant bits. */
1446 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1447 if (u
& ((1 << shift
) - 1))
1450 /* Convert the one word of data, and rescale. */
1452 f
*= (UWtype
)1 << shift
;
1458 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1459 /* Reenable the normal types, in case limits.h needs them. */
1472 __fixunsxfSI (XFtype a
)
1474 if (a
>= - (DFtype
) Wtype_MIN
)
1475 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1480 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1481 /* Reenable the normal types, in case limits.h needs them. */
1494 __fixunsdfSI (DFtype a
)
1496 if (a
>= - (DFtype
) Wtype_MIN
)
1497 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1502 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1503 /* Reenable the normal types, in case limits.h needs them. */
1516 __fixunssfSI (SFtype a
)
1518 if (a
>= - (SFtype
) Wtype_MIN
)
1519 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
1524 /* Integer power helper used from __builtin_powi for non-constant
1527 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1528 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1529 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1530 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1531 # if defined(L_powisf2)
1532 # define TYPE SFtype
1533 # define NAME __powisf2
1534 # elif defined(L_powidf2)
1535 # define TYPE DFtype
1536 # define NAME __powidf2
1537 # elif defined(L_powixf2)
1538 # define TYPE XFtype
1539 # define NAME __powixf2
1540 # elif defined(L_powitf2)
1541 # define TYPE TFtype
1542 # define NAME __powitf2
1548 NAME (TYPE x
, int m
)
1550 unsigned int n
= m
< 0 ? -m
: m
;
1551 TYPE y
= n
% 2 ? x
: 1;
1558 return m
< 0 ? 1/y
: y
;
1563 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1564 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1565 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1566 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1572 #if defined(L_mulsc3) || defined(L_divsc3)
1573 # define MTYPE SFtype
1574 # define CTYPE SCtype
1577 # define NOTRUNC __FLT_EVAL_METHOD__ == 0
1578 #elif defined(L_muldc3) || defined(L_divdc3)
1579 # define MTYPE DFtype
1580 # define CTYPE DCtype
1582 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1587 # define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1
1589 #elif defined(L_mulxc3) || defined(L_divxc3)
1590 # define MTYPE XFtype
1591 # define CTYPE XCtype
1595 #elif defined(L_multc3) || defined(L_divtc3)
1596 # define MTYPE TFtype
1597 # define CTYPE TCtype
1605 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
1606 #define _CONCAT3(A,B,C) A##B##C
1608 #define CONCAT2(A,B) _CONCAT2(A,B)
1609 #define _CONCAT2(A,B) A##B
1611 /* All of these would be present in a full C99 implementation of <math.h>
1612 and <complex.h>. Our problem is that only a few systems have such full
1613 implementations. Further, libgcc_s.so isn't currently linked against
1614 libm.so, and even for systems that do provide full C99, the extra overhead
1615 of all programs using libgcc having to link against libm. So avoid it. */
1617 #define isnan(x) __builtin_expect ((x) != (x), 0)
1618 #define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
1619 #define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
1621 #define INFINITY CONCAT2(__builtin_inf, CEXT) ()
1624 /* Helpers to make the following code slightly less gross. */
1625 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
1626 #define FABS CONCAT2(__builtin_fabs, CEXT)
1628 /* Verify that MTYPE matches up with CEXT. */
1629 extern void *compile_type_assert
[sizeof(INFINITY
) == sizeof(MTYPE
) ? 1 : -1];
1631 /* Ensure that we've lost any extra precision. */
1635 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
1638 #if defined(L_mulsc3) || defined(L_muldc3) \
1639 || defined(L_mulxc3) || defined(L_multc3)
1642 CONCAT3(__mul
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
1644 MTYPE ac
, bd
, ad
, bc
, x
, y
;
1659 if (isnan (x
) && isnan (y
))
1661 /* Recover infinities that computed as NaN + iNaN. */
1663 if (isinf (a
) || isinf (b
))
1665 /* z is infinite. "Box" the infinity and change NaNs in
1666 the other factor to 0. */
1667 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
1668 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
1669 if (isnan (c
)) c
= COPYSIGN (0, c
);
1670 if (isnan (d
)) d
= COPYSIGN (0, d
);
1673 if (isinf (c
) || isinf (d
))
1675 /* w is infinite. "Box" the infinity and change NaNs in
1676 the other factor to 0. */
1677 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
1678 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
1679 if (isnan (a
)) a
= COPYSIGN (0, a
);
1680 if (isnan (b
)) b
= COPYSIGN (0, b
);
1684 && (isinf (ac
) || isinf (bd
)
1685 || isinf (ad
) || isinf (bc
)))
1687 /* Recover infinities from overflow by changing NaNs to 0. */
1688 if (isnan (a
)) a
= COPYSIGN (0, a
);
1689 if (isnan (b
)) b
= COPYSIGN (0, b
);
1690 if (isnan (c
)) c
= COPYSIGN (0, c
);
1691 if (isnan (d
)) d
= COPYSIGN (0, d
);
1696 x
= INFINITY
* (a
* c
- b
* d
);
1697 y
= INFINITY
* (a
* d
+ b
* c
);
1703 #endif /* complex multiply */
1705 #if defined(L_divsc3) || defined(L_divdc3) \
1706 || defined(L_divxc3) || defined(L_divtc3)
1709 CONCAT3(__div
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
1711 MTYPE denom
, ratio
, x
, y
;
1713 /* ??? We can get better behavior from logarithmic scaling instead of
1714 the division. But that would mean starting to link libgcc against
1715 libm. We could implement something akin to ldexp/frexp as gcc builtins
1717 if (FABS (c
) < FABS (d
))
1720 denom
= (c
* ratio
) + d
;
1721 x
= ((a
* ratio
) + b
) / denom
;
1722 y
= ((b
* ratio
) - a
) / denom
;
1727 denom
= (d
* ratio
) + c
;
1728 x
= ((b
* ratio
) + a
) / denom
;
1729 y
= (b
- (a
* ratio
)) / denom
;
1732 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
1733 are nonzero/zero, infinite/finite, and finite/infinite. */
1734 if (isnan (x
) && isnan (y
))
1736 if (c
== 0.0 && d
== 0.0 && (!isnan (a
) || !isnan (b
)))
1738 x
= COPYSIGN (INFINITY
, c
) * a
;
1739 y
= COPYSIGN (INFINITY
, c
) * b
;
1741 else if ((isinf (a
) || isinf (b
)) && isfinite (c
) && isfinite (d
))
1743 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
1744 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
1745 x
= INFINITY
* (a
* c
+ b
* d
);
1746 y
= INFINITY
* (b
* c
- a
* d
);
1748 else if ((isinf (c
) || isinf (d
)) && isfinite (a
) && isfinite (b
))
1750 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
1751 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
1752 x
= 0.0 * (a
* c
+ b
* d
);
1753 y
= 0.0 * (b
* c
- a
* d
);
1759 #endif /* complex divide */
1761 #endif /* all complex float routines */
1763 /* From here on down, the routines use normal data types. */
1765 #define SItype bogus_type
1766 #define USItype bogus_type
1767 #define DItype bogus_type
1768 #define UDItype bogus_type
1769 #define SFtype bogus_type
1770 #define DFtype bogus_type
1788 /* Like bcmp except the sign is meaningful.
1789 Result is negative if S1 is less than S2,
1790 positive if S1 is greater, 0 if S1 and S2 are equal. */
1793 __gcc_bcmp (const unsigned char *s1
, const unsigned char *s2
, size_t size
)
1797 const unsigned char c1
= *s1
++, c2
= *s2
++;
1807 /* __eprintf used to be used by GCC's private version of <assert.h>.
1808 We no longer provide that header, but this routine remains in libgcc.a
1809 for binary backward compatibility. Note that it is not included in
1810 the shared version of libgcc. */
1812 #ifndef inhibit_libc
1814 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
1818 __eprintf (const char *string
, const char *expression
,
1819 unsigned int line
, const char *filename
)
1821 fprintf (stderr
, string
, expression
, line
, filename
);
1830 #ifdef L_clear_cache
1831 /* Clear part of an instruction cache. */
1834 __clear_cache (char *beg
__attribute__((__unused__
)),
1835 char *end
__attribute__((__unused__
)))
1837 #ifdef CLEAR_INSN_CACHE
1838 CLEAR_INSN_CACHE (beg
, end
);
1839 #endif /* CLEAR_INSN_CACHE */
1842 #endif /* L_clear_cache */
1844 #ifdef L_enable_execute_stack
1845 /* Attempt to turn on execute permission for the stack. */
1847 #ifdef ENABLE_EXECUTE_STACK
1848 ENABLE_EXECUTE_STACK
1851 __enable_execute_stack (void *addr
__attribute__((__unused__
)))
1853 #endif /* ENABLE_EXECUTE_STACK */
1855 #endif /* L_enable_execute_stack */
1859 /* Jump to a trampoline, loading the static chain address. */
1861 #if defined(WINNT) && ! defined(__CYGWIN__) && ! defined (_UWIN)
1874 extern int VirtualProtect (char *, int, int, int *) __attribute__((stdcall));
1878 mprotect (char *addr
, int len
, int prot
)
1895 if (VirtualProtect (addr
, len
, np
, &op
))
1901 #endif /* WINNT && ! __CYGWIN__ && ! _UWIN */
1903 #ifdef TRANSFER_FROM_TRAMPOLINE
1904 TRANSFER_FROM_TRAMPOLINE
1906 #endif /* L_trampoline */
1911 #include "gbl-ctors.h"
1913 /* Some systems use __main in a way incompatible with its use in gcc, in these
1914 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
1915 give the same symbol without quotes for an alternative entry point. You
1916 must define both, or neither. */
1918 #define NAME__MAIN "__main"
1919 #define SYMBOL__MAIN __main
1922 #if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP)
1923 #undef HAS_INIT_SECTION
1924 #define HAS_INIT_SECTION
1927 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
1929 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
1930 code to run constructors. In that case, we need to handle EH here, too. */
1932 #ifdef EH_FRAME_SECTION_NAME
1933 #include "unwind-dw2-fde.h"
1934 extern unsigned char __EH_FRAME_BEGIN__
[];
1937 /* Run all the global destructors on exit from the program. */
1940 __do_global_dtors (void)
1942 #ifdef DO_GLOBAL_DTORS_BODY
1943 DO_GLOBAL_DTORS_BODY
;
1945 static func_ptr
*p
= __DTOR_LIST__
+ 1;
1952 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
1954 static int completed
= 0;
1958 __deregister_frame_info (__EH_FRAME_BEGIN__
);
1965 #ifndef HAS_INIT_SECTION
1966 /* Run all the global constructors on entry to the program. */
1969 __do_global_ctors (void)
1971 #ifdef EH_FRAME_SECTION_NAME
1973 static struct object object
;
1974 __register_frame_info (__EH_FRAME_BEGIN__
, &object
);
1977 DO_GLOBAL_CTORS_BODY
;
1978 atexit (__do_global_dtors
);
1980 #endif /* no HAS_INIT_SECTION */
1982 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
1983 /* Subroutine called automatically by `main'.
1984 Compiling a global function named `main'
1985 produces an automatic call to this function at the beginning.
1987 For many systems, this routine calls __do_global_ctors.
1988 For systems which support a .init section we use the .init section
1989 to run __do_global_ctors, so we need not do anything here. */
1991 extern void SYMBOL__MAIN (void);
1995 /* Support recursive calls to `main': run initializers just once. */
1996 static int initialized
;
2000 __do_global_ctors ();
2003 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2005 #endif /* L__main */
2006 #endif /* __CYGWIN__ */
2010 #include "gbl-ctors.h"
2012 /* Provide default definitions for the lists of constructors and
2013 destructors, so that we don't get linker errors. These symbols are
2014 intentionally bss symbols, so that gld and/or collect will provide
2015 the right values. */
2017 /* We declare the lists here with two elements each,
2018 so that they are valid empty lists if no other definition is loaded.
2020 If we are using the old "set" extensions to have the gnu linker
2021 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2022 must be in the bss/common section.
2024 Long term no port should use those extensions. But many still do. */
2025 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2026 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2027 func_ptr __CTOR_LIST__
[2] = {0, 0};
2028 func_ptr __DTOR_LIST__
[2] = {0, 0};
2030 func_ptr __CTOR_LIST__
[2];
2031 func_ptr __DTOR_LIST__
[2];
2033 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2034 #endif /* L_ctors */
2035 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */