1 /* More subroutines needed by GCC output code on some machines. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2013 Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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.
11
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.
16
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.
20
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/>. */
25
26 #include "tconfig.h"
27 #include "tsystem.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "libgcc_tm.h"
31
32 #ifdef HAVE_GAS_HIDDEN
33 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
34 #else
35 #define ATTRIBUTE_HIDDEN
36 #endif
37
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
47
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
53
54 #if LIBGCC2_UNITS_PER_WORD <= LIBGCC2_MAX_UNITS_PER_WORD
55
56 #include "libgcc2.h"
57
58 #ifdef DECLARE_LIBRARY_RENAMES
59 DECLARE_LIBRARY_RENAMES
60 #endif
61
62 #if defined (L_negdi2)
63 DWtype
__negdi2(DWtype u)64 __negdi2 (DWtype u)
65 {
66 const DWunion uu = {.ll = u};
67 const DWunion w = { {.low = -uu.s.low,
68 .high = -uu.s.high - ((UWtype) -uu.s.low > 0) } };
69
70 return w.ll;
71 }
72 #endif
73
74 #ifdef L_addvsi3
75 Wtype
__addvSI3(Wtype a,Wtype b)76 __addvSI3 (Wtype a, Wtype b)
77 {
78 const Wtype w = (UWtype) a + (UWtype) b;
79
80 if (b >= 0 ? w < a : w > a)
81 abort ();
82
83 return w;
84 }
85 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
86 SItype
__addvsi3(SItype a,SItype b)87 __addvsi3 (SItype a, SItype b)
88 {
89 const SItype w = (USItype) a + (USItype) b;
90
91 if (b >= 0 ? w < a : w > a)
92 abort ();
93
94 return w;
95 }
96 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
97 #endif
98
99 #ifdef L_addvdi3
100 DWtype
__addvDI3(DWtype a,DWtype b)101 __addvDI3 (DWtype a, DWtype b)
102 {
103 const DWtype w = (UDWtype) a + (UDWtype) b;
104
105 if (b >= 0 ? w < a : w > a)
106 abort ();
107
108 return w;
109 }
110 #endif
111
112 #ifdef L_subvsi3
113 Wtype
__subvSI3(Wtype a,Wtype b)114 __subvSI3 (Wtype a, Wtype b)
115 {
116 const Wtype w = (UWtype) a - (UWtype) b;
117
118 if (b >= 0 ? w > a : w < a)
119 abort ();
120
121 return w;
122 }
123 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
124 SItype
__subvsi3(SItype a,SItype b)125 __subvsi3 (SItype a, SItype b)
126 {
127 const SItype w = (USItype) a - (USItype) b;
128
129 if (b >= 0 ? w > a : w < a)
130 abort ();
131
132 return w;
133 }
134 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
135 #endif
136
137 #ifdef L_subvdi3
138 DWtype
__subvDI3(DWtype a,DWtype b)139 __subvDI3 (DWtype a, DWtype b)
140 {
141 const DWtype w = (UDWtype) a - (UDWtype) b;
142
143 if (b >= 0 ? w > a : w < a)
144 abort ();
145
146 return w;
147 }
148 #endif
149
150 #ifdef L_mulvsi3
151 Wtype
__mulvSI3(Wtype a,Wtype b)152 __mulvSI3 (Wtype a, Wtype b)
153 {
154 const DWtype w = (DWtype) a * (DWtype) b;
155
156 if ((Wtype) (w >> W_TYPE_SIZE) != (Wtype) w >> (W_TYPE_SIZE - 1))
157 abort ();
158
159 return w;
160 }
161 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
162 #undef WORD_SIZE
163 #define WORD_SIZE (sizeof (SItype) * BITS_PER_UNIT)
164 SItype
__mulvsi3(SItype a,SItype b)165 __mulvsi3 (SItype a, SItype b)
166 {
167 const DItype w = (DItype) a * (DItype) b;
168
169 if ((SItype) (w >> WORD_SIZE) != (SItype) w >> (WORD_SIZE-1))
170 abort ();
171
172 return w;
173 }
174 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
175 #endif
176
177 #ifdef L_negvsi2
178 Wtype
__negvSI2(Wtype a)179 __negvSI2 (Wtype a)
180 {
181 const Wtype w = -(UWtype) a;
182
183 if (a >= 0 ? w > 0 : w < 0)
184 abort ();
185
186 return w;
187 }
188 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
189 SItype
__negvsi2(SItype a)190 __negvsi2 (SItype a)
191 {
192 const SItype w = -(USItype) a;
193
194 if (a >= 0 ? w > 0 : w < 0)
195 abort ();
196
197 return w;
198 }
199 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
200 #endif
201
202 #ifdef L_negvdi2
203 DWtype
__negvDI2(DWtype a)204 __negvDI2 (DWtype a)
205 {
206 const DWtype w = -(UDWtype) a;
207
208 if (a >= 0 ? w > 0 : w < 0)
209 abort ();
210
211 return w;
212 }
213 #endif
214
215 #ifdef L_absvsi2
216 Wtype
__absvSI2(Wtype a)217 __absvSI2 (Wtype a)
218 {
219 Wtype w = a;
220
221 if (a < 0)
222 #ifdef L_negvsi2
223 w = __negvSI2 (a);
224 #else
225 w = -(UWtype) a;
226
227 if (w < 0)
228 abort ();
229 #endif
230
231 return w;
232 }
233 #ifdef COMPAT_SIMODE_TRAPPING_ARITHMETIC
234 SItype
__absvsi2(SItype a)235 __absvsi2 (SItype a)
236 {
237 SItype w = a;
238
239 if (a < 0)
240 #ifdef L_negvsi2
241 w = __negvsi2 (a);
242 #else
243 w = -(USItype) a;
244
245 if (w < 0)
246 abort ();
247 #endif
248
249 return w;
250 }
251 #endif /* COMPAT_SIMODE_TRAPPING_ARITHMETIC */
252 #endif
253
254 #ifdef L_absvdi2
255 DWtype
__absvDI2(DWtype a)256 __absvDI2 (DWtype a)
257 {
258 DWtype w = a;
259
260 if (a < 0)
261 #ifdef L_negvdi2
262 w = __negvDI2 (a);
263 #else
264 w = -(UDWtype) a;
265
266 if (w < 0)
267 abort ();
268 #endif
269
270 return w;
271 }
272 #endif
273
274 #ifdef L_mulvdi3
275 DWtype
__mulvDI3(DWtype u,DWtype v)276 __mulvDI3 (DWtype u, DWtype v)
277 {
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};
282
283 if (__builtin_expect (uu.s.high == uu.s.low >> (W_TYPE_SIZE - 1), 1))
284 {
285 /* u fits in a single Wtype. */
286 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
287 {
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;
291 }
292 else
293 {
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};
299
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))
306 {
307 w0.s.high = w1.s.low;
308 return w0.ll;
309 }
310 }
311 }
312 else
313 {
314 if (__builtin_expect (vv.s.high == vv.s.low >> (W_TYPE_SIZE - 1), 1))
315 {
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};
322
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))
329 {
330 w0.s.high = w1.s.low;
331 return w0.ll;
332 }
333 }
334 else
335 {
336 /* A few sign checks and a single multiplication. */
337 if (uu.s.high >= 0)
338 {
339 if (vv.s.high >= 0)
340 {
341 if (uu.s.high == 0 && vv.s.high == 0)
342 {
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;
347 }
348 }
349 else
350 {
351 if (uu.s.high == 0 && vv.s.high == (Wtype) -1)
352 {
353 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
354 * (UDWtype) (UWtype) vv.s.low};
355
356 ww.s.high -= uu.s.low;
357 if (__builtin_expect (ww.s.high < 0, 1))
358 return ww.ll;
359 }
360 }
361 }
362 else
363 {
364 if (vv.s.high >= 0)
365 {
366 if (uu.s.high == (Wtype) -1 && vv.s.high == 0)
367 {
368 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
369 * (UDWtype) (UWtype) vv.s.low};
370
371 ww.s.high -= vv.s.low;
372 if (__builtin_expect (ww.s.high < 0, 1))
373 return ww.ll;
374 }
375 }
376 else
377 {
378 if (uu.s.high == (Wtype) -1 && vv.s.high == (Wtype) - 1)
379 {
380 DWunion ww = {.ll = (UDWtype) (UWtype) uu.s.low
381 * (UDWtype) (UWtype) vv.s.low};
382
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;
387 }
388 }
389 }
390 }
391 }
392
393 /* Overflow. */
394 abort ();
395 }
396 #endif
397
398
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
__lshrdi3(DWtype u,shift_count_type b)403 __lshrdi3 (DWtype u, shift_count_type b)
404 {
405 if (b == 0)
406 return u;
407
408 const DWunion uu = {.ll = u};
409 const shift_count_type bm = W_TYPE_SIZE - b;
410 DWunion w;
411
412 if (bm <= 0)
413 {
414 w.s.high = 0;
415 w.s.low = (UWtype) uu.s.high >> -bm;
416 }
417 else
418 {
419 const UWtype carries = (UWtype) uu.s.high << bm;
420
421 w.s.high = (UWtype) uu.s.high >> b;
422 w.s.low = ((UWtype) uu.s.low >> b) | carries;
423 }
424
425 return w.ll;
426 }
427 #endif
428
429 #ifdef L_ashldi3
430 DWtype
__ashldi3(DWtype u,shift_count_type b)431 __ashldi3 (DWtype u, shift_count_type b)
432 {
433 if (b == 0)
434 return u;
435
436 const DWunion uu = {.ll = u};
437 const shift_count_type bm = W_TYPE_SIZE - b;
438 DWunion w;
439
440 if (bm <= 0)
441 {
442 w.s.low = 0;
443 w.s.high = (UWtype) uu.s.low << -bm;
444 }
445 else
446 {
447 const UWtype carries = (UWtype) uu.s.low >> bm;
448
449 w.s.low = (UWtype) uu.s.low << b;
450 w.s.high = ((UWtype) uu.s.high << b) | carries;
451 }
452
453 return w.ll;
454 }
455 #endif
456
457 #ifdef L_ashrdi3
458 DWtype
__ashrdi3(DWtype u,shift_count_type b)459 __ashrdi3 (DWtype u, shift_count_type b)
460 {
461 if (b == 0)
462 return u;
463
464 const DWunion uu = {.ll = u};
465 const shift_count_type bm = W_TYPE_SIZE - b;
466 DWunion w;
467
468 if (bm <= 0)
469 {
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;
473 }
474 else
475 {
476 const UWtype carries = (UWtype) uu.s.high << bm;
477
478 w.s.high = uu.s.high >> b;
479 w.s.low = ((UWtype) uu.s.low >> b) | carries;
480 }
481
482 return w.ll;
483 }
484 #endif
485
486 #ifdef L_bswapsi2
487 SItype
__bswapsi2(SItype u)488 __bswapsi2 (SItype u)
489 {
490 return ((((u) & 0xff000000) >> 24)
491 | (((u) & 0x00ff0000) >> 8)
492 | (((u) & 0x0000ff00) << 8)
493 | (((u) & 0x000000ff) << 24));
494 }
495 #endif
496 #ifdef L_bswapdi2
497 DItype
__bswapdi2(DItype u)498 __bswapdi2 (DItype u)
499 {
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));
508 }
509 #endif
510 #ifdef L_ffssi2
511 #undef int
512 int
__ffsSI2(UWtype u)513 __ffsSI2 (UWtype u)
514 {
515 UWtype count;
516
517 if (u == 0)
518 return 0;
519
520 count_trailing_zeros (count, u);
521 return count + 1;
522 }
523 #endif
524
525 #ifdef L_ffsdi2
526 #undef int
527 int
__ffsDI2(DWtype u)528 __ffsDI2 (DWtype u)
529 {
530 const DWunion uu = {.ll = u};
531 UWtype word, count, add;
532
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;
539
540 count_trailing_zeros (count, word);
541 return count + add + 1;
542 }
543 #endif
544
545 #ifdef L_muldi3
546 DWtype
__muldi3(DWtype u,DWtype v)547 __muldi3 (DWtype u, DWtype v)
548 {
549 const DWunion uu = {.ll = u};
550 const DWunion vv = {.ll = v};
551 DWunion w = {.ll = __umulsidi3 (uu.s.low, vv.s.low)};
552
553 w.s.high += ((UWtype) uu.s.low * (UWtype) vv.s.high
554 + (UWtype) uu.s.high * (UWtype) vv.s.low);
555
556 return w.ll;
557 }
558 #endif
559
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
566
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
__udiv_w_sdiv(UWtype * rp,UWtype a1,UWtype a0,UWtype d)574 __udiv_w_sdiv (UWtype *rp, UWtype a1, UWtype a0, UWtype d)
575 {
576 UWtype q, r;
577 UWtype c0, c1, b1;
578
579 if ((Wtype) d >= 0)
580 {
581 if (a1 < d - a1 - (a0 >> (W_TYPE_SIZE - 1)))
582 {
583 /* Dividend, divisor, and quotient are nonnegative. */
584 sdiv_qrnnd (q, r, a1, a0, d);
585 }
586 else
587 {
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);
594 }
595 }
596 else
597 {
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);
601
602 if (a1 < b1) /* A < 2^32*b1, so A/2 < 2^31*b1 */
603 {
604 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
605
606 r = 2*r + (a0 & 1); /* Remainder from A/(2*b1) */
607 if ((d & 1) != 0)
608 {
609 if (r >= q)
610 r = r - q;
611 else if (q - r <= d)
612 {
613 r = r - q + d;
614 q--;
615 }
616 else
617 {
618 r = r - q + 2*d;
619 q -= 2;
620 }
621 }
622 }
623 else if (c1 < b1) /* So 2^31 <= (A/2)/b1 < 2^32 */
624 {
625 c1 = (b1 - 1) - c1;
626 c0 = ~c0; /* logical NOT */
627
628 sdiv_qrnnd (q, r, c1, c0, b1); /* (A/2) / (d/2) */
629
630 q = ~q; /* (A/2)/b1 */
631 r = (b1 - 1) - r;
632
633 r = 2*r + (a0 & 1); /* A/(2*b1) */
634
635 if ((d & 1) != 0)
636 {
637 if (r >= q)
638 r = r - q;
639 else if (q - r <= d)
640 {
641 r = r - q + d;
642 q--;
643 }
644 else
645 {
646 r = r - q + 2*d;
647 q -= 2;
648 }
649 }
650 }
651 else /* Implies c1 = b1 */
652 { /* Hence a1 = d - 1 = 2*b1 - 1 */
653 if (a0 >= -d)
654 {
655 q = -1;
656 r = a0 + d;
657 }
658 else
659 {
660 q = -2;
661 r = a0 + 2*d;
662 }
663 }
664 }
665
666 *rp = r;
667 return q;
668 }
669 #else
670 /* If sdiv_qrnnd doesn't exist, define dummy __udiv_w_sdiv. */
671 UWtype
__udiv_w_sdiv(UWtype * rp,UWtype a1,UWtype a0,UWtype d)672 __udiv_w_sdiv (UWtype *rp __attribute__ ((__unused__)),
673 UWtype a1 __attribute__ ((__unused__)),
674 UWtype a0 __attribute__ ((__unused__)),
675 UWtype d __attribute__ ((__unused__)))
676 {
677 return 0;
678 }
679 #endif
680 #endif
681
682 #if (defined (L_udivdi3) || defined (L_divdi3) || \
683 defined (L_umoddi3) || defined (L_moddi3))
684 #define L_udivmoddi4
685 #endif
686
687 #ifdef L_clz
688 const UQItype __clz_tab[256] =
689 {
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
698 };
699 #endif
700
701 #ifdef L_clzsi2
702 #undef int
703 int
__clzSI2(UWtype x)704 __clzSI2 (UWtype x)
705 {
706 Wtype ret;
707
708 count_leading_zeros (ret, x);
709
710 return ret;
711 }
712 #endif
713
714 #ifdef L_clzdi2
715 #undef int
716 int
__clzDI2(UDWtype x)717 __clzDI2 (UDWtype x)
718 {
719 const DWunion uu = {.ll = x};
720 UWtype word;
721 Wtype ret, add;
722
723 if (uu.s.high)
724 word = uu.s.high, add = 0;
725 else
726 word = uu.s.low, add = W_TYPE_SIZE;
727
728 count_leading_zeros (ret, word);
729 return ret + add;
730 }
731 #endif
732
733 #ifdef L_ctzsi2
734 #undef int
735 int
__ctzSI2(UWtype x)736 __ctzSI2 (UWtype x)
737 {
738 Wtype ret;
739
740 count_trailing_zeros (ret, x);
741
742 return ret;
743 }
744 #endif
745
746 #ifdef L_ctzdi2
747 #undef int
748 int
__ctzDI2(UDWtype x)749 __ctzDI2 (UDWtype x)
750 {
751 const DWunion uu = {.ll = x};
752 UWtype word;
753 Wtype ret, add;
754
755 if (uu.s.low)
756 word = uu.s.low, add = 0;
757 else
758 word = uu.s.high, add = W_TYPE_SIZE;
759
760 count_trailing_zeros (ret, word);
761 return ret + add;
762 }
763 #endif
764
765 #ifdef L_clrsbsi2
766 #undef int
767 int
__clrsbSI2(Wtype x)768 __clrsbSI2 (Wtype x)
769 {
770 Wtype ret;
771
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;
778 }
779 #endif
780
781 #ifdef L_clrsbdi2
782 #undef int
783 int
__clrsbDI2(DWtype x)784 __clrsbDI2 (DWtype x)
785 {
786 const DWunion uu = {.ll = x};
787 UWtype word;
788 Wtype ret, add;
789
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;
798
799 if (word == 0)
800 ret = W_TYPE_SIZE;
801 else
802 count_leading_zeros (ret, word);
803
804 return ret + add - 1;
805 }
806 #endif
807
808 #ifdef L_popcount_tab
809 const UQItype __popcount_tab[256] =
810 {
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
819 };
820 #endif
821
822 #ifdef L_popcountsi2
823 #undef int
824 int
__popcountSI2(UWtype x)825 __popcountSI2 (UWtype x)
826 {
827 int i, ret = 0;
828
829 for (i = 0; i < W_TYPE_SIZE; i += 8)
830 ret += __popcount_tab[(x >> i) & 0xff];
831
832 return ret;
833 }
834 #endif
835
836 #ifdef L_popcountdi2
837 #undef int
838 int
__popcountDI2(UDWtype x)839 __popcountDI2 (UDWtype x)
840 {
841 int i, ret = 0;
842
843 for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
844 ret += __popcount_tab[(x >> i) & 0xff];
845
846 return ret;
847 }
848 #endif
849
850 #ifdef L_paritysi2
851 #undef int
852 int
__paritySI2(UWtype x)853 __paritySI2 (UWtype x)
854 {
855 #if W_TYPE_SIZE > 64
856 # error "fill out the table"
857 #endif
858 #if W_TYPE_SIZE > 32
859 x ^= x >> 32;
860 #endif
861 #if W_TYPE_SIZE > 16
862 x ^= x >> 16;
863 #endif
864 x ^= x >> 8;
865 x ^= x >> 4;
866 x &= 0xf;
867 return (0x6996 >> x) & 1;
868 }
869 #endif
870
871 #ifdef L_paritydi2
872 #undef int
873 int
__parityDI2(UDWtype x)874 __parityDI2 (UDWtype x)
875 {
876 const DWunion uu = {.ll = x};
877 UWtype nx = uu.s.low ^ uu.s.high;
878
879 #if W_TYPE_SIZE > 64
880 # error "fill out the table"
881 #endif
882 #if W_TYPE_SIZE > 32
883 nx ^= nx >> 32;
884 #endif
885 #if W_TYPE_SIZE > 16
886 nx ^= nx >> 16;
887 #endif
888 nx ^= nx >> 8;
889 nx ^= nx >> 4;
890 nx &= 0xf;
891 return (0x6996 >> nx) & 1;
892 }
893 #endif
894
895 #ifdef L_udivmoddi4
896
897 #if (defined (L_udivdi3) || defined (L_divdi3) || \
898 defined (L_umoddi3) || defined (L_moddi3))
899 static inline __attribute__ ((__always_inline__))
900 #endif
901 UDWtype
__udivmoddi4(UDWtype n,UDWtype d,UDWtype * rp)902 __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
903 {
904 const DWunion nn = {.ll = n};
905 const DWunion dd = {.ll = d};
906 DWunion rr;
907 UWtype d0, d1, n0, n1, n2;
908 UWtype q0, q1;
909 UWtype b, bm;
910
911 d0 = dd.s.low;
912 d1 = dd.s.high;
913 n0 = nn.s.low;
914 n1 = nn.s.high;
915
916 #if !UDIV_NEEDS_NORMALIZATION
917 if (d1 == 0)
918 {
919 if (d0 > n1)
920 {
921 /* 0q = nn / 0D */
922
923 udiv_qrnnd (q0, n0, n1, n0, d0);
924 q1 = 0;
925
926 /* Remainder in n0. */
927 }
928 else
929 {
930 /* qq = NN / 0d */
931
932 if (d0 == 0)
933 d0 = 1 / d0; /* Divide intentionally by zero. */
934
935 udiv_qrnnd (q1, n1, 0, n1, d0);
936 udiv_qrnnd (q0, n0, n1, n0, d0);
937
938 /* Remainder in n0. */
939 }
940
941 if (rp != 0)
942 {
943 rr.s.low = n0;
944 rr.s.high = 0;
945 *rp = rr.ll;
946 }
947 }
948
949 #else /* UDIV_NEEDS_NORMALIZATION */
950
951 if (d1 == 0)
952 {
953 if (d0 > n1)
954 {
955 /* 0q = nn / 0D */
956
957 count_leading_zeros (bm, d0);
958
959 if (bm != 0)
960 {
961 /* Normalize, i.e. make the most significant bit of the
962 denominator set. */
963
964 d0 = d0 << bm;
965 n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
966 n0 = n0 << bm;
967 }
968
969 udiv_qrnnd (q0, n0, n1, n0, d0);
970 q1 = 0;
971
972 /* Remainder in n0 >> bm. */
973 }
974 else
975 {
976 /* qq = NN / 0d */
977
978 if (d0 == 0)
979 d0 = 1 / d0; /* Divide intentionally by zero. */
980
981 count_leading_zeros (bm, d0);
982
983 if (bm == 0)
984 {
985 /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
986 conclude (the most significant bit of n1 is set) /\ (the
987 leading quotient digit q1 = 1).
988
989 This special case is necessary, not an optimization.
990 (Shifts counts of W_TYPE_SIZE are undefined.) */
991
992 n1 -= d0;
993 q1 = 1;
994 }
995 else
996 {
997 /* Normalize. */
998
999 b = W_TYPE_SIZE - bm;
1000
1001 d0 = d0 << bm;
1002 n2 = n1 >> b;
1003 n1 = (n1 << bm) | (n0 >> b);
1004 n0 = n0 << bm;
1005
1006 udiv_qrnnd (q1, n1, n2, n1, d0);
1007 }
1008
1009 /* n1 != d0... */
1010
1011 udiv_qrnnd (q0, n0, n1, n0, d0);
1012
1013 /* Remainder in n0 >> bm. */
1014 }
1015
1016 if (rp != 0)
1017 {
1018 rr.s.low = n0 >> bm;
1019 rr.s.high = 0;
1020 *rp = rr.ll;
1021 }
1022 }
1023 #endif /* UDIV_NEEDS_NORMALIZATION */
1024
1025 else
1026 {
1027 if (d1 > n1)
1028 {
1029 /* 00 = nn / DD */
1030
1031 q0 = 0;
1032 q1 = 0;
1033
1034 /* Remainder in n1n0. */
1035 if (rp != 0)
1036 {
1037 rr.s.low = n0;
1038 rr.s.high = n1;
1039 *rp = rr.ll;
1040 }
1041 }
1042 else
1043 {
1044 /* 0q = NN / dd */
1045
1046 count_leading_zeros (bm, d1);
1047 if (bm == 0)
1048 {
1049 /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
1050 conclude (the most significant bit of n1 is set) /\ (the
1051 quotient digit q0 = 0 or 1).
1052
1053 This special case is necessary, not an optimization. */
1054
1055 /* The condition on the next line takes advantage of that
1056 n1 >= d1 (true due to program flow). */
1057 if (n1 > d1 || n0 >= d0)
1058 {
1059 q0 = 1;
1060 sub_ddmmss (n1, n0, n1, n0, d1, d0);
1061 }
1062 else
1063 q0 = 0;
1064
1065 q1 = 0;
1066
1067 if (rp != 0)
1068 {
1069 rr.s.low = n0;
1070 rr.s.high = n1;
1071 *rp = rr.ll;
1072 }
1073 }
1074 else
1075 {
1076 UWtype m1, m0;
1077 /* Normalize. */
1078
1079 b = W_TYPE_SIZE - bm;
1080
1081 d1 = (d1 << bm) | (d0 >> b);
1082 d0 = d0 << bm;
1083 n2 = n1 >> b;
1084 n1 = (n1 << bm) | (n0 >> b);
1085 n0 = n0 << bm;
1086
1087 udiv_qrnnd (q0, n1, n2, n1, d1);
1088 umul_ppmm (m1, m0, q0, d0);
1089
1090 if (m1 > n1 || (m1 == n1 && m0 > n0))
1091 {
1092 q0--;
1093 sub_ddmmss (m1, m0, m1, m0, d1, d0);
1094 }
1095
1096 q1 = 0;
1097
1098 /* Remainder in (n1n0 - m1m0) >> bm. */
1099 if (rp != 0)
1100 {
1101 sub_ddmmss (n1, n0, n1, n0, m1, m0);
1102 rr.s.low = (n1 << b) | (n0 >> bm);
1103 rr.s.high = n1 >> bm;
1104 *rp = rr.ll;
1105 }
1106 }
1107 }
1108 }
1109
1110 const DWunion ww = {{.low = q0, .high = q1}};
1111 return ww.ll;
1112 }
1113 #endif
1114
1115 #ifdef L_divdi3
1116 DWtype
__divdi3(DWtype u,DWtype v)1117 __divdi3 (DWtype u, DWtype v)
1118 {
1119 Wtype c = 0;
1120 DWunion uu = {.ll = u};
1121 DWunion vv = {.ll = v};
1122 DWtype w;
1123
1124 if (uu.s.high < 0)
1125 c = ~c,
1126 uu.ll = -uu.ll;
1127 if (vv.s.high < 0)
1128 c = ~c,
1129 vv.ll = -vv.ll;
1130
1131 w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
1132 if (c)
1133 w = -w;
1134
1135 return w;
1136 }
1137 #endif
1138
1139 #ifdef L_moddi3
1140 DWtype
__moddi3(DWtype u,DWtype v)1141 __moddi3 (DWtype u, DWtype v)
1142 {
1143 Wtype c = 0;
1144 DWunion uu = {.ll = u};
1145 DWunion vv = {.ll = v};
1146 DWtype w;
1147
1148 if (uu.s.high < 0)
1149 c = ~c,
1150 uu.ll = -uu.ll;
1151 if (vv.s.high < 0)
1152 vv.ll = -vv.ll;
1153
1154 (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
1155 if (c)
1156 w = -w;
1157
1158 return w;
1159 }
1160 #endif
1161
1162 #ifdef L_umoddi3
1163 UDWtype
__umoddi3(UDWtype u,UDWtype v)1164 __umoddi3 (UDWtype u, UDWtype v)
1165 {
1166 UDWtype w;
1167
1168 (void) __udivmoddi4 (u, v, &w);
1169
1170 return w;
1171 }
1172 #endif
1173
1174 #ifdef L_udivdi3
1175 UDWtype
__udivdi3(UDWtype n,UDWtype d)1176 __udivdi3 (UDWtype n, UDWtype d)
1177 {
1178 return __udivmoddi4 (n, d, (UDWtype *) 0);
1179 }
1180 #endif
1181
1182 #ifdef L_cmpdi2
1183 cmp_return_type
__cmpdi2(DWtype a,DWtype b)1184 __cmpdi2 (DWtype a, DWtype b)
1185 {
1186 const DWunion au = {.ll = a};
1187 const DWunion bu = {.ll = b};
1188
1189 if (au.s.high < bu.s.high)
1190 return 0;
1191 else if (au.s.high > bu.s.high)
1192 return 2;
1193 if ((UWtype) au.s.low < (UWtype) bu.s.low)
1194 return 0;
1195 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1196 return 2;
1197 return 1;
1198 }
1199 #endif
1200
1201 #ifdef L_ucmpdi2
1202 cmp_return_type
__ucmpdi2(DWtype a,DWtype b)1203 __ucmpdi2 (DWtype a, DWtype b)
1204 {
1205 const DWunion au = {.ll = a};
1206 const DWunion bu = {.ll = b};
1207
1208 if ((UWtype) au.s.high < (UWtype) bu.s.high)
1209 return 0;
1210 else if ((UWtype) au.s.high > (UWtype) bu.s.high)
1211 return 2;
1212 if ((UWtype) au.s.low < (UWtype) bu.s.low)
1213 return 0;
1214 else if ((UWtype) au.s.low > (UWtype) bu.s.low)
1215 return 2;
1216 return 1;
1217 }
1218 #endif
1219
1220 #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
1221 UDWtype
__fixunstfDI(TFtype a)1222 __fixunstfDI (TFtype a)
1223 {
1224 if (a < 0)
1225 return 0;
1226
1227 /* Compute high word of result, as a flonum. */
1228 const TFtype b = (a / Wtype_MAXp1_F);
1229 /* Convert that to fixed (but not to DWtype!),
1230 and shift it into the high word. */
1231 UDWtype v = (UWtype) b;
1232 v <<= W_TYPE_SIZE;
1233 /* Remove high part from the TFtype, leaving the low part as flonum. */
1234 a -= (TFtype)v;
1235 /* Convert that to fixed (but not to DWtype!) and add it in.
1236 Sometimes A comes out negative. This is significant, since
1237 A has more bits than a long int does. */
1238 if (a < 0)
1239 v -= (UWtype) (- a);
1240 else
1241 v += (UWtype) a;
1242 return v;
1243 }
1244 #endif
1245
1246 #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
1247 DWtype
__fixtfdi(TFtype a)1248 __fixtfdi (TFtype a)
1249 {
1250 if (a < 0)
1251 return - __fixunstfDI (-a);
1252 return __fixunstfDI (a);
1253 }
1254 #endif
1255
1256 #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
1257 UDWtype
__fixunsxfDI(XFtype a)1258 __fixunsxfDI (XFtype a)
1259 {
1260 if (a < 0)
1261 return 0;
1262
1263 /* Compute high word of result, as a flonum. */
1264 const XFtype b = (a / Wtype_MAXp1_F);
1265 /* Convert that to fixed (but not to DWtype!),
1266 and shift it into the high word. */
1267 UDWtype v = (UWtype) b;
1268 v <<= W_TYPE_SIZE;
1269 /* Remove high part from the XFtype, leaving the low part as flonum. */
1270 a -= (XFtype)v;
1271 /* Convert that to fixed (but not to DWtype!) and add it in.
1272 Sometimes A comes out negative. This is significant, since
1273 A has more bits than a long int does. */
1274 if (a < 0)
1275 v -= (UWtype) (- a);
1276 else
1277 v += (UWtype) a;
1278 return v;
1279 }
1280 #endif
1281
1282 #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
1283 DWtype
__fixxfdi(XFtype a)1284 __fixxfdi (XFtype a)
1285 {
1286 if (a < 0)
1287 return - __fixunsxfDI (-a);
1288 return __fixunsxfDI (a);
1289 }
1290 #endif
1291
1292 #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
1293 UDWtype
__fixunsdfDI(DFtype a)1294 __fixunsdfDI (DFtype a)
1295 {
1296 /* Get high part of result. The division here will just moves the radix
1297 point and will not cause any rounding. Then the conversion to integral
1298 type chops result as desired. */
1299 const UWtype hi = a / Wtype_MAXp1_F;
1300
1301 /* Get low part of result. Convert `hi' to floating type and scale it back,
1302 then subtract this from the number being converted. This leaves the low
1303 part. Convert that to integral type. */
1304 const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
1305
1306 /* Assemble result from the two parts. */
1307 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1308 }
1309 #endif
1310
1311 #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
1312 DWtype
__fixdfdi(DFtype a)1313 __fixdfdi (DFtype a)
1314 {
1315 if (a < 0)
1316 return - __fixunsdfDI (-a);
1317 return __fixunsdfDI (a);
1318 }
1319 #endif
1320
1321 #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
1322 UDWtype
__fixunssfDI(SFtype a)1323 __fixunssfDI (SFtype a)
1324 {
1325 #if LIBGCC2_HAS_DF_MODE
1326 /* Convert the SFtype to a DFtype, because that is surely not going
1327 to lose any bits. Some day someone else can write a faster version
1328 that avoids converting to DFtype, and verify it really works right. */
1329 const DFtype dfa = a;
1330
1331 /* Get high part of result. The division here will just moves the radix
1332 point and will not cause any rounding. Then the conversion to integral
1333 type chops result as desired. */
1334 const UWtype hi = dfa / Wtype_MAXp1_F;
1335
1336 /* Get low part of result. Convert `hi' to floating type and scale it back,
1337 then subtract this from the number being converted. This leaves the low
1338 part. Convert that to integral type. */
1339 const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
1340
1341 /* Assemble result from the two parts. */
1342 return ((UDWtype) hi << W_TYPE_SIZE) | lo;
1343 #elif FLT_MANT_DIG < W_TYPE_SIZE
1344 if (a < 1)
1345 return 0;
1346 if (a < Wtype_MAXp1_F)
1347 return (UWtype)a;
1348 if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
1349 {
1350 /* Since we know that there are fewer significant bits in the SFmode
1351 quantity than in a word, we know that we can convert out all the
1352 significant bits in one step, and thus avoid losing bits. */
1353
1354 /* ??? This following loop essentially performs frexpf. If we could
1355 use the real libm function, or poke at the actual bits of the fp
1356 format, it would be significantly faster. */
1357
1358 UWtype shift = 0, counter;
1359 SFtype msb;
1360
1361 a /= Wtype_MAXp1_F;
1362 for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
1363 {
1364 SFtype counterf = (UWtype)1 << counter;
1365 if (a >= counterf)
1366 {
1367 shift |= counter;
1368 a /= counterf;
1369 }
1370 }
1371
1372 /* Rescale into the range of one word, extract the bits of that
1373 one word, and shift the result into position. */
1374 a *= Wtype_MAXp1_F;
1375 counter = a;
1376 return (DWtype)counter << shift;
1377 }
1378 return -1;
1379 #else
1380 # error
1381 #endif
1382 }
1383 #endif
1384
1385 #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
1386 DWtype
__fixsfdi(SFtype a)1387 __fixsfdi (SFtype a)
1388 {
1389 if (a < 0)
1390 return - __fixunssfDI (-a);
1391 return __fixunssfDI (a);
1392 }
1393 #endif
1394
1395 #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
1396 XFtype
__floatdixf(DWtype u)1397 __floatdixf (DWtype u)
1398 {
1399 #if W_TYPE_SIZE > XF_SIZE
1400 # error
1401 #endif
1402 XFtype d = (Wtype) (u >> W_TYPE_SIZE);
1403 d *= Wtype_MAXp1_F;
1404 d += (UWtype)u;
1405 return d;
1406 }
1407 #endif
1408
1409 #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
1410 XFtype
__floatundixf(UDWtype u)1411 __floatundixf (UDWtype u)
1412 {
1413 #if W_TYPE_SIZE > XF_SIZE
1414 # error
1415 #endif
1416 XFtype d = (UWtype) (u >> W_TYPE_SIZE);
1417 d *= Wtype_MAXp1_F;
1418 d += (UWtype)u;
1419 return d;
1420 }
1421 #endif
1422
1423 #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
1424 TFtype
__floatditf(DWtype u)1425 __floatditf (DWtype u)
1426 {
1427 #if W_TYPE_SIZE > TF_SIZE
1428 # error
1429 #endif
1430 TFtype d = (Wtype) (u >> W_TYPE_SIZE);
1431 d *= Wtype_MAXp1_F;
1432 d += (UWtype)u;
1433 return d;
1434 }
1435 #endif
1436
1437 #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
1438 TFtype
__floatunditf(UDWtype u)1439 __floatunditf (UDWtype u)
1440 {
1441 #if W_TYPE_SIZE > TF_SIZE
1442 # error
1443 #endif
1444 TFtype d = (UWtype) (u >> W_TYPE_SIZE);
1445 d *= Wtype_MAXp1_F;
1446 d += (UWtype)u;
1447 return d;
1448 }
1449 #endif
1450
1451 #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE) \
1452 || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
1453 #define DI_SIZE (W_TYPE_SIZE * 2)
1454 #define F_MODE_OK(SIZE) \
1455 (SIZE < DI_SIZE \
1456 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1457 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1458 #if defined(L_floatdisf)
1459 #define FUNC __floatdisf
1460 #define FSTYPE SFtype
1461 #define FSSIZE SF_SIZE
1462 #else
1463 #define FUNC __floatdidf
1464 #define FSTYPE DFtype
1465 #define FSSIZE DF_SIZE
1466 #endif
1467
1468 FSTYPE
FUNC(DWtype u)1469 FUNC (DWtype u)
1470 {
1471 #if FSSIZE >= W_TYPE_SIZE
1472 /* When the word size is small, we never get any rounding error. */
1473 FSTYPE f = (Wtype) (u >> W_TYPE_SIZE);
1474 f *= Wtype_MAXp1_F;
1475 f += (UWtype)u;
1476 return f;
1477 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
1478 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
1479 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1480
1481 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
1482 # define FSIZE DF_SIZE
1483 # define FTYPE DFtype
1484 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
1485 # define FSIZE XF_SIZE
1486 # define FTYPE XFtype
1487 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1488 # define FSIZE TF_SIZE
1489 # define FTYPE TFtype
1490 #else
1491 # error
1492 #endif
1493
1494 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1495
1496 /* Protect against double-rounding error.
1497 Represent any low-order bits, that might be truncated by a bit that
1498 won't be lost. The bit can go in anywhere below the rounding position
1499 of the FSTYPE. A fixed mask and bit position handles all usual
1500 configurations. */
1501 if (! (- ((DWtype) 1 << FSIZE) < u
1502 && u < ((DWtype) 1 << FSIZE)))
1503 {
1504 if ((UDWtype) u & (REP_BIT - 1))
1505 {
1506 u &= ~ (REP_BIT - 1);
1507 u |= REP_BIT;
1508 }
1509 }
1510
1511 /* Do the calculation in a wider type so that we don't lose any of
1512 the precision of the high word while multiplying it. */
1513 FTYPE f = (Wtype) (u >> W_TYPE_SIZE);
1514 f *= Wtype_MAXp1_F;
1515 f += (UWtype)u;
1516 return (FSTYPE) f;
1517 #else
1518 #if FSSIZE >= W_TYPE_SIZE - 2
1519 # error
1520 #endif
1521 /* Finally, the word size is larger than the number of bits in the
1522 required FSTYPE, and we've got no suitable wider type. The only
1523 way to avoid double rounding is to special case the
1524 extraction. */
1525
1526 /* If there are no high bits set, fall back to one conversion. */
1527 if ((Wtype)u == u)
1528 return (FSTYPE)(Wtype)u;
1529
1530 /* Otherwise, find the power of two. */
1531 Wtype hi = u >> W_TYPE_SIZE;
1532 if (hi < 0)
1533 hi = -hi;
1534
1535 UWtype count, shift;
1536 count_leading_zeros (count, hi);
1537
1538 /* No leading bits means u == minimum. */
1539 if (count == 0)
1540 return -(Wtype_MAXp1_F * (Wtype_MAXp1_F / 2));
1541
1542 shift = 1 + W_TYPE_SIZE - count;
1543
1544 /* Shift down the most significant bits. */
1545 hi = u >> shift;
1546
1547 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1548 if ((UWtype)u << (W_TYPE_SIZE - shift))
1549 hi |= 1;
1550
1551 /* Convert the one word of data, and rescale. */
1552 FSTYPE f = hi, e;
1553 if (shift == W_TYPE_SIZE)
1554 e = Wtype_MAXp1_F;
1555 /* The following two cases could be merged if we knew that the target
1556 supported a native unsigned->float conversion. More often, we only
1557 have a signed conversion, and have to add extra fixup code. */
1558 else if (shift == W_TYPE_SIZE - 1)
1559 e = Wtype_MAXp1_F / 2;
1560 else
1561 e = (Wtype)1 << shift;
1562 return f * e;
1563 #endif
1564 }
1565 #endif
1566
1567 #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE) \
1568 || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
1569 #define DI_SIZE (W_TYPE_SIZE * 2)
1570 #define F_MODE_OK(SIZE) \
1571 (SIZE < DI_SIZE \
1572 && SIZE > (DI_SIZE - SIZE + FSSIZE) \
1573 && !AVOID_FP_TYPE_CONVERSION(SIZE))
1574 #if defined(L_floatundisf)
1575 #define FUNC __floatundisf
1576 #define FSTYPE SFtype
1577 #define FSSIZE SF_SIZE
1578 #else
1579 #define FUNC __floatundidf
1580 #define FSTYPE DFtype
1581 #define FSSIZE DF_SIZE
1582 #endif
1583
1584 FSTYPE
FUNC(UDWtype u)1585 FUNC (UDWtype u)
1586 {
1587 #if FSSIZE >= W_TYPE_SIZE
1588 /* When the word size is small, we never get any rounding error. */
1589 FSTYPE f = (UWtype) (u >> W_TYPE_SIZE);
1590 f *= Wtype_MAXp1_F;
1591 f += (UWtype)u;
1592 return f;
1593 #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE)) \
1594 || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE)) \
1595 || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1596
1597 #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (DF_SIZE))
1598 # define FSIZE DF_SIZE
1599 # define FTYPE DFtype
1600 #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (XF_SIZE))
1601 # define FSIZE XF_SIZE
1602 # define FTYPE XFtype
1603 #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (TF_SIZE))
1604 # define FSIZE TF_SIZE
1605 # define FTYPE TFtype
1606 #else
1607 # error
1608 #endif
1609
1610 #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
1611
1612 /* Protect against double-rounding error.
1613 Represent any low-order bits, that might be truncated by a bit that
1614 won't be lost. The bit can go in anywhere below the rounding position
1615 of the FSTYPE. A fixed mask and bit position handles all usual
1616 configurations. */
1617 if (u >= ((UDWtype) 1 << FSIZE))
1618 {
1619 if ((UDWtype) u & (REP_BIT - 1))
1620 {
1621 u &= ~ (REP_BIT - 1);
1622 u |= REP_BIT;
1623 }
1624 }
1625
1626 /* Do the calculation in a wider type so that we don't lose any of
1627 the precision of the high word while multiplying it. */
1628 FTYPE f = (UWtype) (u >> W_TYPE_SIZE);
1629 f *= Wtype_MAXp1_F;
1630 f += (UWtype)u;
1631 return (FSTYPE) f;
1632 #else
1633 #if FSSIZE == W_TYPE_SIZE - 1
1634 # error
1635 #endif
1636 /* Finally, the word size is larger than the number of bits in the
1637 required FSTYPE, and we've got no suitable wider type. The only
1638 way to avoid double rounding is to special case the
1639 extraction. */
1640
1641 /* If there are no high bits set, fall back to one conversion. */
1642 if ((UWtype)u == u)
1643 return (FSTYPE)(UWtype)u;
1644
1645 /* Otherwise, find the power of two. */
1646 UWtype hi = u >> W_TYPE_SIZE;
1647
1648 UWtype count, shift;
1649 count_leading_zeros (count, hi);
1650
1651 shift = W_TYPE_SIZE - count;
1652
1653 /* Shift down the most significant bits. */
1654 hi = u >> shift;
1655
1656 /* If we lost any nonzero bits, set the lsb to ensure correct rounding. */
1657 if ((UWtype)u << (W_TYPE_SIZE - shift))
1658 hi |= 1;
1659
1660 /* Convert the one word of data, and rescale. */
1661 FSTYPE f = hi, e;
1662 if (shift == W_TYPE_SIZE)
1663 e = Wtype_MAXp1_F;
1664 /* The following two cases could be merged if we knew that the target
1665 supported a native unsigned->float conversion. More often, we only
1666 have a signed conversion, and have to add extra fixup code. */
1667 else if (shift == W_TYPE_SIZE - 1)
1668 e = Wtype_MAXp1_F / 2;
1669 else
1670 e = (Wtype)1 << shift;
1671 return f * e;
1672 #endif
1673 }
1674 #endif
1675
1676 #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
1677 /* Reenable the normal types, in case limits.h needs them. */
1678 #undef char
1679 #undef short
1680 #undef int
1681 #undef long
1682 #undef unsigned
1683 #undef float
1684 #undef double
1685 #undef MIN
1686 #undef MAX
1687 #include <limits.h>
1688
1689 UWtype
__fixunsxfSI(XFtype a)1690 __fixunsxfSI (XFtype a)
1691 {
1692 if (a >= - (DFtype) Wtype_MIN)
1693 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1694 return (Wtype) a;
1695 }
1696 #endif
1697
1698 #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
1699 /* Reenable the normal types, in case limits.h needs them. */
1700 #undef char
1701 #undef short
1702 #undef int
1703 #undef long
1704 #undef unsigned
1705 #undef float
1706 #undef double
1707 #undef MIN
1708 #undef MAX
1709 #include <limits.h>
1710
1711 UWtype
__fixunsdfSI(DFtype a)1712 __fixunsdfSI (DFtype a)
1713 {
1714 if (a >= - (DFtype) Wtype_MIN)
1715 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1716 return (Wtype) a;
1717 }
1718 #endif
1719
1720 #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
1721 /* Reenable the normal types, in case limits.h needs them. */
1722 #undef char
1723 #undef short
1724 #undef int
1725 #undef long
1726 #undef unsigned
1727 #undef float
1728 #undef double
1729 #undef MIN
1730 #undef MAX
1731 #include <limits.h>
1732
1733 UWtype
__fixunssfSI(SFtype a)1734 __fixunssfSI (SFtype a)
1735 {
1736 if (a >= - (SFtype) Wtype_MIN)
1737 return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
1738 return (Wtype) a;
1739 }
1740 #endif
1741
1742 /* Integer power helper used from __builtin_powi for non-constant
1743 exponents. */
1744
1745 #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
1746 || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
1747 || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
1748 || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
1749 # if defined(L_powisf2)
1750 # define TYPE SFtype
1751 # define NAME __powisf2
1752 # elif defined(L_powidf2)
1753 # define TYPE DFtype
1754 # define NAME __powidf2
1755 # elif defined(L_powixf2)
1756 # define TYPE XFtype
1757 # define NAME __powixf2
1758 # elif defined(L_powitf2)
1759 # define TYPE TFtype
1760 # define NAME __powitf2
1761 # endif
1762
1763 #undef int
1764 #undef unsigned
1765 TYPE
NAME(TYPE x,int m)1766 NAME (TYPE x, int m)
1767 {
1768 unsigned int n = m < 0 ? -m : m;
1769 TYPE y = n % 2 ? x : 1;
1770 while (n >>= 1)
1771 {
1772 x = x * x;
1773 if (n % 2)
1774 y = y * x;
1775 }
1776 return m < 0 ? 1/y : y;
1777 }
1778
1779 #endif
1780
1781 #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
1782 || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
1783 || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
1784 || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
1785
1786 #undef float
1787 #undef double
1788 #undef long
1789
1790 #if defined(L_mulsc3) || defined(L_divsc3)
1791 # define MTYPE SFtype
1792 # define CTYPE SCtype
1793 # define MODE sc
1794 # define CEXT f
1795 # define NOTRUNC __FLT_EVAL_METHOD__ == 0
1796 #elif defined(L_muldc3) || defined(L_divdc3)
1797 # define MTYPE DFtype
1798 # define CTYPE DCtype
1799 # define MODE dc
1800 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 64
1801 # define CEXT l
1802 # define NOTRUNC 1
1803 # else
1804 # define CEXT
1805 # define NOTRUNC __FLT_EVAL_METHOD__ == 0 || __FLT_EVAL_METHOD__ == 1
1806 # endif
1807 #elif defined(L_mulxc3) || defined(L_divxc3)
1808 # define MTYPE XFtype
1809 # define CTYPE XCtype
1810 # define MODE xc
1811 # define CEXT l
1812 # define NOTRUNC 1
1813 #elif defined(L_multc3) || defined(L_divtc3)
1814 # define MTYPE TFtype
1815 # define CTYPE TCtype
1816 # define MODE tc
1817 # if LIBGCC2_LONG_DOUBLE_TYPE_SIZE == 128
1818 # define CEXT l
1819 # else
1820 # define CEXT LIBGCC2_TF_CEXT
1821 # endif
1822 # define NOTRUNC 1
1823 #else
1824 # error
1825 #endif
1826
1827 #define CONCAT3(A,B,C) _CONCAT3(A,B,C)
1828 #define _CONCAT3(A,B,C) A##B##C
1829
1830 #define CONCAT2(A,B) _CONCAT2(A,B)
1831 #define _CONCAT2(A,B) A##B
1832
1833 /* All of these would be present in a full C99 implementation of <math.h>
1834 and <complex.h>. Our problem is that only a few systems have such full
1835 implementations. Further, libgcc_s.so isn't currently linked against
1836 libm.so, and even for systems that do provide full C99, the extra overhead
1837 of all programs using libgcc having to link against libm. So avoid it. */
1838
1839 #define isnan(x) __builtin_expect ((x) != (x), 0)
1840 #define isfinite(x) __builtin_expect (!isnan((x) - (x)), 1)
1841 #define isinf(x) __builtin_expect (!isnan(x) & !isfinite(x), 0)
1842
1843 #define INFINITY CONCAT2(__builtin_huge_val, CEXT) ()
1844 #define I 1i
1845
1846 /* Helpers to make the following code slightly less gross. */
1847 #define COPYSIGN CONCAT2(__builtin_copysign, CEXT)
1848 #define FABS CONCAT2(__builtin_fabs, CEXT)
1849
1850 /* Verify that MTYPE matches up with CEXT. */
1851 extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
1852
1853 /* Ensure that we've lost any extra precision. */
1854 #if NOTRUNC
1855 # define TRUNC(x)
1856 #else
1857 # define TRUNC(x) __asm__ ("" : "=m"(x) : "m"(x))
1858 #endif
1859
1860 #if defined(L_mulsc3) || defined(L_muldc3) \
1861 || defined(L_mulxc3) || defined(L_multc3)
1862
1863 CTYPE
1864 CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
1865 {
1866 MTYPE ac, bd, ad, bc, x, y;
1867 CTYPE res;
1868
1869 ac = a * c;
1870 bd = b * d;
1871 ad = a * d;
1872 bc = b * c;
1873
1874 TRUNC (ac);
1875 TRUNC (bd);
1876 TRUNC (ad);
1877 TRUNC (bc);
1878
1879 x = ac - bd;
1880 y = ad + bc;
1881
1882 if (isnan (x) && isnan (y))
1883 {
1884 /* Recover infinities that computed as NaN + iNaN. */
1885 _Bool recalc = 0;
1886 if (isinf (a) || isinf (b))
1887 {
1888 /* z is infinite. "Box" the infinity and change NaNs in
1889 the other factor to 0. */
1890 a = COPYSIGN (isinf (a) ? 1 : 0, a);
1891 b = COPYSIGN (isinf (b) ? 1 : 0, b);
1892 if (isnan (c)) c = COPYSIGN (0, c);
1893 if (isnan (d)) d = COPYSIGN (0, d);
1894 recalc = 1;
1895 }
1896 if (isinf (c) || isinf (d))
1897 {
1898 /* w is infinite. "Box" the infinity and change NaNs in
1899 the other factor to 0. */
1900 c = COPYSIGN (isinf (c) ? 1 : 0, c);
1901 d = COPYSIGN (isinf (d) ? 1 : 0, d);
1902 if (isnan (a)) a = COPYSIGN (0, a);
1903 if (isnan (b)) b = COPYSIGN (0, b);
1904 recalc = 1;
1905 }
1906 if (!recalc
1907 && (isinf (ac) || isinf (bd)
1908 || isinf (ad) || isinf (bc)))
1909 {
1910 /* Recover infinities from overflow by changing NaNs to 0. */
1911 if (isnan (a)) a = COPYSIGN (0, a);
1912 if (isnan (b)) b = COPYSIGN (0, b);
1913 if (isnan (c)) c = COPYSIGN (0, c);
1914 if (isnan (d)) d = COPYSIGN (0, d);
1915 recalc = 1;
1916 }
1917 if (recalc)
1918 {
1919 x = INFINITY * (a * c - b * d);
1920 y = INFINITY * (a * d + b * c);
1921 }
1922 }
1923
1924 __real__ res = x;
1925 __imag__ res = y;
1926 return res;
1927 }
1928 #endif /* complex multiply */
1929
1930 #if defined(L_divsc3) || defined(L_divdc3) \
1931 || defined(L_divxc3) || defined(L_divtc3)
1932
1933 CTYPE
1934 CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
1935 {
1936 MTYPE denom, ratio, x, y;
1937 CTYPE res;
1938
1939 /* ??? We can get better behavior from logarithmic scaling instead of
1940 the division. But that would mean starting to link libgcc against
1941 libm. We could implement something akin to ldexp/frexp as gcc builtins
1942 fairly easily... */
1943 if (FABS (c) < FABS (d))
1944 {
1945 ratio = c / d;
1946 denom = (c * ratio) + d;
1947 x = ((a * ratio) + b) / denom;
1948 y = ((b * ratio) - a) / denom;
1949 }
1950 else
1951 {
1952 ratio = d / c;
1953 denom = (d * ratio) + c;
1954 x = ((b * ratio) + a) / denom;
1955 y = (b - (a * ratio)) / denom;
1956 }
1957
1958 /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
1959 are nonzero/zero, infinite/finite, and finite/infinite. */
1960 if (isnan (x) && isnan (y))
1961 {
1962 if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b)))
1963 {
1964 x = COPYSIGN (INFINITY, c) * a;
1965 y = COPYSIGN (INFINITY, c) * b;
1966 }
1967 else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d))
1968 {
1969 a = COPYSIGN (isinf (a) ? 1 : 0, a);
1970 b = COPYSIGN (isinf (b) ? 1 : 0, b);
1971 x = INFINITY * (a * c + b * d);
1972 y = INFINITY * (b * c - a * d);
1973 }
1974 else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b))
1975 {
1976 c = COPYSIGN (isinf (c) ? 1 : 0, c);
1977 d = COPYSIGN (isinf (d) ? 1 : 0, d);
1978 x = 0.0 * (a * c + b * d);
1979 y = 0.0 * (b * c - a * d);
1980 }
1981 }
1982
1983 __real__ res = x;
1984 __imag__ res = y;
1985 return res;
1986 }
1987 #endif /* complex divide */
1988
1989 #endif /* all complex float routines */
1990
1991 /* From here on down, the routines use normal data types. */
1992
1993 #define SItype bogus_type
1994 #define USItype bogus_type
1995 #define DItype bogus_type
1996 #define UDItype bogus_type
1997 #define SFtype bogus_type
1998 #define DFtype bogus_type
1999 #undef Wtype
2000 #undef UWtype
2001 #undef HWtype
2002 #undef UHWtype
2003 #undef DWtype
2004 #undef UDWtype
2005
2006 #undef char
2007 #undef short
2008 #undef int
2009 #undef long
2010 #undef unsigned
2011 #undef float
2012 #undef double
2013
2014 #ifdef L__gcc_bcmp
2015
2016 /* Like bcmp except the sign is meaningful.
2017 Result is negative if S1 is less than S2,
2018 positive if S1 is greater, 0 if S1 and S2 are equal. */
2019
2020 int
2021 __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
2022 {
2023 while (size > 0)
2024 {
2025 const unsigned char c1 = *s1++, c2 = *s2++;
2026 if (c1 != c2)
2027 return c1 - c2;
2028 size--;
2029 }
2030 return 0;
2031 }
2032
2033 #endif
2034
2035 /* __eprintf used to be used by GCC's private version of <assert.h>.
2036 We no longer provide that header, but this routine remains in libgcc.a
2037 for binary backward compatibility. Note that it is not included in
2038 the shared version of libgcc. */
2039 #ifdef L_eprintf
2040 #ifndef inhibit_libc
2041
2042 #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */
2043 #include <stdio.h>
2044
2045 void
2046 __eprintf (const char *string, const char *expression,
2047 unsigned int line, const char *filename)
2048 {
2049 fprintf (stderr, string, expression, line, filename);
2050 fflush (stderr);
2051 abort ();
2052 }
2053
2054 #endif
2055 #endif
2056
2057
2058 #ifdef L_clear_cache
2059 /* Clear part of an instruction cache. */
2060
2061 void
2062 __clear_cache (char *beg __attribute__((__unused__)),
2063 char *end __attribute__((__unused__)))
2064 {
2065 #ifdef CLEAR_INSN_CACHE
2066 CLEAR_INSN_CACHE (beg, end);
2067 #endif /* CLEAR_INSN_CACHE */
2068 }
2069
2070 #endif /* L_clear_cache */
2071
2072 #ifdef L_trampoline
2073
2074 /* Jump to a trampoline, loading the static chain address. */
2075
2076 #if defined(WINNT) && ! defined(__CYGWIN__)
2077 #include <windows.h>
2078 int getpagesize (void);
2079 int mprotect (char *,int, int);
2080
2081 int
2082 getpagesize (void)
2083 {
2084 #ifdef _ALPHA_
2085 return 8192;
2086 #else
2087 return 4096;
2088 #endif
2089 }
2090
2091 int
2092 mprotect (char *addr, int len, int prot)
2093 {
2094 DWORD np, op;
2095
2096 if (prot == 7)
2097 np = 0x40;
2098 else if (prot == 5)
2099 np = 0x20;
2100 else if (prot == 4)
2101 np = 0x10;
2102 else if (prot == 3)
2103 np = 0x04;
2104 else if (prot == 1)
2105 np = 0x02;
2106 else if (prot == 0)
2107 np = 0x01;
2108 else
2109 return -1;
2110
2111 if (VirtualProtect (addr, len, np, &op))
2112 return 0;
2113 else
2114 return -1;
2115 }
2116
2117 #endif /* WINNT && ! __CYGWIN__ */
2118
2119 #ifdef TRANSFER_FROM_TRAMPOLINE
2120 TRANSFER_FROM_TRAMPOLINE
2121 #endif
2122 #endif /* L_trampoline */
2123
2124 #ifndef __CYGWIN__
2125 #ifdef L__main
2126
2127 #include "gbl-ctors.h"
2128
2129 /* Some systems use __main in a way incompatible with its use in gcc, in these
2130 cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
2131 give the same symbol without quotes for an alternative entry point. You
2132 must define both, or neither. */
2133 #ifndef NAME__MAIN
2134 #define NAME__MAIN "__main"
2135 #define SYMBOL__MAIN __main
2136 #endif
2137
2138 #if defined (INIT_SECTION_ASM_OP) || defined (INIT_ARRAY_SECTION_ASM_OP)
2139 #undef HAS_INIT_SECTION
2140 #define HAS_INIT_SECTION
2141 #endif
2142
2143 #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
2144
2145 /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
2146 code to run constructors. In that case, we need to handle EH here, too. */
2147
2148 #ifdef EH_FRAME_SECTION_NAME
2149 #include "unwind-dw2-fde.h"
2150 extern unsigned char __EH_FRAME_BEGIN__[];
2151 #endif
2152
2153 /* Run all the global destructors on exit from the program. */
2154
2155 void
2156 __do_global_dtors (void)
2157 {
2158 #ifdef DO_GLOBAL_DTORS_BODY
2159 DO_GLOBAL_DTORS_BODY;
2160 #else
2161 static func_ptr *p = __DTOR_LIST__ + 1;
2162 while (*p)
2163 {
2164 p++;
2165 (*(p-1)) ();
2166 }
2167 #endif
2168 #if defined (EH_FRAME_SECTION_NAME) && !defined (HAS_INIT_SECTION)
2169 {
2170 static int completed = 0;
2171 if (! completed)
2172 {
2173 completed = 1;
2174 __deregister_frame_info (__EH_FRAME_BEGIN__);
2175 }
2176 }
2177 #endif
2178 }
2179 #endif
2180
2181 #ifndef HAS_INIT_SECTION
2182 /* Run all the global constructors on entry to the program. */
2183
2184 void
2185 __do_global_ctors (void)
2186 {
2187 #ifdef EH_FRAME_SECTION_NAME
2188 {
2189 static struct object object;
2190 __register_frame_info (__EH_FRAME_BEGIN__, &object);
2191 }
2192 #endif
2193 DO_GLOBAL_CTORS_BODY;
2194 atexit (__do_global_dtors);
2195 }
2196 #endif /* no HAS_INIT_SECTION */
2197
2198 #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
2199 /* Subroutine called automatically by `main'.
2200 Compiling a global function named `main'
2201 produces an automatic call to this function at the beginning.
2202
2203 For many systems, this routine calls __do_global_ctors.
2204 For systems which support a .init section we use the .init section
2205 to run __do_global_ctors, so we need not do anything here. */
2206
2207 extern void SYMBOL__MAIN (void);
2208 void
2209 SYMBOL__MAIN (void)
2210 {
2211 /* Support recursive calls to `main': run initializers just once. */
2212 static int initialized;
2213 if (! initialized)
2214 {
2215 initialized = 1;
2216 __do_global_ctors ();
2217 }
2218 }
2219 #endif /* no HAS_INIT_SECTION or INVOKE__main */
2220
2221 #endif /* L__main */
2222 #endif /* __CYGWIN__ */
2223
2224 #ifdef L_ctors
2225
2226 #include "gbl-ctors.h"
2227
2228 /* Provide default definitions for the lists of constructors and
2229 destructors, so that we don't get linker errors. These symbols are
2230 intentionally bss symbols, so that gld and/or collect will provide
2231 the right values. */
2232
2233 /* We declare the lists here with two elements each,
2234 so that they are valid empty lists if no other definition is loaded.
2235
2236 If we are using the old "set" extensions to have the gnu linker
2237 collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
2238 must be in the bss/common section.
2239
2240 Long term no port should use those extensions. But many still do. */
2241 #if !defined(INIT_SECTION_ASM_OP) && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
2242 #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
2243 func_ptr __CTOR_LIST__[2] = {0, 0};
2244 func_ptr __DTOR_LIST__[2] = {0, 0};
2245 #else
2246 func_ptr __CTOR_LIST__[2];
2247 func_ptr __DTOR_LIST__[2];
2248 #endif
2249 #endif /* no INIT_SECTION_ASM_OP and not CTOR_LISTS_DEFINED_EXTERNALLY */
2250 #endif /* L_ctors */
2251 #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */
2252