LCOV - code coverage report
Current view: top level - gcc - real.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 7 7 100.0 %
Date: 2020-03-28 11:57:23 Functions: 3 3 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Definitions of floating-point access for GNU compiler.
       2                 :            :    Copyright (C) 1989-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            :    This file is part of GCC.
       5                 :            : 
       6                 :            :    GCC is free software; you can redistribute it and/or modify it under
       7                 :            :    the terms of the GNU General Public License as published by the Free
       8                 :            :    Software Foundation; either version 3, or (at your option) any later
       9                 :            :    version.
      10                 :            : 
      11                 :            :    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            :    WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            :    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            :    for more details.
      15                 :            : 
      16                 :            :    You should have received a copy of the GNU General Public License
      17                 :            :    along with GCC; see the file COPYING3.  If not see
      18                 :            :    <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #ifndef GCC_REAL_H
      21                 :            : #define GCC_REAL_H
      22                 :            : 
      23                 :            : /* An expanded form of the represented number.  */
      24                 :            : 
      25                 :            : /* Enumerate the special cases of numbers that we encounter.  */
      26                 :            : enum real_value_class {
      27                 :            :   rvc_zero,
      28                 :            :   rvc_normal,
      29                 :            :   rvc_inf,
      30                 :            :   rvc_nan
      31                 :            : };
      32                 :            : 
      33                 :            : #define SIGNIFICAND_BITS        (128 + HOST_BITS_PER_LONG)
      34                 :            : #define EXP_BITS                (32 - 6)
      35                 :            : #define MAX_EXP                 ((1 << (EXP_BITS - 1)) - 1)
      36                 :            : #define SIGSZ                   (SIGNIFICAND_BITS / HOST_BITS_PER_LONG)
      37                 :            : #define SIG_MSB                 ((unsigned long)1 << (HOST_BITS_PER_LONG - 1))
      38                 :            : 
      39                 :            : struct GTY(()) real_value {
      40                 :            :   /* Use the same underlying type for all bit-fields, so as to make
      41                 :            :      sure they're packed together, otherwise REAL_VALUE_TYPE_SIZE will
      42                 :            :      be miscomputed.  */
      43                 :            :   unsigned int /* ENUM_BITFIELD (real_value_class) */ cl : 2;
      44                 :            :   /* 1 if number is decimal floating point.  */
      45                 :            :   unsigned int decimal : 1;
      46                 :            :   /* 1 if number is negative.  */
      47                 :            :   unsigned int sign : 1;
      48                 :            :   /* 1 if number is signalling.  */
      49                 :            :   unsigned int signalling : 1;
      50                 :            :   /* 1 if number is canonical
      51                 :            :   All are generally used for handling cases in real.c.  */
      52                 :            :   unsigned int canonical : 1;
      53                 :            :   /* unbiased exponent of the number.  */
      54                 :            :   unsigned int uexp : EXP_BITS;
      55                 :            :   /* significand of the number.  */
      56                 :            :   unsigned long sig[SIGSZ];
      57                 :            : };
      58                 :            : 
      59                 :            : #define REAL_EXP(REAL) \
      60                 :            :   ((int)((REAL)->uexp ^ (unsigned int)(1 << (EXP_BITS - 1))) \
      61                 :            :    - (1 << (EXP_BITS - 1)))
      62                 :            : #define SET_REAL_EXP(REAL, EXP) \
      63                 :            :   ((REAL)->uexp = ((unsigned int)(EXP) & (unsigned int)((1 << EXP_BITS) - 1)))
      64                 :            : 
      65                 :            : /* Various headers condition prototypes on #ifdef REAL_VALUE_TYPE, so it
      66                 :            :    needs to be a macro.  We do need to continue to have a structure tag
      67                 :            :    so that other headers can forward declare it.  */
      68                 :            : #define REAL_VALUE_TYPE struct real_value
      69                 :            : 
      70                 :            : /* We store a REAL_VALUE_TYPE into an rtx, and we do this by putting it in
      71                 :            :    consecutive "w" slots.  Moreover, we've got to compute the number of "w"
      72                 :            :    slots at preprocessor time, which means we can't use sizeof.  Guess.  */
      73                 :            : 
      74                 :            : #define REAL_VALUE_TYPE_SIZE (SIGNIFICAND_BITS + 32)
      75                 :            : #define REAL_WIDTH \
      76                 :            :   (REAL_VALUE_TYPE_SIZE/HOST_BITS_PER_WIDE_INT \
      77                 :            :    + (REAL_VALUE_TYPE_SIZE%HOST_BITS_PER_WIDE_INT ? 1 : 0)) /* round up */
      78                 :            : 
      79                 :            : /* Verify the guess.  */
      80                 :            : extern char test_real_width
      81                 :            :   [sizeof (REAL_VALUE_TYPE) <= REAL_WIDTH * sizeof (HOST_WIDE_INT) ? 1 : -1];
      82                 :            : 
      83                 :            : /* Calculate the format for CONST_DOUBLE.  We need as many slots as
      84                 :            :    are necessary to overlay a REAL_VALUE_TYPE on them.  This could be
      85                 :            :    as many as four (32-bit HOST_WIDE_INT, 128-bit REAL_VALUE_TYPE).
      86                 :            : 
      87                 :            :    A number of places assume that there are always at least two 'w'
      88                 :            :    slots in a CONST_DOUBLE, so we provide them even if one would suffice.  */
      89                 :            : 
      90                 :            : #if REAL_WIDTH == 1
      91                 :            : # define CONST_DOUBLE_FORMAT     "ww"
      92                 :            : #else
      93                 :            : # if REAL_WIDTH == 2
      94                 :            : #  define CONST_DOUBLE_FORMAT    "ww"
      95                 :            : # else
      96                 :            : #  if REAL_WIDTH == 3
      97                 :            : #   define CONST_DOUBLE_FORMAT   "www"
      98                 :            : #  else
      99                 :            : #   if REAL_WIDTH == 4
     100                 :            : #    define CONST_DOUBLE_FORMAT  "wwww"
     101                 :            : #   else
     102                 :            : #    if REAL_WIDTH == 5
     103                 :            : #     define CONST_DOUBLE_FORMAT "wwwww"
     104                 :            : #    else
     105                 :            : #     if REAL_WIDTH == 6
     106                 :            : #      define CONST_DOUBLE_FORMAT "wwwwww"
     107                 :            : #     else
     108                 :            :        #error "REAL_WIDTH > 6 not supported"
     109                 :            : #     endif
     110                 :            : #    endif
     111                 :            : #   endif
     112                 :            : #  endif
     113                 :            : # endif
     114                 :            : #endif
     115                 :            : 
     116                 :            : 
     117                 :            : /* Describes the properties of the specific target format in use.  */
     118                 :            : struct real_format
     119                 :            : {
     120                 :            :   /* Move to and from the target bytes.  */
     121                 :            :   void (*encode) (const struct real_format *, long *,
     122                 :            :                   const REAL_VALUE_TYPE *);
     123                 :            :   void (*decode) (const struct real_format *, REAL_VALUE_TYPE *,
     124                 :            :                   const long *);
     125                 :            : 
     126                 :            :   /* The radix of the exponent and digits of the significand.  */
     127                 :            :   int b;
     128                 :            : 
     129                 :            :   /* Size of the significand in digits of radix B.  */
     130                 :            :   int p;
     131                 :            : 
     132                 :            :   /* Size of the significant of a NaN, in digits of radix B.  */
     133                 :            :   int pnan;
     134                 :            : 
     135                 :            :   /* The minimum negative integer, x, such that b**(x-1) is normalized.  */
     136                 :            :   int emin;
     137                 :            : 
     138                 :            :   /* The maximum integer, x, such that b**(x-1) is representable.  */
     139                 :            :   int emax;
     140                 :            : 
     141                 :            :   /* The bit position of the sign bit, for determining whether a value
     142                 :            :      is positive/negative, or -1 for a complex encoding.  */
     143                 :            :   int signbit_ro;
     144                 :            : 
     145                 :            :   /* The bit position of the sign bit, for changing the sign of a number,
     146                 :            :      or -1 for a complex encoding.  */
     147                 :            :   int signbit_rw;
     148                 :            : 
     149                 :            :   /* If this is an IEEE interchange format, the number of bits in the
     150                 :            :      format; otherwise, if it is an IEEE extended format, one more
     151                 :            :      than the greatest number of bits in an interchange format it
     152                 :            :      extends; otherwise 0.  Formats need not follow the IEEE 754-2008
     153                 :            :      recommended practice regarding how signaling NaNs are identified,
     154                 :            :      and may vary in the choice of default NaN, but must follow other
     155                 :            :      IEEE practice regarding having NaNs, infinities and subnormal
     156                 :            :      values, and the relation of minimum and maximum exponents, and,
     157                 :            :      for interchange formats, the details of the encoding.  */
     158                 :            :   int ieee_bits;
     159                 :            : 
     160                 :            :   /* Default rounding mode for operations on this format.  */
     161                 :            :   bool round_towards_zero;
     162                 :            :   bool has_sign_dependent_rounding;
     163                 :            : 
     164                 :            :   /* Properties of the format.  */
     165                 :            :   bool has_nans;
     166                 :            :   bool has_inf;
     167                 :            :   bool has_denorm;
     168                 :            :   bool has_signed_zero;
     169                 :            :   bool qnan_msb_set;
     170                 :            :   bool canonical_nan_lsbs_set;
     171                 :            :   const char *name;
     172                 :            : };
     173                 :            : 
     174                 :            : 
     175                 :            : /* The target format used for each floating point mode.
     176                 :            :    Float modes are followed by decimal float modes, with entries for
     177                 :            :    float modes indexed by (MODE - first float mode), and entries for
     178                 :            :    decimal float modes indexed by (MODE - first decimal float mode) +
     179                 :            :    the number of float modes.  */
     180                 :            : extern const struct real_format *
     181                 :            :   real_format_for_mode[MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1
     182                 :            :                        + MAX_MODE_DECIMAL_FLOAT - MIN_MODE_DECIMAL_FLOAT + 1];
     183                 :            : 
     184                 :            : #define REAL_MODE_FORMAT(MODE)                                          \
     185                 :            :   (real_format_for_mode[DECIMAL_FLOAT_MODE_P (MODE)                     \
     186                 :            :                         ? (((MODE) - MIN_MODE_DECIMAL_FLOAT)            \
     187                 :            :                            + (MAX_MODE_FLOAT - MIN_MODE_FLOAT + 1))     \
     188                 :            :                         : GET_MODE_CLASS (MODE) == MODE_FLOAT           \
     189                 :            :                         ? ((MODE) - MIN_MODE_FLOAT)                     \
     190                 :            :                         : (gcc_unreachable (), 0)])
     191                 :            : 
     192                 :            : #define FLOAT_MODE_FORMAT(MODE) \
     193                 :            :   (REAL_MODE_FORMAT (as_a <scalar_float_mode> (GET_MODE_INNER (MODE))))
     194                 :            : 
     195                 :            : /* The following macro determines whether the floating point format is
     196                 :            :    composite, i.e. may contain non-consecutive mantissa bits, in which
     197                 :            :    case compile-time FP overflow may not model run-time overflow.  */
     198                 :            : #define MODE_COMPOSITE_P(MODE) \
     199                 :            :   (FLOAT_MODE_P (MODE) \
     200                 :            :    && FLOAT_MODE_FORMAT (MODE)->pnan < FLOAT_MODE_FORMAT (MODE)->p)
     201                 :            : 
     202                 :            : /* Accessor macros for format properties.  */
     203                 :            : #define MODE_HAS_NANS(MODE) \
     204                 :            :   (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_nans)
     205                 :            : #define MODE_HAS_INFINITIES(MODE) \
     206                 :            :   (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_inf)
     207                 :            : #define MODE_HAS_SIGNED_ZEROS(MODE) \
     208                 :            :   (FLOAT_MODE_P (MODE) && FLOAT_MODE_FORMAT (MODE)->has_signed_zero)
     209                 :            : #define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE) \
     210                 :            :   (FLOAT_MODE_P (MODE) \
     211                 :            :    && FLOAT_MODE_FORMAT (MODE)->has_sign_dependent_rounding)
     212                 :            : 
     213                 :            : /* This class allows functions in this file to accept a floating-point
     214                 :            :    format as either a mode or an explicit real_format pointer.  In the
     215                 :            :    former case the mode must be VOIDmode (which means "no particular
     216                 :            :    format") or must satisfy SCALAR_FLOAT_MODE_P.  */
     217                 :            : class format_helper
     218                 :            : {
     219                 :            : public:
     220                 :      94783 :   format_helper (const real_format *format) : m_format (format) {}
     221                 :            :   template<typename T> format_helper (const T &);
     222                 :    8526890 :   const real_format *operator-> () const { return m_format; }
     223                 :   12972500 :   operator const real_format *() const { return m_format; }
     224                 :            : 
     225                 :    3357930 :   bool decimal_p () const { return m_format && m_format->b == 10; }
     226                 :            :   bool can_represent_integral_type_p (tree type) const;
     227                 :            : 
     228                 :            : private:
     229                 :            :   const real_format *m_format;
     230                 :            : };
     231                 :            : 
     232                 :            : template<typename T>
     233                 :    8950710 : inline format_helper::format_helper (const T &m)
     234                 :    8950710 :   : m_format (m == VOIDmode ? 0 : REAL_MODE_FORMAT (m))
     235                 :    8950710 : {}
     236                 :            : 
     237                 :            : /* Declare functions in real.c.  */
     238                 :            : 
     239                 :            : /* True if the given mode has a NaN representation and the treatment of
     240                 :            :    NaN operands is important.  Certain optimizations, such as folding
     241                 :            :    x * 0 into 0, are not correct for NaN operands, and are normally
     242                 :            :    disabled for modes with NaNs.  The user can ask for them to be
     243                 :            :    done anyway using the -funsafe-math-optimizations switch.  */
     244                 :            : extern bool HONOR_NANS (machine_mode);
     245                 :            : extern bool HONOR_NANS (const_tree);
     246                 :            : extern bool HONOR_NANS (const_rtx);
     247                 :            : 
     248                 :            : /* Like HONOR_NANs, but true if we honor signaling NaNs (or sNaNs).  */
     249                 :            : extern bool HONOR_SNANS (machine_mode);
     250                 :            : extern bool HONOR_SNANS (const_tree);
     251                 :            : extern bool HONOR_SNANS (const_rtx);
     252                 :            : 
     253                 :            : /* As for HONOR_NANS, but true if the mode can represent infinity and
     254                 :            :    the treatment of infinite values is important.  */
     255                 :            : extern bool HONOR_INFINITIES (machine_mode);
     256                 :            : extern bool HONOR_INFINITIES (const_tree);
     257                 :            : extern bool HONOR_INFINITIES (const_rtx);
     258                 :            : 
     259                 :            : /* Like HONOR_NANS, but true if the given mode distinguishes between
     260                 :            :    positive and negative zero, and the sign of zero is important.  */
     261                 :            : extern bool HONOR_SIGNED_ZEROS (machine_mode);
     262                 :            : extern bool HONOR_SIGNED_ZEROS (const_tree);
     263                 :            : extern bool HONOR_SIGNED_ZEROS (const_rtx);
     264                 :            : 
     265                 :            : /* Like HONOR_NANS, but true if given mode supports sign-dependent rounding,
     266                 :            :    and the rounding mode is important.  */
     267                 :            : extern bool HONOR_SIGN_DEPENDENT_ROUNDING (machine_mode);
     268                 :            : extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_tree);
     269                 :            : extern bool HONOR_SIGN_DEPENDENT_ROUNDING (const_rtx);
     270                 :            : 
     271                 :            : /* Binary or unary arithmetic on tree_code.  */
     272                 :            : extern bool real_arithmetic (REAL_VALUE_TYPE *, int, const REAL_VALUE_TYPE *,
     273                 :            :                              const REAL_VALUE_TYPE *);
     274                 :            : 
     275                 :            : /* Compare reals by tree_code.  */
     276                 :            : extern bool real_compare (int, const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     277                 :            : 
     278                 :            : /* Determine whether a floating-point value X is infinite.  */
     279                 :            : extern bool real_isinf (const REAL_VALUE_TYPE *);
     280                 :            : 
     281                 :            : /* Determine whether a floating-point value X is a NaN.  */
     282                 :            : extern bool real_isnan (const REAL_VALUE_TYPE *);
     283                 :            : 
     284                 :            : /* Determine whether a floating-point value X is a signaling NaN.  */
     285                 :            : extern bool real_issignaling_nan (const REAL_VALUE_TYPE *);
     286                 :            : 
     287                 :            : /* Determine whether a floating-point value X is finite.  */
     288                 :            : extern bool real_isfinite (const REAL_VALUE_TYPE *);
     289                 :            : 
     290                 :            : /* Determine whether a floating-point value X is negative.  */
     291                 :            : extern bool real_isneg (const REAL_VALUE_TYPE *);
     292                 :            : 
     293                 :            : /* Determine whether a floating-point value X is minus zero.  */
     294                 :            : extern bool real_isnegzero (const REAL_VALUE_TYPE *);
     295                 :            : 
     296                 :            : /* Test relationships between reals.  */
     297                 :            : extern bool real_identical (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     298                 :            : extern bool real_equal (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     299                 :            : extern bool real_less (const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     300                 :            : 
     301                 :            : /* Extend or truncate to a new format.  */
     302                 :            : extern void real_convert (REAL_VALUE_TYPE *, format_helper,
     303                 :            :                           const REAL_VALUE_TYPE *);
     304                 :            : 
     305                 :            : /* Return true if truncating to NEW is exact.  */
     306                 :            : extern bool exact_real_truncate (format_helper, const REAL_VALUE_TYPE *);
     307                 :            : 
     308                 :            : /* Render R as a decimal floating point constant.  */
     309                 :            : extern void real_to_decimal (char *, const REAL_VALUE_TYPE *, size_t,
     310                 :            :                              size_t, int);
     311                 :            : 
     312                 :            : /* Render R as a decimal floating point constant, rounded so as to be
     313                 :            :    parsed back to the same value when interpreted in mode MODE.  */
     314                 :            : extern void real_to_decimal_for_mode (char *, const REAL_VALUE_TYPE *, size_t,
     315                 :            :                                       size_t, int, machine_mode);
     316                 :            : 
     317                 :            : /* Render R as a hexadecimal floating point constant.  */
     318                 :            : extern void real_to_hexadecimal (char *, const REAL_VALUE_TYPE *,
     319                 :            :                                  size_t, size_t, int);
     320                 :            : 
     321                 :            : /* Render R as an integer.  */
     322                 :            : extern HOST_WIDE_INT real_to_integer (const REAL_VALUE_TYPE *);
     323                 :            : 
     324                 :            : /* Initialize R from a decimal or hexadecimal string.  Return -1 if
     325                 :            :    the value underflows, +1 if overflows, and 0 otherwise.  */
     326                 :            : extern int real_from_string (REAL_VALUE_TYPE *, const char *);
     327                 :            : /* Wrapper to allow different internal representation for decimal floats. */
     328                 :            : extern void real_from_string3 (REAL_VALUE_TYPE *, const char *, format_helper);
     329                 :            : 
     330                 :            : extern long real_to_target (long *, const REAL_VALUE_TYPE *, format_helper);
     331                 :            : 
     332                 :            : extern void real_from_target (REAL_VALUE_TYPE *, const long *,
     333                 :            :                               format_helper);
     334                 :            : 
     335                 :            : extern void real_inf (REAL_VALUE_TYPE *);
     336                 :            : 
     337                 :            : extern bool real_nan (REAL_VALUE_TYPE *, const char *, int, format_helper);
     338                 :            : 
     339                 :            : extern void real_maxval (REAL_VALUE_TYPE *, int, machine_mode);
     340                 :            : 
     341                 :            : extern void real_2expN (REAL_VALUE_TYPE *, int, format_helper);
     342                 :            : 
     343                 :            : extern unsigned int real_hash (const REAL_VALUE_TYPE *);
     344                 :            : 
     345                 :            : 
     346                 :            : /* Target formats defined in real.c.  */
     347                 :            : extern const struct real_format ieee_single_format;
     348                 :            : extern const struct real_format mips_single_format;
     349                 :            : extern const struct real_format motorola_single_format;
     350                 :            : extern const struct real_format spu_single_format;
     351                 :            : extern const struct real_format ieee_double_format;
     352                 :            : extern const struct real_format mips_double_format;
     353                 :            : extern const struct real_format motorola_double_format;
     354                 :            : extern const struct real_format ieee_extended_motorola_format;
     355                 :            : extern const struct real_format ieee_extended_intel_96_format;
     356                 :            : extern const struct real_format ieee_extended_intel_96_round_53_format;
     357                 :            : extern const struct real_format ieee_extended_intel_128_format;
     358                 :            : extern const struct real_format ibm_extended_format;
     359                 :            : extern const struct real_format mips_extended_format;
     360                 :            : extern const struct real_format ieee_quad_format;
     361                 :            : extern const struct real_format mips_quad_format;
     362                 :            : extern const struct real_format vax_f_format;
     363                 :            : extern const struct real_format vax_d_format;
     364                 :            : extern const struct real_format vax_g_format;
     365                 :            : extern const struct real_format real_internal_format;
     366                 :            : extern const struct real_format decimal_single_format;
     367                 :            : extern const struct real_format decimal_double_format;
     368                 :            : extern const struct real_format decimal_quad_format;
     369                 :            : extern const struct real_format ieee_half_format;
     370                 :            : extern const struct real_format arm_half_format;
     371                 :            : extern const struct real_format arm_bfloat_half_format;
     372                 :            : 
     373                 :            : 
     374                 :            : /* ====================================================================== */
     375                 :            : /* Crap.  */
     376                 :            : 
     377                 :            : /* Determine whether a floating-point value X is infinite.  */
     378                 :            : #define REAL_VALUE_ISINF(x)             real_isinf (&(x))
     379                 :            : 
     380                 :            : /* Determine whether a floating-point value X is a NaN.  */
     381                 :            : #define REAL_VALUE_ISNAN(x)             real_isnan (&(x))
     382                 :            : 
     383                 :            : /* Determine whether a floating-point value X is a signaling NaN.  */ 
     384                 :            : #define REAL_VALUE_ISSIGNALING_NAN(x)  real_issignaling_nan (&(x))
     385                 :            : 
     386                 :            : /* Determine whether a floating-point value X is negative.  */
     387                 :            : #define REAL_VALUE_NEGATIVE(x)          real_isneg (&(x))
     388                 :            : 
     389                 :            : /* Determine whether a floating-point value X is minus zero.  */
     390                 :            : #define REAL_VALUE_MINUS_ZERO(x)        real_isnegzero (&(x))
     391                 :            : 
     392                 :            : /* IN is a REAL_VALUE_TYPE.  OUT is an array of longs.  */
     393                 :            : #define REAL_VALUE_TO_TARGET_LONG_DOUBLE(IN, OUT)                       \
     394                 :            :   real_to_target (OUT, &(IN),                                               \
     395                 :            :                   float_mode_for_size (LONG_DOUBLE_TYPE_SIZE).require ())
     396                 :            : 
     397                 :            : #define REAL_VALUE_TO_TARGET_DOUBLE(IN, OUT) \
     398                 :            :   real_to_target (OUT, &(IN), float_mode_for_size (64).require ())
     399                 :            : 
     400                 :            : /* IN is a REAL_VALUE_TYPE.  OUT is a long.  */
     401                 :            : #define REAL_VALUE_TO_TARGET_SINGLE(IN, OUT) \
     402                 :            :   ((OUT) = real_to_target (NULL, &(IN), float_mode_for_size (32).require ()))
     403                 :            : 
     404                 :            : /* Real values to IEEE 754 decimal floats.  */
     405                 :            : 
     406                 :            : /* IN is a REAL_VALUE_TYPE.  OUT is an array of longs.  */
     407                 :            : #define REAL_VALUE_TO_TARGET_DECIMAL128(IN, OUT) \
     408                 :            :   real_to_target (OUT, &(IN), decimal_float_mode_for_size (128).require ())
     409                 :            : 
     410                 :            : #define REAL_VALUE_TO_TARGET_DECIMAL64(IN, OUT) \
     411                 :            :   real_to_target (OUT, &(IN), decimal_float_mode_for_size (64).require ())
     412                 :            : 
     413                 :            : /* IN is a REAL_VALUE_TYPE.  OUT is a long.  */
     414                 :            : #define REAL_VALUE_TO_TARGET_DECIMAL32(IN, OUT) \
     415                 :            :   ((OUT) = real_to_target (NULL, &(IN), \
     416                 :            :                            decimal_float_mode_for_size (32).require ()))
     417                 :            : 
     418                 :            : extern REAL_VALUE_TYPE real_value_truncate (format_helper, REAL_VALUE_TYPE);
     419                 :            : 
     420                 :            : extern REAL_VALUE_TYPE real_value_negate (const REAL_VALUE_TYPE *);
     421                 :            : extern REAL_VALUE_TYPE real_value_abs (const REAL_VALUE_TYPE *);
     422                 :            : 
     423                 :            : extern int significand_size (format_helper);
     424                 :            : 
     425                 :            : extern REAL_VALUE_TYPE real_from_string2 (const char *, format_helper);
     426                 :            : 
     427                 :            : #define REAL_VALUE_ATOF(s, m) \
     428                 :            :   real_from_string2 (s, m)
     429                 :            : 
     430                 :            : #define CONST_DOUBLE_ATOF(s, m) \
     431                 :            :   const_double_from_real_value (real_from_string2 (s, m), m)
     432                 :            : 
     433                 :            : #define REAL_VALUE_FIX(r) \
     434                 :            :   real_to_integer (&(r))
     435                 :            : 
     436                 :            : /* ??? Not quite right.  */
     437                 :            : #define REAL_VALUE_UNSIGNED_FIX(r) \
     438                 :            :   real_to_integer (&(r))
     439                 :            : 
     440                 :            : /* ??? These were added for Paranoia support.  */
     441                 :            : 
     442                 :            : /* Return floor log2(R).  */
     443                 :            : extern int real_exponent (const REAL_VALUE_TYPE *);
     444                 :            : 
     445                 :            : /* R = A * 2**EXP.  */
     446                 :            : extern void real_ldexp (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, int);
     447                 :            : 
     448                 :            : /* **** End of software floating point emulator interface macros **** */
     449                 :            : 
     450                 :            : /* Constant real values 0, 1, 2, -1 and 0.5.  */
     451                 :            : 
     452                 :            : extern REAL_VALUE_TYPE dconst0;
     453                 :            : extern REAL_VALUE_TYPE dconst1;
     454                 :            : extern REAL_VALUE_TYPE dconst2;
     455                 :            : extern REAL_VALUE_TYPE dconstm1;
     456                 :            : extern REAL_VALUE_TYPE dconsthalf;
     457                 :            : 
     458                 :            : #define dconst_e() (*dconst_e_ptr ())
     459                 :            : #define dconst_third() (*dconst_third_ptr ())
     460                 :            : #define dconst_quarter() (*dconst_quarter_ptr ())
     461                 :            : #define dconst_sixth() (*dconst_sixth_ptr ())
     462                 :            : #define dconst_ninth() (*dconst_ninth_ptr ())
     463                 :            : #define dconst_sqrt2() (*dconst_sqrt2_ptr ())
     464                 :            : 
     465                 :            : /* Function to return the real value special constant 'e'.  */
     466                 :            : extern const REAL_VALUE_TYPE * dconst_e_ptr (void);
     467                 :            : 
     468                 :            : /* Returns a cached REAL_VALUE_TYPE corresponding to 1/n, for various n.  */
     469                 :            : extern const REAL_VALUE_TYPE *dconst_third_ptr (void);
     470                 :            : extern const REAL_VALUE_TYPE *dconst_quarter_ptr (void);
     471                 :            : extern const REAL_VALUE_TYPE *dconst_sixth_ptr (void);
     472                 :            : extern const REAL_VALUE_TYPE *dconst_ninth_ptr (void);
     473                 :            : 
     474                 :            : /* Returns the special REAL_VALUE_TYPE corresponding to sqrt(2).  */
     475                 :            : extern const REAL_VALUE_TYPE * dconst_sqrt2_ptr (void);
     476                 :            : 
     477                 :            : /* Function to return a real value (not a tree node)
     478                 :            :    from a given integer constant.  */
     479                 :            : REAL_VALUE_TYPE real_value_from_int_cst (const_tree, const_tree);
     480                 :            : 
     481                 :            : /* Return a CONST_DOUBLE with value R and mode M.  */
     482                 :            : extern rtx const_double_from_real_value (REAL_VALUE_TYPE, machine_mode);
     483                 :            : 
     484                 :            : /* Replace R by 1/R in the given format, if the result is exact.  */
     485                 :            : extern bool exact_real_inverse (format_helper, REAL_VALUE_TYPE *);
     486                 :            : 
     487                 :            : /* Return true if arithmetic on values in IMODE that were promoted
     488                 :            :    from values in TMODE is equivalent to direct arithmetic on values
     489                 :            :    in TMODE.  */
     490                 :            : bool real_can_shorten_arithmetic (machine_mode, machine_mode);
     491                 :            : 
     492                 :            : /* In tree.c: wrap up a REAL_VALUE_TYPE in a tree node.  */
     493                 :            : extern tree build_real (tree, REAL_VALUE_TYPE);
     494                 :            : 
     495                 :            : /* Likewise, but first truncate the value to the type.  */
     496                 :            : extern tree build_real_truncate (tree, REAL_VALUE_TYPE);
     497                 :            : 
     498                 :            : /* Calculate R as X raised to the integer exponent N in format FMT.  */
     499                 :            : extern bool real_powi (REAL_VALUE_TYPE *, format_helper,
     500                 :            :                        const REAL_VALUE_TYPE *, HOST_WIDE_INT);
     501                 :            : 
     502                 :            : /* Standard round to integer value functions.  */
     503                 :            : extern void real_trunc (REAL_VALUE_TYPE *, format_helper,
     504                 :            :                         const REAL_VALUE_TYPE *);
     505                 :            : extern void real_floor (REAL_VALUE_TYPE *, format_helper,
     506                 :            :                         const REAL_VALUE_TYPE *);
     507                 :            : extern void real_ceil (REAL_VALUE_TYPE *, format_helper,
     508                 :            :                        const REAL_VALUE_TYPE *);
     509                 :            : extern void real_round (REAL_VALUE_TYPE *, format_helper,
     510                 :            :                         const REAL_VALUE_TYPE *);
     511                 :            : extern void real_roundeven (REAL_VALUE_TYPE *, format_helper,
     512                 :            :                             const REAL_VALUE_TYPE *);
     513                 :            : 
     514                 :            : /* Set the sign of R to the sign of X.  */
     515                 :            : extern void real_copysign (REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     516                 :            : 
     517                 :            : /* Check whether the real constant value given is an integer.  */
     518                 :            : extern bool real_isinteger (const REAL_VALUE_TYPE *, format_helper);
     519                 :            : extern bool real_isinteger (const REAL_VALUE_TYPE *, HOST_WIDE_INT *);
     520                 :            : 
     521                 :            : /* Calculate nextafter (X, Y) in format FMT.  */
     522                 :            : extern bool real_nextafter (REAL_VALUE_TYPE *, format_helper,
     523                 :            :                             const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *);
     524                 :            : 
     525                 :            : /* Write into BUF the maximum representable finite floating-point
     526                 :            :    number, (1 - b**-p) * b**emax for a given FP format FMT as a hex
     527                 :            :    float string.  BUF must be large enough to contain the result.  */
     528                 :            : extern void get_max_float (const struct real_format *, char *, size_t, bool);
     529                 :            : 
     530                 :            : #ifndef GENERATOR_FILE
     531                 :            : /* real related routines.  */
     532                 :            : extern wide_int real_to_integer (const REAL_VALUE_TYPE *, bool *, int);
     533                 :            : extern void real_from_integer (REAL_VALUE_TYPE *, format_helper,
     534                 :            :                                const wide_int_ref &, signop);
     535                 :            : #endif
     536                 :            : 
     537                 :            : /* Fills r with the largest value such that 1 + r*r won't overflow.
     538                 :            :    This is used in both sin (atan (x)) and cos (atan(x)) optimizations. */
     539                 :            : extern void build_sinatan_real (REAL_VALUE_TYPE *, tree); 
     540                 :            : 
     541                 :            : #endif /* ! GCC_REAL_H */

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.