1 /* More subroutines needed by GCC output code on some machines. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2024 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
)
80 if (__builtin_add_overflow (a
, b
, &w
))
85 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
87 __addvsi3 (SItype a
, SItype b
)
91 if (__builtin_add_overflow (a
, b
, &w
))
96 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
101 __addvDI3 (DWtype a
, DWtype b
)
105 if (__builtin_add_overflow (a
, b
, &w
))
114 __subvSI3 (Wtype a
, Wtype b
)
118 if (__builtin_sub_overflow (a
, b
, &w
))
123 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
125 __subvsi3 (SItype a
, SItype b
)
129 if (__builtin_sub_overflow (a
, b
, &w
))
134 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
139 __subvDI3 (DWtype a
, DWtype b
)
143 if (__builtin_sub_overflow (a
, b
, &w
))
152 __mulvSI3 (Wtype a
, Wtype b
)
156 if (__builtin_mul_overflow (a
, b
, &w
))
161 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
163 __mulvsi3 (SItype a
, SItype b
)
167 if (__builtin_mul_overflow (a
, b
, &w
))
172 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
181 if (__builtin_sub_overflow (0, a
, &w
))
186 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
192 if (__builtin_sub_overflow (0, a
, &w
))
197 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
206 if (__builtin_sub_overflow (0, a
, &w
))
217 const Wtype v
= 0 - (a
< 0);
220 if (__builtin_add_overflow (a
, v
, &w
))
225 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
229 const SItype v
= 0 - (a
< 0);
232 if (__builtin_add_overflow (a
, v
, &w
))
237 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
244 const DWtype v
= 0 - (a
< 0);
247 if (__builtin_add_overflow (a
, v
, &w
))
256 __mulvDI3 (DWtype u
, DWtype v
)
258 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
259 but the checked multiplication needs only two. */
260 const DWunion uu
= {.ll
= u
};
261 const DWunion vv
= {.ll
= v
};
263 if (__builtin_expect (uu
.s
.high
== uu
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
265 /* u fits in a single Wtype. */
266 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
268 /* v fits in a single Wtype as well. */
269 /* A single multiplication. No overflow risk. */
270 return (DWtype
) uu
.s
.low
* (DWtype
) vv
.s
.low
;
274 /* Two multiplications. */
275 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
276 * (UDWtype
) (UWtype
) vv
.s
.low
};
277 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
278 * (UDWtype
) (UWtype
) vv
.s
.high
};
281 w1
.s
.high
-= uu
.s
.low
;
284 w1
.ll
+= (UWtype
) w0
.s
.high
;
285 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
287 w0
.s
.high
= w1
.s
.low
;
294 if (__builtin_expect (vv
.s
.high
== vv
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
296 /* v fits into a single Wtype. */
297 /* Two multiplications. */
298 DWunion w0
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
299 * (UDWtype
) (UWtype
) vv
.s
.low
};
300 DWunion w1
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.high
301 * (UDWtype
) (UWtype
) vv
.s
.low
};
304 w1
.s
.high
-= vv
.s
.low
;
307 w1
.ll
+= (UWtype
) w0
.s
.high
;
308 if (__builtin_expect (w1
.s
.high
== w1
.s
.low
>> (W_TYPE_SIZE
- 1), 1))
310 w0
.s
.high
= w1
.s
.low
;
316 /* A few sign checks and a single multiplication. */
321 if (uu
.s
.high
== 0 && vv
.s
.high
== 0)
323 const DWtype w
= (UDWtype
) (UWtype
) uu
.s
.low
324 * (UDWtype
) (UWtype
) vv
.s
.low
;
325 if (__builtin_expect (w
>= 0, 1))
331 if (uu
.s
.high
== 0 && vv
.s
.high
== (Wtype
) -1)
333 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
334 * (UDWtype
) (UWtype
) vv
.s
.low
};
336 ww
.s
.high
-= uu
.s
.low
;
337 if (__builtin_expect (ww
.s
.high
< 0, 1))
346 if (uu
.s
.high
== (Wtype
) -1 && vv
.s
.high
== 0)
348 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
349 * (UDWtype
) (UWtype
) vv
.s
.low
};
351 ww
.s
.high
-= vv
.s
.low
;
352 if (__builtin_expect (ww
.s
.high
< 0, 1))
358 if ((uu
.s
.high
& vv
.s
.high
) == (Wtype
) -1
359 && (uu
.s
.low
| vv
.s
.low
) != 0)
361 DWunion ww
= {.ll
= (UDWtype
) (UWtype
) uu
.s
.low
362 * (UDWtype
) (UWtype
) vv
.s
.low
};
364 ww
.s
.high
-= uu
.s
.low
;
365 ww
.s
.high
-= vv
.s
.low
;
366 if (__builtin_expect (ww
.s
.high
>= 0, 1))
380 /* Unless shift functions are defined with full ANSI prototypes,
381 parameter b will be promoted to int if shift_count_type is smaller than an int. */
384 __lshrdi3 (DWtype u
, shift_count_type b
)
389 const DWunion uu
= {.ll
= u
};
390 const shift_count_type bm
= W_TYPE_SIZE
- b
;
396 w
.s
.low
= (UWtype
) uu
.s
.high
>> -bm
;
400 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
402 w
.s
.high
= (UWtype
) uu
.s
.high
>> b
;
403 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
412 __ashldi3 (DWtype u
, shift_count_type b
)
417 const DWunion uu
= {.ll
= u
};
418 const shift_count_type bm
= W_TYPE_SIZE
- b
;
424 w
.s
.high
= (UWtype
) uu
.s
.low
<< -bm
;
428 const UWtype carries
= (UWtype
) uu
.s
.low
>> bm
;
430 w
.s
.low
= (UWtype
) uu
.s
.low
<< b
;
431 w
.s
.high
= ((UWtype
) uu
.s
.high
<< b
) | carries
;
440 __ashrdi3 (DWtype u
, shift_count_type b
)
445 const DWunion uu
= {.ll
= u
};
446 const shift_count_type bm
= W_TYPE_SIZE
- b
;
451 /* w.s.high = 1..1 or 0..0 */
452 w
.s
.high
= uu
.s
.high
>> (W_TYPE_SIZE
- 1);
453 w
.s
.low
= uu
.s
.high
>> -bm
;
457 const UWtype carries
= (UWtype
) uu
.s
.high
<< bm
;
459 w
.s
.high
= uu
.s
.high
>> b
;
460 w
.s
.low
= ((UWtype
) uu
.s
.low
>> b
) | carries
;
469 __bswapsi2 (SItype u
)
471 return ((((u
) & 0xff000000u
) >> 24)
472 | (((u
) & 0x00ff0000u
) >> 8)
473 | (((u
) & 0x0000ff00u
) << 8)
474 | (((u
) & 0x000000ffu
) << 24));
479 __bswapdi2 (DItype u
)
481 return ((((u
) & 0xff00000000000000ull
) >> 56)
482 | (((u
) & 0x00ff000000000000ull
) >> 40)
483 | (((u
) & 0x0000ff0000000000ull
) >> 24)
484 | (((u
) & 0x000000ff00000000ull
) >> 8)
485 | (((u
) & 0x00000000ff000000ull
) << 8)
486 | (((u
) & 0x0000000000ff0000ull
) << 24)
487 | (((u
) & 0x000000000000ff00ull
) << 40)
488 | (((u
) & 0x00000000000000ffull
) << 56));
501 count_trailing_zeros (count
, u
);
511 const DWunion uu
= {.ll
= u
};
512 UWtype word
, count
, add
;
515 word
= uu
.s
.low
, add
= 0;
516 else if (uu
.s
.high
!= 0)
517 word
= uu
.s
.high
, add
= W_TYPE_SIZE
;
521 count_trailing_zeros (count
, word
);
522 return count
+ add
+ 1;
528 __muldi3 (DWtype u
, DWtype v
)
530 const DWunion uu
= {.ll
= u
};
531 const DWunion vv
= {.ll
= v
};
532 DWunion w
= {.ll
= __umulsidi3 (uu
.s
.low
, vv
.s
.low
)};
534 w
.s
.high
+= ((UWtype
) uu
.s
.low
* (UWtype
) vv
.s
.high
535 + (UWtype
) uu
.s
.high
* (UWtype
) vv
.s
.low
);
541 #if (defined (L_udivdi3) || defined (L_divdi3) || \
542 defined (L_umoddi3) || defined (L_moddi3))
543 #if defined (sdiv_qrnnd)
544 #define L_udiv_w_sdiv
549 #if defined (sdiv_qrnnd)
550 #if (defined (L_udivdi3) || defined (L_divdi3) || \
551 defined (L_umoddi3) || defined (L_moddi3))
552 static inline __attribute__ ((__always_inline__
))
555 __udiv_w_sdiv (UWtype
*rp
, UWtype a1
, UWtype a0
, UWtype d
)
562 if (a1
< d
- a1
- (a0
>> (W_TYPE_SIZE
- 1)))
564 /* Dividend, divisor, and quotient are nonnegative. */
565 sdiv_qrnnd (q
, r
, a1
, a0
, d
);
569 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
570 sub_ddmmss (c1
, c0
, a1
, a0
, d
>> 1, d
<< (W_TYPE_SIZE
- 1));
571 /* Divide (c1*2^32 + c0) by d. */
572 sdiv_qrnnd (q
, r
, c1
, c0
, d
);
573 /* Add 2^31 to quotient. */
574 q
+= (UWtype
) 1 << (W_TYPE_SIZE
- 1);
579 b1
= d
>> 1; /* d/2, between 2^30 and 2^31 - 1 */
580 c1
= a1
>> 1; /* A/2 */
581 c0
= (a1
<< (W_TYPE_SIZE
- 1)) + (a0
>> 1);
583 if (a1
< b1
) /* A < 2^32*b1, so A/2 < 2^31*b1 */
585 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
587 r
= 2*r
+ (a0
& 1); /* Remainder from A/(2*b1) */
604 else if (c1
< b1
) /* So 2^31 <= (A/2)/b1 < 2^32 */
607 c0
= ~c0
; /* logical NOT */
609 sdiv_qrnnd (q
, r
, c1
, c0
, b1
); /* (A/2) / (d/2) */
611 q
= ~q
; /* (A/2)/b1 */
614 r
= 2*r
+ (a0
& 1); /* A/(2*b1) */
632 else /* Implies c1 = b1 */
633 { /* Hence a1 = d - 1 = 2*b1 - 1 */
651 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
653 __udiv_w_sdiv (UWtype
*rp
__attribute__ ((__unused__
)),
654 UWtype a1
__attribute__ ((__unused__
)),
655 UWtype a0
__attribute__ ((__unused__
)),
656 UWtype d
__attribute__ ((__unused__
)))
663 #if (defined (L_udivdi3) || defined (L_divdi3) || \
664 defined (L_umoddi3) || defined (L_moddi3) || \
665 defined (L_divmoddi4))
670 const UQItype __clz_tab
[256] =
672 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,
673 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,
674 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,
675 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,
676 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,
677 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,
678 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,
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
690 count_leading_zeros (ret
, x
);
701 const DWunion uu
= {.ll
= x
};
706 word
= uu
.s
.high
, add
= 0;
708 word
= uu
.s
.low
, add
= W_TYPE_SIZE
;
710 count_leading_zeros (ret
, word
);
722 count_trailing_zeros (ret
, x
);
733 const DWunion uu
= {.ll
= x
};
738 word
= uu
.s
.low
, add
= 0;
740 word
= uu
.s
.high
, add
= W_TYPE_SIZE
;
742 count_trailing_zeros (ret
, word
);
757 return W_TYPE_SIZE
- 1;
758 count_leading_zeros (ret
, x
);
766 __clrsbDI2 (DWtype x
)
768 const DWunion uu
= {.ll
= x
};
773 word
= uu
.s
.low
, add
= W_TYPE_SIZE
;
774 else if (uu
.s
.high
== -1)
775 word
= ~uu
.s
.low
, add
= W_TYPE_SIZE
;
776 else if (uu
.s
.high
>= 0)
777 word
= uu
.s
.high
, add
= 0;
779 word
= ~uu
.s
.high
, add
= 0;
784 count_leading_zeros (ret
, word
);
786 return ret
+ add
- 1;
790 #ifdef L_popcount_tab
791 const UQItype __popcount_tab
[256] =
793 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,
794 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,
795 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,
796 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,
797 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,
798 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,
799 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,
800 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
804 #if defined(L_popcountsi2) || defined(L_popcountdi2)
805 #define POPCOUNTCST2(x) (((UWtype) x << __CHAR_BIT__) | x)
806 #define POPCOUNTCST4(x) (((UWtype) x << (2 * __CHAR_BIT__)) | x)
807 #define POPCOUNTCST8(x) (((UWtype) x << (4 * __CHAR_BIT__)) | x)
808 #if W_TYPE_SIZE == __CHAR_BIT__
809 #define POPCOUNTCST(x) x
810 #elif W_TYPE_SIZE == 2 * __CHAR_BIT__
811 #define POPCOUNTCST(x) POPCOUNTCST2 (x)
812 #elif W_TYPE_SIZE == 4 * __CHAR_BIT__
813 #define POPCOUNTCST(x) POPCOUNTCST4 (POPCOUNTCST2 (x))
814 #elif W_TYPE_SIZE == 8 * __CHAR_BIT__
815 #define POPCOUNTCST(x) POPCOUNTCST8 (POPCOUNTCST4 (POPCOUNTCST2 (x)))
822 __popcountSI2 (UWtype x
)
824 /* Force table lookup on targets like AVR and RL78 which only
825 pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
826 have 1, and other small word targets. */
827 #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && __CHAR_BIT__ == 8
828 x
= x
- ((x
>> 1) & POPCOUNTCST (0x55));
829 x
= (x
& POPCOUNTCST (0x33)) + ((x
>> 2) & POPCOUNTCST (0x33));
830 x
= (x
+ (x
>> 4)) & POPCOUNTCST (0x0F);
831 return (x
* POPCOUNTCST (0x01)) >> (W_TYPE_SIZE
- __CHAR_BIT__
);
835 for (i
= 0; i
< W_TYPE_SIZE
; i
+= 8)
836 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
846 __popcountDI2 (UDWtype x
)
848 /* Force table lookup on targets like AVR and RL78 which only
849 pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
850 have 1, and other small word targets. */
851 #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && __CHAR_BIT__ == 8
852 const DWunion uu
= {.ll
= x
};
853 UWtype x1
= uu
.s
.low
, x2
= uu
.s
.high
;
854 x1
= x1
- ((x1
>> 1) & POPCOUNTCST (0x55));
855 x2
= x2
- ((x2
>> 1) & POPCOUNTCST (0x55));
856 x1
= (x1
& POPCOUNTCST (0x33)) + ((x1
>> 2) & POPCOUNTCST (0x33));
857 x2
= (x2
& POPCOUNTCST (0x33)) + ((x2
>> 2) & POPCOUNTCST (0x33));
858 x1
= (x1
+ (x1
>> 4)) & POPCOUNTCST (0x0F);
859 x2
= (x2
+ (x2
>> 4)) & POPCOUNTCST (0x0F);
861 return (x1
* POPCOUNTCST (0x01)) >> (W_TYPE_SIZE
- __CHAR_BIT__
);
865 for (i
= 0; i
< 2*W_TYPE_SIZE
; i
+= 8)
866 ret
+= __popcount_tab
[(x
>> i
) & 0xff];
876 __paritySI2 (UWtype x
)
879 # error "fill out the table"
890 return (0x6996 >> x
) & 1;
897 __parityDI2 (UDWtype x
)
899 const DWunion uu
= {.ll
= x
};
900 UWtype nx
= uu
.s
.low
^ uu
.s
.high
;
903 # error "fill out the table"
914 return (0x6996 >> nx
) & 1;
919 #ifdef TARGET_HAS_NO_HW_DIVIDE
921 #if (defined (L_udivdi3) || defined (L_divdi3) || \
922 defined (L_umoddi3) || defined (L_moddi3) || \
923 defined (L_divmoddi4))
924 static inline __attribute__ ((__always_inline__
))
927 __udivmoddi4 (UDWtype n
, UDWtype d
, UDWtype
*rp
)
929 UDWtype q
= 0, r
= n
, y
= d
;
930 UWtype lz1
, lz2
, i
, k
;
932 /* Implements align divisor shift dividend method. This algorithm
933 aligns the divisor under the dividend and then perform number of
934 test-subtract iterations which shift the dividend left. Number of
935 iterations is k + 1 where k is the number of bit positions the
936 divisor must be shifted left to align it under the dividend.
937 quotient bits can be saved in the rightmost positions of the dividend
938 as it shifts left on each test-subtract iteration. */
942 lz1
= __builtin_clzll (d
);
943 lz2
= __builtin_clzll (n
);
948 /* Dividend can exceed 2 ^ (width - 1) - 1 but still be less than the
949 aligned divisor. Normal iteration can drops the high order bit
950 of the dividend. Therefore, first test-subtract iteration is a
951 special case, saving its quotient bit in a separate location and
952 not shifting the dividend. */
963 /* k additional iterations where k regular test subtract shift
964 dividend iterations are done. */
969 r
= ((r
- y
) << 1) + 1;
975 /* First quotient bit is combined with the quotient bits resulting
976 from the k regular iterations. */
989 #if (defined (L_udivdi3) || defined (L_divdi3) || \
990 defined (L_umoddi3) || defined (L_moddi3) || \
991 defined (L_divmoddi4))
992 static inline __attribute__ ((__always_inline__
))
995 __udivmoddi4 (UDWtype n
, UDWtype d
, UDWtype
*rp
)
997 const DWunion nn
= {.ll
= n
};
998 const DWunion dd
= {.ll
= d
};
1000 UWtype d0
, d1
, n0
, n1
, n2
;
1009 #if !UDIV_NEEDS_NORMALIZATION
1016 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
1019 /* Remainder in n0. */
1026 d0
= 1 / d0
; /* Divide intentionally by zero. */
1028 udiv_qrnnd (q1
, n1
, 0, n1
, d0
);
1029 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
1031 /* Remainder in n0. */
1042 #else /* UDIV_NEEDS_NORMALIZATION */
1050 count_leading_zeros (bm
, d0
);
1054 /* Normalize, i.e. make the most significant bit of the
1058 n1
= (n1
<< bm
) | (n0
>> (W_TYPE_SIZE
- bm
));
1062 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
1065 /* Remainder in n0 >> bm. */
1072 d0
= 1 / d0
; /* Divide intentionally by zero. */
1074 count_leading_zeros (bm
, d0
);
1078 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
1079 conclude (the most significant bit of n1 is set) /\ (the
1080 leading quotient digit q1 = 1).
1082 This special case is necessary, not an optimization.
1083 (Shifts counts of W_TYPE_SIZE are undefined.) */
1092 b
= W_TYPE_SIZE
- bm
;
1096 n1
= (n1
<< bm
) | (n0
>> b
);
1099 udiv_qrnnd (q1
, n1
, n2
, n1
, d0
);
1104 udiv_qrnnd (q0
, n0
, n1
, n0
, d0
);
1106 /* Remainder in n0 >> bm. */
1111 rr
.s
.low
= n0
>> bm
;
1116 #endif /* UDIV_NEEDS_NORMALIZATION */
1127 /* Remainder in n1n0. */
1139 count_leading_zeros (bm
, d1
);
1142 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
1143 conclude (the most significant bit of n1 is set) /\ (the
1144 quotient digit q0 = 0 or 1).
1146 This special case is necessary, not an optimization. */
1148 /* The condition on the next line takes advantage of that
1149 n1 >= d1 (true due to program flow). */
1150 if (n1
> d1
|| n0
>= d0
)
1153 sub_ddmmss (n1
, n0
, n1
, n0
, d1
, d0
);
1172 b
= W_TYPE_SIZE
- bm
;
1174 d1
= (d1
<< bm
) | (d0
>> b
);
1177 n1
= (n1
<< bm
) | (n0
>> b
);
1180 udiv_qrnnd (q0
, n1
, n2
, n1
, d1
);
1181 umul_ppmm (m1
, m0
, q0
, d0
);
1183 if (m1
> n1
|| (m1
== n1
&& m0
> n0
))
1186 sub_ddmmss (m1
, m0
, m1
, m0
, d1
, d0
);
1191 /* Remainder in (n1n0 - m1m0) >> bm. */
1194 sub_ddmmss (n1
, n0
, n1
, n0
, m1
, m0
);
1195 rr
.s
.low
= (n1
<< b
) | (n0
>> bm
);
1196 rr
.s
.high
= n1
>> bm
;
1203 const DWunion ww
= {{.low
= q0
, .high
= q1
}};
1211 __divdi3 (DWtype u
, DWtype v
)
1214 DWunion uu
= {.ll
= u
};
1215 DWunion vv
= {.ll
= v
};
1225 w
= __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*) 0);
1235 __moddi3 (DWtype u
, DWtype v
)
1238 DWunion uu
= {.ll
= u
};
1239 DWunion vv
= {.ll
= v
};
1248 (void) __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*)&w
);
1258 __divmoddi4 (DWtype u
, DWtype v
, DWtype
*rp
)
1260 Wtype c1
= 0, c2
= 0;
1261 DWunion uu
= {.ll
= u
};
1262 DWunion vv
= {.ll
= v
};
1273 w
= __udivmoddi4 (uu
.ll
, vv
.ll
, (UDWtype
*)&r
);
1286 __umoddi3 (UDWtype u
, UDWtype v
)
1290 (void) __udivmoddi4 (u
, v
, &w
);
1298 __udivdi3 (UDWtype n
, UDWtype d
)
1300 return __udivmoddi4 (n
, d
, (UDWtype
*) 0);
1304 #if (defined(__BITINT_MAXWIDTH__) \
1305 && (defined(L_mulbitint3) || defined(L_divmodbitint4)))
1306 /* _BitInt support. */
1308 /* If *P is zero or sign extended (the latter only for PREC < 0) from
1309 some narrower _BitInt value, reduce precision. */
1311 static inline __attribute__((__always_inline__
)) SItype
1312 bitint_reduce_prec (const UBILtype
**p
, SItype prec
)
1318 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1321 i
= ((USItype
) -1 - prec
) / W_TYPE_SIZE
;
1324 if (mslimb
& ((UWtype
) 1 << (((USItype
) -1 - prec
) % W_TYPE_SIZE
)))
1326 SItype n
= ((USItype
) -prec
) % W_TYPE_SIZE
;
1329 mslimb
|= ((UWtype
) -1 << (((USItype
) -1 - prec
) % W_TYPE_SIZE
));
1330 if (mslimb
== (UWtype
) -1)
1335 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1344 while (mslimb
== (UWtype
) -1)
1346 prec
+= W_TYPE_SIZE
;
1349 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1358 if ((Wtype
) mslimb
>= 0)
1360 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1373 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1376 i
= ((USItype
) prec
- 1) / W_TYPE_SIZE
;
1380 SItype n
= ((USItype
) prec
) % W_TYPE_SIZE
;
1383 mslimb
&= ((UWtype
) 1 << (((USItype
) prec
) % W_TYPE_SIZE
)) - 1;
1389 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1399 prec
-= W_TYPE_SIZE
;
1402 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1412 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1413 # define BITINT_INC -1
1414 # define BITINT_END(be, le) (be)
1416 # define BITINT_INC 1
1417 # define BITINT_END(be, le) (le)
1424 bitint_mul_1 (UBILtype
*d
, const UBILtype
*s
, UWtype l
, SItype n
)
1426 UWtype sv
, hi
, lo
, c
= 0;
1431 umul_ppmm (hi
, lo
, sv
, l
);
1432 c
= __builtin_add_overflow (lo
, c
, &lo
) + hi
;
1443 bitint_addmul_1 (UBILtype
*d
, const UBILtype
*s
, UWtype l
, SItype n
)
1445 UWtype sv
, hi
, lo
, c
= 0;
1450 umul_ppmm (hi
, lo
, sv
, l
);
1451 hi
+= __builtin_add_overflow (lo
, *d
, &lo
);
1452 c
= __builtin_add_overflow (lo
, c
, &lo
) + hi
;
1460 /* If XPREC is positive, it is precision in bits
1461 of an unsigned _BitInt operand (which has XPREC/W_TYPE_SIZE
1462 full limbs and if Xprec%W_TYPE_SIZE one partial limb.
1463 If Xprec is negative, -XPREC is precision in bits
1464 of a signed _BitInt operand. RETPREC should be always
1468 __mulbitint3 (UBILtype
*ret
, SItype retprec
,
1469 const UBILtype
*u
, SItype uprec
,
1470 const UBILtype
*v
, SItype vprec
)
1472 uprec
= bitint_reduce_prec (&u
, uprec
);
1473 vprec
= bitint_reduce_prec (&v
, vprec
);
1474 USItype auprec
= uprec
< 0 ? -uprec
: uprec
;
1475 USItype avprec
= vprec
< 0 ? -vprec
: vprec
;
1477 /* Prefer non-negative U.
1478 Otherwise make sure V doesn't have higher precision than U. */
1479 if ((uprec
< 0 && vprec
>= 0)
1480 || (avprec
> auprec
&& !(uprec
>= 0 && vprec
< 0)))
1484 p
= uprec
; uprec
= vprec
; vprec
= p
;
1485 p
= auprec
; auprec
= avprec
; avprec
= p
;
1486 t
= u
; u
= v
; v
= t
;
1489 USItype un
= auprec
/ W_TYPE_SIZE
;
1490 USItype un2
= (auprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1491 USItype vn
= avprec
/ W_TYPE_SIZE
;
1492 USItype vn2
= (avprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1493 USItype retn
= ((USItype
) retprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1494 USItype retidx
, uidx
, vidx
;
1496 /* Indexes of least significant limb. */
1497 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1506 if (__builtin_expect (auprec
<= W_TYPE_SIZE
, 0) && vprec
< 0)
1508 UWtype uu
= u
[uidx
];
1509 if (__builtin_expect (auprec
< W_TYPE_SIZE
, 0))
1510 uu
&= ((UWtype
) 1 << (auprec
% W_TYPE_SIZE
)) - 1;
1513 /* 0 * negative would be otherwise mishandled below, so
1514 handle it specially. */
1515 __builtin_memset (ret
, 0, retn
* sizeof (UWtype
));
1520 if (__builtin_expect (avprec
< W_TYPE_SIZE
, 0))
1523 vv
&= ((UWtype
) 1 << (avprec
% W_TYPE_SIZE
)) - 1;
1525 vv
|= (UWtype
) -1 << (avprec
% W_TYPE_SIZE
);
1528 USItype n
= un
> retn
? retn
: un
;
1530 USItype retidx2
= retidx
+ n
* BITINT_INC
;
1531 UWtype c
= 0, uv
= 0;
1533 c
= bitint_mul_1 (ret
+ retidx
, u
+ uidx
, vv
, n
);
1534 if (retn
> un
&& un2
!= un
)
1537 uv
= u
[uidx
+ n
* BITINT_INC
];
1539 uv
&= ((UWtype
) 1 << (auprec
% W_TYPE_SIZE
)) - 1;
1541 uv
|= (UWtype
) -1 << (auprec
% W_TYPE_SIZE
);
1542 umul_ppmm (hi
, lo
, uv
, vv
);
1543 c
= __builtin_add_overflow (lo
, c
, &lo
) + hi
;
1545 retidx2
+= BITINT_INC
;
1554 if (n2
>= un2
+ vn2
)
1557 umul_ppmm (hi
, lo
, (UWtype
) -1, vv
);
1558 c
= __builtin_add_overflow (lo
, c
, &lo
) + hi
;
1560 retidx2
+= BITINT_INC
;
1567 retidx2
+= BITINT_INC
;
1570 /* If RET has more limbs than U after precision reduction,
1571 fill in the remaining limbs. */
1574 if (n2
< un2
+ vn2
|| (uprec
^ vprec
) >= 0)
1579 retidx2
+= BITINT_INC
;
1583 /* N is now number of possibly non-zero limbs in RET (ignoring
1584 limbs above UN2 + VN2 which if any have been finalized already). */
1585 USItype end
= vprec
< 0 ? un2
+ vn2
: vn2
;
1586 if (retn
> un2
+ vn2
) retn
= un2
+ vn2
;
1587 if (end
> retn
) end
= retn
;
1588 for (USItype m
= 1; m
< end
; ++m
)
1590 retidx
+= BITINT_INC
;
1595 if (__builtin_expect (m
== vn
, 0))
1598 vv
&= ((UWtype
) 1 << (avprec
% W_TYPE_SIZE
)) - 1;
1600 vv
|= (UWtype
) -1 << (avprec
% W_TYPE_SIZE
);
1609 c
= bitint_addmul_1 (ret
+ retidx
, u
+ uidx
, vv
, n
);
1611 retidx2
= retidx
+ n
* BITINT_INC
;
1612 if (n2
< retn
&& un2
!= un
)
1615 umul_ppmm (hi
, lo
, uv
, vv
);
1616 hi
+= __builtin_add_overflow (lo
, ret
[retidx2
], &lo
);
1617 c
= __builtin_add_overflow (lo
, c
, &lo
) + hi
;
1619 retidx2
+= BITINT_INC
;
1626 umul_ppmm (hi
, lo
, (UWtype
) -1, vv
);
1627 hi
+= __builtin_add_overflow (lo
, ret
[retidx2
], &lo
);
1628 c
= __builtin_add_overflow (lo
, c
, &lo
) + hi
;
1630 retidx2
+= BITINT_INC
;
1636 retidx2
+= BITINT_INC
;
1642 #ifdef L_divmodbitint4
1646 bitint_negate (UBILtype
*d
, const UBILtype
*s
, SItype n
)
1655 c
= __builtin_add_overflow (~sv
, c
, &lo
);
1666 bitint_submul_1 (UBILtype
*d
, const UBILtype
*s
, UWtype l
, SItype n
)
1668 UWtype sv
, hi
, lo
, c
= 0;
1673 umul_ppmm (hi
, lo
, sv
, l
);
1674 hi
+= __builtin_sub_overflow (*d
, lo
, &lo
);
1675 c
= __builtin_sub_overflow (lo
, c
, &lo
) + hi
;
1683 /* If XPREC is positive, it is precision in bits
1684 of an unsigned _BitInt operand (which has XPREC/W_TYPE_SIZE
1685 full limbs and if Xprec%W_TYPE_SIZE one partial limb.
1686 If Xprec is negative, -XPREC is precision in bits
1687 of a signed _BitInt operand. QPREC and RPREC should be
1688 always non-negative. If either Q or R is NULL (at least
1689 one should be non-NULL), then corresponding QPREC or RPREC
1693 __divmodbitint4 (UBILtype
*q
, SItype qprec
,
1694 UBILtype
*r
, SItype rprec
,
1695 const UBILtype
*u
, SItype uprec
,
1696 const UBILtype
*v
, SItype vprec
)
1698 uprec
= bitint_reduce_prec (&u
, uprec
);
1699 vprec
= bitint_reduce_prec (&v
, vprec
);
1700 USItype auprec
= uprec
< 0 ? -uprec
: uprec
;
1701 USItype avprec
= vprec
< 0 ? -vprec
: vprec
;
1702 USItype un
= (auprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1703 USItype vn
= (avprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1704 USItype qn
= ((USItype
) qprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1705 USItype rn
= ((USItype
) rprec
+ W_TYPE_SIZE
- 1) / W_TYPE_SIZE
;
1706 USItype up
= auprec
% W_TYPE_SIZE
;
1707 USItype vp
= avprec
% W_TYPE_SIZE
;
1708 /* If vprec < 0 and the top limb of v is all ones and the second most
1709 significant limb has most significant bit clear, then just decrease
1710 vn/avprec/vp, because after negation otherwise v2 would have most
1711 significant limb clear. */
1713 && ((v
[BITINT_END (0, vn
- 1)] | (vp
? ((UWtype
) -1 << vp
) : 0))
1716 && (Wtype
) v
[BITINT_END (1, vn
- 2)] >= 0)
1718 /* Unless all bits below the most significant limb are zero. */
1720 for (vn2
= vn
- 2; vn2
>= 0; --vn2
)
1721 if (v
[BITINT_END (vn
- 1 - vn2
, vn2
)])
1725 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1731 if (__builtin_expect (un
< vn
, 0))
1733 /* q is 0 and r is u. */
1735 __builtin_memset (q
, 0, qn
* sizeof (UWtype
));
1738 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1746 for (rn
-= un
; un
; --un
)
1757 *r
= *u
& (((UWtype
) 1 << up
) - 1);
1759 *r
= *u
| ((UWtype
) -1 << up
);
1764 UWtype c
= uprec
< 0 ? (UWtype
) -1 : (UWtype
) 0;
1772 USItype qn2
= un
- vn
+ 1;
1775 USItype sz
= un
+ 1 + vn
+ qn2
;
1776 UBILtype
*buf
= __builtin_alloca (sz
* sizeof (UWtype
));
1778 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1786 bitint_negate (buf
+ BITINT_END (uidx
+ 1, 0), u
+ uidx
, un
);
1788 __builtin_memcpy (buf
+ BITINT_END (1, 0), u
, un
* sizeof (UWtype
));
1790 buf
[BITINT_END (1, un
- 1)] &= (((UWtype
) 1 << up
) - 1);
1792 bitint_negate (buf
+ un
+ 1 + vidx
, v
+ vidx
, vn
);
1794 __builtin_memcpy (buf
+ un
+ 1, v
, vn
* sizeof (UWtype
));
1796 buf
[un
+ 1 + BITINT_END (0, vn
- 1)] &= (((UWtype
) 1 << vp
) - 1);
1798 UBILtype
*v2
= u2
+ un
+ 1;
1799 UBILtype
*q2
= v2
+ vn
;
1801 q2
= q
+ BITINT_END (qn
- (un
- vn
+ 1), 0);
1803 /* Knuth's algorithm. See also ../gcc/wide-int.cc (divmod_internal_2). */
1805 #ifndef UDIV_NEEDS_NORMALIZATION
1806 /* Handle single limb divisor first. */
1811 vv
= 1 / vv
; /* Divide intentionally by zero. */
1813 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1814 for (SItype i
= 0; i
<= un
- 1; ++i
)
1816 for (SItype i
= un
- 1; i
>= 0; --i
)
1818 udiv_qrnnd (q2
[i
], k
, k
, u2
[BITINT_END (i
+ 1, i
)], vv
);
1820 r
[BITINT_END (rn
- 1, 0)] = k
;
1826 #ifdef UDIV_NEEDS_NORMALIZATION
1827 if (vn
== 1 && v2
[0] == 0)
1831 if (sizeof (0U) == sizeof (UWtype
))
1832 s
= __builtin_clz (v2
[BITINT_END (0, vn
- 1)]);
1833 else if (sizeof (0UL) == sizeof (UWtype
))
1834 s
= __builtin_clzl (v2
[BITINT_END (0, vn
- 1)]);
1836 s
= __builtin_clzll (v2
[BITINT_END (0, vn
- 1)]);
1839 /* Normalize by shifting v2 left so that it has msb set. */
1840 const SItype n
= sizeof (UWtype
) * __CHAR_BIT__
;
1841 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1842 for (SItype i
= 0; i
< vn
- 1; ++i
)
1844 for (SItype i
= vn
- 1; i
> 0; --i
)
1846 v2
[i
] = (v2
[i
] << s
) | (v2
[i
- BITINT_INC
] >> (n
- s
));
1847 v2
[vidx
] = v2
[vidx
] << s
;
1848 /* And shift u2 left by the same amount. */
1849 u2
[BITINT_END (0, un
)] = u2
[BITINT_END (1, un
- 1)] >> (n
- s
);
1850 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1851 for (SItype i
= 1; i
< un
; ++i
)
1853 for (SItype i
= un
- 1; i
> 0; --i
)
1855 u2
[i
] = (u2
[i
] << s
) | (u2
[i
- BITINT_INC
] >> (n
- s
));
1856 u2
[BITINT_END (un
, 0)] = u2
[BITINT_END (un
, 0)] << s
;
1859 u2
[BITINT_END (0, un
)] = 0;
1860 #ifdef UDIV_NEEDS_NORMALIZATION
1861 /* Handle single limb divisor first. */
1866 vv
= 1 / vv
; /* Divide intentionally by zero. */
1867 UWtype k
= u2
[BITINT_END (0, un
)];
1868 #if __LIBGCC_BITINT_ORDER__ == __ORDER_BIG_ENDIAN__
1869 for (SItype i
= 0; i
<= un
- 1; ++i
)
1871 for (SItype i
= un
- 1; i
>= 0; --i
)
1873 udiv_qrnnd (q2
[i
], k
, k
, u2
[BITINT_END (i
+ 1, i
)], vv
);
1875 r
[BITINT_END (rn
- 1, 0)] = k
>> s
;
1880 UWtype vv1
= v2
[BITINT_END (0, vn
- 1)];
1881 UWtype vv0
= v2
[BITINT_END (1, vn
- 2)];
1883 for (SItype j
= un
- vn
; j
>= 0; --j
)
1885 /* Compute estimate in qhat. */
1886 UWtype uv1
= u2
[BITINT_END (un
- j
- vn
, j
+ vn
)];
1887 UWtype uv0
= u2
[BITINT_END (un
- j
- vn
+ 1, j
+ vn
- 1)];
1888 UWtype qhat
, rhat
, hi
, lo
, c
;
1891 /* udiv_qrnnd doesn't support quotients which don't
1892 fit into UWtype, while Knuth's algorithm originally
1893 uses a double-word by word to double-word division.
1894 Fortunately, the algorithm guarantees that uv1 <= vv1,
1895 because if uv1 > vv1, then even if v would have all
1896 bits in all words below vv1 set, the previous iteration
1897 would be supposed to use qhat larger by 1 and subtract
1898 v. With uv1 == vv1 and uv0 >= vv1 the double-word
1899 qhat in Knuth's algorithm would be 1 in the upper word
1900 and 1 in the lower word, say for
1901 uv1 0x8000000000000000ULL
1902 uv0 0xffffffffffffffffULL
1903 vv1 0x8000000000000000ULL
1904 0x8000000000000000ffffffffffffffffuwb
1905 / 0x8000000000000000uwb == 0x10000000000000001uwb, and
1906 exactly like that also for any other value
1907 > 0x8000000000000000ULL in uv1 and vv1 and uv0 >= uv1.
1908 So we need to subtract one or at most two vv1s from
1909 uv1:uv0 (qhat because of that decreases by 1 or 2 and
1910 is then representable in UWtype) and need to increase
1911 rhat by vv1 once or twice because of that. Now, if
1912 we need to subtract 2 vv1s, i.e. if
1913 uv1 == vv1 && uv0 >= vv1, then rhat (which is uv0 - vv1)
1914 + vv1 computation can't overflow, because it is equal
1915 to uv0 and therefore the original algorithm in that case
1916 performs goto again, but the second vv1 addition must
1917 overflow already because vv1 has msb set from the
1918 canonicalization. */
1919 uv1
-= __builtin_sub_overflow (uv0
, vv1
, &uv0
);
1922 uv1
-= __builtin_sub_overflow (uv0
, vv1
, &uv0
);
1923 udiv_qrnnd (qhat
, rhat
, uv1
, uv0
, vv1
);
1928 udiv_qrnnd (qhat
, rhat
, uv1
, uv0
, vv1
);
1929 if (!__builtin_add_overflow (rhat
, vv1
, &rhat
))
1935 udiv_qrnnd (qhat
, rhat
, uv1
, uv0
, vv1
);
1937 umul_ppmm (hi
, lo
, qhat
, vv0
);
1940 && lo
> u2
[BITINT_END (un
- j
- vn
+ 2,
1944 if (!__builtin_add_overflow (rhat
, vv1
, &rhat
))
1949 c
= bitint_submul_1 (u2
+ BITINT_END (un
- j
, j
),
1950 v2
+ BITINT_END (vn
- 1, 0), qhat
, vn
);
1951 u2
[BITINT_END (un
- j
- vn
, j
+ vn
)] -= c
;
1952 /* If we've subtracted too much, decrease qhat and
1954 if ((Wtype
) u2
[BITINT_END (un
- j
- vn
, j
+ vn
)] < 0)
1958 for (USItype i
= 0; i
< vn
; ++i
)
1960 UWtype s
= v2
[BITINT_END (vn
- 1 - i
, i
)];
1961 UWtype d
= u2
[BITINT_END (un
- i
- j
, i
+ j
)];
1962 UWtype c1
= __builtin_add_overflow (d
, s
, &d
);
1963 UWtype c2
= __builtin_add_overflow (d
, c
, &d
);
1965 u2
[BITINT_END (un
- i
- j
, i
+ j
)] = d
;
1967 u2
[BITINT_END (un
- j
- vn
, j
+ vn
)] += c
;
1969 q2
[BITINT_END (un
- vn
- j
, j
)] = qhat
;
1975 const SItype n
= sizeof (UWtype
) * __CHAR_BIT__
;
1976 /* Unnormalize remainder. */
1978 for (i
= 0; i
< vn
&& i
< rn
; ++i
)
1979 r
[BITINT_END (rn
- 1 - i
, i
)]
1980 = ((u2
[BITINT_END (un
- i
, i
)] >> s
)
1981 | (u2
[BITINT_END (un
- i
- 1, i
+ 1)] << (n
- s
)));
1983 r
[BITINT_END (rn
- vn
, vn
- 1)]
1984 = u2
[BITINT_END (un
- vn
+ 1, vn
- 1)] >> s
;
1987 __builtin_memcpy (&r
[BITINT_END (rn
- vn
, 0)],
1988 &u2
[BITINT_END (un
+ 1 - vn
, 0)],
1989 vn
* sizeof (UWtype
));
1991 __builtin_memcpy (&r
[0], &u2
[BITINT_END (un
+ 1 - rn
, 0)],
1992 rn
* sizeof (UWtype
));
1998 if ((uprec
< 0) ^ (vprec
< 0))
2000 /* Negative quotient. */
2002 if (un
- vn
+ 1 > qn
)
2006 SItype c
= bitint_negate (q
+ BITINT_END (qn
- 1, 0),
2007 q2
+ BITINT_END (un
- vn
, 0), n
) ? -1 : 0;
2009 __builtin_memset (q
+ BITINT_END (0, n
), c
,
2010 (qn
- n
) * sizeof (UWtype
));
2014 /* Positive quotient. */
2016 __builtin_memcpy (q
, q2
+ BITINT_END (un
- vn
+ 1 - qn
, 0),
2017 qn
* sizeof (UWtype
));
2018 else if (qn
> un
- vn
+ 1)
2019 __builtin_memset (q
+ BITINT_END (0, un
- vn
+ 1), 0,
2020 (qn
- (un
- vn
+ 1)) * sizeof (UWtype
));
2027 /* Negative remainder. */
2028 SItype c
= bitint_negate (r
+ BITINT_END (rn
- 1, 0),
2029 r
+ BITINT_END (rn
- 1, 0),
2030 rn
> vn
? vn
: rn
) ? -1 : 0;
2032 __builtin_memset (r
+ BITINT_END (0, vn
), c
,
2033 (rn
- vn
) * sizeof (UWtype
));
2037 /* Positive remainder. */
2039 __builtin_memset (r
+ BITINT_END (0, vn
), 0,
2040 (rn
- vn
) * sizeof (UWtype
));
2049 __cmpdi2 (DWtype a
, DWtype b
)
2051 return (a
> b
) - (a
< b
) + 1;
2057 __ucmpdi2 (UDWtype a
, UDWtype b
)
2059 return (a
> b
) - (a
< b
) + 1;
2063 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
2065 __fixunstfDI (TFtype a
)
2070 /* Compute high word of result, as a flonum. */
2071 const TFtype b
= (a
/ Wtype_MAXp1_F
);
2072 /* Convert that to fixed (but not to DWtype!),
2073 and shift it into the high word. */
2074 UDWtype v
= (UWtype
) b
;
2076 /* Remove high part from the TFtype, leaving the low part as flonum. */
2078 /* Convert that to fixed (but not to DWtype!) and add it in.
2079 Sometimes A comes out negative. This is significant, since
2080 A has more bits than a long int does. */
2082 v
-= (UWtype
) (- a
);
2089 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
2091 __fixtfdi (TFtype a
)
2094 return - __fixunstfDI (-a
);
2095 return __fixunstfDI (a
);
2099 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
2101 __fixunsxfDI (XFtype a
)
2106 /* Compute high word of result, as a flonum. */
2107 const XFtype b
= (a
/ Wtype_MAXp1_F
);
2108 /* Convert that to fixed (but not to DWtype!),
2109 and shift it into the high word. */
2110 UDWtype v
= (UWtype
) b
;
2112 /* Remove high part from the XFtype, leaving the low part as flonum. */
2114 /* Convert that to fixed (but not to DWtype!) and add it in.
2115 Sometimes A comes out negative. This is significant, since
2116 A has more bits than a long int does. */
2118 v
-= (UWtype
) (- a
);
2125 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
2127 __fixxfdi (XFtype a
)
2130 return - __fixunsxfDI (-a
);
2131 return __fixunsxfDI (a
);
2135 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
2137 __fixunsdfDI (DFtype a
)
2139 /* Get high part of result. The division here will just moves the radix
2140 point and will not cause any rounding. Then the conversion to integral
2141 type chops result as desired. */
2142 const UWtype hi
= a
/ Wtype_MAXp1_F
;
2144 /* Get low part of result. Convert `hi' to floating type and scale it back,
2145 then subtract this from the number being converted. This leaves the low
2146 part. Convert that to integral type. */
2147 const UWtype lo
= a
- (DFtype
) hi
* Wtype_MAXp1_F
;
2149 /* Assemble result from the two parts. */
2150 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
2154 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
2156 __fixdfdi (DFtype a
)
2159 return - __fixunsdfDI (-a
);
2160 return __fixunsdfDI (a
);
2164 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
2166 __fixunssfDI (SFtype a
)
2168 #if LIBGCC2_HAS_DF_MODE
2169 /* Convert the SFtype to a DFtype, because that is surely not going
2170 to lose any bits. Some day someone else can write a faster version
2171 that avoids converting to DFtype, and verify it really works right. */
2172 const DFtype dfa
= a
;
2174 /* Get high part of result. The division here will just moves the radix
2175 point and will not cause any rounding. Then the conversion to integral
2176 type chops result as desired. */
2177 const UWtype hi
= dfa
/ Wtype_MAXp1_F
;
2179 /* Get low part of result. Convert `hi' to floating type and scale it back,
2180 then subtract this from the number being converted. This leaves the low
2181 part. Convert that to integral type. */
2182 const UWtype lo
= dfa
- (DFtype
) hi
* Wtype_MAXp1_F
;
2184 /* Assemble result from the two parts. */
2185 return ((UDWtype
) hi
<< W_TYPE_SIZE
) | lo
;
2186 #elif FLT_MANT_DIG < W_TYPE_SIZE
2189 if (a
< Wtype_MAXp1_F
)
2191 if (a
< Wtype_MAXp1_F
* Wtype_MAXp1_F
)
2193 /* Since we know that there are fewer significant bits in the SFmode
2194 quantity than in a word, we know that we can convert out all the
2195 significant bits in one step, and thus avoid losing bits. */
2197 /* ??? This following loop essentially performs frexpf. If we could
2198 use the real libm function, or poke at the actual bits of the fp
2199 format, it would be significantly faster. */
2201 UWtype shift
= 0, counter
;
2205 for (counter
= W_TYPE_SIZE
/ 2; counter
!= 0; counter
>>= 1)
2207 SFtype counterf
= (UWtype
)1 << counter
;
2215 /* Rescale into the range of one word, extract the bits of that
2216 one word, and shift the result into position. */
2219 return (DWtype
)counter
<< shift
;
2228 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
2230 __fixsfdi (SFtype a
)
2233 return - __fixunssfDI (-a
);
2234 return __fixunssfDI (a
);
2238 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
2240 __floatdixf (DWtype u
)
2242 #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
2245 XFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
2252 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
2254 __floatundixf (UDWtype u
)
2256 #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
2259 XFtype d
= (UWtype
) (u
>> W_TYPE_SIZE
);
2266 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
2268 __floatditf (DWtype u
)
2270 #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
2273 TFtype d
= (Wtype
) (u
>> W_TYPE_SIZE
);
2280 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
2282 __floatunditf (UDWtype u
)
2284 #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
2287 TFtype d
= (UWtype
) (u
>> W_TYPE_SIZE
);
2294 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
2295 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
2296 #define DI_SIZE (W_TYPE_SIZE * 2)
2297 #define F_MODE_OK(SIZE) \
2299 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
2300 && !AVOID_FP_TYPE_CONVERSION(SIZE))
2301 #if defined(L_floatdisf)
2302 #define FUNC __floatdisf
2303 #define FSTYPE SFtype
2304 #define FSSIZE __LIBGCC_SF_MANT_DIG__
2306 #define FUNC __floatdidf
2307 #define FSTYPE DFtype
2308 #define FSSIZE __LIBGCC_DF_MANT_DIG__
2314 #if FSSIZE >= W_TYPE_SIZE
2315 /* When the word size is small, we never get any rounding error. */
2316 FSTYPE f
= (Wtype
) (u
>> W_TYPE_SIZE
);
2320 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
2321 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
2322 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
2324 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
2325 # define FSIZE __LIBGCC_DF_MANT_DIG__
2326 # define FTYPE DFtype
2327 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
2328 # define FSIZE __LIBGCC_XF_MANT_DIG__
2329 # define FTYPE XFtype
2330 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
2331 # define FSIZE __LIBGCC_TF_MANT_DIG__
2332 # define FTYPE TFtype
2337 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
2339 /* Protect against double-rounding error.
2340 Represent any low-order bits, that might be truncated by a bit that
2341 won't be lost. The bit can go in anywhere below the rounding position
2342 of the FSTYPE. A fixed mask and bit position handles all usual
2344 if (! (- ((DWtype
) 1 << FSIZE
) < u
2345 && u
< ((DWtype
) 1 << FSIZE
)))
2347 if ((UDWtype
) u
& (REP_BIT
- 1))
2349 u
&= ~ (REP_BIT
- 1);
2354 /* Do the calculation in a wider type so that we don't lose any of
2355 the precision of the high word while multiplying it. */
2356 FTYPE f
= (Wtype
) (u
>> W_TYPE_SIZE
);
2361 #if FSSIZE >= W_TYPE_SIZE - 2
2364 /* Finally, the word size is larger than the number of bits in the
2365 required FSTYPE, and we've got no suitable wider type. The only
2366 way to avoid double rounding is to special case the
2369 /* If there are no high bits set, fall back to one conversion. */
2371 return (FSTYPE
)(Wtype
)u
;
2373 /* Otherwise, find the power of two. */
2374 Wtype hi
= u
>> W_TYPE_SIZE
;
2378 UWtype count
, shift
;
2379 #if !defined (COUNT_LEADING_ZEROS_0) || COUNT_LEADING_ZEROS_0 != W_TYPE_SIZE
2381 count
= W_TYPE_SIZE
;
2384 count_leading_zeros (count
, hi
);
2386 /* No leading bits means u == minimum. */
2388 return Wtype_MAXp1_F
* (FSTYPE
) (hi
| ((UWtype
) u
!= 0));
2390 shift
= 1 + W_TYPE_SIZE
- count
;
2392 /* Shift down the most significant bits. */
2395 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
2396 if ((UWtype
)u
<< (W_TYPE_SIZE
- shift
))
2399 /* Convert the one word of data, and rescale. */
2401 if (shift
== W_TYPE_SIZE
)
2403 /* The following two cases could be merged if we knew that the target
2404 supported a native unsigned->float conversion. More often, we only
2405 have a signed conversion, and have to add extra fixup code. */
2406 else if (shift
== W_TYPE_SIZE
- 1)
2407 e
= Wtype_MAXp1_F
/ 2;
2409 e
= (Wtype
)1 << shift
;
2415 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
2416 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
2417 #define DI_SIZE (W_TYPE_SIZE * 2)
2418 #define F_MODE_OK(SIZE) \
2420 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
2421 && !AVOID_FP_TYPE_CONVERSION(SIZE))
2422 #if defined(L_floatundisf)
2423 #define FUNC __floatundisf
2424 #define FSTYPE SFtype
2425 #define FSSIZE __LIBGCC_SF_MANT_DIG__
2427 #define FUNC __floatundidf
2428 #define FSTYPE DFtype
2429 #define FSSIZE __LIBGCC_DF_MANT_DIG__
2435 #if FSSIZE >= W_TYPE_SIZE
2436 /* When the word size is small, we never get any rounding error. */
2437 FSTYPE f
= (UWtype
) (u
>> W_TYPE_SIZE
);
2441 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
2442 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
2443 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
2445 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
2446 # define FSIZE __LIBGCC_DF_MANT_DIG__
2447 # define FTYPE DFtype
2448 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
2449 # define FSIZE __LIBGCC_XF_MANT_DIG__
2450 # define FTYPE XFtype
2451 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
2452 # define FSIZE __LIBGCC_TF_MANT_DIG__
2453 # define FTYPE TFtype
2458 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
2460 /* Protect against double-rounding error.
2461 Represent any low-order bits, that might be truncated by a bit that
2462 won't be lost. The bit can go in anywhere below the rounding position
2463 of the FSTYPE. A fixed mask and bit position handles all usual
2465 if (u
>= ((UDWtype
) 1 << FSIZE
))
2467 if ((UDWtype
) u
& (REP_BIT
- 1))
2469 u
&= ~ (REP_BIT
- 1);
2474 /* Do the calculation in a wider type so that we don't lose any of
2475 the precision of the high word while multiplying it. */
2476 FTYPE f
= (UWtype
) (u
>> W_TYPE_SIZE
);
2481 #if FSSIZE == W_TYPE_SIZE - 1
2484 /* Finally, the word size is larger than the number of bits in the
2485 required FSTYPE, and we've got no suitable wider type. The only
2486 way to avoid double rounding is to special case the
2489 /* If there are no high bits set, fall back to one conversion. */
2491 return (FSTYPE
)(UWtype
)u
;
2493 /* Otherwise, find the power of two. */
2494 UWtype hi
= u
>> W_TYPE_SIZE
;
2496 UWtype count
, shift
;
2497 count_leading_zeros (count
, hi
);
2499 shift
= W_TYPE_SIZE
- count
;
2501 /* Shift down the most significant bits. */
2504 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
2505 if ((UWtype
)u
<< (W_TYPE_SIZE
- shift
))
2508 /* Convert the one word of data, and rescale. */
2510 if (shift
== W_TYPE_SIZE
)
2512 /* The following two cases could be merged if we knew that the target
2513 supported a native unsigned->float conversion. More often, we only
2514 have a signed conversion, and have to add extra fixup code. */
2515 else if (shift
== W_TYPE_SIZE
- 1)
2516 e
= Wtype_MAXp1_F
/ 2;
2518 e
= (Wtype
)1 << shift
;
2524 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
2526 __fixunsxfSI (XFtype a
)
2528 if (a
>= - (DFtype
) Wtype_MIN
)
2529 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
2534 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
2536 __fixunsdfSI (DFtype a
)
2538 if (a
>= - (DFtype
) Wtype_MIN
)
2539 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
2544 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
2546 __fixunssfSI (SFtype a
)
2548 if (a
>= - (SFtype
) Wtype_MIN
)
2549 return (Wtype
) (a
+ Wtype_MIN
) - Wtype_MIN
;
2554 /* Integer power helper used from __builtin_powi for non-constant
2557 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
2558 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
2559 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
2560 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
2561 # if defined(L_powisf2)
2562 # define TYPE SFtype
2563 # define NAME __powisf2
2564 # elif defined(L_powidf2)
2565 # define TYPE DFtype
2566 # define NAME __powidf2
2567 # elif defined(L_powixf2)
2568 # define TYPE XFtype
2569 # define NAME __powixf2
2570 # elif defined(L_powitf2)
2571 # define TYPE TFtype
2572 # define NAME __powitf2
2578 NAME (TYPE x
, int m
)
2580 unsigned int n
= m
< 0 ? -(unsigned int) m
: (unsigned int) m
;
2581 TYPE y
= n
% 2 ? x
: 1;
2588 return m
< 0 ? 1/y
: y
;
2593 #if((defined(L_mulhc3) || defined(L_divhc3)) && LIBGCC2_HAS_HF_MODE) \
2594 || ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
2595 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
2596 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
2597 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
2603 #if defined(L_mulhc3) || defined(L_divhc3)
2604 # define MTYPE HFtype
2605 # define CTYPE HCtype
2606 # define AMTYPE SFtype
2608 # define CEXT __LIBGCC_HF_FUNC_EXT__
2609 # define NOTRUNC (!__LIBGCC_HF_EXCESS_PRECISION__)
2610 #elif defined(L_mulsc3) || defined(L_divsc3)
2611 # define MTYPE SFtype
2612 # define CTYPE SCtype
2613 # define AMTYPE DFtype
2615 # define CEXT __LIBGCC_SF_FUNC_EXT__
2616 # define NOTRUNC (!__LIBGCC_SF_EXCESS_PRECISION__)
2617 # define RBIG (__LIBGCC_SF_MAX__ / 2)
2618 # define RMIN (__LIBGCC_SF_MIN__)
2619 # define RMIN2 (__LIBGCC_SF_EPSILON__)
2620 # define RMINSCAL (1 / __LIBGCC_SF_EPSILON__)
2621 # define RMAX2 (RBIG * RMIN2)
2622 #elif defined(L_muldc3) || defined(L_divdc3)
2623 # define MTYPE DFtype
2624 # define CTYPE DCtype
2626 # define CEXT __LIBGCC_DF_FUNC_EXT__
2627 # define NOTRUNC (!__LIBGCC_DF_EXCESS_PRECISION__)
2628 # define RBIG (__LIBGCC_DF_MAX__ / 2)
2629 # define RMIN (__LIBGCC_DF_MIN__)
2630 # define RMIN2 (__LIBGCC_DF_EPSILON__)
2631 # define RMINSCAL (1 / __LIBGCC_DF_EPSILON__)
2632 # define RMAX2 (RBIG * RMIN2)
2633 #elif defined(L_mulxc3) || defined(L_divxc3)
2634 # define MTYPE XFtype
2635 # define CTYPE XCtype
2637 # define CEXT __LIBGCC_XF_FUNC_EXT__
2638 # define NOTRUNC (!__LIBGCC_XF_EXCESS_PRECISION__)
2639 # define RBIG (__LIBGCC_XF_MAX__ / 2)
2640 # define RMIN (__LIBGCC_XF_MIN__)
2641 # define RMIN2 (__LIBGCC_XF_EPSILON__)
2642 # define RMINSCAL (1 / __LIBGCC_XF_EPSILON__)
2643 # define RMAX2 (RBIG * RMIN2)
2644 #elif defined(L_multc3) || defined(L_divtc3)
2645 # define MTYPE TFtype
2646 # define CTYPE TCtype
2648 # define CEXT __LIBGCC_TF_FUNC_EXT__
2649 # define NOTRUNC (!__LIBGCC_TF_EXCESS_PRECISION__)
2650 # if __LIBGCC_TF_MANT_DIG__ == 106
2651 # define RBIG (__LIBGCC_DF_MAX__ / 2)
2652 # define RMIN (__LIBGCC_DF_MIN__)
2653 # define RMIN2 (__LIBGCC_DF_EPSILON__)
2654 # define RMINSCAL (1 / __LIBGCC_DF_EPSILON__)
2656 # define RBIG (__LIBGCC_TF_MAX__ / 2)
2657 # define RMIN (__LIBGCC_TF_MIN__)
2658 # define RMIN2 (__LIBGCC_TF_EPSILON__)
2659 # define RMINSCAL (1 / __LIBGCC_TF_EPSILON__)
2661 # define RMAX2 (RBIG * RMIN2)
2666 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
2667 #define _CONCAT3(A,B,C) A##B##C
2669 #define CONCAT2(A,B) _CONCAT2(A,B)
2670 #define _CONCAT2(A,B) A##B
2672 #define isnan(x) __builtin_isnan (x)
2673 #define isfinite(x) __builtin_isfinite (x)
2674 #define isinf(x) __builtin_isinf (x)
2676 #define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
2679 /* Helpers to make the following code slightly less gross. */
2680 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
2681 #define FABS CONCAT2(__builtin_fabs, CEXT)
2683 /* Verify that MTYPE matches up with CEXT. */
2684 extern void *compile_type_assert
[sizeof(INFINITY
) == sizeof(MTYPE
) ? 1 : -1];
2686 /* Ensure that we've lost any extra precision. */
2690 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
2693 #if defined(L_mulhc3) || defined(L_mulsc3) || defined(L_muldc3) \
2694 || defined(L_mulxc3) || defined(L_multc3)
2697 CONCAT3(__mul
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
2699 MTYPE ac
, bd
, ad
, bc
, x
, y
;
2715 if (isnan (x
) && isnan (y
))
2717 /* Recover infinities that computed as NaN + iNaN. */
2719 if (isinf (a
) || isinf (b
))
2721 /* z is infinite. "Box" the infinity and change NaNs in
2722 the other factor to 0. */
2723 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
2724 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
2725 if (isnan (c
)) c
= COPYSIGN (0, c
);
2726 if (isnan (d
)) d
= COPYSIGN (0, d
);
2729 if (isinf (c
) || isinf (d
))
2731 /* w is infinite. "Box" the infinity and change NaNs in
2732 the other factor to 0. */
2733 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
2734 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
2735 if (isnan (a
)) a
= COPYSIGN (0, a
);
2736 if (isnan (b
)) b
= COPYSIGN (0, b
);
2740 && (isinf (ac
) || isinf (bd
)
2741 || isinf (ad
) || isinf (bc
)))
2743 /* Recover infinities from overflow by changing NaNs to 0. */
2744 if (isnan (a
)) a
= COPYSIGN (0, a
);
2745 if (isnan (b
)) b
= COPYSIGN (0, b
);
2746 if (isnan (c
)) c
= COPYSIGN (0, c
);
2747 if (isnan (d
)) d
= COPYSIGN (0, d
);
2752 x
= INFINITY
* (a
* c
- b
* d
);
2753 y
= INFINITY
* (a
* d
+ b
* c
);
2761 #endif /* complex multiply */
2763 #if defined(L_divhc3) || defined(L_divsc3) || defined(L_divdc3) \
2764 || defined(L_divxc3) || defined(L_divtc3)
2767 CONCAT3(__div
,MODE
,3) (MTYPE a
, MTYPE b
, MTYPE c
, MTYPE d
)
2769 #if defined(L_divhc3) \
2770 || (defined(L_divsc3) && defined(__LIBGCC_HAVE_HWDBL__) )
2772 /* Half precision is handled with float precision.
2773 float is handled with double precision when double precision
2774 hardware is available.
2775 Due to the additional precision, the simple complex divide
2776 method (without Smith's method) is sufficient to get accurate
2777 answers and runs slightly faster than Smith's method. */
2779 AMTYPE aa
, bb
, cc
, dd
;
2788 denom
= (cc
* cc
) + (dd
* dd
);
2789 x
= ((aa
* cc
) + (bb
* dd
)) / denom
;
2790 y
= ((bb
* cc
) - (aa
* dd
)) / denom
;
2793 MTYPE denom
, ratio
, x
, y
;
2796 /* double, extended, long double have significant potential
2797 underflow/overflow errors that can be greatly reduced with
2798 a limited number of tests and adjustments. float is handled
2799 the same way when no HW double is available.
2802 /* Scale by max(c,d) to reduce chances of denominator overflowing. */
2803 if (FABS (c
) < FABS (d
))
2805 /* Prevent underflow when denominator is near max representable. */
2806 if (FABS (d
) >= RBIG
)
2813 /* Avoid overflow/underflow issues when c and d are small.
2814 Scaling up helps avoid some underflows.
2815 No new overflow possible since c&d < RMIN2. */
2816 if (FABS (d
) < RMIN2
)
2825 if (((FABS (a
) < RMIN
) && (FABS (b
) < RMAX2
) && (FABS (d
) < RMAX2
))
2826 || ((FABS (b
) < RMIN
) && (FABS (a
) < RMAX2
)
2827 && (FABS (d
) < RMAX2
)))
2836 denom
= (c
* ratio
) + d
;
2837 /* Choose alternate order of computation if ratio is subnormal. */
2838 if (FABS (ratio
) > RMIN
)
2840 x
= ((a
* ratio
) + b
) / denom
;
2841 y
= ((b
* ratio
) - a
) / denom
;
2845 x
= ((c
* (a
/ d
)) + b
) / denom
;
2846 y
= ((c
* (b
/ d
)) - a
) / denom
;
2851 /* Prevent underflow when denominator is near max representable. */
2852 if (FABS (c
) >= RBIG
)
2859 /* Avoid overflow/underflow issues when both c and d are small.
2860 Scaling up helps avoid some underflows.
2861 No new overflow possible since both c&d are less than RMIN2. */
2862 if (FABS (c
) < RMIN2
)
2871 if (((FABS (a
) < RMIN
) && (FABS (b
) < RMAX2
) && (FABS (c
) < RMAX2
))
2872 || ((FABS (b
) < RMIN
) && (FABS (a
) < RMAX2
)
2873 && (FABS (c
) < RMAX2
)))
2882 denom
= (d
* ratio
) + c
;
2883 /* Choose alternate order of computation if ratio is subnormal. */
2884 if (FABS (ratio
) > RMIN
)
2886 x
= ((b
* ratio
) + a
) / denom
;
2887 y
= (b
- (a
* ratio
)) / denom
;
2891 x
= (a
+ (d
* (b
/ c
))) / denom
;
2892 y
= (b
- (d
* (a
/ c
))) / denom
;
2897 /* Recover infinities and zeros that computed as NaN+iNaN; the only
2898 cases are nonzero/zero, infinite/finite, and finite/infinite. */
2899 if (isnan (x
) && isnan (y
))
2901 if (c
== 0.0 && d
== 0.0 && (!isnan (a
) || !isnan (b
)))
2903 x
= COPYSIGN (INFINITY
, c
) * a
;
2904 y
= COPYSIGN (INFINITY
, c
) * b
;
2906 else if ((isinf (a
) || isinf (b
)) && isfinite (c
) && isfinite (d
))
2908 a
= COPYSIGN (isinf (a
) ? 1 : 0, a
);
2909 b
= COPYSIGN (isinf (b
) ? 1 : 0, b
);
2910 x
= INFINITY
* (a
* c
+ b
* d
);
2911 y
= INFINITY
* (b
* c
- a
* d
);
2913 else if ((isinf (c
) || isinf (d
)) && isfinite (a
) && isfinite (b
))
2915 c
= COPYSIGN (isinf (c
) ? 1 : 0, c
);
2916 d
= COPYSIGN (isinf (d
) ? 1 : 0, d
);
2917 x
= 0.0 * (a
* c
+ b
* d
);
2918 y
= 0.0 * (b
* c
- a
* d
);
2926 #endif /* complex divide */
2928 #endif /* all complex float routines */
2930 /* From here on down, the routines use normal data types. */
2932 #define SItype bogus_type
2933 #define USItype bogus_type
2934 #define DItype bogus_type
2935 #define UDItype bogus_type
2936 #define SFtype bogus_type
2937 #define DFtype bogus_type
2955 /* Like bcmp except the sign is meaningful.
2956 Result is negative if S1 is less than S2,
2957 positive if S1 is greater, 0 if S1 and S2 are equal. */
2960 __gcc_bcmp (const unsigned char *s1
, const unsigned char *s2
, size_t size
)
2964 const unsigned char c1
= *s1
++, c2
= *s2
++;
2974 /* __eprintf used to be used by GCC's private version of <assert.h>.
2975 We no longer provide that header, but this routine remains in libgcc.a
2976 for binary backward compatibility. Note that it is not included in
2977 the shared version of libgcc. */
2979 #ifndef inhibit_libc
2981 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2985 __eprintf (const char *string
, const char *expression
,
2986 unsigned int line
, const char *filename
)
2988 fprintf (stderr
, string
, expression
, line
, filename
);
2997 #ifdef L_clear_cache
2998 /* Clear part of an instruction cache. */
3001 __clear_cache (void *beg
__attribute__((__unused__
)),
3002 void *end
__attribute__((__unused__
)))
3004 #ifdef CLEAR_INSN_CACHE
3005 /* Cast the void* pointers to char* as some implementations
3006 of the macro assume the pointers can be subtracted from
3008 CLEAR_INSN_CACHE ((char *) beg
, (char *) end
);
3009 #endif /* CLEAR_INSN_CACHE */
3012 #endif /* L_clear_cache */
3016 /* Jump to a trampoline, loading the static chain address. */
3018 #if defined(WINNT) && ! defined(__CYGWIN__)
3019 #define WIN32_LEAN_AND_MEAN
3020 #include <windows.h>
3021 int getpagesize (void);
3022 int mprotect (char *,int, int);
3035 mprotect (char *addr
, int len
, int prot
)
3054 if (VirtualProtect (addr
, len
, np
, &op
))
3060 #endif /* WINNT && ! __CYGWIN__ */
3062 #ifdef TRANSFER_FROM_TRAMPOLINE
3063 TRANSFER_FROM_TRAMPOLINE
3065 #endif /* L_trampoline */
3070 #include "gbl-ctors.h"
3072 /* Some systems use __main in a way incompatible with its use in gcc, in these
3073 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
3074 give the same symbol without quotes for an alternative entry point. You
3075 must define both, or neither. */
3077 #define NAME__MAIN "__main"
3078 #define SYMBOL__MAIN __main
3081 #if defined (__LIBGCC_INIT_SECTION_ASM_OP__) \
3082 || defined (__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__)
3083 #undef HAS_INIT_SECTION
3084 #define HAS_INIT_SECTION
3087 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
3089 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
3090 code to run constructors. In that case, we need to handle EH here, too.
3091 But MINGW32 is special because it handles CRTSTUFF and EH on its own. */
3094 #undef __LIBGCC_EH_FRAME_SECTION_NAME__
3097 #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
3098 #include "unwind-dw2-fde.h"
3099 extern unsigned char __EH_FRAME_BEGIN__
[];
3102 /* Run all the global destructors on exit from the program. */
3105 __do_global_dtors (void)
3107 #ifdef DO_GLOBAL_DTORS_BODY
3108 DO_GLOBAL_DTORS_BODY
;
3110 static func_ptr
*p
= __DTOR_LIST__
+ 1;
3117 #if defined (__LIBGCC_EH_FRAME_SECTION_NAME__) && !defined (HAS_INIT_SECTION)
3119 static int completed
= 0;
3123 __deregister_frame_info (__EH_FRAME_BEGIN__
);
3130 #ifndef HAS_INIT_SECTION
3131 /* Run all the global constructors on entry to the program. */
3134 __do_global_ctors (void)
3136 #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
3138 static struct object object
;
3139 __register_frame_info (__EH_FRAME_BEGIN__
, &object
);
3142 DO_GLOBAL_CTORS_BODY
;
3143 atexit (__do_global_dtors
);
3145 #endif /* no HAS_INIT_SECTION */
3147 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
3148 /* Subroutine called automatically by `main'.
3149 Compiling a global function named `main'
3150 produces an automatic call to this function at the beginning.
3152 For many systems, this routine calls __do_global_ctors.
3153 For systems which support a .init section we use the .init section
3154 to run __do_global_ctors, so we need not do anything here. */
3156 extern void SYMBOL__MAIN (void);
3160 /* Support recursive calls to `main': run initializers just once. */
3161 static int initialized
;
3165 __do_global_ctors ();
3168 #endif /* no HAS_INIT_SECTION or INVOKE__main */
3170 #endif /* L__main */
3171 #endif /* __CYGWIN__ */
3175 #include "gbl-ctors.h"
3177 /* Provide default definitions for the lists of constructors and
3178 destructors, so that we don't get linker errors. These symbols are
3179 intentionally bss symbols, so that gld and/or collect will provide
3180 the right values. */
3182 /* We declare the lists here with two elements each,
3183 so that they are valid empty lists if no other definition is loaded.
3185 If we are using the old "set" extensions to have the gnu linker
3186 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
3187 must be in the bss/common section.
3189 Long term no port should use those extensions. But many still do. */
3190 #if !defined(__LIBGCC_INIT_SECTION_ASM_OP__)
3191 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
3192 func_ptr __CTOR_LIST__
[2] = {0, 0};
3193 func_ptr __DTOR_LIST__
[2] = {0, 0};
3195 func_ptr __CTOR_LIST__
[2];
3196 func_ptr __DTOR_LIST__
[2];
3198 #endif /* no __LIBGCC_INIT_SECTION_ASM_OP__ */
3199 #endif /* L_ctors */
3200 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */