Remove extra newline
[official-gcc.git] / libgcc / libgcc2.c
blobe0a9fd712e70c816113ddb6d061ce979657878fc
1 /* More subroutines needed by GCC output code on some machines. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2020 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
10 version.
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
15 for more details.
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/>. */
26 #include "tconfig.h"
27 #include "tsystem.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "libgcc_tm.h"
32 #ifdef HAVE_GAS_HIDDEN
33 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
34 #else
35 #define ATTRIBUTE_HIDDEN
36 #endif
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
44 #else
45 # define LIBGCC2_MAX_UNITS_PER_WORD MIN_UNITS_PER_WORD
46 #endif
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
52 #endif
54 #if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
56 #include "libgcc2.h"
58 #ifdef DECLARE_LIBRARY_RENAMES
59 DECLARE_LIBRARY_RENAMES
60 #endif
62 #if defined (L_negdi2)
63 DWtype
64 __negdi2 (DWtype u)
66 const DWunion uu = {.ll = u};
67 const DWunion w = { {.low = -uu.s.low,
68 .high = -uu.s.high - ((UWtype) -uu.s.low > 0) } };
70 return w.ll;
72 #endif
74 #ifdef L_addvsi3
75 Wtype
76 __addvSI3 (Wtype a, Wtype b)
78 const Wtype w = (UWtype) a + (UWtype) b;
80 if (b >= 0 ? w < a : w > a)
81 abort ();
83 return w;
85 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
86 SItype
87 __addvsi3 (SItype a, SItype b)
89 const SItype w = (USItype) a + (USItype) b;
91 if (b >= 0 ? w < a : w > a)
92 abort ();
94 return w;
96 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
97 #endif
99 #ifdef L_addvdi3
100 DWtype
101 __addvDI3 (DWtype a, DWtype b)
103 const DWtype w = (UDWtype) a + (UDWtype) b;
105 if (b >= 0 ? w < a : w > a)
106 abort ();
108 return w;
110 #endif
112 #ifdef L_subvsi3
113 Wtype
114 __subvSI3 (Wtype a, Wtype b)
116 const Wtype w = (UWtype) a - (UWtype) b;
118 if (b >= 0 ? w > a : w < a)
119 abort ();
121 return w;
123 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
124 SItype
125 __subvsi3 (SItype a, SItype b)
127 const SItype w = (USItype) a - (USItype) b;
129 if (b >= 0 ? w > a : w < a)
130 abort ();
132 return w;
134 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
135 #endif
137 #ifdef L_subvdi3
138 DWtype
139 __subvDI3 (DWtype a, DWtype b)
141 const DWtype w = (UDWtype) a - (UDWtype) b;
143 if (b >= 0 ? w > a : w < a)
144 abort ();
146 return w;
148 #endif
150 #ifdef L_mulvsi3
151 Wtype
152 __mulvSI3 (Wtype a, Wtype b)
154 const DWtype w = (DWtype) a * (DWtype) b;
156 if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1))
157 abort ();
159 return w;
161 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
162 #undef WORD_SIZE
163 #define WORD_SIZE (sizeof (SItype) * __CHAR_BIT__)
164 SItype
165 __mulvsi3 (SItype a, SItype b)
167 const DItype w = (DItype) a * (DItype) b;
169 if ((SItype) (w >> WORD_SIZE) != (SItype) w >> (WORD_SIZE-1))
170 abort ();
172 return w;
174 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
175 #endif
177 #ifdef L_negvsi2
178 Wtype
179 __negvSI2 (Wtype a)
181 const Wtype w = -(UWtype) a;
183 if (a >= 0 ? w > 0 : w < 0)
184 abort ();
186 return w;
188 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
189 SItype
190 __negvsi2 (SItype a)
192 const SItype w = -(USItype) a;
194 if (a >= 0 ? w > 0 : w < 0)
195 abort ();
197 return w;
199 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
200 #endif
202 #ifdef L_negvdi2
203 DWtype
204 __negvDI2 (DWtype a)
206 const DWtype w = -(UDWtype) a;
208 if (a >= 0 ? w > 0 : w < 0)
209 abort ();
211 return w;
213 #endif
215 #ifdef L_absvsi2
216 Wtype
217 __absvSI2 (Wtype a)
219 Wtype w = a;
221 if (a < 0)
222 #ifdef L_negvsi2
223 w = __negvSI2 (a);
224 #else
225 w = -(UWtype) a;
227 if (w < 0)
228 abort ();
229 #endif
231 return w;
233 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
234 SItype
235 __absvsi2 (SItype a)
237 SItype w = a;
239 if (a < 0)
240 #ifdef L_negvsi2
241 w = __negvsi2 (a);
242 #else
243 w = -(USItype) a;
245 if (w < 0)
246 abort ();
247 #endif
249 return w;
251 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
252 #endif
254 #ifdef L_absvdi2
255 DWtype
256 __absvDI2 (DWtype a)
258 DWtype w = a;
260 if (a < 0)
261 #ifdef L_negvdi2
262 w = __negvDI2 (a);
263 #else
264 w = -(UDWtype) a;
266 if (w < 0)
267 abort ();
268 #endif
270 return w;
272 #endif
274 #ifdef L_mulvdi3
275 DWtype
276 __mulvDI3 (DWtype u, DWtype v)
278 /* The unchecked multiplication needs 3 Wtype x Wtype multiplications,
279 but the checked multiplication needs only two. */
280 const DWunion uu = {.ll = u};
281 const DWunion vv = {.ll = v};
283 if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1))
285 /* u fits in a single Wtype. */
286 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
288 /* v fits in a single Wtype as well. */
289 /* A single multiplication. No overflow risk. */
290 return (DWtype) uu.s.low * (DWtype) vv.s.low;
292 else
294 /* Two multiplications. */
295 DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
296 * (UDWtype) (UWtype) vv.s.low};
297 DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.low
298 * (UDWtype) (UWtype) vv.s.high};
300 if (vv.s.high < 0)
301 w1.s.high -= uu.s.low;
302 if (uu.s.low < 0)
303 w1.ll -= vv.ll;
304 w1.ll += (UWtype) w0.s.high;
305 if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
307 w0.s.high = w1.s.low;
308 return w0.ll;
312 else
314 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
316 /* v fits into a single Wtype. */
317 /* Two multiplications. */
318 DWunion w0 = {.ll = (UDWtype) (UWtype) uu.s.low
319 * (UDWtype) (UWtype) vv.s.low};
320 DWunion w1 = {.ll = (UDWtype) (UWtype) uu.s.high
321 * (UDWtype) (UWtype) vv.s.low};
323 if (uu.s.high < 0)
324 w1.s.high -= vv.s.low;
325 if (vv.s.low < 0)
326 w1.ll -= uu.ll;
327 w1.ll += (UWtype) w0.s.high;
328 if (__builtin_expect (w1.s.high == w1.s.low >> (W_TYPE_SIZE - 1), 1))
330 w0.s.high = w1.s.low;
331 return w0.ll;
334 else
336 /* A few sign checks and a single multiplication. */
337 if (uu.s.high >= 0)
339 if (vv.s.high >= 0)
341 if (uu.s.high == 0 && vv.s.high == 0)
343 const DWtype w = (UDWtype) (UWtype) uu.s.low
344 * (UDWtype) (UWtype) vv.s.low;
345 if (__builtin_expect (w >= 0, 1))
346 return w;
349 else
351 if (uu.s.high == 0 && vv.s.high == (Wtype) -1)
353 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
354 * (UDWtype) (UWtype) vv.s.low};
356 ww.s.high -= uu.s.low;
357 if (__builtin_expect (ww.s.high < 0, 1))
358 return ww.ll;
362 else
364 if (vv.s.high >= 0)
366 if (uu.s.high == (Wtype) -1 && vv.s.high == 0)
368 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
369 * (UDWtype) (UWtype) vv.s.low};
371 ww.s.high -= vv.s.low;
372 if (__builtin_expect (ww.s.high < 0, 1))
373 return ww.ll;
376 else
378 if ((uu.s.high & vv.s.high) == (Wtype) -1
379 && (uu.s.low | vv.s.low) != 0)
381 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
382 * (UDWtype) (UWtype) vv.s.low};
384 ww.s.high -= uu.s.low;
385 ww.s.high -= vv.s.low;
386 if (__builtin_expect (ww.s.high >= 0, 1))
387 return ww.ll;
394 /* Overflow. */
395 abort ();
397 #endif
400 /* Unless shift functions are defined with full ANSI prototypes,
401 parameter b will be promoted to int if shift_count_type is smaller than an int. */
402 #ifdef L_lshrdi3
403 DWtype
404 __lshrdi3 (DWtype u, shift_count_type b)
406 if (b == 0)
407 return u;
409 const DWunion uu = {.ll = u};
410 const shift_count_type bm = W_TYPE_SIZE - b;
411 DWunion w;
413 if (bm <= 0)
415 w.s.high = 0;
416 w.s.low = (UWtype) uu.s.high >> -bm;
418 else
420 const UWtype carries = (UWtype) uu.s.high << bm;
422 w.s.high = (UWtype) uu.s.high >> b;
423 w.s.low = ((UWtype) uu.s.low >> b) | carries;
426 return w.ll;
428 #endif
430 #ifdef L_ashldi3
431 DWtype
432 __ashldi3 (DWtype u, shift_count_type b)
434 if (b == 0)
435 return u;
437 const DWunion uu = {.ll = u};
438 const shift_count_type bm = W_TYPE_SIZE - b;
439 DWunion w;
441 if (bm <= 0)
443 w.s.low = 0;
444 w.s.high = (UWtype) uu.s.low << -bm;
446 else
448 const UWtype carries = (UWtype) uu.s.low >> bm;
450 w.s.low = (UWtype) uu.s.low << b;
451 w.s.high = ((UWtype) uu.s.high << b) | carries;
454 return w.ll;
456 #endif
458 #ifdef L_ashrdi3
459 DWtype
460 __ashrdi3 (DWtype u, shift_count_type b)
462 if (b == 0)
463 return u;
465 const DWunion uu = {.ll = u};
466 const shift_count_type bm = W_TYPE_SIZE - b;
467 DWunion w;
469 if (bm <= 0)
471 /* w.s.high = 1..1 or 0..0 */
472 w.s.high = uu.s.high >> (W_TYPE_SIZE - 1);
473 w.s.low = uu.s.high >> -bm;
475 else
477 const UWtype carries = (UWtype) uu.s.high << bm;
479 w.s.high = uu.s.high >> b;
480 w.s.low = ((UWtype) uu.s.low >> b) | carries;
483 return w.ll;
485 #endif
487 #ifdef L_bswapsi2
488 SItype
489 __bswapsi2 (SItype u)
491 return ((((u) & 0xff000000) >> 24)
492 | (((u) & 0x00ff0000) >> 8)
493 | (((u) & 0x0000ff00) << 8)
494 | (((u) & 0x000000ff) << 24));
496 #endif
497 #ifdef L_bswapdi2
498 DItype
499 __bswapdi2 (DItype u)
501 return ((((u) & 0xff00000000000000ull) >> 56)
502 | (((u) & 0x00ff000000000000ull) >> 40)
503 | (((u) & 0x0000ff0000000000ull) >> 24)
504 | (((u) & 0x000000ff00000000ull) >> 8)
505 | (((u) & 0x00000000ff000000ull) << 8)
506 | (((u) & 0x0000000000ff0000ull) << 24)
507 | (((u) & 0x000000000000ff00ull) << 40)
508 | (((u) & 0x00000000000000ffull) << 56));
510 #endif
511 #ifdef L_ffssi2
512 #undef int
514 __ffsSI2 (UWtype u)
516 UWtype count;
518 if (u == 0)
519 return 0;
521 count_trailing_zeros (count, u);
522 return count + 1;
524 #endif
526 #ifdef L_ffsdi2
527 #undef int
529 __ffsDI2 (DWtype u)
531 const DWunion uu = {.ll = u};
532 UWtype word, count, add;
534 if (uu.s.low != 0)
535 word = uu.s.low, add = 0;
536 else if (uu.s.high != 0)
537 word = uu.s.high, add = W_TYPE_SIZE;
538 else
539 return 0;
541 count_trailing_zeros (count, word);
542 return count + add + 1;
544 #endif
546 #ifdef L_muldi3
547 DWtype
548 __muldi3 (DWtype u, DWtype v)
550 const DWunion uu = {.ll = u};
551 const DWunion vv = {.ll = v};
552 DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
554 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
555 + (UWtype) uu.s.high * (UWtype) vv.s.low);
557 return w.ll;
559 #endif
561 #if (defined (L_udivdi3) || defined (L_divdi3) || \
562 defined (L_umoddi3) || defined (L_moddi3))
563 #if defined (sdiv_qrnnd)
564 #define L_udiv_w_sdiv
565 #endif
566 #endif
568 #ifdef L_udiv_w_sdiv
569 #if defined (sdiv_qrnnd)
570 #if (defined (L_udivdi3) || defined (L_divdi3) || \
571 defined (L_umoddi3) || defined (L_moddi3))
572 static inline __attribute__ ((__always_inline__))
573 #endif
574 UWtype
575 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
577 UWtype q, r;
578 UWtype c0, c1, b1;
580 if ((Wtype) d >= 0)
582 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
584 /* Dividend, divisor, and quotient are nonnegative. */
585 sdiv_qrnnd (q, r, a1, a0, d);
587 else
589 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
590 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
591 /* Divide (c1*2^32 + c0) by d. */
592 sdiv_qrnnd (q, r, c1, c0, d);
593 /* Add 2^31 to quotient. */
594 q += (UWtype) 1 << (W_TYPE_SIZE - 1);
597 else
599 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
600 c1 = a1 >> 1; /* A/2 */
601 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
603 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
605 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
607 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
608 if ((d & 1) != 0)
610 if (r >= q)
611 r = r - q;
612 else if (q - r <= d)
614 r = r - q + d;
615 q--;
617 else
619 r = r - q + 2*d;
620 q -= 2;
624 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
626 c1 = (b1 - 1) - c1;
627 c0 = ~c0; /* logical NOT */
629 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
631 q = ~q; /* (A/2)/b1 */
632 r = (b1 - 1) - r;
634 r = 2*r + (a0 & 1); /* A/(2*b1) */
636 if ((d & 1) != 0)
638 if (r >= q)
639 r = r - q;
640 else if (q - r <= d)
642 r = r - q + d;
643 q--;
645 else
647 r = r - q + 2*d;
648 q -= 2;
652 else /* Implies c1 = b1 */
653 { /* Hence a1 = d - 1 = 2*b1 - 1 */
654 if (a0 >= -d)
656 q = -1;
657 r = a0 + d;
659 else
661 q = -2;
662 r = a0 + 2*d;
667 *rp = r;
668 return q;
670 #else
671 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
672 UWtype
673 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
674 UWtype a1 __attribute__ ((__unused__)),
675 UWtype a0 __attribute__ ((__unused__)),
676 UWtype d __attribute__ ((__unused__)))
678 return 0;
680 #endif
681 #endif
683 #if (defined (L_udivdi3) || defined (L_divdi3) || \
684 defined (L_umoddi3) || defined (L_moddi3) || \
685 defined (L_divmoddi4))
686 #define L_udivmoddi4
687 #endif
689 #ifdef L_clz
690 const UQItype __clz_tab[256] =
692 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,
693 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,
694 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
695 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,
696 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
697 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
698 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
699 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
701 #endif
703 #ifdef L_clzsi2
704 #undef int
706 __clzSI2 (UWtype x)
708 Wtype ret;
710 count_leading_zeros (ret, x);
712 return ret;
714 #endif
716 #ifdef L_clzdi2
717 #undef int
719 __clzDI2 (UDWtype x)
721 const DWunion uu = {.ll = x};
722 UWtype word;
723 Wtype ret, add;
725 if (uu.s.high)
726 word = uu.s.high, add = 0;
727 else
728 word = uu.s.low, add = W_TYPE_SIZE;
730 count_leading_zeros (ret, word);
731 return ret + add;
733 #endif
735 #ifdef L_ctzsi2
736 #undef int
738 __ctzSI2 (UWtype x)
740 Wtype ret;
742 count_trailing_zeros (ret, x);
744 return ret;
746 #endif
748 #ifdef L_ctzdi2
749 #undef int
751 __ctzDI2 (UDWtype x)
753 const DWunion uu = {.ll = x};
754 UWtype word;
755 Wtype ret, add;
757 if (uu.s.low)
758 word = uu.s.low, add = 0;
759 else
760 word = uu.s.high, add = W_TYPE_SIZE;
762 count_trailing_zeros (ret, word);
763 return ret + add;
765 #endif
767 #ifdef L_clrsbsi2
768 #undef int
770 __clrsbSI2 (Wtype x)
772 Wtype ret;
774 if (x < 0)
775 x = ~x;
776 if (x == 0)
777 return W_TYPE_SIZE - 1;
778 count_leading_zeros (ret, x);
779 return ret - 1;
781 #endif
783 #ifdef L_clrsbdi2
784 #undef int
786 __clrsbDI2 (DWtype x)
788 const DWunion uu = {.ll = x};
789 UWtype word;
790 Wtype ret, add;
792 if (uu.s.high == 0)
793 word = uu.s.low, add = W_TYPE_SIZE;
794 else if (uu.s.high == -1)
795 word = ~uu.s.low, add = W_TYPE_SIZE;
796 else if (uu.s.high >= 0)
797 word = uu.s.high, add = 0;
798 else
799 word = ~uu.s.high, add = 0;
801 if (word == 0)
802 ret = W_TYPE_SIZE;
803 else
804 count_leading_zeros (ret, word);
806 return ret + add - 1;
808 #endif
810 #ifdef L_popcount_tab
811 const UQItype __popcount_tab[256] =
813 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,
814 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,
815 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
816 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
817 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,
818 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,
819 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,
820 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
822 #endif
824 #if defined(L_popcountsi2) || defined(L_popcountdi2)
825 #define POPCOUNTCST2(x) (((UWtype) x << __CHAR_BIT__) | x)
826 #define POPCOUNTCST4(x) (((UWtype) x << (2 * __CHAR_BIT__)) | x)
827 #define POPCOUNTCST8(x) (((UWtype) x << (4 * __CHAR_BIT__)) | x)
828 #if W_TYPE_SIZE == __CHAR_BIT__
829 #define POPCOUNTCST(x) x
830 #elif W_TYPE_SIZE == 2 * __CHAR_BIT__
831 #define POPCOUNTCST(x) POPCOUNTCST2 (x)
832 #elif W_TYPE_SIZE == 4 * __CHAR_BIT__
833 #define POPCOUNTCST(x) POPCOUNTCST4 (POPCOUNTCST2 (x))
834 #elif W_TYPE_SIZE == 8 * __CHAR_BIT__
835 #define POPCOUNTCST(x) POPCOUNTCST8 (POPCOUNTCST4 (POPCOUNTCST2 (x)))
836 #endif
837 #endif
839 #ifdef L_popcountsi2
840 #undef int
842 __popcountSI2 (UWtype x)
844 /* Force table lookup on targets like AVR and RL78 which only
845 pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
846 have 1, and other small word targets. */
847 #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && __CHAR_BIT__ == 8
848 x = x - ((x >> 1) & POPCOUNTCST (0x55));
849 x = (x & POPCOUNTCST (0x33)) + ((x >> 2) & POPCOUNTCST (0x33));
850 x = (x + (x >> 4)) & POPCOUNTCST (0x0F);
851 return (x * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - __CHAR_BIT__);
852 #else
853 int i, ret = 0;
855 for (i = 0; i < W_TYPE_SIZE; i += 8)
856 ret += __popcount_tab[(x >> i) & 0xff];
858 return ret;
859 #endif
861 #endif
863 #ifdef L_popcountdi2
864 #undef int
866 __popcountDI2 (UDWtype x)
868 /* Force table lookup on targets like AVR and RL78 which only
869 pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
870 have 1, and other small word targets. */
871 #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && __CHAR_BIT__ == 8
872 const DWunion uu = {.ll = x};
873 UWtype x1 = uu.s.low, x2 = uu.s.high;
874 x1 = x1 - ((x1 >> 1) & POPCOUNTCST (0x55));
875 x2 = x2 - ((x2 >> 1) & POPCOUNTCST (0x55));
876 x1 = (x1 & POPCOUNTCST (0x33)) + ((x1 >> 2) & POPCOUNTCST (0x33));
877 x2 = (x2 & POPCOUNTCST (0x33)) + ((x2 >> 2) & POPCOUNTCST (0x33));
878 x1 = (x1 + (x1 >> 4)) & POPCOUNTCST (0x0F);
879 x2 = (x2 + (x2 >> 4)) & POPCOUNTCST (0x0F);
880 x1 += x2;
881 return (x1 * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - __CHAR_BIT__);
882 #else
883 int i, ret = 0;
885 for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
886 ret += __popcount_tab[(x >> i) & 0xff];
888 return ret;
889 #endif
891 #endif
893 #ifdef L_paritysi2
894 #undef int
896 __paritySI2 (UWtype x)
898 #if W_TYPE_SIZE > 64
899 # error "fill out the table"
900 #endif
901 #if W_TYPE_SIZE > 32
902 x ^= x >> 32;
903 #endif
904 #if W_TYPE_SIZE > 16
905 x ^= x >> 16;
906 #endif
907 x ^= x >> 8;
908 x ^= x >> 4;
909 x &= 0xf;
910 return (0x6996 >> x) & 1;
912 #endif
914 #ifdef L_paritydi2
915 #undef int
917 __parityDI2 (UDWtype x)
919 const DWunion uu = {.ll = x};
920 UWtype nx = uu.s.low ^ uu.s.high;
922 #if W_TYPE_SIZE > 64
923 # error "fill out the table"
924 #endif
925 #if W_TYPE_SIZE > 32
926 nx ^= nx >> 32;
927 #endif
928 #if W_TYPE_SIZE > 16
929 nx ^= nx >> 16;
930 #endif
931 nx ^= nx >> 8;
932 nx ^= nx >> 4;
933 nx &= 0xf;
934 return (0x6996 >> nx) & 1;
936 #endif
938 #ifdef L_udivmoddi4
939 #ifdef TARGET_HAS_NO_HW_DIVIDE
941 #if (defined (L_udivdi3) || defined (L_divdi3) || \
942 defined (L_umoddi3) || defined (L_moddi3) || \
943 defined (L_divmoddi4))
944 static inline __attribute__ ((__always_inline__))
945 #endif
946 UDWtype
947 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
949 UDWtype q = 0, r = n, y = d;
950 UWtype lz1, lz2, i, k;
952 /* Implements align divisor shift dividend method. This algorithm
953 aligns the divisor under the dividend and then perform number of
954 test-subtract iterations which shift the dividend left. Number of
955 iterations is k + 1 where k is the number of bit positions the
956 divisor must be shifted left to align it under the dividend.
957 quotient bits can be saved in the rightmost positions of the dividend
958 as it shifts left on each test-subtract iteration. */
960 if (y <= r)
962 lz1 = __builtin_clzll (d);
963 lz2 = __builtin_clzll (n);
965 k = lz1 - lz2;
966 y = (y << k);
968 /* Dividend can exceed 2 ^ (width − 1) − 1 but still be less than the
969 aligned divisor. Normal iteration can drops the high order bit
970 of the dividend. Therefore, first test-subtract iteration is a
971 special case, saving its quotient bit in a separate location and
972 not shifting the dividend. */
973 if (r >= y)
975 r = r - y;
976 q = (1ULL << k);
979 if (k > 0)
981 y = y >> 1;
983 /* k additional iterations where k regular test subtract shift
984 dividend iterations are done. */
985 i = k;
988 if (r >= y)
989 r = ((r - y) << 1) + 1;
990 else
991 r = (r << 1);
992 i = i - 1;
993 } while (i != 0);
995 /* First quotient bit is combined with the quotient bits resulting
996 from the k regular iterations. */
997 q = q + r;
998 r = r >> k;
999 q = q - (r << k);
1003 if (rp)
1004 *rp = r;
1005 return q;
1007 #else
1009 #if (defined (L_udivdi3) || defined (L_divdi3) || \
1010 defined (L_umoddi3) || defined (L_moddi3) || \
1011 defined (L_divmoddi4))
1012 static inline __attribute__ ((__always_inline__))
1013 #endif
1014 UDWtype
1015 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
1017 const DWunion nn = {.ll = n};
1018 const DWunion dd = {.ll = d};
1019 DWunion rr;
1020 UWtype d0, d1, n0, n1, n2;
1021 UWtype q0, q1;
1022 UWtype b, bm;
1024 d0 = dd.s.low;
1025 d1 = dd.s.high;
1026 n0 = nn.s.low;
1027 n1 = nn.s.high;
1029 #if !UDIV_NEEDS_NORMALIZATION
1030 if (d1 == 0)
1032 if (d0 > n1)
1034 /* 0q = nn / 0D */
1036 udiv_qrnnd (q0, n0, n1, n0, d0);
1037 q1 = 0;
1039 /* Remainder in n0. */
1041 else
1043 /* qq = NN / 0d */
1045 if (d0 == 0)
1046 d0 = 1 / d0; /* Divide intentionally by zero. */
1048 udiv_qrnnd (q1, n1, 0, n1, d0);
1049 udiv_qrnnd (q0, n0, n1, n0, d0);
1051 /* Remainder in n0. */
1054 if (rp != 0)
1056 rr.s.low = n0;
1057 rr.s.high = 0;
1058 *rp = rr.ll;
1062 #else /* UDIV_NEEDS_NORMALIZATION */
1064 if (d1 == 0)
1066 if (d0 > n1)
1068 /* 0q = nn / 0D */
1070 count_leading_zeros (bm, d0);
1072 if (bm != 0)
1074 /* Normalize, i.e. make the most significant bit of the
1075 denominator set. */
1077 d0 = d0 << bm;
1078 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
1079 n0 = n0 << bm;
1082 udiv_qrnnd (q0, n0, n1, n0, d0);
1083 q1 = 0;
1085 /* Remainder in n0 >> bm. */
1087 else
1089 /* qq = NN / 0d */
1091 if (d0 == 0)
1092 d0 = 1 / d0; /* Divide intentionally by zero. */
1094 count_leading_zeros (bm, d0);
1096 if (bm == 0)
1098 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
1099 conclude (the most significant bit of n1 is set) /\ (the
1100 leading quotient digit q1 = 1).
1102 This special case is necessary, not an optimization.
1103 (Shifts counts of W_TYPE_SIZE are undefined.) */
1105 n1 -= d0;
1106 q1 = 1;
1108 else
1110 /* Normalize. */
1112 b = W_TYPE_SIZE - bm;
1114 d0 = d0 << bm;
1115 n2 = n1 >> b;
1116 n1 = (n1 << bm) | (n0 >> b);
1117 n0 = n0 << bm;
1119 udiv_qrnnd (q1, n1, n2, n1, d0);
1122 /* n1 != d0... */
1124 udiv_qrnnd (q0, n0, n1, n0, d0);
1126 /* Remainder in n0 >> bm. */
1129 if (rp != 0)
1131 rr.s.low = n0 >> bm;
1132 rr.s.high = 0;
1133 *rp = rr.ll;
1136 #endif /* UDIV_NEEDS_NORMALIZATION */
1138 else
1140 if (d1 > n1)
1142 /* 00 = nn / DD */
1144 q0 = 0;
1145 q1 = 0;
1147 /* Remainder in n1n0. */
1148 if (rp != 0)
1150 rr.s.low = n0;
1151 rr.s.high = n1;
1152 *rp = rr.ll;
1155 else
1157 /* 0q = NN / dd */
1159 count_leading_zeros (bm, d1);
1160 if (bm == 0)
1162 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
1163 conclude (the most significant bit of n1 is set) /\ (the
1164 quotient digit q0 = 0 or 1).
1166 This special case is necessary, not an optimization. */
1168 /* The condition on the next line takes advantage of that
1169 n1 >= d1 (true due to program flow). */
1170 if (n1 > d1 || n0 >= d0)
1172 q0 = 1;
1173 sub_ddmmss (n1, n0, n1, n0, d1, d0);
1175 else
1176 q0 = 0;
1178 q1 = 0;
1180 if (rp != 0)
1182 rr.s.low = n0;
1183 rr.s.high = n1;
1184 *rp = rr.ll;
1187 else
1189 UWtype m1, m0;
1190 /* Normalize. */
1192 b = W_TYPE_SIZE - bm;
1194 d1 = (d1 << bm) | (d0 >> b);
1195 d0 = d0 << bm;
1196 n2 = n1 >> b;
1197 n1 = (n1 << bm) | (n0 >> b);
1198 n0 = n0 << bm;
1200 udiv_qrnnd (q0, n1, n2, n1, d1);
1201 umul_ppmm (m1, m0, q0, d0);
1203 if (m1 > n1 || (m1 == n1 && m0 > n0))
1205 q0--;
1206 sub_ddmmss (m1, m0, m1, m0, d1, d0);
1209 q1 = 0;
1211 /* Remainder in (n1n0 - m1m0) >> bm. */
1212 if (rp != 0)
1214 sub_ddmmss (n1, n0, n1, n0, m1, m0);
1215 rr.s.low = (n1 << b) | (n0 >> bm);
1216 rr.s.high = n1 >> bm;
1217 *rp = rr.ll;
1223 const DWunion ww = {{.low = q0, .high = q1}};
1224 return ww.ll;
1226 #endif
1227 #endif
1229 #ifdef L_divdi3
1230 DWtype
1231 __divdi3 (DWtype u, DWtype v)
1233 Wtype c = 0;
1234 DWunion uu = {.ll = u};
1235 DWunion vv = {.ll = v};
1236 DWtype w;
1238 if (uu.s.high < 0)
1239 c = ~c,
1240 uu.ll = -uu.ll;
1241 if (vv.s.high < 0)
1242 c = ~c,
1243 vv.ll = -vv.ll;
1245 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
1246 if (c)
1247 w = -w;
1249 return w;
1251 #endif
1253 #ifdef L_moddi3
1254 DWtype
1255 __moddi3 (DWtype u, DWtype v)
1257 Wtype c = 0;
1258 DWunion uu = {.ll = u};
1259 DWunion vv = {.ll = v};
1260 DWtype w;
1262 if (uu.s.high < 0)
1263 c = ~c,
1264 uu.ll = -uu.ll;
1265 if (vv.s.high < 0)
1266 vv.ll = -vv.ll;
1268 (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
1269 if (c)
1270 w = -w;
1272 return w;
1274 #endif
1276 #ifdef L_divmoddi4
1277 DWtype
1278 __divmoddi4 (DWtype u, DWtype v, DWtype *rp)
1280 Wtype c1 = 0, c2 = 0;
1281 DWunion uu = {.ll = u};
1282 DWunion vv = {.ll = v};
1283 DWtype w;
1284 DWtype r;
1286 if (uu.s.high < 0)
1287 c1 = ~c1, c2 = ~c2,
1288 uu.ll = -uu.ll;
1289 if (vv.s.high < 0)
1290 c1 = ~c1,
1291 vv.ll = -vv.ll;
1293 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&r);
1294 if (c1)
1295 w = -w;
1296 if (c2)
1297 r = -r;
1299 *rp = r;
1300 return w;
1302 #endif
1304 #ifdef L_umoddi3
1305 UDWtype
1306 __umoddi3 (UDWtype u, UDWtype v)
1308 UDWtype w;
1310 (void) __udivmoddi4 (u, v, &w);
1312 return w;
1314 #endif
1316 #ifdef L_udivdi3
1317 UDWtype
1318 __udivdi3 (UDWtype n, UDWtype d)
1320 return __udivmoddi4 (n, d, (UDWtype *) 0);
1322 #endif
1324 #ifdef L_cmpdi2
1325 cmp_return_type
1326 __cmpdi2 (DWtype a, DWtype b)
1328 const DWunion au = {.ll = a};
1329 const DWunion bu = {.ll = b};
1331 if (au.s.high < bu.s.high)
1332 return 0;
1333 else if (au.s.high > bu.s.high)
1334 return 2;
1335 if ((UWtype) au.s.low < (UWtype) bu.s.low)
1336 return 0;
1337 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1338 return 2;
1339 return 1;
1341 #endif
1343 #ifdef L_ucmpdi2
1344 cmp_return_type
1345 __ucmpdi2 (DWtype a, DWtype b)
1347 const DWunion au = {.ll = a};
1348 const DWunion bu = {.ll = b};
1350 if ((UWtype) au.s.high < (UWtype) bu.s.high)
1351 return 0;
1352 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
1353 return 2;
1354 if ((UWtype) au.s.low < (UWtype) bu.s.low)
1355 return 0;
1356 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1357 return 2;
1358 return 1;
1360 #endif
1362 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1363 UDWtype
1364 __fixunstfDI (TFtype a)
1366 if (a < 0)
1367 return 0;
1369 /* Compute high word of result, as a flonum. */
1370 const TFtype b = (a / Wtype_MAXp1_F);
1371 /* Convert that to fixed (but not to DWtype!),
1372 and shift it into the high word. */
1373 UDWtype v = (UWtype) b;
1374 v <<= W_TYPE_SIZE;
1375 /* Remove high part from the TFtype, leaving the low part as flonum. */
1376 a -= (TFtype)v;
1377 /* Convert that to fixed (but not to DWtype!) and add it in.
1378 Sometimes A comes out negative. This is significant, since
1379 A has more bits than a long int does. */
1380 if (a < 0)
1381 v -= (UWtype) (- a);
1382 else
1383 v += (UWtype) a;
1384 return v;
1386 #endif
1388 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1389 DWtype
1390 __fixtfdi (TFtype a)
1392 if (a < 0)
1393 return - __fixunstfDI (-a);
1394 return __fixunstfDI (a);
1396 #endif
1398 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1399 UDWtype
1400 __fixunsxfDI (XFtype a)
1402 if (a < 0)
1403 return 0;
1405 /* Compute high word of result, as a flonum. */
1406 const XFtype b = (a / Wtype_MAXp1_F);
1407 /* Convert that to fixed (but not to DWtype!),
1408 and shift it into the high word. */
1409 UDWtype v = (UWtype) b;
1410 v <<= W_TYPE_SIZE;
1411 /* Remove high part from the XFtype, leaving the low part as flonum. */
1412 a -= (XFtype)v;
1413 /* Convert that to fixed (but not to DWtype!) and add it in.
1414 Sometimes A comes out negative. This is significant, since
1415 A has more bits than a long int does. */
1416 if (a < 0)
1417 v -= (UWtype) (- a);
1418 else
1419 v += (UWtype) a;
1420 return v;
1422 #endif
1424 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1425 DWtype
1426 __fixxfdi (XFtype a)
1428 if (a < 0)
1429 return - __fixunsxfDI (-a);
1430 return __fixunsxfDI (a);
1432 #endif
1434 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1435 UDWtype
1436 __fixunsdfDI (DFtype a)
1438 /* Get high part of result. The division here will just moves the radix
1439 point and will not cause any rounding. Then the conversion to integral
1440 type chops result as desired. */
1441 const UWtype hi = a / Wtype_MAXp1_F;
1443 /* Get low part of result. Convert `hi' to floating type and scale it back,
1444 then subtract this from the number being converted. This leaves the low
1445 part. Convert that to integral type. */
1446 const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
1448 /* Assemble result from the two parts. */
1449 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1451 #endif
1453 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1454 DWtype
1455 __fixdfdi (DFtype a)
1457 if (a < 0)
1458 return - __fixunsdfDI (-a);
1459 return __fixunsdfDI (a);
1461 #endif
1463 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1464 UDWtype
1465 __fixunssfDI (SFtype a)
1467 #if LIBGCC2_HAS_DF_MODE
1468 /* Convert the SFtype to a DFtype, because that is surely not going
1469 to lose any bits. Some day someone else can write a faster version
1470 that avoids converting to DFtype, and verify it really works right. */
1471 const DFtype dfa = a;
1473 /* Get high part of result. The division here will just moves the radix
1474 point and will not cause any rounding. Then the conversion to integral
1475 type chops result as desired. */
1476 const UWtype hi = dfa / Wtype_MAXp1_F;
1478 /* Get low part of result. Convert `hi' to floating type and scale it back,
1479 then subtract this from the number being converted. This leaves the low
1480 part. Convert that to integral type. */
1481 const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
1483 /* Assemble result from the two parts. */
1484 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1485 #elif FLT_MANT_DIG < W_TYPE_SIZE
1486 if (a < 1)
1487 return 0;
1488 if (a < Wtype_MAXp1_F)
1489 return (UWtype)a;
1490 if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
1492 /* Since we know that there are fewer significant bits in the SFmode
1493 quantity than in a word, we know that we can convert out all the
1494 significant bits in one step, and thus avoid losing bits. */
1496 /* ??? This following loop essentially performs frexpf. If we could
1497 use the real libm function, or poke at the actual bits of the fp
1498 format, it would be significantly faster. */
1500 UWtype shift = 0, counter;
1501 SFtype msb;
1503 a /= Wtype_MAXp1_F;
1504 for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
1506 SFtype counterf = (UWtype)1 << counter;
1507 if (a >= counterf)
1509 shift |= counter;
1510 a /= counterf;
1514 /* Rescale into the range of one word, extract the bits of that
1515 one word, and shift the result into position. */
1516 a *= Wtype_MAXp1_F;
1517 counter = a;
1518 return (DWtype)counter << shift;
1520 return -1;
1521 #else
1522 # error
1523 #endif
1525 #endif
1527 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1528 DWtype
1529 __fixsfdi (SFtype a)
1531 if (a < 0)
1532 return - __fixunssfDI (-a);
1533 return __fixunssfDI (a);
1535 #endif
1537 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1538 XFtype
1539 __floatdixf (DWtype u)
1541 #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
1542 # error
1543 #endif
1544 XFtype d = (Wtype) (u >> W_TYPE_SIZE);
1545 d *= Wtype_MAXp1_F;
1546 d += (UWtype)u;
1547 return d;
1549 #endif
1551 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
1552 XFtype
1553 __floatundixf (UDWtype u)
1555 #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
1556 # error
1557 #endif
1558 XFtype d = (UWtype) (u >> W_TYPE_SIZE);
1559 d *= Wtype_MAXp1_F;
1560 d += (UWtype)u;
1561 return d;
1563 #endif
1565 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1566 TFtype
1567 __floatditf (DWtype u)
1569 #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
1570 # error
1571 #endif
1572 TFtype d = (Wtype) (u >> W_TYPE_SIZE);
1573 d *= Wtype_MAXp1_F;
1574 d += (UWtype)u;
1575 return d;
1577 #endif
1579 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
1580 TFtype
1581 __floatunditf (UDWtype u)
1583 #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
1584 # error
1585 #endif
1586 TFtype d = (UWtype) (u >> W_TYPE_SIZE);
1587 d *= Wtype_MAXp1_F;
1588 d += (UWtype)u;
1589 return d;
1591 #endif
1593 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
1594 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
1595 #define DI_SIZE (W_TYPE_SIZE * 2)
1596 #define F_MODE_OK(SIZE) \
1597 (SIZE < DI_SIZE \
1598 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1599 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1600 #if defined(L_floatdisf)
1601 #define FUNC __floatdisf
1602 #define FSTYPE SFtype
1603 #define FSSIZE __LIBGCC_SF_MANT_DIG__
1604 #else
1605 #define FUNC __floatdidf
1606 #define FSTYPE DFtype
1607 #define FSSIZE __LIBGCC_DF_MANT_DIG__
1608 #endif
1610 FSTYPE
1611 FUNC (DWtype u)
1613 #if FSSIZE >= W_TYPE_SIZE
1614 /* When the word size is small, we never get any rounding error. */
1615 FSTYPE f = (Wtype) (u >> W_TYPE_SIZE);
1616 f *= Wtype_MAXp1_F;
1617 f += (UWtype)u;
1618 return f;
1619 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
1620 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
1621 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1623 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
1624 # define FSIZE __LIBGCC_DF_MANT_DIG__
1625 # define FTYPE DFtype
1626 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
1627 # define FSIZE __LIBGCC_XF_MANT_DIG__
1628 # define FTYPE XFtype
1629 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1630 # define FSIZE __LIBGCC_TF_MANT_DIG__
1631 # define FTYPE TFtype
1632 #else
1633 # error
1634 #endif
1636 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1638 /* Protect against double-rounding error.
1639 Represent any low-order bits, that might be truncated by a bit that
1640 won't be lost. The bit can go in anywhere below the rounding position
1641 of the FSTYPE. A fixed mask and bit position handles all usual
1642 configurations. */
1643 if (! (- ((DWtype) 1 << FSIZE) < u
1644 && u < ((DWtype) 1 << FSIZE)))
1646 if ((UDWtype) u & (REP_BIT - 1))
1648 u &= ~ (REP_BIT - 1);
1649 u |= REP_BIT;
1653 /* Do the calculation in a wider type so that we don't lose any of
1654 the precision of the high word while multiplying it. */
1655 FTYPE f = (Wtype) (u >> W_TYPE_SIZE);
1656 f *= Wtype_MAXp1_F;
1657 f += (UWtype)u;
1658 return (FSTYPE) f;
1659 #else
1660 #if FSSIZE >= W_TYPE_SIZE - 2
1661 # error
1662 #endif
1663 /* Finally, the word size is larger than the number of bits in the
1664 required FSTYPE, and we've got no suitable wider type. The only
1665 way to avoid double rounding is to special case the
1666 extraction. */
1668 /* If there are no high bits set, fall back to one conversion. */
1669 if ((Wtype)u == u)
1670 return (FSTYPE)(Wtype)u;
1672 /* Otherwise, find the power of two. */
1673 Wtype hi = u >> W_TYPE_SIZE;
1674 if (hi < 0)
1675 hi = -(UWtype) hi;
1677 UWtype count, shift;
1678 #if !defined (COUNT_LEADING_ZEROS_0) || COUNT_LEADING_ZEROS_0 != W_TYPE_SIZE
1679 if (hi == 0)
1680 count = W_TYPE_SIZE;
1681 else
1682 #endif
1683 count_leading_zeros (count, hi);
1685 /* No leading bits means u == minimum. */
1686 if (count == 0)
1687 return Wtype_MAXp1_F * (FSTYPE) (hi | ((UWtype) u != 0));
1689 shift = 1 + W_TYPE_SIZE - count;
1691 /* Shift down the most significant bits. */
1692 hi = u >> shift;
1694 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1695 if ((UWtype)u << (W_TYPE_SIZE - shift))
1696 hi |= 1;
1698 /* Convert the one word of data, and rescale. */
1699 FSTYPE f = hi, e;
1700 if (shift == W_TYPE_SIZE)
1701 e = Wtype_MAXp1_F;
1702 /* The following two cases could be merged if we knew that the target
1703 supported a native unsigned->float conversion. More often, we only
1704 have a signed conversion, and have to add extra fixup code. */
1705 else if (shift == W_TYPE_SIZE - 1)
1706 e = Wtype_MAXp1_F / 2;
1707 else
1708 e = (Wtype)1 << shift;
1709 return f * e;
1710 #endif
1712 #endif
1714 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
1715 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
1716 #define DI_SIZE (W_TYPE_SIZE * 2)
1717 #define F_MODE_OK(SIZE) \
1718 (SIZE < DI_SIZE \
1719 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1720 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1721 #if defined(L_floatundisf)
1722 #define FUNC __floatundisf
1723 #define FSTYPE SFtype
1724 #define FSSIZE __LIBGCC_SF_MANT_DIG__
1725 #else
1726 #define FUNC __floatundidf
1727 #define FSTYPE DFtype
1728 #define FSSIZE __LIBGCC_DF_MANT_DIG__
1729 #endif
1731 FSTYPE
1732 FUNC (UDWtype u)
1734 #if FSSIZE >= W_TYPE_SIZE
1735 /* When the word size is small, we never get any rounding error. */
1736 FSTYPE f = (UWtype) (u >> W_TYPE_SIZE);
1737 f *= Wtype_MAXp1_F;
1738 f += (UWtype)u;
1739 return f;
1740 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
1741 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
1742 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1744 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
1745 # define FSIZE __LIBGCC_DF_MANT_DIG__
1746 # define FTYPE DFtype
1747 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
1748 # define FSIZE __LIBGCC_XF_MANT_DIG__
1749 # define FTYPE XFtype
1750 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1751 # define FSIZE __LIBGCC_TF_MANT_DIG__
1752 # define FTYPE TFtype
1753 #else
1754 # error
1755 #endif
1757 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1759 /* Protect against double-rounding error.
1760 Represent any low-order bits, that might be truncated by a bit that
1761 won't be lost. The bit can go in anywhere below the rounding position
1762 of the FSTYPE. A fixed mask and bit position handles all usual
1763 configurations. */
1764 if (u >= ((UDWtype) 1 << FSIZE))
1766 if ((UDWtype) u & (REP_BIT - 1))
1768 u &= ~ (REP_BIT - 1);
1769 u |= REP_BIT;
1773 /* Do the calculation in a wider type so that we don't lose any of
1774 the precision of the high word while multiplying it. */
1775 FTYPE f = (UWtype) (u >> W_TYPE_SIZE);
1776 f *= Wtype_MAXp1_F;
1777 f += (UWtype)u;
1778 return (FSTYPE) f;
1779 #else
1780 #if FSSIZE == W_TYPE_SIZE - 1
1781 # error
1782 #endif
1783 /* Finally, the word size is larger than the number of bits in the
1784 required FSTYPE, and we've got no suitable wider type. The only
1785 way to avoid double rounding is to special case the
1786 extraction. */
1788 /* If there are no high bits set, fall back to one conversion. */
1789 if ((UWtype)u == u)
1790 return (FSTYPE)(UWtype)u;
1792 /* Otherwise, find the power of two. */
1793 UWtype hi = u >> W_TYPE_SIZE;
1795 UWtype count, shift;
1796 count_leading_zeros (count, hi);
1798 shift = W_TYPE_SIZE - count;
1800 /* Shift down the most significant bits. */
1801 hi = u >> shift;
1803 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1804 if ((UWtype)u << (W_TYPE_SIZE - shift))
1805 hi |= 1;
1807 /* Convert the one word of data, and rescale. */
1808 FSTYPE f = hi, e;
1809 if (shift == W_TYPE_SIZE)
1810 e = Wtype_MAXp1_F;
1811 /* The following two cases could be merged if we knew that the target
1812 supported a native unsigned->float conversion. More often, we only
1813 have a signed conversion, and have to add extra fixup code. */
1814 else if (shift == W_TYPE_SIZE - 1)
1815 e = Wtype_MAXp1_F / 2;
1816 else
1817 e = (Wtype)1 << shift;
1818 return f * e;
1819 #endif
1821 #endif
1823 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1824 UWtype
1825 __fixunsxfSI (XFtype a)
1827 if (a >= - (DFtype) Wtype_MIN)
1828 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1829 return (Wtype) a;
1831 #endif
1833 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1834 UWtype
1835 __fixunsdfSI (DFtype a)
1837 if (a >= - (DFtype) Wtype_MIN)
1838 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1839 return (Wtype) a;
1841 #endif
1843 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1844 UWtype
1845 __fixunssfSI (SFtype a)
1847 if (a >= - (SFtype) Wtype_MIN)
1848 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1849 return (Wtype) a;
1851 #endif
1853 /* Integer power helper used from __builtin_powi for non-constant
1854 exponents. */
1856 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1857 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1858 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1859 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1860 # if defined(L_powisf2)
1861 # define TYPE SFtype
1862 # define NAME __powisf2
1863 # elif defined(L_powidf2)
1864 # define TYPE DFtype
1865 # define NAME __powidf2
1866 # elif defined(L_powixf2)
1867 # define TYPE XFtype
1868 # define NAME __powixf2
1869 # elif defined(L_powitf2)
1870 # define TYPE TFtype
1871 # define NAME __powitf2
1872 # endif
1874 #undef int
1875 #undef unsigned
1876 TYPE
1877 NAME (TYPE x, int m)
1879 unsigned int n = m < 0 ? -m : m;
1880 TYPE y = n % 2 ? x : 1;
1881 while (n >>= 1)
1883 x = x * x;
1884 if (n % 2)
1885 y = y * x;
1887 return m < 0 ? 1/y : y;
1890 #endif
1892 #if((defined(L_mulhc3) || defined(L_divhc3)) && LIBGCC2_HAS_HF_MODE) \
1893 || ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1894 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1895 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1896 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1898 #undef float
1899 #undef double
1900 #undef long
1902 #if defined(L_mulhc3) || defined(L_divhc3)
1903 # define MTYPE HFtype
1904 # define CTYPE HCtype
1905 # define MODE hc
1906 # define CEXT __LIBGCC_HF_FUNC_EXT__
1907 # define NOTRUNC (!__LIBGCC_HF_EXCESS_PRECISION__)
1908 #elif defined(L_mulsc3) || defined(L_divsc3)
1909 # define MTYPE SFtype
1910 # define CTYPE SCtype
1911 # define MODE sc
1912 # define CEXT __LIBGCC_SF_FUNC_EXT__
1913 # define NOTRUNC (!__LIBGCC_SF_EXCESS_PRECISION__)
1914 #elif defined(L_muldc3) || defined(L_divdc3)
1915 # define MTYPE DFtype
1916 # define CTYPE DCtype
1917 # define MODE dc
1918 # define CEXT __LIBGCC_DF_FUNC_EXT__
1919 # define NOTRUNC (!__LIBGCC_DF_EXCESS_PRECISION__)
1920 #elif defined(L_mulxc3) || defined(L_divxc3)
1921 # define MTYPE XFtype
1922 # define CTYPE XCtype
1923 # define MODE xc
1924 # define CEXT __LIBGCC_XF_FUNC_EXT__
1925 # define NOTRUNC (!__LIBGCC_XF_EXCESS_PRECISION__)
1926 #elif defined(L_multc3) || defined(L_divtc3)
1927 # define MTYPE TFtype
1928 # define CTYPE TCtype
1929 # define MODE tc
1930 # define CEXT __LIBGCC_TF_FUNC_EXT__
1931 # define NOTRUNC (!__LIBGCC_TF_EXCESS_PRECISION__)
1932 #else
1933 # error
1934 #endif
1936 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
1937 #define _CONCAT3(A,B,C) A##B##C
1939 #define CONCAT2(A,B) _CONCAT2(A,B)
1940 #define _CONCAT2(A,B) A##B
1942 #define isnan(x) __builtin_isnan (x)
1943 #define isfinite(x) __builtin_isfinite (x)
1944 #define isinf(x) __builtin_isinf (x)
1946 #define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
1947 #define I 1i
1949 /* Helpers to make the following code slightly less gross. */
1950 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
1951 #define FABS CONCAT2(__builtin_fabs, CEXT)
1953 /* Verify that MTYPE matches up with CEXT. */
1954 extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
1956 /* Ensure that we've lost any extra precision. */
1957 #if NOTRUNC
1958 # define TRUNC(x)
1959 #else
1960 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
1961 #endif
1963 #if defined(L_mulhc3) || defined(L_mulsc3) || defined(L_muldc3) \
1964 || defined(L_mulxc3) || defined(L_multc3)
1966 CTYPE
1967 CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
1969 MTYPE ac, bd, ad, bc, x, y;
1970 CTYPE res;
1972 ac = a * c;
1973 bd = b * d;
1974 ad = a * d;
1975 bc = b * c;
1977 TRUNC (ac);
1978 TRUNC (bd);
1979 TRUNC (ad);
1980 TRUNC (bc);
1982 x = ac - bd;
1983 y = ad + bc;
1985 if (isnan (x) && isnan (y))
1987 /* Recover infinities that computed as NaN + iNaN. */
1988 _Bool recalc = 0;
1989 if (isinf (a) || isinf (b))
1991 /* z is infinite. "Box" the infinity and change NaNs in
1992 the other factor to 0. */
1993 a = COPYSIGN (isinf (a) ? 1 : 0, a);
1994 b = COPYSIGN (isinf (b) ? 1 : 0, b);
1995 if (isnan (c)) c = COPYSIGN (0, c);
1996 if (isnan (d)) d = COPYSIGN (0, d);
1997 recalc = 1;
1999 if (isinf (c) || isinf (d))
2001 /* w is infinite. "Box" the infinity and change NaNs in
2002 the other factor to 0. */
2003 c = COPYSIGN (isinf (c) ? 1 : 0, c);
2004 d = COPYSIGN (isinf (d) ? 1 : 0, d);
2005 if (isnan (a)) a = COPYSIGN (0, a);
2006 if (isnan (b)) b = COPYSIGN (0, b);
2007 recalc = 1;
2009 if (!recalc
2010 && (isinf (ac) || isinf (bd)
2011 || isinf (ad) || isinf (bc)))
2013 /* Recover infinities from overflow by changing NaNs to 0. */
2014 if (isnan (a)) a = COPYSIGN (0, a);
2015 if (isnan (b)) b = COPYSIGN (0, b);
2016 if (isnan (c)) c = COPYSIGN (0, c);
2017 if (isnan (d)) d = COPYSIGN (0, d);
2018 recalc = 1;
2020 if (recalc)
2022 x = INFINITY * (a * c - b * d);
2023 y = INFINITY * (a * d + b * c);
2027 __real__ res = x;
2028 __imag__ res = y;
2029 return res;
2031 #endif /* complex multiply */
2033 #if defined(L_divhc3) || defined(L_divsc3) || defined(L_divdc3) \
2034 || defined(L_divxc3) || defined(L_divtc3)
2036 CTYPE
2037 CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
2039 MTYPE denom, ratio, x, y;
2040 CTYPE res;
2042 /* ??? We can get better behavior from logarithmic scaling instead of
2043 the division. But that would mean starting to link libgcc against
2044 libm. We could implement something akin to ldexp/frexp as gcc builtins
2045 fairly easily... */
2046 if (FABS (c) < FABS (d))
2048 ratio = c / d;
2049 denom = (c * ratio) + d;
2050 x = ((a * ratio) + b) / denom;
2051 y = ((b * ratio) - a) / denom;
2053 else
2055 ratio = d / c;
2056 denom = (d * ratio) + c;
2057 x = ((b * ratio) + a) / denom;
2058 y = (b - (a * ratio)) / denom;
2061 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
2062 are nonzero/zero, infinite/finite, and finite/infinite. */
2063 if (isnan (x) && isnan (y))
2065 if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b)))
2067 x = COPYSIGN (INFINITY, c) * a;
2068 y = COPYSIGN (INFINITY, c) * b;
2070 else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d))
2072 a = COPYSIGN (isinf (a) ? 1 : 0, a);
2073 b = COPYSIGN (isinf (b) ? 1 : 0, b);
2074 x = INFINITY * (a * c + b * d);
2075 y = INFINITY * (b * c - a * d);
2077 else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b))
2079 c = COPYSIGN (isinf (c) ? 1 : 0, c);
2080 d = COPYSIGN (isinf (d) ? 1 : 0, d);
2081 x = 0.0 * (a * c + b * d);
2082 y = 0.0 * (b * c - a * d);
2086 __real__ res = x;
2087 __imag__ res = y;
2088 return res;
2090 #endif /* complex divide */
2092 #endif /* all complex float routines */
2094 /* From here on down, the routines use normal data types. */
2096 #define SItype bogus_type
2097 #define USItype bogus_type
2098 #define DItype bogus_type
2099 #define UDItype bogus_type
2100 #define SFtype bogus_type
2101 #define DFtype bogus_type
2102 #undef Wtype
2103 #undef UWtype
2104 #undef HWtype
2105 #undef UHWtype
2106 #undef DWtype
2107 #undef UDWtype
2109 #undef char
2110 #undef short
2111 #undef int
2112 #undef long
2113 #undef unsigned
2114 #undef float
2115 #undef double
2117 #ifdef L__gcc_bcmp
2119 /* Like bcmp except the sign is meaningful.
2120 Result is negative if S1 is less than S2,
2121 positive if S1 is greater, 0 if S1 and S2 are equal. */
2124 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
2126 while (size > 0)
2128 const unsigned char c1 = *s1++, c2 = *s2++;
2129 if (c1 != c2)
2130 return c1 - c2;
2131 size--;
2133 return 0;
2136 #endif
2138 /* __eprintf used to be used by GCC's private version of <assert.h>.
2139 We no longer provide that header, but this routine remains in libgcc.a
2140 for binary backward compatibility. Note that it is not included in
2141 the shared version of libgcc. */
2142 #ifdef L_eprintf
2143 #ifndef inhibit_libc
2145 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2146 #include <stdio.h>
2148 void
2149 __eprintf (const char *string, const char *expression,
2150 unsigned int line, const char *filename)
2152 fprintf (stderr, string, expression, line, filename);
2153 fflush (stderr);
2154 abort ();
2157 #endif
2158 #endif
2161 #ifdef L_clear_cache
2162 /* Clear part of an instruction cache. */
2164 void
2165 __clear_cache (void *beg __attribute__((__unused__)),
2166 void *end __attribute__((__unused__)))
2168 #ifdef CLEAR_INSN_CACHE
2169 /* Cast the void* pointers to char* as some implementations
2170 of the macro assume the pointers can be subtracted from
2171 one another. */
2172 CLEAR_INSN_CACHE ((char *) beg, (char *) end);
2173 #endif /* CLEAR_INSN_CACHE */
2176 #endif /* L_clear_cache */
2178 #ifdef L_trampoline
2180 /* Jump to a trampoline, loading the static chain address. */
2182 #if defined(WINNT) && ! defined(__CYGWIN__)
2183 #include <windows.h>
2184 int getpagesize (void);
2185 int mprotect (char *,int, int);
2188 getpagesize (void)
2190 #ifdef _ALPHA_
2191 return 8192;
2192 #else
2193 return 4096;
2194 #endif
2198 mprotect (char *addr, int len, int prot)
2200 DWORD np, op;
2202 if (prot == 7)
2203 np = 0x40;
2204 else if (prot == 5)
2205 np = 0x20;
2206 else if (prot == 4)
2207 np = 0x10;
2208 else if (prot == 3)
2209 np = 0x04;
2210 else if (prot == 1)
2211 np = 0x02;
2212 else if (prot == 0)
2213 np = 0x01;
2214 else
2215 return -1;
2217 if (VirtualProtect (addr, len, np, &op))
2218 return 0;
2219 else
2220 return -1;
2223 #endif /* WINNT && ! __CYGWIN__ */
2225 #ifdef TRANSFER_FROM_TRAMPOLINE
2226 TRANSFER_FROM_TRAMPOLINE
2227 #endif
2228 #endif /* L_trampoline */
2230 #ifndef __CYGWIN__
2231 #ifdef L__main
2233 #include "gbl-ctors.h"
2235 /* Some systems use __main in a way incompatible with its use in gcc, in these
2236 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2237 give the same symbol without quotes for an alternative entry point. You
2238 must define both, or neither. */
2239 #ifndef NAME__MAIN
2240 #define NAME__MAIN "__main"
2241 #define SYMBOL__MAIN __main
2242 #endif
2244 #if defined (__LIBGCC_INIT_SECTION_ASM_OP__) \
2245 || defined (__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__)
2246 #undef HAS_INIT_SECTION
2247 #define HAS_INIT_SECTION
2248 #endif
2250 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2252 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2253 code to run constructors. In that case, we need to handle EH here, too.
2254 But MINGW32 is special because it handles CRTSTUFF and EH on its own. */
2256 #ifdef __MINGW32__
2257 #undef __LIBGCC_EH_FRAME_SECTION_NAME__
2258 #endif
2260 #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
2261 #include "unwind-dw2-fde.h"
2262 extern unsigned char __EH_FRAME_BEGIN__[];
2263 #endif
2265 /* Run all the global destructors on exit from the program. */
2267 void
2268 __do_global_dtors (void)
2270 #ifdef DO_GLOBAL_DTORS_BODY
2271 DO_GLOBAL_DTORS_BODY;
2272 #else
2273 static func_ptr *p = __DTOR_LIST__ + 1;
2274 while (*p)
2276 p++;
2277 (*(p-1)) ();
2279 #endif
2280 #if defined (__LIBGCC_EH_FRAME_SECTION_NAME__) && !defined (HAS_INIT_SECTION)
2282 static int completed = 0;
2283 if (! completed)
2285 completed = 1;
2286 __deregister_frame_info (__EH_FRAME_BEGIN__);
2289 #endif
2291 #endif
2293 #ifndef HAS_INIT_SECTION
2294 /* Run all the global constructors on entry to the program. */
2296 void
2297 __do_global_ctors (void)
2299 #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
2301 static struct object object;
2302 __register_frame_info (__EH_FRAME_BEGIN__, &object);
2304 #endif
2305 DO_GLOBAL_CTORS_BODY;
2306 atexit (__do_global_dtors);
2308 #endif /* no HAS_INIT_SECTION */
2310 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2311 /* Subroutine called automatically by `main'.
2312 Compiling a global function named `main'
2313 produces an automatic call to this function at the beginning.
2315 For many systems, this routine calls __do_global_ctors.
2316 For systems which support a .init section we use the .init section
2317 to run __do_global_ctors, so we need not do anything here. */
2319 extern void SYMBOL__MAIN (void);
2320 void
2321 SYMBOL__MAIN (void)
2323 /* Support recursive calls to `main': run initializers just once. */
2324 static int initialized;
2325 if (! initialized)
2327 initialized = 1;
2328 __do_global_ctors ();
2331 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2333 #endif /* L__main */
2334 #endif /* __CYGWIN__ */
2336 #ifdef L_ctors
2338 #include "gbl-ctors.h"
2340 /* Provide default definitions for the lists of constructors and
2341 destructors, so that we don't get linker errors. These symbols are
2342 intentionally bss symbols, so that gld and/or collect will provide
2343 the right values. */
2345 /* We declare the lists here with two elements each,
2346 so that they are valid empty lists if no other definition is loaded.
2348 If we are using the old "set" extensions to have the gnu linker
2349 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2350 must be in the bss/common section.
2352 Long term no port should use those extensions. But many still do. */
2353 #if !defined(__LIBGCC_INIT_SECTION_ASM_OP__)
2354 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2355 func_ptr __CTOR_LIST__[2] = {0, 0};
2356 func_ptr __DTOR_LIST__[2] = {0, 0};
2357 #else
2358 func_ptr __CTOR_LIST__[2];
2359 func_ptr __DTOR_LIST__[2];
2360 #endif
2361 #endif /* no __LIBGCC_INIT_SECTION_ASM_OP__ */
2362 #endif /* L_ctors */
2363 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */