Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /* More subroutines needed by GCC output code on some machines.  */
  2. /* Compile this one with gcc.  */
  3. /* Copyright (C) 1989-2015 Free Software Foundation, Inc.
  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"
  58. #ifdef DECLARE_LIBRARY_RENAMES
  59.   DECLARE_LIBRARY_RENAMES
  60. #endif
  61.  
  62. #if defined (L_negdi2)
  63. DWtype
  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
  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
  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
  99. #ifdef L_addvdi3
  100. DWtype
  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
  112. #ifdef L_subvsi3
  113. Wtype
  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
  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
  137. #ifdef L_subvdi3
  138. DWtype
  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
  150. #ifdef L_mulvsi3
  151. Wtype
  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
  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
  177. #ifdef L_negvsi2
  178. Wtype
  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
  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
  202. #ifdef L_negvdi2
  203. DWtype
  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
  215. #ifdef L_absvsi2
  216. Wtype
  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
  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
  254. #ifdef L_absvdi2
  255. DWtype
  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
  274. #ifdef L_mulvdi3
  275. DWtype
  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
  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
  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
  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
  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
  486. #ifdef L_bswapsi2
  487. SItype
  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
  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
  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
  525. #ifdef L_ffsdi2
  526. #undef int
  527. int
  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
  545. #ifdef L_muldi3
  546. DWtype
  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
  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
  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
  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
  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
  701. #ifdef L_clzsi2
  702. #undef int
  703. int
  704. __clzSI2 (UWtype x)
  705. {
  706.   Wtype ret;
  707.  
  708.   count_leading_zeros (ret, x);
  709.  
  710.   return ret;
  711. }
  712. #endif
  714. #ifdef L_clzdi2
  715. #undef int
  716. int
  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
  733. #ifdef L_ctzsi2
  734. #undef int
  735. int
  736. __ctzSI2 (UWtype x)
  737. {
  738.   Wtype ret;
  739.  
  740.   count_trailing_zeros (ret, x);
  741.  
  742.   return ret;
  743. }
  744. #endif
  746. #ifdef L_ctzdi2
  747. #undef int
  748. int
  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
  765. #ifdef L_clrsbsi2
  766. #undef int
  767. int
  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
  781. #ifdef L_clrsbdi2
  782. #undef int
  783. int
  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
  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
  822. #if defined(L_popcountsi2) || defined(L_popcountdi2)
  823. #define POPCOUNTCST2(x) (((UWtype) x << BITS_PER_UNIT) | x)
  824. #define POPCOUNTCST4(x) (((UWtype) x << (2 * BITS_PER_UNIT)) | x)
  825. #define POPCOUNTCST8(x) (((UWtype) x << (4 * BITS_PER_UNIT)) | x)
  826. #if W_TYPE_SIZE == BITS_PER_UNIT
  827. #define POPCOUNTCST(x) x
  828. #elif W_TYPE_SIZE == 2 * BITS_PER_UNIT
  829. #define POPCOUNTCST(x) POPCOUNTCST2 (x)
  830. #elif W_TYPE_SIZE == 4 * BITS_PER_UNIT
  831. #define POPCOUNTCST(x) POPCOUNTCST4 (POPCOUNTCST2 (x))
  832. #elif W_TYPE_SIZE == 8 * BITS_PER_UNIT
  833. #define POPCOUNTCST(x) POPCOUNTCST8 (POPCOUNTCST4 (POPCOUNTCST2 (x)))
  834. #endif
  835. #endif
  837. #ifdef L_popcountsi2
  838. #undef int
  839. int
  840. __popcountSI2 (UWtype x)
  841. {
  842.   /* Force table lookup on targets like AVR and RL78 which only
  843.      pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
  844.      have 1, and other small word targets.  */
  845. #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && BITS_PER_UNIT == 8
  846.   x = x - ((x >> 1) & POPCOUNTCST (0x55));
  847.   x = (x & POPCOUNTCST (0x33)) + ((x >> 2) & POPCOUNTCST (0x33));
  848.   x = (x + (x >> 4)) & POPCOUNTCST (0x0F);
  849.   return (x * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - BITS_PER_UNIT);
  850. #else
  851.   int i, ret = 0;
  852.  
  853.   for (i = 0; i < W_TYPE_SIZE; i += 8)
  854.     ret += __popcount_tab[(x >> i) & 0xff];
  855.  
  856.   return ret;
  857. #endif
  858. }
  859. #endif
  861. #ifdef L_popcountdi2
  862. #undef int
  863. int
  864. __popcountDI2 (UDWtype x)
  865. {
  866.   /* Force table lookup on targets like AVR and RL78 which only
  867.      pretend they have LIBGCC2_UNITS_PER_WORD 4, but actually
  868.      have 1, and other small word targets.  */
  869. #if __SIZEOF_INT__ > 2 && defined (POPCOUNTCST) && BITS_PER_UNIT == 8
  870.   const DWunion uu = {.ll = x};
  871.   UWtype x1 = uu.s.low, x2 = uu.s.high;
  872.   x1 = x1 - ((x1 >> 1) & POPCOUNTCST (0x55));
  873.   x2 = x2 - ((x2 >> 1) & POPCOUNTCST (0x55));
  874.   x1 = (x1 & POPCOUNTCST (0x33)) + ((x1 >> 2) & POPCOUNTCST (0x33));
  875.   x2 = (x2 & POPCOUNTCST (0x33)) + ((x2 >> 2) & POPCOUNTCST (0x33));
  876.   x1 = (x1 + (x1 >> 4)) & POPCOUNTCST (0x0F);
  877.   x2 = (x2 + (x2 >> 4)) & POPCOUNTCST (0x0F);
  878.   x1 += x2;
  879.   return (x1 * POPCOUNTCST (0x01)) >> (W_TYPE_SIZE - BITS_PER_UNIT);
  880. #else
  881.   int i, ret = 0;
  882.  
  883.   for (i = 0; i < 2*W_TYPE_SIZE; i += 8)
  884.     ret += __popcount_tab[(x >> i) & 0xff];
  885.  
  886.   return ret;
  887. #endif
  888. }
  889. #endif
  891. #ifdef L_paritysi2
  892. #undef int
  893. int
  894. __paritySI2 (UWtype x)
  895. {
  896. #if W_TYPE_SIZE > 64
  897. # error "fill out the table"
  898. #endif
  899. #if W_TYPE_SIZE > 32
  900.   x ^= x >> 32;
  901. #endif
  902. #if W_TYPE_SIZE > 16
  903.   x ^= x >> 16;
  904. #endif
  905.   x ^= x >> 8;
  906.   x ^= x >> 4;
  907.   x &= 0xf;
  908.   return (0x6996 >> x) & 1;
  909. }
  910. #endif
  912. #ifdef L_paritydi2
  913. #undef int
  914. int
  915. __parityDI2 (UDWtype x)
  916. {
  917.   const DWunion uu = {.ll = x};
  918.   UWtype nx = uu.s.low ^ uu.s.high;
  919.  
  920. #if W_TYPE_SIZE > 64
  921. # error "fill out the table"
  922. #endif
  923. #if W_TYPE_SIZE > 32
  924.   nx ^= nx >> 32;
  925. #endif
  926. #if W_TYPE_SIZE > 16
  927.   nx ^= nx >> 16;
  928. #endif
  929.   nx ^= nx >> 8;
  930.   nx ^= nx >> 4;
  931.   nx &= 0xf;
  932.   return (0x6996 >> nx) & 1;
  933. }
  934. #endif
  935.  
  936. #ifdef L_udivmoddi4
  937. #ifdef TARGET_HAS_NO_HW_DIVIDE
  938.  
  939. #if (defined (L_udivdi3) || defined (L_divdi3) || \
  940.      defined (L_umoddi3) || defined (L_moddi3))
  941. static inline __attribute__ ((__always_inline__))
  942. #endif
  943. UDWtype
  944. __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
  945. {
  946.   UDWtype q = 0, r = n, y = d;
  947.   UWtype lz1, lz2, i, k;
  948.  
  949.   /* Implements align divisor shift dividend method. This algorithm
  950.      aligns the divisor under the dividend and then perform number of
  951.      test-subtract iterations which shift the dividend left. Number of
  952.      iterations is k + 1 where k is the number of bit positions the
  953.      divisor must be shifted left  to align it under the dividend.
  954.      quotient bits can be saved in the rightmost positions of the dividend
  955.      as it shifts left on each test-subtract iteration. */
  956.  
  957.   if (y <= r)
  958.     {
  959.       lz1 = __builtin_clzll (d);
  960.       lz2 = __builtin_clzll (n);
  961.  
  962.       k = lz1 - lz2;
  963.       y = (y << k);
  964.  
  965.       /* Dividend can exceed 2 ^ (width − 1) − 1 but still be less than the
  966.          aligned divisor. Normal iteration can drops the high order bit
  967.          of the dividend. Therefore, first test-subtract iteration is a
  968.          special case, saving its quotient bit in a separate location and
  969.          not shifting the dividend. */
  970.       if (r >= y)
  971.         {
  972.           r = r - y;
  973.           q =  (1ULL << k);
  974.         }
  975.  
  976.       if (k > 0)
  977.         {
  978.           y = y >> 1;
  979.  
  980.           /* k additional iterations where k regular test subtract shift
  981.             dividend iterations are done.  */
  982.           i = k;
  983.           do
  984.             {
  985.               if (r >= y)
  986.                 r = ((r - y) << 1) + 1;
  987.               else
  988.                 r =  (r << 1);
  989.               i = i - 1;
  990.             } while (i != 0);
  991.  
  992.           /* First quotient bit is combined with the quotient bits resulting
  993.              from the k regular iterations.  */
  994.           q = q + r;
  995.           r = r >> k;
  996.           q = q - (r << k);
  997.         }
  998.     }
  999.  
  1000.   if (rp)
  1001.     *rp = r;
  1002.   return q;
  1003. }
  1004. #else
  1005.  
  1006. #if (defined (L_udivdi3) || defined (L_divdi3) || \
  1007.      defined (L_umoddi3) || defined (L_moddi3))
  1008. static inline __attribute__ ((__always_inline__))
  1009. #endif
  1010. UDWtype
  1011. __udivmoddi4 (UDWtype n, UDWtype d, UDWtype *rp)
  1012. {
  1013.   const DWunion nn = {.ll = n};
  1014.   const DWunion dd = {.ll = d};
  1015.   DWunion rr;
  1016.   UWtype d0, d1, n0, n1, n2;
  1017.   UWtype q0, q1;
  1018.   UWtype b, bm;
  1019.  
  1020.   d0 = dd.s.low;
  1021.   d1 = dd.s.high;
  1022.   n0 = nn.s.low;
  1023.   n1 = nn.s.high;
  1024.  
  1025. #if !UDIV_NEEDS_NORMALIZATION
  1026.   if (d1 == 0)
  1027.     {
  1028.       if (d0 > n1)
  1029.         {
  1030.           /* 0q = nn / 0D */
  1031.  
  1032.           udiv_qrnnd (q0, n0, n1, n0, d0);
  1033.           q1 = 0;
  1034.  
  1035.           /* Remainder in n0.  */
  1036.         }
  1037.       else
  1038.         {
  1039.           /* qq = NN / 0d */
  1040.  
  1041.           if (d0 == 0)
  1042.             d0 = 1 / d0;        /* Divide intentionally by zero.  */
  1043.  
  1044.           udiv_qrnnd (q1, n1, 0, n1, d0);
  1045.           udiv_qrnnd (q0, n0, n1, n0, d0);
  1046.  
  1047.           /* Remainder in n0.  */
  1048.         }
  1049.  
  1050.       if (rp != 0)
  1051.         {
  1052.           rr.s.low = n0;
  1053.           rr.s.high = 0;
  1054.           *rp = rr.ll;
  1055.         }
  1056.     }
  1057.  
  1058. #else /* UDIV_NEEDS_NORMALIZATION */
  1059.  
  1060.   if (d1 == 0)
  1061.     {
  1062.       if (d0 > n1)
  1063.         {
  1064.           /* 0q = nn / 0D */
  1065.  
  1066.           count_leading_zeros (bm, d0);
  1067.  
  1068.           if (bm != 0)
  1069.             {
  1070.               /* Normalize, i.e. make the most significant bit of the
  1071.                  denominator set.  */
  1072.  
  1073.               d0 = d0 << bm;
  1074.               n1 = (n1 << bm) | (n0 >> (W_TYPE_SIZE - bm));
  1075.               n0 = n0 << bm;
  1076.             }
  1077.  
  1078.           udiv_qrnnd (q0, n0, n1, n0, d0);
  1079.           q1 = 0;
  1080.  
  1081.           /* Remainder in n0 >> bm.  */
  1082.         }
  1083.       else
  1084.         {
  1085.           /* qq = NN / 0d */
  1086.  
  1087.           if (d0 == 0)
  1088.             d0 = 1 / d0;        /* Divide intentionally by zero.  */
  1089.  
  1090.           count_leading_zeros (bm, d0);
  1091.  
  1092.           if (bm == 0)
  1093.             {
  1094.               /* From (n1 >= d0) /\ (the most significant bit of d0 is set),
  1095.                  conclude (the most significant bit of n1 is set) /\ (the
  1096.                  leading quotient digit q1 = 1).
  1097.  
  1098.                  This special case is necessary, not an optimization.
  1099.                  (Shifts counts of W_TYPE_SIZE are undefined.)  */
  1100.  
  1101.               n1 -= d0;
  1102.               q1 = 1;
  1103.             }
  1104.           else
  1105.             {
  1106.               /* Normalize.  */
  1107.  
  1108.               b = W_TYPE_SIZE - bm;
  1109.  
  1110.               d0 = d0 << bm;
  1111.               n2 = n1 >> b;
  1112.               n1 = (n1 << bm) | (n0 >> b);
  1113.               n0 = n0 << bm;
  1114.  
  1115.               udiv_qrnnd (q1, n1, n2, n1, d0);
  1116.             }
  1117.  
  1118.           /* n1 != d0...  */
  1119.  
  1120.           udiv_qrnnd (q0, n0, n1, n0, d0);
  1121.  
  1122.           /* Remainder in n0 >> bm.  */
  1123.         }
  1124.  
  1125.       if (rp != 0)
  1126.         {
  1127.           rr.s.low = n0 >> bm;
  1128.           rr.s.high = 0;
  1129.           *rp = rr.ll;
  1130.         }
  1131.     }
  1132. #endif /* UDIV_NEEDS_NORMALIZATION */
  1133.  
  1134.   else
  1135.     {
  1136.       if (d1 > n1)
  1137.         {
  1138.           /* 00 = nn / DD */
  1139.  
  1140.           q0 = 0;
  1141.           q1 = 0;
  1142.  
  1143.           /* Remainder in n1n0.  */
  1144.           if (rp != 0)
  1145.             {
  1146.               rr.s.low = n0;
  1147.               rr.s.high = n1;
  1148.               *rp = rr.ll;
  1149.             }
  1150.         }
  1151.       else
  1152.         {
  1153.           /* 0q = NN / dd */
  1154.  
  1155.           count_leading_zeros (bm, d1);
  1156.           if (bm == 0)
  1157.             {
  1158.               /* From (n1 >= d1) /\ (the most significant bit of d1 is set),
  1159.                  conclude (the most significant bit of n1 is set) /\ (the
  1160.                  quotient digit q0 = 0 or 1).
  1161.  
  1162.                  This special case is necessary, not an optimization.  */
  1163.  
  1164.               /* The condition on the next line takes advantage of that
  1165.                  n1 >= d1 (true due to program flow).  */
  1166.               if (n1 > d1 || n0 >= d0)
  1167.                 {
  1168.                   q0 = 1;
  1169.                   sub_ddmmss (n1, n0, n1, n0, d1, d0);
  1170.                 }
  1171.               else
  1172.                 q0 = 0;
  1173.  
  1174.               q1 = 0;
  1175.  
  1176.               if (rp != 0)
  1177.                 {
  1178.                   rr.s.low = n0;
  1179.                   rr.s.high = n1;
  1180.                   *rp = rr.ll;
  1181.                 }
  1182.             }
  1183.           else
  1184.             {
  1185.               UWtype m1, m0;
  1186.               /* Normalize.  */
  1187.  
  1188.               b = W_TYPE_SIZE - bm;
  1189.  
  1190.               d1 = (d1 << bm) | (d0 >> b);
  1191.               d0 = d0 << bm;
  1192.               n2 = n1 >> b;
  1193.               n1 = (n1 << bm) | (n0 >> b);
  1194.               n0 = n0 << bm;
  1195.  
  1196.               udiv_qrnnd (q0, n1, n2, n1, d1);
  1197.               umul_ppmm (m1, m0, q0, d0);
  1198.  
  1199.               if (m1 > n1 || (m1 == n1 && m0 > n0))
  1200.                 {
  1201.                   q0--;
  1202.                   sub_ddmmss (m1, m0, m1, m0, d1, d0);
  1203.                 }
  1204.  
  1205.               q1 = 0;
  1206.  
  1207.               /* Remainder in (n1n0 - m1m0) >> bm.  */
  1208.               if (rp != 0)
  1209.                 {
  1210.                   sub_ddmmss (n1, n0, n1, n0, m1, m0);
  1211.                   rr.s.low = (n1 << b) | (n0 >> bm);
  1212.                   rr.s.high = n1 >> bm;
  1213.                   *rp = rr.ll;
  1214.                 }
  1215.             }
  1216.         }
  1217.     }
  1218.  
  1219.   const DWunion ww = {{.low = q0, .high = q1}};
  1220.   return ww.ll;
  1221. }
  1222. #endif
  1223. #endif
  1224.  
  1225. #ifdef L_divdi3
  1226. DWtype
  1227. __divdi3 (DWtype u, DWtype v)
  1228. {
  1229.   Wtype c = 0;
  1230.   DWunion uu = {.ll = u};
  1231.   DWunion vv = {.ll = v};
  1232.   DWtype w;
  1233.  
  1234.   if (uu.s.high < 0)
  1235.     c = ~c,
  1236.     uu.ll = -uu.ll;
  1237.   if (vv.s.high < 0)
  1238.     c = ~c,
  1239.     vv.ll = -vv.ll;
  1240.  
  1241.   w = __udivmoddi4 (uu.ll, vv.ll, (UDWtype *) 0);
  1242.   if (c)
  1243.     w = -w;
  1244.  
  1245.   return w;
  1246. }
  1247. #endif
  1248.  
  1249. #ifdef L_moddi3
  1250. DWtype
  1251. __moddi3 (DWtype u, DWtype v)
  1252. {
  1253.   Wtype c = 0;
  1254.   DWunion uu = {.ll = u};
  1255.   DWunion vv = {.ll = v};
  1256.   DWtype w;
  1257.  
  1258.   if (uu.s.high < 0)
  1259.     c = ~c,
  1260.     uu.ll = -uu.ll;
  1261.   if (vv.s.high < 0)
  1262.     vv.ll = -vv.ll;
  1263.  
  1264.   (void) __udivmoddi4 (uu.ll, vv.ll, (UDWtype*)&w);
  1265.   if (c)
  1266.     w = -w;
  1267.  
  1268.   return w;
  1269. }
  1270. #endif
  1271.  
  1272. #ifdef L_umoddi3
  1273. UDWtype
  1274. __umoddi3 (UDWtype u, UDWtype v)
  1275. {
  1276.   UDWtype w;
  1277.  
  1278.   (void) __udivmoddi4 (u, v, &w);
  1279.  
  1280.   return w;
  1281. }
  1282. #endif
  1283.  
  1284. #ifdef L_udivdi3
  1285. UDWtype
  1286. __udivdi3 (UDWtype n, UDWtype d)
  1287. {
  1288.   return __udivmoddi4 (n, d, (UDWtype *) 0);
  1289. }
  1290. #endif
  1292. #ifdef L_cmpdi2
  1293. cmp_return_type
  1294. __cmpdi2 (DWtype a, DWtype b)
  1295. {
  1296.   const DWunion au = {.ll = a};
  1297.   const DWunion bu = {.ll = b};
  1298.  
  1299.   if (au.s.high < bu.s.high)
  1300.     return 0;
  1301.   else if (au.s.high > bu.s.high)
  1302.     return 2;
  1303.   if ((UWtype) au.s.low < (UWtype) bu.s.low)
  1304.     return 0;
  1305.   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
  1306.     return 2;
  1307.   return 1;
  1308. }
  1309. #endif
  1310.  
  1311. #ifdef L_ucmpdi2
  1312. cmp_return_type
  1313. __ucmpdi2 (DWtype a, DWtype b)
  1314. {
  1315.   const DWunion au = {.ll = a};
  1316.   const DWunion bu = {.ll = b};
  1317.  
  1318.   if ((UWtype) au.s.high < (UWtype) bu.s.high)
  1319.     return 0;
  1320.   else if ((UWtype) au.s.high > (UWtype) bu.s.high)
  1321.     return 2;
  1322.   if ((UWtype) au.s.low < (UWtype) bu.s.low)
  1323.     return 0;
  1324.   else if ((UWtype) au.s.low > (UWtype) bu.s.low)
  1325.     return 2;
  1326.   return 1;
  1327. }
  1328. #endif
  1330. #if defined(L_fixunstfdi) && LIBGCC2_HAS_TF_MODE
  1331. UDWtype
  1332. __fixunstfDI (TFtype a)
  1333. {
  1334.   if (a < 0)
  1335.     return 0;
  1336.  
  1337.   /* Compute high word of result, as a flonum.  */
  1338.   const TFtype b = (a / Wtype_MAXp1_F);
  1339.   /* Convert that to fixed (but not to DWtype!),
  1340.      and shift it into the high word.  */
  1341.   UDWtype v = (UWtype) b;
  1342.   v <<= W_TYPE_SIZE;
  1343.   /* Remove high part from the TFtype, leaving the low part as flonum.  */
  1344.   a -= (TFtype)v;
  1345.   /* Convert that to fixed (but not to DWtype!) and add it in.
  1346.      Sometimes A comes out negative.  This is significant, since
  1347.      A has more bits than a long int does.  */
  1348.   if (a < 0)
  1349.     v -= (UWtype) (- a);
  1350.   else
  1351.     v += (UWtype) a;
  1352.   return v;
  1353. }
  1354. #endif
  1355.  
  1356. #if defined(L_fixtfdi) && LIBGCC2_HAS_TF_MODE
  1357. DWtype
  1358. __fixtfdi (TFtype a)
  1359. {
  1360.   if (a < 0)
  1361.     return - __fixunstfDI (-a);
  1362.   return __fixunstfDI (a);
  1363. }
  1364. #endif
  1365.  
  1366. #if defined(L_fixunsxfdi) && LIBGCC2_HAS_XF_MODE
  1367. UDWtype
  1368. __fixunsxfDI (XFtype a)
  1369. {
  1370.   if (a < 0)
  1371.     return 0;
  1372.  
  1373.   /* Compute high word of result, as a flonum.  */
  1374.   const XFtype b = (a / Wtype_MAXp1_F);
  1375.   /* Convert that to fixed (but not to DWtype!),
  1376.      and shift it into the high word.  */
  1377.   UDWtype v = (UWtype) b;
  1378.   v <<= W_TYPE_SIZE;
  1379.   /* Remove high part from the XFtype, leaving the low part as flonum.  */
  1380.   a -= (XFtype)v;
  1381.   /* Convert that to fixed (but not to DWtype!) and add it in.
  1382.      Sometimes A comes out negative.  This is significant, since
  1383.      A has more bits than a long int does.  */
  1384.   if (a < 0)
  1385.     v -= (UWtype) (- a);
  1386.   else
  1387.     v += (UWtype) a;
  1388.   return v;
  1389. }
  1390. #endif
  1391.  
  1392. #if defined(L_fixxfdi) && LIBGCC2_HAS_XF_MODE
  1393. DWtype
  1394. __fixxfdi (XFtype a)
  1395. {
  1396.   if (a < 0)
  1397.     return - __fixunsxfDI (-a);
  1398.   return __fixunsxfDI (a);
  1399. }
  1400. #endif
  1401.  
  1402. #if defined(L_fixunsdfdi) && LIBGCC2_HAS_DF_MODE
  1403. UDWtype
  1404. __fixunsdfDI (DFtype a)
  1405. {
  1406.   /* Get high part of result.  The division here will just moves the radix
  1407.      point and will not cause any rounding.  Then the conversion to integral
  1408.      type chops result as desired.  */
  1409.   const UWtype hi = a / Wtype_MAXp1_F;
  1410.  
  1411.   /* Get low part of result.  Convert `hi' to floating type and scale it back,
  1412.      then subtract this from the number being converted.  This leaves the low
  1413.      part.  Convert that to integral type.  */
  1414.   const UWtype lo = a - (DFtype) hi * Wtype_MAXp1_F;
  1415.  
  1416.   /* Assemble result from the two parts.  */
  1417.   return ((UDWtype) hi << W_TYPE_SIZE) | lo;
  1418. }
  1419. #endif
  1420.  
  1421. #if defined(L_fixdfdi) && LIBGCC2_HAS_DF_MODE
  1422. DWtype
  1423. __fixdfdi (DFtype a)
  1424. {
  1425.   if (a < 0)
  1426.     return - __fixunsdfDI (-a);
  1427.   return __fixunsdfDI (a);
  1428. }
  1429. #endif
  1430.  
  1431. #if defined(L_fixunssfdi) && LIBGCC2_HAS_SF_MODE
  1432. UDWtype
  1433. __fixunssfDI (SFtype a)
  1434. {
  1435. #if LIBGCC2_HAS_DF_MODE
  1436.   /* Convert the SFtype to a DFtype, because that is surely not going
  1437.      to lose any bits.  Some day someone else can write a faster version
  1438.      that avoids converting to DFtype, and verify it really works right.  */
  1439.   const DFtype dfa = a;
  1440.  
  1441.   /* Get high part of result.  The division here will just moves the radix
  1442.      point and will not cause any rounding.  Then the conversion to integral
  1443.      type chops result as desired.  */
  1444.   const UWtype hi = dfa / Wtype_MAXp1_F;
  1445.  
  1446.   /* Get low part of result.  Convert `hi' to floating type and scale it back,
  1447.      then subtract this from the number being converted.  This leaves the low
  1448.      part.  Convert that to integral type.  */
  1449.   const UWtype lo = dfa - (DFtype) hi * Wtype_MAXp1_F;
  1450.  
  1451.   /* Assemble result from the two parts.  */
  1452.   return ((UDWtype) hi << W_TYPE_SIZE) | lo;
  1453. #elif FLT_MANT_DIG < W_TYPE_SIZE
  1454.   if (a < 1)
  1455.     return 0;
  1456.   if (a < Wtype_MAXp1_F)
  1457.     return (UWtype)a;
  1458.   if (a < Wtype_MAXp1_F * Wtype_MAXp1_F)
  1459.     {
  1460.       /* Since we know that there are fewer significant bits in the SFmode
  1461.          quantity than in a word, we know that we can convert out all the
  1462.          significant bits in one step, and thus avoid losing bits.  */
  1463.  
  1464.       /* ??? This following loop essentially performs frexpf.  If we could
  1465.          use the real libm function, or poke at the actual bits of the fp
  1466.          format, it would be significantly faster.  */
  1467.  
  1468.       UWtype shift = 0, counter;
  1469.       SFtype msb;
  1470.  
  1471.       a /= Wtype_MAXp1_F;
  1472.       for (counter = W_TYPE_SIZE / 2; counter != 0; counter >>= 1)
  1473.         {
  1474.           SFtype counterf = (UWtype)1 << counter;
  1475.           if (a >= counterf)
  1476.             {
  1477.               shift |= counter;
  1478.               a /= counterf;
  1479.             }
  1480.         }
  1481.  
  1482.       /* Rescale into the range of one word, extract the bits of that
  1483.          one word, and shift the result into position.  */
  1484.       a *= Wtype_MAXp1_F;
  1485.       counter = a;
  1486.       return (DWtype)counter << shift;
  1487.     }
  1488.   return -1;
  1489. #else
  1490. # error
  1491. #endif
  1492. }
  1493. #endif
  1494.  
  1495. #if defined(L_fixsfdi) && LIBGCC2_HAS_SF_MODE
  1496. DWtype
  1497. __fixsfdi (SFtype a)
  1498. {
  1499.   if (a < 0)
  1500.     return - __fixunssfDI (-a);
  1501.   return __fixunssfDI (a);
  1502. }
  1503. #endif
  1504.  
  1505. #if defined(L_floatdixf) && LIBGCC2_HAS_XF_MODE
  1506. XFtype
  1507. __floatdixf (DWtype u)
  1508. {
  1509. #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
  1510. # error
  1511. #endif
  1512.   XFtype d = (Wtype) (u >> W_TYPE_SIZE);
  1513.   d *= Wtype_MAXp1_F;
  1514.   d += (UWtype)u;
  1515.   return d;
  1516. }
  1517. #endif
  1518.  
  1519. #if defined(L_floatundixf) && LIBGCC2_HAS_XF_MODE
  1520. XFtype
  1521. __floatundixf (UDWtype u)
  1522. {
  1523. #if W_TYPE_SIZE > __LIBGCC_XF_MANT_DIG__
  1524. # error
  1525. #endif
  1526.   XFtype d = (UWtype) (u >> W_TYPE_SIZE);
  1527.   d *= Wtype_MAXp1_F;
  1528.   d += (UWtype)u;
  1529.   return d;
  1530. }
  1531. #endif
  1532.  
  1533. #if defined(L_floatditf) && LIBGCC2_HAS_TF_MODE
  1534. TFtype
  1535. __floatditf (DWtype u)
  1536. {
  1537. #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
  1538. # error
  1539. #endif
  1540.   TFtype d = (Wtype) (u >> W_TYPE_SIZE);
  1541.   d *= Wtype_MAXp1_F;
  1542.   d += (UWtype)u;
  1543.   return d;
  1544. }
  1545. #endif
  1546.  
  1547. #if defined(L_floatunditf) && LIBGCC2_HAS_TF_MODE
  1548. TFtype
  1549. __floatunditf (UDWtype u)
  1550. {
  1551. #if W_TYPE_SIZE > __LIBGCC_TF_MANT_DIG__
  1552. # error
  1553. #endif
  1554.   TFtype d = (UWtype) (u >> W_TYPE_SIZE);
  1555.   d *= Wtype_MAXp1_F;
  1556.   d += (UWtype)u;
  1557.   return d;
  1558. }
  1559. #endif
  1560.  
  1561. #if (defined(L_floatdisf) && LIBGCC2_HAS_SF_MODE)       \
  1562.      || (defined(L_floatdidf) && LIBGCC2_HAS_DF_MODE)
  1563. #define DI_SIZE (W_TYPE_SIZE * 2)
  1564. #define F_MODE_OK(SIZE) \
  1565.   (SIZE < DI_SIZE                                                       \
  1566.    && SIZE > (DI_SIZE - SIZE + FSSIZE)                                  \
  1567.    && !AVOID_FP_TYPE_CONVERSION(SIZE))
  1568. #if defined(L_floatdisf)
  1569. #define FUNC __floatdisf
  1570. #define FSTYPE SFtype
  1571. #define FSSIZE __LIBGCC_SF_MANT_DIG__
  1572. #else
  1573. #define FUNC __floatdidf
  1574. #define FSTYPE DFtype
  1575. #define FSSIZE __LIBGCC_DF_MANT_DIG__
  1576. #endif
  1577.  
  1578. FSTYPE
  1579. FUNC (DWtype u)
  1580. {
  1581. #if FSSIZE >= W_TYPE_SIZE
  1582.   /* When the word size is small, we never get any rounding error.  */
  1583.   FSTYPE f = (Wtype) (u >> W_TYPE_SIZE);
  1584.   f *= Wtype_MAXp1_F;
  1585.   f += (UWtype)u;
  1586.   return f;
  1587. #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))       \
  1588.      || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))     \
  1589.      || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
  1590.  
  1591. #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
  1592. # define FSIZE __LIBGCC_DF_MANT_DIG__
  1593. # define FTYPE DFtype
  1594. #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
  1595. # define FSIZE __LIBGCC_XF_MANT_DIG__
  1596. # define FTYPE XFtype
  1597. #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
  1598. # define FSIZE __LIBGCC_TF_MANT_DIG__
  1599. # define FTYPE TFtype
  1600. #else
  1601. # error
  1602. #endif
  1603.  
  1604. #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
  1605.  
  1606.   /* Protect against double-rounding error.
  1607.      Represent any low-order bits, that might be truncated by a bit that
  1608.      won't be lost.  The bit can go in anywhere below the rounding position
  1609.      of the FSTYPE.  A fixed mask and bit position handles all usual
  1610.      configurations.  */
  1611.   if (! (- ((DWtype) 1 << FSIZE) < u
  1612.          && u < ((DWtype) 1 << FSIZE)))
  1613.     {
  1614.       if ((UDWtype) u & (REP_BIT - 1))
  1615.         {
  1616.           u &= ~ (REP_BIT - 1);
  1617.           u |= REP_BIT;
  1618.         }
  1619.     }
  1620.  
  1621.   /* Do the calculation in a wider type so that we don't lose any of
  1622.      the precision of the high word while multiplying it.  */
  1623.   FTYPE f = (Wtype) (u >> W_TYPE_SIZE);
  1624.   f *= Wtype_MAXp1_F;
  1625.   f += (UWtype)u;
  1626.   return (FSTYPE) f;
  1627. #else
  1628. #if FSSIZE >= W_TYPE_SIZE - 2
  1629. # error
  1630. #endif
  1631.   /* Finally, the word size is larger than the number of bits in the
  1632.      required FSTYPE, and we've got no suitable wider type.  The only
  1633.      way to avoid double rounding is to special case the
  1634.      extraction.  */
  1635.  
  1636.   /* If there are no high bits set, fall back to one conversion.  */
  1637.   if ((Wtype)u == u)
  1638.     return (FSTYPE)(Wtype)u;
  1639.  
  1640.   /* Otherwise, find the power of two.  */
  1641.   Wtype hi = u >> W_TYPE_SIZE;
  1642.   if (hi < 0)
  1643.     hi = -(UWtype) hi;
  1644.  
  1645.   UWtype count, shift;
  1646.   count_leading_zeros (count, hi);
  1647.  
  1648.   /* No leading bits means u == minimum.  */
  1649.   if (count == 0)
  1650.     return -(Wtype_MAXp1_F * (Wtype_MAXp1_F / 2));
  1651.  
  1652.   shift = 1 + W_TYPE_SIZE - count;
  1653.  
  1654.   /* Shift down the most significant bits.  */
  1655.   hi = u >> shift;
  1656.  
  1657.   /* If we lost any nonzero bits, set the lsb to ensure correct rounding.  */
  1658.   if ((UWtype)u << (W_TYPE_SIZE - shift))
  1659.     hi |= 1;
  1660.  
  1661.   /* Convert the one word of data, and rescale.  */
  1662.   FSTYPE f = hi, e;
  1663.   if (shift == W_TYPE_SIZE)
  1664.     e = Wtype_MAXp1_F;
  1665.   /* The following two cases could be merged if we knew that the target
  1666.      supported a native unsigned->float conversion.  More often, we only
  1667.      have a signed conversion, and have to add extra fixup code.  */
  1668.   else if (shift == W_TYPE_SIZE - 1)
  1669.     e = Wtype_MAXp1_F / 2;
  1670.   else
  1671.     e = (Wtype)1 << shift;
  1672.   return f * e;
  1673. #endif
  1674. }
  1675. #endif
  1676.  
  1677. #if (defined(L_floatundisf) && LIBGCC2_HAS_SF_MODE)     \
  1678.      || (defined(L_floatundidf) && LIBGCC2_HAS_DF_MODE)
  1679. #define DI_SIZE (W_TYPE_SIZE * 2)
  1680. #define F_MODE_OK(SIZE) \
  1681.   (SIZE < DI_SIZE                                                       \
  1682.    && SIZE > (DI_SIZE - SIZE + FSSIZE)                                  \
  1683.    && !AVOID_FP_TYPE_CONVERSION(SIZE))
  1684. #if defined(L_floatundisf)
  1685. #define FUNC __floatundisf
  1686. #define FSTYPE SFtype
  1687. #define FSSIZE __LIBGCC_SF_MANT_DIG__
  1688. #else
  1689. #define FUNC __floatundidf
  1690. #define FSTYPE DFtype
  1691. #define FSSIZE __LIBGCC_DF_MANT_DIG__
  1692. #endif
  1693.  
  1694. FSTYPE
  1695. FUNC (UDWtype u)
  1696. {
  1697. #if FSSIZE >= W_TYPE_SIZE
  1698.   /* When the word size is small, we never get any rounding error.  */
  1699.   FSTYPE f = (UWtype) (u >> W_TYPE_SIZE);
  1700.   f *= Wtype_MAXp1_F;
  1701.   f += (UWtype)u;
  1702.   return f;
  1703. #elif (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))       \
  1704.      || (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))     \
  1705.      || (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
  1706.  
  1707. #if (LIBGCC2_HAS_DF_MODE && F_MODE_OK (__LIBGCC_DF_MANT_DIG__))
  1708. # define FSIZE __LIBGCC_DF_MANT_DIG__
  1709. # define FTYPE DFtype
  1710. #elif (LIBGCC2_HAS_XF_MODE && F_MODE_OK (__LIBGCC_XF_MANT_DIG__))
  1711. # define FSIZE __LIBGCC_XF_MANT_DIG__
  1712. # define FTYPE XFtype
  1713. #elif (LIBGCC2_HAS_TF_MODE && F_MODE_OK (__LIBGCC_TF_MANT_DIG__))
  1714. # define FSIZE __LIBGCC_TF_MANT_DIG__
  1715. # define FTYPE TFtype
  1716. #else
  1717. # error
  1718. #endif
  1719.  
  1720. #define REP_BIT ((UDWtype) 1 << (DI_SIZE - FSIZE))
  1721.  
  1722.   /* Protect against double-rounding error.
  1723.      Represent any low-order bits, that might be truncated by a bit that
  1724.      won't be lost.  The bit can go in anywhere below the rounding position
  1725.      of the FSTYPE.  A fixed mask and bit position handles all usual
  1726.      configurations.  */
  1727.   if (u >= ((UDWtype) 1 << FSIZE))
  1728.     {
  1729.       if ((UDWtype) u & (REP_BIT - 1))
  1730.         {
  1731.           u &= ~ (REP_BIT - 1);
  1732.           u |= REP_BIT;
  1733.         }
  1734.     }
  1735.  
  1736.   /* Do the calculation in a wider type so that we don't lose any of
  1737.      the precision of the high word while multiplying it.  */
  1738.   FTYPE f = (UWtype) (u >> W_TYPE_SIZE);
  1739.   f *= Wtype_MAXp1_F;
  1740.   f += (UWtype)u;
  1741.   return (FSTYPE) f;
  1742. #else
  1743. #if FSSIZE == W_TYPE_SIZE - 1
  1744. # error
  1745. #endif
  1746.   /* Finally, the word size is larger than the number of bits in the
  1747.      required FSTYPE, and we've got no suitable wider type.  The only
  1748.      way to avoid double rounding is to special case the
  1749.      extraction.  */
  1750.  
  1751.   /* If there are no high bits set, fall back to one conversion.  */
  1752.   if ((UWtype)u == u)
  1753.     return (FSTYPE)(UWtype)u;
  1754.  
  1755.   /* Otherwise, find the power of two.  */
  1756.   UWtype hi = u >> W_TYPE_SIZE;
  1757.  
  1758.   UWtype count, shift;
  1759.   count_leading_zeros (count, hi);
  1760.  
  1761.   shift = W_TYPE_SIZE - count;
  1762.  
  1763.   /* Shift down the most significant bits.  */
  1764.   hi = u >> shift;
  1765.  
  1766.   /* If we lost any nonzero bits, set the lsb to ensure correct rounding.  */
  1767.   if ((UWtype)u << (W_TYPE_SIZE - shift))
  1768.     hi |= 1;
  1769.  
  1770.   /* Convert the one word of data, and rescale.  */
  1771.   FSTYPE f = hi, e;
  1772.   if (shift == W_TYPE_SIZE)
  1773.     e = Wtype_MAXp1_F;
  1774.   /* The following two cases could be merged if we knew that the target
  1775.      supported a native unsigned->float conversion.  More often, we only
  1776.      have a signed conversion, and have to add extra fixup code.  */
  1777.   else if (shift == W_TYPE_SIZE - 1)
  1778.     e = Wtype_MAXp1_F / 2;
  1779.   else
  1780.     e = (Wtype)1 << shift;
  1781.   return f * e;
  1782. #endif
  1783. }
  1784. #endif
  1785.  
  1786. #if defined(L_fixunsxfsi) && LIBGCC2_HAS_XF_MODE
  1787. UWtype
  1788. __fixunsxfSI (XFtype a)
  1789. {
  1790.   if (a >= - (DFtype) Wtype_MIN)
  1791.     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
  1792.   return (Wtype) a;
  1793. }
  1794. #endif
  1795.  
  1796. #if defined(L_fixunsdfsi) && LIBGCC2_HAS_DF_MODE
  1797. UWtype
  1798. __fixunsdfSI (DFtype a)
  1799. {
  1800.   if (a >= - (DFtype) Wtype_MIN)
  1801.     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
  1802.   return (Wtype) a;
  1803. }
  1804. #endif
  1805.  
  1806. #if defined(L_fixunssfsi) && LIBGCC2_HAS_SF_MODE
  1807. UWtype
  1808. __fixunssfSI (SFtype a)
  1809. {
  1810.   if (a >= - (SFtype) Wtype_MIN)
  1811.     return (Wtype) (a + Wtype_MIN) - Wtype_MIN;
  1812.   return (Wtype) a;
  1813. }
  1814. #endif
  1816. /* Integer power helper used from __builtin_powi for non-constant
  1817.    exponents.  */
  1818.  
  1819. #if (defined(L_powisf2) && LIBGCC2_HAS_SF_MODE) \
  1820.     || (defined(L_powidf2) && LIBGCC2_HAS_DF_MODE) \
  1821.     || (defined(L_powixf2) && LIBGCC2_HAS_XF_MODE) \
  1822.     || (defined(L_powitf2) && LIBGCC2_HAS_TF_MODE)
  1823. # if defined(L_powisf2)
  1824. #  define TYPE SFtype
  1825. #  define NAME __powisf2
  1826. # elif defined(L_powidf2)
  1827. #  define TYPE DFtype
  1828. #  define NAME __powidf2
  1829. # elif defined(L_powixf2)
  1830. #  define TYPE XFtype
  1831. #  define NAME __powixf2
  1832. # elif defined(L_powitf2)
  1833. #  define TYPE TFtype
  1834. #  define NAME __powitf2
  1835. # endif
  1836.  
  1837. #undef int
  1838. #undef unsigned
  1839. TYPE
  1840. NAME (TYPE x, int m)
  1841. {
  1842.   unsigned int n = m < 0 ? -m : m;
  1843.   TYPE y = n % 2 ? x : 1;
  1844.   while (n >>= 1)
  1845.     {
  1846.       x = x * x;
  1847.       if (n % 2)
  1848.         y = y * x;
  1849.     }
  1850.   return m < 0 ? 1/y : y;
  1851. }
  1852.  
  1853. #endif
  1855. #if ((defined(L_mulsc3) || defined(L_divsc3)) && LIBGCC2_HAS_SF_MODE) \
  1856.     || ((defined(L_muldc3) || defined(L_divdc3)) && LIBGCC2_HAS_DF_MODE) \
  1857.     || ((defined(L_mulxc3) || defined(L_divxc3)) && LIBGCC2_HAS_XF_MODE) \
  1858.     || ((defined(L_multc3) || defined(L_divtc3)) && LIBGCC2_HAS_TF_MODE)
  1859.  
  1860. #undef float
  1861. #undef double
  1862. #undef long
  1863.  
  1864. #if defined(L_mulsc3) || defined(L_divsc3)
  1865. # define MTYPE  SFtype
  1866. # define CTYPE  SCtype
  1867. # define MODE   sc
  1868. # define CEXT   __LIBGCC_SF_FUNC_EXT__
  1869. # define NOTRUNC __LIBGCC_SF_EXCESS_PRECISION__
  1870. #elif defined(L_muldc3) || defined(L_divdc3)
  1871. # define MTYPE  DFtype
  1872. # define CTYPE  DCtype
  1873. # define MODE   dc
  1874. # define CEXT   __LIBGCC_DF_FUNC_EXT__
  1875. # define NOTRUNC __LIBGCC_DF_EXCESS_PRECISION__
  1876. #elif defined(L_mulxc3) || defined(L_divxc3)
  1877. # define MTYPE  XFtype
  1878. # define CTYPE  XCtype
  1879. # define MODE   xc
  1880. # define CEXT   __LIBGCC_XF_FUNC_EXT__
  1881. # define NOTRUNC __LIBGCC_XF_EXCESS_PRECISION__
  1882. #elif defined(L_multc3) || defined(L_divtc3)
  1883. # define MTYPE  TFtype
  1884. # define CTYPE  TCtype
  1885. # define MODE   tc
  1886. # define CEXT   __LIBGCC_TF_FUNC_EXT__
  1887. # define NOTRUNC __LIBGCC_TF_EXCESS_PRECISION__
  1888. #else
  1889. # error
  1890. #endif
  1891.  
  1892. #define CONCAT3(A,B,C)  _CONCAT3(A,B,C)
  1893. #define _CONCAT3(A,B,C) A##B##C
  1894.  
  1895. #define CONCAT2(A,B)    _CONCAT2(A,B)
  1896. #define _CONCAT2(A,B)   A##B
  1897.  
  1898. /* All of these would be present in a full C99 implementation of <math.h>
  1899.    and <complex.h>.  Our problem is that only a few systems have such full
  1900.    implementations.  Further, libgcc_s.so isn't currently linked against
  1901.    libm.so, and even for systems that do provide full C99, the extra overhead
  1902.    of all programs using libgcc having to link against libm.  So avoid it.  */
  1903.  
  1904. #define isnan(x)        __builtin_expect ((x) != (x), 0)
  1905. #define isfinite(x)     __builtin_expect (!isnan((x) - (x)), 1)
  1906. #define isinf(x)        __builtin_expect (!isnan(x) & !isfinite(x), 0)
  1907.  
  1908. #define INFINITY        CONCAT2(__builtin_huge_val, CEXT) ()
  1909. #define I               1i
  1910.  
  1911. /* Helpers to make the following code slightly less gross.  */
  1912. #define COPYSIGN        CONCAT2(__builtin_copysign, CEXT)
  1913. #define FABS            CONCAT2(__builtin_fabs, CEXT)
  1914.  
  1915. /* Verify that MTYPE matches up with CEXT.  */
  1916. extern void *compile_type_assert[sizeof(INFINITY) == sizeof(MTYPE) ? 1 : -1];
  1917.  
  1918. /* Ensure that we've lost any extra precision.  */
  1919. #if NOTRUNC
  1920. # define TRUNC(x)
  1921. #else
  1922. # define TRUNC(x)       __asm__ ("" : "=m"(x) : "m"(x))
  1923. #endif
  1924.  
  1925. #if defined(L_mulsc3) || defined(L_muldc3) \
  1926.     || defined(L_mulxc3) || defined(L_multc3)
  1927.  
  1928. CTYPE
  1929. CONCAT3(__mul,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
  1930. {
  1931.   MTYPE ac, bd, ad, bc, x, y;
  1932.   CTYPE res;
  1933.  
  1934.   ac = a * c;
  1935.   bd = b * d;
  1936.   ad = a * d;
  1937.   bc = b * c;
  1938.  
  1939.   TRUNC (ac);
  1940.   TRUNC (bd);
  1941.   TRUNC (ad);
  1942.   TRUNC (bc);
  1943.  
  1944.   x = ac - bd;
  1945.   y = ad + bc;
  1946.  
  1947.   if (isnan (x) && isnan (y))
  1948.     {
  1949.       /* Recover infinities that computed as NaN + iNaN.  */
  1950.       _Bool recalc = 0;
  1951.       if (isinf (a) || isinf (b))
  1952.         {
  1953.           /* z is infinite.  "Box" the infinity and change NaNs in
  1954.              the other factor to 0.  */
  1955.           a = COPYSIGN (isinf (a) ? 1 : 0, a);
  1956.           b = COPYSIGN (isinf (b) ? 1 : 0, b);
  1957.           if (isnan (c)) c = COPYSIGN (0, c);
  1958.           if (isnan (d)) d = COPYSIGN (0, d);
  1959.           recalc = 1;
  1960.         }
  1961.      if (isinf (c) || isinf (d))
  1962.         {
  1963.           /* w is infinite.  "Box" the infinity and change NaNs in
  1964.              the other factor to 0.  */
  1965.           c = COPYSIGN (isinf (c) ? 1 : 0, c);
  1966.           d = COPYSIGN (isinf (d) ? 1 : 0, d);
  1967.           if (isnan (a)) a = COPYSIGN (0, a);
  1968.           if (isnan (b)) b = COPYSIGN (0, b);
  1969.           recalc = 1;
  1970.         }
  1971.      if (!recalc
  1972.           && (isinf (ac) || isinf (bd)
  1973.               || isinf (ad) || isinf (bc)))
  1974.         {
  1975.           /* Recover infinities from overflow by changing NaNs to 0.  */
  1976.           if (isnan (a)) a = COPYSIGN (0, a);
  1977.           if (isnan (b)) b = COPYSIGN (0, b);
  1978.           if (isnan (c)) c = COPYSIGN (0, c);
  1979.           if (isnan (d)) d = COPYSIGN (0, d);
  1980.           recalc = 1;
  1981.         }
  1982.       if (recalc)
  1983.         {
  1984.           x = INFINITY * (a * c - b * d);
  1985.           y = INFINITY * (a * d + b * c);
  1986.         }
  1987.     }
  1988.  
  1989.   __real__ res = x;
  1990.   __imag__ res = y;
  1991.   return res;
  1992. }
  1993. #endif /* complex multiply */
  1994.  
  1995. #if defined(L_divsc3) || defined(L_divdc3) \
  1996.     || defined(L_divxc3) || defined(L_divtc3)
  1997.  
  1998. CTYPE
  1999. CONCAT3(__div,MODE,3) (MTYPE a, MTYPE b, MTYPE c, MTYPE d)
  2000. {
  2001.   MTYPE denom, ratio, x, y;
  2002.   CTYPE res;
  2003.  
  2004.   /* ??? We can get better behavior from logarithmic scaling instead of
  2005.      the division.  But that would mean starting to link libgcc against
  2006.      libm.  We could implement something akin to ldexp/frexp as gcc builtins
  2007.      fairly easily...  */
  2008.   if (FABS (c) < FABS (d))
  2009.     {
  2010.       ratio = c / d;
  2011.       denom = (c * ratio) + d;
  2012.       x = ((a * ratio) + b) / denom;
  2013.       y = ((b * ratio) - a) / denom;
  2014.     }
  2015.   else
  2016.     {
  2017.       ratio = d / c;
  2018.       denom = (d * ratio) + c;
  2019.       x = ((b * ratio) + a) / denom;
  2020.       y = (b - (a * ratio)) / denom;
  2021.     }
  2022.  
  2023.   /* Recover infinities and zeros that computed as NaN+iNaN; the only cases
  2024.      are nonzero/zero, infinite/finite, and finite/infinite.  */
  2025.   if (isnan (x) && isnan (y))
  2026.     {
  2027.       if (c == 0.0 && d == 0.0 && (!isnan (a) || !isnan (b)))
  2028.         {
  2029.           x = COPYSIGN (INFINITY, c) * a;
  2030.           y = COPYSIGN (INFINITY, c) * b;
  2031.         }
  2032.       else if ((isinf (a) || isinf (b)) && isfinite (c) && isfinite (d))
  2033.         {
  2034.           a = COPYSIGN (isinf (a) ? 1 : 0, a);
  2035.           b = COPYSIGN (isinf (b) ? 1 : 0, b);
  2036.           x = INFINITY * (a * c + b * d);
  2037.           y = INFINITY * (b * c - a * d);
  2038.         }
  2039.       else if ((isinf (c) || isinf (d)) && isfinite (a) && isfinite (b))
  2040.         {
  2041.           c = COPYSIGN (isinf (c) ? 1 : 0, c);
  2042.           d = COPYSIGN (isinf (d) ? 1 : 0, d);
  2043.           x = 0.0 * (a * c + b * d);
  2044.           y = 0.0 * (b * c - a * d);
  2045.         }
  2046.     }
  2047.  
  2048.   __real__ res = x;
  2049.   __imag__ res = y;
  2050.   return res;
  2051. }
  2052. #endif /* complex divide */
  2053.  
  2054. #endif /* all complex float routines */
  2056. /* From here on down, the routines use normal data types.  */
  2057.  
  2058. #define SItype bogus_type
  2059. #define USItype bogus_type
  2060. #define DItype bogus_type
  2061. #define UDItype bogus_type
  2062. #define SFtype bogus_type
  2063. #define DFtype bogus_type
  2064. #undef Wtype
  2065. #undef UWtype
  2066. #undef HWtype
  2067. #undef UHWtype
  2068. #undef DWtype
  2069. #undef UDWtype
  2070.  
  2071. #undef char
  2072. #undef short
  2073. #undef int
  2074. #undef long
  2075. #undef unsigned
  2076. #undef float
  2077. #undef double
  2079. #ifdef L__gcc_bcmp
  2080.  
  2081. /* Like bcmp except the sign is meaningful.
  2082.    Result is negative if S1 is less than S2,
  2083.    positive if S1 is greater, 0 if S1 and S2 are equal.  */
  2084.  
  2085. int
  2086. __gcc_bcmp (const unsigned char *s1, const unsigned char *s2, size_t size)
  2087. {
  2088.   while (size > 0)
  2089.     {
  2090.       const unsigned char c1 = *s1++, c2 = *s2++;
  2091.       if (c1 != c2)
  2092.         return c1 - c2;
  2093.       size--;
  2094.     }
  2095.   return 0;
  2096. }
  2097.  
  2098. #endif
  2100. /* __eprintf used to be used by GCC's private version of <assert.h>.
  2101.    We no longer provide that header, but this routine remains in libgcc.a
  2102.    for binary backward compatibility.  Note that it is not included in
  2103.    the shared version of libgcc.  */
  2104. #ifdef L_eprintf
  2105. #ifndef inhibit_libc
  2106.  
  2107. #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch.  */
  2108. #include <stdio.h>
  2109.  
  2110. void
  2111. __eprintf (const char *string, const char *expression,
  2112.            unsigned int line, const char *filename)
  2113. {
  2114.   fprintf (stderr, string, expression, line, filename);
  2115.   fflush (stderr);
  2116.   abort ();
  2117. }
  2118.  
  2119. #endif
  2120. #endif
  2121.  
  2123. #ifdef L_clear_cache
  2124. /* Clear part of an instruction cache.  */
  2125.  
  2126. void
  2127. __clear_cache (char *beg __attribute__((__unused__)),
  2128.                char *end __attribute__((__unused__)))
  2129. {
  2130. #ifdef CLEAR_INSN_CACHE
  2131.   CLEAR_INSN_CACHE (beg, end);
  2132. #endif /* CLEAR_INSN_CACHE */
  2133. }
  2134.  
  2135. #endif /* L_clear_cache */
  2137. #ifdef L_trampoline
  2138.  
  2139. /* Jump to a trampoline, loading the static chain address.  */
  2140.  
  2141. #if defined(WINNT) && ! defined(__CYGWIN__)
  2142. #include <windows.h>
  2143. int getpagesize (void);
  2144. int mprotect (char *,int, int);
  2145.  
  2146. int
  2147. getpagesize (void)
  2148. {
  2149. #ifdef _ALPHA_
  2150.   return 8192;
  2151. #else
  2152.   return 4096;
  2153. #endif
  2154. }
  2155.  
  2156. int
  2157. mprotect (char *addr, int len, int prot)
  2158. {
  2159.   DWORD np, op;
  2160.  
  2161.   if (prot == 7)
  2162.     np = 0x40;
  2163.   else if (prot == 5)
  2164.     np = 0x20;
  2165.   else if (prot == 4)
  2166.     np = 0x10;
  2167.   else if (prot == 3)
  2168.     np = 0x04;
  2169.   else if (prot == 1)
  2170.     np = 0x02;
  2171.   else if (prot == 0)
  2172.     np = 0x01;
  2173.   else
  2174.     return -1;
  2175.  
  2176.   if (VirtualProtect (addr, len, np, &op))
  2177.     return 0;
  2178.   else
  2179.     return -1;
  2180. }
  2181.  
  2182. #endif /* WINNT && ! __CYGWIN__ */
  2183.  
  2184. #ifdef TRANSFER_FROM_TRAMPOLINE
  2185. TRANSFER_FROM_TRAMPOLINE
  2186. #endif
  2187. #endif /* L_trampoline */
  2189. #ifndef __CYGWIN__
  2190. #ifdef L__main
  2191.  
  2192. #include "gbl-ctors.h"
  2193.  
  2194. /* Some systems use __main in a way incompatible with its use in gcc, in these
  2195.    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
  2196.    give the same symbol without quotes for an alternative entry point.  You
  2197.    must define both, or neither.  */
  2198. #ifndef NAME__MAIN
  2199. #define NAME__MAIN "__main"
  2200. #define SYMBOL__MAIN __main
  2201. #endif
  2202.  
  2203. #if defined (__LIBGCC_INIT_SECTION_ASM_OP__) \
  2204.     || defined (__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__)
  2205. #undef HAS_INIT_SECTION
  2206. #define HAS_INIT_SECTION
  2207. #endif
  2208.  
  2209. #if !defined (HAS_INIT_SECTION) || !defined (OBJECT_FORMAT_ELF)
  2210.  
  2211. /* Some ELF crosses use crtstuff.c to provide __CTOR_LIST__, but use this
  2212.    code to run constructors.  In that case, we need to handle EH here, too.
  2213.    But MINGW32 is special because it handles CRTSTUFF and EH on its own.  */
  2214.  
  2215. #ifdef __MINGW32__
  2216. #undef __LIBGCC_EH_FRAME_SECTION_NAME__
  2217. #endif
  2218.  
  2219. #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
  2220. #include "unwind-dw2-fde.h"
  2221. extern unsigned char __EH_FRAME_BEGIN__[];
  2222. #endif
  2223.  
  2224. /* Run all the global destructors on exit from the program.  */
  2225.  
  2226. void
  2227. __do_global_dtors (void)
  2228. {
  2229. #ifdef DO_GLOBAL_DTORS_BODY
  2230.   DO_GLOBAL_DTORS_BODY;
  2231. #else
  2232.   static func_ptr *p = __DTOR_LIST__ + 1;
  2233.   while (*p)
  2234.     {
  2235.       p++;
  2236.       (*(p-1)) ();
  2237.     }
  2238. #endif
  2239. #if defined (__LIBGCC_EH_FRAME_SECTION_NAME__) && !defined (HAS_INIT_SECTION)
  2240.   {
  2241.     static int completed = 0;
  2242.     if (! completed)
  2243.       {
  2244.         completed = 1;
  2245.         __deregister_frame_info (__EH_FRAME_BEGIN__);
  2246.       }
  2247.   }
  2248. #endif
  2249. }
  2250. #endif
  2251.  
  2252. #ifndef HAS_INIT_SECTION
  2253. /* Run all the global constructors on entry to the program.  */
  2254.  
  2255. void
  2256. __do_global_ctors (void)
  2257. {
  2258. #ifdef __LIBGCC_EH_FRAME_SECTION_NAME__
  2259.   {
  2260.     static struct object object;
  2261.     __register_frame_info (__EH_FRAME_BEGIN__, &object);
  2262.   }
  2263. #endif
  2264.   DO_GLOBAL_CTORS_BODY;
  2265.   atexit (__do_global_dtors);
  2266. }
  2267. #endif /* no HAS_INIT_SECTION */
  2268.  
  2269. #if !defined (HAS_INIT_SECTION) || defined (INVOKE__main)
  2270. /* Subroutine called automatically by `main'.
  2271.    Compiling a global function named `main'
  2272.    produces an automatic call to this function at the beginning.
  2273.  
  2274.    For many systems, this routine calls __do_global_ctors.
  2275.    For systems which support a .init section we use the .init section
  2276.    to run __do_global_ctors, so we need not do anything here.  */
  2277.  
  2278. extern void SYMBOL__MAIN (void);
  2279. void
  2280. SYMBOL__MAIN (void)
  2281. {
  2282.   /* Support recursive calls to `main': run initializers just once.  */
  2283.   static int initialized;
  2284.   if (! initialized)
  2285.     {
  2286.       initialized = 1;
  2287.       __do_global_ctors ();
  2288.     }
  2289. }
  2290. #endif /* no HAS_INIT_SECTION or INVOKE__main */
  2291.  
  2292. #endif /* L__main */
  2293. #endif /* __CYGWIN__ */
  2295. #ifdef L_ctors
  2296.  
  2297. #include "gbl-ctors.h"
  2298.  
  2299. /* Provide default definitions for the lists of constructors and
  2300.    destructors, so that we don't get linker errors.  These symbols are
  2301.    intentionally bss symbols, so that gld and/or collect will provide
  2302.    the right values.  */
  2303.  
  2304. /* We declare the lists here with two elements each,
  2305.    so that they are valid empty lists if no other definition is loaded.
  2306.  
  2307.    If we are using the old "set" extensions to have the gnu linker
  2308.    collect ctors and dtors, then we __CTOR_LIST__ and __DTOR_LIST__
  2309.    must be in the bss/common section.
  2310.  
  2311.    Long term no port should use those extensions.  But many still do.  */
  2312. #if !defined(__LIBGCC_INIT_SECTION_ASM_OP__) \
  2313.     && !defined(CTOR_LISTS_DEFINED_EXTERNALLY)
  2314. #if defined (TARGET_ASM_CONSTRUCTOR) || defined (USE_COLLECT2)
  2315. func_ptr __CTOR_LIST__[2] = {0, 0};
  2316. func_ptr __DTOR_LIST__[2] = {0, 0};
  2317. #else
  2318. func_ptr __CTOR_LIST__[2];
  2319. func_ptr __DTOR_LIST__[2];
  2320. #endif
  2321. #endif /* no __LIBGCC_INIT_SECTION_ASM_OP__ and not CTOR_LISTS_DEFINED_EXTERNALLY */
  2322. #endif /* L_ctors */
  2323. #endif /* LIBGCC2_UNITS_PER_WORD <= MIN_UNITS_PER_WORD */
  2324.