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

Generated by: LCOV version 2.0-1

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.