Daily bump.
[official-gcc.git] / libgcc / libgcc2.c
blobc7376206d64f5c720cd20d4aebbf97f31e32f42c
1 /* More subroutines needed by GCC output code on some machines. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2015 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) * BITS_PER_UNIT)
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 == (Wtype) -1 && vv.s.high == (Wtype) - 1)
380 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
381 * (UDWtype) (UWtype) vv.s.low};
383 ww.s.high -= uu.s.low;
384 ww.s.high -= vv.s.low;
385 if (__builtin_expect (ww.s.high >= 0, 1))
386 return ww.ll;
393 /* Overflow. */
394 abort ();
396 #endif
399 /* Unless shift functions are defined with full ANSI prototypes,
400 parameter b will be promoted to int if shift_count_type is smaller than an int. */
401 #ifdef L_lshrdi3
402 DWtype
403 __lshrdi3 (DWtype u, shift_count_type b)
405 if (b == 0)
406 return u;
408 const DWunion uu = {.ll = u};
409 const shift_count_type bm = W_TYPE_SIZE - b;
410 DWunion w;
412 if (bm <= 0)
414 w.s.high = 0;
415 w.s.low = (UWtype) uu.s.high >> -bm;
417 else
419 const UWtype carries = (UWtype) uu.s.high << bm;
421 w.s.high = (UWtype) uu.s.high >> b;
422 w.s.low = ((UWtype) uu.s.low >> b) | carries;
425 return w.ll;
427 #endif
429 #ifdef L_ashldi3
430 DWtype
431 __ashldi3 (DWtype u, shift_count_type b)
433 if (b == 0)
434 return u;
436 const DWunion uu = {.ll = u};
437 const shift_count_type bm = W_TYPE_SIZE - b;
438 DWunion w;
440 if (bm <= 0)
442 w.s.low = 0;
443 w.s.high = (UWtype) uu.s.low << -bm;
445 else
447 const UWtype carries = (UWtype) uu.s.low >> bm;
449 w.s.low = (UWtype) uu.s.low << b;
450 w.s.high = ((UWtype) uu.s.high << b) | carries;
453 return w.ll;
455 #endif
457 #ifdef L_ashrdi3
458 DWtype
459 __ashrdi3 (DWtype u, shift_count_type b)
461 if (b == 0)
462 return u;
464 const DWunion uu = {.ll = u};
465 const shift_count_type bm = W_TYPE_SIZE - b;
466 DWunion w;
468 if (bm <= 0)
470 /* w.s.high = 1..1 or 0..0 */
471 w.s.high = uu.s.high >> (W_TYPE_SIZE - 1);
472 w.s.low = uu.s.high >> -bm;
474 else
476 const UWtype carries = (UWtype) uu.s.high << bm;
478 w.s.high = uu.s.high >> b;
479 w.s.low = ((UWtype) uu.s.low >> b) | carries;
482 return w.ll;
484 #endif
486 #ifdef L_bswapsi2
487 SItype
488 __bswapsi2 (SItype u)
490 return ((((u) & 0xff000000) >> 24)
491 | (((u) & 0x00ff0000) >> 8)
492 | (((u) & 0x0000ff00) << 8)
493 | (((u) & 0x000000ff) << 24));
495 #endif
496 #ifdef L_bswapdi2
497 DItype
498 __bswapdi2 (DItype u)
500 return ((((u) & 0xff00000000000000ull) >> 56)
501 | (((u) & 0x00ff000000000000ull) >> 40)
502 | (((u) & 0x0000ff0000000000ull) >> 24)
503 | (((u) & 0x000000ff00000000ull) >> 8)
504 | (((u) & 0x00000000ff000000ull) << 8)
505 | (((u) & 0x0000000000ff0000ull) << 24)
506 | (((u) & 0x000000000000ff00ull) << 40)
507 | (((u) & 0x00000000000000ffull) << 56));
509 #endif
510 #ifdef L_ffssi2
511 #undef int
513 __ffsSI2 (UWtype u)
515 UWtype count;
517 if (u == 0)
518 return 0;
520 count_trailing_zeros (count, u);
521 return count + 1;
523 #endif
525 #ifdef L_ffsdi2
526 #undef int
528 __ffsDI2 (DWtype u)
530 const DWunion uu = {.ll = u};
531 UWtype word, count, add;
533 if (uu.s.low != 0)
534 word = uu.s.low, add = 0;
535 else if (uu.s.high != 0)
536 word = uu.s.high, add = W_TYPE_SIZE;
537 else
538 return 0;
540 count_trailing_zeros (count, word);
541 return count + add + 1;
543 #endif
545 #ifdef L_muldi3
546 DWtype
547 __muldi3 (DWtype u, DWtype v)
549 const DWunion uu = {.ll = u};
550 const DWunion vv = {.ll = v};
551 DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
553 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
554 + (UWtype) uu.s.high * (UWtype) vv.s.low);
556 return w.ll;
558 #endif
560 #if (defined (L_udivdi3) || defined (L_divdi3) || \
561 defined (L_umoddi3) || defined (L_moddi3))
562 #if defined (sdiv_qrnnd)
563 #define L_udiv_w_sdiv
564 #endif
565 #endif
567 #ifdef L_udiv_w_sdiv
568 #if defined (sdiv_qrnnd)
569 #if (defined (L_udivdi3) || defined (L_divdi3) || \
570 defined (L_umoddi3) || defined (L_moddi3))
571 static inline __attribute__ ((__always_inline__))
572 #endif
573 UWtype
574 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
576 UWtype q, r;
577 UWtype c0, c1, b1;
579 if ((Wtype) d >= 0)
581 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
583 /* Dividend, divisor, and quotient are nonnegative. */
584 sdiv_qrnnd (q, r, a1, a0, d);
586 else
588 /* Compute c1*2^32 + c0 = a1*2^32 + a0 - 2^31*d. */
589 sub_ddmmss (c1, c0, a1, a0, d >> 1, d << (W_TYPE_SIZE - 1));
590 /* Divide (c1*2^32 + c0) by d. */
591 sdiv_qrnnd (q, r, c1, c0, d);
592 /* Add 2^31 to quotient. */
593 q += (UWtype) 1 << (W_TYPE_SIZE - 1);
596 else
598 b1 = d >> 1; /* d/2, between 2^30 and 2^31 - 1 */
599 c1 = a1 >> 1; /* A/2 */
600 c0 = (a1 << (W_TYPE_SIZE - 1)) + (a0 >> 1);
602 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
604 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
606 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
607 if ((d & 1) != 0)
609 if (r >= q)
610 r = r - q;
611 else if (q - r <= d)
613 r = r - q + d;
614 q--;
616 else
618 r = r - q + 2*d;
619 q -= 2;
623 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
625 c1 = (b1 - 1) - c1;
626 c0 = ~c0; /* logical NOT */
628 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
630 q = ~q; /* (A/2)/b1 */
631 r = (b1 - 1) - r;
633 r = 2*r + (a0 & 1); /* A/(2*b1) */
635 if ((d & 1) != 0)
637 if (r >= q)
638 r = r - q;
639 else if (q - r <= d)
641 r = r - q + d;
642 q--;
644 else
646 r = r - q + 2*d;
647 q -= 2;
651 else /* Implies c1 = b1 */
652 { /* Hence a1 = d - 1 = 2*b1 - 1 */
653 if (a0 >= -d)
655 q = -1;
656 r = a0 + d;
658 else
660 q = -2;
661 r = a0 + 2*d;
666 *rp = r;
667 return q;
669 #else
670 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
671 UWtype
672 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
673 UWtype a1 __attribute__ ((__unused__)),
674 UWtype a0 __attribute__ ((__unused__)),
675 UWtype d __attribute__ ((__unused__)))
677 return 0;
679 #endif
680 #endif
682 #if (defined (L_udivdi3) || defined (L_divdi3) || \
683 defined (L_umoddi3) || defined (L_moddi3))
684 #define L_udivmoddi4
685 #endif
687 #ifdef L_clz
688 const UQItype __clz_tab[256] =
690 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
691 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
692 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
693 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
694 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
695 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
696 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
697 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
699 #endif
701 #ifdef L_clzsi2
702 #undef int
704 __clzSI2 (UWtype x)
706 Wtype ret;
708 count_leading_zeros (ret, x);
710 return ret;
712 #endif
714 #ifdef L_clzdi2
715 #undef int
717 __clzDI2 (UDWtype x)
719 const DWunion uu = {.ll = x};
720 UWtype word;
721 Wtype ret, add;
723 if (uu.s.high)
724 word = uu.s.high, add = 0;
725 else
726 word = uu.s.low, add = W_TYPE_SIZE;
728 count_leading_zeros (ret, word);
729 return ret + add;
731 #endif
733 #ifdef L_ctzsi2
734 #undef int
736 __ctzSI2 (UWtype x)
738 Wtype ret;
740 count_trailing_zeros (ret, x);
742 return ret;
744 #endif
746 #ifdef L_ctzdi2
747 #undef int
749 __ctzDI2 (UDWtype x)
751 const DWunion uu = {.ll = x};
752 UWtype word;
753 Wtype ret, add;
755 if (uu.s.low)
756 word = uu.s.low, add = 0;
757 else
758 word = uu.s.high, add = W_TYPE_SIZE;
760 count_trailing_zeros (ret, word);
761 return ret + add;
763 #endif
765 #ifdef L_clrsbsi2
766 #undef int
768 __clrsbSI2 (Wtype x)
770 Wtype ret;
772 if (x < 0)
773 x = ~x;
774 if (x == 0)
775 return W_TYPE_SIZE - 1;
776 count_leading_zeros (ret, x);
777 return ret - 1;
779 #endif
781 #ifdef L_clrsbdi2
782 #undef int
784 __clrsbDI2 (DWtype x)
786 const DWunion uu = {.ll = x};
787 UWtype word;
788 Wtype ret, add;
790 if (uu.s.high == 0)
791 word = uu.s.low, add = W_TYPE_SIZE;
792 else if (uu.s.high == -1)
793 word = ~uu.s.low, add = W_TYPE_SIZE;
794 else if (uu.s.high >= 0)
795 word = uu.s.high, add = 0;
796 else
797 word = ~uu.s.high, add = 0;
799 if (word == 0)
800 ret = W_TYPE_SIZE;
801 else
802 count_leading_zeros (ret, word);
804 return ret + add - 1;
806 #endif
808 #ifdef L_popcount_tab
809 const UQItype __popcount_tab[256] =
811 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
812 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
813 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
814 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
815 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
816 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
817 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
818 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8
820 #endif
822 #if defined(L_popcountsi2) || defined(L_popcountdi2)
823 #define POPCOUNTCST2(x) (((UWtype) x << BITS_PER_UNIT) | x)
824 #define POPCOUNTCST4(x) (((UWtype) x << (2 * BITS_PER_UNIT)) | x)
825 #define POPCOUNTCST8(x) (((UWtype) x << (4 * BITS_PER_UNIT)) | x)
826 #if W_TYPE_SIZE == BITS_PER_UNIT
827 #define POPCOUNTCST(x) x
828 #elif W_TYPE_SIZE == 2 * BITS_PER_UNIT
829 #define POPCOUNTCST(x) POPCOUNTCST2 (x)
830 #elif W_TYPE_SIZE == 4 * BITS_PER_UNIT
831 #define POPCOUNTCST(x) POPCOUNTCST4 (POPCOUNTCST2 (x))
832 #elif W_TYPE_SIZE == 8 * BITS_PER_UNIT
833 #define POPCOUNTCST(x) POPCOUNTCST8 (POPCOUNTCST4 (POPCOUNTCST2 (x)))
834 #endif
835 #endif
837 #ifdef L_popcountsi2
838 #undef int
840 __popcountSI2 (UWtype x)
842 /* Force table lookup on targets like AVR and RL78 which only
843 pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
844 have 1, and other small word targets. */
845 #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && BITS_PER_UNIT == 8
846 x = x - ((x >> 1) & POPCOUNTCST (0x55));
847 x = (x & POPCOUNTCST (0x33)) + ((x >> 2) & POPCOUNTCST (0x33));
848 x = (x + (x >> 4)) & POPCOUNTCST (0x0F);
849 return (x * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - BITS_PER_UNIT);
850 #else
851 int i, ret = 0;
853 for (i = 0; i < W_TYPE_SIZE; i += 8)
854 ret += __popcount_tab[(x >> i) & 0xff];
856 return ret;
857 #endif
859 #endif
861 #ifdef L_popcountdi2
862 #undef int
864 __popcountDI2 (UDWtype x)
866 /* Force table lookup on targets like AVR and RL78 which only
867 pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
868 have 1, and other small word targets. */
869 #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && BITS_PER_UNIT == 8
870 const DWunion uu = {.ll = x};
871 UWtype x1 = uu.s.low, x2 = uu.s.high;
872 x1 = x1 - ((x1 >> 1) & POPCOUNTCST (0x55));
873 x2 = x2 - ((x2 >> 1) & POPCOUNTCST (0x55));
874 x1 = (x1 & POPCOUNTCST (0x33)) + ((x1 >> 2) & POPCOUNTCST (0x33));
875 x2 = (x2 & POPCOUNTCST (0x33)) + ((x2 >> 2) & POPCOUNTCST (0x33));
876 x1 = (x1 + (x1 >> 4)) & POPCOUNTCST (0x0F);
877 x2 = (x2 + (x2 >> 4)) & POPCOUNTCST (0x0F);
878 x1 += x2;
879 return (x1 * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - BITS_PER_UNIT);
880 #else
881 int i, ret = 0;
883 for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
884 ret += __popcount_tab[(x >> i) & 0xff];
886 return ret;
887 #endif
889 #endif
891 #ifdef L_paritysi2
892 #undef int
894 __paritySI2 (UWtype x)
896 #if W_TYPE_SIZE > 64
897 # error "fill out the table"
898 #endif
899 #if W_TYPE_SIZE > 32
900 x ^= x >> 32;
901 #endif
902 #if W_TYPE_SIZE > 16
903 x ^= x >> 16;
904 #endif
905 x ^= x >> 8;
906 x ^= x >> 4;
907 x &= 0xf;
908 return (0x6996 >> x) & 1;
910 #endif
912 #ifdef L_paritydi2
913 #undef int
915 __parityDI2 (UDWtype x)
917 const DWunion uu = {.ll = x};
918 UWtype nx = uu.s.low ^ uu.s.high;
920 #if W_TYPE_SIZE > 64
921 # error "fill out the table"
922 #endif
923 #if W_TYPE_SIZE > 32
924 nx ^= nx >> 32;
925 #endif
926 #if W_TYPE_SIZE > 16
927 nx ^= nx >> 16;
928 #endif
929 nx ^= nx >> 8;
930 nx ^= nx >> 4;
931 nx &= 0xf;
932 return (0x6996 >> nx) & 1;
934 #endif
936 #ifdef L_udivmoddi4
937 #ifdef TARGET_HAS_NO_HW_DIVIDE
939 #if (defined (L_udivdi3) || defined (L_divdi3) || \
940 defined (L_umoddi3) || defined (L_moddi3))
941 static inline __attribute__ ((__always_inline__))
942 #endif
943 UDWtype
944 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
946 UDWtype q = 0, r = n, y = d;
947 UWtype lz1, lz2, i, k;
949 /* Implements align divisor shift dividend method. This algorithm
950 aligns the divisor under the dividend and then perform number of
951 test-subtract iterations which shift the dividend left. Number of
952 iterations is k + 1 where k is the number of bit positions the
953 divisor must be shifted left to align it under the dividend.
954 quotient bits can be saved in the rightmost positions of the dividend
955 as it shifts left on each test-subtract iteration. */
957 if (y <= r)
959 lz1 = __builtin_clzll (d);
960 lz2 = __builtin_clzll (n);
962 k = lz1 - lz2;
963 y = (y << k);
965 /* Dividend can exceed 2 ^ (width − 1) − 1 but still be less than the
966 aligned divisor. Normal iteration can drops the high order bit
967 of the dividend. Therefore, first test-subtract iteration is a
968 special case, saving its quotient bit in a separate location and
969 not shifting the dividend. */
970 if (r >= y)
972 r = r - y;
973 q = (1ULL << k);
976 if (k > 0)
978 y = y >> 1;
980 /* k additional iterations where k regular test subtract shift
981 dividend iterations are done. */
982 i = k;
985 if (r >= y)
986 r = ((r - y) << 1) + 1;
987 else
988 r = (r << 1);
989 i = i - 1;
990 } while (i != 0);
992 /* First quotient bit is combined with the quotient bits resulting
993 from the k regular iterations. */
994 q = q + r;
995 r = r >> k;
996 q = q - (r << k);
1000 if (rp)
1001 *rp = r;
1002 return q;
1004 #else
1006 #if (defined (L_udivdi3) || defined (L_divdi3) || \
1007 defined (L_umoddi3) || defined (L_moddi3))
1008 static inline __attribute__ ((__always_inline__))
1009 #endif
1010 UDWtype
1011 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
1013 const DWunion nn = {.ll = n};
1014 const DWunion dd = {.ll = d};
1015 DWunion rr;
1016 UWtype d0, d1, n0, n1, n2;
1017 UWtype q0, q1;
1018 UWtype b, bm;
1020 d0 = dd.s.low;
1021 d1 = dd.s.high;
1022 n0 = nn.s.low;
1023 n1 = nn.s.high;
1025 #if !UDIV_NEEDS_NORMALIZATION
1026 if (d1 == 0)
1028 if (d0 > n1)
1030 /* 0q = nn / 0D */
1032 udiv_qrnnd (q0, n0, n1, n0, d0);
1033 q1 = 0;
1035 /* Remainder in n0. */
1037 else
1039 /* qq = NN / 0d */
1041 if (d0 == 0)
1042 d0 = 1 / d0; /* Divide intentionally by zero. */
1044 udiv_qrnnd (q1, n1, 0, n1, d0);
1045 udiv_qrnnd (q0, n0, n1, n0, d0);
1047 /* Remainder in n0. */
1050 if (rp != 0)
1052 rr.s.low = n0;
1053 rr.s.high = 0;
1054 *rp = rr.ll;
1058 #else /* UDIV_NEEDS_NORMALIZATION */
1060 if (d1 == 0)
1062 if (d0 > n1)
1064 /* 0q = nn / 0D */
1066 count_leading_zeros (bm, d0);
1068 if (bm != 0)
1070 /* Normalize, i.e. make the most significant bit of the
1071 denominator set. */
1073 d0 = d0 << bm;
1074 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
1075 n0 = n0 << bm;
1078 udiv_qrnnd (q0, n0, n1, n0, d0);
1079 q1 = 0;
1081 /* Remainder in n0 >> bm. */
1083 else
1085 /* qq = NN / 0d */
1087 if (d0 == 0)
1088 d0 = 1 / d0; /* Divide intentionally by zero. */
1090 count_leading_zeros (bm, d0);
1092 if (bm == 0)
1094 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
1095 conclude (the most significant bit of n1 is set) /\ (the
1096 leading quotient digit q1 = 1).
1098 This special case is necessary, not an optimization.
1099 (Shifts counts of W_TYPE_SIZE are undefined.) */
1101 n1 -= d0;
1102 q1 = 1;
1104 else
1106 /* Normalize. */
1108 b = W_TYPE_SIZE - bm;
1110 d0 = d0 << bm;
1111 n2 = n1 >> b;
1112 n1 = (n1 << bm) | (n0 >> b);
1113 n0 = n0 << bm;
1115 udiv_qrnnd (q1, n1, n2, n1, d0);
1118 /* n1 != d0... */
1120 udiv_qrnnd (q0, n0, n1, n0, d0);
1122 /* Remainder in n0 >> bm. */
1125 if (rp != 0)
1127 rr.s.low = n0 >> bm;
1128 rr.s.high = 0;
1129 *rp = rr.ll;
1132 #endif /* UDIV_NEEDS_NORMALIZATION */
1134 else
1136 if (d1 > n1)
1138 /* 00 = nn / DD */
1140 q0 = 0;
1141 q1 = 0;
1143 /* Remainder in n1n0. */
1144 if (rp != 0)
1146 rr.s.low = n0;
1147 rr.s.high = n1;
1148 *rp = rr.ll;
1151 else
1153 /* 0q = NN / dd */
1155 count_leading_zeros (bm, d1);
1156 if (bm == 0)
1158 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
1159 conclude (the most significant bit of n1 is set) /\ (the
1160 quotient digit q0 = 0 or 1).
1162 This special case is necessary, not an optimization. */
1164 /* The condition on the next line takes advantage of that
1165 n1 >= d1 (true due to program flow). */
1166 if (n1 > d1 || n0 >= d0)
1168 q0 = 1;
1169 sub_ddmmss (n1, n0, n1, n0, d1, d0);
1171 else
1172 q0 = 0;
1174 q1 = 0;
1176 if (rp != 0)
1178 rr.s.low = n0;
1179 rr.s.high = n1;
1180 *rp = rr.ll;
1183 else
1185 UWtype m1, m0;
1186 /* Normalize. */
1188 b = W_TYPE_SIZE - bm;
1190 d1 = (d1 << bm) | (d0 >> b);
1191 d0 = d0 << bm;
1192 n2 = n1 >> b;
1193 n1 = (n1 << bm) | (n0 >> b);
1194 n0 = n0 << bm;
1196 udiv_qrnnd (q0, n1, n2, n1, d1);
1197 umul_ppmm (m1, m0, q0, d0);
1199 if (m1 > n1 || (m1 == n1 && m0 > n0))
1201 q0--;
1202 sub_ddmmss (m1, m0, m1, m0, d1, d0);
1205 q1 = 0;
1207 /* Remainder in (n1n0 - m1m0) >> bm. */
1208 if (rp != 0)
1210 sub_ddmmss (n1, n0, n1, n0, m1, m0);
1211 rr.s.low = (n1 << b) | (n0 >> bm);
1212 rr.s.high = n1 >> bm;
1213 *rp = rr.ll;
1219 const DWunion ww = {{.low = q0, .high = q1}};
1220 return ww.ll;
1222 #endif
1223 #endif
1225 #ifdef L_divdi3
1226 DWtype
1227 __divdi3 (DWtype u, DWtype v)
1229 Wtype c = 0;
1230 DWunion uu = {.ll = u};
1231 DWunion vv = {.ll = v};
1232 DWtype w;
1234 if (uu.s.high < 0)
1235 c = ~c,
1236 uu.ll = -uu.ll;
1237 if (vv.s.high < 0)
1238 c = ~c,
1239 vv.ll = -vv.ll;
1241 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
1242 if (c)
1243 w = -w;
1245 return w;
1247 #endif
1249 #ifdef L_moddi3
1250 DWtype
1251 __moddi3 (DWtype u, DWtype v)
1253 Wtype c = 0;
1254 DWunion uu = {.ll = u};
1255 DWunion vv = {.ll = v};
1256 DWtype w;
1258 if (uu.s.high < 0)
1259 c = ~c,
1260 uu.ll = -uu.ll;
1261 if (vv.s.high < 0)
1262 vv.ll = -vv.ll;
1264 (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
1265 if (c)
1266 w = -w;
1268 return w;
1270 #endif
1272 #ifdef L_umoddi3
1273 UDWtype
1274 __umoddi3 (UDWtype u, UDWtype v)
1276 UDWtype w;
1278 (void) __udivmoddi4 (u, v, &w);
1280 return w;
1282 #endif
1284 #ifdef L_udivdi3
1285 UDWtype
1286 __udivdi3 (UDWtype n, UDWtype d)
1288 return __udivmoddi4 (n, d, (UDWtype *) 0);
1290 #endif
1292 #ifdef L_cmpdi2
1293 cmp_return_type
1294 __cmpdi2 (DWtype a, DWtype b)
1296 const DWunion au = {.ll = a};
1297 const DWunion bu = {.ll = b};
1299 if (au.s.high < bu.s.high)
1300 return 0;
1301 else if (au.s.high > bu.s.high)
1302 return 2;
1303 if ((UWtype) au.s.low < (UWtype) bu.s.low)
1304 return 0;
1305 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1306 return 2;
1307 return 1;
1309 #endif
1311 #ifdef L_ucmpdi2
1312 cmp_return_type
1313 __ucmpdi2 (DWtype a, DWtype b)
1315 const DWunion au = {.ll = a};
1316 const DWunion bu = {.ll = b};
1318 if ((UWtype) au.s.high < (UWtype) bu.s.high)
1319 return 0;
1320 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
1321 return 2;
1322 if ((UWtype) au.s.low < (UWtype) bu.s.low)
1323 return 0;
1324 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1325 return 2;
1326 return 1;
1328 #endif
1330 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1331 UDWtype
1332 __fixunstfDI (TFtype a)
1334 if (a < 0)
1335 return 0;
1337 /* Compute high word of result, as a flonum. */
1338 const TFtype b = (a / Wtype_MAXp1_F);
1339 /* Convert that to fixed (but not to DWtype!),
1340 and shift it into the high word. */
1341 UDWtype v = (UWtype) b;
1342 v <<= W_TYPE_SIZE;
1343 /* Remove high part from the TFtype, leaving the low part as flonum. */
1344 a -= (TFtype)v;
1345 /* Convert that to fixed (but not to DWtype!) and add it in.
1346 Sometimes A comes out negative. This is significant, since
1347 A has more bits than a long int does. */
1348 if (a < 0)
1349 v -= (UWtype) (- a);
1350 else
1351 v += (UWtype) a;
1352 return v;
1354 #endif
1356 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1357 DWtype
1358 __fixtfdi (TFtype a)
1360 if (a < 0)
1361 return - __fixunstfDI (-a);
1362 return __fixunstfDI (a);
1364 #endif
1366 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1367 UDWtype
1368 __fixunsxfDI (XFtype a)
1370 if (a < 0)
1371 return 0;
1373 /* Compute high word of result, as a flonum. */
1374 const XFtype b = (a / Wtype_MAXp1_F);
1375 /* Convert that to fixed (but not to DWtype!),
1376 and shift it into the high word. */
1377 UDWtype v = (UWtype) b;
1378 v <<= W_TYPE_SIZE;
1379 /* Remove high part from the XFtype, leaving the low part as flonum. */
1380 a -= (XFtype)v;
1381 /* Convert that to fixed (but not to DWtype!) and add it in.
1382 Sometimes A comes out negative. This is significant, since
1383 A has more bits than a long int does. */
1384 if (a < 0)
1385 v -= (UWtype) (- a);
1386 else
1387 v += (UWtype) a;
1388 return v;
1390 #endif
1392 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1393 DWtype
1394 __fixxfdi (XFtype a)
1396 if (a < 0)
1397 return - __fixunsxfDI (-a);
1398 return __fixunsxfDI (a);
1400 #endif
1402 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1403 UDWtype
1404 __fixunsdfDI (DFtype a)
1406 /* Get high part of result. The division here will just moves the radix
1407 point and will not cause any rounding. Then the conversion to integral
1408 type chops result as desired. */
1409 const UWtype hi = a / Wtype_MAXp1_F;
1411 /* Get low part of result. Convert `hi' to floating type and scale it back,
1412 then subtract this from the number being converted. This leaves the low
1413 part. Convert that to integral type. */
1414 const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
1416 /* Assemble result from the two parts. */
1417 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1419 #endif
1421 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1422 DWtype
1423 __fixdfdi (DFtype a)
1425 if (a < 0)
1426 return - __fixunsdfDI (-a);
1427 return __fixunsdfDI (a);
1429 #endif
1431 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1432 UDWtype
1433 __fixunssfDI (SFtype a)
1435 #if LIBGCC2_HAS_DF_MODE
1436 /* Convert the SFtype to a DFtype, because that is surely not going
1437 to lose any bits. Some day someone else can write a faster version
1438 that avoids converting to DFtype, and verify it really works right. */
1439 const DFtype dfa = a;
1441 /* Get high part of result. The division here will just moves the radix
1442 point and will not cause any rounding. Then the conversion to integral
1443 type chops result as desired. */
1444 const UWtype hi = dfa / Wtype_MAXp1_F;
1446 /* Get low part of result. Convert `hi' to floating type and scale it back,
1447 then subtract this from the number being converted. This leaves the low
1448 part. Convert that to integral type. */
1449 const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
1451 /* Assemble result from the two parts. */
1452 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1453 #elif FLT_MANT_DIG < W_TYPE_SIZE
1454 if (a < 1)
1455 return 0;
1456 if (a < Wtype_MAXp1_F)
1457 return (UWtype)a;
1458 if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
1460 /* Since we know that there are fewer significant bits in the SFmode
1461 quantity than in a word, we know that we can convert out all the
1462 significant bits in one step, and thus avoid losing bits. */
1464 /* ??? This following loop essentially performs frexpf. If we could
1465 use the real libm function, or poke at the actual bits of the fp
1466 format, it would be significantly faster. */
1468 UWtype shift = 0, counter;
1469 SFtype msb;
1471 a /= Wtype_MAXp1_F;
1472 for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
1474 SFtype counterf = (UWtype)1 << counter;
1475 if (a >= counterf)
1477 shift |= counter;
1478 a /= counterf;
1482 /* Rescale into the range of one word, extract the bits of that
1483 one word, and shift the result into position. */
1484 a *= Wtype_MAXp1_F;
1485 counter = a;
1486 return (DWtype)counter << shift;
1488 return -1;
1489 #else
1490 # error
1491 #endif
1493 #endif
1495 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1496 DWtype
1497 __fixsfdi (SFtype a)
1499 if (a < 0)
1500 return - __fixunssfDI (-a);
1501 return __fixunssfDI (a);
1503 #endif
1505 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1506 XFtype
1507 __floatdixf (DWtype u)
1509 #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
1510 # error
1511 #endif
1512 XFtype d = (Wtype) (u >> W_TYPE_SIZE);
1513 d *= Wtype_MAXp1_F;
1514 d += (UWtype)u;
1515 return d;
1517 #endif
1519 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
1520 XFtype
1521 __floatundixf (UDWtype u)
1523 #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
1524 # error
1525 #endif
1526 XFtype d = (UWtype) (u >> W_TYPE_SIZE);
1527 d *= Wtype_MAXp1_F;
1528 d += (UWtype)u;
1529 return d;
1531 #endif
1533 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1534 TFtype
1535 __floatditf (DWtype u)
1537 #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
1538 # error
1539 #endif
1540 TFtype d = (Wtype) (u >> W_TYPE_SIZE);
1541 d *= Wtype_MAXp1_F;
1542 d += (UWtype)u;
1543 return d;
1545 #endif
1547 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
1548 TFtype
1549 __floatunditf (UDWtype u)
1551 #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
1552 # error
1553 #endif
1554 TFtype d = (UWtype) (u >> W_TYPE_SIZE);
1555 d *= Wtype_MAXp1_F;
1556 d += (UWtype)u;
1557 return d;
1559 #endif
1561 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
1562 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
1563 #define DI_SIZE (W_TYPE_SIZE * 2)
1564 #define F_MODE_OK(SIZE) \
1565 (SIZE < DI_SIZE \
1566 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1567 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1568 #if defined(L_floatdisf)
1569 #define FUNC __floatdisf
1570 #define FSTYPE SFtype
1571 #define FSSIZE __LIBGCC_SF_MANT_DIG__
1572 #else
1573 #define FUNC __floatdidf
1574 #define FSTYPE DFtype
1575 #define FSSIZE __LIBGCC_DF_MANT_DIG__
1576 #endif
1578 FSTYPE
1579 FUNC (DWtype u)
1581 #if FSSIZE >= W_TYPE_SIZE
1582 /* When the word size is small, we never get any rounding error. */
1583 FSTYPE f = (Wtype) (u >> W_TYPE_SIZE);
1584 f *= Wtype_MAXp1_F;
1585 f += (UWtype)u;
1586 return f;
1587 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
1588 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
1589 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1591 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
1592 # define FSIZE __LIBGCC_DF_MANT_DIG__
1593 # define FTYPE DFtype
1594 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
1595 # define FSIZE __LIBGCC_XF_MANT_DIG__
1596 # define FTYPE XFtype
1597 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1598 # define FSIZE __LIBGCC_TF_MANT_DIG__
1599 # define FTYPE TFtype
1600 #else
1601 # error
1602 #endif
1604 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1606 /* Protect against double-rounding error.
1607 Represent any low-order bits, that might be truncated by a bit that
1608 won't be lost. The bit can go in anywhere below the rounding position
1609 of the FSTYPE. A fixed mask and bit position handles all usual
1610 configurations. */
1611 if (! (- ((DWtype) 1 << FSIZE) < u
1612 && u < ((DWtype) 1 << FSIZE)))
1614 if ((UDWtype) u & (REP_BIT - 1))
1616 u &= ~ (REP_BIT - 1);
1617 u |= REP_BIT;
1621 /* Do the calculation in a wider type so that we don't lose any of
1622 the precision of the high word while multiplying it. */
1623 FTYPE f = (Wtype) (u >> W_TYPE_SIZE);
1624 f *= Wtype_MAXp1_F;
1625 f += (UWtype)u;
1626 return (FSTYPE) f;
1627 #else
1628 #if FSSIZE >= W_TYPE_SIZE - 2
1629 # error
1630 #endif
1631 /* Finally, the word size is larger than the number of bits in the
1632 required FSTYPE, and we've got no suitable wider type. The only
1633 way to avoid double rounding is to special case the
1634 extraction. */
1636 /* If there are no high bits set, fall back to one conversion. */
1637 if ((Wtype)u == u)
1638 return (FSTYPE)(Wtype)u;
1640 /* Otherwise, find the power of two. */
1641 Wtype hi = u >> W_TYPE_SIZE;
1642 if (hi < 0)
1643 hi = -(UWtype) hi;
1645 UWtype count, shift;
1646 count_leading_zeros (count, hi);
1648 /* No leading bits means u == minimum. */
1649 if (count == 0)
1650 return -(Wtype_MAXp1_F * (Wtype_MAXp1_F / 2));
1652 shift = 1 + W_TYPE_SIZE - count;
1654 /* Shift down the most significant bits. */
1655 hi = u >> shift;
1657 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1658 if ((UWtype)u << (W_TYPE_SIZE - shift))
1659 hi |= 1;
1661 /* Convert the one word of data, and rescale. */
1662 FSTYPE f = hi, e;
1663 if (shift == W_TYPE_SIZE)
1664 e = Wtype_MAXp1_F;
1665 /* The following two cases could be merged if we knew that the target
1666 supported a native unsigned->float conversion. More often, we only
1667 have a signed conversion, and have to add extra fixup code. */
1668 else if (shift == W_TYPE_SIZE - 1)
1669 e = Wtype_MAXp1_F / 2;
1670 else
1671 e = (Wtype)1 << shift;
1672 return f * e;
1673 #endif
1675 #endif
1677 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
1678 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
1679 #define DI_SIZE (W_TYPE_SIZE * 2)
1680 #define F_MODE_OK(SIZE) \
1681 (SIZE < DI_SIZE \
1682 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1683 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1684 #if defined(L_floatundisf)
1685 #define FUNC __floatundisf
1686 #define FSTYPE SFtype
1687 #define FSSIZE __LIBGCC_SF_MANT_DIG__
1688 #else
1689 #define FUNC __floatundidf
1690 #define FSTYPE DFtype
1691 #define FSSIZE __LIBGCC_DF_MANT_DIG__
1692 #endif
1694 FSTYPE
1695 FUNC (UDWtype u)
1697 #if FSSIZE >= W_TYPE_SIZE
1698 /* When the word size is small, we never get any rounding error. */
1699 FSTYPE f = (UWtype) (u >> W_TYPE_SIZE);
1700 f *= Wtype_MAXp1_F;
1701 f += (UWtype)u;
1702 return f;
1703 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__)) \
1704 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__)) \
1705 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1707 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
1708 # define FSIZE __LIBGCC_DF_MANT_DIG__
1709 # define FTYPE DFtype
1710 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
1711 # define FSIZE __LIBGCC_XF_MANT_DIG__
1712 # define FTYPE XFtype
1713 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
1714 # define FSIZE __LIBGCC_TF_MANT_DIG__
1715 # define FTYPE TFtype
1716 #else
1717 # error
1718 #endif
1720 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1722 /* Protect against double-rounding error.
1723 Represent any low-order bits, that might be truncated by a bit that
1724 won't be lost. The bit can go in anywhere below the rounding position
1725 of the FSTYPE. A fixed mask and bit position handles all usual
1726 configurations. */
1727 if (u >= ((UDWtype) 1 << FSIZE))
1729 if ((UDWtype) u & (REP_BIT - 1))
1731 u &= ~ (REP_BIT - 1);
1732 u |= REP_BIT;
1736 /* Do the calculation in a wider type so that we don't lose any of
1737 the precision of the high word while multiplying it. */
1738 FTYPE f = (UWtype) (u >> W_TYPE_SIZE);
1739 f *= Wtype_MAXp1_F;
1740 f += (UWtype)u;
1741 return (FSTYPE) f;
1742 #else
1743 #if FSSIZE == W_TYPE_SIZE - 1
1744 # error
1745 #endif
1746 /* Finally, the word size is larger than the number of bits in the
1747 required FSTYPE, and we've got no suitable wider type. The only
1748 way to avoid double rounding is to special case the
1749 extraction. */
1751 /* If there are no high bits set, fall back to one conversion. */
1752 if ((UWtype)u == u)
1753 return (FSTYPE)(UWtype)u;
1755 /* Otherwise, find the power of two. */
1756 UWtype hi = u >> W_TYPE_SIZE;
1758 UWtype count, shift;
1759 count_leading_zeros (count, hi);
1761 shift = W_TYPE_SIZE - count;
1763 /* Shift down the most significant bits. */
1764 hi = u >> shift;
1766 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1767 if ((UWtype)u << (W_TYPE_SIZE - shift))
1768 hi |= 1;
1770 /* Convert the one word of data, and rescale. */
1771 FSTYPE f = hi, e;
1772 if (shift == W_TYPE_SIZE)
1773 e = Wtype_MAXp1_F;
1774 /* The following two cases could be merged if we knew that the target
1775 supported a native unsigned->float conversion. More often, we only
1776 have a signed conversion, and have to add extra fixup code. */
1777 else if (shift == W_TYPE_SIZE - 1)
1778 e = Wtype_MAXp1_F / 2;
1779 else
1780 e = (Wtype)1 << shift;
1781 return f * e;
1782 #endif
1784 #endif
1786 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1787 UWtype
1788 __fixunsxfSI (XFtype a)
1790 if (a >= - (DFtype) Wtype_MIN)
1791 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1792 return (Wtype) a;
1794 #endif
1796 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1797 UWtype
1798 __fixunsdfSI (DFtype a)
1800 if (a >= - (DFtype) Wtype_MIN)
1801 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1802 return (Wtype) a;
1804 #endif
1806 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1807 UWtype
1808 __fixunssfSI (SFtype a)
1810 if (a >= - (SFtype) Wtype_MIN)
1811 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1812 return (Wtype) a;
1814 #endif
1816 /* Integer power helper used from __builtin_powi for non-constant
1817 exponents. */
1819 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1820 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1821 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1822 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1823 # if defined(L_powisf2)
1824 # define TYPE SFtype
1825 # define NAME __powisf2
1826 # elif defined(L_powidf2)
1827 # define TYPE DFtype
1828 # define NAME __powidf2
1829 # elif defined(L_powixf2)
1830 # define TYPE XFtype
1831 # define NAME __powixf2
1832 # elif defined(L_powitf2)
1833 # define TYPE TFtype
1834 # define NAME __powitf2
1835 # endif
1837 #undef int
1838 #undef unsigned
1839 TYPE
1840 NAME (TYPE x, int m)
1842 unsigned int n = m < 0 ? -m : m;
1843 TYPE y = n % 2 ? x : 1;
1844 while (n >>= 1)
1846 x = x * x;
1847 if (n % 2)
1848 y = y * x;
1850 return m < 0 ? 1/y : y;
1853 #endif
1855 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1856 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1857 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1858 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1860 #undef float
1861 #undef double
1862 #undef long
1864 #if defined(L_mulsc3) || defined(L_divsc3)
1865 # define MTYPE SFtype
1866 # define CTYPE SCtype
1867 # define MODE sc
1868 # define CEXT __LIBGCC_SF_FUNC_EXT__
1869 # define NOTRUNC __LIBGCC_SF_EXCESS_PRECISION__
1870 #elif defined(L_muldc3) || defined(L_divdc3)
1871 # define MTYPE DFtype
1872 # define CTYPE DCtype
1873 # define MODE dc
1874 # define CEXT __LIBGCC_DF_FUNC_EXT__
1875 # define NOTRUNC __LIBGCC_DF_EXCESS_PRECISION__
1876 #elif defined(L_mulxc3) || defined(L_divxc3)
1877 # define MTYPE XFtype
1878 # define CTYPE XCtype
1879 # define MODE xc
1880 # define CEXT __LIBGCC_XF_FUNC_EXT__
1881 # define NOTRUNC __LIBGCC_XF_EXCESS_PRECISION__
1882 #elif defined(L_multc3) || defined(L_divtc3)
1883 # define MTYPE TFtype
1884 # define CTYPE TCtype
1885 # define MODE tc
1886 # define CEXT __LIBGCC_TF_FUNC_EXT__
1887 # define NOTRUNC __LIBGCC_TF_EXCESS_PRECISION__
1888 #else
1889 # error
1890 #endif
1892 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
1893 #define _CONCAT3(A,B,C) A##B##C
1895 #define CONCAT2(A,B) _CONCAT2(A,B)
1896 #define _CONCAT2(A,B) A##B
1898 /* All of these would be present in a full C99 implementation of <math.h>
1899 and <complex.h>. Our problem is that only a few systems have such full
1900 implementations. Further, libgcc_s.so isn't currently linked against
1901 libm.so, and even for systems that do provide full C99, the extra overhead
1902 of all programs using libgcc having to link against libm. So avoid it. */
1904 #define isnan(x) __builtin_expect ((x) != (x), 0)
1905 #define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
1906 #define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
1908 #define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
1909 #define I 1i
1911 /* Helpers to make the following code slightly less gross. */
1912 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
1913 #define FABS CONCAT2(__builtin_fabs, CEXT)
1915 /* Verify that MTYPE matches up with CEXT. */
1916 extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
1918 /* Ensure that we've lost any extra precision. */
1919 #if NOTRUNC
1920 # define TRUNC(x)
1921 #else
1922 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
1923 #endif
1925 #if defined(L_mulsc3) || defined(L_muldc3) \
1926 || defined(L_mulxc3) || defined(L_multc3)
1928 CTYPE
1929 CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
1931 MTYPE ac, bd, ad, bc, x, y;
1932 CTYPE res;
1934 ac = a * c;
1935 bd = b * d;
1936 ad = a * d;
1937 bc = b * c;
1939 TRUNC (ac);
1940 TRUNC (bd);
1941 TRUNC (ad);
1942 TRUNC (bc);
1944 x = ac - bd;
1945 y = ad + bc;
1947 if (isnan (x) && isnan (y))
1949 /* Recover infinities that computed as NaN + iNaN. */
1950 _Bool recalc = 0;
1951 if (isinf (a) || isinf (b))
1953 /* z is infinite. "Box" the infinity and change NaNs in
1954 the other factor to 0. */
1955 a = COPYSIGN (isinf (a) ? 1 : 0, a);
1956 b = COPYSIGN (isinf (b) ? 1 : 0, b);
1957 if (isnan (c)) c = COPYSIGN (0, c);
1958 if (isnan (d)) d = COPYSIGN (0, d);
1959 recalc = 1;
1961 if (isinf (c) || isinf (d))
1963 /* w is infinite. "Box" the infinity and change NaNs in
1964 the other factor to 0. */
1965 c = COPYSIGN (isinf (c) ? 1 : 0, c);
1966 d = COPYSIGN (isinf (d) ? 1 : 0, d);
1967 if (isnan (a)) a = COPYSIGN (0, a);
1968 if (isnan (b)) b = COPYSIGN (0, b);
1969 recalc = 1;
1971 if (!recalc
1972 && (isinf (ac) || isinf (bd)
1973 || isinf (ad) || isinf (bc)))
1975 /* Recover infinities from overflow by changing NaNs to 0. */
1976 if (isnan (a)) a = COPYSIGN (0, a);
1977 if (isnan (b)) b = COPYSIGN (0, b);
1978 if (isnan (c)) c = COPYSIGN (0, c);
1979 if (isnan (d)) d = COPYSIGN (0, d);
1980 recalc = 1;
1982 if (recalc)
1984 x = INFINITY * (a * c - b * d);
1985 y = INFINITY * (a * d + b * c);
1989 __real__ res = x;
1990 __imag__ res = y;
1991 return res;
1993 #endif /* complex multiply */
1995 #if defined(L_divsc3) || defined(L_divdc3) \
1996 || defined(L_divxc3) || defined(L_divtc3)
1998 CTYPE
1999 CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
2001 MTYPE denom, ratio, x, y;
2002 CTYPE res;
2004 /* ??? We can get better behavior from logarithmic scaling instead of
2005 the division. But that would mean starting to link libgcc against
2006 libm. We could implement something akin to ldexp/frexp as gcc builtins
2007 fairly easily... */
2008 if (FABS (c) < FABS (d))
2010 ratio = c / d;
2011 denom = (c * ratio) + d;
2012 x = ((a * ratio) + b) / denom;
2013 y = ((b * ratio) - a) / denom;
2015 else
2017 ratio = d / c;
2018 denom = (d * ratio) + c;
2019 x = ((b * ratio) + a) / denom;
2020 y = (b - (a * ratio)) / denom;
2023 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
2024 are nonzero/zero, infinite/finite, and finite/infinite. */
2025 if (isnan (x) && isnan (y))
2027 if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b)))
2029 x = COPYSIGN (INFINITY, c) * a;
2030 y = COPYSIGN (INFINITY, c) * b;
2032 else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d))
2034 a = COPYSIGN (isinf (a) ? 1 : 0, a);
2035 b = COPYSIGN (isinf (b) ? 1 : 0, b);
2036 x = INFINITY * (a * c + b * d);
2037 y = INFINITY * (b * c - a * d);
2039 else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b))
2041 c = COPYSIGN (isinf (c) ? 1 : 0, c);
2042 d = COPYSIGN (isinf (d) ? 1 : 0, d);
2043 x = 0.0 * (a * c + b * d);
2044 y = 0.0 * (b * c - a * d);
2048 __real__ res = x;
2049 __imag__ res = y;
2050 return res;
2052 #endif /* complex divide */
2054 #endif /* all complex float routines */
2056 /* From here on down, the routines use normal data types. */
2058 #define SItype bogus_type
2059 #define USItype bogus_type
2060 #define DItype bogus_type
2061 #define UDItype bogus_type
2062 #define SFtype bogus_type
2063 #define DFtype bogus_type
2064 #undef Wtype
2065 #undef UWtype
2066 #undef HWtype
2067 #undef UHWtype
2068 #undef DWtype
2069 #undef UDWtype
2071 #undef char
2072 #undef short
2073 #undef int
2074 #undef long
2075 #undef unsigned
2076 #undef float
2077 #undef double
2079 #ifdef L__gcc_bcmp
2081 /* Like bcmp except the sign is meaningful.
2082 Result is negative if S1 is less than S2,
2083 positive if S1 is greater, 0 if S1 and S2 are equal. */
2086 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
2088 while (size > 0)
2090 const unsigned char c1 = *s1++, c2 = *s2++;
2091 if (c1 != c2)
2092 return c1 - c2;
2093 size--;
2095 return 0;
2098 #endif
2100 /* __eprintf used to be used by GCC's private version of <assert.h>.
2101 We no longer provide that header, but this routine remains in libgcc.a
2102 for binary backward compatibility. Note that it is not included in
2103 the shared version of libgcc. */
2104 #ifdef L_eprintf
2105 #ifndef inhibit_libc
2107 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2108 #include <stdio.h>
2110 void
2111 __eprintf (const char *string, const char *expression,
2112 unsigned int line, const char *filename)
2114 fprintf (stderr, string, expression, line, filename);
2115 fflush (stderr);
2116 abort ();
2119 #endif
2120 #endif
2123 #ifdef L_clear_cache
2124 /* Clear part of an instruction cache. */
2126 void
2127 __clear_cache (char *beg __attribute__((__unused__)),
2128 char *end __attribute__((__unused__)))
2130 #ifdef CLEAR_INSN_CACHE
2131 CLEAR_INSN_CACHE (beg, end);
2132 #endif /* CLEAR_INSN_CACHE */
2135 #endif /* L_clear_cache */
2137 #ifdef L_trampoline
2139 /* Jump to a trampoline, loading the static chain address. */
2141 #if defined(WINNT) && ! defined(__CYGWIN__)
2142 #include <windows.h>
2143 int getpagesize (void);
2144 int mprotect (char *,int, int);
2147 getpagesize (void)
2149 #ifdef _ALPHA_
2150 return 8192;
2151 #else
2152 return 4096;
2153 #endif
2157 mprotect (char *addr, int len, int prot)
2159 DWORD np, op;
2161 if (prot == 7)
2162 np = 0x40;
2163 else if (prot == 5)
2164 np = 0x20;
2165 else if (prot == 4)
2166 np = 0x10;
2167 else if (prot == 3)
2168 np = 0x04;
2169 else if (prot == 1)
2170 np = 0x02;
2171 else if (prot == 0)
2172 np = 0x01;
2173 else
2174 return -1;
2176 if (VirtualProtect (addr, len, np, &op))
2177 return 0;
2178 else
2179 return -1;
2182 #endif /* WINNT && ! __CYGWIN__ */
2184 #ifdef TRANSFER_FROM_TRAMPOLINE
2185 TRANSFER_FROM_TRAMPOLINE
2186 #endif
2187 #endif /* L_trampoline */
2189 #ifndef __CYGWIN__
2190 #ifdef L__main
2192 #include "gbl-ctors.h"
2194 /* Some systems use __main in a way incompatible with its use in gcc, in these
2195 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2196 give the same symbol without quotes for an alternative entry point. You
2197 must define both, or neither. */
2198 #ifndef NAME__MAIN
2199 #define NAME__MAIN "__main"
2200 #define SYMBOL__MAIN __main
2201 #endif
2203 #if defined (__LIBGCC_INIT_SECTION_ASM_OP__) \
2204 || defined (__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__)
2205 #undef HAS_INIT_SECTION
2206 #define HAS_INIT_SECTION
2207 #endif
2209 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2211 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2212 code to run constructors. In that case, we need to handle EH here, too. */
2214 #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
2215 #include "unwind-dw2-fde.h"
2216 extern unsigned char __EH_FRAME_BEGIN__[];
2217 #endif
2219 /* Run all the global destructors on exit from the program. */
2221 void
2222 __do_global_dtors (void)
2224 #ifdef DO_GLOBAL_DTORS_BODY
2225 DO_GLOBAL_DTORS_BODY;
2226 #else
2227 static func_ptr *p = __DTOR_LIST__ + 1;
2228 while (*p)
2230 p++;
2231 (*(p-1)) ();
2233 #endif
2234 #if defined (__LIBGCC_EH_FRAME_SECTION_NAME__) && !defined (HAS_INIT_SECTION)
2236 static int completed = 0;
2237 if (! completed)
2239 completed = 1;
2240 __deregister_frame_info (__EH_FRAME_BEGIN__);
2243 #endif
2245 #endif
2247 #ifndef HAS_INIT_SECTION
2248 /* Run all the global constructors on entry to the program. */
2250 void
2251 __do_global_ctors (void)
2253 #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
2255 static struct object object;
2256 __register_frame_info (__EH_FRAME_BEGIN__, &object);
2258 #endif
2259 DO_GLOBAL_CTORS_BODY;
2260 atexit (__do_global_dtors);
2262 #endif /* no HAS_INIT_SECTION */
2264 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2265 /* Subroutine called automatically by `main'.
2266 Compiling a global function named `main'
2267 produces an automatic call to this function at the beginning.
2269 For many systems, this routine calls __do_global_ctors.
2270 For systems which support a .init section we use the .init section
2271 to run __do_global_ctors, so we need not do anything here. */
2273 extern void SYMBOL__MAIN (void);
2274 void
2275 SYMBOL__MAIN (void)
2277 /* Support recursive calls to `main': run initializers just once. */
2278 static int initialized;
2279 if (! initialized)
2281 initialized = 1;
2282 __do_global_ctors ();
2285 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2287 #endif /* L__main */
2288 #endif /* __CYGWIN__ */
2290 #ifdef L_ctors
2292 #include "gbl-ctors.h"
2294 /* Provide default definitions for the lists of constructors and
2295 destructors, so that we don't get linker errors. These symbols are
2296 intentionally bss symbols, so that gld and/or collect will provide
2297 the right values. */
2299 /* We declare the lists here with two elements each,
2300 so that they are valid empty lists if no other definition is loaded.
2302 If we are using the old "set" extensions to have the gnu linker
2303 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2304 must be in the bss/common section.
2306 Long term no port should use those extensions. But many still do. */
2307 #if !defined(__LIBGCC_INIT_SECTION_ASM_OP__) \
2308 && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2309 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2310 func_ptr __CTOR_LIST__[2] = {0, 0};
2311 func_ptr __DTOR_LIST__[2] = {0, 0};
2312 #else
2313 func_ptr __CTOR_LIST__[2];
2314 func_ptr __DTOR_LIST__[2];
2315 #endif
2316 #endif /* no __LIBGCC_INIT_SECTION_ASM_OP__ and not CTOR_LISTS_DEFINED_EXTERNALLY */
2317 #endif /* L_ctors */
2318 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */