LCOV - code coverage report
Current view: top level - gcc - real.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 1726 2202 78.4 %
Date: 2020-05-30 12:51:24 Functions: 105 126 83.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* real.c - software floating point emulation.
       2                 :            :    Copyright (C) 1993-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Stephen L. Moshier (moshier@world.std.com).
       4                 :            :    Re-written by Richard Henderson <rth@redhat.com>
       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 3, or (at your option) any later
      11                 :            :    version.
      12                 :            : 
      13                 :            :    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14                 :            :    WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15                 :            :    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16                 :            :    for more details.
      17                 :            : 
      18                 :            :    You should have received a copy of the GNU General Public License
      19                 :            :    along with GCC; see the file COPYING3.  If not see
      20                 :            :    <http://www.gnu.org/licenses/>.  */
      21                 :            : 
      22                 :            : #include "config.h"
      23                 :            : #include "system.h"
      24                 :            : #include "coretypes.h"
      25                 :            : #include "tm.h"
      26                 :            : #include "rtl.h"
      27                 :            : #include "tree.h"
      28                 :            : #include "realmpfr.h"
      29                 :            : #include "dfp.h"
      30                 :            : 
      31                 :            : /* The floating point model used internally is not exactly IEEE 754
      32                 :            :    compliant, and close to the description in the ISO C99 standard,
      33                 :            :    section 5.2.4.2.2 Characteristics of floating types.
      34                 :            : 
      35                 :            :    Specifically
      36                 :            : 
      37                 :            :         x = s * b^e * \sum_{k=1}^p f_k * b^{-k}
      38                 :            : 
      39                 :            :         where
      40                 :            :                 s = sign (+- 1)
      41                 :            :                 b = base or radix, here always 2
      42                 :            :                 e = exponent
      43                 :            :                 p = precision (the number of base-b digits in the significand)
      44                 :            :                 f_k = the digits of the significand.
      45                 :            : 
      46                 :            :    We differ from typical IEEE 754 encodings in that the entire
      47                 :            :    significand is fractional.  Normalized significands are in the
      48                 :            :    range [0.5, 1.0).
      49                 :            : 
      50                 :            :    A requirement of the model is that P be larger than the largest
      51                 :            :    supported target floating-point type by at least 2 bits.  This gives
      52                 :            :    us proper rounding when we truncate to the target type.  In addition,
      53                 :            :    E must be large enough to hold the smallest supported denormal number
      54                 :            :    in a normalized form.
      55                 :            : 
      56                 :            :    Both of these requirements are easily satisfied.  The largest target
      57                 :            :    significand is 113 bits; we store at least 160.  The smallest
      58                 :            :    denormal number fits in 17 exponent bits; we store 26.  */
      59                 :            : 
      60                 :            : 
      61                 :            : /* Used to classify two numbers simultaneously.  */
      62                 :            : #define CLASS2(A, B)  ((A) << 2 | (B))
      63                 :            : 
      64                 :            : #if HOST_BITS_PER_LONG != 64 && HOST_BITS_PER_LONG != 32
      65                 :            :  #error "Some constant folding done by hand to avoid shift count warnings"
      66                 :            : #endif
      67                 :            : 
      68                 :            : static void get_zero (REAL_VALUE_TYPE *, int);
      69                 :            : static void get_canonical_qnan (REAL_VALUE_TYPE *, int);
      70                 :            : static void get_canonical_snan (REAL_VALUE_TYPE *, int);
      71                 :            : static void get_inf (REAL_VALUE_TYPE *, int);
      72                 :            : static bool sticky_rshift_significand (REAL_VALUE_TYPE *,
      73                 :            :                                        const REAL_VALUE_TYPE *, unsigned int);
      74                 :            : static void rshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      75                 :            :                                 unsigned int);
      76                 :            : static void lshift_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      77                 :            :                                 unsigned int);
      78                 :            : static void lshift_significand_1 (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
      79                 :            : static bool add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *,
      80                 :            :                               const REAL_VALUE_TYPE *);
      81                 :            : static bool sub_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      82                 :            :                               const REAL_VALUE_TYPE *, int);
      83                 :            : static void neg_significand (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
      84                 :            : static int cmp_significands (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
      85                 :            : static int cmp_significand_0 (const REAL_VALUE_TYPE *);
      86                 :            : static void set_significand_bit (REAL_VALUE_TYPE *, unsigned int);
      87                 :            : static void clear_significand_bit (REAL_VALUE_TYPE *, unsigned int);
      88                 :            : static bool test_significand_bit (REAL_VALUE_TYPE *, unsigned int);
      89                 :            : static void clear_significand_below (REAL_VALUE_TYPE *, unsigned int);
      90                 :            : static bool div_significands (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      91                 :            :                               const REAL_VALUE_TYPE *);
      92                 :            : static void normalize (REAL_VALUE_TYPE *);
      93                 :            : 
      94                 :            : static bool do_add (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      95                 :            :                     const REAL_VALUE_TYPE *, int);
      96                 :            : static bool do_multiply (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      97                 :            :                          const REAL_VALUE_TYPE *);
      98                 :            : static bool do_divide (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *,
      99                 :            :                        const REAL_VALUE_TYPE *);
     100                 :            : static int do_compare (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
     101                 :            : static void do_fix_trunc (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     102                 :            : 
     103                 :            : static unsigned long rtd_divmod (REAL_VALUE_TYPE *, REAL_VALUE_TYPE *);
     104                 :            : static void decimal_from_integer (REAL_VALUE_TYPE *);
     105                 :            : static void decimal_integer_string (char *, const REAL_VALUE_TYPE *,
     106                 :            :                                     size_t);
     107                 :            : 
     108                 :            : static const REAL_VALUE_TYPE * ten_to_ptwo (int);
     109                 :            : static const REAL_VALUE_TYPE * ten_to_mptwo (int);
     110                 :            : static const REAL_VALUE_TYPE * real_digit (int);
     111                 :            : static void times_pten (REAL_VALUE_TYPE *, int);
     112                 :            : 
     113                 :            : static void round_for_format (const struct real_format *, REAL_VALUE_TYPE *);
     114                 :            : 
     115                 :            : /* Initialize R with a positive zero.  */
     116                 :            : 
     117                 :            : static inline void
     118                 :   36124700 : get_zero (REAL_VALUE_TYPE *r, int sign)
     119                 :            : {
     120                 :   36124700 :   memset (r, 0, sizeof (*r));
     121                 :   36124700 :   r->sign = sign;
     122                 :     825267 : }
     123                 :            : 
     124                 :            : /* Initialize R with the canonical quiet NaN.  */
     125                 :            : 
     126                 :            : static inline void
     127                 :      84405 : get_canonical_qnan (REAL_VALUE_TYPE *r, int sign)
     128                 :            : {
     129                 :      84405 :   memset (r, 0, sizeof (*r));
     130                 :      84405 :   r->cl = rvc_nan;
     131                 :      84405 :   r->sign = sign;
     132                 :      84405 :   r->canonical = 1;
     133                 :      83344 : }
     134                 :            : 
     135                 :            : static inline void
     136                 :      47134 : get_canonical_snan (REAL_VALUE_TYPE *r, int sign)
     137                 :            : {
     138                 :      47134 :   memset (r, 0, sizeof (*r));
     139                 :      47134 :   r->cl = rvc_nan;
     140                 :      47134 :   r->sign = sign;
     141                 :      47134 :   r->signalling = 1;
     142                 :      47134 :   r->canonical = 1;
     143                 :      47126 : }
     144                 :            : 
     145                 :            : static inline void
     146                 :     514407 : get_inf (REAL_VALUE_TYPE *r, int sign)
     147                 :            : {
     148                 :     514407 :   memset (r, 0, sizeof (*r));
     149                 :     514407 :   r->cl = rvc_inf;
     150                 :     514407 :   r->sign = sign;
     151                 :     353261 : }
     152                 :            : 
     153                 :            : 
     154                 :            : /* Right-shift the significand of A by N bits; put the result in the
     155                 :            :    significand of R.  If any one bits are shifted out, return true.  */
     156                 :            : 
     157                 :            : static bool
     158                 :   34988500 : sticky_rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     159                 :            :                            unsigned int n)
     160                 :            : {
     161                 :   34988500 :   unsigned long sticky = 0;
     162                 :   34988500 :   unsigned int i, ofs = 0;
     163                 :            : 
     164                 :   34988500 :   if (n >= HOST_BITS_PER_LONG)
     165                 :            :     {
     166                 :       8271 :       for (i = 0, ofs = n / HOST_BITS_PER_LONG; i < ofs; ++i)
     167                 :       4270 :         sticky |= a->sig[i];
     168                 :       4001 :       n &= HOST_BITS_PER_LONG - 1;
     169                 :            :     }
     170                 :            : 
     171                 :   34988500 :   if (n != 0)
     172                 :            :     {
     173                 :   34987800 :       sticky |= a->sig[ofs] & (((unsigned long)1 << n) - 1);
     174                 :  139951000 :       for (i = 0; i < SIGSZ; ++i)
     175                 :            :         {
     176                 :  104963000 :           r->sig[i]
     177                 :  104963000 :             = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
     178                 :  104963000 :                | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
     179                 :  104963000 :                   << (HOST_BITS_PER_LONG - n)));
     180                 :            :         }
     181                 :            :     }
     182                 :            :   else
     183                 :            :     {
     184                 :       2053 :       for (i = 0; ofs + i < SIGSZ; ++i)
     185                 :       1287 :         r->sig[i] = a->sig[ofs + i];
     186                 :       1777 :       for (; i < SIGSZ; ++i)
     187                 :       1011 :         r->sig[i] = 0;
     188                 :            :     }
     189                 :            : 
     190                 :   34988500 :   return sticky != 0;
     191                 :            : }
     192                 :            : 
     193                 :            : /* Right-shift the significand of A by N bits; put the result in the
     194                 :            :    significand of R.  */
     195                 :            : 
     196                 :            : static void
     197                 :     159909 : rshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     198                 :            :                     unsigned int n)
     199                 :            : {
     200                 :     159909 :   unsigned int i, ofs = n / HOST_BITS_PER_LONG;
     201                 :            : 
     202                 :     159909 :   n &= HOST_BITS_PER_LONG - 1;
     203                 :     159909 :   if (n != 0)
     204                 :            :     {
     205                 :     639636 :       for (i = 0; i < SIGSZ; ++i)
     206                 :            :         {
     207                 :     479727 :           r->sig[i]
     208                 :     479727 :             = (((ofs + i >= SIGSZ ? 0 : a->sig[ofs + i]) >> n)
     209                 :     479727 :                | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[ofs + i + 1])
     210                 :     479727 :                   << (HOST_BITS_PER_LONG - n)));
     211                 :            :         }
     212                 :            :     }
     213                 :            :   else
     214                 :            :     {
     215                 :          0 :       for (i = 0; ofs + i < SIGSZ; ++i)
     216                 :          0 :         r->sig[i] = a->sig[ofs + i];
     217                 :          0 :       for (; i < SIGSZ; ++i)
     218                 :          0 :         r->sig[i] = 0;
     219                 :            :     }
     220                 :     159909 : }
     221                 :            : 
     222                 :            : /* Left-shift the significand of A by N bits; put the result in the
     223                 :            :    significand of R.  */
     224                 :            : 
     225                 :            : static void
     226                 :   43557400 : lshift_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     227                 :            :                     unsigned int n)
     228                 :            : {
     229                 :   43557400 :   unsigned int i, ofs = n / HOST_BITS_PER_LONG;
     230                 :            : 
     231                 :   43557400 :   n &= HOST_BITS_PER_LONG - 1;
     232                 :   43557400 :   if (n == 0)
     233                 :            :     {
     234                 :      45564 :       for (i = 0; ofs + i < SIGSZ; ++i)
     235                 :      30128 :         r->sig[SIGSZ-1-i] = a->sig[SIGSZ-1-i-ofs];
     236                 :      31616 :       for (; i < SIGSZ; ++i)
     237                 :      16180 :         r->sig[SIGSZ-1-i] = 0;
     238                 :            :     }
     239                 :            :   else
     240                 :  174168000 :     for (i = 0; i < SIGSZ; ++i)
     241                 :            :       {
     242                 :  261252000 :         r->sig[SIGSZ-1-i]
     243                 :  130626000 :           = (((ofs + i >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs]) << n)
     244                 :  130626000 :              | ((ofs + i + 1 >= SIGSZ ? 0 : a->sig[SIGSZ-1-i-ofs-1])
     245                 :  130626000 :                 >> (HOST_BITS_PER_LONG - n)));
     246                 :            :       }
     247                 :   43557400 : }
     248                 :            : 
     249                 :            : /* Likewise, but N is specialized to 1.  */
     250                 :            : 
     251                 :            : static inline void
     252                 :  205706000 : lshift_significand_1 (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
     253                 :            : {
     254                 :  205706000 :   unsigned int i;
     255                 :            : 
     256                 :  617119000 :   for (i = SIGSZ - 1; i > 0; --i)
     257                 :  411413000 :     r->sig[i] = (a->sig[i] << 1) | (a->sig[i-1] >> (HOST_BITS_PER_LONG - 1));
     258                 :  205706000 :   r->sig[0] = a->sig[0] << 1;
     259                 :  205706000 : }
     260                 :            : 
     261                 :            : /* Add the significands of A and B, placing the result in R.  Return
     262                 :            :    true if there was carry out of the most significant word.  */
     263                 :            : 
     264                 :            : static inline bool
     265                 :        204 : add_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     266                 :            :                   const REAL_VALUE_TYPE *b)
     267                 :            : {
     268                 :            :   bool carry = false;
     269                 :            :   int i;
     270                 :            : 
     271                 :        816 :   for (i = 0; i < SIGSZ; ++i)
     272                 :            :     {
     273                 :  103854000 :       unsigned long ai = a->sig[i];
     274                 :  103854000 :       unsigned long ri = ai + b->sig[i];
     275                 :            : 
     276                 :  103854000 :       if (carry)
     277                 :            :         {
     278                 :    2886090 :           carry = ri < ai;
     279                 :    2886090 :           carry |= ++ri == 0;
     280                 :            :         }
     281                 :            :       else
     282                 :  100968000 :         carry = ri < ai;
     283                 :            : 
     284                 :  103854000 :       r->sig[i] = ri;
     285                 :            :     }
     286                 :            : 
     287                 :   34617900 :   return carry;
     288                 :            : }
     289                 :            : 
     290                 :            : /* Subtract the significands of A and B, placing the result in R.  CARRY is
     291                 :            :    true if there's a borrow incoming to the least significant word.
     292                 :            :    Return true if there was borrow out of the most significant word.  */
     293                 :            : 
     294                 :            : static inline bool
     295                 :      83320 : sub_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     296                 :            :                   const REAL_VALUE_TYPE *b, int carry)
     297                 :            : {
     298                 :      83320 :   int i;
     299                 :            : 
     300                 :     333280 :   for (i = 0; i < SIGSZ; ++i)
     301                 :            :     {
     302                 :  273836000 :       unsigned long ai = a->sig[i];
     303                 :  273836000 :       unsigned long ri = ai - b->sig[i];
     304                 :            : 
     305                 :  273836000 :       if (carry)
     306                 :            :         {
     307                 :   35159500 :           carry = ri > ai;
     308                 :   35159500 :           carry |= ~--ri == 0;
     309                 :            :         }
     310                 :            :       else
     311                 :  238676000 :         carry = ri > ai;
     312                 :            : 
     313                 :  273836000 :       r->sig[i] = ri;
     314                 :            :     }
     315                 :            : 
     316                 :   91277700 :   return carry;
     317                 :            : }
     318                 :            : 
     319                 :            : /* Negate the significand A, placing the result in R.  */
     320                 :            : 
     321                 :            : static inline void
     322                 :       4052 : neg_significand (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
     323                 :            : {
     324                 :       4052 :   bool carry = true;
     325                 :       4052 :   int i;
     326                 :            : 
     327                 :      16208 :   for (i = 0; i < SIGSZ; ++i)
     328                 :            :     {
     329                 :      12156 :       unsigned long ri, ai = a->sig[i];
     330                 :            : 
     331                 :      12156 :       if (carry)
     332                 :            :         {
     333                 :      12156 :           if (ai)
     334                 :            :             {
     335                 :       4052 :               ri = -ai;
     336                 :       4052 :               carry = false;
     337                 :            :             }
     338                 :            :           else
     339                 :            :             ri = ai;
     340                 :            :         }
     341                 :            :       else
     342                 :          0 :         ri = ~ai;
     343                 :            : 
     344                 :      12156 :       r->sig[i] = ri;
     345                 :            :     }
     346                 :            : }
     347                 :            : 
     348                 :            : /* Compare significands.  Return tri-state vs zero.  */
     349                 :            : 
     350                 :            : static inline int
     351                 :     428570 : cmp_significands (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
     352                 :            : {
     353                 :     428570 :   int i;
     354                 :            : 
     355                 :  170109000 :   for (i = SIGSZ - 1; i >= 0; --i)
     356                 :            :     {
     357                 :  170168000 :       unsigned long ai = a->sig[i];
     358                 :  170168000 :       unsigned long bi = b->sig[i];
     359                 :            : 
     360                 :  170168000 :       if (ai > bi)
     361                 :            :         return 1;
     362                 :  122967000 :       if (ai < bi)
     363                 :            :         return -1;
     364                 :            :     }
     365                 :            : 
     366                 :            :   return 0;
     367                 :            : }
     368                 :            : 
     369                 :            : /* Return true if A is nonzero.  */
     370                 :            : 
     371                 :            : static inline int
     372                 :    2471520 : cmp_significand_0 (const REAL_VALUE_TYPE *a)
     373                 :            : {
     374                 :    2471520 :   int i;
     375                 :            : 
     376                 :    2751790 :   for (i = SIGSZ - 1; i >= 0; --i)
     377                 :    2719170 :     if (a->sig[i])
     378                 :            :       return 1;
     379                 :            : 
     380                 :            :   return 0;
     381                 :            : }
     382                 :            : 
     383                 :            : /* Set bit N of the significand of R.  */
     384                 :            : 
     385                 :            : static inline void
     386                 :   83755900 : set_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
     387                 :            : {
     388                 :   83755900 :   r->sig[n / HOST_BITS_PER_LONG]
     389                 :   83755900 :     |= (unsigned long)1 << (n % HOST_BITS_PER_LONG);
     390                 :   83754500 : }
     391                 :            : 
     392                 :            : /* Clear bit N of the significand of R.  */
     393                 :            : 
     394                 :            : static inline void
     395                 :        268 : clear_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
     396                 :            : {
     397                 :        268 :   r->sig[n / HOST_BITS_PER_LONG]
     398                 :        268 :     &= ~((unsigned long)1 << (n % HOST_BITS_PER_LONG));
     399                 :          0 : }
     400                 :            : 
     401                 :            : /* Test bit N of the significand of R.  */
     402                 :            : 
     403                 :            : static inline bool
     404                 :    6379690 : test_significand_bit (REAL_VALUE_TYPE *r, unsigned int n)
     405                 :            : {
     406                 :            :   /* ??? Compiler bug here if we return this expression directly.
     407                 :            :      The conversion to bool strips the "&1" and we wind up testing
     408                 :            :      e.g. 2 != 0 -> true.  Seen in gcc version 3.2 20020520.  */
     409                 :    6379690 :   int t = (r->sig[n / HOST_BITS_PER_LONG] >> (n % HOST_BITS_PER_LONG)) & 1;
     410                 :    6379690 :   return t;
     411                 :            : }
     412                 :            : 
     413                 :            : /* Clear bits 0..N-1 of the significand of R.  */
     414                 :            : 
     415                 :            : static void
     416                 :    6862670 : clear_significand_below (REAL_VALUE_TYPE *r, unsigned int n)
     417                 :            : {
     418                 :    6862670 :   int i, w = n / HOST_BITS_PER_LONG;
     419                 :            : 
     420                 :   19629900 :   for (i = 0; i < w; ++i)
     421                 :   12767200 :     r->sig[i] = 0;
     422                 :            : 
     423                 :            :   /* We are actually passing N == SIGNIFICAND_BITS which would result
     424                 :            :      in an out-of-bound access below.  */
     425                 :    6862650 :   if (n % HOST_BITS_PER_LONG != 0)
     426                 :    5600510 :     r->sig[w] &= ~(((unsigned long)1 << (n % HOST_BITS_PER_LONG)) - 1);
     427                 :          0 : }
     428                 :            : 
     429                 :            : /* Divide the significands of A and B, placing the result in R.  Return
     430                 :            :    true if the division was inexact.  */
     431                 :            : 
     432                 :            : static inline bool
     433                 :    1000990 : div_significands (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     434                 :            :                   const REAL_VALUE_TYPE *b)
     435                 :            : {
     436                 :    1000990 :   REAL_VALUE_TYPE u;
     437                 :    1000990 :   int i, bit = SIGNIFICAND_BITS - 1;
     438                 :    1000990 :   unsigned long msb, inexact;
     439                 :            : 
     440                 :    1000990 :   u = *a;
     441                 :    1000990 :   memset (r->sig, 0, sizeof (r->sig));
     442                 :            : 
     443                 :    1000990 :   msb = 0;
     444                 :    1000990 :   goto start;
     445                 :  191190000 :   do
     446                 :            :     {
     447                 :  191190000 :       msb = u.sig[SIGSZ-1] & SIG_MSB;
     448                 :  191190000 :       lshift_significand_1 (&u, &u);
     449                 :  192191000 :     start:
     450                 :  343254000 :       if (msb || cmp_significands (&u, b) >= 0)
     451                 :            :         {
     452                 :  333215000 :           sub_significands (&u, &u, b, 0);
     453                 :   83303600 :           set_significand_bit (r, bit);
     454                 :            :         }
     455                 :            :     }
     456                 :  192191000 :   while (--bit >= 0);
     457                 :            : 
     458                 :    4003980 :   for (i = 0, inexact = 0; i < SIGSZ; i++)
     459                 :    3002980 :     inexact |= u.sig[i];
     460                 :            : 
     461                 :    1000990 :   return inexact != 0;
     462                 :            : }
     463                 :            : 
     464                 :            : /* Adjust the exponent and significand of R such that the most
     465                 :            :    significant bit is set.  We underflow to zero and overflow to
     466                 :            :    infinity here, without denormals.  (The intermediate representation
     467                 :            :    exponent is large enough to handle target denormals normalized.)  */
     468                 :            : 
     469                 :            : static void
     470                 :  136415000 : normalize (REAL_VALUE_TYPE *r)
     471                 :            : {
     472                 :  136415000 :   int shift = 0, exp;
     473                 :  136415000 :   int i, j;
     474                 :            : 
     475                 :  136415000 :   if (r->decimal)
     476                 :            :     return;
     477                 :            : 
     478                 :            :   /* Find the first word that is nonzero.  */
     479                 :  256405000 :   for (i = SIGSZ - 1; i >= 0; i--)
     480                 :  216362000 :     if (r->sig[i] == 0)
     481                 :  120276000 :       shift += HOST_BITS_PER_LONG;
     482                 :            :     else
     483                 :            :       break;
     484                 :            : 
     485                 :            :   /* Zero significand flushes to zero.  */
     486                 :  136129000 :   if (i < 0)
     487                 :            :     {
     488                 :   40042500 :       r->cl = rvc_zero;
     489                 :   40042500 :       SET_REAL_EXP (r, 0);
     490                 :   40042500 :       return;
     491                 :            :     }
     492                 :            : 
     493                 :            :   /* Find the first bit that is nonzero.  */
     494                 :  173591000 :   for (j = 0; ; j++)
     495                 :  269677000 :     if (r->sig[i] & ((unsigned long)1 << (HOST_BITS_PER_LONG - 1 - j)))
     496                 :            :       break;
     497                 :   96086100 :   shift += j;
     498                 :            : 
     499                 :   96086100 :   if (shift > 0)
     500                 :            :     {
     501                 :   43556000 :       exp = REAL_EXP (r) - shift;
     502                 :   43556000 :       if (exp > MAX_EXP)
     503                 :  136415000 :         get_inf (r, r->sign);
     504                 :   43556000 :       else if (exp < -MAX_EXP)
     505                 :          0 :         get_zero (r, r->sign);
     506                 :            :       else
     507                 :            :         {
     508                 :   43556000 :           SET_REAL_EXP (r, exp);
     509                 :   43556000 :           lshift_significand (r, r, shift);
     510                 :            :         }
     511                 :            :     }
     512                 :            : }
     513                 :            : 
     514                 :            : /* Calculate R = A + (SUBTRACT_P ? -B : B).  Return true if the
     515                 :            :    result may be inexact due to a loss of precision.  */
     516                 :            : 
     517                 :            : static bool
     518                 :   86445900 : do_add (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     519                 :            :         const REAL_VALUE_TYPE *b, int subtract_p)
     520                 :            : {
     521                 :   86445900 :   int dexp, sign, exp;
     522                 :   86445900 :   REAL_VALUE_TYPE t;
     523                 :   86445900 :   bool inexact = false;
     524                 :            : 
     525                 :            :   /* Determine if we need to add or subtract.  */
     526                 :   86445900 :   sign = a->sign;
     527                 :   86445900 :   subtract_p = (sign ^ b->sign) ^ subtract_p;
     528                 :            : 
     529                 :   86445900 :   switch (CLASS2 (a->cl, b->cl))
     530                 :            :     {
     531                 :   11511800 :     case CLASS2 (rvc_zero, rvc_zero):
     532                 :            :       /* -0 + -0 = -0, -0 - +0 = -0; all other cases yield +0.  */
     533                 :   11511800 :       get_zero (r, sign & !subtract_p);
     534                 :   11511800 :       return false;
     535                 :            : 
     536                 :   12048500 :     case CLASS2 (rvc_zero, rvc_normal):
     537                 :   12048500 :     case CLASS2 (rvc_zero, rvc_inf):
     538                 :   12048500 :     case CLASS2 (rvc_zero, rvc_nan):
     539                 :            :       /* 0 + ANY = ANY.  */
     540                 :   12048500 :     case CLASS2 (rvc_normal, rvc_nan):
     541                 :   12048500 :     case CLASS2 (rvc_inf, rvc_nan):
     542                 :   12048500 :     case CLASS2 (rvc_nan, rvc_nan):
     543                 :            :       /* ANY + NaN = NaN.  */
     544                 :   12048500 :     case CLASS2 (rvc_normal, rvc_inf):
     545                 :            :       /* R + Inf = Inf.  */
     546                 :   12048500 :       *r = *b;
     547                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     548                 :            :          responsibility to avoid the operation if flag_signaling_nans
     549                 :            :          is on.  */
     550                 :   12048500 :       r->signalling = 0;
     551                 :   12048500 :       r->sign = sign ^ subtract_p;
     552                 :   12048500 :       return false;
     553                 :            : 
     554                 :   28635900 :     case CLASS2 (rvc_normal, rvc_zero):
     555                 :   28635900 :     case CLASS2 (rvc_inf, rvc_zero):
     556                 :   28635900 :     case CLASS2 (rvc_nan, rvc_zero):
     557                 :            :       /* ANY + 0 = ANY.  */
     558                 :   28635900 :     case CLASS2 (rvc_nan, rvc_normal):
     559                 :   28635900 :     case CLASS2 (rvc_nan, rvc_inf):
     560                 :            :       /* NaN + ANY = NaN.  */
     561                 :   28635900 :     case CLASS2 (rvc_inf, rvc_normal):
     562                 :            :       /* Inf + R = Inf.  */
     563                 :   28635900 :       *r = *a;
     564                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     565                 :            :          responsibility to avoid the operation if flag_signaling_nans
     566                 :            :          is on.  */
     567                 :   28635900 :       r->signalling = 0;
     568                 :   28635900 :       return false;
     569                 :            : 
     570                 :        101 :     case CLASS2 (rvc_inf, rvc_inf):
     571                 :        101 :       if (subtract_p)
     572                 :            :         /* Inf - Inf = NaN.  */
     573                 :         95 :         get_canonical_qnan (r, 0);
     574                 :            :       else
     575                 :            :         /* Inf + Inf = Inf.  */
     576                 :          6 :         *r = *a;
     577                 :            :       return false;
     578                 :            : 
     579                 :   34249500 :     case CLASS2 (rvc_normal, rvc_normal):
     580                 :   34249500 :       break;
     581                 :            : 
     582                 :            :     default:
     583                 :            :       gcc_unreachable ();
     584                 :            :     }
     585                 :            : 
     586                 :            :   /* Swap the arguments such that A has the larger exponent.  */
     587                 :   34249500 :   dexp = REAL_EXP (a) - REAL_EXP (b);
     588                 :   34249500 :   if (dexp < 0)
     589                 :            :     {
     590                 :   32271800 :       const REAL_VALUE_TYPE *t;
     591                 :   32271800 :       t = a, a = b, b = t;
     592                 :   32271800 :       dexp = -dexp;
     593                 :   32271800 :       sign ^= subtract_p;
     594                 :            :     }
     595                 :   34249500 :   exp = REAL_EXP (a);
     596                 :            : 
     597                 :            :   /* If the exponents are not identical, we need to shift the
     598                 :            :      significand of B down.  */
     599                 :   34249500 :   if (dexp > 0)
     600                 :            :     {
     601                 :            :       /* If the exponents are too far apart, the significands
     602                 :            :          do not overlap, which makes the subtraction a noop.  */
     603                 :   33644200 :       if (dexp >= SIGNIFICAND_BITS)
     604                 :            :         {
     605                 :        415 :           *r = *a;
     606                 :        415 :           r->sign = sign;
     607                 :        415 :           return true;
     608                 :            :         }
     609                 :            : 
     610                 :   33643800 :       inexact |= sticky_rshift_significand (&t, b, dexp);
     611                 :   33643800 :       b = &t;
     612                 :            :     }
     613                 :            : 
     614                 :   34249100 :   if (subtract_p)
     615                 :            :     {
     616                 :     164752 :       if (sub_significands (r, a, b, inexact))
     617                 :            :         {
     618                 :            :           /* We got a borrow out of the subtraction.  That means that
     619                 :            :              A and B had the same exponent, and B had the larger
     620                 :            :              significand.  We need to swap the sign and negate the
     621                 :            :              significand.  */
     622                 :       4052 :           sign ^= 1;
     623                 :       4052 :           neg_significand (r, r);
     624                 :            :         }
     625                 :            :     }
     626                 :            :   else
     627                 :            :     {
     628                 :  136667000 :       if (add_significands (r, a, b))
     629                 :            :         {
     630                 :            :           /* We got carry out of the addition.  This means we need to
     631                 :            :              shift the significand back down one bit and increase the
     632                 :            :              exponent.  */
     633                 :    1238360 :           inexact |= sticky_rshift_significand (r, r, 1);
     634                 :    1238360 :           r->sig[SIGSZ-1] |= SIG_MSB;
     635                 :    1238360 :           if (++exp > MAX_EXP)
     636                 :            :             {
     637                 :          0 :               get_inf (r, sign);
     638                 :          0 :               return true;
     639                 :            :             }
     640                 :            :         }
     641                 :            :     }
     642                 :            : 
     643                 :   34249100 :   r->cl = rvc_normal;
     644                 :   34249100 :   r->sign = sign;
     645                 :   34249100 :   SET_REAL_EXP (r, exp);
     646                 :            :   /* Zero out the remaining fields.  */
     647                 :   34249100 :   r->signalling = 0;
     648                 :   34249100 :   r->canonical = 0;
     649                 :   34249100 :   r->decimal = 0;
     650                 :            : 
     651                 :            :   /* Re-normalize the result.  */
     652                 :   34249100 :   normalize (r);
     653                 :            : 
     654                 :            :   /* Special case: if the subtraction results in zero, the result
     655                 :            :      is positive.  */
     656                 :   34249100 :   if (r->cl == rvc_zero)
     657                 :       4758 :     r->sign = 0;
     658                 :            :   else
     659                 :   34244400 :     r->sig[0] |= inexact;
     660                 :            : 
     661                 :            :   return inexact;
     662                 :            : }
     663                 :            : 
     664                 :            : /* Calculate R = A * B.  Return true if the result may be inexact.  */
     665                 :            : 
     666                 :            : static bool
     667                 :   15356500 : do_multiply (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     668                 :            :              const REAL_VALUE_TYPE *b)
     669                 :            : {
     670                 :   15356500 :   REAL_VALUE_TYPE u, t, *rr;
     671                 :   15356500 :   unsigned int i, j, k;
     672                 :   15356500 :   int sign = a->sign ^ b->sign;
     673                 :   15356500 :   bool inexact = false;
     674                 :            : 
     675                 :   15356500 :   switch (CLASS2 (a->cl, b->cl))
     676                 :            :     {
     677                 :    3315760 :     case CLASS2 (rvc_zero, rvc_zero):
     678                 :    3315760 :     case CLASS2 (rvc_zero, rvc_normal):
     679                 :    3315760 :     case CLASS2 (rvc_normal, rvc_zero):
     680                 :            :       /* +-0 * ANY = 0 with appropriate sign.  */
     681                 :    3315760 :       get_zero (r, sign);
     682                 :    3315760 :       return false;
     683                 :            : 
     684                 :          0 :     case CLASS2 (rvc_zero, rvc_nan):
     685                 :          0 :     case CLASS2 (rvc_normal, rvc_nan):
     686                 :          0 :     case CLASS2 (rvc_inf, rvc_nan):
     687                 :          0 :     case CLASS2 (rvc_nan, rvc_nan):
     688                 :            :       /* ANY * NaN = NaN.  */
     689                 :          0 :       *r = *b;
     690                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     691                 :            :          responsibility to avoid the operation if flag_signaling_nans
     692                 :            :          is on.  */
     693                 :          0 :       r->signalling = 0;
     694                 :          0 :       r->sign = sign;
     695                 :          0 :       return false;
     696                 :            : 
     697                 :         65 :     case CLASS2 (rvc_nan, rvc_zero):
     698                 :         65 :     case CLASS2 (rvc_nan, rvc_normal):
     699                 :         65 :     case CLASS2 (rvc_nan, rvc_inf):
     700                 :            :       /* NaN * ANY = NaN.  */
     701                 :         65 :       *r = *a;
     702                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     703                 :            :          responsibility to avoid the operation if flag_signaling_nans
     704                 :            :          is on.  */
     705                 :         65 :       r->signalling = 0;
     706                 :         65 :       r->sign = sign;
     707                 :         65 :       return false;
     708                 :            : 
     709                 :        684 :     case CLASS2 (rvc_zero, rvc_inf):
     710                 :        684 :     case CLASS2 (rvc_inf, rvc_zero):
     711                 :            :       /* 0 * Inf = NaN */
     712                 :        684 :       get_canonical_qnan (r, sign);
     713                 :        684 :       return false;
     714                 :            : 
     715                 :      40786 :     case CLASS2 (rvc_inf, rvc_inf):
     716                 :      40786 :     case CLASS2 (rvc_normal, rvc_inf):
     717                 :      40786 :     case CLASS2 (rvc_inf, rvc_normal):
     718                 :            :       /* Inf * Inf = Inf, R * Inf = Inf */
     719                 :      40786 :       get_inf (r, sign);
     720                 :      40786 :       return false;
     721                 :            : 
     722                 :   11999200 :     case CLASS2 (rvc_normal, rvc_normal):
     723                 :   11999200 :       break;
     724                 :            : 
     725                 :            :     default:
     726                 :            :       gcc_unreachable ();
     727                 :            :     }
     728                 :            : 
     729                 :   11999200 :   if (r == a || r == b)
     730                 :            :     rr = &t;
     731                 :            :   else
     732                 :    5911050 :     rr = r;
     733                 :   11999200 :   get_zero (rr, 0);
     734                 :            : 
     735                 :            :   /* Collect all the partial products.  Since we don't have sure access
     736                 :            :      to a widening multiply, we split each long into two half-words.
     737                 :            : 
     738                 :            :      Consider the long-hand form of a four half-word multiplication:
     739                 :            : 
     740                 :            :                  A  B  C  D
     741                 :            :               *  E  F  G  H
     742                 :            :              --------------
     743                 :            :                 DE DF DG DH
     744                 :            :              CE CF CG CH
     745                 :            :           BE BF BG BH
     746                 :            :        AE AF AG AH
     747                 :            : 
     748                 :            :      We construct partial products of the widened half-word products
     749                 :            :      that are known to not overlap, e.g. DF+DH.  Each such partial
     750                 :            :      product is given its proper exponent, which allows us to sum them
     751                 :            :      and obtain the finished product.  */
     752                 :            : 
     753                 :   83992600 :   for (i = 0; i < SIGSZ * 2; ++i)
     754                 :            :     {
     755                 :   71995100 :       unsigned long ai = a->sig[i / 2];
     756                 :   71995100 :       if (i & 1)
     757                 :   35997500 :         ai >>= HOST_BITS_PER_LONG / 2;
     758                 :            :       else
     759                 :   35997500 :         ai &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
     760                 :            : 
     761                 :   71995100 :       if (ai == 0)
     762                 :   29013300 :         continue;
     763                 :            : 
     764                 :  128944000 :       for (j = 0; j < 2; ++j)
     765                 :            :         {
     766                 :   85963600 :           int exp = (REAL_EXP (a) - (2*SIGSZ-1-i)*(HOST_BITS_PER_LONG/2)
     767                 :   85963600 :                      + (REAL_EXP (b) - (1-j)*(HOST_BITS_PER_LONG/2)));
     768                 :            : 
     769                 :   85963600 :           if (exp > MAX_EXP)
     770                 :            :             {
     771                 :       1654 :               get_inf (r, sign);
     772                 :       1654 :               return true;
     773                 :            :             }
     774                 :   85961900 :           if (exp < -MAX_EXP)
     775                 :            :             {
     776                 :            :               /* Would underflow to zero, which we shouldn't bother adding.  */
     777                 :          0 :               inexact = true;
     778                 :          0 :               continue;
     779                 :            :             }
     780                 :            : 
     781                 :   85961900 :           memset (&u, 0, sizeof (u));
     782                 :   85961900 :           u.cl = rvc_normal;
     783                 :   85961900 :           SET_REAL_EXP (&u, exp);
     784                 :            : 
     785                 :  343848000 :           for (k = j; k < SIGSZ * 2; k += 2)
     786                 :            :             {
     787                 :  257886000 :               unsigned long bi = b->sig[k / 2];
     788                 :  257886000 :               if (k & 1)
     789                 :  128940000 :                 bi >>= HOST_BITS_PER_LONG / 2;
     790                 :            :               else
     791                 :  128945000 :                 bi &= ((unsigned long)1 << (HOST_BITS_PER_LONG / 2)) - 1;
     792                 :            : 
     793                 :  257886000 :               u.sig[k / 2] = ai * bi;
     794                 :            :             }
     795                 :            : 
     796                 :   85961900 :           normalize (&u);
     797                 :   85961900 :           inexact |= do_add (rr, rr, &u, 0);
     798                 :            :         }
     799                 :            :     }
     800                 :            : 
     801                 :   11997500 :   rr->sign = sign;
     802                 :   11997500 :   if (rr != r)
     803                 :    6086480 :     *r = t;
     804                 :            : 
     805                 :            :   return inexact;
     806                 :            : }
     807                 :            : 
     808                 :            : /* Calculate R = A / B.  Return true if the result may be inexact.  */
     809                 :            : 
     810                 :            : static bool
     811                 :    1004890 : do_divide (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a,
     812                 :            :            const REAL_VALUE_TYPE *b)
     813                 :            : {
     814                 :    1004890 :   int exp, sign = a->sign ^ b->sign;
     815                 :    1004890 :   REAL_VALUE_TYPE t, *rr;
     816                 :    1004890 :   bool inexact;
     817                 :            : 
     818                 :    1004890 :   switch (CLASS2 (a->cl, b->cl))
     819                 :            :     {
     820                 :        333 :     case CLASS2 (rvc_zero, rvc_zero):
     821                 :            :       /* 0 / 0 = NaN.  */
     822                 :        333 :     case CLASS2 (rvc_inf, rvc_inf):
     823                 :            :       /* Inf / Inf = NaN.  */
     824                 :        333 :       get_canonical_qnan (r, sign);
     825                 :        333 :       return false;
     826                 :            : 
     827                 :       3046 :     case CLASS2 (rvc_zero, rvc_normal):
     828                 :       3046 :     case CLASS2 (rvc_zero, rvc_inf):
     829                 :            :       /* 0 / ANY = 0.  */
     830                 :       3046 :     case CLASS2 (rvc_normal, rvc_inf):
     831                 :            :       /* R / Inf = 0.  */
     832                 :       3046 :       get_zero (r, sign);
     833                 :       3046 :       return false;
     834                 :            : 
     835                 :        519 :     case CLASS2 (rvc_normal, rvc_zero):
     836                 :            :       /* R / 0 = Inf.  */
     837                 :        519 :     case CLASS2 (rvc_inf, rvc_zero):
     838                 :            :       /* Inf / 0 = Inf.  */
     839                 :        519 :       get_inf (r, sign);
     840                 :        519 :       return false;
     841                 :            : 
     842                 :          0 :     case CLASS2 (rvc_zero, rvc_nan):
     843                 :          0 :     case CLASS2 (rvc_normal, rvc_nan):
     844                 :          0 :     case CLASS2 (rvc_inf, rvc_nan):
     845                 :          0 :     case CLASS2 (rvc_nan, rvc_nan):
     846                 :            :       /* ANY / NaN = NaN.  */
     847                 :          0 :       *r = *b;
     848                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     849                 :            :          responsibility to avoid the operation if flag_signaling_nans
     850                 :            :          is on.  */
     851                 :          0 :       r->signalling = 0;
     852                 :          0 :       r->sign = sign;
     853                 :          0 :       return false;
     854                 :            : 
     855                 :          0 :     case CLASS2 (rvc_nan, rvc_zero):
     856                 :          0 :     case CLASS2 (rvc_nan, rvc_normal):
     857                 :          0 :     case CLASS2 (rvc_nan, rvc_inf):
     858                 :            :       /* NaN / ANY = NaN.  */
     859                 :          0 :       *r = *a;
     860                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     861                 :            :          responsibility to avoid the operation if flag_signaling_nans
     862                 :            :          is on.  */
     863                 :          0 :       r->signalling = 0;
     864                 :          0 :       r->sign = sign;
     865                 :          0 :       return false;
     866                 :            : 
     867                 :          0 :     case CLASS2 (rvc_inf, rvc_normal):
     868                 :            :       /* Inf / R = Inf.  */
     869                 :          0 :       get_inf (r, sign);
     870                 :          0 :       return false;
     871                 :            : 
     872                 :    1000990 :     case CLASS2 (rvc_normal, rvc_normal):
     873                 :    1000990 :       break;
     874                 :            : 
     875                 :            :     default:
     876                 :            :       gcc_unreachable ();
     877                 :            :     }
     878                 :            : 
     879                 :    1000990 :   if (r == a || r == b)
     880                 :            :     rr = &t;
     881                 :            :   else
     882                 :     689460 :     rr = r;
     883                 :            : 
     884                 :            :   /* Make sure all fields in the result are initialized.  */
     885                 :    1000990 :   get_zero (rr, 0);
     886                 :    1000990 :   rr->cl = rvc_normal;
     887                 :    1000990 :   rr->sign = sign;
     888                 :            : 
     889                 :    1000990 :   exp = REAL_EXP (a) - REAL_EXP (b) + 1;
     890                 :    1000990 :   if (exp > MAX_EXP)
     891                 :            :     {
     892                 :          0 :       get_inf (r, sign);
     893                 :          0 :       return true;
     894                 :            :     }
     895                 :    1000990 :   if (exp < -MAX_EXP)
     896                 :            :     {
     897                 :          0 :       get_zero (r, sign);
     898                 :          0 :       return true;
     899                 :            :     }
     900                 :    1000990 :   SET_REAL_EXP (rr, exp);
     901                 :            : 
     902                 :    1000990 :   inexact = div_significands (rr, a, b);
     903                 :            : 
     904                 :            :   /* Re-normalize the result.  */
     905                 :    1000990 :   normalize (rr);
     906                 :    1000990 :   rr->sig[0] |= inexact;
     907                 :            : 
     908                 :    1000990 :   if (rr != r)
     909                 :     311534 :     *r = t;
     910                 :            : 
     911                 :            :   return inexact;
     912                 :            : }
     913                 :            : 
     914                 :            : /* Return a tri-state comparison of A vs B.  Return NAN_RESULT if
     915                 :            :    one of the two operands is a NaN.  */
     916                 :            : 
     917                 :            : static int
     918                 :   11467700 : do_compare (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b,
     919                 :            :             int nan_result)
     920                 :            : {
     921                 :   11467700 :   int ret;
     922                 :            : 
     923                 :   11467700 :   switch (CLASS2 (a->cl, b->cl))
     924                 :            :     {
     925                 :            :     case CLASS2 (rvc_zero, rvc_zero):
     926                 :            :       /* Sign of zero doesn't matter for compares.  */
     927                 :            :       return 0;
     928                 :            : 
     929                 :    4804980 :     case CLASS2 (rvc_normal, rvc_zero):
     930                 :            :       /* Decimal float zero is special and uses rvc_normal, not rvc_zero.  */
     931                 :    4804980 :       if (a->decimal)
     932                 :      42140 :         return decimal_do_compare (a, b, nan_result);
     933                 :            :       /* Fall through.  */
     934                 :    4809510 :     case CLASS2 (rvc_inf, rvc_zero):
     935                 :    4809510 :     case CLASS2 (rvc_inf, rvc_normal):
     936                 :    4809510 :       return (a->sign ? -1 : 1);
     937                 :            : 
     938                 :       3051 :     case CLASS2 (rvc_inf, rvc_inf):
     939                 :       3051 :       return -a->sign - -b->sign;
     940                 :            : 
     941                 :     327149 :     case CLASS2 (rvc_zero, rvc_normal):
     942                 :            :       /* Decimal float zero is special and uses rvc_normal, not rvc_zero.  */
     943                 :     327149 :       if (b->decimal)
     944                 :       3111 :         return decimal_do_compare (a, b, nan_result);
     945                 :            :       /* Fall through.  */
     946                 :     330535 :     case CLASS2 (rvc_zero, rvc_inf):
     947                 :     330535 :     case CLASS2 (rvc_normal, rvc_inf):
     948                 :     330535 :       return (b->sign ? 1 : -1);
     949                 :            : 
     950                 :       8750 :     case CLASS2 (rvc_zero, rvc_nan):
     951                 :       8750 :     case CLASS2 (rvc_normal, rvc_nan):
     952                 :       8750 :     case CLASS2 (rvc_inf, rvc_nan):
     953                 :       8750 :     case CLASS2 (rvc_nan, rvc_nan):
     954                 :       8750 :     case CLASS2 (rvc_nan, rvc_zero):
     955                 :       8750 :     case CLASS2 (rvc_nan, rvc_normal):
     956                 :       8750 :     case CLASS2 (rvc_nan, rvc_inf):
     957                 :       8750 :       return nan_result;
     958                 :            : 
     959                 :    4189330 :     case CLASS2 (rvc_normal, rvc_normal):
     960                 :    4189330 :       break;
     961                 :            : 
     962                 :            :     default:
     963                 :            :       gcc_unreachable ();
     964                 :            :     }
     965                 :            : 
     966                 :    4189330 :   if (a->decimal || b->decimal)
     967                 :     146126 :     return decimal_do_compare (a, b, nan_result);
     968                 :            : 
     969                 :    4043210 :   if (a->sign != b->sign)
     970                 :    1123560 :     return -a->sign - -b->sign;
     971                 :            : 
     972                 :    2919640 :   if (REAL_EXP (a) > REAL_EXP (b))
     973                 :            :     ret = 1;
     974                 :    1568980 :   else if (REAL_EXP (a) < REAL_EXP (b))
     975                 :            :     ret = -1;
     976                 :            :   else
     977                 :    1093530 :     ret = cmp_significands (a, b);
     978                 :            : 
     979                 :    2919640 :   return (a->sign ? -ret : ret);
     980                 :            : }
     981                 :            : 
     982                 :            : /* Return A truncated to an integral value toward zero.  */
     983                 :            : 
     984                 :            : static void
     985                 :     462351 : do_fix_trunc (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *a)
     986                 :            : {
     987                 :     462351 :   *r = *a;
     988                 :            : 
     989                 :     462351 :   switch (r->cl)
     990                 :            :     {
     991                 :       3567 :     case rvc_zero:
     992                 :       3567 :     case rvc_inf:
     993                 :       3567 :     case rvc_nan:
     994                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
     995                 :            :          responsibility to avoid the operation if flag_signaling_nans
     996                 :            :          is on.  */
     997                 :       3567 :       r->signalling = 0;
     998                 :       3567 :       break;
     999                 :            : 
    1000                 :     458784 :     case rvc_normal:
    1001                 :     458784 :       if (r->decimal)
    1002                 :            :         {
    1003                 :        324 :           decimal_do_fix_trunc (r, a);
    1004                 :        324 :           return;
    1005                 :            :         }
    1006                 :     458460 :       if (REAL_EXP (r) <= 0)
    1007                 :      27096 :         get_zero (r, r->sign);
    1008                 :     431364 :       else if (REAL_EXP (r) < SIGNIFICAND_BITS)
    1009                 :     431334 :         clear_significand_below (r, SIGNIFICAND_BITS - REAL_EXP (r));
    1010                 :            :       break;
    1011                 :            : 
    1012                 :          0 :     default:
    1013                 :          0 :       gcc_unreachable ();
    1014                 :            :     }
    1015                 :            : }
    1016                 :            : 
    1017                 :            : /* Perform the binary or unary operation described by CODE.
    1018                 :            :    For a unary operation, leave OP1 NULL.  This function returns
    1019                 :            :    true if the result may be inexact due to loss of precision.  */
    1020                 :            : 
    1021                 :            : bool
    1022                 :    1986360 : real_arithmetic (REAL_VALUE_TYPE *r, int icode, const REAL_VALUE_TYPE *op0,
    1023                 :            :                  const REAL_VALUE_TYPE *op1)
    1024                 :            : {
    1025                 :    1986360 :   enum tree_code code = (enum tree_code) icode;
    1026                 :            : 
    1027                 :    1986360 :   if (op0->decimal || (op1 && op1->decimal))
    1028                 :     263476 :     return decimal_real_arithmetic (r, code, op0, op1);
    1029                 :            : 
    1030                 :    1722880 :   switch (code)
    1031                 :            :     {
    1032                 :     283463 :     case PLUS_EXPR:
    1033                 :            :       /* Clear any padding areas in *r if it isn't equal to one of the
    1034                 :            :          operands so that we can later do bitwise comparisons later on.  */
    1035                 :     283463 :       if (r != op0 && r != op1)
    1036                 :     283463 :         memset (r, '\0', sizeof (*r));
    1037                 :     283463 :       return do_add (r, op0, op1, 0);
    1038                 :            : 
    1039                 :     198708 :     case MINUS_EXPR:
    1040                 :     198708 :       if (r != op0 && r != op1)
    1041                 :     195881 :         memset (r, '\0', sizeof (*r));
    1042                 :     198708 :       return do_add (r, op0, op1, 1);
    1043                 :            : 
    1044                 :     673649 :     case MULT_EXPR:
    1045                 :     673649 :       if (r != op0 && r != op1)
    1046                 :     673586 :         memset (r, '\0', sizeof (*r));
    1047                 :     673649 :       return do_multiply (r, op0, op1);
    1048                 :            : 
    1049                 :     120044 :     case RDIV_EXPR:
    1050                 :     120044 :       if (r != op0 && r != op1)
    1051                 :     120044 :         memset (r, '\0', sizeof (*r));
    1052                 :     120044 :       return do_divide (r, op0, op1);
    1053                 :            : 
    1054                 :        108 :     case MIN_EXPR:
    1055                 :        108 :       if (op1->cl == rvc_nan)
    1056                 :            :       {
    1057                 :          0 :         *r = *op1;
    1058                 :            :         /* Make resulting NaN value to be qNaN. The caller has the
    1059                 :            :            responsibility to avoid the operation if flag_signaling_nans
    1060                 :            :            is on.  */
    1061                 :          0 :         r->signalling = 0;
    1062                 :            :       }
    1063                 :        108 :       else if (do_compare (op0, op1, -1) < 0)
    1064                 :         44 :         *r = *op0;
    1065                 :            :       else
    1066                 :         64 :         *r = *op1;
    1067                 :            :       break;
    1068                 :            : 
    1069                 :        194 :     case MAX_EXPR:
    1070                 :        194 :       if (op1->cl == rvc_nan)
    1071                 :            :       {
    1072                 :          0 :         *r = *op1;
    1073                 :            :         /* Make resulting NaN value to be qNaN. The caller has the
    1074                 :            :            responsibility to avoid the operation if flag_signaling_nans
    1075                 :            :            is on.  */
    1076                 :          0 :         r->signalling = 0;
    1077                 :            :       }
    1078                 :        194 :       else if (do_compare (op0, op1, 1) < 0)
    1079                 :        105 :         *r = *op1;
    1080                 :            :       else
    1081                 :         89 :         *r = *op0;
    1082                 :            :       break;
    1083                 :            : 
    1084                 :     446315 :     case NEGATE_EXPR:
    1085                 :     446315 :       *r = *op0;
    1086                 :     446315 :       r->sign ^= 1;
    1087                 :     446315 :       break;
    1088                 :            : 
    1089                 :        403 :     case ABS_EXPR:
    1090                 :        403 :       *r = *op0;
    1091                 :        403 :       r->sign = 0;
    1092                 :        403 :       break;
    1093                 :            : 
    1094                 :          0 :     case FIX_TRUNC_EXPR:
    1095                 :          0 :       do_fix_trunc (r, op0);
    1096                 :          0 :       break;
    1097                 :            : 
    1098                 :          0 :     default:
    1099                 :          0 :       gcc_unreachable ();
    1100                 :            :     }
    1101                 :            :   return false;
    1102                 :            : }
    1103                 :            : 
    1104                 :            : REAL_VALUE_TYPE
    1105                 :     452588 : real_value_negate (const REAL_VALUE_TYPE *op0)
    1106                 :            : {
    1107                 :     452588 :   REAL_VALUE_TYPE r;
    1108                 :     452588 :   real_arithmetic (&r, NEGATE_EXPR, op0, NULL);
    1109                 :     452588 :   return r;
    1110                 :            : }
    1111                 :            : 
    1112                 :            : REAL_VALUE_TYPE
    1113                 :        403 : real_value_abs (const REAL_VALUE_TYPE *op0)
    1114                 :            : {
    1115                 :        403 :   REAL_VALUE_TYPE r;
    1116                 :        403 :   real_arithmetic (&r, ABS_EXPR, op0, NULL);
    1117                 :        403 :   return r;
    1118                 :            : }
    1119                 :            : 
    1120                 :            : /* Return whether OP0 == OP1.  */
    1121                 :            : 
    1122                 :            : bool
    1123                 :    9439440 : real_equal (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
    1124                 :            : {
    1125                 :    9439440 :   return do_compare (op0, op1, -1) == 0;
    1126                 :            : }
    1127                 :            : 
    1128                 :            : /* Return whether OP0 < OP1.  */
    1129                 :            : 
    1130                 :            : bool
    1131                 :      95147 : real_less (const REAL_VALUE_TYPE *op0, const REAL_VALUE_TYPE *op1)
    1132                 :            : {
    1133                 :      95147 :   return do_compare (op0, op1, 1) < 0;
    1134                 :            : }
    1135                 :            : 
    1136                 :            : bool
    1137                 :     715832 : real_compare (int icode, const REAL_VALUE_TYPE *op0,
    1138                 :            :               const REAL_VALUE_TYPE *op1)
    1139                 :            : {
    1140                 :     715832 :   enum tree_code code = (enum tree_code) icode;
    1141                 :            : 
    1142                 :     715832 :   switch (code)
    1143                 :            :     {
    1144                 :      53487 :     case LT_EXPR:
    1145                 :      53487 :       return real_less (op0, op1);
    1146                 :      17940 :     case LE_EXPR:
    1147                 :      17940 :       return do_compare (op0, op1, 1) <= 0;
    1148                 :      43722 :     case GT_EXPR:
    1149                 :      43722 :       return do_compare (op0, op1, -1) > 0;
    1150                 :      17981 :     case GE_EXPR:
    1151                 :      17981 :       return do_compare (op0, op1, -1) >= 0;
    1152                 :      25007 :     case EQ_EXPR:
    1153                 :      25007 :       return real_equal (op0, op1);
    1154                 :     524897 :     case NE_EXPR:
    1155                 :     524897 :       return do_compare (op0, op1, -1) != 0;
    1156                 :      19937 :     case UNORDERED_EXPR:
    1157                 :      19937 :       return op0->cl == rvc_nan || op1->cl == rvc_nan;
    1158                 :        759 :     case ORDERED_EXPR:
    1159                 :        759 :       return op0->cl != rvc_nan && op1->cl != rvc_nan;
    1160                 :        184 :     case UNLT_EXPR:
    1161                 :        184 :       return do_compare (op0, op1, -1) < 0;
    1162                 :       5622 :     case UNLE_EXPR:
    1163                 :       5622 :       return do_compare (op0, op1, -1) <= 0;
    1164                 :        792 :     case UNGT_EXPR:
    1165                 :        792 :       return do_compare (op0, op1, 1) > 0;
    1166                 :       5424 :     case UNGE_EXPR:
    1167                 :       5424 :       return do_compare (op0, op1, 1) >= 0;
    1168                 :         80 :     case UNEQ_EXPR:
    1169                 :         80 :       return do_compare (op0, op1, 0) == 0;
    1170                 :          0 :     case LTGT_EXPR:
    1171                 :          0 :       return do_compare (op0, op1, 0) != 0;
    1172                 :            : 
    1173                 :          0 :     default:
    1174                 :          0 :       gcc_unreachable ();
    1175                 :            :     }
    1176                 :            : }
    1177                 :            : 
    1178                 :            : /* Return floor log2(R).  */
    1179                 :            : 
    1180                 :            : int
    1181                 :          0 : real_exponent (const REAL_VALUE_TYPE *r)
    1182                 :            : {
    1183                 :          0 :   switch (r->cl)
    1184                 :            :     {
    1185                 :            :     case rvc_zero:
    1186                 :            :       return 0;
    1187                 :          0 :     case rvc_inf:
    1188                 :          0 :     case rvc_nan:
    1189                 :          0 :       return (unsigned int)-1 >> 1;
    1190                 :          0 :     case rvc_normal:
    1191                 :          0 :       return REAL_EXP (r);
    1192                 :          0 :     default:
    1193                 :          0 :       gcc_unreachable ();
    1194                 :            :     }
    1195                 :            : }
    1196                 :            : 
    1197                 :            : /* R = OP0 * 2**EXP.  */
    1198                 :            : 
    1199                 :            : void
    1200                 :      10025 : real_ldexp (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *op0, int exp)
    1201                 :            : {
    1202                 :      10025 :   *r = *op0;
    1203                 :      10025 :   switch (r->cl)
    1204                 :            :     {
    1205                 :         52 :     case rvc_zero:
    1206                 :         52 :     case rvc_inf:
    1207                 :         52 :     case rvc_nan:
    1208                 :            :       /* Make resulting NaN value to be qNaN. The caller has the
    1209                 :            :          responsibility to avoid the operation if flag_signaling_nans
    1210                 :            :          is on.  */
    1211                 :         52 :       r->signalling = 0;
    1212                 :         52 :       break;
    1213                 :            : 
    1214                 :       9973 :     case rvc_normal:
    1215                 :       9973 :       exp += REAL_EXP (op0);
    1216                 :       9973 :       if (exp > MAX_EXP)
    1217                 :          0 :         get_inf (r, r->sign);
    1218                 :       9973 :       else if (exp < -MAX_EXP)
    1219                 :          0 :         get_zero (r, r->sign);
    1220                 :            :       else
    1221                 :       9973 :         SET_REAL_EXP (r, exp);
    1222                 :            :       break;
    1223                 :            : 
    1224                 :          0 :     default:
    1225                 :          0 :       gcc_unreachable ();
    1226                 :            :     }
    1227                 :      10025 : }
    1228                 :            : 
    1229                 :            : /* Determine whether a floating-point value X is infinite.  */
    1230                 :            : 
    1231                 :            : bool
    1232                 :   10469700 : real_isinf (const REAL_VALUE_TYPE *r)
    1233                 :            : {
    1234                 :   10469700 :   return (r->cl == rvc_inf);
    1235                 :            : }
    1236                 :            : 
    1237                 :            : /* Determine whether a floating-point value X is a NaN.  */
    1238                 :            : 
    1239                 :            : bool
    1240                 :   12498500 : real_isnan (const REAL_VALUE_TYPE *r)
    1241                 :            : {
    1242                 :   12498500 :   return (r->cl == rvc_nan);
    1243                 :            : }
    1244                 :            : 
    1245                 :            : /* Determine whether a floating-point value X is a signaling NaN.  */ 
    1246                 :      23359 : bool real_issignaling_nan (const REAL_VALUE_TYPE *r)
    1247                 :            : {
    1248                 :      23359 :   return real_isnan (r) && r->signalling;
    1249                 :            : }
    1250                 :            : 
    1251                 :            : /* Determine whether a floating-point value X is finite.  */
    1252                 :            : 
    1253                 :            : bool
    1254                 :     389357 : real_isfinite (const REAL_VALUE_TYPE *r)
    1255                 :            : {
    1256                 :     389357 :   return (r->cl != rvc_nan) && (r->cl != rvc_inf);
    1257                 :            : }
    1258                 :            : 
    1259                 :            : /* Determine whether a floating-point value X is negative.  */
    1260                 :            : 
    1261                 :            : bool
    1262                 :    2008590 : real_isneg (const REAL_VALUE_TYPE *r)
    1263                 :            : {
    1264                 :    2008590 :   return r->sign;
    1265                 :            : }
    1266                 :            : 
    1267                 :            : /* Determine whether a floating-point value X is minus zero.  */
    1268                 :            : 
    1269                 :            : bool
    1270                 :    7206780 : real_isnegzero (const REAL_VALUE_TYPE *r)
    1271                 :            : {
    1272                 :    7206780 :   return r->sign && r->cl == rvc_zero;
    1273                 :            : }
    1274                 :            : 
    1275                 :            : /* Compare two floating-point objects for bitwise identity.  */
    1276                 :            : 
    1277                 :            : bool
    1278                 :   10350100 : real_identical (const REAL_VALUE_TYPE *a, const REAL_VALUE_TYPE *b)
    1279                 :            : {
    1280                 :   10350100 :   int i;
    1281                 :            : 
    1282                 :   10350100 :   if (a->cl != b->cl)
    1283                 :            :     return false;
    1284                 :    9331820 :   if (a->sign != b->sign)
    1285                 :            :     return false;
    1286                 :            : 
    1287                 :    6457000 :   switch (a->cl)
    1288                 :            :     {
    1289                 :            :     case rvc_zero:
    1290                 :            :     case rvc_inf:
    1291                 :            :       return true;
    1292                 :            : 
    1293                 :    5493030 :     case rvc_normal:
    1294                 :    5493030 :       if (a->decimal != b->decimal)
    1295                 :            :         return false;
    1296                 :    5491160 :       if (REAL_EXP (a) != REAL_EXP (b))
    1297                 :            :         return false;
    1298                 :            :       break;
    1299                 :            : 
    1300                 :      56862 :     case rvc_nan:
    1301                 :      56862 :       if (a->signalling != b->signalling)
    1302                 :            :         return false;
    1303                 :            :       /* The significand is ignored for canonical NaNs.  */
    1304                 :      56823 :       if (a->canonical || b->canonical)
    1305                 :      37981 :         return a->canonical == b->canonical;
    1306                 :            :       break;
    1307                 :            : 
    1308                 :          0 :     default:
    1309                 :          0 :       gcc_unreachable ();
    1310                 :            :     }
    1311                 :            : 
    1312                 :   10658900 :   for (i = 0; i < SIGSZ; ++i)
    1313                 :    8371030 :     if (a->sig[i] != b->sig[i])
    1314                 :            :       return false;
    1315                 :            : 
    1316                 :            :   return true;
    1317                 :            : }
    1318                 :            : 
    1319                 :            : /* Try to change R into its exact multiplicative inverse in format FMT.
    1320                 :            :    Return true if successful.  */
    1321                 :            : 
    1322                 :            : bool
    1323                 :     123876 : exact_real_inverse (format_helper fmt, REAL_VALUE_TYPE *r)
    1324                 :            : {
    1325                 :     123876 :   const REAL_VALUE_TYPE *one = real_digit (1);
    1326                 :     123876 :   REAL_VALUE_TYPE u;
    1327                 :     123876 :   int i;
    1328                 :            : 
    1329                 :     123876 :   if (r->cl != rvc_normal)
    1330                 :            :     return false;
    1331                 :            : 
    1332                 :            :   /* Check for a power of two: all significand bits zero except the MSB.  */
    1333                 :     339718 :   for (i = 0; i < SIGSZ-1; ++i)
    1334                 :     226918 :     if (r->sig[i] != 0)
    1335                 :            :       return false;
    1336                 :     112800 :   if (r->sig[SIGSZ-1] != SIG_MSB)
    1337                 :            :     return false;
    1338                 :            : 
    1339                 :            :   /* Find the inverse and truncate to the required format.  */
    1340                 :      13334 :   do_divide (&u, one, r);
    1341                 :      13334 :   real_convert (&u, fmt, &u);
    1342                 :            : 
    1343                 :            :   /* The rounding may have overflowed.  */
    1344                 :      13334 :   if (u.cl != rvc_normal)
    1345                 :            :     return false;
    1346                 :      40002 :   for (i = 0; i < SIGSZ-1; ++i)
    1347                 :      26668 :     if (u.sig[i] != 0)
    1348                 :            :       return false;
    1349                 :      13334 :   if (u.sig[SIGSZ-1] != SIG_MSB)
    1350                 :            :     return false;
    1351                 :            : 
    1352                 :      13334 :   *r = u;
    1353                 :      13334 :   return true;
    1354                 :            : }
    1355                 :            : 
    1356                 :            : /* Return true if arithmetic on values in IMODE that were promoted
    1357                 :            :    from values in TMODE is equivalent to direct arithmetic on values
    1358                 :            :    in TMODE.  */
    1359                 :            : 
    1360                 :            : bool
    1361                 :      82655 : real_can_shorten_arithmetic (machine_mode imode, machine_mode tmode)
    1362                 :            : {
    1363                 :      82655 :   const struct real_format *tfmt, *ifmt;
    1364                 :      82655 :   tfmt = REAL_MODE_FORMAT (tmode);
    1365                 :      82655 :   ifmt = REAL_MODE_FORMAT (imode);
    1366                 :            :   /* These conditions are conservative rather than trying to catch the
    1367                 :            :      exact boundary conditions; the main case to allow is IEEE float
    1368                 :            :      and double.  */
    1369                 :      82655 :   return (ifmt->b == tfmt->b
    1370                 :      82655 :           && ifmt->p > 2 * tfmt->p
    1371                 :       4432 :           && ifmt->emin < 2 * tfmt->emin - tfmt->p - 2
    1372                 :       4432 :           && ifmt->emin < tfmt->emin - tfmt->emax - tfmt->p - 2
    1373                 :       4432 :           && ifmt->emax > 2 * tfmt->emax + 2
    1374                 :       4432 :           && ifmt->emax > tfmt->emax - tfmt->emin + tfmt->p + 2
    1375                 :            :           && ifmt->round_towards_zero == tfmt->round_towards_zero
    1376                 :       4432 :           && (ifmt->has_sign_dependent_rounding
    1377                 :            :               == tfmt->has_sign_dependent_rounding)
    1378                 :       4432 :           && ifmt->has_nans >= tfmt->has_nans
    1379                 :       4432 :           && ifmt->has_inf >= tfmt->has_inf
    1380                 :       4432 :           && ifmt->has_signed_zero >= tfmt->has_signed_zero
    1381                 :      31024 :           && !MODE_COMPOSITE_P (tmode)
    1382                 :     113679 :           && !MODE_COMPOSITE_P (imode));
    1383                 :            : }
    1384                 :            : 
    1385                 :            : /* Render R as an integer.  */
    1386                 :            : 
    1387                 :            : HOST_WIDE_INT
    1388                 :      11377 : real_to_integer (const REAL_VALUE_TYPE *r)
    1389                 :            : {
    1390                 :      11377 :   unsigned HOST_WIDE_INT i;
    1391                 :            : 
    1392                 :      11377 :   switch (r->cl)
    1393                 :            :     {
    1394                 :            :     case rvc_zero:
    1395                 :      11377 :     underflow:
    1396                 :            :       return 0;
    1397                 :            : 
    1398                 :       2689 :     case rvc_inf:
    1399                 :       2689 :     case rvc_nan:
    1400                 :       2689 :     overflow:
    1401                 :       2689 :       i = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
    1402                 :       2689 :       if (!r->sign)
    1403                 :       1861 :         i--;
    1404                 :       2689 :       return i;
    1405                 :            : 
    1406                 :       8888 :     case rvc_normal:
    1407                 :       8888 :       if (r->decimal)
    1408                 :          0 :         return decimal_real_to_integer (r);
    1409                 :            : 
    1410                 :       8888 :       if (REAL_EXP (r) <= 0)
    1411                 :        124 :         goto underflow;
    1412                 :            :       /* Only force overflow for unsigned overflow.  Signed overflow is
    1413                 :            :          undefined, so it doesn't matter what we return, and some callers
    1414                 :            :          expect to be able to use this routine for both signed and
    1415                 :            :          unsigned conversions.  */
    1416                 :       8764 :       if (REAL_EXP (r) > HOST_BITS_PER_WIDE_INT)
    1417                 :        205 :         goto overflow;
    1418                 :            : 
    1419                 :       8559 :       if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
    1420                 :       8559 :         i = r->sig[SIGSZ-1];
    1421                 :            :       else
    1422                 :            :         {
    1423                 :            :           gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
    1424                 :            :           i = r->sig[SIGSZ-1];
    1425                 :            :           i = i << (HOST_BITS_PER_LONG - 1) << 1;
    1426                 :            :           i |= r->sig[SIGSZ-2];
    1427                 :            :         }
    1428                 :            : 
    1429                 :       8559 :       i >>= HOST_BITS_PER_WIDE_INT - REAL_EXP (r);
    1430                 :            : 
    1431                 :       8559 :       if (r->sign)
    1432                 :       4182 :         i = -i;
    1433                 :       8559 :       return i;
    1434                 :            : 
    1435                 :          0 :     default:
    1436                 :          0 :       gcc_unreachable ();
    1437                 :            :     }
    1438                 :            : }
    1439                 :            : 
    1440                 :            : /* Likewise, but producing a wide-int of PRECISION.  If the value cannot
    1441                 :            :    be represented in precision, *FAIL is set to TRUE.  */
    1442                 :            : 
    1443                 :            : wide_int
    1444                 :      23746 : real_to_integer (const REAL_VALUE_TYPE *r, bool *fail, int precision)
    1445                 :            : {
    1446                 :      23746 :   HOST_WIDE_INT val[2 * WIDE_INT_MAX_ELTS];
    1447                 :      23746 :   int exp;
    1448                 :      23746 :   int words, w;
    1449                 :      23746 :   wide_int result;
    1450                 :            : 
    1451                 :      23746 :   switch (r->cl)
    1452                 :            :     {
    1453                 :       3874 :     case rvc_zero:
    1454                 :       3874 :     underflow:
    1455                 :       3874 :       return wi::zero (precision);
    1456                 :            : 
    1457                 :        114 :     case rvc_inf:
    1458                 :        114 :     case rvc_nan:
    1459                 :        114 :     overflow:
    1460                 :        114 :       *fail = true;
    1461                 :            : 
    1462                 :        114 :       if (r->sign)
    1463                 :         36 :         return wi::set_bit_in_zero (precision - 1, precision);
    1464                 :            :       else
    1465                 :         78 :         return ~wi::set_bit_in_zero (precision - 1, precision);
    1466                 :            : 
    1467                 :      19817 :     case rvc_normal:
    1468                 :      19817 :       if (r->decimal)
    1469                 :        238 :         return decimal_real_to_integer (r, fail, precision);
    1470                 :            : 
    1471                 :      19579 :       exp = REAL_EXP (r);
    1472                 :      19579 :       if (exp <= 0)
    1473                 :          0 :         goto underflow;
    1474                 :            :       /* Only force overflow for unsigned overflow.  Signed overflow is
    1475                 :            :          undefined, so it doesn't matter what we return, and some callers
    1476                 :            :          expect to be able to use this routine for both signed and
    1477                 :            :          unsigned conversions.  */
    1478                 :      19579 :       if (exp > precision)
    1479                 :         59 :         goto overflow;
    1480                 :            : 
    1481                 :            :       /* Put the significand into a wide_int that has precision W, which
    1482                 :            :          is the smallest HWI-multiple that has at least PRECISION bits.
    1483                 :            :          This ensures that the top bit of the significand is in the
    1484                 :            :          top bit of the wide_int.  */
    1485                 :      19520 :       words = (precision + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT;
    1486                 :      19520 :       w = words * HOST_BITS_PER_WIDE_INT;
    1487                 :            : 
    1488                 :            : #if (HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG)
    1489                 :      39040 :       for (int i = 0; i < words; i++)
    1490                 :            :         {
    1491                 :      19520 :           int j = SIGSZ - words + i;
    1492                 :      19520 :           val[i] = (j < 0) ? 0 : r->sig[j];
    1493                 :            :         }
    1494                 :            : #else
    1495                 :            :       gcc_assert (HOST_BITS_PER_WIDE_INT == 2 * HOST_BITS_PER_LONG);
    1496                 :            :       for (int i = 0; i < words; i++)
    1497                 :            :         {
    1498                 :            :           int j = SIGSZ - (words * 2) + (i * 2);
    1499                 :            :           if (j < 0)
    1500                 :            :             val[i] = 0;
    1501                 :            :           else
    1502                 :            :             val[i] = r->sig[j];
    1503                 :            :           j += 1;
    1504                 :            :           if (j >= 0)
    1505                 :            :             val[i] |= (unsigned HOST_WIDE_INT) r->sig[j] << HOST_BITS_PER_LONG;
    1506                 :            :         }
    1507                 :            : #endif
    1508                 :            :       /* Shift the value into place and truncate to the desired precision.  */
    1509                 :      19520 :       result = wide_int::from_array (val, words, w);
    1510                 :      19520 :       result = wi::lrshift (result, w - exp);
    1511                 :      19520 :       result = wide_int::from (result, precision, UNSIGNED);
    1512                 :            : 
    1513                 :      19520 :       if (r->sign)
    1514                 :       1589 :         return -result;
    1515                 :            :       else
    1516                 :      17931 :         return result;
    1517                 :            : 
    1518                 :          0 :     default:
    1519                 :          0 :       gcc_unreachable ();
    1520                 :            :     }
    1521                 :            : }
    1522                 :            : 
    1523                 :            : /* A subroutine of real_to_decimal.  Compute the quotient and remainder
    1524                 :            :    of NUM / DEN.  Return the quotient and place the remainder in NUM.
    1525                 :            :    It is expected that NUM / DEN are close enough that the quotient is
    1526                 :            :    small.  */
    1527                 :            : 
    1528                 :            : static unsigned long
    1529                 :    8764490 : rtd_divmod (REAL_VALUE_TYPE *num, REAL_VALUE_TYPE *den)
    1530                 :            : {
    1531                 :    8764490 :   unsigned long q, msb;
    1532                 :    8764490 :   int expn = REAL_EXP (num), expd = REAL_EXP (den);
    1533                 :            : 
    1534                 :    8764490 :   if (expn < expd)
    1535                 :            :     return 0;
    1536                 :            : 
    1537                 :    5001700 :   q = msb = 0;
    1538                 :    5001700 :   goto start;
    1539                 :   14516400 :   do
    1540                 :            :     {
    1541                 :   14516400 :       msb = num->sig[SIGSZ-1] & SIG_MSB;
    1542                 :   14516400 :       q <<= 1;
    1543                 :   14516400 :       lshift_significand_1 (num, num);
    1544                 :   19518100 :     start:
    1545                 :   36105900 :       if (msb || cmp_significands (num, den) >= 0)
    1546                 :            :         {
    1547                 :   31566500 :           sub_significands (num, num, den, 0);
    1548                 :    7891630 :           q |= 1;
    1549                 :            :         }
    1550                 :            :     }
    1551                 :   19518100 :   while (--expn >= expd);
    1552                 :            : 
    1553                 :    5001700 :   SET_REAL_EXP (num, expd);
    1554                 :    5001700 :   normalize (num);
    1555                 :            : 
    1556                 :    5001700 :   return q;
    1557                 :            : }
    1558                 :            : 
    1559                 :            : /* Render R as a decimal floating point constant.  Emit DIGITS significant
    1560                 :            :    digits in the result, bounded by BUF_SIZE.  If DIGITS is 0, choose the
    1561                 :            :    maximum for the representation.  If CROP_TRAILING_ZEROS, strip trailing
    1562                 :            :    zeros.  If MODE is VOIDmode, round to nearest value.  Otherwise, round
    1563                 :            :    to a string that, when parsed back in mode MODE, yields the same value.  */
    1564                 :            : 
    1565                 :            : #define M_LOG10_2       0.30102999566398119521
    1566                 :            : 
    1567                 :            : void
    1568                 :     265098 : real_to_decimal_for_mode (char *str, const REAL_VALUE_TYPE *r_orig,
    1569                 :            :                           size_t buf_size, size_t digits,
    1570                 :            :                           int crop_trailing_zeros, machine_mode mode)
    1571                 :            : {
    1572                 :     265098 :   const struct real_format *fmt = NULL;
    1573                 :     265098 :   const REAL_VALUE_TYPE *one, *ten;
    1574                 :     265098 :   REAL_VALUE_TYPE r, pten, u, v;
    1575                 :     265098 :   int dec_exp, cmp_one, digit;
    1576                 :     265098 :   size_t max_digits;
    1577                 :     265098 :   char *p, *first, *last;
    1578                 :     265098 :   bool sign;
    1579                 :     265098 :   bool round_up;
    1580                 :            : 
    1581                 :     265098 :   if (mode != VOIDmode)
    1582                 :            :    {
    1583                 :     146928 :      fmt = REAL_MODE_FORMAT (mode);
    1584                 :     146928 :      gcc_assert (fmt);
    1585                 :            :    }
    1586                 :            : 
    1587                 :     265098 :   r = *r_orig;
    1588                 :     265098 :   switch (r.cl)
    1589                 :            :     {
    1590                 :      62523 :     case rvc_zero:
    1591                 :      62523 :       strcpy (str, (r.sign ? "-0.0" : "0.0"));
    1592                 :      62987 :       return;
    1593                 :     202157 :     case rvc_normal:
    1594                 :     202157 :       break;
    1595                 :        246 :     case rvc_inf:
    1596                 :        246 :       strcpy (str, (r.sign ? "-Inf" : "+Inf"));
    1597                 :        246 :       return;
    1598                 :        172 :     case rvc_nan:
    1599                 :            :       /* ??? Print the significand as well, if not canonical?  */
    1600                 :        172 :       sprintf (str, "%c%cNaN", (r_orig->sign ? '-' : '+'),
    1601                 :        172 :                (r_orig->signalling ? 'S' : 'Q'));
    1602                 :        172 :       return;
    1603                 :          0 :     default:
    1604                 :          0 :       gcc_unreachable ();
    1605                 :            :     }
    1606                 :            : 
    1607                 :     202157 :   if (r.decimal)
    1608                 :            :     {
    1609                 :         46 :       decimal_real_to_decimal (str, &r, buf_size, digits, crop_trailing_zeros);
    1610                 :         46 :       return;
    1611                 :            :     }
    1612                 :            : 
    1613                 :            :   /* Bound the number of digits printed by the size of the representation.  */
    1614                 :     202111 :   max_digits = SIGNIFICAND_BITS * M_LOG10_2;
    1615                 :     202111 :   if (digits == 0 || digits > max_digits)
    1616                 :      54415 :     digits = max_digits;
    1617                 :            : 
    1618                 :            :   /* Estimate the decimal exponent, and compute the length of the string it
    1619                 :            :      will print as.  Be conservative and add one to account for possible
    1620                 :            :      overflow or rounding error.  */
    1621                 :     202111 :   dec_exp = REAL_EXP (&r) * M_LOG10_2;
    1622                 :     616817 :   for (max_digits = 1; dec_exp ; max_digits++)
    1623                 :     414706 :     dec_exp /= 10;
    1624                 :            : 
    1625                 :            :   /* Bound the number of digits printed by the size of the output buffer.  */
    1626                 :     202111 :   max_digits = buf_size - 1 - 1 - 2 - max_digits - 1;
    1627                 :     202111 :   gcc_assert (max_digits <= buf_size);
    1628                 :     202111 :   if (digits > max_digits)
    1629                 :            :     digits = max_digits;
    1630                 :            : 
    1631                 :     202111 :   one = real_digit (1);
    1632                 :     202111 :   ten = ten_to_ptwo (0);
    1633                 :            : 
    1634                 :     202111 :   sign = r.sign;
    1635                 :     202111 :   r.sign = 0;
    1636                 :            : 
    1637                 :     202111 :   dec_exp = 0;
    1638                 :     202111 :   pten = *one;
    1639                 :            : 
    1640                 :     202111 :   cmp_one = do_compare (&r, one, 0);
    1641                 :     202111 :   if (cmp_one > 0)
    1642                 :            :     {
    1643                 :      67356 :       int m;
    1644                 :            : 
    1645                 :            :       /* Number is greater than one.  Convert significand to an integer
    1646                 :            :          and strip trailing decimal zeros.  */
    1647                 :            : 
    1648                 :      67356 :       u = r;
    1649                 :      67356 :       SET_REAL_EXP (&u, SIGNIFICAND_BITS - 1);
    1650                 :            : 
    1651                 :            :       /* Largest M, such that 10**2**M fits within SIGNIFICAND_BITS.  */
    1652                 :     134712 :       m = floor_log2 (max_digits);
    1653                 :            : 
    1654                 :            :       /* Iterate over the bits of the possible powers of 10 that might
    1655                 :            :          be present in U and eliminate them.  That is, if we find that
    1656                 :            :          10**2**M divides U evenly, keep the division and increase
    1657                 :            :          DEC_EXP by 2**M.  */
    1658                 :     428570 :       do
    1659                 :            :         {
    1660                 :     428570 :           REAL_VALUE_TYPE t;
    1661                 :            : 
    1662                 :     428570 :           do_divide (&t, &u, ten_to_ptwo (m));
    1663                 :     428570 :           do_fix_trunc (&v, &t);
    1664                 :     857140 :           if (cmp_significands (&v, &t) == 0)
    1665                 :            :             {
    1666                 :      32165 :               u = t;
    1667                 :      32165 :               dec_exp += 1 << m;
    1668                 :            :             }
    1669                 :            :         }
    1670                 :     428570 :       while (--m >= 0);
    1671                 :            : 
    1672                 :            :       /* Revert the scaling to integer that we performed earlier.  */
    1673                 :      67356 :       SET_REAL_EXP (&u, REAL_EXP (&u) + REAL_EXP (&r)
    1674                 :            :                     - (SIGNIFICAND_BITS - 1));
    1675                 :      67356 :       r = u;
    1676                 :            : 
    1677                 :            :       /* Find power of 10.  Do this by dividing out 10**2**M when
    1678                 :            :          this is larger than the current remainder.  Fill PTEN with
    1679                 :            :          the power of 10 that we compute.  */
    1680                 :      67356 :       if (REAL_EXP (&r) > 0)
    1681                 :            :         {
    1682                 :     117838 :           m = floor_log2 ((int)(REAL_EXP (&r) * M_LOG10_2)) + 1;
    1683                 :     507660 :           do
    1684                 :            :             {
    1685                 :     507660 :               const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
    1686                 :     507660 :               if (do_compare (&u, ptentwo, 0) >= 0)
    1687                 :            :                 {
    1688                 :     204169 :                   do_divide (&u, &u, ptentwo);
    1689                 :     204169 :                   do_multiply (&pten, &pten, ptentwo);
    1690                 :     204169 :                   dec_exp += 1 << m;
    1691                 :            :                 }
    1692                 :            :             }
    1693                 :     507660 :           while (--m >= 0);
    1694                 :            :         }
    1695                 :            :       else
    1696                 :            :         /* We managed to divide off enough tens in the above reduction
    1697                 :            :            loop that we've now got a negative exponent.  Fall into the
    1698                 :            :            less-than-one code to compute the proper value for PTEN.  */
    1699                 :            :         cmp_one = -1;
    1700                 :            :     }
    1701                 :     200149 :   if (cmp_one < 0)
    1702                 :            :     {
    1703                 :     107275 :       int m;
    1704                 :            : 
    1705                 :            :       /* Number is less than one.  Pad significand with leading
    1706                 :            :          decimal zeros.  */
    1707                 :            : 
    1708                 :     107275 :       v = r;
    1709                 :   10519700 :       while (1)
    1710                 :            :         {
    1711                 :            :           /* Stop if we'd shift bits off the bottom.  */
    1712                 :    5313460 :           if (v.sig[0] & 7)
    1713                 :            :             break;
    1714                 :            : 
    1715                 :    5266150 :           do_multiply (&u, &v, ten);
    1716                 :            : 
    1717                 :            :           /* Stop if we're now >= 1 or zero.  */
    1718                 :    5266150 :           if (REAL_EXP (&u) > 0 || u.cl == rvc_zero)
    1719                 :            :             break;
    1720                 :            : 
    1721                 :    5206190 :           v = u;
    1722                 :    5206190 :           dec_exp -= 1;
    1723                 :            :         }
    1724                 :     107275 :       r = v;
    1725                 :            : 
    1726                 :            :       /* Find power of 10.  Do this by multiplying in P=10**2**M when
    1727                 :            :          the current remainder is smaller than 1/P.  Fill PTEN with the
    1728                 :            :          power of 10 that we compute.  */
    1729                 :     154595 :       m = floor_log2 ((int)(-REAL_EXP (&r) * M_LOG10_2)) + 1;
    1730                 :     604040 :       do
    1731                 :            :         {
    1732                 :     604040 :           const REAL_VALUE_TYPE *ptentwo = ten_to_ptwo (m);
    1733                 :     604040 :           const REAL_VALUE_TYPE *ptenmtwo = ten_to_mptwo (m);
    1734                 :            : 
    1735                 :     604040 :           if (do_compare (&v, ptenmtwo, 0) <= 0)
    1736                 :            :             {
    1737                 :     239304 :               do_multiply (&v, &v, ptentwo);
    1738                 :     239304 :               do_multiply (&pten, &pten, ptentwo);
    1739                 :     239304 :               dec_exp -= 1 << m;
    1740                 :            :             }
    1741                 :            :         }
    1742                 :     604040 :       while (--m >= 0);
    1743                 :            : 
    1744                 :            :       /* Invert the positive power of 10 that we've collected so far.  */
    1745                 :     107275 :       do_divide (&pten, one, &pten);
    1746                 :            :     }
    1747                 :            : 
    1748                 :     202111 :   p = str;
    1749                 :     202111 :   if (sign)
    1750                 :      14997 :     *p++ = '-';
    1751                 :     202111 :   first = p++;
    1752                 :            : 
    1753                 :            :   /* At this point, PTEN should contain the nearest power of 10 smaller
    1754                 :            :      than R, such that this division produces the first digit.
    1755                 :            : 
    1756                 :            :      Using a divide-step primitive that returns the complete integral
    1757                 :            :      remainder avoids the rounding error that would be produced if
    1758                 :            :      we were to use do_divide here and then simply multiply by 10 for
    1759                 :            :      each subsequent digit.  */
    1760                 :            : 
    1761                 :     202111 :   digit = rtd_divmod (&r, &pten);
    1762                 :            : 
    1763                 :            :   /* Be prepared for error in that division via underflow ...  */
    1764                 :     309386 :   if (digit == 0 && cmp_significand_0 (&r))
    1765                 :            :     {
    1766                 :            :       /* Multiply by 10 and try again.  */
    1767                 :     107272 :       do_multiply (&r, &r, ten);
    1768                 :     107272 :       digit = rtd_divmod (&r, &pten);
    1769                 :     107272 :       dec_exp -= 1;
    1770                 :     107272 :       gcc_assert (digit != 0);
    1771                 :            :     }
    1772                 :            : 
    1773                 :            :   /* ... or overflow.  */
    1774                 :     202111 :   if (digit == 10)
    1775                 :            :     {
    1776                 :          0 :       *p++ = '1';
    1777                 :          0 :       if (--digits > 0)
    1778                 :          0 :         *p++ = '0';
    1779                 :          0 :       dec_exp += 1;
    1780                 :            :     }
    1781                 :            :   else
    1782                 :            :     {
    1783                 :     202111 :       gcc_assert (digit <= 10);
    1784                 :     202111 :       *p++ = digit + '0';
    1785                 :            :     }
    1786                 :            : 
    1787                 :            :   /* Generate subsequent digits.  */
    1788                 :    8401200 :   while (--digits > 0)
    1789                 :            :     {
    1790                 :    8199090 :       do_multiply (&r, &r, ten);
    1791                 :    8199090 :       digit = rtd_divmod (&r, &pten);
    1792                 :    8199090 :       *p++ = digit + '0';
    1793                 :            :     }
    1794                 :     202111 :   last = p;
    1795                 :            : 
    1796                 :            :   /* Generate one more digit with which to do rounding.  */
    1797                 :     202111 :   do_multiply (&r, &r, ten);
    1798                 :     202111 :   digit = rtd_divmod (&r, &pten);
    1799                 :            : 
    1800                 :            :   /* Round the result.  */
    1801                 :     202111 :   if (fmt && fmt->round_towards_zero)
    1802                 :            :     {
    1803                 :            :       /* If the format uses round towards zero when parsing the string
    1804                 :            :          back in, we need to always round away from zero here.  */
    1805                 :          0 :       if (cmp_significand_0 (&r))
    1806                 :          0 :         digit++;
    1807                 :          0 :       round_up = digit > 0;
    1808                 :            :     }
    1809                 :            :   else
    1810                 :            :     {
    1811                 :     202111 :       if (digit == 5)
    1812                 :            :         {
    1813                 :            :           /* Round to nearest.  If R is nonzero there are additional
    1814                 :            :              nonzero digits to be extracted.  */
    1815                 :      73890 :           if (cmp_significand_0 (&r))
    1816                 :            :             digit++;
    1817                 :            :           /* Round to even.  */
    1818                 :      11900 :           else if ((p[-1] - '0') & 1)
    1819                 :            :             digit++;
    1820                 :            :         }
    1821                 :            : 
    1822                 :     202111 :       round_up = digit > 5;
    1823                 :            :     }
    1824                 :            : 
    1825                 :     202111 :   if (round_up)
    1826                 :            :     {
    1827                 :      54575 :       while (p > first)
    1828                 :            :         {
    1829                 :      54575 :           digit = *--p;
    1830                 :      54575 :           if (digit == '9')
    1831                 :        280 :             *p = '0';
    1832                 :            :           else
    1833                 :            :             {
    1834                 :      54295 :               *p = digit + 1;
    1835                 :      54295 :               break;
    1836                 :            :             }
    1837                 :            :         }
    1838                 :            : 
    1839                 :            :       /* Carry out of the first digit.  This means we had all 9's and
    1840                 :            :          now have all 0's.  "Prepend" a 1 by overwriting the first 0.  */
    1841                 :      54295 :       if (p == first)
    1842                 :            :         {
    1843                 :          0 :           first[1] = '1';
    1844                 :          0 :           dec_exp++;
    1845                 :            :         }
    1846                 :            :     }
    1847                 :            : 
    1848                 :            :   /* Insert the decimal point.  */
    1849                 :     202111 :   first[0] = first[1];
    1850                 :     202111 :   first[1] = '.';
    1851                 :            : 
    1852                 :            :   /* If requested, drop trailing zeros.  Never crop past "1.0".  */
    1853                 :     202111 :   if (crop_trailing_zeros)
    1854                 :    2943990 :     while (last > first + 3 && last[-1] == '0')
    1855                 :    2888800 :       last--;
    1856                 :            : 
    1857                 :            :   /* Append the exponent.  */
    1858                 :     202111 :   sprintf (last, "e%+d", dec_exp);
    1859                 :            : 
    1860                 :            :   /* Verify that we can read the original value back in.  */
    1861                 :     202111 :   if (flag_checking && mode != VOIDmode)
    1862                 :            :     {
    1863                 :     146928 :       real_from_string (&r, str);
    1864                 :     146928 :       real_convert (&r, mode, &r);
    1865                 :     146928 :       gcc_assert (real_identical (&r, r_orig));
    1866                 :            :     }
    1867                 :            : }
    1868                 :            : 
    1869                 :            : /* Likewise, except always uses round-to-nearest.  */
    1870                 :            : 
    1871                 :            : void
    1872                 :     118170 : real_to_decimal (char *str, const REAL_VALUE_TYPE *r_orig, size_t buf_size,
    1873                 :            :                  size_t digits, int crop_trailing_zeros)
    1874                 :            : {
    1875                 :     118170 :   real_to_decimal_for_mode (str, r_orig, buf_size,
    1876                 :            :                             digits, crop_trailing_zeros, VOIDmode);
    1877                 :     118170 : }
    1878                 :            : 
    1879                 :            : /* Render R as a hexadecimal floating point constant.  Emit DIGITS
    1880                 :            :    significant digits in the result, bounded by BUF_SIZE.  If DIGITS is 0,
    1881                 :            :    choose the maximum for the representation.  If CROP_TRAILING_ZEROS,
    1882                 :            :    strip trailing zeros.  */
    1883                 :            : 
    1884                 :            : void
    1885                 :     249187 : real_to_hexadecimal (char *str, const REAL_VALUE_TYPE *r, size_t buf_size,
    1886                 :            :                      size_t digits, int crop_trailing_zeros)
    1887                 :            : {
    1888                 :     249187 :   int i, j, exp = REAL_EXP (r);
    1889                 :     249187 :   char *p, *first;
    1890                 :     249187 :   char exp_buf[16];
    1891                 :     249187 :   size_t max_digits;
    1892                 :            : 
    1893                 :     249187 :   switch (r->cl)
    1894                 :            :     {
    1895                 :      78261 :     case rvc_zero:
    1896                 :      78261 :       exp = 0;
    1897                 :      78261 :       break;
    1898                 :            :     case rvc_normal:
    1899                 :            :       break;
    1900                 :          0 :     case rvc_inf:
    1901                 :          0 :       strcpy (str, (r->sign ? "-Inf" : "+Inf"));
    1902                 :          2 :       return;
    1903                 :          2 :     case rvc_nan:
    1904                 :            :       /* ??? Print the significand as well, if not canonical?  */
    1905                 :          2 :       sprintf (str, "%c%cNaN", (r->sign ? '-' : '+'),
    1906                 :          2 :                (r->signalling ? 'S' : 'Q'));
    1907                 :          2 :       return;
    1908                 :          0 :     default:
    1909                 :          0 :       gcc_unreachable ();
    1910                 :            :     }
    1911                 :            : 
    1912                 :     249185 :   if (r->decimal)
    1913                 :            :     {
    1914                 :            :       /* Hexadecimal format for decimal floats is not interesting. */
    1915                 :          0 :       strcpy (str, "N/A");
    1916                 :          0 :       return;
    1917                 :            :     }
    1918                 :            : 
    1919                 :     249185 :   if (digits == 0)
    1920                 :     249185 :     digits = SIGNIFICAND_BITS / 4;
    1921                 :            : 
    1922                 :            :   /* Bound the number of digits printed by the size of the output buffer.  */
    1923                 :            : 
    1924                 :     249185 :   sprintf (exp_buf, "p%+d", exp);
    1925                 :     249185 :   max_digits = buf_size - strlen (exp_buf) - r->sign - 4 - 1;
    1926                 :     249185 :   gcc_assert (max_digits <= buf_size);
    1927                 :     249185 :   if (digits > max_digits)
    1928                 :            :     digits = max_digits;
    1929                 :            : 
    1930                 :     249185 :   p = str;
    1931                 :     249185 :   if (r->sign)
    1932                 :      81457 :     *p++ = '-';
    1933                 :     249185 :   *p++ = '0';
    1934                 :     249185 :   *p++ = 'x';
    1935                 :     249185 :   *p++ = '0';
    1936                 :     249185 :   *p++ = '.';
    1937                 :     249185 :   first = p;
    1938                 :            : 
    1939                 :     747555 :   for (i = SIGSZ - 1; i >= 0; --i)
    1940                 :   12459200 :     for (j = HOST_BITS_PER_LONG - 4; j >= 0; j -= 4)
    1941                 :            :       {
    1942                 :   11960900 :         *p++ = "0123456789abcdef"[(r->sig[i] >> j) & 15];
    1943                 :   11960900 :         if (--digits == 0)
    1944                 :     249185 :           goto out;
    1945                 :            :       }
    1946                 :            : 
    1947                 :          0 :  out:
    1948                 :     249185 :   if (crop_trailing_zeros)
    1949                 :   11432600 :     while (p > first + 1 && p[-1] == '0')
    1950                 :   11183400 :       p--;
    1951                 :            : 
    1952                 :     249185 :   sprintf (p, "p%+d", exp);
    1953                 :            : }
    1954                 :            : 
    1955                 :            : /* Initialize R from a decimal or hexadecimal string.  The string is
    1956                 :            :    assumed to have been syntax checked already.  Return -1 if the
    1957                 :            :    value underflows, +1 if overflows, and 0 otherwise. */
    1958                 :            : 
    1959                 :            : int
    1960                 :    5615590 : real_from_string (REAL_VALUE_TYPE *r, const char *str)
    1961                 :            : {
    1962                 :    5615590 :   int exp = 0;
    1963                 :    5615590 :   bool sign = false;
    1964                 :            : 
    1965                 :    5615590 :   get_zero (r, 0);
    1966                 :            : 
    1967                 :    5615590 :   if (*str == '-')
    1968                 :            :     {
    1969                 :      48944 :       sign = true;
    1970                 :      48944 :       str++;
    1971                 :            :     }
    1972                 :    5566650 :   else if (*str == '+')
    1973                 :          1 :     str++;
    1974                 :            : 
    1975                 :    5615590 :   if (!strncmp (str, "QNaN", 4))
    1976                 :            :     {
    1977                 :          8 :       get_canonical_qnan (r, sign);
    1978                 :          8 :       return 0;
    1979                 :            :     }
    1980                 :    5615580 :   else if (!strncmp (str, "SNaN", 4))
    1981                 :            :     {
    1982                 :          8 :       get_canonical_snan (r, sign);
    1983                 :          8 :       return 0;
    1984                 :            :     }
    1985                 :    5615580 :   else if (!strncmp (str, "Inf", 3))
    1986                 :            :     {
    1987                 :          9 :       get_inf (r, sign);
    1988                 :          9 :       return 0;
    1989                 :            :     }
    1990                 :            : 
    1991                 :    5615570 :   if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
    1992                 :            :     {
    1993                 :            :       /* Hexadecimal floating point.  */
    1994                 :    2471520 :       int pos = SIGNIFICAND_BITS - 4, d;
    1995                 :            : 
    1996                 :    2471520 :       str += 2;
    1997                 :            : 
    1998                 :    2694360 :       while (*str == '0')
    1999                 :     222835 :         str++;
    2000                 :    2888940 :       while (1)
    2001                 :            :         {
    2002                 :    2680230 :           d = hex_value (*str);
    2003                 :    2680230 :           if (d == _hex_bad)
    2004                 :            :             break;
    2005                 :     208709 :           if (pos >= 0)
    2006                 :            :             {
    2007                 :     208673 :               r->sig[pos / HOST_BITS_PER_LONG]
    2008                 :     208673 :                 |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
    2009                 :     208673 :               pos -= 4;
    2010                 :            :             }
    2011                 :         36 :           else if (d)
    2012                 :            :             /* Ensure correct rounding by setting last bit if there is
    2013                 :            :                a subsequent nonzero digit.  */
    2014                 :          8 :             r->sig[0] |= 1;
    2015                 :     208709 :           exp += 4;
    2016                 :     208709 :           str++;
    2017                 :            :         }
    2018                 :    2471520 :       if (*str == '.')
    2019                 :            :         {
    2020                 :    2266600 :           str++;
    2021                 :    2266600 :           if (pos == SIGNIFICAND_BITS - 4)
    2022                 :            :             {
    2023                 :    3082350 :               while (*str == '0')
    2024                 :     818004 :                 str++, exp -= 4;
    2025                 :            :             }
    2026                 :  191178000 :           while (1)
    2027                 :            :             {
    2028                 :   96722300 :               d = hex_value (*str);
    2029                 :   96722300 :               if (d == _hex_bad)
    2030                 :            :                 break;
    2031                 :   94455800 :               if (pos >= 0)
    2032                 :            :                 {
    2033                 :   92142800 :                   r->sig[pos / HOST_BITS_PER_LONG]
    2034                 :   92142800 :                     |= (unsigned long) d << (pos % HOST_BITS_PER_LONG);
    2035                 :   92142800 :                   pos -= 4;
    2036                 :            :                 }
    2037                 :    2312900 :               else if (d)
    2038                 :            :                 /* Ensure correct rounding by setting last bit if there is
    2039                 :            :                    a subsequent nonzero digit.  */
    2040                 :     410369 :                 r->sig[0] |= 1;
    2041                 :   94455800 :               str++;
    2042                 :            :             }
    2043                 :            :         }
    2044                 :            : 
    2045                 :            :       /* If the mantissa is zero, ignore the exponent.  */
    2046                 :    4943050 :       if (!cmp_significand_0 (r))
    2047                 :      45760 :         goto is_a_zero;
    2048                 :            : 
    2049                 :    2425760 :       if (*str == 'p' || *str == 'P')
    2050                 :            :         {
    2051                 :    2425760 :           bool exp_neg = false;
    2052                 :            : 
    2053                 :    2425760 :           str++;
    2054                 :    2425760 :           if (*str == '-')
    2055                 :            :             {
    2056                 :     494119 :               exp_neg = true;
    2057                 :     494119 :               str++;
    2058                 :            :             }
    2059                 :    1931640 :           else if (*str == '+')
    2060                 :       1301 :             str++;
    2061                 :            : 
    2062                 :    2425760 :           d = 0;
    2063                 :    7000240 :           while (ISDIGIT (*str))
    2064                 :            :             {
    2065                 :    4574470 :               d *= 10;
    2066                 :    4574470 :               d += *str - '0';
    2067                 :    4574470 :               if (d > MAX_EXP)
    2068                 :            :                 {
    2069                 :            :                   /* Overflowed the exponent.  */
    2070                 :          0 :                   if (exp_neg)
    2071                 :          0 :                     goto underflow;
    2072                 :            :                   else
    2073                 :          0 :                     goto overflow;
    2074                 :            :                 }
    2075                 :    4574470 :               str++;
    2076                 :            :             }
    2077                 :    2425760 :           if (exp_neg)
    2078                 :     494119 :             d = -d;
    2079                 :            : 
    2080                 :    2425760 :           exp += d;
    2081                 :            :         }
    2082                 :            : 
    2083                 :    2425760 :       r->cl = rvc_normal;
    2084                 :    2425760 :       SET_REAL_EXP (r, exp);
    2085                 :            : 
    2086                 :    2425760 :       normalize (r);
    2087                 :            :     }
    2088                 :            :   else
    2089                 :            :     {
    2090                 :            :       /* Decimal floating point.  */
    2091                 :            :       const char *cstr = str;
    2092                 :    4855820 :       mpfr_t m;
    2093                 :    4855820 :       bool inexact;
    2094                 :            : 
    2095                 :    4855820 :       while (*cstr == '0')
    2096                 :    1711770 :         cstr++;
    2097                 :    3144040 :       if (*cstr == '.')
    2098                 :            :         {
    2099                 :    1712140 :           cstr++;
    2100                 :    3455510 :           while (*cstr == '0')
    2101                 :    1743380 :             cstr++;
    2102                 :            :         }
    2103                 :            : 
    2104                 :            :       /* If the mantissa is zero, ignore the exponent.  */
    2105                 :    3144040 :       if (!ISDIGIT (*cstr))
    2106                 :    1354270 :         goto is_a_zero;
    2107                 :            : 
    2108                 :            :       /* Nonzero value, possibly overflowing or underflowing.  */
    2109                 :    1789780 :       mpfr_init2 (m, SIGNIFICAND_BITS);
    2110                 :    1789780 :       inexact = mpfr_strtofr (m, str, NULL, 10, MPFR_RNDZ);
    2111                 :            :       /* The result should never be a NaN, and because the rounding is
    2112                 :            :          toward zero should never be an infinity.  */
    2113                 :    1789780 :       gcc_assert (!mpfr_nan_p (m) && !mpfr_inf_p (m));
    2114                 :    1789780 :       if (mpfr_zero_p (m) || mpfr_get_exp (m) < -MAX_EXP + 4)
    2115                 :            :         {
    2116                 :         42 :           mpfr_clear (m);
    2117                 :         42 :           goto underflow;
    2118                 :            :         }
    2119                 :    1789740 :       else if (mpfr_get_exp (m) > MAX_EXP - 4)
    2120                 :            :         {
    2121                 :          0 :           mpfr_clear (m);
    2122                 :          0 :           goto overflow;
    2123                 :            :         }
    2124                 :            :       else
    2125                 :            :         {
    2126                 :    1789740 :           real_from_mpfr (r, m, NULL_TREE, MPFR_RNDZ);
    2127                 :            :           /* 1 to 3 bits may have been shifted off (with a sticky bit)
    2128                 :            :              because the hex digits used in real_from_mpfr did not
    2129                 :            :              start with a digit 8 to f, but the exponent bounds above
    2130                 :            :              should have avoided underflow or overflow.  */
    2131                 :    1789740 :           gcc_assert (r->cl == rvc_normal);
    2132                 :            :           /* Set a sticky bit if mpfr_strtofr was inexact.  */
    2133                 :    1789740 :           r->sig[0] |= inexact;
    2134                 :    1789740 :           mpfr_clear (m);
    2135                 :            :         }
    2136                 :            :     }
    2137                 :            : 
    2138                 :    4215500 :   r->sign = sign;
    2139                 :    4215500 :   return 0;
    2140                 :            : 
    2141                 :    1400030 :  is_a_zero:
    2142                 :    1400030 :   get_zero (r, sign);
    2143                 :    1400030 :   return 0;
    2144                 :            : 
    2145                 :         42 :  underflow:
    2146                 :         42 :   get_zero (r, sign);
    2147                 :         42 :   return -1;
    2148                 :            : 
    2149                 :          0 :  overflow:
    2150                 :          0 :   get_inf (r, sign);
    2151                 :          0 :   return 1;
    2152                 :            : }
    2153                 :            : 
    2154                 :            : /* Legacy.  Similar, but return the result directly.  */
    2155                 :            : 
    2156                 :            : REAL_VALUE_TYPE
    2157                 :          5 : real_from_string2 (const char *s, format_helper fmt)
    2158                 :            : {
    2159                 :          5 :   REAL_VALUE_TYPE r;
    2160                 :            : 
    2161                 :          5 :   real_from_string (&r, s);
    2162                 :          5 :   if (fmt)
    2163                 :          5 :     real_convert (&r, fmt, &r);
    2164                 :            : 
    2165                 :          5 :   return r;
    2166                 :            : }
    2167                 :            : 
    2168                 :            : /* Initialize R from string S and desired format FMT. */
    2169                 :            : 
    2170                 :            : void
    2171                 :    2331530 : real_from_string3 (REAL_VALUE_TYPE *r, const char *s, format_helper fmt)
    2172                 :            : {
    2173                 :    2331530 :   if (fmt.decimal_p ())
    2174                 :      16036 :     decimal_real_from_string (r, s);
    2175                 :            :   else
    2176                 :    2315500 :     real_from_string (r, s);
    2177                 :            : 
    2178                 :    2331530 :   if (fmt)
    2179                 :    2331530 :     real_convert (r, fmt, r);
    2180                 :    2331530 : }
    2181                 :            : 
    2182                 :            : /* Initialize R from the wide_int VAL_IN.  Round it to format FMT if
    2183                 :            :    FMT is nonnull.  */
    2184                 :            : 
    2185                 :            : void
    2186                 :    2394150 : real_from_integer (REAL_VALUE_TYPE *r, format_helper fmt,
    2187                 :            :                    const wide_int_ref &val_in, signop sgn)
    2188                 :            : {
    2189                 :    2394150 :   if (val_in == 0)
    2190                 :     785595 :     get_zero (r, 0);
    2191                 :            :   else
    2192                 :            :     {
    2193                 :    1608560 :       unsigned int len = val_in.get_precision ();
    2194                 :    1608560 :       int i, j, e = 0;
    2195                 :    1608560 :       int maxbitlen = MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT;
    2196                 :    1608560 :       const unsigned int realmax = (SIGNIFICAND_BITS / HOST_BITS_PER_WIDE_INT
    2197                 :            :                                     * HOST_BITS_PER_WIDE_INT);
    2198                 :            : 
    2199                 :    1608560 :       memset (r, 0, sizeof (*r));
    2200                 :    1608560 :       r->cl = rvc_normal;
    2201                 :    1608560 :       r->sign = wi::neg_p (val_in, sgn);
    2202                 :            : 
    2203                 :            :       /* We have to ensure we can negate the largest negative number.  */
    2204                 :    1608560 :       wide_int val = wide_int::from (val_in, maxbitlen, sgn);
    2205                 :            : 
    2206                 :    1608560 :       if (r->sign)
    2207                 :     107717 :         val = -val;
    2208                 :            : 
    2209                 :            :       /* Ensure a multiple of HOST_BITS_PER_WIDE_INT, ceiling, as elt
    2210                 :            :          won't work with precisions that are not a multiple of
    2211                 :            :          HOST_BITS_PER_WIDE_INT.  */
    2212                 :    1608560 :       len += HOST_BITS_PER_WIDE_INT - 1;
    2213                 :            : 
    2214                 :            :       /* Ensure we can represent the largest negative number.  */
    2215                 :    1608560 :       len += 1;
    2216                 :            : 
    2217                 :    1608560 :       len = len/HOST_BITS_PER_WIDE_INT * HOST_BITS_PER_WIDE_INT;
    2218                 :            : 
    2219                 :            :       /* Cap the size to the size allowed by real.h.  */
    2220                 :    1608560 :       if (len > realmax)
    2221                 :            :         {
    2222                 :          0 :           HOST_WIDE_INT cnt_l_z;
    2223                 :          0 :           cnt_l_z = wi::clz (val);
    2224                 :            : 
    2225                 :          0 :           if (maxbitlen - cnt_l_z > realmax)
    2226                 :            :             {
    2227                 :          0 :               e = maxbitlen - cnt_l_z - realmax;
    2228                 :            : 
    2229                 :            :               /* This value is too large, we must shift it right to
    2230                 :            :                  preserve all the bits we can, and then bump the
    2231                 :            :                  exponent up by that amount.  */
    2232                 :          0 :               val = wi::lrshift (val, e);
    2233                 :            :             }
    2234                 :            :           len = realmax;
    2235                 :            :         }
    2236                 :            : 
    2237                 :            :       /* Clear out top bits so elt will work with precisions that aren't
    2238                 :            :          a multiple of HOST_BITS_PER_WIDE_INT.  */
    2239                 :    1608560 :       val = wide_int::from (val, len, sgn);
    2240                 :    1608560 :       len = len / HOST_BITS_PER_WIDE_INT;
    2241                 :            : 
    2242                 :    1608560 :       SET_REAL_EXP (r, len * HOST_BITS_PER_WIDE_INT + e);
    2243                 :            : 
    2244                 :    1608560 :       j = SIGSZ - 1;
    2245                 :    1608560 :       if (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT)
    2246                 :    3362180 :         for (i = len - 1; i >= 0; i--)
    2247                 :            :           {
    2248                 :    1761650 :             r->sig[j--] = val.elt (i);
    2249                 :    1761650 :             if (j < 0)
    2250                 :            :               break;
    2251                 :            :           }
    2252                 :            :       else
    2253                 :            :         {
    2254                 :            :           gcc_assert (HOST_BITS_PER_LONG*2 == HOST_BITS_PER_WIDE_INT);
    2255                 :            :           for (i = len - 1; i >= 0; i--)
    2256                 :            :             {
    2257                 :            :               HOST_WIDE_INT e = val.elt (i);
    2258                 :            :               r->sig[j--] = e >> (HOST_BITS_PER_LONG - 1) >> 1;
    2259                 :            :               if (j < 0)
    2260                 :            :                 break;
    2261                 :            :               r->sig[j--] = e;
    2262                 :            :               if (j < 0)
    2263                 :            :                 break;
    2264                 :            :             }
    2265                 :            :         }
    2266                 :            : 
    2267                 :    1608560 :       normalize (r);
    2268                 :            :     }
    2269                 :            : 
    2270                 :    2394150 :   if (fmt.decimal_p ())
    2271                 :      10168 :     decimal_from_integer (r);
    2272                 :    2394150 :   if (fmt)
    2273                 :    2275510 :     real_convert (r, fmt, r);
    2274                 :    2394150 : }
    2275                 :            : 
    2276                 :            : /* Render R, an integral value, as a floating point constant with no
    2277                 :            :    specified exponent.  */
    2278                 :            : 
    2279                 :            : static void
    2280                 :      10168 : decimal_integer_string (char *str, const REAL_VALUE_TYPE *r_orig,
    2281                 :            :                         size_t buf_size)
    2282                 :            : {
    2283                 :      10168 :   int dec_exp, digit, digits;
    2284                 :      10168 :   REAL_VALUE_TYPE r, pten;
    2285                 :      10168 :   char *p;
    2286                 :      10168 :   bool sign;
    2287                 :            : 
    2288                 :      10168 :   r = *r_orig;
    2289                 :            : 
    2290                 :      10168 :   if (r.cl == rvc_zero)
    2291                 :            :     {
    2292                 :       1523 :       strcpy (str, "0.");
    2293                 :       1523 :       return;
    2294                 :            :     }
    2295                 :            : 
    2296                 :       8645 :   sign = r.sign;
    2297                 :       8645 :   r.sign = 0;
    2298                 :            : 
    2299                 :       8645 :   dec_exp = REAL_EXP (&r) * M_LOG10_2;
    2300                 :       8645 :   digits = dec_exp + 1;
    2301                 :       8645 :   gcc_assert ((digits + 2) < (int)buf_size);
    2302                 :            : 
    2303                 :       8645 :   pten = *real_digit (1);
    2304                 :       8645 :   times_pten (&pten, dec_exp);
    2305                 :            : 
    2306                 :       8645 :   p = str;
    2307                 :       8645 :   if (sign)
    2308                 :       1310 :     *p++ = '-';
    2309                 :            : 
    2310                 :       8645 :   digit = rtd_divmod (&r, &pten);
    2311                 :       8645 :   gcc_assert (digit >= 0 && digit <= 9);
    2312                 :       8645 :   *p++ = digit + '0';
    2313                 :      53908 :   while (--digits > 0)
    2314                 :            :     {
    2315                 :      45263 :       times_pten (&r, 1);
    2316                 :      45263 :       digit = rtd_divmod (&r, &pten);
    2317                 :      45263 :       *p++ = digit + '0';
    2318                 :            :     }
    2319                 :       8645 :   *p++ = '.';
    2320                 :       8645 :   *p++ = '\0';
    2321                 :            : }
    2322                 :            : 
    2323                 :            : /* Convert a real with an integral value to decimal float.  */
    2324                 :            : 
    2325                 :            : static void
    2326                 :      10168 : decimal_from_integer (REAL_VALUE_TYPE *r)
    2327                 :            : {
    2328                 :      10168 :   char str[256];
    2329                 :            : 
    2330                 :      10168 :   decimal_integer_string (str, r, sizeof (str) - 1);
    2331                 :      10168 :   decimal_real_from_string (r, str);
    2332                 :      10168 : }
    2333                 :            : 
    2334                 :            : /* Returns 10**2**N.  */
    2335                 :            : 
    2336                 :            : static const REAL_VALUE_TYPE *
    2337                 :    2014100 : ten_to_ptwo (int n)
    2338                 :            : {
    2339                 :    2014100 :   static REAL_VALUE_TYPE tens[EXP_BITS];
    2340                 :            : 
    2341                 :    2014100 :   gcc_assert (n >= 0);
    2342                 :    2014100 :   gcc_assert (n < EXP_BITS);
    2343                 :            : 
    2344                 :    2014100 :   if (tens[n].cl == rvc_zero)
    2345                 :            :     {
    2346                 :     137355 :       if (n < (HOST_BITS_PER_WIDE_INT == 64 ? 5 : 4))
    2347                 :            :         {
    2348                 :            :           HOST_WIDE_INT t = 10;
    2349                 :            :           int i;
    2350                 :            : 
    2351                 :     153687 :           for (i = 0; i < n; ++i)
    2352                 :     102211 :             t *= t;
    2353                 :            : 
    2354                 :      51476 :           real_from_integer (&tens[n], VOIDmode, t, UNSIGNED);
    2355                 :            :         }
    2356                 :            :       else
    2357                 :            :         {
    2358                 :      85879 :           const REAL_VALUE_TYPE *t = ten_to_ptwo (n - 1);
    2359                 :      85879 :           do_multiply (&tens[n], t, t);
    2360                 :            :         }
    2361                 :            :     }
    2362                 :            : 
    2363                 :    2014100 :   return &tens[n];
    2364                 :            : }
    2365                 :            : 
    2366                 :            : /* Returns 10**(-2**N).  */
    2367                 :            : 
    2368                 :            : static const REAL_VALUE_TYPE *
    2369                 :     604040 : ten_to_mptwo (int n)
    2370                 :            : {
    2371                 :     604040 :   static REAL_VALUE_TYPE tens[EXP_BITS];
    2372                 :            : 
    2373                 :     604040 :   gcc_assert (n >= 0);
    2374                 :     604040 :   gcc_assert (n < EXP_BITS);
    2375                 :            : 
    2376                 :     604040 :   if (tens[n].cl == rvc_zero)
    2377                 :     130580 :     do_divide (&tens[n], real_digit (1), ten_to_ptwo (n));
    2378                 :            : 
    2379                 :     604040 :   return &tens[n];
    2380                 :            : }
    2381                 :            : 
    2382                 :            : /* Returns N.  */
    2383                 :            : 
    2384                 :            : static const REAL_VALUE_TYPE *
    2385                 :     465306 : real_digit (int n)
    2386                 :            : {
    2387                 :     465306 :   static REAL_VALUE_TYPE num[10];
    2388                 :            : 
    2389                 :     465306 :   gcc_assert (n >= 0);
    2390                 :     465306 :   gcc_assert (n <= 9);
    2391                 :            : 
    2392                 :     465306 :   if (n > 0 && num[n].cl == rvc_zero)
    2393                 :      11673 :     real_from_integer (&num[n], VOIDmode, n, UNSIGNED);
    2394                 :            : 
    2395                 :     465306 :   return &num[n];
    2396                 :            : }
    2397                 :            : 
    2398                 :            : /* Multiply R by 10**EXP.  */
    2399                 :            : 
    2400                 :            : static void
    2401                 :      53908 : times_pten (REAL_VALUE_TYPE *r, int exp)
    2402                 :            : {
    2403                 :      53908 :   REAL_VALUE_TYPE pten, *rr;
    2404                 :      53908 :   bool negative = (exp < 0);
    2405                 :      53908 :   int i;
    2406                 :            : 
    2407                 :      53908 :   if (negative)
    2408                 :            :     {
    2409                 :          0 :       exp = -exp;
    2410                 :          0 :       pten = *real_digit (1);
    2411                 :          0 :       rr = &pten;
    2412                 :            :     }
    2413                 :            :   else
    2414                 :            :     rr = r;
    2415                 :            : 
    2416                 :     116194 :   for (i = 0; exp > 0; ++i, exp >>= 1)
    2417                 :      62286 :     if (exp & 1)
    2418                 :      55258 :       do_multiply (rr, rr, ten_to_ptwo (i));
    2419                 :            : 
    2420                 :      53908 :   if (negative)
    2421                 :          0 :     do_divide (r, r, &pten);
    2422                 :      53908 : }
    2423                 :            : 
    2424                 :            : /* Returns the special REAL_VALUE_TYPE corresponding to 'e'.  */
    2425                 :            : 
    2426                 :            : const REAL_VALUE_TYPE *
    2427                 :         72 : dconst_e_ptr (void)
    2428                 :            : {
    2429                 :         72 :   static REAL_VALUE_TYPE value;
    2430                 :            : 
    2431                 :            :   /* Initialize mathematical constants for constant folding builtins.
    2432                 :            :      These constants need to be given to at least 160 bits precision.  */
    2433                 :         72 :   if (value.cl == rvc_zero)
    2434                 :            :     {
    2435                 :          6 :       mpfr_t m;
    2436                 :          6 :       mpfr_init2 (m, SIGNIFICAND_BITS);
    2437                 :          6 :       mpfr_set_ui (m, 1, MPFR_RNDN);
    2438                 :          6 :       mpfr_exp (m, m, MPFR_RNDN);
    2439                 :          6 :       real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
    2440                 :          6 :       mpfr_clear (m);
    2441                 :            : 
    2442                 :            :     }
    2443                 :         72 :   return &value;
    2444                 :            : }
    2445                 :            : 
    2446                 :            : /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n.  */
    2447                 :            : 
    2448                 :            : #define CACHED_FRACTION(NAME, N)                                        \
    2449                 :            :   const REAL_VALUE_TYPE *                                               \
    2450                 :            :   NAME (void)                                                           \
    2451                 :            :   {                                                                     \
    2452                 :            :     static REAL_VALUE_TYPE value;                                       \
    2453                 :            :                                                                         \
    2454                 :            :     /* Initialize mathematical constants for constant folding builtins. \
    2455                 :            :        These constants need to be given to at least 160 bits            \
    2456                 :            :        precision.  */                                                   \
    2457                 :            :     if (value.cl == rvc_zero)                                           \
    2458                 :            :       real_arithmetic (&value, RDIV_EXPR, &dconst1, real_digit (N));    \
    2459                 :            :     return &value;                                                  \
    2460                 :            :   }
    2461                 :            : 
    2462                 :       1821 : CACHED_FRACTION (dconst_third_ptr, 3)
    2463                 :         36 : CACHED_FRACTION (dconst_quarter_ptr, 4)
    2464                 :         72 : CACHED_FRACTION (dconst_sixth_ptr, 6)
    2465                 :         36 : CACHED_FRACTION (dconst_ninth_ptr, 9)
    2466                 :            : 
    2467                 :            : /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2).  */
    2468                 :            : 
    2469                 :            : const REAL_VALUE_TYPE *
    2470                 :         21 : dconst_sqrt2_ptr (void)
    2471                 :            : {
    2472                 :         21 :   static REAL_VALUE_TYPE value;
    2473                 :            : 
    2474                 :            :   /* Initialize mathematical constants for constant folding builtins.
    2475                 :            :      These constants need to be given to at least 160 bits precision.  */
    2476                 :         21 :   if (value.cl == rvc_zero)
    2477                 :            :     {
    2478                 :          2 :       mpfr_t m;
    2479                 :          2 :       mpfr_init2 (m, SIGNIFICAND_BITS);
    2480                 :          2 :       mpfr_sqrt_ui (m, 2, MPFR_RNDN);
    2481                 :          2 :       real_from_mpfr (&value, m, NULL_TREE, MPFR_RNDN);
    2482                 :          2 :       mpfr_clear (m);
    2483                 :            :     }
    2484                 :         21 :   return &value;
    2485                 :            : }
    2486                 :            : 
    2487                 :            : /* Fills R with +Inf.  */
    2488                 :            : 
    2489                 :            : void
    2490                 :     118160 : real_inf (REAL_VALUE_TYPE *r)
    2491                 :            : {
    2492                 :     118160 :   get_inf (r, 0);
    2493                 :     118160 : }
    2494                 :            : 
    2495                 :            : /* Fills R with a NaN whose significand is described by STR.  If QUIET,
    2496                 :            :    we force a QNaN, else we force an SNaN.  The string, if not empty,
    2497                 :            :    is parsed as a number and placed in the significand.  Return true
    2498                 :            :    if the string was successfully parsed.  */
    2499                 :            : 
    2500                 :            : bool
    2501                 :     130572 : real_nan (REAL_VALUE_TYPE *r, const char *str, int quiet,
    2502                 :            :           format_helper fmt)
    2503                 :            : {
    2504                 :     130572 :   if (*str == 0)
    2505                 :            :     {
    2506                 :     130375 :       if (quiet)
    2507                 :      83249 :         get_canonical_qnan (r, 0);
    2508                 :            :       else
    2509                 :      47126 :         get_canonical_snan (r, 0);
    2510                 :            :     }
    2511                 :            :   else
    2512                 :            :     {
    2513                 :        197 :       int base = 10, d;
    2514                 :            : 
    2515                 :        197 :       memset (r, 0, sizeof (*r));
    2516                 :        197 :       r->cl = rvc_nan;
    2517                 :            : 
    2518                 :            :       /* Parse akin to strtol into the significand of R.  */
    2519                 :            : 
    2520                 :        197 :       while (ISSPACE (*str))
    2521                 :          0 :         str++;
    2522                 :        197 :       if (*str == '-')
    2523                 :          0 :         str++;
    2524                 :        197 :       else if (*str == '+')
    2525                 :          0 :         str++;
    2526                 :        197 :       if (*str == '0')
    2527                 :            :         {
    2528                 :        143 :           str++;
    2529                 :        143 :           if (*str == 'x' || *str == 'X')
    2530                 :            :             {
    2531                 :         58 :               base = 16;
    2532                 :         58 :               str++;
    2533                 :            :             }
    2534                 :            :           else
    2535                 :        197 :             base = 8;
    2536                 :            :         }
    2537                 :            : 
    2538                 :        377 :       while ((d = hex_value (*str)) < base)
    2539                 :            :         {
    2540                 :        180 :           REAL_VALUE_TYPE u;
    2541                 :            : 
    2542                 :        180 :           switch (base)
    2543                 :            :             {
    2544                 :          0 :             case 8:
    2545                 :          0 :               lshift_significand (r, r, 3);
    2546                 :          0 :               break;
    2547                 :        156 :             case 16:
    2548                 :        156 :               lshift_significand (r, r, 4);
    2549                 :        156 :               break;
    2550                 :            :             case 10:
    2551                 :         72 :               lshift_significand_1 (&u, r);
    2552                 :         24 :               lshift_significand (r, r, 3);
    2553                 :         24 :               add_significands (r, r, &u);
    2554                 :            :               break;
    2555                 :          0 :             default:
    2556                 :          0 :               gcc_unreachable ();
    2557                 :            :             }
    2558                 :            : 
    2559                 :        180 :           get_zero (&u, 0);
    2560                 :        180 :           u.sig[0] = d;
    2561                 :        180 :           add_significands (r, r, &u);
    2562                 :            : 
    2563                 :        180 :           str++;
    2564                 :            :         }
    2565                 :            : 
    2566                 :            :       /* Must have consumed the entire string for success.  */
    2567                 :        197 :       if (*str != 0)
    2568                 :            :         return false;
    2569                 :            : 
    2570                 :            :       /* Shift the significand into place such that the bits
    2571                 :            :          are in the most significant bits for the format.  */
    2572                 :        167 :       lshift_significand (r, r, SIGNIFICAND_BITS - fmt->pnan);
    2573                 :            : 
    2574                 :            :       /* Our MSB is always unset for NaNs.  */
    2575                 :        167 :       r->sig[SIGSZ-1] &= ~SIG_MSB;
    2576                 :            : 
    2577                 :            :       /* Force quiet or signaling NaN.  */
    2578                 :        167 :       r->signalling = !quiet;
    2579                 :            :     }
    2580                 :            : 
    2581                 :            :   return true;
    2582                 :            : }
    2583                 :            : 
    2584                 :            : /* Fills R with the largest finite value representable in mode MODE.
    2585                 :            :    If SIGN is nonzero, R is set to the most negative finite value.  */
    2586                 :            : 
    2587                 :            : void
    2588                 :      33227 : real_maxval (REAL_VALUE_TYPE *r, int sign, machine_mode mode)
    2589                 :            : {
    2590                 :      33227 :   const struct real_format *fmt;
    2591                 :      33227 :   int np2;
    2592                 :            : 
    2593                 :      33227 :   fmt = REAL_MODE_FORMAT (mode);
    2594                 :      33227 :   gcc_assert (fmt);
    2595                 :      33227 :   memset (r, 0, sizeof (*r));
    2596                 :            : 
    2597                 :      33227 :   if (fmt->b == 10)
    2598                 :         82 :     decimal_real_maxval (r, sign, mode);
    2599                 :            :   else
    2600                 :            :     {
    2601                 :      33145 :       r->cl = rvc_normal;
    2602                 :      33145 :       r->sign = sign;
    2603                 :      33145 :       SET_REAL_EXP (r, fmt->emax);
    2604                 :            : 
    2605                 :      33145 :       np2 = SIGNIFICAND_BITS - fmt->p;
    2606                 :      33145 :       memset (r->sig, -1, SIGSZ * sizeof (unsigned long));
    2607                 :      33145 :       clear_significand_below (r, np2);
    2608                 :            : 
    2609                 :      33145 :       if (fmt->pnan < fmt->p)
    2610                 :            :         /* This is an IBM extended double format made up of two IEEE
    2611                 :            :            doubles.  The value of the long double is the sum of the
    2612                 :            :            values of the two parts.  The most significant part is
    2613                 :            :            required to be the value of the long double rounded to the
    2614                 :            :            nearest double.  Rounding means we need a slightly smaller
    2615                 :            :            value for LDBL_MAX.  */
    2616                 :          0 :         clear_significand_bit (r, SIGNIFICAND_BITS - fmt->pnan - 1);
    2617                 :            :     }
    2618                 :      33227 : }
    2619                 :            : 
    2620                 :            : /* Fills R with 2**N.  */
    2621                 :            : 
    2622                 :            : void
    2623                 :       4663 : real_2expN (REAL_VALUE_TYPE *r, int n, format_helper fmt)
    2624                 :            : {
    2625                 :       4663 :   memset (r, 0, sizeof (*r));
    2626                 :            : 
    2627                 :       4663 :   n++;
    2628                 :       4663 :   if (n > MAX_EXP)
    2629                 :          0 :     r->cl = rvc_inf;
    2630                 :       4663 :   else if (n < -MAX_EXP)
    2631                 :            :     ;
    2632                 :            :   else
    2633                 :            :     {
    2634                 :       4663 :       r->cl = rvc_normal;
    2635                 :       4663 :       SET_REAL_EXP (r, n);
    2636                 :       4663 :       r->sig[SIGSZ-1] = SIG_MSB;
    2637                 :            :     }
    2638                 :       4663 :   if (fmt.decimal_p ())
    2639                 :          0 :     decimal_real_convert (r, fmt, r);
    2640                 :       4663 : }
    2641                 :            : 
    2642                 :            : 
    2643                 :            : static void
    2644                 :    9408930 : round_for_format (const struct real_format *fmt, REAL_VALUE_TYPE *r)
    2645                 :            : {
    2646                 :    9408930 :   int p2, np2, i, w;
    2647                 :    9408930 :   int emin2m1, emax2;
    2648                 :    9408930 :   bool round_up = false;
    2649                 :            : 
    2650                 :    9408930 :   if (r->decimal)
    2651                 :            :     {
    2652                 :     310080 :       if (fmt->b == 10)
    2653                 :            :         {
    2654                 :     310080 :           decimal_round_for_format (fmt, r);
    2655                 :     310080 :           return;
    2656                 :            :         }
    2657                 :            :       /* FIXME. We can come here via fp_easy_constant
    2658                 :            :          (e.g. -O0 on '_Decimal32 x = 1.0 + 2.0dd'), but have not
    2659                 :            :          investigated whether this convert needs to be here, or
    2660                 :            :          something else is missing. */
    2661                 :          0 :       decimal_real_convert (r, REAL_MODE_FORMAT (DFmode), r);
    2662                 :            :     }
    2663                 :            : 
    2664                 :    9098850 :   p2 = fmt->p;
    2665                 :    9098850 :   emin2m1 = fmt->emin - 1;
    2666                 :    9098850 :   emax2 = fmt->emax;
    2667                 :            : 
    2668                 :    9098850 :   np2 = SIGNIFICAND_BITS - p2;
    2669                 :    9098850 :   switch (r->cl)
    2670                 :            :     {
    2671                 :      12576 :     underflow:
    2672                 :      12576 :       get_zero (r, r->sign);
    2673                 :            :       /* FALLTHRU */
    2674                 :    2330670 :     case rvc_zero:
    2675                 :    2330670 :       if (!fmt->has_signed_zero)
    2676                 :          0 :         r->sign = 0;
    2677                 :            :       return;
    2678                 :            : 
    2679                 :     353261 :     overflow:
    2680                 :     353261 :       get_inf (r, r->sign);
    2681                 :            :     case rvc_inf:
    2682                 :            :       return;
    2683                 :            : 
    2684                 :      17244 :     case rvc_nan:
    2685                 :      17244 :       clear_significand_below (r, np2);
    2686                 :            :       return;
    2687                 :            : 
    2688                 :    6745390 :     case rvc_normal:
    2689                 :    6745390 :       break;
    2690                 :            : 
    2691                 :          0 :     default:
    2692                 :          0 :       gcc_unreachable ();
    2693                 :            :     }
    2694                 :            : 
    2695                 :            :   /* Check the range of the exponent.  If we're out of range,
    2696                 :            :      either underflow or overflow.  */
    2697                 :    6745390 :   if (REAL_EXP (r) > emax2)
    2698                 :     353116 :     goto overflow;
    2699                 :    6392270 :   else if (REAL_EXP (r) <= emin2m1)
    2700                 :            :     {
    2701                 :     119000 :       int diff;
    2702                 :            : 
    2703                 :     119000 :       if (!fmt->has_denorm)
    2704                 :            :         {
    2705                 :            :           /* Don't underflow completely until we've had a chance to round.  */
    2706                 :          0 :           if (REAL_EXP (r) < emin2m1)
    2707                 :          0 :             goto underflow;
    2708                 :            :         }
    2709                 :            :       else
    2710                 :            :         {
    2711                 :     119000 :           diff = emin2m1 - REAL_EXP (r) + 1;
    2712                 :     119000 :           if (diff > p2)
    2713                 :      12576 :             goto underflow;
    2714                 :            : 
    2715                 :            :           /* De-normalize the significand.  */
    2716                 :     106424 :           r->sig[0] |= sticky_rshift_significand (r, r, diff);
    2717                 :     106424 :           SET_REAL_EXP (r, REAL_EXP (r) + diff);
    2718                 :            :         }
    2719                 :            :     }
    2720                 :            : 
    2721                 :    6379690 :   if (!fmt->round_towards_zero)
    2722                 :            :     {
    2723                 :            :       /* There are P2 true significand bits, followed by one guard bit,
    2724                 :            :          followed by one sticky bit, followed by stuff.  Fold nonzero
    2725                 :            :          stuff into the sticky bit.  */
    2726                 :    6379690 :       unsigned long sticky;
    2727                 :    6379690 :       bool guard, lsb;
    2728                 :            : 
    2729                 :    6379690 :       sticky = 0;
    2730                 :   17669900 :       for (i = 0, w = (np2 - 1) / HOST_BITS_PER_LONG; i < w; ++i)
    2731                 :   11290200 :         sticky |= r->sig[i];
    2732                 :    6379690 :       sticky |= r->sig[w]
    2733                 :    6379690 :                 & (((unsigned long)1 << ((np2 - 1) % HOST_BITS_PER_LONG)) - 1);
    2734                 :            : 
    2735                 :    6379690 :       guard = test_significand_bit (r, np2 - 1);
    2736                 :    6379690 :       lsb = test_significand_bit (r, np2);
    2737                 :            : 
    2738                 :            :       /* Round to even.  */
    2739                 :    6379690 :       round_up = guard && (sticky || lsb);
    2740                 :            :     }
    2741                 :            : 
    2742                 :     450565 :   if (round_up)
    2743                 :            :     {
    2744                 :     450565 :       REAL_VALUE_TYPE u;
    2745                 :     450565 :       get_zero (&u, 0);
    2746                 :     450565 :       set_significand_bit (&u, np2);
    2747                 :            : 
    2748                 :    1802260 :       if (add_significands (r, r, &u))
    2749                 :            :         {
    2750                 :            :           /* Overflow.  Means the significand had been all ones, and
    2751                 :            :              is now all zeros.  Need to increase the exponent, and
    2752                 :            :              possibly re-normalize it.  */
    2753                 :      83652 :           SET_REAL_EXP (r, REAL_EXP (r) + 1);
    2754                 :      83652 :           if (REAL_EXP (r) > emax2)
    2755                 :        145 :             goto overflow;
    2756                 :      83507 :           r->sig[SIGSZ-1] = SIG_MSB;
    2757                 :            :         }
    2758                 :            :     }
    2759                 :            : 
    2760                 :            :   /* Catch underflow that we deferred until after rounding.  */
    2761                 :    6379550 :   if (REAL_EXP (r) <= emin2m1)
    2762                 :          0 :     goto underflow;
    2763                 :            : 
    2764                 :            :   /* Clear out trailing garbage.  */
    2765                 :    6379550 :   clear_significand_below (r, np2);
    2766                 :            : }
    2767                 :            : 
    2768                 :            : /* Extend or truncate to a new format.  */
    2769                 :            : 
    2770                 :            : void
    2771                 :    8637540 : real_convert (REAL_VALUE_TYPE *r, format_helper fmt,
    2772                 :            :               const REAL_VALUE_TYPE *a)
    2773                 :            : {
    2774                 :    8637540 :   *r = *a;
    2775                 :            : 
    2776                 :    8637540 :   if (a->decimal || fmt->b == 10)
    2777                 :     287252 :     decimal_real_convert (r, fmt, a);
    2778                 :            : 
    2779                 :    8637540 :   round_for_format (fmt, r);
    2780                 :            : 
    2781                 :            :   /* Make resulting NaN value to be qNaN. The caller has the
    2782                 :            :      responsibility to avoid the operation if flag_signaling_nans
    2783                 :            :      is on.  */
    2784                 :    8637540 :   if (r->cl == rvc_nan)
    2785                 :       4942 :     r->signalling = 0;
    2786                 :            : 
    2787                 :            :   /* round_for_format de-normalizes denormals.  Undo just that part.  */
    2788                 :    8637540 :   if (r->cl == rvc_normal)
    2789                 :    6163540 :     normalize (r);
    2790                 :    8637540 : }
    2791                 :            : 
    2792                 :            : /* Legacy.  Likewise, except return the struct directly.  */
    2793                 :            : 
    2794                 :            : REAL_VALUE_TYPE
    2795                 :     310124 : real_value_truncate (format_helper fmt, REAL_VALUE_TYPE a)
    2796                 :            : {
    2797                 :     310124 :   REAL_VALUE_TYPE r;
    2798                 :     310124 :   real_convert (&r, fmt, &a);
    2799                 :     310124 :   return r;
    2800                 :            : }
    2801                 :            : 
    2802                 :            : /* Return true if truncating to FMT is exact.  */
    2803                 :            : 
    2804                 :            : bool
    2805                 :    1243880 : exact_real_truncate (format_helper fmt, const REAL_VALUE_TYPE *a)
    2806                 :            : {
    2807                 :    1243880 :   REAL_VALUE_TYPE t;
    2808                 :    1243880 :   int emin2m1;
    2809                 :            : 
    2810                 :            :   /* Don't allow conversion to denormals.  */
    2811                 :    1243880 :   emin2m1 = fmt->emin - 1;
    2812                 :    1243880 :   if (REAL_EXP (a) <= emin2m1)
    2813                 :            :     return false;
    2814                 :            : 
    2815                 :            :   /* After conversion to the new format, the value must be identical.  */
    2816                 :    1158470 :   real_convert (&t, fmt, a);
    2817                 :    1158470 :   return real_identical (&t, a);
    2818                 :            : }
    2819                 :            : 
    2820                 :            : /* Write R to the given target format.  Place the words of the result
    2821                 :            :    in target word order in BUF.  There are always 32 bits in each
    2822                 :            :    long, no matter the size of the host long.
    2823                 :            : 
    2824                 :            :    Legacy: return word 0 for implementing REAL_VALUE_TO_TARGET_SINGLE.  */
    2825                 :            : 
    2826                 :            : long
    2827                 :     771389 : real_to_target (long *buf, const REAL_VALUE_TYPE *r_orig,
    2828                 :            :                 format_helper fmt)
    2829                 :            : {
    2830                 :     771389 :   REAL_VALUE_TYPE r;
    2831                 :     771389 :   long buf1;
    2832                 :            : 
    2833                 :     771389 :   r = *r_orig;
    2834                 :     771389 :   round_for_format (fmt, &r);
    2835                 :            : 
    2836                 :     771389 :   if (!buf)
    2837                 :      11118 :     buf = &buf1;
    2838                 :     771389 :   (*fmt->encode) (fmt, buf, &r);
    2839                 :            : 
    2840                 :     771389 :   return *buf;
    2841                 :            : }
    2842                 :            : 
    2843                 :            : /* Read R from the given target format.  Read the words of the result
    2844                 :            :    in target word order in BUF.  There are always 32 bits in each
    2845                 :            :    long, no matter the size of the host long.  */
    2846                 :            : 
    2847                 :            : void
    2848                 :      86596 : real_from_target (REAL_VALUE_TYPE *r, const long *buf, format_helper fmt)
    2849                 :            : {
    2850                 :      86596 :   (*fmt->decode) (fmt, r, buf);
    2851                 :      86596 : }
    2852                 :            : 
    2853                 :            : /* Return the number of bits of the largest binary value that the
    2854                 :            :    significand of FMT will hold.  */
    2855                 :            : /* ??? Legacy.  Should get access to real_format directly.  */
    2856                 :            : 
    2857                 :            : int
    2858                 :      43766 : significand_size (format_helper fmt)
    2859                 :            : {
    2860                 :      43766 :   if (fmt == NULL)
    2861                 :            :     return 0;
    2862                 :            : 
    2863                 :      43766 :   if (fmt->b == 10)
    2864                 :            :     {
    2865                 :            :       /* Return the size in bits of the largest binary value that can be
    2866                 :            :          held by the decimal coefficient for this format.  This is one more
    2867                 :            :          than the number of bits required to hold the largest coefficient
    2868                 :            :          of this format.  */
    2869                 :       8910 :       double log2_10 = 3.3219281;
    2870                 :       8910 :       return fmt->p * log2_10;
    2871                 :            :     }
    2872                 :      34856 :   return fmt->p;
    2873                 :            : }
    2874                 :            : 
    2875                 :            : /* Return a hash value for the given real value.  */
    2876                 :            : /* ??? The "unsigned int" return value is intended to be hashval_t,
    2877                 :            :    but I didn't want to pull hashtab.h into real.h.  */
    2878                 :            : 
    2879                 :            : unsigned int
    2880                 :   24458100 : real_hash (const REAL_VALUE_TYPE *r)
    2881                 :            : {
    2882                 :   24458100 :   unsigned int h;
    2883                 :   24458100 :   size_t i;
    2884                 :            : 
    2885                 :   24458100 :   h = r->cl | (r->sign << 2);
    2886                 :   24458100 :   switch (r->cl)
    2887                 :            :     {
    2888                 :            :     case rvc_zero:
    2889                 :            :     case rvc_inf:
    2890                 :            :       return h;
    2891                 :            : 
    2892                 :   18148800 :     case rvc_normal:
    2893                 :   18148800 :       h |= (unsigned int)REAL_EXP (r) << 3;
    2894                 :   18148800 :       break;
    2895                 :            : 
    2896                 :     275355 :     case rvc_nan:
    2897                 :     275355 :       if (r->signalling)
    2898                 :        857 :         h ^= (unsigned int)-1;
    2899                 :     275355 :       if (r->canonical)
    2900                 :            :         return h;
    2901                 :            :       break;
    2902                 :            : 
    2903                 :          0 :     default:
    2904                 :          0 :       gcc_unreachable ();
    2905                 :            :     }
    2906                 :            : 
    2907                 :            :   if (sizeof (unsigned long) > sizeof (unsigned int))
    2908                 :   73173900 :     for (i = 0; i < SIGSZ; ++i)
    2909                 :            :       {
    2910                 :   54880400 :         unsigned long s = r->sig[i];
    2911                 :   54880400 :         h ^= s ^ (s >> (HOST_BITS_PER_LONG / 2));
    2912                 :            :       }
    2913                 :            :   else
    2914                 :            :     for (i = 0; i < SIGSZ; ++i)
    2915                 :            :       h ^= r->sig[i];
    2916                 :            : 
    2917                 :            :   return h;
    2918                 :            : }
    2919                 :            : 
    2920                 :            : /* IEEE single-precision format.  */
    2921                 :            : 
    2922                 :            : static void encode_ieee_single (const struct real_format *fmt,
    2923                 :            :                                 long *, const REAL_VALUE_TYPE *);
    2924                 :            : static void decode_ieee_single (const struct real_format *,
    2925                 :            :                                 REAL_VALUE_TYPE *, const long *);
    2926                 :            : 
    2927                 :            : static void
    2928                 :     220986 : encode_ieee_single (const struct real_format *fmt, long *buf,
    2929                 :            :                     const REAL_VALUE_TYPE *r)
    2930                 :            : {
    2931                 :     220986 :   unsigned long image, sig, exp;
    2932                 :     220986 :   unsigned long sign = r->sign;
    2933                 :     220986 :   bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
    2934                 :            : 
    2935                 :     220986 :   image = sign << 31;
    2936                 :     220986 :   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
    2937                 :            : 
    2938                 :     220986 :   switch (r->cl)
    2939                 :            :     {
    2940                 :            :     case rvc_zero:
    2941                 :            :       break;
    2942                 :            : 
    2943                 :       2425 :     case rvc_inf:
    2944                 :       2425 :       if (fmt->has_inf)
    2945                 :       2425 :         image |= 255 << 23;
    2946                 :            :       else
    2947                 :          0 :         image |= 0x7fffffff;
    2948                 :            :       break;
    2949                 :            : 
    2950                 :       5799 :     case rvc_nan:
    2951                 :       5799 :       if (fmt->has_nans)
    2952                 :            :         {
    2953                 :       5799 :           if (r->canonical)
    2954                 :       1118 :             sig = (fmt->canonical_nan_lsbs_set ? (1 << 22) - 1 : 0);
    2955                 :       5799 :           if (r->signalling == fmt->qnan_msb_set)
    2956                 :         26 :             sig &= ~(1 << 22);
    2957                 :            :           else
    2958                 :       5773 :             sig |= 1 << 22;
    2959                 :       5799 :           if (sig == 0)
    2960                 :         26 :             sig = 1 << 21;
    2961                 :            : 
    2962                 :       5799 :           image |= 255 << 23;
    2963                 :       5799 :           image |= sig;
    2964                 :            :         }
    2965                 :            :       else
    2966                 :          0 :         image |= 0x7fffffff;
    2967                 :            :       break;
    2968                 :            : 
    2969                 :     179080 :     case rvc_normal:
    2970                 :            :       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
    2971                 :            :          whereas the intermediate representation is 0.F x 2**exp.
    2972                 :            :          Which means we're off by one.  */
    2973                 :     179080 :       if (denormal)
    2974                 :            :         exp = 0;
    2975                 :            :       else
    2976                 :     177889 :       exp = REAL_EXP (r) + 127 - 1;
    2977                 :     179080 :       image |= exp << 23;
    2978                 :     179080 :       image |= sig;
    2979                 :     179080 :       break;
    2980                 :            : 
    2981                 :          0 :     default:
    2982                 :          0 :       gcc_unreachable ();
    2983                 :            :     }
    2984                 :            : 
    2985                 :     220986 :   buf[0] = image;
    2986                 :     220986 : }
    2987                 :            : 
    2988                 :            : static void
    2989                 :      42559 : decode_ieee_single (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    2990                 :            :                     const long *buf)
    2991                 :            : {
    2992                 :      42559 :   unsigned long image = buf[0] & 0xffffffff;
    2993                 :      42559 :   bool sign = (image >> 31) & 1;
    2994                 :      42559 :   int exp = (image >> 23) & 0xff;
    2995                 :            : 
    2996                 :      42559 :   memset (r, 0, sizeof (*r));
    2997                 :      42559 :   image <<= HOST_BITS_PER_LONG - 24;
    2998                 :      42559 :   image &= ~SIG_MSB;
    2999                 :            : 
    3000                 :      42559 :   if (exp == 0)
    3001                 :            :     {
    3002                 :      22964 :       if (image && fmt->has_denorm)
    3003                 :            :         {
    3004                 :        985 :           r->cl = rvc_normal;
    3005                 :        985 :           r->sign = sign;
    3006                 :        985 :           SET_REAL_EXP (r, -126);
    3007                 :        985 :           r->sig[SIGSZ-1] = image << 1;
    3008                 :        985 :           normalize (r);
    3009                 :            :         }
    3010                 :      21979 :       else if (fmt->has_signed_zero)
    3011                 :      21979 :         r->sign = sign;
    3012                 :            :     }
    3013                 :      19595 :   else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
    3014                 :            :     {
    3015                 :       8062 :       if (image)
    3016                 :            :         {
    3017                 :       7854 :           r->cl = rvc_nan;
    3018                 :       7854 :           r->sign = sign;
    3019                 :       7854 :           r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
    3020                 :       7854 :                            ^ fmt->qnan_msb_set);
    3021                 :       7854 :           r->sig[SIGSZ-1] = image;
    3022                 :            :         }
    3023                 :            :       else
    3024                 :            :         {
    3025                 :        208 :           r->cl = rvc_inf;
    3026                 :        208 :           r->sign = sign;
    3027                 :            :         }
    3028                 :            :     }
    3029                 :            :   else
    3030                 :            :     {
    3031                 :      11533 :       r->cl = rvc_normal;
    3032                 :      11533 :       r->sign = sign;
    3033                 :      11533 :       SET_REAL_EXP (r, exp - 127 + 1);
    3034                 :      11533 :       r->sig[SIGSZ-1] = image | SIG_MSB;
    3035                 :            :     }
    3036                 :      42559 : }
    3037                 :            : 
    3038                 :            : const struct real_format ieee_single_format =
    3039                 :            :   {
    3040                 :            :     encode_ieee_single,
    3041                 :            :     decode_ieee_single,
    3042                 :            :     2,
    3043                 :            :     24,
    3044                 :            :     24,
    3045                 :            :     -125,
    3046                 :            :     128,
    3047                 :            :     31,
    3048                 :            :     31,
    3049                 :            :     32,
    3050                 :            :     false,
    3051                 :            :     true,
    3052                 :            :     true,
    3053                 :            :     true,
    3054                 :            :     true,
    3055                 :            :     true,
    3056                 :            :     true,
    3057                 :            :     false,
    3058                 :            :     "ieee_single"
    3059                 :            :   };
    3060                 :            : 
    3061                 :            : const struct real_format mips_single_format =
    3062                 :            :   {
    3063                 :            :     encode_ieee_single,
    3064                 :            :     decode_ieee_single,
    3065                 :            :     2,
    3066                 :            :     24,
    3067                 :            :     24,
    3068                 :            :     -125,
    3069                 :            :     128,
    3070                 :            :     31,
    3071                 :            :     31,
    3072                 :            :     32,
    3073                 :            :     false,
    3074                 :            :     true,
    3075                 :            :     true,
    3076                 :            :     true,
    3077                 :            :     true,
    3078                 :            :     true,
    3079                 :            :     false,
    3080                 :            :     true,
    3081                 :            :     "mips_single"
    3082                 :            :   };
    3083                 :            : 
    3084                 :            : const struct real_format motorola_single_format =
    3085                 :            :   {
    3086                 :            :     encode_ieee_single,
    3087                 :            :     decode_ieee_single,
    3088                 :            :     2,
    3089                 :            :     24,
    3090                 :            :     24,
    3091                 :            :     -125,
    3092                 :            :     128,
    3093                 :            :     31,
    3094                 :            :     31,
    3095                 :            :     32,
    3096                 :            :     false,
    3097                 :            :     true,
    3098                 :            :     true,
    3099                 :            :     true,
    3100                 :            :     true,
    3101                 :            :     true,
    3102                 :            :     true,
    3103                 :            :     true,
    3104                 :            :     "motorola_single"
    3105                 :            :   };
    3106                 :            : 
    3107                 :            : /*  SPU Single Precision (Extended-Range Mode) format is the same as IEEE
    3108                 :            :     single precision with the following differences:
    3109                 :            :       - Infinities are not supported.  Instead MAX_FLOAT or MIN_FLOAT
    3110                 :            :         are generated.
    3111                 :            :       - NaNs are not supported.
    3112                 :            :       - The range of non-zero numbers in binary is
    3113                 :            :         (001)[1.]000...000 to (255)[1.]111...111.
    3114                 :            :       - Denormals can be represented, but are treated as +0.0 when
    3115                 :            :         used as an operand and are never generated as a result.
    3116                 :            :       - -0.0 can be represented, but a zero result is always +0.0.
    3117                 :            :       - the only supported rounding mode is trunction (towards zero).  */
    3118                 :            : const struct real_format spu_single_format =
    3119                 :            :   {
    3120                 :            :     encode_ieee_single,
    3121                 :            :     decode_ieee_single,
    3122                 :            :     2,
    3123                 :            :     24,
    3124                 :            :     24,
    3125                 :            :     -125,
    3126                 :            :     129,
    3127                 :            :     31,
    3128                 :            :     31,
    3129                 :            :     0,
    3130                 :            :     true,
    3131                 :            :     false,
    3132                 :            :     false,
    3133                 :            :     false,
    3134                 :            :     true,
    3135                 :            :     true,
    3136                 :            :     false,
    3137                 :            :     false,
    3138                 :            :     "spu_single"
    3139                 :            :   };
    3140                 :            : 
    3141                 :            : /* IEEE double-precision format.  */
    3142                 :            : 
    3143                 :            : static void encode_ieee_double (const struct real_format *fmt,
    3144                 :            :                                 long *, const REAL_VALUE_TYPE *);
    3145                 :            : static void decode_ieee_double (const struct real_format *,
    3146                 :            :                                 REAL_VALUE_TYPE *, const long *);
    3147                 :            : 
    3148                 :            : static void
    3149                 :     326489 : encode_ieee_double (const struct real_format *fmt, long *buf,
    3150                 :            :                     const REAL_VALUE_TYPE *r)
    3151                 :            : {
    3152                 :     326489 :   unsigned long image_lo, image_hi, sig_lo, sig_hi, exp;
    3153                 :     326489 :   bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
    3154                 :            : 
    3155                 :     326489 :   image_hi = r->sign << 31;
    3156                 :     326489 :   image_lo = 0;
    3157                 :            : 
    3158                 :     326489 :   if (HOST_BITS_PER_LONG == 64)
    3159                 :            :     {
    3160                 :     326489 :       sig_hi = r->sig[SIGSZ-1];
    3161                 :     326489 :       sig_lo = (sig_hi >> (64 - 53)) & 0xffffffff;
    3162                 :     326489 :       sig_hi = (sig_hi >> (64 - 53 + 1) >> 31) & 0xfffff;
    3163                 :            :     }
    3164                 :            :   else
    3165                 :            :     {
    3166                 :            :       sig_hi = r->sig[SIGSZ-1];
    3167                 :            :       sig_lo = r->sig[SIGSZ-2];
    3168                 :            :       sig_lo = (sig_hi << 21) | (sig_lo >> 11);
    3169                 :            :       sig_hi = (sig_hi >> 11) & 0xfffff;
    3170                 :            :     }
    3171                 :            : 
    3172                 :     326489 :   switch (r->cl)
    3173                 :            :     {
    3174                 :            :     case rvc_zero:
    3175                 :            :       break;
    3176                 :            : 
    3177                 :       2758 :     case rvc_inf:
    3178                 :       2758 :       if (fmt->has_inf)
    3179                 :       2758 :         image_hi |= 2047 << 20;
    3180                 :            :       else
    3181                 :            :         {
    3182                 :          0 :           image_hi |= 0x7fffffff;
    3183                 :          0 :           image_lo = 0xffffffff;
    3184                 :            :         }
    3185                 :            :       break;
    3186                 :            : 
    3187                 :       5572 :     case rvc_nan:
    3188                 :       5572 :       if (fmt->has_nans)
    3189                 :            :         {
    3190                 :       5572 :           if (r->canonical)
    3191                 :            :             {
    3192                 :       1329 :               if (fmt->canonical_nan_lsbs_set)
    3193                 :            :                 {
    3194                 :            :                   sig_hi = (1 << 19) - 1;
    3195                 :            :                   sig_lo = 0xffffffff;
    3196                 :            :                 }
    3197                 :            :               else
    3198                 :            :                 {
    3199                 :       1329 :                   sig_hi = 0;
    3200                 :       1329 :                   sig_lo = 0;
    3201                 :            :                 }
    3202                 :            :             }
    3203                 :       5572 :           if (r->signalling == fmt->qnan_msb_set)
    3204                 :         36 :             sig_hi &= ~(1 << 19);
    3205                 :            :           else
    3206                 :       5536 :             sig_hi |= 1 << 19;
    3207                 :       5572 :           if (sig_hi == 0 && sig_lo == 0)
    3208                 :         36 :             sig_hi = 1 << 18;
    3209                 :            : 
    3210                 :       5572 :           image_hi |= 2047 << 20;
    3211                 :       5572 :           image_hi |= sig_hi;
    3212                 :       5572 :           image_lo = sig_lo;
    3213                 :            :         }
    3214                 :            :       else
    3215                 :            :         {
    3216                 :          0 :           image_hi |= 0x7fffffff;
    3217                 :          0 :           image_lo = 0xffffffff;
    3218                 :            :         }
    3219                 :            :       break;
    3220                 :            : 
    3221                 :     246192 :     case rvc_normal:
    3222                 :            :       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
    3223                 :            :          whereas the intermediate representation is 0.F x 2**exp.
    3224                 :            :          Which means we're off by one.  */
    3225                 :     246192 :       if (denormal)
    3226                 :            :         exp = 0;
    3227                 :            :       else
    3228                 :     245127 :         exp = REAL_EXP (r) + 1023 - 1;
    3229                 :     246192 :       image_hi |= exp << 20;
    3230                 :     246192 :       image_hi |= sig_hi;
    3231                 :     246192 :       image_lo = sig_lo;
    3232                 :     246192 :       break;
    3233                 :            : 
    3234                 :          0 :     default:
    3235                 :          0 :       gcc_unreachable ();
    3236                 :            :     }
    3237                 :            : 
    3238                 :     326489 :   if (FLOAT_WORDS_BIG_ENDIAN)
    3239                 :            :     buf[0] = image_hi, buf[1] = image_lo;
    3240                 :            :   else
    3241                 :     326489 :     buf[0] = image_lo, buf[1] = image_hi;
    3242                 :     326489 : }
    3243                 :            : 
    3244                 :            : static void
    3245                 :      36427 : decode_ieee_double (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    3246                 :            :                     const long *buf)
    3247                 :            : {
    3248                 :      36427 :   unsigned long image_hi, image_lo;
    3249                 :      36427 :   bool sign;
    3250                 :      36427 :   int exp;
    3251                 :            : 
    3252                 :      36427 :   if (FLOAT_WORDS_BIG_ENDIAN)
    3253                 :            :     image_hi = buf[0], image_lo = buf[1];
    3254                 :            :   else
    3255                 :      36427 :     image_lo = buf[0], image_hi = buf[1];
    3256                 :      36427 :   image_lo &= 0xffffffff;
    3257                 :      36427 :   image_hi &= 0xffffffff;
    3258                 :            : 
    3259                 :      36427 :   sign = (image_hi >> 31) & 1;
    3260                 :      36427 :   exp = (image_hi >> 20) & 0x7ff;
    3261                 :            : 
    3262                 :      36427 :   memset (r, 0, sizeof (*r));
    3263                 :            : 
    3264                 :      36427 :   image_hi <<= 32 - 21;
    3265                 :      36427 :   image_hi |= image_lo >> 21;
    3266                 :      36427 :   image_hi &= 0x7fffffff;
    3267                 :      36427 :   image_lo <<= 32 - 21;
    3268                 :            : 
    3269                 :      36427 :   if (exp == 0)
    3270                 :            :     {
    3271                 :      22461 :       if ((image_hi || image_lo) && fmt->has_denorm)
    3272                 :            :         {
    3273                 :        639 :           r->cl = rvc_normal;
    3274                 :        639 :           r->sign = sign;
    3275                 :        639 :           SET_REAL_EXP (r, -1022);
    3276                 :        639 :           if (HOST_BITS_PER_LONG == 32)
    3277                 :            :             {
    3278                 :            :               image_hi = (image_hi << 1) | (image_lo >> 31);
    3279                 :            :               image_lo <<= 1;
    3280                 :            :               r->sig[SIGSZ-1] = image_hi;
    3281                 :            :               r->sig[SIGSZ-2] = image_lo;
    3282                 :            :             }
    3283                 :            :           else
    3284                 :            :             {
    3285                 :        639 :               image_hi = (image_hi << 31 << 2) | (image_lo << 1);
    3286                 :        639 :               r->sig[SIGSZ-1] = image_hi;
    3287                 :            :             }
    3288                 :        639 :           normalize (r);
    3289                 :            :         }
    3290                 :      21822 :       else if (fmt->has_signed_zero)
    3291                 :      21822 :         r->sign = sign;
    3292                 :            :     }
    3293                 :      13966 :   else if (exp == 2047 && (fmt->has_nans || fmt->has_inf))
    3294                 :            :     {
    3295                 :       9077 :       if (image_hi || image_lo)
    3296                 :            :         {
    3297                 :       7904 :           r->cl = rvc_nan;
    3298                 :       7904 :           r->sign = sign;
    3299                 :       7904 :           r->signalling = ((image_hi >> 30) & 1) ^ fmt->qnan_msb_set;
    3300                 :       7904 :           if (HOST_BITS_PER_LONG == 32)
    3301                 :            :             {
    3302                 :            :               r->sig[SIGSZ-1] = image_hi;
    3303                 :            :               r->sig[SIGSZ-2] = image_lo;
    3304                 :            :             }
    3305                 :            :           else
    3306                 :       7904 :             r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo;
    3307                 :            :         }
    3308                 :            :       else
    3309                 :            :         {
    3310                 :       1173 :           r->cl = rvc_inf;
    3311                 :       1173 :           r->sign = sign;
    3312                 :            :         }
    3313                 :            :     }
    3314                 :            :   else
    3315                 :            :     {
    3316                 :       4889 :       r->cl = rvc_normal;
    3317                 :       4889 :       r->sign = sign;
    3318                 :       4889 :       SET_REAL_EXP (r, exp - 1023 + 1);
    3319                 :       4889 :       if (HOST_BITS_PER_LONG == 32)
    3320                 :            :         {
    3321                 :            :           r->sig[SIGSZ-1] = image_hi | SIG_MSB;
    3322                 :            :           r->sig[SIGSZ-2] = image_lo;
    3323                 :            :         }
    3324                 :            :       else
    3325                 :       4889 :         r->sig[SIGSZ-1] = (image_hi << 31 << 1) | image_lo | SIG_MSB;
    3326                 :            :     }
    3327                 :      36427 : }
    3328                 :            : 
    3329                 :            : const struct real_format ieee_double_format =
    3330                 :            :   {
    3331                 :            :     encode_ieee_double,
    3332                 :            :     decode_ieee_double,
    3333                 :            :     2,
    3334                 :            :     53,
    3335                 :            :     53,
    3336                 :            :     -1021,
    3337                 :            :     1024,
    3338                 :            :     63,
    3339                 :            :     63,
    3340                 :            :     64,
    3341                 :            :     false,
    3342                 :            :     true,
    3343                 :            :     true,
    3344                 :            :     true,
    3345                 :            :     true,
    3346                 :            :     true,
    3347                 :            :     true,
    3348                 :            :     false,
    3349                 :            :     "ieee_double"
    3350                 :            :   };
    3351                 :            : 
    3352                 :            : const struct real_format mips_double_format =
    3353                 :            :   {
    3354                 :            :     encode_ieee_double,
    3355                 :            :     decode_ieee_double,
    3356                 :            :     2,
    3357                 :            :     53,
    3358                 :            :     53,
    3359                 :            :     -1021,
    3360                 :            :     1024,
    3361                 :            :     63,
    3362                 :            :     63,
    3363                 :            :     64,
    3364                 :            :     false,
    3365                 :            :     true,
    3366                 :            :     true,
    3367                 :            :     true,
    3368                 :            :     true,
    3369                 :            :     true,
    3370                 :            :     false,
    3371                 :            :     true,
    3372                 :            :     "mips_double"
    3373                 :            :   };
    3374                 :            : 
    3375                 :            : const struct real_format motorola_double_format =
    3376                 :            :   {
    3377                 :            :     encode_ieee_double,
    3378                 :            :     decode_ieee_double,
    3379                 :            :     2,
    3380                 :            :     53,
    3381                 :            :     53,
    3382                 :            :     -1021,
    3383                 :            :     1024,
    3384                 :            :     63,
    3385                 :            :     63,
    3386                 :            :     64,
    3387                 :            :     false,
    3388                 :            :     true,
    3389                 :            :     true,
    3390                 :            :     true,
    3391                 :            :     true,
    3392                 :            :     true,
    3393                 :            :     true,
    3394                 :            :     true,
    3395                 :            :     "motorola_double"
    3396                 :            :   };
    3397                 :            : 
    3398                 :            : /* IEEE extended real format.  This comes in three flavors: Intel's as
    3399                 :            :    a 12 byte image, Intel's as a 16 byte image, and Motorola's.  Intel
    3400                 :            :    12- and 16-byte images may be big- or little endian; Motorola's is
    3401                 :            :    always big endian.  */
    3402                 :            : 
    3403                 :            : /* Helper subroutine which converts from the internal format to the
    3404                 :            :    12-byte little-endian Intel format.  Functions below adjust this
    3405                 :            :    for the other possible formats.  */
    3406                 :            : static void
    3407                 :      40494 : encode_ieee_extended (const struct real_format *fmt, long *buf,
    3408                 :            :                       const REAL_VALUE_TYPE *r)
    3409                 :            : {
    3410                 :      40494 :   unsigned long image_hi, sig_hi, sig_lo;
    3411                 :      40494 :   bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
    3412                 :            : 
    3413                 :      40494 :   image_hi = r->sign << 15;
    3414                 :      40494 :   sig_hi = sig_lo = 0;
    3415                 :            : 
    3416                 :      40494 :   switch (r->cl)
    3417                 :            :     {
    3418                 :            :     case rvc_zero:
    3419                 :            :       break;
    3420                 :            : 
    3421                 :        864 :     case rvc_inf:
    3422                 :        864 :       if (fmt->has_inf)
    3423                 :            :         {
    3424                 :        864 :           image_hi |= 32767;
    3425                 :            : 
    3426                 :            :           /* Intel requires the explicit integer bit to be set, otherwise
    3427                 :            :              it considers the value a "pseudo-infinity".  Motorola docs
    3428                 :            :              say it doesn't care.  */
    3429                 :        864 :           sig_hi = 0x80000000;
    3430                 :            :         }
    3431                 :            :       else
    3432                 :            :         {
    3433                 :          0 :           image_hi |= 32767;
    3434                 :          0 :           sig_lo = sig_hi = 0xffffffff;
    3435                 :            :         }
    3436                 :            :       break;
    3437                 :            : 
    3438                 :        674 :     case rvc_nan:
    3439                 :        674 :       if (fmt->has_nans)
    3440                 :            :         {
    3441                 :        674 :           image_hi |= 32767;
    3442                 :        674 :           if (r->canonical)
    3443                 :            :             {
    3444                 :        644 :               if (fmt->canonical_nan_lsbs_set)
    3445                 :            :                 {
    3446                 :          0 :                   sig_hi = (1 << 30) - 1;
    3447                 :          0 :                   sig_lo = 0xffffffff;
    3448                 :            :                 }
    3449                 :            :             }
    3450                 :         30 :           else if (HOST_BITS_PER_LONG == 32)
    3451                 :            :             {
    3452                 :            :               sig_hi = r->sig[SIGSZ-1];
    3453                 :            :               sig_lo = r->sig[SIGSZ-2];
    3454                 :            :             }
    3455                 :            :           else
    3456                 :            :             {
    3457                 :         30 :               sig_lo = r->sig[SIGSZ-1];
    3458                 :         30 :               sig_hi = sig_lo >> 31 >> 1;
    3459                 :         30 :               sig_lo &= 0xffffffff;
    3460                 :            :             }
    3461                 :        674 :           if (r->signalling == fmt->qnan_msb_set)
    3462                 :         24 :             sig_hi &= ~(1 << 30);
    3463                 :            :           else
    3464                 :        650 :             sig_hi |= 1 << 30;
    3465                 :        674 :           if ((sig_hi & 0x7fffffff) == 0 && sig_lo == 0)
    3466                 :         24 :             sig_hi = 1 << 29;
    3467                 :            : 
    3468                 :            :           /* Intel requires the explicit integer bit to be set, otherwise
    3469                 :            :              it considers the value a "pseudo-nan".  Motorola docs say it
    3470                 :            :              doesn't care.  */
    3471                 :        674 :           sig_hi |= 0x80000000;
    3472                 :            :         }
    3473                 :            :       else
    3474                 :            :         {
    3475                 :          0 :           image_hi |= 32767;
    3476                 :          0 :           sig_lo = sig_hi = 0xffffffff;
    3477                 :            :         }
    3478                 :            :       break;
    3479                 :            : 
    3480                 :      30378 :     case rvc_normal:
    3481                 :      30378 :       {
    3482                 :      30378 :         int exp = REAL_EXP (r);
    3483                 :            : 
    3484                 :            :         /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
    3485                 :            :            whereas the intermediate representation is 0.F x 2**exp.
    3486                 :            :            Which means we're off by one.
    3487                 :            : 
    3488                 :            :            Except for Motorola, which consider exp=0 and explicit
    3489                 :            :            integer bit set to continue to be normalized.  In theory
    3490                 :            :            this discrepancy has been taken care of by the difference
    3491                 :            :            in fmt->emin in round_for_format.  */
    3492                 :            : 
    3493                 :      30378 :         if (denormal)
    3494                 :            :           exp = 0;
    3495                 :            :         else
    3496                 :            :           {
    3497                 :      30254 :             exp += 16383 - 1;
    3498                 :      30254 :             gcc_assert (exp >= 0);
    3499                 :            :           }
    3500                 :      30378 :         image_hi |= exp;
    3501                 :            : 
    3502                 :      30378 :         if (HOST_BITS_PER_LONG == 32)
    3503                 :            :           {
    3504                 :            :             sig_hi = r->sig[SIGSZ-1];
    3505                 :            :             sig_lo = r->sig[SIGSZ-2];
    3506                 :            :           }
    3507                 :            :         else
    3508                 :            :           {
    3509                 :      30378 :             sig_lo = r->sig[SIGSZ-1];
    3510                 :      30378 :             sig_hi = sig_lo >> 31 >> 1;
    3511                 :      30378 :             sig_lo &= 0xffffffff;
    3512                 :            :           }
    3513                 :            :       }
    3514                 :            :       break;
    3515                 :            : 
    3516                 :          0 :     default:
    3517                 :          0 :       gcc_unreachable ();
    3518                 :            :     }
    3519                 :            : 
    3520                 :      40494 :   buf[0] = sig_lo, buf[1] = sig_hi, buf[2] = image_hi;
    3521                 :      40494 : }
    3522                 :            : 
    3523                 :            : /* Convert from the internal format to the 12-byte Motorola format
    3524                 :            :    for an IEEE extended real.  */
    3525                 :            : static void
    3526                 :          0 : encode_ieee_extended_motorola (const struct real_format *fmt, long *buf,
    3527                 :            :                                const REAL_VALUE_TYPE *r)
    3528                 :            : {
    3529                 :          0 :   long intermed[3];
    3530                 :          0 :   encode_ieee_extended (fmt, intermed, r);
    3531                 :            : 
    3532                 :          0 :   if (r->cl == rvc_inf)
    3533                 :            :     /* For infinity clear the explicit integer bit again, so that the
    3534                 :            :        format matches the canonical infinity generated by the FPU.  */
    3535                 :          0 :     intermed[1] = 0;
    3536                 :            : 
    3537                 :            :   /* Motorola chips are assumed always to be big-endian.  Also, the
    3538                 :            :      padding in a Motorola extended real goes between the exponent and
    3539                 :            :      the mantissa.  At this point the mantissa is entirely within
    3540                 :            :      elements 0 and 1 of intermed, and the exponent entirely within
    3541                 :            :      element 2, so all we have to do is swap the order around, and
    3542                 :            :      shift element 2 left 16 bits.  */
    3543                 :          0 :   buf[0] = intermed[2] << 16;
    3544                 :          0 :   buf[1] = intermed[1];
    3545                 :          0 :   buf[2] = intermed[0];
    3546                 :          0 : }
    3547                 :            : 
    3548                 :            : /* Convert from the internal format to the 12-byte Intel format for
    3549                 :            :    an IEEE extended real.  */
    3550                 :            : static void
    3551                 :      40494 : encode_ieee_extended_intel_96 (const struct real_format *fmt, long *buf,
    3552                 :            :                                const REAL_VALUE_TYPE *r)
    3553                 :            : {
    3554                 :      40494 :   if (FLOAT_WORDS_BIG_ENDIAN)
    3555                 :            :     {
    3556                 :            :       /* All the padding in an Intel-format extended real goes at the high
    3557                 :            :          end, which in this case is after the mantissa, not the exponent.
    3558                 :            :          Therefore we must shift everything down 16 bits.  */
    3559                 :            :       long intermed[3];
    3560                 :            :       encode_ieee_extended (fmt, intermed, r);
    3561                 :            :       buf[0] = ((intermed[2] << 16) | ((unsigned long)(intermed[1] & 0xFFFF0000) >> 16));
    3562                 :            :       buf[1] = ((intermed[1] << 16) | ((unsigned long)(intermed[0] & 0xFFFF0000) >> 16));
    3563                 :            :       buf[2] =  (intermed[0] << 16);
    3564                 :            :     }
    3565                 :            :   else
    3566                 :            :     /* encode_ieee_extended produces what we want directly.  */
    3567                 :       2658 :     encode_ieee_extended (fmt, buf, r);
    3568                 :       2658 : }
    3569                 :            : 
    3570                 :            : /* Convert from the internal format to the 16-byte Intel format for
    3571                 :            :    an IEEE extended real.  */
    3572                 :            : static void
    3573                 :      37836 : encode_ieee_extended_intel_128 (const struct real_format *fmt, long *buf,
    3574                 :            :                                 const REAL_VALUE_TYPE *r)
    3575                 :            : {
    3576                 :            :   /* All the padding in an Intel-format extended real goes at the high end.  */
    3577                 :      37836 :   encode_ieee_extended_intel_96 (fmt, buf, r);
    3578                 :      37836 :   buf[3] = 0;
    3579                 :      37836 : }
    3580                 :            : 
    3581                 :            : /* As above, we have a helper function which converts from 12-byte
    3582                 :            :    little-endian Intel format to internal format.  Functions below
    3583                 :            :    adjust for the other possible formats.  */
    3584                 :            : static void
    3585                 :        239 : decode_ieee_extended (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    3586                 :            :                       const long *buf)
    3587                 :            : {
    3588                 :        239 :   unsigned long image_hi, sig_hi, sig_lo;
    3589                 :        239 :   bool sign;
    3590                 :        239 :   int exp;
    3591                 :            : 
    3592                 :        239 :   sig_lo = buf[0], sig_hi = buf[1], image_hi = buf[2];
    3593                 :        239 :   sig_lo &= 0xffffffff;
    3594                 :        239 :   sig_hi &= 0xffffffff;
    3595                 :        239 :   image_hi &= 0xffffffff;
    3596                 :            : 
    3597                 :        239 :   sign = (image_hi >> 15) & 1;
    3598                 :        239 :   exp = image_hi & 0x7fff;
    3599                 :            : 
    3600                 :        239 :   memset (r, 0, sizeof (*r));
    3601                 :            : 
    3602                 :        239 :   if (exp == 0)
    3603                 :            :     {
    3604                 :         39 :       if ((sig_hi || sig_lo) && fmt->has_denorm)
    3605                 :            :         {
    3606                 :          0 :           r->cl = rvc_normal;
    3607                 :          0 :           r->sign = sign;
    3608                 :            : 
    3609                 :            :           /* When the IEEE format contains a hidden bit, we know that
    3610                 :            :              it's zero at this point, and so shift up the significand
    3611                 :            :              and decrease the exponent to match.  In this case, Motorola
    3612                 :            :              defines the explicit integer bit to be valid, so we don't
    3613                 :            :              know whether the msb is set or not.  */
    3614                 :          0 :           SET_REAL_EXP (r, fmt->emin);
    3615                 :          0 :           if (HOST_BITS_PER_LONG == 32)
    3616                 :            :             {
    3617                 :            :               r->sig[SIGSZ-1] = sig_hi;
    3618                 :            :               r->sig[SIGSZ-2] = sig_lo;
    3619                 :            :             }
    3620                 :            :           else
    3621                 :          0 :             r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
    3622                 :            : 
    3623                 :          0 :           normalize (r);
    3624                 :            :         }
    3625                 :         39 :       else if (fmt->has_signed_zero)
    3626                 :         39 :         r->sign = sign;
    3627                 :            :     }
    3628                 :        200 :   else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
    3629                 :            :     {
    3630                 :            :       /* See above re "pseudo-infinities" and "pseudo-nans".
    3631                 :            :          Short summary is that the MSB will likely always be
    3632                 :            :          set, and that we don't care about it.  */
    3633                 :         50 :       sig_hi &= 0x7fffffff;
    3634                 :            : 
    3635                 :         50 :       if (sig_hi || sig_lo)
    3636                 :            :         {
    3637                 :         18 :           r->cl = rvc_nan;
    3638                 :         18 :           r->sign = sign;
    3639                 :         18 :           r->signalling = ((sig_hi >> 30) & 1) ^ fmt->qnan_msb_set;
    3640                 :         18 :           if (HOST_BITS_PER_LONG == 32)
    3641                 :            :             {
    3642                 :            :               r->sig[SIGSZ-1] = sig_hi;
    3643                 :            :               r->sig[SIGSZ-2] = sig_lo;
    3644                 :            :             }
    3645                 :            :           else
    3646                 :         18 :             r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
    3647                 :            :         }
    3648                 :            :       else
    3649                 :            :         {
    3650                 :         32 :           r->cl = rvc_inf;
    3651                 :         32 :           r->sign = sign;
    3652                 :            :         }
    3653                 :            :     }
    3654                 :            :   else
    3655                 :            :     {
    3656                 :        150 :       r->cl = rvc_normal;
    3657                 :        150 :       r->sign = sign;
    3658                 :        150 :       SET_REAL_EXP (r, exp - 16383 + 1);
    3659                 :        150 :       if (HOST_BITS_PER_LONG == 32)
    3660                 :            :         {
    3661                 :            :           r->sig[SIGSZ-1] = sig_hi;
    3662                 :            :           r->sig[SIGSZ-2] = sig_lo;
    3663                 :            :         }
    3664                 :            :       else
    3665                 :        150 :         r->sig[SIGSZ-1] = (sig_hi << 31 << 1) | sig_lo;
    3666                 :            :     }
    3667                 :        239 : }
    3668                 :            : 
    3669                 :            : /* Convert from the internal format to the 12-byte Motorola format
    3670                 :            :    for an IEEE extended real.  */
    3671                 :            : static void
    3672                 :          0 : decode_ieee_extended_motorola (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    3673                 :            :                                const long *buf)
    3674                 :            : {
    3675                 :          0 :   long intermed[3];
    3676                 :            : 
    3677                 :            :   /* Motorola chips are assumed always to be big-endian.  Also, the
    3678                 :            :      padding in a Motorola extended real goes between the exponent and
    3679                 :            :      the mantissa; remove it.  */
    3680                 :          0 :   intermed[0] = buf[2];
    3681                 :          0 :   intermed[1] = buf[1];
    3682                 :          0 :   intermed[2] = (unsigned long)buf[0] >> 16;
    3683                 :            : 
    3684                 :          0 :   decode_ieee_extended (fmt, r, intermed);
    3685                 :          0 : }
    3686                 :            : 
    3687                 :            : /* Convert from the internal format to the 12-byte Intel format for
    3688                 :            :    an IEEE extended real.  */
    3689                 :            : static void
    3690                 :        239 : decode_ieee_extended_intel_96 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    3691                 :            :                                const long *buf)
    3692                 :            : {
    3693                 :        239 :   if (FLOAT_WORDS_BIG_ENDIAN)
    3694                 :            :     {
    3695                 :            :       /* All the padding in an Intel-format extended real goes at the high
    3696                 :            :          end, which in this case is after the mantissa, not the exponent.
    3697                 :            :          Therefore we must shift everything up 16 bits.  */
    3698                 :            :       long intermed[3];
    3699                 :            : 
    3700                 :            :       intermed[0] = (((unsigned long)buf[2] >> 16) | (buf[1] << 16));
    3701                 :            :       intermed[1] = (((unsigned long)buf[1] >> 16) | (buf[0] << 16));
    3702                 :            :       intermed[2] =  ((unsigned long)buf[0] >> 16);
    3703                 :            : 
    3704                 :            :       decode_ieee_extended (fmt, r, intermed);
    3705                 :            :     }
    3706                 :            :   else
    3707                 :            :     /* decode_ieee_extended produces what we want directly.  */
    3708                 :          0 :     decode_ieee_extended (fmt, r, buf);
    3709                 :          0 : }
    3710                 :            : 
    3711                 :            : /* Convert from the internal format to the 16-byte Intel format for
    3712                 :            :    an IEEE extended real.  */
    3713                 :            : static void
    3714                 :        239 : decode_ieee_extended_intel_128 (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    3715                 :            :                                 const long *buf)
    3716                 :            : {
    3717                 :            :   /* All the padding in an Intel-format extended real goes at the high end.  */
    3718                 :        239 :   decode_ieee_extended_intel_96 (fmt, r, buf);
    3719                 :        239 : }
    3720                 :            : 
    3721                 :            : const struct real_format ieee_extended_motorola_format =
    3722                 :            :   {
    3723                 :            :     encode_ieee_extended_motorola,
    3724                 :            :     decode_ieee_extended_motorola,
    3725                 :            :     2,
    3726                 :            :     64,
    3727                 :            :     64,
    3728                 :            :     -16382,
    3729                 :            :     16384,
    3730                 :            :     95,
    3731                 :            :     95,
    3732                 :            :     0,
    3733                 :            :     false,
    3734                 :            :     true,
    3735                 :            :     true,
    3736                 :            :     true,
    3737                 :            :     true,
    3738                 :            :     true,
    3739                 :            :     true,
    3740                 :            :     true,
    3741                 :            :     "ieee_extended_motorola"
    3742                 :            :   };
    3743                 :            : 
    3744                 :            : const struct real_format ieee_extended_intel_96_format =
    3745                 :            :   {
    3746                 :            :     encode_ieee_extended_intel_96,
    3747                 :            :     decode_ieee_extended_intel_96,
    3748                 :            :     2,
    3749                 :            :     64,
    3750                 :            :     64,
    3751                 :            :     -16381,
    3752                 :            :     16384,
    3753                 :            :     79,
    3754                 :            :     79,
    3755                 :            :     65,
    3756                 :            :     false,
    3757                 :            :     true,
    3758                 :            :     true,
    3759                 :            :     true,
    3760                 :            :     true,
    3761                 :            :     true,
    3762                 :            :     true,
    3763                 :            :     false,
    3764                 :            :     "ieee_extended_intel_96"
    3765                 :            :   };
    3766                 :            : 
    3767                 :            : const struct real_format ieee_extended_intel_128_format =
    3768                 :            :   {
    3769                 :            :     encode_ieee_extended_intel_128,
    3770                 :            :     decode_ieee_extended_intel_128,
    3771                 :            :     2,
    3772                 :            :     64,
    3773                 :            :     64,
    3774                 :            :     -16381,
    3775                 :            :     16384,
    3776                 :            :     79,
    3777                 :            :     79,
    3778                 :            :     65,
    3779                 :            :     false,
    3780                 :            :     true,
    3781                 :            :     true,
    3782                 :            :     true,
    3783                 :            :     true,
    3784                 :            :     true,
    3785                 :            :     true,
    3786                 :            :     false,
    3787                 :            :     "ieee_extended_intel_128"
    3788                 :            :   };
    3789                 :            : 
    3790                 :            : /* The following caters to i386 systems that set the rounding precision
    3791                 :            :    to 53 bits instead of 64, e.g. FreeBSD.  */
    3792                 :            : const struct real_format ieee_extended_intel_96_round_53_format =
    3793                 :            :   {
    3794                 :            :     encode_ieee_extended_intel_96,
    3795                 :            :     decode_ieee_extended_intel_96,
    3796                 :            :     2,
    3797                 :            :     53,
    3798                 :            :     53,
    3799                 :            :     -16381,
    3800                 :            :     16384,
    3801                 :            :     79,
    3802                 :            :     79,
    3803                 :            :     33,
    3804                 :            :     false,
    3805                 :            :     true,
    3806                 :            :     true,
    3807                 :            :     true,
    3808                 :            :     true,
    3809                 :            :     true,
    3810                 :            :     true,
    3811                 :            :     false,
    3812                 :            :     "ieee_extended_intel_96_round_53"
    3813                 :            :   };
    3814                 :            : 
    3815                 :            : /* IBM 128-bit extended precision format: a pair of IEEE double precision
    3816                 :            :    numbers whose sum is equal to the extended precision value.  The number
    3817                 :            :    with greater magnitude is first.  This format has the same magnitude
    3818                 :            :    range as an IEEE double precision value, but effectively 106 bits of
    3819                 :            :    significand precision.  Infinity and NaN are represented by their IEEE
    3820                 :            :    double precision value stored in the first number, the second number is
    3821                 :            :    +0.0 or -0.0 for Infinity and don't-care for NaN.  */
    3822                 :            : 
    3823                 :            : static void encode_ibm_extended (const struct real_format *fmt,
    3824                 :            :                                  long *, const REAL_VALUE_TYPE *);
    3825                 :            : static void decode_ibm_extended (const struct real_format *,
    3826                 :            :                                  REAL_VALUE_TYPE *, const long *);
    3827                 :            : 
    3828                 :            : static void
    3829                 :          0 : encode_ibm_extended (const struct real_format *fmt, long *buf,
    3830                 :            :                      const REAL_VALUE_TYPE *r)
    3831                 :            : {
    3832                 :          0 :   REAL_VALUE_TYPE u, normr, v;
    3833                 :          0 :   const struct real_format *base_fmt;
    3834                 :            : 
    3835                 :          0 :   base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
    3836                 :            : 
    3837                 :            :   /* Renormalize R before doing any arithmetic on it.  */
    3838                 :          0 :   normr = *r;
    3839                 :          0 :   if (normr.cl == rvc_normal)
    3840                 :          0 :     normalize (&normr);
    3841                 :            : 
    3842                 :            :   /* u = IEEE double precision portion of significand.  */
    3843                 :          0 :   u = normr;
    3844                 :          0 :   round_for_format (base_fmt, &u);
    3845                 :          0 :   encode_ieee_double (base_fmt, &buf[0], &u);
    3846                 :            : 
    3847                 :          0 :   if (u.cl == rvc_normal)
    3848                 :            :     {
    3849                 :          0 :       do_add (&v, &normr, &u, 1);
    3850                 :            :       /* Call round_for_format since we might need to denormalize.  */
    3851                 :          0 :       round_for_format (base_fmt, &v);
    3852                 :          0 :       encode_ieee_double (base_fmt, &buf[2], &v);
    3853                 :            :     }
    3854                 :            :   else
    3855                 :            :     {
    3856                 :            :       /* Inf, NaN, 0 are all representable as doubles, so the
    3857                 :            :          least-significant part can be 0.0.  */
    3858                 :          0 :       buf[2] = 0;
    3859                 :          0 :       buf[3] = 0;
    3860                 :            :     }
    3861                 :          0 : }
    3862                 :            : 
    3863                 :            : static void
    3864                 :          0 : decode_ibm_extended (const struct real_format *fmt ATTRIBUTE_UNUSED, REAL_VALUE_TYPE *r,
    3865                 :            :                      const long *buf)
    3866                 :            : {
    3867                 :          0 :   REAL_VALUE_TYPE u, v;
    3868                 :          0 :   const struct real_format *base_fmt;
    3869                 :            : 
    3870                 :          0 :   base_fmt = fmt->qnan_msb_set ? &ieee_double_format : &mips_double_format;
    3871                 :          0 :   decode_ieee_double (base_fmt, &u, &buf[0]);
    3872                 :            : 
    3873                 :          0 :   if (u.cl != rvc_zero && u.cl != rvc_inf && u.cl != rvc_nan)
    3874                 :            :     {
    3875                 :          0 :       decode_ieee_double (base_fmt, &v, &buf[2]);
    3876                 :          0 :       do_add (r, &u, &v, 0);
    3877                 :            :     }
    3878                 :            :   else
    3879                 :          0 :     *r = u;
    3880                 :          0 : }
    3881                 :            : 
    3882                 :            : const struct real_format ibm_extended_format =
    3883                 :            :   {
    3884                 :            :     encode_ibm_extended,
    3885                 :            :     decode_ibm_extended,
    3886                 :            :     2,
    3887                 :            :     53 + 53,
    3888                 :            :     53,
    3889                 :            :     -1021 + 53,
    3890                 :            :     1024,
    3891                 :            :     127,
    3892                 :            :     -1,
    3893                 :            :     0,
    3894                 :            :     false,
    3895                 :            :     true,
    3896                 :            :     true,
    3897                 :            :     true,
    3898                 :            :     true,
    3899                 :            :     true,
    3900                 :            :     true,
    3901                 :            :     false,
    3902                 :            :     "ibm_extended"
    3903                 :            :   };
    3904                 :            : 
    3905                 :            : const struct real_format mips_extended_format =
    3906                 :            :   {
    3907                 :            :     encode_ibm_extended,
    3908                 :            :     decode_ibm_extended,
    3909                 :            :     2,
    3910                 :            :     53 + 53,
    3911                 :            :     53,
    3912                 :            :     -1021 + 53,
    3913                 :            :     1024,
    3914                 :            :     127,
    3915                 :            :     -1,
    3916                 :            :     0,
    3917                 :            :     false,
    3918                 :            :     true,
    3919                 :            :     true,
    3920                 :            :     true,
    3921                 :            :     true,
    3922                 :            :     true,
    3923                 :            :     false,
    3924                 :            :     true,
    3925                 :            :     "mips_extended"
    3926                 :            :   };
    3927                 :            : 
    3928                 :            : 
    3929                 :            : /* IEEE quad precision format.  */
    3930                 :            : 
    3931                 :            : static void encode_ieee_quad (const struct real_format *fmt,
    3932                 :            :                               long *, const REAL_VALUE_TYPE *);
    3933                 :            : static void decode_ieee_quad (const struct real_format *,
    3934                 :            :                               REAL_VALUE_TYPE *, const long *);
    3935                 :            : 
    3936                 :            : static void
    3937                 :     159909 : encode_ieee_quad (const struct real_format *fmt, long *buf,
    3938                 :            :                   const REAL_VALUE_TYPE *r)
    3939                 :            : {
    3940                 :     159909 :   unsigned long image3, image2, image1, image0, exp;
    3941                 :     159909 :   bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
    3942                 :     159909 :   REAL_VALUE_TYPE u;
    3943                 :            : 
    3944                 :     159909 :   image3 = r->sign << 31;
    3945                 :     159909 :   image2 = 0;
    3946                 :     159909 :   image1 = 0;
    3947                 :     159909 :   image0 = 0;
    3948                 :            : 
    3949                 :     159909 :   rshift_significand (&u, r, SIGNIFICAND_BITS - 113);
    3950                 :            : 
    3951                 :     159909 :   switch (r->cl)
    3952                 :            :     {
    3953                 :            :     case rvc_zero:
    3954                 :            :       break;
    3955                 :            : 
    3956                 :        375 :     case rvc_inf:
    3957                 :        375 :       if (fmt->has_inf)
    3958                 :        375 :         image3 |= 32767 << 16;
    3959                 :            :       else
    3960                 :            :         {
    3961                 :          0 :           image3 |= 0x7fffffff;
    3962                 :          0 :           image2 = 0xffffffff;
    3963                 :          0 :           image1 = 0xffffffff;
    3964                 :          0 :           image0 = 0xffffffff;
    3965                 :            :         }
    3966                 :            :       break;
    3967                 :            : 
    3968                 :        398 :     case rvc_nan:
    3969                 :        398 :       if (fmt->has_nans)
    3970                 :            :         {
    3971                 :        398 :           image3 |= 32767 << 16;
    3972                 :            : 
    3973                 :        398 :           if (r->canonical)
    3974                 :            :             {
    3975                 :        176 :               if (fmt->canonical_nan_lsbs_set)
    3976                 :            :                 {
    3977                 :          0 :                   image3 |= 0x7fff;
    3978                 :          0 :                   image2 = image1 = image0 = 0xffffffff;
    3979                 :            :                 }
    3980                 :            :             }
    3981                 :        222 :           else if (HOST_BITS_PER_LONG == 32)
    3982                 :            :             {
    3983                 :            :               image0 = u.sig[0];
    3984                 :            :               image1 = u.sig[1];
    3985                 :            :               image2 = u.sig[2];
    3986                 :            :               image3 |= u.sig[3] & 0xffff;
    3987                 :            :             }
    3988                 :            :           else
    3989                 :            :             {
    3990                 :        222 :               image0 = u.sig[0];
    3991                 :        222 :               image1 = image0 >> 31 >> 1;
    3992                 :        222 :               image2 = u.sig[1];
    3993                 :        222 :               image3 |= (image2 >> 31 >> 1) & 0xffff;
    3994                 :        222 :               image0 &= 0xffffffff;
    3995                 :        222 :               image2 &= 0xffffffff;
    3996                 :            :             }
    3997                 :        398 :           if (r->signalling == fmt->qnan_msb_set)
    3998                 :         46 :             image3 &= ~0x8000;
    3999                 :            :           else
    4000                 :        352 :             image3 |= 0x8000;
    4001                 :        398 :           if (((image3 & 0xffff) | image2 | image1 | image0) == 0)
    4002                 :         36 :             image3 |= 0x4000;
    4003                 :            :         }
    4004                 :            :       else
    4005                 :            :         {
    4006                 :          0 :           image3 |= 0x7fffffff;
    4007                 :          0 :           image2 = 0xffffffff;
    4008                 :          0 :           image1 = 0xffffffff;
    4009                 :          0 :           image0 = 0xffffffff;
    4010                 :            :         }
    4011                 :            :       break;
    4012                 :            : 
    4013                 :      46280 :     case rvc_normal:
    4014                 :            :       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
    4015                 :            :          whereas the intermediate representation is 0.F x 2**exp.
    4016                 :            :          Which means we're off by one.  */
    4017                 :      46280 :       if (denormal)
    4018                 :            :         exp = 0;
    4019                 :            :       else
    4020                 :      46000 :         exp = REAL_EXP (r) + 16383 - 1;
    4021                 :      46280 :       image3 |= exp << 16;
    4022                 :            : 
    4023                 :      46280 :       if (HOST_BITS_PER_LONG == 32)
    4024                 :            :         {
    4025                 :            :           image0 = u.sig[0];
    4026                 :            :           image1 = u.sig[1];
    4027                 :            :           image2 = u.sig[2];
    4028                 :            :           image3 |= u.sig[3] & 0xffff;
    4029                 :            :         }
    4030                 :            :       else
    4031                 :            :         {
    4032                 :      46280 :           image0 = u.sig[0];
    4033                 :      46280 :           image1 = image0 >> 31 >> 1;
    4034                 :      46280 :           image2 = u.sig[1];
    4035                 :      46280 :           image3 |= (image2 >> 31 >> 1) & 0xffff;
    4036                 :      46280 :           image0 &= 0xffffffff;
    4037                 :      46280 :           image2 &= 0xffffffff;
    4038                 :            :         }
    4039                 :            :       break;
    4040                 :            : 
    4041                 :          0 :     default:
    4042                 :          0 :       gcc_unreachable ();
    4043                 :            :     }
    4044                 :            : 
    4045                 :     159909 :   if (FLOAT_WORDS_BIG_ENDIAN)
    4046                 :            :     {
    4047                 :            :       buf[0] = image3;
    4048                 :            :       buf[1] = image2;
    4049                 :            :       buf[2] = image1;
    4050                 :            :       buf[3] = image0;
    4051                 :            :     }
    4052                 :            :   else
    4053                 :            :     {
    4054                 :     159909 :       buf[0] = image0;
    4055                 :     159909 :       buf[1] = image1;
    4056                 :     159909 :       buf[2] = image2;
    4057                 :     159909 :       buf[3] = image3;
    4058                 :            :     }
    4059                 :     159909 : }
    4060                 :            : 
    4061                 :            : static void
    4062                 :       1914 : decode_ieee_quad (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    4063                 :            :                   const long *buf)
    4064                 :            : {
    4065                 :       1914 :   unsigned long image3, image2, image1, image0;
    4066                 :       1914 :   bool sign;
    4067                 :       1914 :   int exp;
    4068                 :            : 
    4069                 :       1914 :   if (FLOAT_WORDS_BIG_ENDIAN)
    4070                 :            :     {
    4071                 :            :       image3 = buf[0];
    4072                 :            :       image2 = buf[1];
    4073                 :            :       image1 = buf[2];
    4074                 :            :       image0 = buf[3];
    4075                 :            :     }
    4076                 :            :   else
    4077                 :            :     {
    4078                 :       1914 :       image0 = buf[0];
    4079                 :       1914 :       image1 = buf[1];
    4080                 :       1914 :       image2 = buf[2];
    4081                 :       1914 :       image3 = buf[3];
    4082                 :            :     }
    4083                 :       1914 :   image0 &= 0xffffffff;
    4084                 :       1914 :   image1 &= 0xffffffff;
    4085                 :       1914 :   image2 &= 0xffffffff;
    4086                 :            : 
    4087                 :       1914 :   sign = (image3 >> 31) & 1;
    4088                 :       1914 :   exp = (image3 >> 16) & 0x7fff;
    4089                 :       1914 :   image3 &= 0xffff;
    4090                 :            : 
    4091                 :       1914 :   memset (r, 0, sizeof (*r));
    4092                 :            : 
    4093                 :       1914 :   if (exp == 0)
    4094                 :            :     {
    4095                 :        920 :       if ((image3 | image2 | image1 | image0) && fmt->has_denorm)
    4096                 :            :         {
    4097                 :        200 :           r->cl = rvc_normal;
    4098                 :        200 :           r->sign = sign;
    4099                 :            : 
    4100                 :        200 :           SET_REAL_EXP (r, -16382 + (SIGNIFICAND_BITS - 112));
    4101                 :        200 :           if (HOST_BITS_PER_LONG == 32)
    4102                 :            :             {
    4103                 :            :               r->sig[0] = image0;
    4104                 :            :               r->sig[1] = image1;
    4105                 :            :               r->sig[2] = image2;
    4106                 :            :               r->sig[3] = image3;
    4107                 :            :             }
    4108                 :            :           else
    4109                 :            :             {
    4110                 :        200 :               r->sig[0] = (image1 << 31 << 1) | image0;
    4111                 :        200 :               r->sig[1] = (image3 << 31 << 1) | image2;
    4112                 :            :             }
    4113                 :            : 
    4114                 :        200 :           normalize (r);
    4115                 :            :         }
    4116                 :        720 :       else if (fmt->has_signed_zero)
    4117                 :        720 :         r->sign = sign;
    4118                 :            :     }
    4119                 :        994 :   else if (exp == 32767 && (fmt->has_nans || fmt->has_inf))
    4120                 :            :     {
    4121                 :        898 :       if (image3 | image2 | image1 | image0)
    4122                 :            :         {
    4123                 :        898 :           r->cl = rvc_nan;
    4124                 :        898 :           r->sign = sign;
    4125                 :        898 :           r->signalling = ((image3 >> 15) & 1) ^ fmt->qnan_msb_set;
    4126                 :            : 
    4127                 :        898 :           if (HOST_BITS_PER_LONG == 32)
    4128                 :            :             {
    4129                 :            :               r->sig[0] = image0;
    4130                 :            :               r->sig[1] = image1;
    4131                 :            :               r->sig[2] = image2;
    4132                 :            :               r->sig[3] = image3;
    4133                 :            :             }
    4134                 :            :           else
    4135                 :            :             {
    4136                 :        898 :               r->sig[0] = (image1 << 31 << 1) | image0;
    4137                 :        898 :               r->sig[1] = (image3 << 31 << 1) | image2;
    4138                 :            :             }
    4139                 :        898 :           lshift_significand (r, r, SIGNIFICAND_BITS - 113);
    4140                 :            :         }
    4141                 :            :       else
    4142                 :            :         {
    4143                 :          0 :           r->cl = rvc_inf;
    4144                 :          0 :           r->sign = sign;
    4145                 :            :         }
    4146                 :            :     }
    4147                 :            :   else
    4148                 :            :     {
    4149                 :         96 :       r->cl = rvc_normal;
    4150                 :         96 :       r->sign = sign;
    4151                 :         96 :       SET_REAL_EXP (r, exp - 16383 + 1);
    4152                 :            : 
    4153                 :         96 :       if (HOST_BITS_PER_LONG == 32)
    4154                 :            :         {
    4155                 :            :           r->sig[0] = image0;
    4156                 :            :           r->sig[1] = image1;
    4157                 :            :           r->sig[2] = image2;
    4158                 :            :           r->sig[3] = image3;
    4159                 :            :         }
    4160                 :            :       else
    4161                 :            :         {
    4162                 :         96 :           r->sig[0] = (image1 << 31 << 1) | image0;
    4163                 :         96 :           r->sig[1] = (image3 << 31 << 1) | image2;
    4164                 :            :         }
    4165                 :         96 :       lshift_significand (r, r, SIGNIFICAND_BITS - 113);
    4166                 :         96 :       r->sig[SIGSZ-1] |= SIG_MSB;
    4167                 :            :     }
    4168                 :       1914 : }
    4169                 :            : 
    4170                 :            : const struct real_format ieee_quad_format =
    4171                 :            :   {
    4172                 :            :     encode_ieee_quad,
    4173                 :            :     decode_ieee_quad,
    4174                 :            :     2,
    4175                 :            :     113,
    4176                 :            :     113,
    4177                 :            :     -16381,
    4178                 :            :     16384,
    4179                 :            :     127,
    4180                 :            :     127,
    4181                 :            :     128,
    4182                 :            :     false,
    4183                 :            :     true,
    4184                 :            :     true,
    4185                 :            :     true,
    4186                 :            :     true,
    4187                 :            :     true,
    4188                 :            :     true,
    4189                 :            :     false,
    4190                 :            :     "ieee_quad"
    4191                 :            :   };
    4192                 :            : 
    4193                 :            : const struct real_format mips_quad_format =
    4194                 :            :   {
    4195                 :            :     encode_ieee_quad,
    4196                 :            :     decode_ieee_quad,
    4197                 :            :     2,
    4198                 :            :     113,
    4199                 :            :     113,
    4200                 :            :     -16381,
    4201                 :            :     16384,
    4202                 :            :     127,
    4203                 :            :     127,
    4204                 :            :     128,
    4205                 :            :     false,
    4206                 :            :     true,
    4207                 :            :     true,
    4208                 :            :     true,
    4209                 :            :     true,
    4210                 :            :     true,
    4211                 :            :     false,
    4212                 :            :     true,
    4213                 :            :     "mips_quad"
    4214                 :            :   };
    4215                 :            : 
    4216                 :            : /* Descriptions of VAX floating point formats can be found beginning at
    4217                 :            : 
    4218                 :            :    http://h71000.www7.hp.com/doc/73FINAL/4515/4515pro_013.html#f_floating_point_format
    4219                 :            : 
    4220                 :            :    The thing to remember is that they're almost IEEE, except for word
    4221                 :            :    order, exponent bias, and the lack of infinities, nans, and denormals.
    4222                 :            : 
    4223                 :            :    We don't implement the H_floating format here, simply because neither
    4224                 :            :    the VAX or Alpha ports use it.  */
    4225                 :            : 
    4226                 :            : static void encode_vax_f (const struct real_format *fmt,
    4227                 :            :                           long *, const REAL_VALUE_TYPE *);
    4228                 :            : static void decode_vax_f (const struct real_format *,
    4229                 :            :                           REAL_VALUE_TYPE *, const long *);
    4230                 :            : static void encode_vax_d (const struct real_format *fmt,
    4231                 :            :                           long *, const REAL_VALUE_TYPE *);
    4232                 :            : static void decode_vax_d (const struct real_format *,
    4233                 :            :                           REAL_VALUE_TYPE *, const long *);
    4234                 :            : static void encode_vax_g (const struct real_format *fmt,
    4235                 :            :                           long *, const REAL_VALUE_TYPE *);
    4236                 :            : static void decode_vax_g (const struct real_format *,
    4237                 :            :                           REAL_VALUE_TYPE *, const long *);
    4238                 :            : 
    4239                 :            : static void
    4240                 :          0 : encode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
    4241                 :            :               const REAL_VALUE_TYPE *r)
    4242                 :            : {
    4243                 :          0 :   unsigned long sign, exp, sig, image;
    4244                 :            : 
    4245                 :          0 :   sign = r->sign << 15;
    4246                 :            : 
    4247                 :          0 :   switch (r->cl)
    4248                 :            :     {
    4249                 :            :     case rvc_zero:
    4250                 :            :       image = 0;
    4251                 :            :       break;
    4252                 :            : 
    4253                 :          0 :     case rvc_inf:
    4254                 :          0 :     case rvc_nan:
    4255                 :          0 :       image = 0xffff7fff | sign;
    4256                 :          0 :       break;
    4257                 :            : 
    4258                 :          0 :     case rvc_normal:
    4259                 :          0 :       sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 24)) & 0x7fffff;
    4260                 :          0 :       exp = REAL_EXP (r) + 128;
    4261                 :            : 
    4262                 :          0 :       image = (sig << 16) & 0xffff0000;
    4263                 :          0 :       image |= sign;
    4264                 :          0 :       image |= exp << 7;
    4265                 :          0 :       image |= sig >> 16;
    4266                 :          0 :       break;
    4267                 :            : 
    4268                 :          0 :     default:
    4269                 :          0 :       gcc_unreachable ();
    4270                 :            :     }
    4271                 :            : 
    4272                 :          0 :   buf[0] = image;
    4273                 :          0 : }
    4274                 :            : 
    4275                 :            : static void
    4276                 :          0 : decode_vax_f (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4277                 :            :               REAL_VALUE_TYPE *r, const long *buf)
    4278                 :            : {
    4279                 :          0 :   unsigned long image = buf[0] & 0xffffffff;
    4280                 :          0 :   int exp = (image >> 7) & 0xff;
    4281                 :            : 
    4282                 :          0 :   memset (r, 0, sizeof (*r));
    4283                 :            : 
    4284                 :          0 :   if (exp != 0)
    4285                 :            :     {
    4286                 :          0 :       r->cl = rvc_normal;
    4287                 :          0 :       r->sign = (image >> 15) & 1;
    4288                 :          0 :       SET_REAL_EXP (r, exp - 128);
    4289                 :            : 
    4290                 :          0 :       image = ((image & 0x7f) << 16) | ((image >> 16) & 0xffff);
    4291                 :          0 :       r->sig[SIGSZ-1] = (image << (HOST_BITS_PER_LONG - 24)) | SIG_MSB;
    4292                 :            :     }
    4293                 :          0 : }
    4294                 :            : 
    4295                 :            : static void
    4296                 :          0 : encode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
    4297                 :            :               const REAL_VALUE_TYPE *r)
    4298                 :            : {
    4299                 :          0 :   unsigned long image0, image1, sign = r->sign << 15;
    4300                 :            : 
    4301                 :          0 :   switch (r->cl)
    4302                 :            :     {
    4303                 :            :     case rvc_zero:
    4304                 :            :       image0 = image1 = 0;
    4305                 :            :       break;
    4306                 :            : 
    4307                 :          0 :     case rvc_inf:
    4308                 :          0 :     case rvc_nan:
    4309                 :          0 :       image0 = 0xffff7fff | sign;
    4310                 :          0 :       image1 = 0xffffffff;
    4311                 :          0 :       break;
    4312                 :            : 
    4313                 :          0 :     case rvc_normal:
    4314                 :            :       /* Extract the significand into straight hi:lo.  */
    4315                 :          0 :       if (HOST_BITS_PER_LONG == 64)
    4316                 :            :         {
    4317                 :          0 :           image0 = r->sig[SIGSZ-1];
    4318                 :          0 :           image1 = (image0 >> (64 - 56)) & 0xffffffff;
    4319                 :          0 :           image0 = (image0 >> (64 - 56 + 1) >> 31) & 0x7fffff;
    4320                 :            :         }
    4321                 :            :       else
    4322                 :            :         {
    4323                 :            :           image0 = r->sig[SIGSZ-1];
    4324                 :            :           image1 = r->sig[SIGSZ-2];
    4325                 :            :           image1 = (image0 << 24) | (image1 >> 8);
    4326                 :            :           image0 = (image0 >> 8) & 0xffffff;
    4327                 :            :         }
    4328                 :            : 
    4329                 :            :       /* Rearrange the half-words of the significand to match the
    4330                 :            :          external format.  */
    4331                 :          0 :       image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff007f;
    4332                 :          0 :       image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
    4333                 :            : 
    4334                 :            :       /* Add the sign and exponent.  */
    4335                 :          0 :       image0 |= sign;
    4336                 :          0 :       image0 |= (REAL_EXP (r) + 128) << 7;
    4337                 :          0 :       break;
    4338                 :            : 
    4339                 :          0 :     default:
    4340                 :          0 :       gcc_unreachable ();
    4341                 :            :     }
    4342                 :            : 
    4343                 :          0 :   if (FLOAT_WORDS_BIG_ENDIAN)
    4344                 :            :     buf[0] = image1, buf[1] = image0;
    4345                 :            :   else
    4346                 :          0 :     buf[0] = image0, buf[1] = image1;
    4347                 :          0 : }
    4348                 :            : 
    4349                 :            : static void
    4350                 :          0 : decode_vax_d (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4351                 :            :               REAL_VALUE_TYPE *r, const long *buf)
    4352                 :            : {
    4353                 :          0 :   unsigned long image0, image1;
    4354                 :          0 :   int exp;
    4355                 :            : 
    4356                 :          0 :   if (FLOAT_WORDS_BIG_ENDIAN)
    4357                 :            :     image1 = buf[0], image0 = buf[1];
    4358                 :            :   else
    4359                 :          0 :     image0 = buf[0], image1 = buf[1];
    4360                 :          0 :   image0 &= 0xffffffff;
    4361                 :          0 :   image1 &= 0xffffffff;
    4362                 :            : 
    4363                 :          0 :   exp = (image0 >> 7) & 0xff;
    4364                 :            : 
    4365                 :          0 :   memset (r, 0, sizeof (*r));
    4366                 :            : 
    4367                 :          0 :   if (exp != 0)
    4368                 :            :     {
    4369                 :          0 :       r->cl = rvc_normal;
    4370                 :          0 :       r->sign = (image0 >> 15) & 1;
    4371                 :          0 :       SET_REAL_EXP (r, exp - 128);
    4372                 :            : 
    4373                 :            :       /* Rearrange the half-words of the external format into
    4374                 :            :          proper ascending order.  */
    4375                 :          0 :       image0 = ((image0 & 0x7f) << 16) | ((image0 >> 16) & 0xffff);
    4376                 :          0 :       image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
    4377                 :            : 
    4378                 :          0 :       if (HOST_BITS_PER_LONG == 64)
    4379                 :            :         {
    4380                 :          0 :           image0 = (image0 << 31 << 1) | image1;
    4381                 :          0 :           image0 <<= 64 - 56;
    4382                 :          0 :           image0 |= SIG_MSB;
    4383                 :          0 :           r->sig[SIGSZ-1] = image0;
    4384                 :            :         }
    4385                 :            :       else
    4386                 :            :         {
    4387                 :            :           r->sig[SIGSZ-1] = image0;
    4388                 :            :           r->sig[SIGSZ-2] = image1;
    4389                 :            :           lshift_significand (r, r, 2*HOST_BITS_PER_LONG - 56);
    4390                 :            :           r->sig[SIGSZ-1] |= SIG_MSB;
    4391                 :            :         }
    4392                 :            :     }
    4393                 :          0 : }
    4394                 :            : 
    4395                 :            : static void
    4396                 :          0 : encode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
    4397                 :            :               const REAL_VALUE_TYPE *r)
    4398                 :            : {
    4399                 :          0 :   unsigned long image0, image1, sign = r->sign << 15;
    4400                 :            : 
    4401                 :          0 :   switch (r->cl)
    4402                 :            :     {
    4403                 :            :     case rvc_zero:
    4404                 :            :       image0 = image1 = 0;
    4405                 :            :       break;
    4406                 :            : 
    4407                 :          0 :     case rvc_inf:
    4408                 :          0 :     case rvc_nan:
    4409                 :          0 :       image0 = 0xffff7fff | sign;
    4410                 :          0 :       image1 = 0xffffffff;
    4411                 :          0 :       break;
    4412                 :            : 
    4413                 :          0 :     case rvc_normal:
    4414                 :            :       /* Extract the significand into straight hi:lo.  */
    4415                 :          0 :       if (HOST_BITS_PER_LONG == 64)
    4416                 :            :         {
    4417                 :          0 :           image0 = r->sig[SIGSZ-1];
    4418                 :          0 :           image1 = (image0 >> (64 - 53)) & 0xffffffff;
    4419                 :          0 :           image0 = (image0 >> (64 - 53 + 1) >> 31) & 0xfffff;
    4420                 :            :         }
    4421                 :            :       else
    4422                 :            :         {
    4423                 :            :           image0 = r->sig[SIGSZ-1];
    4424                 :            :           image1 = r->sig[SIGSZ-2];
    4425                 :            :           image1 = (image0 << 21) | (image1 >> 11);
    4426                 :            :           image0 = (image0 >> 11) & 0xfffff;
    4427                 :            :         }
    4428                 :            : 
    4429                 :            :       /* Rearrange the half-words of the significand to match the
    4430                 :            :          external format.  */
    4431                 :          0 :       image0 = ((image0 << 16) | (image0 >> 16)) & 0xffff000f;
    4432                 :          0 :       image1 = ((image1 << 16) | (image1 >> 16)) & 0xffffffff;
    4433                 :            : 
    4434                 :            :       /* Add the sign and exponent.  */
    4435                 :          0 :       image0 |= sign;
    4436                 :          0 :       image0 |= (REAL_EXP (r) + 1024) << 4;
    4437                 :          0 :       break;
    4438                 :            : 
    4439                 :          0 :     default:
    4440                 :          0 :       gcc_unreachable ();
    4441                 :            :     }
    4442                 :            : 
    4443                 :          0 :   if (FLOAT_WORDS_BIG_ENDIAN)
    4444                 :            :     buf[0] = image1, buf[1] = image0;
    4445                 :            :   else
    4446                 :          0 :     buf[0] = image0, buf[1] = image1;
    4447                 :          0 : }
    4448                 :            : 
    4449                 :            : static void
    4450                 :          0 : decode_vax_g (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4451                 :            :               REAL_VALUE_TYPE *r, const long *buf)
    4452                 :            : {
    4453                 :          0 :   unsigned long image0, image1;
    4454                 :          0 :   int exp;
    4455                 :            : 
    4456                 :          0 :   if (FLOAT_WORDS_BIG_ENDIAN)
    4457                 :            :     image1 = buf[0], image0 = buf[1];
    4458                 :            :   else
    4459                 :          0 :     image0 = buf[0], image1 = buf[1];
    4460                 :          0 :   image0 &= 0xffffffff;
    4461                 :          0 :   image1 &= 0xffffffff;
    4462                 :            : 
    4463                 :          0 :   exp = (image0 >> 4) & 0x7ff;
    4464                 :            : 
    4465                 :          0 :   memset (r, 0, sizeof (*r));
    4466                 :            : 
    4467                 :          0 :   if (exp != 0)
    4468                 :            :     {
    4469                 :          0 :       r->cl = rvc_normal;
    4470                 :          0 :       r->sign = (image0 >> 15) & 1;
    4471                 :          0 :       SET_REAL_EXP (r, exp - 1024);
    4472                 :            : 
    4473                 :            :       /* Rearrange the half-words of the external format into
    4474                 :            :          proper ascending order.  */
    4475                 :          0 :       image0 = ((image0 & 0xf) << 16) | ((image0 >> 16) & 0xffff);
    4476                 :          0 :       image1 = ((image1 & 0xffff) << 16) | ((image1 >> 16) & 0xffff);
    4477                 :            : 
    4478                 :          0 :       if (HOST_BITS_PER_LONG == 64)
    4479                 :            :         {
    4480                 :          0 :           image0 = (image0 << 31 << 1) | image1;
    4481                 :          0 :           image0 <<= 64 - 53;
    4482                 :          0 :           image0 |= SIG_MSB;
    4483                 :          0 :           r->sig[SIGSZ-1] = image0;
    4484                 :            :         }
    4485                 :            :       else
    4486                 :            :         {
    4487                 :            :           r->sig[SIGSZ-1] = image0;
    4488                 :            :           r->sig[SIGSZ-2] = image1;
    4489                 :            :           lshift_significand (r, r, 64 - 53);
    4490                 :            :           r->sig[SIGSZ-1] |= SIG_MSB;
    4491                 :            :         }
    4492                 :            :     }
    4493                 :          0 : }
    4494                 :            : 
    4495                 :            : const struct real_format vax_f_format =
    4496                 :            :   {
    4497                 :            :     encode_vax_f,
    4498                 :            :     decode_vax_f,
    4499                 :            :     2,
    4500                 :            :     24,
    4501                 :            :     24,
    4502                 :            :     -127,
    4503                 :            :     127,
    4504                 :            :     15,
    4505                 :            :     15,
    4506                 :            :     0,
    4507                 :            :     false,
    4508                 :            :     false,
    4509                 :            :     false,
    4510                 :            :     false,
    4511                 :            :     false,
    4512                 :            :     false,
    4513                 :            :     false,
    4514                 :            :     false,
    4515                 :            :     "vax_f"
    4516                 :            :   };
    4517                 :            : 
    4518                 :            : const struct real_format vax_d_format =
    4519                 :            :   {
    4520                 :            :     encode_vax_d,
    4521                 :            :     decode_vax_d,
    4522                 :            :     2,
    4523                 :            :     56,
    4524                 :            :     56,
    4525                 :            :     -127,
    4526                 :            :     127,
    4527                 :            :     15,
    4528                 :            :     15,
    4529                 :            :     0,
    4530                 :            :     false,
    4531                 :            :     false,
    4532                 :            :     false,
    4533                 :            :     false,
    4534                 :            :     false,
    4535                 :            :     false,
    4536                 :            :     false,
    4537                 :            :     false,
    4538                 :            :     "vax_d"
    4539                 :            :   };
    4540                 :            : 
    4541                 :            : const struct real_format vax_g_format =
    4542                 :            :   {
    4543                 :            :     encode_vax_g,
    4544                 :            :     decode_vax_g,
    4545                 :            :     2,
    4546                 :            :     53,
    4547                 :            :     53,
    4548                 :            :     -1023,
    4549                 :            :     1023,
    4550                 :            :     15,
    4551                 :            :     15,
    4552                 :            :     0,
    4553                 :            :     false,
    4554                 :            :     false,
    4555                 :            :     false,
    4556                 :            :     false,
    4557                 :            :     false,
    4558                 :            :     false,
    4559                 :            :     false,
    4560                 :            :     false,
    4561                 :            :     "vax_g"
    4562                 :            :   };
    4563                 :            : 
    4564                 :            : /* Encode real R into a single precision DFP value in BUF.  */
    4565                 :            : static void
    4566                 :       8204 : encode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4567                 :            :                        long *buf ATTRIBUTE_UNUSED,
    4568                 :            :                        const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
    4569                 :            : {
    4570                 :       8204 :   encode_decimal32 (fmt, buf, r);
    4571                 :       8204 : }
    4572                 :            : 
    4573                 :            : /* Decode a single precision DFP value in BUF into a real R.  */
    4574                 :            : static void
    4575                 :        627 : decode_decimal_single (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4576                 :            :                        REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
    4577                 :            :                        const long *buf ATTRIBUTE_UNUSED)
    4578                 :            : {
    4579                 :        627 :   decode_decimal32 (fmt, r, buf);
    4580                 :        627 : }
    4581                 :            : 
    4582                 :            : /* Encode real R into a double precision DFP value in BUF.  */
    4583                 :            : static void
    4584                 :       7717 : encode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4585                 :            :                        long *buf ATTRIBUTE_UNUSED,
    4586                 :            :                        const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
    4587                 :            : {
    4588                 :       7717 :   encode_decimal64 (fmt, buf, r);
    4589                 :       7717 : }
    4590                 :            : 
    4591                 :            : /* Decode a double precision DFP value in BUF into a real R.  */
    4592                 :            : static void
    4593                 :       2464 : decode_decimal_double (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4594                 :            :                        REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
    4595                 :            :                        const long *buf ATTRIBUTE_UNUSED)
    4596                 :            : {
    4597                 :       2464 :   decode_decimal64 (fmt, r, buf);
    4598                 :       2464 : }
    4599                 :            : 
    4600                 :            : /* Encode real R into a quad precision DFP value in BUF.  */
    4601                 :            : static void
    4602                 :       7590 : encode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4603                 :            :                      long *buf ATTRIBUTE_UNUSED,
    4604                 :            :                      const REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED)
    4605                 :            : {
    4606                 :       7590 :   encode_decimal128 (fmt, buf, r);
    4607                 :       7590 : }
    4608                 :            : 
    4609                 :            : /* Decode a quad precision DFP value in BUF into a real R.  */
    4610                 :            : static void
    4611                 :       2366 : decode_decimal_quad (const struct real_format *fmt ATTRIBUTE_UNUSED,
    4612                 :            :                      REAL_VALUE_TYPE *r ATTRIBUTE_UNUSED,
    4613                 :            :                      const long *buf ATTRIBUTE_UNUSED)
    4614                 :            : {
    4615                 :       2366 :   decode_decimal128 (fmt, r, buf);
    4616                 :       2366 : }
    4617                 :            : 
    4618                 :            : /* Single precision decimal floating point (IEEE 754). */
    4619                 :            : const struct real_format decimal_single_format =
    4620                 :            :   {
    4621                 :            :     encode_decimal_single,
    4622                 :            :     decode_decimal_single,
    4623                 :            :     10,
    4624                 :            :     7,
    4625                 :            :     7,
    4626                 :            :     -94,
    4627                 :            :     97,
    4628                 :            :     31,
    4629                 :            :     31,
    4630                 :            :     32,
    4631                 :            :     false,
    4632                 :            :     true,
    4633                 :            :     true,
    4634                 :            :     true,
    4635                 :            :     true,
    4636                 :            :     true,
    4637                 :            :     true,
    4638                 :            :     false,
    4639                 :            :     "decimal_single"
    4640                 :            :   };
    4641                 :            : 
    4642                 :            : /* Double precision decimal floating point (IEEE 754). */
    4643                 :            : const struct real_format decimal_double_format =
    4644                 :            :   {
    4645                 :            :     encode_decimal_double,
    4646                 :            :     decode_decimal_double,
    4647                 :            :     10,
    4648                 :            :     16,
    4649                 :            :     16,
    4650                 :            :     -382,
    4651                 :            :     385,
    4652                 :            :     63,
    4653                 :            :     63,
    4654                 :            :     64,
    4655                 :            :     false,
    4656                 :            :     true,
    4657                 :            :     true,
    4658                 :            :     true,
    4659                 :            :     true,
    4660                 :            :     true,
    4661                 :            :     true,
    4662                 :            :     false,
    4663                 :            :     "decimal_double"
    4664                 :            :   };
    4665                 :            : 
    4666                 :            : /* Quad precision decimal floating point (IEEE 754). */
    4667                 :            : const struct real_format decimal_quad_format =
    4668                 :            :   {
    4669                 :            :     encode_decimal_quad,
    4670                 :            :     decode_decimal_quad,
    4671                 :            :     10,
    4672                 :            :     34,
    4673                 :            :     34,
    4674                 :            :     -6142,
    4675                 :            :     6145,
    4676                 :            :     127,
    4677                 :            :     127,
    4678                 :            :     128,
    4679                 :            :     false,
    4680                 :            :     true,
    4681                 :            :     true,
    4682                 :            :     true,
    4683                 :            :     true,
    4684                 :            :     true,
    4685                 :            :     true,
    4686                 :            :     false,
    4687                 :            :     "decimal_quad"
    4688                 :            :   };
    4689                 :            : 
    4690                 :            : /* Encode half-precision floats.  This routine is used both for the IEEE
    4691                 :            :    ARM alternative encodings.  */
    4692                 :            : static void
    4693                 :          0 : encode_ieee_half (const struct real_format *fmt, long *buf,
    4694                 :            :                   const REAL_VALUE_TYPE *r)
    4695                 :            : {
    4696                 :          0 :   unsigned long image, sig, exp;
    4697                 :          0 :   unsigned long sign = r->sign;
    4698                 :          0 :   bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
    4699                 :            : 
    4700                 :          0 :   image = sign << 15;
    4701                 :          0 :   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 11)) & 0x3ff;
    4702                 :            : 
    4703                 :          0 :   switch (r->cl)
    4704                 :            :     {
    4705                 :            :     case rvc_zero:
    4706                 :            :       break;
    4707                 :            : 
    4708                 :          0 :     case rvc_inf:
    4709                 :          0 :       if (fmt->has_inf)
    4710                 :          0 :         image |= 31 << 10;
    4711                 :            :       else
    4712                 :          0 :         image |= 0x7fff;
    4713                 :            :       break;
    4714                 :            : 
    4715                 :          0 :     case rvc_nan:
    4716                 :          0 :       if (fmt->has_nans)
    4717                 :            :         {
    4718                 :          0 :           if (r->canonical)
    4719                 :          0 :             sig = (fmt->canonical_nan_lsbs_set ? (1 << 9) - 1 : 0);
    4720                 :          0 :           if (r->signalling == fmt->qnan_msb_set)
    4721                 :          0 :             sig &= ~(1 << 9);
    4722                 :            :           else
    4723                 :          0 :             sig |= 1 << 9;
    4724                 :          0 :           if (sig == 0)
    4725                 :          0 :             sig = 1 << 8;
    4726                 :            : 
    4727                 :          0 :           image |= 31 << 10;
    4728                 :          0 :           image |= sig;
    4729                 :            :         }
    4730                 :            :       else
    4731                 :          0 :         image |= 0x3ff;
    4732                 :            :       break;
    4733                 :            : 
    4734                 :          0 :     case rvc_normal:
    4735                 :            :       /* Recall that IEEE numbers are interpreted as 1.F x 2**exp,
    4736                 :            :          whereas the intermediate representation is 0.F x 2**exp.
    4737                 :            :          Which means we're off by one.  */
    4738                 :          0 :       if (denormal)
    4739                 :            :         exp = 0;
    4740                 :            :       else
    4741                 :          0 :         exp = REAL_EXP (r) + 15 - 1;
    4742                 :          0 :       image |= exp << 10;
    4743                 :          0 :       image |= sig;
    4744                 :          0 :       break;
    4745                 :            : 
    4746                 :          0 :     default:
    4747                 :          0 :       gcc_unreachable ();
    4748                 :            :     }
    4749                 :            : 
    4750                 :          0 :   buf[0] = image;
    4751                 :          0 : }
    4752                 :            : 
    4753                 :            : /* Decode half-precision floats.  This routine is used both for the IEEE
    4754                 :            :    ARM alternative encodings.  */
    4755                 :            : static void
    4756                 :          0 : decode_ieee_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    4757                 :            :                   const long *buf)
    4758                 :            : {
    4759                 :          0 :   unsigned long image = buf[0] & 0xffff;
    4760                 :          0 :   bool sign = (image >> 15) & 1;
    4761                 :          0 :   int exp = (image >> 10) & 0x1f;
    4762                 :            : 
    4763                 :          0 :   memset (r, 0, sizeof (*r));
    4764                 :          0 :   image <<= HOST_BITS_PER_LONG - 11;
    4765                 :          0 :   image &= ~SIG_MSB;
    4766                 :            : 
    4767                 :          0 :   if (exp == 0)
    4768                 :            :     {
    4769                 :          0 :       if (image && fmt->has_denorm)
    4770                 :            :         {
    4771                 :          0 :           r->cl = rvc_normal;
    4772                 :          0 :           r->sign = sign;
    4773                 :          0 :           SET_REAL_EXP (r, -14);
    4774                 :          0 :           r->sig[SIGSZ-1] = image << 1;
    4775                 :          0 :           normalize (r);
    4776                 :            :         }
    4777                 :          0 :       else if (fmt->has_signed_zero)
    4778                 :          0 :         r->sign = sign;
    4779                 :            :     }
    4780                 :          0 :   else if (exp == 31 && (fmt->has_nans || fmt->has_inf))
    4781                 :            :     {
    4782                 :          0 :       if (image)
    4783                 :            :         {
    4784                 :          0 :           r->cl = rvc_nan;
    4785                 :          0 :           r->sign = sign;
    4786                 :          0 :           r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
    4787                 :          0 :                            ^ fmt->qnan_msb_set);
    4788                 :          0 :           r->sig[SIGSZ-1] = image;
    4789                 :            :         }
    4790                 :            :       else
    4791                 :            :         {
    4792                 :          0 :           r->cl = rvc_inf;
    4793                 :          0 :           r->sign = sign;
    4794                 :            :         }
    4795                 :            :     }
    4796                 :            :   else
    4797                 :            :     {
    4798                 :          0 :       r->cl = rvc_normal;
    4799                 :          0 :       r->sign = sign;
    4800                 :          0 :       SET_REAL_EXP (r, exp - 15 + 1);
    4801                 :          0 :       r->sig[SIGSZ-1] = image | SIG_MSB;
    4802                 :            :     }
    4803                 :          0 : }
    4804                 :            : 
    4805                 :            : /* Encode arm_bfloat types.  */
    4806                 :            : static void
    4807                 :          0 : encode_arm_bfloat_half (const struct real_format *fmt, long *buf,
    4808                 :            :                     const REAL_VALUE_TYPE *r)
    4809                 :            : {
    4810                 :          0 :   unsigned long image, sig, exp;
    4811                 :          0 :   unsigned long sign = r->sign;
    4812                 :          0 :   bool denormal = (r->sig[SIGSZ-1] & SIG_MSB) == 0;
    4813                 :            : 
    4814                 :          0 :   image = sign << 15;
    4815                 :          0 :   sig = (r->sig[SIGSZ-1] >> (HOST_BITS_PER_LONG - 8)) & 0x7f;
    4816                 :            : 
    4817                 :          0 :   switch (r->cl)
    4818                 :            :     {
    4819                 :            :     case rvc_zero:
    4820                 :            :       break;
    4821                 :            : 
    4822                 :          0 :     case rvc_inf:
    4823                 :          0 :       if (fmt->has_inf)
    4824                 :          0 :         image |= 255 << 7;
    4825                 :            :       else
    4826                 :          0 :         image |= 0x7fff;
    4827                 :            :       break;
    4828                 :            : 
    4829                 :          0 :     case rvc_nan:
    4830                 :          0 :       if (fmt->has_nans)
    4831                 :            :         {
    4832                 :          0 :           if (r->canonical)
    4833                 :          0 :             sig = (fmt->canonical_nan_lsbs_set ? (1 << 6) - 1 : 0);
    4834                 :          0 :           if (r->signalling == fmt->qnan_msb_set)
    4835                 :          0 :             sig &= ~(1 << 6);
    4836                 :            :           else
    4837                 :          0 :             sig |= 1 << 6;
    4838                 :          0 :           if (sig == 0)
    4839                 :          0 :             sig = 1 << 5;
    4840                 :            : 
    4841                 :          0 :           image |= 255 << 7;
    4842                 :          0 :           image |= sig;
    4843                 :            :         }
    4844                 :            :       else
    4845                 :          0 :         image |= 0x7fff;
    4846                 :            :       break;
    4847                 :            : 
    4848                 :          0 :     case rvc_normal:
    4849                 :          0 :       if (denormal)
    4850                 :            :         exp = 0;
    4851                 :            :       else
    4852                 :          0 :       exp = REAL_EXP (r) + 127 - 1;
    4853                 :          0 :       image |= exp << 7;
    4854                 :          0 :       image |= sig;
    4855                 :          0 :       break;
    4856                 :            : 
    4857                 :          0 :     default:
    4858                 :          0 :       gcc_unreachable ();
    4859                 :            :     }
    4860                 :            : 
    4861                 :          0 :   buf[0] = image;
    4862                 :          0 : }
    4863                 :            : 
    4864                 :            : /* Decode arm_bfloat types.  */
    4865                 :            : static void
    4866                 :          0 : decode_arm_bfloat_half (const struct real_format *fmt, REAL_VALUE_TYPE *r,
    4867                 :            :                     const long *buf)
    4868                 :            : {
    4869                 :          0 :   unsigned long image = buf[0] & 0xffff;
    4870                 :          0 :   bool sign = (image >> 15) & 1;
    4871                 :          0 :   int exp = (image >> 7) & 0xff;
    4872                 :            : 
    4873                 :          0 :   memset (r, 0, sizeof (*r));
    4874                 :          0 :   image <<= HOST_BITS_PER_LONG - 8;
    4875                 :          0 :   image &= ~SIG_MSB;
    4876                 :            : 
    4877                 :          0 :   if (exp == 0)
    4878                 :            :     {
    4879                 :          0 :       if (image && fmt->has_denorm)
    4880                 :            :         {
    4881                 :          0 :           r->cl = rvc_normal;
    4882                 :          0 :           r->sign = sign;
    4883                 :          0 :           SET_REAL_EXP (r, -126);
    4884                 :          0 :           r->sig[SIGSZ-1] = image << 1;
    4885                 :          0 :           normalize (r);
    4886                 :            :         }
    4887                 :          0 :       else if (fmt->has_signed_zero)
    4888                 :          0 :         r->sign = sign;
    4889                 :            :     }
    4890                 :          0 :   else if (exp == 255 && (fmt->has_nans || fmt->has_inf))
    4891                 :            :     {
    4892                 :          0 :       if (image)
    4893                 :            :         {
    4894                 :          0 :           r->cl = rvc_nan;
    4895                 :          0 :           r->sign = sign;
    4896                 :          0 :           r->signalling = (((image >> (HOST_BITS_PER_LONG - 2)) & 1)
    4897                 :          0 :                            ^ fmt->qnan_msb_set);
    4898                 :          0 :           r->sig[SIGSZ-1] = image;
    4899                 :            :         }
    4900                 :            :       else
    4901                 :            :         {
    4902                 :          0 :           r->cl = rvc_inf;
    4903                 :          0 :           r->sign = sign;
    4904                 :            :         }
    4905                 :            :     }
    4906                 :            :   else
    4907                 :            :     {
    4908                 :          0 :       r->cl = rvc_normal;
    4909                 :          0 :       r->sign = sign;
    4910                 :          0 :       SET_REAL_EXP (r, exp - 127 + 1);
    4911                 :          0 :       r->sig[SIGSZ-1] = image | SIG_MSB;
    4912                 :            :     }
    4913                 :          0 : }
    4914                 :            : 
    4915                 :            : /* Half-precision format, as specified in IEEE 754R.  */
    4916                 :            : const struct real_format ieee_half_format =
    4917                 :            :   {
    4918                 :            :     encode_ieee_half,
    4919                 :            :     decode_ieee_half,
    4920                 :            :     2,
    4921                 :            :     11,
    4922                 :            :     11,
    4923                 :            :     -13,
    4924                 :            :     16,
    4925                 :            :     15,
    4926                 :            :     15,
    4927                 :            :     16,
    4928                 :            :     false,
    4929                 :            :     true,
    4930                 :            :     true,
    4931                 :            :     true,
    4932                 :            :     true,
    4933                 :            :     true,
    4934                 :            :     true,
    4935                 :            :     false,
    4936                 :            :     "ieee_half"
    4937                 :            :   };
    4938                 :            : 
    4939                 :            : /* ARM's alternative half-precision format, similar to IEEE but with
    4940                 :            :    no reserved exponent value for NaNs and infinities; rather, it just
    4941                 :            :    extends the range of exponents by one.  */
    4942                 :            : const struct real_format arm_half_format =
    4943                 :            :   {
    4944                 :            :     encode_ieee_half,
    4945                 :            :     decode_ieee_half,
    4946                 :            :     2,
    4947                 :            :     11,
    4948                 :            :     11,
    4949                 :            :     -13,
    4950                 :            :     17,
    4951                 :            :     15,
    4952                 :            :     15,
    4953                 :            :     0,
    4954                 :            :     false,
    4955                 :            :     true,
    4956                 :            :     false,
    4957                 :            :     false,
    4958                 :            :     true,
    4959                 :            :     true,
    4960                 :            :     false,
    4961                 :            :     false,
    4962                 :            :     "arm_half"
    4963                 :            :   };
    4964                 :            : 
    4965                 :            : /* ARM Bfloat half-precision format.  This format resembles a truncated
    4966                 :            :    (16-bit) version of the 32-bit IEEE 754 single-precision floating-point
    4967                 :            :    format.  */
    4968                 :            : const struct real_format arm_bfloat_half_format =
    4969                 :            :   {
    4970                 :            :     encode_arm_bfloat_half,
    4971                 :            :     decode_arm_bfloat_half,
    4972                 :            :     2,
    4973                 :            :     8,
    4974                 :            :     8,
    4975                 :            :     -125,
    4976                 :            :     128,
    4977                 :            :     15,
    4978                 :            :     15,
    4979                 :            :     0,
    4980                 :            :     false,
    4981                 :            :     true,
    4982                 :            :     true,
    4983                 :            :     true,
    4984                 :            :     true,
    4985                 :            :     true,
    4986                 :            :     true,
    4987                 :            :     false,
    4988                 :            :     "arm_bfloat_half"
    4989                 :            :   };
    4990                 :            : 
    4991                 :            : 
    4992                 :            : /* A synthetic "format" for internal arithmetic.  It's the size of the
    4993                 :            :    internal significand minus the two bits needed for proper rounding.
    4994                 :            :    The encode and decode routines exist only to satisfy our paranoia
    4995                 :            :    harness.  */
    4996                 :            : 
    4997                 :            : static void encode_internal (const struct real_format *fmt,
    4998                 :            :                              long *, const REAL_VALUE_TYPE *);
    4999                 :            : static void decode_internal (const struct real_format *,
    5000                 :            :                              REAL_VALUE_TYPE *, const long *);
    5001                 :            : 
    5002                 :            : static void
    5003                 :          0 : encode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED, long *buf,
    5004                 :            :                  const REAL_VALUE_TYPE *r)
    5005                 :            : {
    5006                 :          0 :   memcpy (buf, r, sizeof (*r));
    5007                 :          0 : }
    5008                 :            : 
    5009                 :            : static void
    5010                 :          0 : decode_internal (const struct real_format *fmt ATTRIBUTE_UNUSED,
    5011                 :            :                  REAL_VALUE_TYPE *r, const long *buf)
    5012                 :            : {
    5013                 :          0 :   memcpy (r, buf, sizeof (*r));
    5014                 :          0 : }
    5015                 :            : 
    5016                 :            : const struct real_format real_internal_format =
    5017                 :            :   {
    5018                 :            :     encode_internal,
    5019                 :            :     decode_internal,
    5020                 :            :     2,
    5021                 :            :     SIGNIFICAND_BITS - 2,
    5022                 :            :     SIGNIFICAND_BITS - 2,
    5023                 :            :     -MAX_EXP,
    5024                 :            :     MAX_EXP,
    5025                 :            :     -1,
    5026                 :            :     -1,
    5027                 :            :     0,
    5028                 :            :     false,
    5029                 :            :     false,
    5030                 :            :     true,
    5031                 :            :     true,
    5032                 :            :     false,
    5033                 :            :     true,
    5034                 :            :     true,
    5035                 :            :     false,
    5036                 :            :     "real_internal"
    5037                 :            :   };
    5038                 :            : 
    5039                 :            : /* Calculate X raised to the integer exponent N in format FMT and store
    5040                 :            :    the result in R.  Return true if the result may be inexact due to
    5041                 :            :    loss of precision.  The algorithm is the classic "left-to-right binary
    5042                 :            :    method" described in section 4.6.3 of Donald Knuth's "Seminumerical
    5043                 :            :    Algorithms", "The Art of Computer Programming", Volume 2.  */
    5044                 :            : 
    5045                 :            : bool
    5046                 :       1912 : real_powi (REAL_VALUE_TYPE *r, format_helper fmt,
    5047                 :            :            const REAL_VALUE_TYPE *x, HOST_WIDE_INT n)
    5048                 :            : {
    5049                 :       1912 :   unsigned HOST_WIDE_INT bit;
    5050                 :       1912 :   REAL_VALUE_TYPE t;
    5051                 :       1912 :   bool inexact = false;
    5052                 :       1912 :   bool init = false;
    5053                 :       1912 :   bool neg;
    5054                 :       1912 :   int i;
    5055                 :            : 
    5056                 :       1912 :   if (n == 0)
    5057                 :            :     {
    5058                 :         27 :       *r = dconst1;
    5059                 :         27 :       return false;
    5060                 :            :     }
    5061                 :       1885 :   else if (n < 0)
    5062                 :            :     {
    5063                 :            :       /* Don't worry about overflow, from now on n is unsigned.  */
    5064                 :        920 :       neg = true;
    5065                 :        920 :       n = -n;
    5066                 :            :     }
    5067                 :            :   else
    5068                 :            :     neg = false;
    5069                 :            : 
    5070                 :       1885 :   t = *x;
    5071                 :       1885 :   bit = HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1);
    5072                 :     122525 :   for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
    5073                 :            :     {
    5074                 :     120640 :       if (init)
    5075                 :            :         {
    5076                 :      81119 :           inexact |= do_multiply (&t, &t, &t);
    5077                 :      81119 :           if (n & bit)
    5078                 :       3176 :             inexact |= do_multiply (&t, &t, x);
    5079                 :            :         }
    5080                 :      39521 :       else if (n & bit)
    5081                 :       1885 :         init = true;
    5082                 :     120640 :       bit >>= 1;
    5083                 :            :     }
    5084                 :            : 
    5085                 :       1885 :   if (neg)
    5086                 :        920 :     inexact |= do_divide (&t, &dconst1, &t);
    5087                 :            : 
    5088                 :       1885 :   real_convert (r, fmt, &t);
    5089                 :       1885 :   return inexact;
    5090                 :            : }
    5091                 :            : 
    5092                 :            : /* Round X to the nearest integer not larger in absolute value, i.e.
    5093                 :            :    towards zero, placing the result in R in format FMT.  */
    5094                 :            : 
    5095                 :            : void
    5096                 :      29809 : real_trunc (REAL_VALUE_TYPE *r, format_helper fmt,
    5097                 :            :             const REAL_VALUE_TYPE *x)
    5098                 :            : {
    5099                 :      29809 :   do_fix_trunc (r, x);
    5100                 :      29809 :   if (fmt)
    5101                 :       6954 :     real_convert (r, fmt, r);
    5102                 :      29809 : }
    5103                 :            : 
    5104                 :            : /* Round X to the largest integer not greater in value, i.e. round
    5105                 :            :    down, placing the result in R in format FMT.  */
    5106                 :            : 
    5107                 :            : void
    5108                 :        985 : real_floor (REAL_VALUE_TYPE *r, format_helper fmt,
    5109                 :            :             const REAL_VALUE_TYPE *x)
    5110                 :            : {
    5111                 :        985 :   REAL_VALUE_TYPE t;
    5112                 :            : 
    5113                 :        985 :   do_fix_trunc (&t, x);
    5114                 :        985 :   if (! real_identical (&t, x) && x->sign)
    5115                 :        234 :     do_add (&t, &t, &dconstm1, 0);
    5116                 :        985 :   if (fmt)
    5117                 :        985 :     real_convert (r, fmt, &t);
    5118                 :            :   else
    5119                 :          0 :     *r = t;
    5120                 :        985 : }
    5121                 :            : 
    5122                 :            : /* Round X to the smallest integer not less then argument, i.e. round
    5123                 :            :    up, placing the result in R in format FMT.  */
    5124                 :            : 
    5125                 :            : void
    5126                 :       1793 : real_ceil (REAL_VALUE_TYPE *r, format_helper fmt,
    5127                 :            :            const REAL_VALUE_TYPE *x)
    5128                 :            : {
    5129                 :       1793 :   REAL_VALUE_TYPE t;
    5130                 :            : 
    5131                 :       1793 :   do_fix_trunc (&t, x);
    5132                 :       1793 :   if (! real_identical (&t, x) && ! x->sign)
    5133                 :        275 :     do_add (&t, &t, &dconst1, 0);
    5134                 :       1793 :   if (fmt)
    5135                 :       1793 :     real_convert (r, fmt, &t);
    5136                 :            :   else
    5137                 :          0 :     *r = t;
    5138                 :       1793 : }
    5139                 :            : 
    5140                 :            : /* Round X to the nearest integer, but round halfway cases away from
    5141                 :            :    zero.  */
    5142                 :            : 
    5143                 :            : void
    5144                 :       1194 : real_round (REAL_VALUE_TYPE *r, format_helper fmt,
    5145                 :            :             const REAL_VALUE_TYPE *x)
    5146                 :            : {
    5147                 :       1194 :   do_add (r, x, &dconsthalf, x->sign);
    5148                 :       1194 :   do_fix_trunc (r, r);
    5149                 :       1194 :   if (fmt)
    5150                 :       1194 :     real_convert (r, fmt, r);
    5151                 :       1194 : }
    5152                 :            : 
    5153                 :            : /* Return true (including 0) if integer part of R is even, else return
    5154                 :            :    false.  The function is not valid for rvc_inf and rvc_nan classes.  */
    5155                 :            : 
    5156                 :            : static bool
    5157                 :         49 : is_even (REAL_VALUE_TYPE *r)
    5158                 :            : {
    5159                 :         49 :   gcc_assert (r->cl != rvc_inf);
    5160                 :         49 :   gcc_assert (r->cl != rvc_nan);
    5161                 :            : 
    5162                 :         49 :   if (r->cl == rvc_zero)
    5163                 :            :     return true;
    5164                 :            : 
    5165                 :            :   /* For (-1,1), number is even.  */
    5166                 :         49 :   if (REAL_EXP (r) <= 0)
    5167                 :            :     return true;
    5168                 :            : 
    5169                 :            :   /* Check lowest bit, if not set, return true.  */
    5170                 :         49 :   else if (REAL_EXP (r) <= SIGNIFICAND_BITS)
    5171                 :            :     {
    5172                 :         49 :       unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r);
    5173                 :         49 :       int w = n / HOST_BITS_PER_LONG;
    5174                 :            : 
    5175                 :         49 :       unsigned long num = ((unsigned long)1 << (n % HOST_BITS_PER_LONG));
    5176                 :            : 
    5177                 :         49 :       if ((r->sig[w] & num) == 0)
    5178                 :         28 :         return true;
    5179                 :            :     }
    5180                 :            :   else
    5181                 :            :     return true;
    5182                 :            : 
    5183                 :            :   return false;
    5184                 :            : }
    5185                 :            : 
    5186                 :            : /* Return true if R is halfway between two integers, else return
    5187                 :            :    false.  */
    5188                 :            : 
    5189                 :            : static bool
    5190                 :        189 : is_halfway_below (const REAL_VALUE_TYPE *r)
    5191                 :            : {
    5192                 :        189 :   if (r->cl != rvc_normal)
    5193                 :            :     return false;
    5194                 :            : 
    5195                 :            :   /* For numbers (-0.5,0) and (0,0.5).  */
    5196                 :        147 :   if (REAL_EXP (r) < 0)
    5197                 :            :     return false;
    5198                 :            : 
    5199                 :        133 :   else if (REAL_EXP (r) < SIGNIFICAND_BITS)
    5200                 :            :     {
    5201                 :        119 :       unsigned int n = SIGNIFICAND_BITS - REAL_EXP (r) - 1;
    5202                 :        119 :       int w = n / HOST_BITS_PER_LONG;
    5203                 :            : 
    5204                 :        322 :       for (int i = 0; i < w; ++i)
    5205                 :        210 :         if (r->sig[i] != 0)
    5206                 :            :           return false;
    5207                 :            : 
    5208                 :        112 :       unsigned long num = 1UL << (n % HOST_BITS_PER_LONG);
    5209                 :            : 
    5210                 :        112 :       if ((r->sig[w] & num) != 0 && (r->sig[w] & (num - 1)) == 0)
    5211                 :         77 :         return true;
    5212                 :            :     }
    5213                 :            :   return false;
    5214                 :            : }
    5215                 :            : 
    5216                 :            : /* Round X to nearest integer, rounding halfway cases towards even.  */
    5217                 :            : 
    5218                 :            : void
    5219                 :        189 : real_roundeven (REAL_VALUE_TYPE *r, format_helper fmt,
    5220                 :            :                 const REAL_VALUE_TYPE *x)
    5221                 :            : {
    5222                 :        189 :   if (is_halfway_below (x))
    5223                 :            :     {
    5224                 :            :       /* Special case as -0.5 rounds to -0.0 and
    5225                 :            :          similarly +0.5 rounds to +0.0.  */
    5226                 :         77 :       if (REAL_EXP (x) == 0)
    5227                 :            :         {
    5228                 :         28 :           *r = *x;
    5229                 :         28 :           clear_significand_below (r, SIGNIFICAND_BITS);
    5230                 :            :         }
    5231                 :            :       else
    5232                 :            :         {
    5233                 :         49 :           do_add (r, x, &dconsthalf, x->sign);
    5234                 :         49 :           if (!is_even (r))
    5235                 :         21 :             do_add (r, r, &dconstm1, x->sign);
    5236                 :            :         }
    5237                 :         77 :       if (fmt)
    5238                 :         77 :         real_convert (r, fmt, r);
    5239                 :            :     }
    5240                 :            :   else
    5241                 :        112 :     real_round (r, fmt, x);
    5242                 :        189 : }
    5243                 :            : 
    5244                 :            : /* Set the sign of R to the sign of X.  */
    5245                 :            : 
    5246                 :            : void
    5247                 :      70355 : real_copysign (REAL_VALUE_TYPE *r, const REAL_VALUE_TYPE *x)
    5248                 :            : {
    5249                 :      70355 :   r->sign = x->sign;
    5250                 :      70355 : }
    5251                 :            : 
    5252                 :            : /* Check whether the real constant value given is an integer.
    5253                 :            :    Returns false for signaling NaN.  */
    5254                 :            : 
    5255                 :            : bool
    5256                 :       6363 : real_isinteger (const REAL_VALUE_TYPE *c, format_helper fmt)
    5257                 :            : {
    5258                 :       6363 :   REAL_VALUE_TYPE cint;
    5259                 :            : 
    5260                 :       6363 :   real_trunc (&cint, fmt, c);
    5261                 :       6363 :   return real_identical (c, &cint);
    5262                 :            : }
    5263                 :            : 
    5264                 :            : /* Check whether C is an integer that fits in a HOST_WIDE_INT,
    5265                 :            :    storing it in *INT_OUT if so.  */
    5266                 :            : 
    5267                 :            : bool
    5268                 :        132 : real_isinteger (const REAL_VALUE_TYPE *c, HOST_WIDE_INT *int_out)
    5269                 :            : {
    5270                 :        132 :   REAL_VALUE_TYPE cint;
    5271                 :            : 
    5272                 :        132 :   HOST_WIDE_INT n = real_to_integer (c);
    5273                 :        132 :   real_from_integer (&cint, VOIDmode, n, SIGNED);
    5274                 :        132 :   if (real_identical (c, &cint))
    5275                 :            :     {
    5276                 :         59 :       *int_out = n;
    5277                 :         59 :       return true;
    5278                 :            :     }
    5279                 :            :   return false;
    5280                 :            : }
    5281                 :            : 
    5282                 :            : /* Calculate nextafter (X, Y) or nexttoward (X, Y).  Return true if
    5283                 :            :    underflow or overflow needs to be raised.  */
    5284                 :            : 
    5285                 :            : bool
    5286                 :       2360 : real_nextafter (REAL_VALUE_TYPE *r, format_helper fmt,
    5287                 :            :                 const REAL_VALUE_TYPE *x, const REAL_VALUE_TYPE *y)
    5288                 :            : {
    5289                 :       2360 :   int cmp = do_compare (x, y, 2);
    5290                 :            :   /* If either operand is NaN, return qNaN.  */
    5291                 :       2360 :   if (cmp == 2)
    5292                 :            :     {
    5293                 :         36 :       get_canonical_qnan (r, 0);
    5294                 :         36 :       return false;
    5295                 :            :     }
    5296                 :            :   /* If x == y, return y cast to target type.  */
    5297                 :       2324 :   if (cmp == 0)
    5298                 :            :     {
    5299                 :        138 :       real_convert (r, fmt, y);
    5300                 :        138 :       return false;
    5301                 :            :     }
    5302                 :            : 
    5303                 :       2186 :   if (x->cl == rvc_zero)
    5304                 :            :     {
    5305                 :        794 :       get_zero (r, y->sign);
    5306                 :        794 :       r->cl = rvc_normal;
    5307                 :        794 :       SET_REAL_EXP (r, fmt->emin - fmt->p + 1);
    5308                 :        794 :       r->sig[SIGSZ - 1] = SIG_MSB;
    5309                 :        794 :       return false;
    5310                 :            :     }
    5311                 :            : 
    5312                 :       1392 :   int np2 = SIGNIFICAND_BITS - fmt->p;
    5313                 :            :   /* For denormals adjust np2 correspondingly.  */
    5314                 :       1392 :   if (x->cl == rvc_normal && REAL_EXP (x) < fmt->emin)
    5315                 :        252 :     np2 += fmt->emin - REAL_EXP (x);
    5316                 :            : 
    5317                 :       1392 :   REAL_VALUE_TYPE u;
    5318                 :       1392 :   get_zero (r, x->sign);
    5319                 :       1392 :   get_zero (&u, 0);
    5320                 :       1392 :   set_significand_bit (&u, np2);
    5321                 :       1392 :   r->cl = rvc_normal;
    5322                 :       1392 :   SET_REAL_EXP (r, REAL_EXP (x));
    5323                 :            : 
    5324                 :       1392 :   if (x->cl == rvc_inf)
    5325                 :            :     {
    5326                 :         72 :       bool borrow = sub_significands (r, r, &u, 0);
    5327                 :         18 :       gcc_assert (borrow);
    5328                 :         18 :       SET_REAL_EXP (r, fmt->emax);
    5329                 :            :     }
    5330                 :       2244 :   else if (cmp == (x->sign ? 1 : -1))
    5331                 :            :     {
    5332                 :       1720 :       if (add_significands (r, x, &u))
    5333                 :            :         {
    5334                 :            :           /* Overflow.  Means the significand had been all ones, and
    5335                 :            :              is now all zeros.  Need to increase the exponent, and
    5336                 :            :              possibly re-normalize it.  */
    5337                 :        175 :           SET_REAL_EXP (r, REAL_EXP (r) + 1);
    5338                 :        175 :           if (REAL_EXP (r) > fmt->emax)
    5339                 :            :             {
    5340                 :         18 :               get_inf (r, x->sign);
    5341                 :         18 :               return true;
    5342                 :            :             }
    5343                 :        157 :           r->sig[SIGSZ - 1] = SIG_MSB;
    5344                 :            :         }
    5345                 :            :     }
    5346                 :            :   else
    5347                 :            :     {
    5348                 :        944 :       if (REAL_EXP (x) > fmt->emin && x->sig[SIGSZ - 1] == SIG_MSB)
    5349                 :            :         {
    5350                 :            :           int i;
    5351                 :        804 :           for (i = SIGSZ - 2; i >= 0; i--)
    5352                 :        536 :             if (x->sig[i])
    5353                 :            :               break;
    5354                 :        268 :           if (i < 0)
    5355                 :            :             {
    5356                 :            :               /* When mantissa is 1.0, we need to subtract only
    5357                 :            :                  half of u: nextafter (1.0, 0.0) is 1.0 - __DBL_EPSILON__ / 2
    5358                 :            :                  rather than 1.0 - __DBL_EPSILON__.  */
    5359                 :        268 :               clear_significand_bit (&u, np2);
    5360                 :        268 :               np2--;
    5361                 :        268 :               set_significand_bit (&u, np2);
    5362                 :            :             }
    5363                 :            :         }
    5364                 :        944 :       sub_significands (r, x, &u, 0);
    5365                 :            :     }
    5366                 :            : 
    5367                 :            :   /* Clear out trailing garbage.  */
    5368                 :       1374 :   clear_significand_below (r, np2);
    5369                 :       1374 :   normalize (r);
    5370                 :       1374 :   if (REAL_EXP (r) <= fmt->emin - fmt->p)
    5371                 :            :     {
    5372                 :          0 :       get_zero (r, x->sign);
    5373                 :          0 :       return true;
    5374                 :            :     }
    5375                 :       1374 :   return r->cl == rvc_zero || REAL_EXP (r) < fmt->emin;
    5376                 :            : }
    5377                 :            : 
    5378                 :            : /* Write into BUF the maximum representable finite floating-point
    5379                 :            :    number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
    5380                 :            :    float string.  LEN is the size of BUF, and the buffer must be large
    5381                 :            :    enough to contain the resulting string.  If NORM_MAX, instead write
    5382                 :            :    the maximum representable finite normalized floating-point number,
    5383                 :            :    defined to be such that all choices of digits for that exponent are
    5384                 :            :    representable in the format (this only makes a difference for IBM
    5385                 :            :    long double).  */
    5386                 :            : 
    5387                 :            : void
    5388                 :    2699730 : get_max_float (const struct real_format *fmt, char *buf, size_t len,
    5389                 :            :                bool norm_max)
    5390                 :            : {
    5391                 :    2699730 :   int i, n;
    5392                 :    2699730 :   char *p;
    5393                 :    2699730 :   bool is_ibm_extended = fmt->pnan < fmt->p;
    5394                 :            : 
    5395                 :    2699730 :   strcpy (buf, "0x0.");
    5396                 :    2699730 :   n = fmt->p;
    5397                 :   39768800 :   for (i = 0, p = buf + 4; i + 3 < n; i += 4)
    5398                 :   37069100 :     *p++ = 'f';
    5399                 :    2699730 :   if (i < n)
    5400                 :    1320720 :     *p++ = "08ce"[n - i];
    5401                 :    2699730 :   sprintf (p, "p%d",
    5402                 :    2699730 :            (is_ibm_extended && norm_max) ? fmt->emax - 1 : fmt->emax);
    5403                 :    2699730 :   if (is_ibm_extended && !norm_max)
    5404                 :            :     {
    5405                 :            :       /* This is an IBM extended double format made up of two IEEE
    5406                 :            :          doubles.  The value of the long double is the sum of the
    5407                 :            :          values of the two parts.  The most significant part is
    5408                 :            :          required to be the value of the long double rounded to the
    5409                 :            :          nearest double.  Rounding means we need a slightly smaller
    5410                 :            :          value for LDBL_MAX.  */
    5411                 :          0 :       buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
    5412                 :            :     }
    5413                 :            : 
    5414                 :    2699730 :   gcc_assert (strlen (buf) < len);
    5415                 :    2699730 : }
    5416                 :            : 
    5417                 :            : /* True if all values of integral type can be represented
    5418                 :            :    by this floating-point type exactly.  */
    5419                 :            : 
    5420                 :      10348 : bool format_helper::can_represent_integral_type_p (tree type) const
    5421                 :            : {
    5422                 :      20696 :   gcc_assert (! decimal_p () && INTEGRAL_TYPE_P (type));
    5423                 :            : 
    5424                 :            :   /* INT?_MIN is power-of-two so it takes
    5425                 :            :      only one mantissa bit.  */
    5426                 :      10348 :   bool signed_p = TYPE_SIGN (type) == SIGNED;
    5427                 :      10348 :   return TYPE_PRECISION (type) - signed_p <= significand_size (*this);
    5428                 :            : }
    5429                 :            : 
    5430                 :            : /* True if mode M has a NaN representation and
    5431                 :            :    the treatment of NaN operands is important.  */
    5432                 :            : 
    5433                 :            : bool
    5434                 :  640160000 : HONOR_NANS (machine_mode m)
    5435                 :            : {
    5436                 :  689883000 :   return MODE_HAS_NANS (m) && !flag_finite_math_only;
    5437                 :            : }
    5438                 :            : 
    5439                 :            : bool
    5440                 :   45009700 : HONOR_NANS (const_tree t)
    5441                 :            : {
    5442                 :   45009700 :   return HONOR_NANS (element_mode (t));
    5443                 :            : }
    5444                 :            : 
    5445                 :            : bool
    5446                 :  427582000 : HONOR_NANS (const_rtx x)
    5447                 :            : {
    5448                 :  427582000 :   return HONOR_NANS (GET_MODE (x));
    5449                 :            : }
    5450                 :            : 
    5451                 :            : /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs).  */
    5452                 :            : 
    5453                 :            : bool
    5454                 :  124456000 : HONOR_SNANS (machine_mode m)
    5455                 :            : {
    5456                 :  124456000 :   return flag_signaling_nans && HONOR_NANS (m);
    5457                 :            : }
    5458                 :            : 
    5459                 :            : bool
    5460                 :     636898 : HONOR_SNANS (const_tree t)
    5461                 :            : {
    5462                 :     636898 :   return HONOR_SNANS (element_mode (t));
    5463                 :            : }
    5464                 :            : 
    5465                 :            : bool
    5466                 :   71536000 : HONOR_SNANS (const_rtx x)
    5467                 :            : {
    5468                 :   71536000 :   return HONOR_SNANS (GET_MODE (x));
    5469                 :            : }
    5470                 :            : 
    5471                 :            : /* As for HONOR_NANS, but true if the mode can represent infinity and
    5472                 :            :    the treatment of infinite values is important.  */
    5473                 :            : 
    5474                 :            : bool
    5475                 :     111073 : HONOR_INFINITIES (machine_mode m)
    5476                 :            : {
    5477                 :     437830 :   return MODE_HAS_INFINITIES (m) && !flag_finite_math_only;
    5478                 :            : }
    5479                 :            : 
    5480                 :            : bool
    5481                 :      63615 : HONOR_INFINITIES (const_tree t)
    5482                 :            : {
    5483                 :      63615 :   return HONOR_INFINITIES (element_mode (t));
    5484                 :            : }
    5485                 :            : 
    5486                 :            : bool
    5487                 :          0 : HONOR_INFINITIES (const_rtx x)
    5488                 :            : {
    5489                 :          0 :   return HONOR_INFINITIES (GET_MODE (x));
    5490                 :            : }
    5491                 :            : 
    5492                 :            : /* Like HONOR_NANS, but true if the given mode distinguishes between
    5493                 :            :    positive and negative zero, and the sign of zero is important.  */
    5494                 :            : 
    5495                 :            : bool
    5496                 :  286883000 : HONOR_SIGNED_ZEROS (machine_mode m)
    5497                 :            : {
    5498                 :  333496000 :   return MODE_HAS_SIGNED_ZEROS (m) && flag_signed_zeros;
    5499                 :            : }
    5500                 :            : 
    5501                 :            : bool
    5502                 :   34701300 : HONOR_SIGNED_ZEROS (const_tree t)
    5503                 :            : {
    5504                 :   34701300 :   return HONOR_SIGNED_ZEROS (element_mode (t));
    5505                 :            : }
    5506                 :            : 
    5507                 :            : bool
    5508                 :     432041 : HONOR_SIGNED_ZEROS (const_rtx x)
    5509                 :            : {
    5510                 :     432041 :   return HONOR_SIGNED_ZEROS (GET_MODE (x));
    5511                 :            : }
    5512                 :            : 
    5513                 :            : /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
    5514                 :            :    and the rounding mode is important.  */
    5515                 :            : 
    5516                 :            : bool
    5517                 :  173179000 : HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode m)
    5518                 :            : {
    5519                 :  185099000 :   return MODE_HAS_SIGN_DEPENDENT_ROUNDING (m) && flag_rounding_math;
    5520                 :            : }
    5521                 :            : 
    5522                 :            : bool
    5523                 :     212751 : HONOR_SIGN_DEPENDENT_ROUNDING (const_tree t)
    5524                 :            : {
    5525                 :     212751 :   return HONOR_SIGN_DEPENDENT_ROUNDING (element_mode (t));
    5526                 :            : }
    5527                 :            : 
    5528                 :            : bool
    5529                 :          0 : HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx x)
    5530                 :            : {
    5531                 :          0 :   return HONOR_SIGN_DEPENDENT_ROUNDING (GET_MODE (x));
    5532                 :            : }
    5533                 :            : 
    5534                 :            : /* Fills r with the largest value such that 1 + r*r won't overflow.
    5535                 :            :    This is used in both sin (atan (x)) and cos (atan(x)) optimizations. */
    5536                 :            : 
    5537                 :            : void
    5538                 :         96 : build_sinatan_real (REAL_VALUE_TYPE * r, tree type)
    5539                 :            : {
    5540                 :         96 :   REAL_VALUE_TYPE maxval;
    5541                 :         96 :   mpfr_t mpfr_const1, mpfr_c, mpfr_maxval;
    5542                 :         96 :   machine_mode mode = TYPE_MODE (type);
    5543                 :         96 :   const struct real_format * fmt = REAL_MODE_FORMAT (mode);
    5544                 :            : 
    5545                 :         96 :   real_maxval (&maxval, 0, mode);
    5546                 :            : 
    5547                 :         96 :   mpfr_inits (mpfr_const1, mpfr_c, mpfr_maxval, NULL);
    5548                 :            : 
    5549                 :         96 :   mpfr_from_real (mpfr_const1, &dconst1, MPFR_RNDN);
    5550                 :         96 :   mpfr_from_real (mpfr_maxval, &maxval,  MPFR_RNDN);
    5551                 :            : 
    5552                 :         96 :   mpfr_sub (mpfr_c, mpfr_maxval, mpfr_const1, MPFR_RNDN);
    5553                 :         96 :   mpfr_sqrt (mpfr_c, mpfr_c, MPFR_RNDZ);
    5554                 :            : 
    5555                 :         96 :   real_from_mpfr (r, mpfr_c, fmt, MPFR_RNDZ);
    5556                 :            :   
    5557                 :         96 :   mpfr_clears (mpfr_const1, mpfr_c, mpfr_maxval, NULL);
    5558                 :         96 : }

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.