LCOV - code coverage report
Current view: top level - gcc/c-family - c-cppbuiltin.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 812 928 87.5 %
Date: 2020-03-28 11:57:23 Functions: 20 23 87.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Define builtin-in macros for the C family front ends.
       2                 :            :    Copyright (C) 2002-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                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "target.h"
      24                 :            : #include "c-common.h"
      25                 :            : #include "memmodel.h"
      26                 :            : #include "tm_p.h"             /* For TARGET_CPU_CPP_BUILTINS & friends.  */
      27                 :            : #include "stringpool.h"
      28                 :            : #include "stor-layout.h"
      29                 :            : #include "flags.h"
      30                 :            : #include "c-pragma.h"
      31                 :            : #include "output.h"           /* For user_label_prefix.  */
      32                 :            : #include "debug.h"            /* For dwarf2out_do_cfi_asm.  */
      33                 :            : #include "common/common-target.h"
      34                 :            : #include "cppbuiltin.h"
      35                 :            : 
      36                 :            : #ifndef TARGET_OS_CPP_BUILTINS
      37                 :            : # define TARGET_OS_CPP_BUILTINS()
      38                 :            : #endif
      39                 :            : 
      40                 :            : #ifndef TARGET_OBJFMT_CPP_BUILTINS
      41                 :            : # define TARGET_OBJFMT_CPP_BUILTINS()
      42                 :            : #endif
      43                 :            : 
      44                 :            : #ifndef REGISTER_PREFIX
      45                 :            : #define REGISTER_PREFIX ""
      46                 :            : #endif
      47                 :            : 
      48                 :            : /* Non-static as some targets don't use it.  */
      49                 :            : static void builtin_define_with_hex_fp_value (const char *, tree,
      50                 :            :                                               int, const char *,
      51                 :            :                                               const char *,
      52                 :            :                                               const char *);
      53                 :            : static void builtin_define_stdint_macros (void);
      54                 :            : static void builtin_define_constants (const char *, tree);
      55                 :            : static void builtin_define_type_max (const char *, tree);
      56                 :            : static void builtin_define_type_minmax (const char *, const char *, tree);
      57                 :            : static void builtin_define_type_width (const char *, tree, tree);
      58                 :            : static void builtin_define_float_constants (const char *,
      59                 :            :                                             const char *,
      60                 :            :                                             const char *,
      61                 :            :                                             const char *,
      62                 :            :                                             tree);
      63                 :            : 
      64                 :            : /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
      65                 :            :    Originally this function used the fma optab, but that doesn't work with
      66                 :            :    -save-temps, so just rely on the HAVE_fma macros for the standard floating
      67                 :            :    point types.  */
      68                 :            : 
      69                 :            : static bool
      70                 :    1253500 : mode_has_fma (machine_mode mode)
      71                 :            : {
      72                 :    1253500 :   switch (mode)
      73                 :            :     {
      74                 :            : #ifdef HAVE_fmasf4
      75                 :     313374 :     case E_SFmode:
      76                 :     313374 :       return !!HAVE_fmasf4;
      77                 :            : #endif
      78                 :            : 
      79                 :            : #ifdef HAVE_fmadf4
      80                 :     470074 :     case E_DFmode:
      81                 :     470074 :       return !!HAVE_fmadf4;
      82                 :            : #endif
      83                 :            : 
      84                 :            : #ifdef HAVE_fmakf4      /* PowerPC if long double != __float128.  */
      85                 :            :     case E_KFmode:
      86                 :            :       return !!HAVE_fmakf4;
      87                 :            : #endif
      88                 :            : 
      89                 :            : #ifdef HAVE_fmaxf4
      90                 :            :     case E_XFmode:
      91                 :            :       return !!HAVE_fmaxf4;
      92                 :            : #endif
      93                 :            : 
      94                 :            : #ifdef HAVE_fmatf4
      95                 :            :     case E_TFmode:
      96                 :            :       return !!HAVE_fmatf4;
      97                 :            : #endif
      98                 :            : 
      99                 :            :     default:
     100                 :            :       break;
     101                 :            :     }
     102                 :            : 
     103                 :            :   return false;
     104                 :            : }
     105                 :            : 
     106                 :            : /* Define NAME with value TYPE size_unit.  */
     107                 :            : void
     108                 :     622343 : builtin_define_type_sizeof (const char *name, tree type)
     109                 :            : {
     110                 :     622343 :   builtin_define_with_int_value (name,
     111                 :     622343 :                                  tree_to_uhwi (TYPE_SIZE_UNIT (type)));
     112                 :     622343 : }
     113                 :            : 
     114                 :            : /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
     115                 :            :    and FP_CAST. */
     116                 :            : static void
     117                 :    1253500 : builtin_define_float_constants (const char *name_prefix,
     118                 :            :                                 const char *fp_suffix,
     119                 :            :                                 const char *fp_cast,
     120                 :            :                                 const char *fma_suffix,
     121                 :            :                                 tree type)
     122                 :            : {
     123                 :            :   /* Used to convert radix-based values to base 10 values in several cases.
     124                 :            : 
     125                 :            :      In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
     126                 :            :      least 6 significant digits for correct results.  Using the fraction
     127                 :            :      formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
     128                 :            :      intermediate; perhaps someone can find a better approximation, in the
     129                 :            :      mean time, I suspect using doubles won't harm the bootstrap here.  */
     130                 :            : 
     131                 :    1253500 :   const double log10_2 = .30102999566398119521;
     132                 :    1253500 :   double log10_b;
     133                 :    1253500 :   const struct real_format *fmt;
     134                 :    1253500 :   const struct real_format *widefmt;
     135                 :            : 
     136                 :    1253500 :   char name[64], buf[128];
     137                 :    1253500 :   int dig, min_10_exp, max_10_exp;
     138                 :    1253500 :   int decimal_dig;
     139                 :    1253500 :   int type_decimal_dig;
     140                 :            : 
     141                 :    3760490 :   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
     142                 :    1253500 :   gcc_assert (fmt->b != 10);
     143                 :    1253500 :   widefmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
     144                 :    1253500 :   gcc_assert (widefmt->b != 10);
     145                 :   10028000 :   for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
     146                 :            :     {
     147                 :    8774470 :       tree wtype = FLOATN_NX_TYPE_NODE (i);
     148                 :    8774470 :       if (wtype != NULL_TREE)
     149                 :            :         {
     150                 :    6267480 :           const struct real_format *wfmt
     151                 :   18802400 :             = REAL_MODE_FORMAT (TYPE_MODE (wtype));
     152                 :    6267480 :           gcc_assert (wfmt->b != 10);
     153                 :    6267480 :           if (wfmt->p > widefmt->p)
     154                 :    1253450 :             widefmt = wfmt;
     155                 :            :         }
     156                 :            :     }
     157                 :            : 
     158                 :            :   /* The radix of the exponent representation.  */
     159                 :    1253500 :   if (type == float_type_node)
     160                 :     156687 :     builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
     161                 :    1253500 :   log10_b = log10_2;
     162                 :            : 
     163                 :            :   /* The number of radix digits, p, in the floating-point significand.  */
     164                 :    1253500 :   sprintf (name, "__%s_MANT_DIG__", name_prefix);
     165                 :    1253500 :   builtin_define_with_int_value (name, fmt->p);
     166                 :            : 
     167                 :            :   /* The number of decimal digits, q, such that any floating-point number
     168                 :            :      with q decimal digits can be rounded into a floating-point number with
     169                 :            :      p radix b digits and back again without change to the q decimal digits,
     170                 :            : 
     171                 :            :         p log10 b                       if b is a power of 10
     172                 :            :         floor((p - 1) log10 b)          otherwise
     173                 :            :   */
     174                 :    1253500 :   dig = (fmt->p - 1) * log10_b;
     175                 :    1253500 :   sprintf (name, "__%s_DIG__", name_prefix);
     176                 :    1253500 :   builtin_define_with_int_value (name, dig);
     177                 :            : 
     178                 :            :   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
     179                 :    1253500 :   sprintf (name, "__%s_MIN_EXP__", name_prefix);
     180                 :    1253500 :   sprintf (buf, "(%d)", fmt->emin);
     181                 :    1253500 :   builtin_define_with_value (name, buf, 0);
     182                 :            : 
     183                 :            :   /* The minimum negative int x such that 10**x is a normalized float,
     184                 :            : 
     185                 :            :           ceil (log10 (b ** (emin - 1)))
     186                 :            :         = ceil (log10 (b) * (emin - 1))
     187                 :            : 
     188                 :            :      Recall that emin is negative, so the integer truncation calculates
     189                 :            :      the ceiling, not the floor, in this case.  */
     190                 :    1253500 :   min_10_exp = (fmt->emin - 1) * log10_b;
     191                 :    1253500 :   sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
     192                 :    1253500 :   sprintf (buf, "(%d)", min_10_exp);
     193                 :    1253500 :   builtin_define_with_value (name, buf, 0);
     194                 :            : 
     195                 :            :   /* The maximum int x such that b**(x-1) is a representable float.  */
     196                 :    1253500 :   sprintf (name, "__%s_MAX_EXP__", name_prefix);
     197                 :    1253500 :   builtin_define_with_int_value (name, fmt->emax);
     198                 :            : 
     199                 :            :   /* The maximum int x such that 10**x is in the range of representable
     200                 :            :      finite floating-point numbers,
     201                 :            : 
     202                 :            :           floor (log10((1 - b**-p) * b**emax))
     203                 :            :         = floor (log10(1 - b**-p) + log10(b**emax))
     204                 :            :         = floor (log10(1 - b**-p) + log10(b)*emax)
     205                 :            : 
     206                 :            :      The safest thing to do here is to just compute this number.  But since
     207                 :            :      we don't link cc1 with libm, we cannot.  We could implement log10 here
     208                 :            :      a series expansion, but that seems too much effort because:
     209                 :            : 
     210                 :            :      Note that the first term, for all extant p, is a number exceedingly close
     211                 :            :      to zero, but slightly negative.  Note that the second term is an integer
     212                 :            :      scaling an irrational number, and that because of the floor we are only
     213                 :            :      interested in its integral portion.
     214                 :            : 
     215                 :            :      In order for the first term to have any effect on the integral portion
     216                 :            :      of the second term, the second term has to be exceedingly close to an
     217                 :            :      integer itself (e.g. 123.000000000001 or something).  Getting a result
     218                 :            :      that close to an integer requires that the irrational multiplicand have
     219                 :            :      a long series of zeros in its expansion, which doesn't occur in the
     220                 :            :      first 20 digits or so of log10(b).
     221                 :            : 
     222                 :            :      Hand-waving aside, crunching all of the sets of constants above by hand
     223                 :            :      does not yield a case for which the first term is significant, which
     224                 :            :      in the end is all that matters.  */
     225                 :    1253500 :   max_10_exp = fmt->emax * log10_b;
     226                 :    1253500 :   sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
     227                 :    1253500 :   builtin_define_with_int_value (name, max_10_exp);
     228                 :            : 
     229                 :            :   /* The number of decimal digits, n, such that any floating-point number
     230                 :            :      can be rounded to n decimal digits and back again without change to
     231                 :            :      the value.
     232                 :            : 
     233                 :            :         p * log10(b)                    if b is a power of 10
     234                 :            :         ceil(1 + p * log10(b))          otherwise
     235                 :            : 
     236                 :            :      The only macro we care about is this number for the widest supported
     237                 :            :      floating type, but we want this value for rendering constants below.  */
     238                 :    1253500 :   {
     239                 :    2506990 :     double d_decimal_dig
     240                 :    1253500 :       = 1 + (fmt->p < widefmt->p ? widefmt->p : fmt->p) * log10_b;
     241                 :    1253500 :     decimal_dig = d_decimal_dig;
     242                 :    1253500 :     if (decimal_dig < d_decimal_dig)
     243                 :    1253500 :       decimal_dig++;
     244                 :            :   }
     245                 :            :   /* Similar, for this type rather than long double.  */
     246                 :    1253500 :   {
     247                 :    1253500 :     double type_d_decimal_dig = 1 + fmt->p * log10_b;
     248                 :    1253500 :     type_decimal_dig = type_d_decimal_dig;
     249                 :    1253500 :     if (type_decimal_dig < type_d_decimal_dig)
     250                 :    1253500 :       type_decimal_dig++;
     251                 :            :   }
     252                 :            :   /* Define __DECIMAL_DIG__ to the value for long double to be
     253                 :            :      compatible with C99 and C11; see DR#501 and N2108.  */
     254                 :    1253500 :   if (type == long_double_type_node)
     255                 :     156687 :     builtin_define_with_int_value ("__DECIMAL_DIG__", type_decimal_dig);
     256                 :    1253500 :   sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
     257                 :    1253500 :   builtin_define_with_int_value (name, type_decimal_dig);
     258                 :            : 
     259                 :            :   /* Since, for the supported formats, B is always a power of 2, we
     260                 :            :      construct the following numbers directly as a hexadecimal
     261                 :            :      constants.  */
     262                 :    1253500 :   get_max_float (fmt, buf, sizeof (buf), false);
     263                 :            : 
     264                 :    1253500 :   sprintf (name, "__%s_MAX__", name_prefix);
     265                 :    1253500 :   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
     266                 :            : 
     267                 :    1253500 :   get_max_float (fmt, buf, sizeof (buf), true);
     268                 :            : 
     269                 :    1253500 :   sprintf (name, "__%s_NORM_MAX__", name_prefix);
     270                 :    1253500 :   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
     271                 :            : 
     272                 :            :   /* The minimum normalized positive floating-point number,
     273                 :            :      b**(emin-1).  */
     274                 :    1253500 :   sprintf (name, "__%s_MIN__", name_prefix);
     275                 :    1253500 :   sprintf (buf, "0x1p%d", fmt->emin - 1);
     276                 :    1253500 :   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
     277                 :            : 
     278                 :            :   /* The difference between 1 and the least value greater than 1 that is
     279                 :            :      representable in the given floating point type, b**(1-p).  */
     280                 :    1253500 :   sprintf (name, "__%s_EPSILON__", name_prefix);
     281                 :    1253500 :   if (fmt->pnan < fmt->p)
     282                 :            :     /* This is an IBM extended double format, so 1.0 + any double is
     283                 :            :        representable precisely.  */
     284                 :          0 :       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
     285                 :            :     else
     286                 :    1253500 :       sprintf (buf, "0x1p%d", 1 - fmt->p);
     287                 :    1253500 :   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
     288                 :            : 
     289                 :            :   /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
     290                 :            :      The minimum denormalized positive floating-point number, b**(emin-p).
     291                 :            :      The minimum normalized positive floating-point number for formats
     292                 :            :      that don't support denormals.  */
     293                 :    1253500 :   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
     294                 :    1253500 :   sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
     295                 :    1253500 :   builtin_define_with_hex_fp_value (name, type, decimal_dig,
     296                 :            :                                     buf, fp_suffix, fp_cast);
     297                 :            : 
     298                 :    1253500 :   sprintf (name, "__%s_HAS_DENORM__", name_prefix);
     299                 :    1253500 :   builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
     300                 :            : 
     301                 :            :   /* For C++ std::numeric_limits<T>::has_infinity.  */
     302                 :    1253500 :   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
     303                 :    2506990 :   builtin_define_with_int_value (name,
     304                 :    8774470 :                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
     305                 :            :   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
     306                 :            :      predicate to distinguish a target that has both quiet and
     307                 :            :      signalling NaNs from a target that has only quiet NaNs or only
     308                 :            :      signalling NaNs, so we assume that a target that has any kind of
     309                 :            :      NaN has quiet NaNs.  */
     310                 :    1253500 :   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
     311                 :    8774470 :   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
     312                 :            : 
     313                 :            :   /* Note whether we have fast FMA.  */
     314                 :    1253500 :   if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
     315                 :            :     {
     316                 :      15250 :       sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
     317                 :      15250 :       builtin_define_with_int_value (name, 1);
     318                 :            :     }
     319                 :    1253500 : }
     320                 :            : 
     321                 :            : /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
     322                 :            : static void
     323                 :     470061 : builtin_define_decimal_float_constants (const char *name_prefix,
     324                 :            :                                         const char *suffix,
     325                 :            :                                         tree type)
     326                 :            : {
     327                 :     470061 :   const struct real_format *fmt;
     328                 :     470061 :   char name[64], buf[128], *p;
     329                 :     470061 :   int digits;
     330                 :            : 
     331                 :     940122 :   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
     332                 :            : 
     333                 :            :   /* The number of radix digits, p, in the significand.  */
     334                 :     470061 :   sprintf (name, "__%s_MANT_DIG__", name_prefix);
     335                 :     470061 :   builtin_define_with_int_value (name, fmt->p);
     336                 :            : 
     337                 :            :   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
     338                 :     470061 :   sprintf (name, "__%s_MIN_EXP__", name_prefix);
     339                 :     470061 :   sprintf (buf, "(%d)", fmt->emin);
     340                 :     470061 :   builtin_define_with_value (name, buf, 0);
     341                 :            : 
     342                 :            :   /* The maximum int x such that b**(x-1) is a representable float.  */
     343                 :     470061 :   sprintf (name, "__%s_MAX_EXP__", name_prefix);
     344                 :     470061 :   builtin_define_with_int_value (name, fmt->emax);
     345                 :            : 
     346                 :            :   /* Compute the minimum representable value.  */
     347                 :     470061 :   sprintf (name, "__%s_MIN__", name_prefix);
     348                 :     470061 :   sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
     349                 :     470061 :   builtin_define_with_value (name, buf, 0);
     350                 :            : 
     351                 :            :   /* Compute the maximum representable value.  */
     352                 :     470061 :   sprintf (name, "__%s_MAX__", name_prefix);
     353                 :     470061 :   p = buf;
     354                 :    9401220 :   for (digits = fmt->p; digits; digits--)
     355                 :            :     {
     356                 :    8931160 :       *p++ = '9';
     357                 :    8931160 :       if (digits == fmt->p)
     358                 :     470061 :         *p++ = '.';
     359                 :            :     }
     360                 :     470061 :   *p = 0;
     361                 :            :   /* fmt->p plus 1, to account for the decimal point and fmt->emax
     362                 :            :      minus 1 because the digits are nines, not 1.0.  */
     363                 :     470061 :   sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
     364                 :     470061 :   builtin_define_with_value (name, buf, 0);
     365                 :            : 
     366                 :            :   /* Compute epsilon (the difference between 1 and least value greater
     367                 :            :      than 1 representable).  */
     368                 :     470061 :   sprintf (name, "__%s_EPSILON__", name_prefix);
     369                 :     470061 :   sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
     370                 :     470061 :   builtin_define_with_value (name, buf, 0);
     371                 :            : 
     372                 :            :   /* Minimum subnormal positive decimal value.  */
     373                 :     470061 :   sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
     374                 :     470061 :   p = buf;
     375                 :    8931160 :   for (digits = fmt->p; digits > 1; digits--)
     376                 :            :     {
     377                 :    8461100 :       *p++ = '0';
     378                 :    8461100 :       if (digits == fmt->p)
     379                 :     470061 :         *p++ = '.';
     380                 :            :     }
     381                 :     470061 :   *p = 0;
     382                 :     470061 :   sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
     383                 :     470061 :   builtin_define_with_value (name, buf, 0);
     384                 :     470061 : }
     385                 :            : 
     386                 :            : /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX.  */
     387                 :            : 
     388                 :            : static void
     389                 :          0 : builtin_define_fixed_point_constants (const char *name_prefix,
     390                 :            :                                       const char *suffix,
     391                 :            :                                       tree type)
     392                 :            : {
     393                 :          0 :   char name[64], buf[256], *new_buf;
     394                 :          0 :   int i, mod;
     395                 :            : 
     396                 :          0 :   sprintf (name, "__%s_FBIT__", name_prefix);
     397                 :          0 :   builtin_define_with_int_value (name, TYPE_FBIT (type));
     398                 :            : 
     399                 :          0 :   sprintf (name, "__%s_IBIT__", name_prefix);
     400                 :          0 :   builtin_define_with_int_value (name, TYPE_IBIT (type));
     401                 :            : 
     402                 :            :   /* If there is no suffix, defines are for fixed-point modes.
     403                 :            :      We just return.  */
     404                 :          0 :   if (strcmp (suffix, "") == 0)
     405                 :          0 :     return;
     406                 :            : 
     407                 :          0 :   if (TYPE_UNSIGNED (type))
     408                 :            :     {
     409                 :          0 :       sprintf (name, "__%s_MIN__", name_prefix);
     410                 :          0 :       sprintf (buf, "0.0%s", suffix);
     411                 :          0 :       builtin_define_with_value (name, buf, 0);
     412                 :            :     }
     413                 :            :   else
     414                 :            :     {
     415                 :          0 :       sprintf (name, "__%s_MIN__", name_prefix);
     416                 :          0 :       if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
     417                 :          0 :         sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
     418                 :          0 :                  TYPE_IBIT (type) - 1, suffix);
     419                 :            :       else
     420                 :          0 :         sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
     421                 :          0 :       builtin_define_with_value (name, buf, 0);
     422                 :            :     }
     423                 :            : 
     424                 :          0 :   sprintf (name, "__%s_MAX__", name_prefix);
     425                 :          0 :   sprintf (buf, "0X");
     426                 :          0 :   new_buf = buf + 2;
     427                 :          0 :   mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
     428                 :          0 :   if (mod)
     429                 :          0 :     sprintf (new_buf++, "%x", (1 << mod) - 1);
     430                 :          0 :   for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
     431                 :          0 :     sprintf (new_buf++, "F");
     432                 :          0 :   sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
     433                 :          0 :   builtin_define_with_value (name, buf, 0);
     434                 :            : 
     435                 :          0 :   sprintf (name, "__%s_EPSILON__", name_prefix);
     436                 :          0 :   sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
     437                 :          0 :   builtin_define_with_value (name, buf, 0);
     438                 :            : }
     439                 :            : 
     440                 :            : /* Define macros used by <stdint.h>.  */
     441                 :            : static void
     442                 :     156687 : builtin_define_stdint_macros (void)
     443                 :            : {
     444                 :     313374 :   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
     445                 :     156687 :   builtin_define_constants ("__INTMAX_C", intmax_type_node);
     446                 :     313374 :   builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
     447                 :     156687 :   builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
     448                 :     156687 :   builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node,
     449                 :            :                              uintmax_type_node);
     450                 :     156687 :   if (sig_atomic_type_node)
     451                 :            :     {
     452                 :     156687 :       builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
     453                 :            :                                   sig_atomic_type_node);
     454                 :     156687 :       builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node,
     455                 :            :                                  NULL_TREE);
     456                 :            :     }
     457                 :     156687 :   if (int8_type_node)
     458                 :     313374 :     builtin_define_type_max ("__INT8_MAX__", int8_type_node);
     459                 :     156687 :   if (int16_type_node)
     460                 :     313374 :     builtin_define_type_max ("__INT16_MAX__", int16_type_node);
     461                 :     156687 :   if (int32_type_node)
     462                 :     313374 :     builtin_define_type_max ("__INT32_MAX__", int32_type_node);
     463                 :     156687 :   if (int64_type_node)
     464                 :     313374 :     builtin_define_type_max ("__INT64_MAX__", int64_type_node);
     465                 :     156687 :   if (uint8_type_node)
     466                 :     313374 :     builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
     467                 :     156687 :   if (c_uint16_type_node)
     468                 :     313374 :     builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
     469                 :     156687 :   if (c_uint32_type_node)
     470                 :     313374 :     builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
     471                 :     156687 :   if (c_uint64_type_node)
     472                 :     313374 :     builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
     473                 :     156687 :   if (int_least8_type_node)
     474                 :            :     {
     475                 :     313374 :       builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
     476                 :     156687 :       builtin_define_constants ("__INT8_C", int_least8_type_node);
     477                 :     156687 :       builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node,
     478                 :            :                                  uint_least8_type_node);
     479                 :            :     }
     480                 :     156687 :   if (int_least16_type_node)
     481                 :            :     {
     482                 :     313374 :       builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
     483                 :     156687 :       builtin_define_constants ("__INT16_C", int_least16_type_node);
     484                 :     156687 :       builtin_define_type_width ("__INT_LEAST16_WIDTH__",
     485                 :            :                                  int_least16_type_node,
     486                 :            :                                  uint_least16_type_node);
     487                 :            :     }
     488                 :     156687 :   if (int_least32_type_node)
     489                 :            :     {
     490                 :     313374 :       builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
     491                 :     156687 :       builtin_define_constants ("__INT32_C", int_least32_type_node);
     492                 :     156687 :       builtin_define_type_width ("__INT_LEAST32_WIDTH__",
     493                 :            :                                  int_least32_type_node,
     494                 :            :                                  uint_least32_type_node);
     495                 :            :     }
     496                 :     156687 :   if (int_least64_type_node)
     497                 :            :     {
     498                 :     313374 :       builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
     499                 :     156687 :       builtin_define_constants ("__INT64_C", int_least64_type_node);
     500                 :     156687 :       builtin_define_type_width ("__INT_LEAST64_WIDTH__",
     501                 :            :                                  int_least64_type_node,
     502                 :            :                                  uint_least64_type_node);
     503                 :            :     }
     504                 :     156687 :   if (uint_least8_type_node)
     505                 :            :     {
     506                 :     313374 :       builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
     507                 :     156687 :       builtin_define_constants ("__UINT8_C", uint_least8_type_node);
     508                 :            :     }
     509                 :     156687 :   if (uint_least16_type_node)
     510                 :            :     {
     511                 :     313374 :       builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
     512                 :     156687 :       builtin_define_constants ("__UINT16_C", uint_least16_type_node);
     513                 :            :     }
     514                 :     156687 :   if (uint_least32_type_node)
     515                 :            :     {
     516                 :     313374 :       builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
     517                 :     156687 :       builtin_define_constants ("__UINT32_C", uint_least32_type_node);
     518                 :            :     }
     519                 :     156687 :   if (uint_least64_type_node)
     520                 :            :     {
     521                 :     313374 :       builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
     522                 :     156687 :       builtin_define_constants ("__UINT64_C", uint_least64_type_node);
     523                 :            :     }
     524                 :     156687 :   if (int_fast8_type_node)
     525                 :            :     {
     526                 :     313374 :       builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
     527                 :     156687 :       builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node,
     528                 :            :                                  uint_fast8_type_node);
     529                 :            :     }
     530                 :     156687 :   if (int_fast16_type_node)
     531                 :            :     {
     532                 :     313374 :       builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
     533                 :     156687 :       builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node,
     534                 :            :                                  uint_fast16_type_node);
     535                 :            :     }
     536                 :     156687 :   if (int_fast32_type_node)
     537                 :            :     {
     538                 :     313374 :       builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
     539                 :     156687 :       builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node,
     540                 :            :                                  uint_fast32_type_node);
     541                 :            :     }
     542                 :     156687 :   if (int_fast64_type_node)
     543                 :            :     {
     544                 :     313374 :       builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
     545                 :     156687 :       builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node,
     546                 :            :                                  uint_fast64_type_node);
     547                 :            :     }
     548                 :     156687 :   if (uint_fast8_type_node)
     549                 :     313374 :     builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
     550                 :     156687 :   if (uint_fast16_type_node)
     551                 :     313374 :     builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
     552                 :     156687 :   if (uint_fast32_type_node)
     553                 :     313374 :     builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
     554                 :     156687 :   if (uint_fast64_type_node)
     555                 :     313374 :     builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
     556                 :     156687 :   if (intptr_type_node)
     557                 :            :     {
     558                 :     313374 :       builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
     559                 :     156687 :       builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node,
     560                 :            :                                  uintptr_type_node);
     561                 :            :     }
     562                 :     156687 :   if (uintptr_type_node)
     563                 :     313374 :     builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
     564                 :     156687 : }
     565                 :            : 
     566                 :            : /* Adjust the optimization macros when a #pragma GCC optimization is done to
     567                 :            :    reflect the current level.  */
     568                 :            : void
     569                 :         47 : c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
     570                 :            :                                 tree cur_tree)
     571                 :            : {
     572                 :         47 :   struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
     573                 :         47 :   struct cl_optimization *cur  = TREE_OPTIMIZATION (cur_tree);
     574                 :         47 :   bool prev_fast_math;
     575                 :         47 :   bool cur_fast_math;
     576                 :            : 
     577                 :            :   /* -undef turns off target-specific built-ins.  */
     578                 :         47 :   if (flag_undef)
     579                 :            :     return;
     580                 :            : 
     581                 :            :   /* Other target-independent built-ins determined by command-line
     582                 :            :      options.  */
     583                 :         47 :   if (!prev->x_optimize_size && cur->x_optimize_size)
     584                 :          0 :     cpp_define (pfile, "__OPTIMIZE_SIZE__");
     585                 :         47 :   else if (prev->x_optimize_size && !cur->x_optimize_size)
     586                 :          1 :     cpp_undef (pfile, "__OPTIMIZE_SIZE__");
     587                 :            : 
     588                 :         47 :   if (!prev->x_optimize && cur->x_optimize)
     589                 :         10 :     cpp_define (pfile, "__OPTIMIZE__");
     590                 :         37 :   else if (prev->x_optimize && !cur->x_optimize)
     591                 :         12 :     cpp_undef (pfile, "__OPTIMIZE__");
     592                 :            : 
     593                 :         47 :   prev_fast_math = fast_math_flags_struct_set_p (prev);
     594                 :         47 :   cur_fast_math  = fast_math_flags_struct_set_p (cur);
     595                 :         47 :   if (!prev_fast_math && cur_fast_math)
     596                 :          0 :     cpp_define (pfile, "__FAST_MATH__");
     597                 :         47 :   else if (prev_fast_math && !cur_fast_math)
     598                 :          0 :     cpp_undef (pfile, "__FAST_MATH__");
     599                 :            : 
     600                 :         47 :   if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
     601                 :          0 :     cpp_define (pfile, "__SUPPORT_SNAN__");
     602                 :         47 :   else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
     603                 :          0 :     cpp_undef (pfile, "__SUPPORT_SNAN__");
     604                 :            : 
     605                 :         47 :   if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
     606                 :          1 :     cpp_undef (pfile, "__NO_MATH_ERRNO__");
     607                 :         46 :   else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
     608                 :          1 :     cpp_define (pfile, "__NO_MATH_ERRNO__");
     609                 :            : 
     610                 :         47 :   if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
     611                 :            :     {
     612                 :          0 :       cpp_undef (pfile, "__FINITE_MATH_ONLY__");
     613                 :          0 :       cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
     614                 :            :     }
     615                 :         47 :   else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
     616                 :            :     {
     617                 :          0 :       cpp_undef (pfile, "__FINITE_MATH_ONLY__");
     618                 :          0 :       cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
     619                 :            :     }
     620                 :            : }
     621                 :            : 
     622                 :            : 
     623                 :            : /* This function will emit cpp macros to indicate the presence of various lock
     624                 :            :    free atomic operations.  */
     625                 :            :    
     626                 :            : static void
     627                 :     156687 : cpp_atomic_builtins (cpp_reader *pfile)
     628                 :            : {
     629                 :            :   /* Set a flag for each size of object that compare and swap exists for up to
     630                 :            :      a 16 byte object.  */
     631                 :            : #define SWAP_LIMIT  17
     632                 :     156687 :   bool have_swap[SWAP_LIMIT];
     633                 :     156687 :   unsigned int psize;
     634                 :            : 
     635                 :            :   /* Clear the map of sizes compare_and swap exists for.  */
     636                 :     156687 :   memset (have_swap, 0, sizeof (have_swap));
     637                 :            : 
     638                 :            :   /* Tell source code if the compiler makes sync_compare_and_swap
     639                 :            :      builtins available.  */
     640                 :            : #ifndef HAVE_sync_compare_and_swapqi
     641                 :            : #define HAVE_sync_compare_and_swapqi 0
     642                 :            : #endif
     643                 :            : #ifndef HAVE_atomic_compare_and_swapqi
     644                 :            : #define HAVE_atomic_compare_and_swapqi 0
     645                 :            : #endif
     646                 :            : 
     647                 :     156687 :   if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
     648                 :            :     {
     649                 :     156687 :       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
     650                 :     156687 :       have_swap[1] = true;
     651                 :            :     }
     652                 :            : 
     653                 :            : #ifndef HAVE_sync_compare_and_swaphi
     654                 :            : #define HAVE_sync_compare_and_swaphi 0
     655                 :            : #endif
     656                 :            : #ifndef HAVE_atomic_compare_and_swaphi
     657                 :            : #define HAVE_atomic_compare_and_swaphi 0
     658                 :            : #endif
     659                 :     156687 :   if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
     660                 :            :     {
     661                 :     156687 :       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
     662                 :     156687 :       have_swap[2] = true;
     663                 :            :     }
     664                 :            : 
     665                 :            : #ifndef HAVE_sync_compare_and_swapsi
     666                 :            : #define HAVE_sync_compare_and_swapsi 0
     667                 :            : #endif
     668                 :            : #ifndef HAVE_atomic_compare_and_swapsi
     669                 :            : #define HAVE_atomic_compare_and_swapsi 0
     670                 :            : #endif
     671                 :     156687 :   if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
     672                 :            :     {
     673                 :     156687 :       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
     674                 :     156687 :       have_swap[4] = true;
     675                 :            :     }
     676                 :            : 
     677                 :            : #ifndef HAVE_sync_compare_and_swapdi
     678                 :            : #define HAVE_sync_compare_and_swapdi 0
     679                 :            : #endif
     680                 :            : #ifndef HAVE_atomic_compare_and_swapdi
     681                 :            : #define HAVE_atomic_compare_and_swapdi 0
     682                 :            : #endif
     683                 :     156687 :   if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
     684                 :            :     {
     685                 :     156390 :       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
     686                 :     156390 :       have_swap[8] = true;
     687                 :            :     }
     688                 :            : 
     689                 :            : #ifndef HAVE_sync_compare_and_swapti
     690                 :            : #define HAVE_sync_compare_and_swapti 0
     691                 :            : #endif
     692                 :            : #ifndef HAVE_atomic_compare_and_swapti
     693                 :            : #define HAVE_atomic_compare_and_swapti 0
     694                 :            : #endif
     695                 :     156687 :   if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
     696                 :            :     {
     697                 :        286 :       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
     698                 :        286 :       have_swap[16] = true;
     699                 :            :     }
     700                 :            : 
     701                 :            :   /* Tell the source code about various types.  These map to the C++11 and C11
     702                 :            :      macros where 2 indicates lock-free always, and 1 indicates sometimes
     703                 :            :      lock free.  */
     704                 :            : #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
     705                 :            : #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
     706                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE", 
     707                 :     156687 :                         (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
     708                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE", 
     709                 :     156687 :                         (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
     710                 :     156687 :   if (flag_char8_t)
     711                 :      15858 :     builtin_define_with_int_value ("__GCC_ATOMIC_CHAR8_T_LOCK_FREE",
     712                 :      15858 :                         (have_swap[SWAP_INDEX (char8_type_node)]? 2 : 1));
     713                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE", 
     714                 :     156687 :                         (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
     715                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE", 
     716                 :     156687 :                         (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
     717                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE", 
     718                 :     156687 :                         (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
     719                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE", 
     720                 :     156687 :                       (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
     721                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE", 
     722                 :     156687 :                         (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
     723                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE", 
     724                 :     156687 :                       (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
     725                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE", 
     726                 :     156687 :                 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
     727                 :            : 
     728                 :            :   /* If we're dealing with a "set" value that doesn't exactly correspond
     729                 :            :      to a boolean truth value, let the library work around that.  */
     730                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
     731                 :     156687 :                                  targetm.atomic_test_and_set_trueval);
     732                 :            : 
     733                 :            :   /* ptr_type_node can't be used here since ptr_mode is only set when
     734                 :            :      toplev calls backend_init which is not done with -E  or pch.  */
     735                 :     156687 :   psize = POINTER_SIZE_UNITS;
     736                 :     156687 :   if (psize >= SWAP_LIMIT)
     737                 :            :     psize = 0;
     738                 :     156687 :   builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE", 
     739                 :     156687 :                         (have_swap[psize]? 2 : 1));
     740                 :     156687 : }
     741                 :            : 
     742                 :            : /* Return TRUE if the implicit excess precision in which the back-end will
     743                 :            :    compute floating-point calculations is not more than the explicit
     744                 :            :    excess precision that the front-end will apply under
     745                 :            :    -fexcess-precision=[standard|fast].
     746                 :            : 
     747                 :            :    More intuitively, return TRUE if the excess precision proposed by the
     748                 :            :    front-end is the excess precision that will actually be used.  */
     749                 :            : 
     750                 :            : static bool
     751                 :       3946 : c_cpp_flt_eval_method_iec_559 (void)
     752                 :            : {
     753                 :       7892 :   enum excess_precision_type front_end_ept
     754                 :       3946 :     = (flag_excess_precision == EXCESS_PRECISION_STANDARD
     755                 :       3946 :        ? EXCESS_PRECISION_TYPE_STANDARD
     756                 :            :        : EXCESS_PRECISION_TYPE_FAST);
     757                 :            : 
     758                 :       3946 :   enum flt_eval_method back_end
     759                 :       3946 :     = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
     760                 :            : 
     761                 :       3946 :   enum flt_eval_method front_end
     762                 :       3946 :     = targetm.c.excess_precision (front_end_ept);
     763                 :            : 
     764                 :       3946 :   return excess_precision_mode_join (front_end, back_end) == front_end;
     765                 :            : }
     766                 :            : 
     767                 :            : /* Return the value for __GCC_IEC_559.  */
     768                 :            : static int
     769                 :     313374 : cpp_iec_559_value (void)
     770                 :            : {
     771                 :            :   /* The default is support for IEEE 754-2008.  */
     772                 :     313374 :   int ret = 2;
     773                 :            : 
     774                 :            :   /* float and double must be binary32 and binary64.  If they are but
     775                 :            :      with reversed NaN convention, at most IEEE 754-1985 is
     776                 :            :      supported.  */
     777                 :     313374 :   const struct real_format *ffmt
     778                 :     313374 :     = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
     779                 :     313374 :   const struct real_format *dfmt
     780                 :     313374 :     = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
     781                 :     313374 :   if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
     782                 :          0 :     ret = 1;
     783                 :     313374 :   if (ffmt->b != 2
     784                 :     313374 :       || ffmt->p != 24
     785                 :            :       || ffmt->pnan != 24
     786                 :     313374 :       || ffmt->emin != -125
     787                 :     313374 :       || ffmt->emax != 128
     788                 :     313374 :       || ffmt->signbit_rw != 31
     789                 :     313374 :       || ffmt->round_towards_zero
     790                 :     313374 :       || !ffmt->has_sign_dependent_rounding
     791                 :     313374 :       || !ffmt->has_nans
     792                 :     313374 :       || !ffmt->has_inf
     793                 :     313374 :       || !ffmt->has_denorm
     794                 :     313374 :       || !ffmt->has_signed_zero
     795                 :            :       || dfmt->b != 2
     796                 :     313374 :       || dfmt->p != 53
     797                 :            :       || dfmt->pnan != 53
     798                 :     313374 :       || dfmt->emin != -1021
     799                 :     313374 :       || dfmt->emax != 1024
     800                 :     313374 :       || dfmt->signbit_rw != 63
     801                 :     313374 :       || dfmt->round_towards_zero
     802                 :     313374 :       || !dfmt->has_sign_dependent_rounding
     803                 :     313374 :       || !dfmt->has_nans
     804                 :     313374 :       || !dfmt->has_inf
     805                 :     313374 :       || !dfmt->has_denorm
     806                 :     313374 :       || !dfmt->has_signed_zero)
     807                 :          0 :     ret = 0;
     808                 :            : 
     809                 :            :   /* In strict C standards conformance mode, consider a back-end providing
     810                 :            :      more implicit excess precision than the explicit excess precision
     811                 :            :      the front-end options would require to mean a lack of IEEE 754
     812                 :            :      support.  For C++, and outside strict conformance mode, do not consider
     813                 :            :      this to mean a lack of IEEE 754 support.  */
     814                 :            : 
     815                 :     313374 :   if (flag_iso
     816                 :      83920 :       && !c_dialect_cxx ()
     817                 :     317320 :       && !c_cpp_flt_eval_method_iec_559 ())
     818                 :            :     ret = 0;
     819                 :            : 
     820                 :     313374 :   if (flag_iso
     821                 :     313374 :       && !c_dialect_cxx ()
     822                 :       3946 :       && flag_fp_contract_mode == FP_CONTRACT_FAST)
     823                 :          4 :     ret = 0;
     824                 :            : 
     825                 :            :   /* Various options are contrary to IEEE 754 semantics.  */
     826                 :     313374 :   if (flag_unsafe_math_optimizations
     827                 :     311176 :       || flag_associative_math
     828                 :     311164 :       || flag_reciprocal_math
     829                 :     311158 :       || flag_finite_math_only
     830                 :     311092 :       || !flag_signed_zeros
     831                 :     311082 :       || flag_single_precision_constant)
     832                 :       2298 :     ret = 0;
     833                 :            : 
     834                 :            :   /* If the target does not support IEEE 754 exceptions and rounding
     835                 :            :      modes, consider IEEE 754 support to be absent.  */
     836                 :     313374 :   if (!targetm.float_exceptions_rounding_supported_p ())
     837                 :        272 :     ret = 0;
     838                 :            : 
     839                 :     313374 :   return ret;
     840                 :            : }
     841                 :            : 
     842                 :            : /* Return the value for __GCC_IEC_559_COMPLEX.  */
     843                 :            : static int
     844                 :     156687 : cpp_iec_559_complex_value (void)
     845                 :            : {
     846                 :            :   /* The value is no bigger than that of __GCC_IEC_559.  */
     847                 :          0 :   int ret = cpp_iec_559_value ();
     848                 :            : 
     849                 :            :   /* Some options are contrary to the required default state of the
     850                 :            :      CX_LIMITED_RANGE pragma.  */
     851                 :     156687 :   if (flag_complex_method != 2)
     852                 :       3196 :     ret = 0;
     853                 :            : 
     854                 :     156687 :   return ret;
     855                 :            : }
     856                 :            : 
     857                 :            : /* Hook that registers front end and target-specific built-ins.  */
     858                 :            : void
     859                 :     156688 : c_cpp_builtins (cpp_reader *pfile)
     860                 :            : {
     861                 :     156688 :   int i;
     862                 :            : 
     863                 :            :   /* -undef turns off target-specific built-ins.  */
     864                 :     156688 :   if (flag_undef)
     865                 :            :     return;
     866                 :            : 
     867                 :     156687 :   define_language_independent_builtin_macros (pfile);
     868                 :            : 
     869                 :     156687 :   if (c_dialect_cxx ())
     870                 :            :   {
     871                 :      78175 :     int major;
     872                 :      78175 :     parse_basever (&major, NULL, NULL);
     873                 :      78175 :     cpp_define_formatted (pfile, "__GNUG__=%d", major);
     874                 :            :   }
     875                 :            : 
     876                 :            :   /* For stddef.h.  They require macros defined in c-common.c.  */
     877                 :     156687 :   c_stddef_cpp_builtins ();
     878                 :            : 
     879                 :     156687 :   if (c_dialect_cxx ())
     880                 :            :     {
     881                 :      78175 :       if (flag_weak && SUPPORTS_ONE_ONLY)
     882                 :      78138 :         cpp_define (pfile, "__GXX_WEAK__=1");
     883                 :            :       else
     884                 :         37 :         cpp_define (pfile, "__GXX_WEAK__=0");
     885                 :            : 
     886                 :      78175 :       if (warn_deprecated)
     887                 :      78016 :         cpp_define (pfile, "__DEPRECATED");
     888                 :            : 
     889                 :      78175 :       if (flag_rtti)
     890                 :            :         {
     891                 :      77534 :           cpp_define (pfile, "__GXX_RTTI");
     892                 :      77534 :           cpp_define (pfile, "__cpp_rtti=199711L");
     893                 :            :         }
     894                 :            : 
     895                 :      78175 :       if (cxx_dialect >= cxx11)
     896                 :      67046 :         cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
     897                 :            : 
     898                 :            :       /* Binary literals have been allowed in g++ before C++11
     899                 :            :          and were standardized for C++14.  */
     900                 :      78175 :       if (!pedantic || cxx_dialect > cxx11)
     901                 :      71137 :         cpp_define (pfile, "__cpp_binary_literals=201304L");
     902                 :            : 
     903                 :            :       /* Similarly for hexadecimal floating point literals and C++17.  */
     904                 :      78175 :       if (!pedantic || cpp_get_options (parse_in)->extended_numbers)
     905                 :      62438 :         cpp_define (pfile, "__cpp_hex_float=201603L");
     906                 :            : 
     907                 :            :       /* Arrays of runtime bound were removed from C++14, but we still
     908                 :            :          support GNU VLAs.  Let's define this macro to a low number
     909                 :            :          (corresponding to the initial test release of GNU C++) if we won't
     910                 :            :          complain about use of VLAs.  */
     911                 :      78175 :       if (c_dialect_cxx ()
     912                 :      78175 :           && (pedantic ? warn_vla == 0 : warn_vla <= 0))
     913                 :      41088 :         cpp_define (pfile, "__cpp_runtime_arrays=198712L");
     914                 :            : 
     915                 :      78175 :       if (cxx_dialect >= cxx11)
     916                 :            :         {
     917                 :            :           /* Set feature test macros for C++11.  */
     918                 :      67046 :           if (cxx_dialect <= cxx14)
     919                 :      34988 :             cpp_define (pfile, "__cpp_unicode_characters=200704L");
     920                 :      67046 :           cpp_define (pfile, "__cpp_raw_strings=200710L");
     921                 :      67046 :           cpp_define (pfile, "__cpp_unicode_literals=200710L");
     922                 :      67046 :           cpp_define (pfile, "__cpp_user_defined_literals=200809L");
     923                 :      67046 :           cpp_define (pfile, "__cpp_lambdas=200907L");
     924                 :      67046 :           if (cxx_dialect == cxx11)
     925                 :       1485 :             cpp_define (pfile, "__cpp_constexpr=200704L");
     926                 :      67046 :           if (cxx_dialect <= cxx14)
     927                 :      34988 :             cpp_define (pfile, "__cpp_range_based_for=200907L");
     928                 :      67046 :           if (cxx_dialect <= cxx14)
     929                 :      34988 :             cpp_define (pfile, "__cpp_static_assert=200410L");
     930                 :      67046 :           cpp_define (pfile, "__cpp_decltype=200707L");
     931                 :      67046 :           cpp_define (pfile, "__cpp_attributes=200809L");
     932                 :      67046 :           cpp_define (pfile, "__cpp_rvalue_reference=200610L");
     933                 :      67046 :           cpp_define (pfile, "__cpp_rvalue_references=200610L");
     934                 :      67046 :           cpp_define (pfile, "__cpp_variadic_templates=200704L");
     935                 :      67046 :           cpp_define (pfile, "__cpp_initializer_lists=200806L");
     936                 :      67046 :           cpp_define (pfile, "__cpp_delegating_constructors=200604L");
     937                 :      67046 :           cpp_define (pfile, "__cpp_nsdmi=200809L");
     938                 :      67046 :           if (!flag_new_inheriting_ctors)
     939                 :        222 :             cpp_define (pfile, "__cpp_inheriting_constructors=200802L");
     940                 :            :           else
     941                 :      66824 :             cpp_define (pfile, "__cpp_inheriting_constructors=201511L");
     942                 :      67046 :           cpp_define (pfile, "__cpp_ref_qualifiers=200710L");
     943                 :      67046 :           cpp_define (pfile, "__cpp_alias_templates=200704L");
     944                 :            :         }
     945                 :      78175 :       if (cxx_dialect > cxx11)
     946                 :            :         {
     947                 :            :           /* Set feature test macros for C++14.  */
     948                 :      65561 :           cpp_define (pfile, "__cpp_return_type_deduction=201304L");
     949                 :      65561 :           if (cxx_dialect <= cxx17)
     950                 :            :             {
     951                 :      49762 :               cpp_define (pfile, "__cpp_init_captures=201304L");
     952                 :      49762 :               cpp_define (pfile, "__cpp_generic_lambdas=201304L");
     953                 :            :             }
     954                 :      65561 :           if (cxx_dialect <= cxx14)
     955                 :      33503 :             cpp_define (pfile, "__cpp_constexpr=201304L");
     956                 :      65561 :           cpp_define (pfile, "__cpp_decltype_auto=201304L");
     957                 :      65561 :           cpp_define (pfile, "__cpp_aggregate_nsdmi=201304L");
     958                 :      65561 :           cpp_define (pfile, "__cpp_variable_templates=201304L");
     959                 :      65561 :           cpp_define (pfile, "__cpp_digit_separators=201309L");
     960                 :            :         }
     961                 :      78175 :       if (cxx_dialect > cxx14)
     962                 :            :         {
     963                 :            :           /* Set feature test macros for C++17.  */
     964                 :      32058 :           cpp_define (pfile, "__cpp_unicode_characters=201411L");
     965                 :      32058 :           cpp_define (pfile, "__cpp_static_assert=201411L");
     966                 :      32058 :           cpp_define (pfile, "__cpp_namespace_attributes=201411L");
     967                 :      32058 :           cpp_define (pfile, "__cpp_enumerator_attributes=201411L");
     968                 :      32058 :           cpp_define (pfile, "__cpp_nested_namespace_definitions=201411L");
     969                 :      32058 :           cpp_define (pfile, "__cpp_fold_expressions=201603L");
     970                 :      32058 :           cpp_define (pfile, "__cpp_nontype_template_args=201411L");
     971                 :      32058 :           cpp_define (pfile, "__cpp_range_based_for=201603L");
     972                 :      32058 :           if (cxx_dialect <= cxx17)
     973                 :      16259 :             cpp_define (pfile, "__cpp_constexpr=201603L");
     974                 :      32058 :           cpp_define (pfile, "__cpp_if_constexpr=201606L");
     975                 :      32058 :           cpp_define (pfile, "__cpp_capture_star_this=201603L");
     976                 :      32058 :           cpp_define (pfile, "__cpp_inline_variables=201606L");
     977                 :      32058 :           cpp_define (pfile, "__cpp_aggregate_bases=201603L");
     978                 :      32058 :           if (cxx_dialect <= cxx17)
     979                 :      16259 :             cpp_define (pfile, "__cpp_deduction_guides=201703L");
     980                 :      32058 :           cpp_define (pfile, "__cpp_noexcept_function_type=201510L");
     981                 :            :           /* Old macro, superseded by
     982                 :            :              __cpp_nontype_template_parameter_auto.  */
     983                 :      32058 :           cpp_define (pfile, "__cpp_template_auto=201606L");
     984                 :      32058 :           cpp_define (pfile, "__cpp_structured_bindings=201606L");
     985                 :      32058 :           cpp_define (pfile, "__cpp_variadic_using=201611L");
     986                 :      32058 :           cpp_define (pfile, "__cpp_guaranteed_copy_elision=201606L");
     987                 :      32058 :           cpp_define (pfile, "__cpp_nontype_template_parameter_auto=201606L");
     988                 :            :         }
     989                 :      78175 :       if (cxx_dialect > cxx17)
     990                 :            :         {
     991                 :            :           /* Set feature test macros for C++2a.  */
     992                 :      15799 :           cpp_define (pfile, "__cpp_init_captures=201803L");
     993                 :      15799 :           cpp_define (pfile, "__cpp_generic_lambdas=201707L");
     994                 :      15799 :           cpp_define (pfile, "__cpp_designated_initializers=201707L");
     995                 :      15799 :           cpp_define (pfile, "__cpp_constexpr=201907L");
     996                 :      15799 :           cpp_define (pfile, "__cpp_constexpr_in_decltype=201711L");
     997                 :      15799 :           cpp_define (pfile, "__cpp_conditional_explicit=201806L");
     998                 :            :           /* cpp_define (pfile, "__cpp_consteval=201811L"); */
     999                 :      15799 :           cpp_define (pfile, "__cpp_constinit=201907L");
    1000                 :      15799 :           cpp_define (pfile, "__cpp_deduction_guides=201907L");
    1001                 :      15799 :           cpp_define (pfile, "__cpp_nontype_template_parameter_class=201806L");
    1002                 :      15799 :           cpp_define (pfile, "__cpp_impl_destroying_delete=201806L");
    1003                 :      15799 :           cpp_define (pfile, "__cpp_constexpr_dynamic_alloc=201907L");
    1004                 :      15799 :           cpp_define (pfile, "__cpp_impl_three_way_comparison=201907L");
    1005                 :      15799 :           cpp_define (pfile, "__cpp_aggregate_paren_init=201902L");
    1006                 :            :         }
    1007                 :      78175 :       if (flag_concepts)
    1008                 :            :         {
    1009                 :      15961 :           if (cxx_dialect >= cxx2a)
    1010                 :      15799 :             cpp_define (pfile, "__cpp_concepts=201907L");
    1011                 :            :           else
    1012                 :        162 :             cpp_define (pfile, "__cpp_concepts=201507L");
    1013                 :            :         }
    1014                 :      78175 :       if (flag_coroutines)
    1015                 :        802 :         cpp_define (pfile, "__cpp_coroutines=201902L"); /* n4835, C++20 CD */
    1016                 :      78175 :       if (flag_tm)
    1017                 :            :         /* Use a value smaller than the 201505 specified in
    1018                 :            :            the TS, since we don't yet support atomic_cancel.  */
    1019                 :        371 :         cpp_define (pfile, "__cpp_transactional_memory=201500L");
    1020                 :      78175 :       if (flag_sized_deallocation)
    1021                 :      65558 :         cpp_define (pfile, "__cpp_sized_deallocation=201309L");
    1022                 :      78175 :       if (aligned_new_threshold)
    1023                 :            :         {
    1024                 :      32067 :           cpp_define (pfile, "__cpp_aligned_new=201606L");
    1025                 :      32067 :           cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
    1026                 :            :                                 aligned_new_threshold);
    1027                 :            :         }
    1028                 :      78175 :       if (flag_new_ttp)
    1029                 :      32058 :         cpp_define (pfile, "__cpp_template_template_args=201611L");
    1030                 :      78175 :       if (flag_threadsafe_statics)
    1031                 :      78167 :         cpp_define (pfile, "__cpp_threadsafe_static_init=200806L");
    1032                 :      78175 :       if (flag_char8_t)
    1033                 :      15858 :         cpp_define (pfile, "__cpp_char8_t=201811L");
    1034                 :            :     }
    1035                 :            :   /* Note that we define this for C as well, so that we know if
    1036                 :            :      __attribute__((cleanup)) will interface with EH.  */
    1037                 :     156687 :   if (flag_exceptions)
    1038                 :            :     {
    1039                 :      77724 :       cpp_define (pfile, "__EXCEPTIONS");
    1040                 :      77724 :       if (c_dialect_cxx ())
    1041                 :      77350 :         cpp_define (pfile, "__cpp_exceptions=199711L");
    1042                 :            :     }
    1043                 :            : 
    1044                 :            :   /* Represents the C++ ABI version, always defined so it can be used while
    1045                 :            :      preprocessing C and assembler.  */
    1046                 :     156687 :   if (flag_abi_version == 0)
    1047                 :            :     /* We should have set this to something real in c_common_post_options.  */
    1048                 :          0 :     gcc_unreachable ();
    1049                 :     156687 :   else if (flag_abi_version == 1)
    1050                 :            :     /* Due to a historical accident, this version had the value
    1051                 :            :        "102".  */
    1052                 :          0 :     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
    1053                 :            :   else
    1054                 :            :     /* Newer versions have values 1002, 1003, ....  */
    1055                 :     156687 :     builtin_define_with_int_value ("__GXX_ABI_VERSION",
    1056                 :     156687 :                                    1000 + flag_abi_version);
    1057                 :            : 
    1058                 :            :   /* libgcc needs to know this.  */
    1059                 :     156687 :   if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
    1060                 :          0 :     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
    1061                 :            : 
    1062                 :            :   /* limits.h and stdint.h need to know these.  */
    1063                 :     313374 :   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
    1064                 :     313374 :   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
    1065                 :     313374 :   builtin_define_type_max ("__INT_MAX__", integer_type_node);
    1066                 :     313374 :   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
    1067                 :     313374 :   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
    1068                 :     156687 :   builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
    1069                 :            :                               underlying_wchar_type_node);
    1070                 :     156687 :   builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
    1071                 :     313374 :   builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
    1072                 :     313374 :   builtin_define_type_max ("__SIZE_MAX__", size_type_node);
    1073                 :            : 
    1074                 :            :   /* These are needed for TS 18661-1.  */
    1075                 :     156687 :   builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
    1076                 :            :                              unsigned_char_type_node);
    1077                 :     156687 :   builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
    1078                 :            :                              short_unsigned_type_node);
    1079                 :     156687 :   builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
    1080                 :            :                              unsigned_type_node);
    1081                 :     156687 :   builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
    1082                 :            :                              long_unsigned_type_node);
    1083                 :     156687 :   builtin_define_type_width ("__LONG_LONG_WIDTH__",
    1084                 :            :                              long_long_integer_type_node,
    1085                 :            :                              long_long_unsigned_type_node);
    1086                 :     156687 :   builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
    1087                 :            :                              NULL_TREE);
    1088                 :     156687 :   builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
    1089                 :     156687 :   builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
    1090                 :     156687 :   builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
    1091                 :            : 
    1092                 :     156687 :   if (c_dialect_cxx ())
    1093                 :     156350 :     for (i = 0; i < NUM_INT_N_ENTS; i ++)
    1094                 :      78175 :       if (int_n_enabled_p[i])
    1095                 :            :         {
    1096                 :      77504 :           char buf[35+20+20];
    1097                 :            : 
    1098                 :            :           /* These are used to configure the C++ library.  */
    1099                 :            : 
    1100                 :      77504 :           if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
    1101                 :            :             {
    1102                 :      37555 :               sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
    1103                 :      37555 :               cpp_define (parse_in, buf);
    1104                 :            : 
    1105                 :      37555 :               sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
    1106                 :      37555 :               cpp_define (parse_in, buf);
    1107                 :            :             }
    1108                 :            :         }
    1109                 :            : 
    1110                 :            :   /* stdint.h and the testsuite need to know these.  */
    1111                 :     156687 :   builtin_define_stdint_macros ();
    1112                 :            : 
    1113                 :            :   /* Provide information for library headers to determine whether to
    1114                 :            :      define macros such as __STDC_IEC_559__ and
    1115                 :            :      __STDC_IEC_559_COMPLEX__.  */
    1116                 :     156687 :   builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
    1117                 :     156687 :   builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
    1118                 :     156687 :                                  cpp_iec_559_complex_value ());
    1119                 :            : 
    1120                 :            :   /* float.h needs these to correctly set FLT_EVAL_METHOD
    1121                 :            : 
    1122                 :            :      We define two values:
    1123                 :            : 
    1124                 :            :      __FLT_EVAL_METHOD__
    1125                 :            :        Which, depending on the value given for
    1126                 :            :        -fpermitted-flt-eval-methods, may be limited to only those values
    1127                 :            :        for FLT_EVAL_METHOD defined in C99/C11.
    1128                 :            : 
    1129                 :            :      __FLT_EVAL_METHOD_TS_18661_3__
    1130                 :            :        Which always permits the values for FLT_EVAL_METHOD defined in
    1131                 :            :        ISO/IEC TS 18661-3.  */
    1132                 :     156687 :   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
    1133                 :     156687 :                                  c_flt_eval_method (true));
    1134                 :     156687 :   builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
    1135                 :     156687 :                                  c_flt_eval_method (false));
    1136                 :            : 
    1137                 :            :   /* And decfloat.h needs this.  */
    1138                 :     156687 :   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
    1139                 :            :                                  TARGET_DEC_EVAL_METHOD);
    1140                 :            : 
    1141                 :     156687 :   builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
    1142                 :            :   /* Cast the double precision constants.  This is needed when single
    1143                 :            :      precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
    1144                 :            :      is used.  The correct result is computed by the compiler when using
    1145                 :            :      macros that include a cast.  We use a different cast for C++ to avoid
    1146                 :            :      problems with -Wold-style-cast.  */
    1147                 :     156687 :   builtin_define_float_constants ("DBL", "L",
    1148                 :     156687 :                                   (c_dialect_cxx ()
    1149                 :            :                                    ? "double(%s)"
    1150                 :            :                                    : "((double)%s)"),
    1151                 :            :                                   "", double_type_node);
    1152                 :     156687 :   builtin_define_float_constants ("LDBL", "L", "%s", "L",
    1153                 :            :                                   long_double_type_node);
    1154                 :            : 
    1155                 :    1253500 :   for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
    1156                 :            :     {
    1157                 :    1096810 :       if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
    1158                 :     313374 :         continue;
    1159                 :     783435 :       char prefix[20], csuffix[20];
    1160                 :    1566870 :       sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
    1161                 :     783435 :                floatn_nx_types[i].extended ? "X" : "");
    1162                 :     783435 :       sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
    1163                 :            :                floatn_nx_types[i].extended ? "x" : "");
    1164                 :     783435 :       builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s",
    1165                 :            :                                       csuffix, FLOATN_NX_TYPE_NODE (i));
    1166                 :            :     }
    1167                 :            : 
    1168                 :            :   /* For float.h.  */
    1169                 :     156687 :   if (targetm.decimal_float_supported_p ())
    1170                 :            :     {
    1171                 :     156687 :       builtin_define_decimal_float_constants ("DEC32", "DF",
    1172                 :            :                                               dfloat32_type_node);
    1173                 :     156687 :       builtin_define_decimal_float_constants ("DEC64", "DD",
    1174                 :            :                                               dfloat64_type_node);
    1175                 :     156687 :       builtin_define_decimal_float_constants ("DEC128", "DL",
    1176                 :            :                                               dfloat128_type_node);
    1177                 :            :     }
    1178                 :            : 
    1179                 :            :   /* For fixed-point fibt, ibit, max, min, and epsilon.  */
    1180                 :     156687 :   if (targetm.fixed_point_supported_p ())
    1181                 :            :     {
    1182                 :          0 :       builtin_define_fixed_point_constants ("SFRACT", "HR",
    1183                 :            :                                             short_fract_type_node);
    1184                 :          0 :       builtin_define_fixed_point_constants ("USFRACT", "UHR",
    1185                 :            :                                             unsigned_short_fract_type_node);
    1186                 :          0 :       builtin_define_fixed_point_constants ("FRACT", "R",
    1187                 :            :                                             fract_type_node);
    1188                 :          0 :       builtin_define_fixed_point_constants ("UFRACT", "UR",
    1189                 :            :                                             unsigned_fract_type_node);
    1190                 :          0 :       builtin_define_fixed_point_constants ("LFRACT", "LR",
    1191                 :            :                                             long_fract_type_node);
    1192                 :          0 :       builtin_define_fixed_point_constants ("ULFRACT", "ULR",
    1193                 :            :                                             unsigned_long_fract_type_node);
    1194                 :          0 :       builtin_define_fixed_point_constants ("LLFRACT", "LLR",
    1195                 :            :                                             long_long_fract_type_node);
    1196                 :          0 :       builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
    1197                 :            :                                             unsigned_long_long_fract_type_node);
    1198                 :          0 :       builtin_define_fixed_point_constants ("SACCUM", "HK",
    1199                 :            :                                             short_accum_type_node);
    1200                 :          0 :       builtin_define_fixed_point_constants ("USACCUM", "UHK",
    1201                 :            :                                             unsigned_short_accum_type_node);
    1202                 :          0 :       builtin_define_fixed_point_constants ("ACCUM", "K",
    1203                 :            :                                             accum_type_node);
    1204                 :          0 :       builtin_define_fixed_point_constants ("UACCUM", "UK",
    1205                 :            :                                             unsigned_accum_type_node);
    1206                 :          0 :       builtin_define_fixed_point_constants ("LACCUM", "LK",
    1207                 :            :                                             long_accum_type_node);
    1208                 :          0 :       builtin_define_fixed_point_constants ("ULACCUM", "ULK",
    1209                 :            :                                             unsigned_long_accum_type_node);
    1210                 :          0 :       builtin_define_fixed_point_constants ("LLACCUM", "LLK",
    1211                 :            :                                             long_long_accum_type_node);
    1212                 :          0 :       builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
    1213                 :            :                                             unsigned_long_long_accum_type_node);
    1214                 :            : 
    1215                 :          0 :       builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
    1216                 :          0 :       builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
    1217                 :          0 :       builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
    1218                 :          0 :       builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
    1219                 :          0 :       builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
    1220                 :          0 :       builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
    1221                 :          0 :       builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
    1222                 :          0 :       builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
    1223                 :          0 :       builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
    1224                 :          0 :       builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
    1225                 :          0 :       builtin_define_fixed_point_constants ("HA", "", ha_type_node);
    1226                 :          0 :       builtin_define_fixed_point_constants ("SA", "", sa_type_node);
    1227                 :          0 :       builtin_define_fixed_point_constants ("DA", "", da_type_node);
    1228                 :          0 :       builtin_define_fixed_point_constants ("TA", "", ta_type_node);
    1229                 :          0 :       builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
    1230                 :          0 :       builtin_define_fixed_point_constants ("USA", "", usa_type_node);
    1231                 :          0 :       builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
    1232                 :          0 :       builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
    1233                 :            :     }
    1234                 :            : 
    1235                 :            :   /* For libgcc-internal use only.  */
    1236                 :     156687 :   if (flag_building_libgcc)
    1237                 :            :     {
    1238                 :            :       /* Properties of floating-point modes for libgcc2.c.  */
    1239                 :        792 :       opt_scalar_float_mode mode_iter;
    1240                 :       7128 :       FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
    1241                 :            :         {
    1242                 :       3168 :           scalar_float_mode mode = mode_iter.require ();
    1243                 :       3168 :           const char *name = GET_MODE_NAME (mode);
    1244                 :       3168 :           char *macro_name
    1245                 :       3168 :             = (char *) alloca (strlen (name)
    1246                 :            :                                + sizeof ("__LIBGCC__MANT_DIG__"));
    1247                 :       3168 :           sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
    1248                 :       6336 :           builtin_define_with_int_value (macro_name,
    1249                 :       3168 :                                          REAL_MODE_FORMAT (mode)->p);
    1250                 :       3168 :           if (!targetm.scalar_mode_supported_p (mode)
    1251                 :       3168 :               || !targetm.libgcc_floating_mode_supported_p (mode))
    1252                 :          0 :             continue;
    1253                 :       3168 :           macro_name = (char *) alloca (strlen (name)
    1254                 :            :                                         + sizeof ("__LIBGCC_HAS__MODE__"));
    1255                 :       3168 :           sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
    1256                 :       3168 :           cpp_define (pfile, macro_name);
    1257                 :       3168 :           macro_name = (char *) alloca (strlen (name)
    1258                 :            :                                         + sizeof ("__LIBGCC__FUNC_EXT__"));
    1259                 :       3168 :           sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
    1260                 :       3168 :           char suffix[20] = "";
    1261                 :       3168 :           if (mode == TYPE_MODE (double_type_node))
    1262                 :            :             ; /* Empty suffix correct.  */
    1263                 :       2376 :           else if (mode == TYPE_MODE (float_type_node))
    1264                 :        792 :             suffix[0] = 'f';
    1265                 :       1584 :           else if (mode == TYPE_MODE (long_double_type_node))
    1266                 :        792 :             suffix[0] = 'l';
    1267                 :            :           else
    1268                 :            :             {
    1269                 :       3168 :               bool found_suffix = false;
    1270                 :       3168 :               for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
    1271                 :       3168 :                 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
    1272                 :       3168 :                     && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
    1273                 :            :                   {
    1274                 :       1584 :                     sprintf (suffix, "f%d%s", floatn_nx_types[i].n,
    1275                 :        792 :                              floatn_nx_types[i].extended ? "x" : "");
    1276                 :        792 :                     found_suffix = true;
    1277                 :        792 :                     break;
    1278                 :            :                   }
    1279                 :        792 :               gcc_assert (found_suffix);
    1280                 :            :             }
    1281                 :       3168 :           builtin_define_with_value (macro_name, suffix, 0);
    1282                 :            : 
    1283                 :            :           /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
    1284                 :            :              eliminating excess precision from results assigned to
    1285                 :            :              variables - meaning it should be about the implicit excess
    1286                 :            :              precision only.  */
    1287                 :       3168 :           bool excess_precision = false;
    1288                 :       3168 :           machine_mode float16_type_mode = (float16_type_node
    1289                 :       3168 :                                             ? TYPE_MODE (float16_type_node)
    1290                 :       3168 :                                             : VOIDmode);
    1291                 :       3168 :           switch (targetm.c.excess_precision
    1292                 :       3168 :                     (EXCESS_PRECISION_TYPE_IMPLICIT))
    1293                 :            :             {
    1294                 :       1572 :             case FLT_EVAL_METHOD_UNPREDICTABLE:
    1295                 :       1572 :             case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
    1296                 :       1572 :               excess_precision = (mode == float16_type_mode
    1297                 :       1572 :                                   || mode == TYPE_MODE (float_type_node)
    1298                 :       2751 :                                   || mode == TYPE_MODE (double_type_node));
    1299                 :            :               break;
    1300                 :            : 
    1301                 :          0 :             case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
    1302                 :          0 :               excess_precision = (mode == float16_type_mode
    1303                 :          0 :                                   || mode == TYPE_MODE (float_type_node));
    1304                 :            :               break;
    1305                 :       1596 :             case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
    1306                 :       1596 :               excess_precision = mode == float16_type_mode;
    1307                 :       1596 :               break;
    1308                 :            :             case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
    1309                 :            :               excess_precision = false;
    1310                 :            :               break;
    1311                 :          0 :             default:
    1312                 :          0 :               gcc_unreachable ();
    1313                 :            :             }
    1314                 :       3168 :           macro_name = (char *) alloca (strlen (name)
    1315                 :            :                                         + sizeof ("__LIBGCC__EXCESS_"
    1316                 :            :                                                   "PRECISION__"));
    1317                 :       3168 :           sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
    1318                 :       3168 :           builtin_define_with_int_value (macro_name, excess_precision);
    1319                 :            :         }
    1320                 :            : 
    1321                 :            :       /* For libgcc crtstuff.c and libgcc2.c.  */
    1322                 :        792 :       builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
    1323                 :            :                                      EH_TABLES_CAN_BE_READ_ONLY);
    1324                 :            : #ifdef EH_FRAME_SECTION_NAME
    1325                 :        792 :       builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
    1326                 :            :                                  EH_FRAME_SECTION_NAME, 1);
    1327                 :            : #endif
    1328                 :            : #ifdef CTORS_SECTION_ASM_OP
    1329                 :            :       builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
    1330                 :            :                                  CTORS_SECTION_ASM_OP, 1);
    1331                 :            : #endif
    1332                 :            : #ifdef DTORS_SECTION_ASM_OP
    1333                 :            :       builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
    1334                 :            :                                  DTORS_SECTION_ASM_OP, 1);
    1335                 :            : #endif
    1336                 :            : #ifdef TEXT_SECTION_ASM_OP
    1337                 :        792 :       builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
    1338                 :            :                                  TEXT_SECTION_ASM_OP, 1);
    1339                 :            : #endif
    1340                 :            : #ifdef INIT_SECTION_ASM_OP
    1341                 :            :       builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
    1342                 :            :                                  INIT_SECTION_ASM_OP, 1);
    1343                 :            : #endif
    1344                 :            : #ifdef INIT_ARRAY_SECTION_ASM_OP
    1345                 :            :       /* Despite the name of this target macro, the expansion is not
    1346                 :            :          actually used, and may be empty rather than a string
    1347                 :            :          constant.  */
    1348                 :        792 :       cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
    1349                 :            : #endif
    1350                 :            : 
    1351                 :            :       /* For libgcc enable-execute-stack.c.  */
    1352                 :        792 :       builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
    1353                 :        792 :                                      TRAMPOLINE_SIZE);
    1354                 :            : 
    1355                 :            :       /* For libgcc generic-morestack.c and unwinder code.  */
    1356                 :        792 :       if (STACK_GROWS_DOWNWARD)
    1357                 :        792 :         cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
    1358                 :            : 
    1359                 :            :       /* For libgcc unwinder code.  */
    1360                 :            : #ifdef DONT_USE_BUILTIN_SETJMP
    1361                 :            :       cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
    1362                 :            : #endif
    1363                 :            : #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
    1364                 :            :       builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
    1365                 :            :                                      DWARF_ALT_FRAME_RETURN_COLUMN);
    1366                 :            : #endif
    1367                 :        792 :       builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
    1368                 :            :                                      DWARF_FRAME_REGISTERS);
    1369                 :            : #ifdef EH_RETURN_STACKADJ_RTX
    1370                 :        792 :       cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
    1371                 :            : #endif
    1372                 :            : #ifdef JMP_BUF_SIZE
    1373                 :            :       builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
    1374                 :            :                                      JMP_BUF_SIZE);
    1375                 :            : #endif
    1376                 :        792 :       builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
    1377                 :            :                                      STACK_POINTER_REGNUM);
    1378                 :            : 
    1379                 :            :       /* For libgcov.  */
    1380                 :        792 :       builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
    1381                 :            :                                      TARGET_VTABLE_USES_DESCRIPTORS);
    1382                 :            :     }
    1383                 :            : 
    1384                 :            :   /* For use in assembly language.  */
    1385                 :     156687 :   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
    1386                 :     156687 :   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
    1387                 :            : 
    1388                 :            :   /* Misc.  */
    1389                 :     156687 :   if (flag_gnu89_inline)
    1390                 :      12695 :     cpp_define (pfile, "__GNUC_GNU_INLINE__");
    1391                 :            :   else
    1392                 :     143992 :     cpp_define (pfile, "__GNUC_STDC_INLINE__");
    1393                 :            : 
    1394                 :     156687 :   if (flag_no_inline)
    1395                 :      69547 :     cpp_define (pfile, "__NO_INLINE__");
    1396                 :            : 
    1397                 :     156687 :   if (flag_iso)
    1398                 :      41960 :     cpp_define (pfile, "__STRICT_ANSI__");
    1399                 :            : 
    1400                 :     156687 :   if (!flag_signed_char)
    1401                 :         21 :     cpp_define (pfile, "__CHAR_UNSIGNED__");
    1402                 :            : 
    1403                 :     156687 :   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
    1404                 :          3 :     cpp_define (pfile, "__WCHAR_UNSIGNED__");
    1405                 :            : 
    1406                 :     156687 :   cpp_atomic_builtins (pfile);
    1407                 :            : 
    1408                 :            :   /* Show support for __builtin_speculation_safe_value () if the target
    1409                 :            :      has been updated to fully support it.  */
    1410                 :     156687 :   if (targetm.have_speculation_safe_value (false))
    1411                 :     156687 :     cpp_define (pfile, "__HAVE_SPECULATION_SAFE_VALUE");
    1412                 :            : 
    1413                 :            : #ifdef DWARF2_UNWIND_INFO
    1414                 :     156687 :   if (dwarf2out_do_cfi_asm ())
    1415                 :     156643 :     cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
    1416                 :            : #endif
    1417                 :            : 
    1418                 :            :   /* Make the choice of ObjC runtime visible to source code.  */
    1419                 :     156687 :   if (c_dialect_objc () && flag_next_runtime)
    1420                 :          0 :     cpp_define (pfile, "__NEXT_RUNTIME__");
    1421                 :            : 
    1422                 :            :   /* Show the availability of some target pragmas.  */
    1423                 :     156687 :   cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
    1424                 :            : 
    1425                 :            :   /* Make the choice of the stack protector runtime visible to source code.
    1426                 :            :      The macro names and values here were chosen for compatibility with an
    1427                 :            :      earlier implementation, i.e. ProPolice.  */
    1428                 :     156687 :   if (flag_stack_protect == 4)
    1429                 :          5 :     cpp_define (pfile, "__SSP_EXPLICIT__=4");
    1430                 :     156687 :   if (flag_stack_protect == 3)
    1431                 :         71 :     cpp_define (pfile, "__SSP_STRONG__=3");
    1432                 :     156687 :   if (flag_stack_protect == 2)
    1433                 :          9 :     cpp_define (pfile, "__SSP_ALL__=2");
    1434                 :     156678 :   else if (flag_stack_protect == 1)
    1435                 :         37 :     cpp_define (pfile, "__SSP__=1");
    1436                 :            : 
    1437                 :     156687 :   if (flag_openacc)
    1438                 :       1251 :     cpp_define (pfile, "_OPENACC=201711");
    1439                 :            : 
    1440                 :     156687 :   if (flag_openmp)
    1441                 :       3401 :     cpp_define (pfile, "_OPENMP=201511");
    1442                 :            : 
    1443                 :     313374 :   for (i = 0; i < NUM_INT_N_ENTS; i ++)
    1444                 :     156687 :     if (int_n_enabled_p[i])
    1445                 :            :       {
    1446                 :     152282 :         char buf[15+20];
    1447                 :     152282 :         sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
    1448                 :     152282 :         builtin_define_type_sizeof (buf,
    1449                 :            :                                     int_n_trees[i].signed_type);
    1450                 :            :       }
    1451                 :     156687 :   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
    1452                 :     156687 :   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
    1453                 :     156687 :   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
    1454                 :            :                               unsigned_ptrdiff_type_node);
    1455                 :            : 
    1456                 :            :   /* A straightforward target hook doesn't work, because of problems
    1457                 :            :      linking that hook's body when part of non-C front ends.  */
    1458                 :            : # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
    1459                 :            : # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
    1460                 :            : # define builtin_define(TXT) cpp_define (pfile, TXT)
    1461                 :            : # define builtin_assert(TXT) cpp_assert (pfile, TXT)
    1462                 :     156687 :   TARGET_CPU_CPP_BUILTINS ();
    1463                 :     156687 :   TARGET_OS_CPP_BUILTINS ();
    1464                 :     156687 :   TARGET_OBJFMT_CPP_BUILTINS ();
    1465                 :            : 
    1466                 :            :   /* Support the __declspec keyword by turning them into attributes.
    1467                 :            :      Note that the current way we do this may result in a collision
    1468                 :            :      with predefined attributes later on.  This can be solved by using
    1469                 :            :      one attribute, say __declspec__, and passing args to it.  The
    1470                 :            :      problem with that approach is that args are not accumulated: each
    1471                 :            :      new appearance would clobber any existing args.  */
    1472                 :     156687 :   if (TARGET_DECLSPEC)
    1473                 :            :     builtin_define ("__declspec(x)=__attribute__((x))");
    1474                 :            : 
    1475                 :            :   /* If decimal floating point is supported, tell the user if the
    1476                 :            :      alternate format (BID) is used instead of the standard (DPD)
    1477                 :            :      format.  */
    1478                 :     156687 :   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
    1479                 :     156687 :     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
    1480                 :            : }
    1481                 :            : 
    1482                 :            : /* Pass an object-like macro.  If it doesn't lie in the user's
    1483                 :            :    namespace, defines it unconditionally.  Otherwise define a version
    1484                 :            :    with two leading underscores, and another version with two leading
    1485                 :            :    and trailing underscores, and define the original only if an ISO
    1486                 :            :    standard was not nominated.
    1487                 :            : 
    1488                 :            :    e.g. passing "unix" defines "__unix", "__unix__" and possibly
    1489                 :            :    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
    1490                 :            :    "_mips".  */
    1491                 :            : void
    1492                 :     317779 : builtin_define_std (const char *macro)
    1493                 :            : {
    1494                 :     317779 :   size_t len = strlen (macro);
    1495                 :     317779 :   char *buff = (char *) alloca (len + 5);
    1496                 :     317779 :   char *p = buff + 2;
    1497                 :     317779 :   char *q = p + len;
    1498                 :            : 
    1499                 :            :   /* prepend __ (or maybe just _) if in user's namespace.  */
    1500                 :     317779 :   memcpy (p, macro, len + 1);
    1501                 :     317779 :   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
    1502                 :            :     {
    1503                 :     317779 :       if (*p != '_')
    1504                 :     317779 :         *--p = '_';
    1505                 :     317779 :       if (p[1] != '_')
    1506                 :     317779 :         *--p = '_';
    1507                 :            :     }
    1508                 :     317779 :   cpp_define (parse_in, p);
    1509                 :            : 
    1510                 :            :   /* If it was in user's namespace...  */
    1511                 :     317779 :   if (p != buff + 2)
    1512                 :            :     {
    1513                 :            :       /* Define the macro with leading and following __.  */
    1514                 :     317779 :       if (q[-1] != '_')
    1515                 :     317779 :         *q++ = '_';
    1516                 :     317779 :       if (q[-2] != '_')
    1517                 :     317779 :         *q++ = '_';
    1518                 :     317779 :       *q = '\0';
    1519                 :     317779 :       cpp_define (parse_in, p);
    1520                 :            : 
    1521                 :            :       /* Finally, define the original macro if permitted.  */
    1522                 :     317779 :       if (!flag_iso)
    1523                 :     233821 :         cpp_define (parse_in, macro);
    1524                 :            :     }
    1525                 :     317779 : }
    1526                 :            : 
    1527                 :            : /* Pass an object-like macro and a value to define it to.  The third
    1528                 :            :    parameter says whether or not to turn the value into a string
    1529                 :            :    constant.  */
    1530                 :            : void
    1531                 :   11929000 : builtin_define_with_value (const char *macro, const char *expansion, int is_str)
    1532                 :            : {
    1533                 :   11929000 :   char *buf;
    1534                 :   11929000 :   size_t mlen = strlen (macro);
    1535                 :   11929000 :   size_t elen = strlen (expansion);
    1536                 :   11929000 :   size_t extra = 2;  /* space for an = and a NUL */
    1537                 :            : 
    1538                 :   11929000 :   if (is_str)
    1539                 :            :     {
    1540                 :       1584 :       char *quoted_expansion = (char *) alloca (elen * 4 + 1);
    1541                 :       1584 :       const char *p;
    1542                 :       1584 :       char *q;
    1543                 :       1584 :       extra += 2;  /* space for two quote marks */
    1544                 :      13464 :       for (p = expansion, q = quoted_expansion; *p; p++)
    1545                 :            :         {
    1546                 :      11880 :           switch (*p)
    1547                 :            :             {
    1548                 :          0 :             case '\n':
    1549                 :          0 :               *q++ = '\\';
    1550                 :          0 :               *q++ = 'n';
    1551                 :          0 :               break;
    1552                 :            : 
    1553                 :        792 :             case '\t':
    1554                 :        792 :               *q++ = '\\';
    1555                 :        792 :               *q++ = 't';
    1556                 :        792 :               break;
    1557                 :            : 
    1558                 :          0 :             case '\\':
    1559                 :          0 :               *q++ = '\\';
    1560                 :          0 :               *q++ = '\\';
    1561                 :          0 :               break;
    1562                 :            : 
    1563                 :          0 :             case '"':
    1564                 :          0 :               *q++ = '\\';
    1565                 :          0 :               *q++ = '"';
    1566                 :          0 :               break;
    1567                 :            : 
    1568                 :      11088 :             default:
    1569                 :      11088 :               if (ISPRINT ((unsigned char) *p))
    1570                 :      11088 :                 *q++ = *p;
    1571                 :            :               else
    1572                 :            :                 {
    1573                 :          0 :                   sprintf (q, "\\%03o", (unsigned char) *p);
    1574                 :          0 :                   q += 4;
    1575                 :            :                 }
    1576                 :            :             }
    1577                 :            :         }
    1578                 :       1584 :       *q = '\0';
    1579                 :       1584 :       expansion = quoted_expansion;
    1580                 :       1584 :       elen = q - expansion;
    1581                 :            :     }
    1582                 :            : 
    1583                 :   11929000 :   buf = (char *) alloca (mlen + elen + extra);
    1584                 :   11929000 :   if (is_str)
    1585                 :       1584 :     sprintf (buf, "%s=\"%s\"", macro, expansion);
    1586                 :            :   else
    1587                 :   11927400 :     sprintf (buf, "%s=%s", macro, expansion);
    1588                 :            : 
    1589                 :   11929000 :   cpp_define (parse_in, buf);
    1590                 :   11929000 : }
    1591                 :            : 
    1592                 :            : 
    1593                 :            : /* Pass an object-like macro and an integer value to define it to.  */
    1594                 :            : void
    1595                 :   16489100 : builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
    1596                 :            : {
    1597                 :   16489100 :   char *buf;
    1598                 :   16489100 :   size_t mlen = strlen (macro);
    1599                 :   16489100 :   size_t vlen = 18;
    1600                 :   16489100 :   size_t extra = 2; /* space for = and NUL.  */
    1601                 :            : 
    1602                 :   16489100 :   buf = (char *) alloca (mlen + vlen + extra);
    1603                 :   16489100 :   memcpy (buf, macro, mlen);
    1604                 :   16489100 :   buf[mlen] = '=';
    1605                 :   16489100 :   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
    1606                 :            : 
    1607                 :   16489100 :   cpp_define (parse_in, buf);
    1608                 :   16489100 : }
    1609                 :            : 
    1610                 :            : /* builtin_define_with_hex_fp_value is very expensive, so the following
    1611                 :            :    array and function allows it to be done lazily when __DBL_MAX__
    1612                 :            :    etc. is first used.  */
    1613                 :            : 
    1614                 :            : struct GTY(()) lazy_hex_fp_value_struct
    1615                 :            : {
    1616                 :            :   const char *hex_str;
    1617                 :            :   machine_mode mode;
    1618                 :            :   int digits;
    1619                 :            :   const char *fp_suffix;
    1620                 :            : };
    1621                 :            : /* Number of the expensive to compute macros we should evaluate lazily.
    1622                 :            :    Each builtin_define_float_constants invocation calls
    1623                 :            :    builtin_define_with_hex_fp_value 5 times and builtin_define_float_constants
    1624                 :            :    is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
    1625                 :            :    FLTNN*.  */ 
    1626                 :            : #define LAZY_HEX_FP_VALUES_CNT (5 * (3 + NUM_FLOATN_NX_TYPES))
    1627                 :            : static GTY(()) struct lazy_hex_fp_value_struct
    1628                 :            :   lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT];
    1629                 :            : static GTY(()) unsigned lazy_hex_fp_value_count;
    1630                 :            : 
    1631                 :            : static void
    1632                 :      20356 : lazy_hex_fp_value (cpp_reader *, cpp_macro *macro, unsigned num)
    1633                 :            : {
    1634                 :      20356 :   REAL_VALUE_TYPE real;
    1635                 :      20356 :   char dec_str[64], buf1[256];
    1636                 :            : 
    1637                 :      20356 :   gcc_checking_assert (num < lazy_hex_fp_value_count);
    1638                 :            : 
    1639                 :      20356 :   real_from_string (&real, lazy_hex_fp_values[num].hex_str);
    1640                 :      20356 :   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
    1641                 :      20356 :                             lazy_hex_fp_values[num].digits, 0,
    1642                 :            :                             lazy_hex_fp_values[num].mode);
    1643                 :            : 
    1644                 :      20356 :   size_t len
    1645                 :      20356 :     = sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[num].fp_suffix);
    1646                 :      20356 :   gcc_assert (len < sizeof (buf1));
    1647                 :      34216 :   for (unsigned idx = 0; idx < macro->count; idx++)
    1648                 :      34216 :     if (macro->exp.tokens[idx].type == CPP_NUMBER)
    1649                 :            :       {
    1650                 :      20356 :         macro->exp.tokens[idx].val.str.len = len;
    1651                 :      20356 :         macro->exp.tokens[idx].val.str.text
    1652                 :      20356 :           = (const unsigned char *) ggc_strdup (buf1);
    1653                 :      20356 :         return;
    1654                 :            :       }
    1655                 :            : 
    1656                 :            :   /* We must have replaced a token.  */
    1657                 :          0 :   gcc_unreachable ();
    1658                 :            : }
    1659                 :            : 
    1660                 :            : /* Pass an object-like macro a hexadecimal floating-point value.  */
    1661                 :            : static void
    1662                 :    6267480 : builtin_define_with_hex_fp_value (const char *macro,
    1663                 :            :                                   tree type, int digits,
    1664                 :            :                                   const char *hex_str,
    1665                 :            :                                   const char *fp_suffix,
    1666                 :            :                                   const char *fp_cast)
    1667                 :            : {
    1668                 :    6267480 :   REAL_VALUE_TYPE real;
    1669                 :    6267480 :   char dec_str[64], buf[256], buf1[128], buf2[64];
    1670                 :            : 
    1671                 :            :   /* This is very expensive, so if possible expand them lazily.  */
    1672                 :    6267480 :   if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT
    1673                 :    6267480 :       && flag_dump_macros == 0
    1674                 :    6219400 :       && flag_dump_go_spec == NULL
    1675                 :   12486800 :       && !cpp_get_options (parse_in)->traditional)
    1676                 :            :     {
    1677                 :    6217200 :       if (lazy_hex_fp_value_count == 0)
    1678                 :     155430 :         cpp_get_callbacks (parse_in)->user_lazy_macro = lazy_hex_fp_value;
    1679                 :    6217200 :       sprintf (buf2, fp_cast, "1.1");
    1680                 :    6217200 :       sprintf (buf1, "%s=%s", macro, buf2);
    1681                 :    6217200 :       cpp_define (parse_in, buf1);
    1682                 :    6217200 :       struct cpp_hashnode *node = C_CPP_HASHNODE (get_identifier (macro));
    1683                 :    6217200 :       lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
    1684                 :    6217200 :         = ggc_strdup (hex_str);
    1685                 :    6217200 :       lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
    1686                 :    6217200 :       lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
    1687                 :    6217200 :       lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
    1688                 :    6217200 :       cpp_define_lazily (parse_in, node, lazy_hex_fp_value_count++);
    1689                 :    6217200 :       return;
    1690                 :            :     }
    1691                 :            : 
    1692                 :            :   /* Hex values are really cool and convenient, except that they're
    1693                 :            :      not supported in strict ISO C90 mode.  First, the "p-" sequence
    1694                 :            :      is not valid as part of a preprocessor number.  Second, we get a
    1695                 :            :      pedwarn from the preprocessor, which has no context, so we can't
    1696                 :            :      suppress the warning with __extension__.
    1697                 :            : 
    1698                 :            :      So instead what we do is construct the number in hex (because
    1699                 :            :      it's easy to get the exact correct value), parse it as a real,
    1700                 :            :      then print it back out as decimal.  */
    1701                 :            : 
    1702                 :      50280 :   real_from_string (&real, hex_str);
    1703                 :     100560 :   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
    1704                 :      50280 :                             TYPE_MODE (type));
    1705                 :            : 
    1706                 :            :   /* Assemble the macro in the following fashion
    1707                 :            :      macro = fp_cast [dec_str fp_suffix] */
    1708                 :      50280 :   sprintf (buf2, "%s%s", dec_str, fp_suffix);
    1709                 :      50280 :   sprintf (buf1, fp_cast, buf2);
    1710                 :      50280 :   sprintf (buf, "%s=%s", macro, buf1);
    1711                 :            : 
    1712                 :      50280 :   cpp_define (parse_in, buf);
    1713                 :            : }
    1714                 :            : 
    1715                 :            : /* Return a string constant for the suffix for a value of type TYPE
    1716                 :            :    promoted according to the integer promotions.  The type must be one
    1717                 :            :    of the standard integer type nodes.  */
    1718                 :            : 
    1719                 :            : static const char *
    1720                 :    7520980 : type_suffix (tree type)
    1721                 :            : {
    1722                 :    7520980 :   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
    1723                 :    7520980 :   int unsigned_suffix;
    1724                 :    7520980 :   int is_long;
    1725                 :    7520980 :   int tp = TYPE_PRECISION (type);
    1726                 :            : 
    1727                 :    7520980 :   if (type == long_long_integer_type_node
    1728                 :    7337450 :       || type == long_long_unsigned_type_node
    1729                 :   14831600 :       || tp > TYPE_PRECISION (long_integer_type_node))
    1730                 :            :     is_long = 2;
    1731                 :    7310610 :   else if (type == long_integer_type_node
    1732                 :    5627310 :            || type == long_unsigned_type_node
    1733                 :   11415800 :            || tp > TYPE_PRECISION (integer_type_node))
    1734                 :            :     is_long = 1;
    1735                 :    4105170 :   else if (type == integer_type_node
    1736                 :    3151640 :            || type == unsigned_type_node
    1737                 :    2507000 :            || type == short_integer_type_node
    1738                 :    1880250 :            || type == short_unsigned_type_node
    1739                 :    1410180 :            || type == signed_char_type_node
    1740                 :     626748 :            || type == unsigned_char_type_node
    1741                 :            :            /* ??? "char" is not a signed or unsigned integer type and
    1742                 :            :               so is not permitted for the standard typedefs, but some
    1743                 :            :               systems use it anyway.  */
    1744                 :          0 :            || type == char_type_node)
    1745                 :            :     is_long = 0;
    1746                 :            :   else
    1747                 :          0 :     gcc_unreachable ();
    1748                 :            : 
    1749                 :    7520980 :   unsigned_suffix = TYPE_UNSIGNED (type);
    1750                 :    7520980 :   if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
    1751                 :    2507000 :     unsigned_suffix = 0;
    1752                 :    7520980 :   return suffixes[is_long * 2 + unsigned_suffix];
    1753                 :            : }
    1754                 :            : 
    1755                 :            : /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE.  */
    1756                 :            : static void
    1757                 :    1566870 : builtin_define_constants (const char *macro, tree type)
    1758                 :            : {
    1759                 :    1566870 :   const char *suffix;
    1760                 :    1566870 :   char *buf;
    1761                 :            : 
    1762                 :    1566870 :   suffix = type_suffix (type);
    1763                 :            : 
    1764                 :    1566870 :   if (suffix[0] == 0)
    1765                 :            :     {
    1766                 :     783435 :       buf = (char *) alloca (strlen (macro) + 6);
    1767                 :     783435 :       sprintf (buf, "%s(c)=c", macro);
    1768                 :            :     }
    1769                 :            :   else
    1770                 :            :     {
    1771                 :     783435 :       buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
    1772                 :     783435 :       sprintf (buf, "%s(c)=c ## %s", macro, suffix);
    1773                 :            :     }
    1774                 :            : 
    1775                 :    1566870 :   cpp_define (parse_in, buf);
    1776                 :    1566870 : }
    1777                 :            : 
    1778                 :            : /* Define MAX for TYPE based on the precision of the type.  */
    1779                 :            : 
    1780                 :            : static void
    1781                 :    5484040 : builtin_define_type_max (const char *macro, tree type)
    1782                 :            : {
    1783                 :    4700610 :   builtin_define_type_minmax (NULL, macro, type);
    1784                 :    2036930 : }
    1785                 :            : 
    1786                 :            : /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
    1787                 :            :    representation of that value.  For example, a COUNT of 10 would
    1788                 :            :    return "0x3ff".  */
    1789                 :            : 
    1790                 :            : static void
    1791                 :    5954110 : print_bits_of_hex (char *buf, int bufsz, int count)
    1792                 :            : {
    1793                 :    5954110 :   gcc_assert (bufsz > 3);
    1794                 :    5954110 :   *buf++ = '0';
    1795                 :    5954110 :   *buf++ = 'x';
    1796                 :    5954110 :   bufsz -= 2;
    1797                 :            : 
    1798                 :    5954110 :   gcc_assert (count > 0);
    1799                 :            : 
    1800                 :    5954110 :   switch (count % 4) {
    1801                 :            :   case 0:
    1802                 :            :     break;
    1803                 :          0 :   case 1:
    1804                 :          0 :     *buf++ = '1';
    1805                 :          0 :     bufsz --;
    1806                 :          0 :     count -= 1;
    1807                 :          0 :     break;
    1808                 :          0 :   case 2:
    1809                 :          0 :     *buf++ = '3';
    1810                 :          0 :     bufsz --;
    1811                 :          0 :     count -= 2;
    1812                 :          0 :     break;
    1813                 :    3447100 :   case 3:
    1814                 :    3447100 :     *buf++ = '7';
    1815                 :    3447100 :     bufsz --;
    1816                 :    3447100 :     count -= 3;
    1817                 :    3447100 :     break;
    1818                 :            :   }
    1819                 :   62666100 :   while (count >= 4)
    1820                 :            :     {
    1821                 :   56712000 :       gcc_assert (bufsz > 1);
    1822                 :   56712000 :       *buf++ = 'f';
    1823                 :   56712000 :       bufsz --;
    1824                 :   56712000 :       count -= 4;
    1825                 :            :     }
    1826                 :    5954110 :   gcc_assert (bufsz > 0);
    1827                 :    5954110 :   *buf++ = 0;
    1828                 :    5954110 : }
    1829                 :            : 
    1830                 :            : /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
    1831                 :            :    precision of the type.  */
    1832                 :            : 
    1833                 :            : static void
    1834                 :    5954110 : builtin_define_type_minmax (const char *min_macro, const char *max_macro,
    1835                 :            :                             tree type)
    1836                 :            : {
    1837                 :            : #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
    1838                 :    5954110 :   char value[PBOH_SZ];
    1839                 :            : 
    1840                 :    5954110 :   const char *suffix;
    1841                 :    5954110 :   char *buf;
    1842                 :    5954110 :   int bits;
    1843                 :            : 
    1844                 :    5954110 :   bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
    1845                 :            : 
    1846                 :    5954110 :   print_bits_of_hex (value, PBOH_SZ, bits);
    1847                 :            : 
    1848                 :    5954110 :   suffix = type_suffix (type);
    1849                 :            : 
    1850                 :    5954110 :   buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
    1851                 :            :                          + strlen (suffix) + 1);
    1852                 :    5954110 :   sprintf (buf, "%s=%s%s", max_macro, value, suffix);
    1853                 :            : 
    1854                 :    5954110 :   cpp_define (parse_in, buf);
    1855                 :            : 
    1856                 :    5954110 :   if (min_macro)
    1857                 :            :     {
    1858                 :     470061 :       if (TYPE_UNSIGNED (type))
    1859                 :            :         {
    1860                 :     156696 :           buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
    1861                 :     156696 :           sprintf (buf, "%s=0%s", min_macro, suffix);
    1862                 :            :         }
    1863                 :            :       else
    1864                 :            :         {
    1865                 :     313365 :           buf = (char *) alloca (strlen (min_macro) + 3
    1866                 :            :                                  + strlen (max_macro) + 6);
    1867                 :     313365 :           sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
    1868                 :            :         }
    1869                 :     470061 :       cpp_define (parse_in, buf);
    1870                 :            :     }
    1871                 :    5954110 : }
    1872                 :            : 
    1873                 :            : /* Define WIDTH_MACRO for the width of TYPE.  If TYPE2 is not NULL,
    1874                 :            :    both types must have the same width.  */
    1875                 :            : 
    1876                 :            : static void
    1877                 :    3133740 : builtin_define_type_width (const char *width_macro, tree type, tree type2)
    1878                 :            : {
    1879                 :    3133740 :   if (type2 != NULL_TREE)
    1880                 :    2350300 :     gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
    1881                 :    3133740 :   builtin_define_with_int_value (width_macro, TYPE_PRECISION (type));
    1882                 :    3133740 : }
    1883                 :            : 
    1884                 :            : #include "gt-c-family-c-cppbuiltin.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.