OSDN Git Service

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