gcc/c-family/c-cppbuiltin.c

   1 /* Define builtin-in macros for the C family front ends.
   2    Copyright (C) 2002-2013 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 "tm.h"
  24 #include "tree.h"
  25 #include "version.h"
  26 #include "flags.h"
  27 #include "c-common.h"
  28 #include "c-pragma.h"
  29 #include "output.h"             /* For user_label_prefix.  */
  30 #include "debug.h"              /* For dwarf2out_do_cfi_asm.  */
  31 #include "tm_p.h"               /* For TARGET_CPU_CPP_BUILTINS & friends.  */
  32 #include "target.h"
  33 #include "common/common-target.h"
  34 #include "cpp-id-data.h"
  35 #include "cppbuiltin.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 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
  51 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
  52 static void builtin_define_with_hex_fp_value (const char *, tree,
  53                                               int, const char *,
  54                                               const char *,
  55                                               const char *);
  56 static void builtin_define_stdint_macros (void);
  57 static void builtin_define_constants (const char *, tree);
  58 static void builtin_define_type_max (const char *, tree);
  59 static void builtin_define_type_minmax (const char *, const char *, tree);
  60 static void builtin_define_type_sizeof (const char *, tree);
  61 static void builtin_define_float_constants (const char *,
  62                                             const char *,
  63                                             const char *,
  64                                             const char *,
  65                                             tree);
  66
  67 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
  68    Originally this function used the fma optab, but that doesn't work with
  69    -save-temps, so just rely on the HAVE_fma macros for the standard floating
  70    point types.  */
  71
  72 static bool
  73 mode_has_fma (enum machine_mode mode)
  74 {
  75   switch (mode)
  76     {
  77 #ifdef HAVE_fmasf4
  78     case SFmode:
  79       return !!HAVE_fmasf4;
  80 #endif
  81
  82 #ifdef HAVE_fmadf4
  83     case DFmode:
  84       return !!HAVE_fmadf4;
  85 #endif
  86
  87 #ifdef HAVE_fmaxf4
  88     case XFmode:
  89       return !!HAVE_fmaxf4;
  90 #endif
  91
  92 #ifdef HAVE_fmatf4
  93     case TFmode:
  94       return !!HAVE_fmatf4;
  95 #endif
  96
  97     default:
  98       break;
  99     }
 100
 101   return false;
 102 }
 103
 104 /* Define NAME with value TYPE size_unit.  */
 105 static void
 106 builtin_define_type_sizeof (const char *name, tree type)
 107 {
 108   builtin_define_with_int_value (name,
 109                                  tree_low_cst (TYPE_SIZE_UNIT (type), 1));
 110 }
 111
 112 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
 113    and FP_CAST. */
 114 static void
 115 builtin_define_float_constants (const char *name_prefix,
 116                                 const char *fp_suffix,
 117                                 const char *fp_cast,
 118                                 const char *fma_suffix,
 119                                 tree type)
 120 {
 121   /* Used to convert radix-based values to base 10 values in several cases.
 122
 123      In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
 124      least 6 significant digits for correct results.  Using the fraction
 125      formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
 126      intermediate; perhaps someone can find a better approximation, in the
 127      mean time, I suspect using doubles won't harm the bootstrap here.  */
 128
 129   const double log10_2 = .30102999566398119521;
 130   double log10_b;
 131   const struct real_format *fmt;
 132   const struct real_format *ldfmt;
 133
 134   char name[64], buf[128];
 135   int dig, min_10_exp, max_10_exp;
 136   int decimal_dig;
 137   int type_decimal_dig;
 138
 139   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
 140   gcc_assert (fmt->b != 10);
 141   ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
 142   gcc_assert (ldfmt->b != 10);
 143
 144   /* The radix of the exponent representation.  */
 145   if (type == float_type_node)
 146     builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
 147   log10_b = log10_2;
 148
 149   /* The number of radix digits, p, in the floating-point significand.  */
 150   sprintf (name, "__%s_MANT_DIG__", name_prefix);
 151   builtin_define_with_int_value (name, fmt->p);
 152
 153   /* The number of decimal digits, q, such that any floating-point number
 154      with q decimal digits can be rounded into a floating-point number with
 155      p radix b digits and back again without change to the q decimal digits,
 156
 157         p log10 b                       if b is a power of 10
 158         floor((p - 1) log10 b)          otherwise
 159   */
 160   dig = (fmt->p - 1) * log10_b;
 161   sprintf (name, "__%s_DIG__", name_prefix);
 162   builtin_define_with_int_value (name, dig);
 163
 164   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
 165   sprintf (name, "__%s_MIN_EXP__", name_prefix);
 166   sprintf (buf, "(%d)", fmt->emin);
 167   builtin_define_with_value (name, buf, 0);
 168
 169   /* The minimum negative int x such that 10**x is a normalized float,
 170
 171           ceil (log10 (b ** (emin - 1)))
 172         = ceil (log10 (b) * (emin - 1))
 173
 174      Recall that emin is negative, so the integer truncation calculates
 175      the ceiling, not the floor, in this case.  */
 176   min_10_exp = (fmt->emin - 1) * log10_b;
 177   sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
 178   sprintf (buf, "(%d)", min_10_exp);
 179   builtin_define_with_value (name, buf, 0);
 180
 181   /* The maximum int x such that b**(x-1) is a representable float.  */
 182   sprintf (name, "__%s_MAX_EXP__", name_prefix);
 183   builtin_define_with_int_value (name, fmt->emax);
 184
 185   /* The maximum int x such that 10**x is in the range of representable
 186      finite floating-point numbers,
 187
 188           floor (log10((1 - b**-p) * b**emax))
 189         = floor (log10(1 - b**-p) + log10(b**emax))
 190         = floor (log10(1 - b**-p) + log10(b)*emax)
 191
 192      The safest thing to do here is to just compute this number.  But since
 193      we don't link cc1 with libm, we cannot.  We could implement log10 here
 194      a series expansion, but that seems too much effort because:
 195
 196      Note that the first term, for all extant p, is a number exceedingly close
 197      to zero, but slightly negative.  Note that the second term is an integer
 198      scaling an irrational number, and that because of the floor we are only
 199      interested in its integral portion.
 200
 201      In order for the first term to have any effect on the integral portion
 202      of the second term, the second term has to be exceedingly close to an
 203      integer itself (e.g. 123.000000000001 or something).  Getting a result
 204      that close to an integer requires that the irrational multiplicand have
 205      a long series of zeros in its expansion, which doesn't occur in the
 206      first 20 digits or so of log10(b).
 207
 208      Hand-waving aside, crunching all of the sets of constants above by hand
 209      does not yield a case for which the first term is significant, which
 210      in the end is all that matters.  */
 211   max_10_exp = fmt->emax * log10_b;
 212   sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
 213   builtin_define_with_int_value (name, max_10_exp);
 214
 215   /* The number of decimal digits, n, such that any floating-point number
 216      can be rounded to n decimal digits and back again without change to
 217      the value.
 218
 219         p * log10(b)                    if b is a power of 10
 220         ceil(1 + p * log10(b))          otherwise
 221
 222      The only macro we care about is this number for the widest supported
 223      floating type, but we want this value for rendering constants below.  */
 224   {
 225     double d_decimal_dig
 226       = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
 227     decimal_dig = d_decimal_dig;
 228     if (decimal_dig < d_decimal_dig)
 229       decimal_dig++;
 230   }
 231   /* Similar, for this type rather than long double.  */
 232   {
 233     double type_d_decimal_dig = 1 + fmt->p * log10_b;
 234     type_decimal_dig = type_d_decimal_dig;
 235     if (type_decimal_dig < type_d_decimal_dig)
 236       type_decimal_dig++;
 237   }
 238   if (type == long_double_type_node)
 239     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
 240   else
 241     {
 242       sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
 243       builtin_define_with_int_value (name, type_decimal_dig);
 244     }
 245
 246   /* Since, for the supported formats, B is always a power of 2, we
 247      construct the following numbers directly as a hexadecimal
 248      constants.  */
 249   get_max_float (fmt, buf, sizeof (buf));
 250
 251   sprintf (name, "__%s_MAX__", name_prefix);
 252   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 253
 254   /* The minimum normalized positive floating-point number,
 255      b**(emin-1).  */
 256   sprintf (name, "__%s_MIN__", name_prefix);
 257   sprintf (buf, "0x1p%d", fmt->emin - 1);
 258   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 259
 260   /* The difference between 1 and the least value greater than 1 that is
 261      representable in the given floating point type, b**(1-p).  */
 262   sprintf (name, "__%s_EPSILON__", name_prefix);
 263   if (fmt->pnan < fmt->p)
 264     /* This is an IBM extended double format, so 1.0 + any double is
 265        representable precisely.  */
 266       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
 267     else
 268       sprintf (buf, "0x1p%d", 1 - fmt->p);
 269   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 270
 271   /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
 272      positive floating-point number, b**(emin-p).  Zero for formats that
 273      don't support denormals.  */
 274   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
 275   if (fmt->has_denorm)
 276     {
 277       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
 278       builtin_define_with_hex_fp_value (name, type, decimal_dig,
 279                                         buf, fp_suffix, fp_cast);
 280     }
 281   else
 282     {
 283       sprintf (buf, "0.0%s", fp_suffix);
 284       builtin_define_with_value (name, buf, 0);
 285     }
 286
 287   sprintf (name, "__%s_HAS_DENORM__", name_prefix);
 288   builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
 289
 290   /* For C++ std::numeric_limits<T>::has_infinity.  */
 291   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
 292   builtin_define_with_int_value (name,
 293                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
 294   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
 295      predicate to distinguish a target that has both quiet and
 296      signalling NaNs from a target that has only quiet NaNs or only
 297      signalling NaNs, so we assume that a target that has any kind of
 298      NaN has quiet NaNs.  */
 299   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
 300   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
 301
 302   /* Note whether we have fast FMA.  */
 303   if (mode_has_fma (TYPE_MODE (type)))
 304     {
 305       sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
 306       builtin_define_with_int_value (name, 1);
 307     }
 308 }
 309
 310 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
 311 static void
 312 builtin_define_decimal_float_constants (const char *name_prefix,
 313                                         const char *suffix,
 314                                         tree type)
 315 {
 316   const struct real_format *fmt;
 317   char name[64], buf[128], *p;
 318   int digits;
 319
 320   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
 321
 322   /* The number of radix digits, p, in the significand.  */
 323   sprintf (name, "__%s_MANT_DIG__", name_prefix);
 324   builtin_define_with_int_value (name, fmt->p);
 325
 326   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
 327   sprintf (name, "__%s_MIN_EXP__", name_prefix);
 328   sprintf (buf, "(%d)", fmt->emin);
 329   builtin_define_with_value (name, buf, 0);
 330
 331   /* The maximum int x such that b**(x-1) is a representable float.  */
 332   sprintf (name, "__%s_MAX_EXP__", name_prefix);
 333   builtin_define_with_int_value (name, fmt->emax);
 334
 335   /* Compute the minimum representable value.  */
 336   sprintf (name, "__%s_MIN__", name_prefix);
 337   sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
 338   builtin_define_with_value (name, buf, 0);
 339
 340   /* Compute the maximum representable value.  */
 341   sprintf (name, "__%s_MAX__", name_prefix);
 342   p = buf;
 343   for (digits = fmt->p; digits; digits--)
 344     {
 345       *p++ = '9';
 346       if (digits == fmt->p)
 347         *p++ = '.';
 348     }
 349   *p = 0;
 350   /* fmt->p plus 1, to account for the decimal point and fmt->emax
 351      minus 1 because the digits are nines, not 1.0.  */
 352   sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
 353   builtin_define_with_value (name, buf, 0);
 354
 355   /* Compute epsilon (the difference between 1 and least value greater
 356      than 1 representable).  */
 357   sprintf (name, "__%s_EPSILON__", name_prefix);
 358   sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
 359   builtin_define_with_value (name, buf, 0);
 360
 361   /* Minimum subnormal positive decimal value.  */
 362   sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
 363   p = buf;
 364   for (digits = fmt->p; digits > 1; digits--)
 365     {
 366       *p++ = '0';
 367       if (digits == fmt->p)
 368         *p++ = '.';
 369     }
 370   *p = 0;
 371   sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
 372   builtin_define_with_value (name, buf, 0);
 373 }
 374
 375 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX.  */
 376
 377 static void
 378 builtin_define_fixed_point_constants (const char *name_prefix,
 379                                       const char *suffix,
 380                                       tree type)
 381 {
 382   char name[64], buf[256], *new_buf;
 383   int i, mod;
 384
 385   sprintf (name, "__%s_FBIT__", name_prefix);
 386   builtin_define_with_int_value (name, TYPE_FBIT (type));
 387
 388   sprintf (name, "__%s_IBIT__", name_prefix);
 389   builtin_define_with_int_value (name, TYPE_IBIT (type));
 390
 391   /* If there is no suffix, defines are for fixed-point modes.
 392      We just return.  */
 393   if (strcmp (suffix, "") == 0)
 394     return;
 395
 396   if (TYPE_UNSIGNED (type))
 397     {
 398       sprintf (name, "__%s_MIN__", name_prefix);
 399       sprintf (buf, "0.0%s", suffix);
 400       builtin_define_with_value (name, buf, 0);
 401     }
 402   else
 403     {
 404       sprintf (name, "__%s_MIN__", name_prefix);
 405       if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
 406         sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
 407                  TYPE_IBIT (type) - 1, suffix);
 408       else
 409         sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
 410       builtin_define_with_value (name, buf, 0);
 411     }
 412
 413   sprintf (name, "__%s_MAX__", name_prefix);
 414   sprintf (buf, "0X");
 415   new_buf = buf + 2;
 416   mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
 417   if (mod)
 418     sprintf (new_buf++, "%x", (1 << mod) - 1);
 419   for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
 420     sprintf (new_buf++, "F");
 421   sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
 422   builtin_define_with_value (name, buf, 0);
 423
 424   sprintf (name, "__%s_EPSILON__", name_prefix);
 425   sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
 426   builtin_define_with_value (name, buf, 0);
 427 }
 428
 429 /* Define macros used by <stdint.h>.  */
 430 static void
 431 builtin_define_stdint_macros (void)
 432 {
 433   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
 434   builtin_define_constants ("__INTMAX_C", intmax_type_node);
 435   builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
 436   builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
 437   if (sig_atomic_type_node)
 438     builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
 439                                 sig_atomic_type_node);
 440   if (int8_type_node)
 441     builtin_define_type_max ("__INT8_MAX__", int8_type_node);
 442   if (int16_type_node)
 443     builtin_define_type_max ("__INT16_MAX__", int16_type_node);
 444   if (int32_type_node)
 445     builtin_define_type_max ("__INT32_MAX__", int32_type_node);
 446   if (int64_type_node)
 447     builtin_define_type_max ("__INT64_MAX__", int64_type_node);
 448   if (uint8_type_node)
 449     builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
 450   if (c_uint16_type_node)
 451     builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
 452   if (c_uint32_type_node)
 453     builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
 454   if (c_uint64_type_node)
 455     builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
 456   if (int_least8_type_node)
 457     {
 458       builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
 459       builtin_define_constants ("__INT8_C", int_least8_type_node);
 460     }
 461   if (int_least16_type_node)
 462     {
 463       builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
 464       builtin_define_constants ("__INT16_C", int_least16_type_node);
 465     }
 466   if (int_least32_type_node)
 467     {
 468       builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
 469       builtin_define_constants ("__INT32_C", int_least32_type_node);
 470     }
 471   if (int_least64_type_node)
 472     {
 473       builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
 474       builtin_define_constants ("__INT64_C", int_least64_type_node);
 475     }
 476   if (uint_least8_type_node)
 477     {
 478       builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
 479       builtin_define_constants ("__UINT8_C", uint_least8_type_node);
 480     }
 481   if (uint_least16_type_node)
 482     {
 483       builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
 484       builtin_define_constants ("__UINT16_C", uint_least16_type_node);
 485     }
 486   if (uint_least32_type_node)
 487     {
 488       builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
 489       builtin_define_constants ("__UINT32_C", uint_least32_type_node);
 490     }
 491   if (uint_least64_type_node)
 492     {
 493       builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
 494       builtin_define_constants ("__UINT64_C", uint_least64_type_node);
 495     }
 496   if (int_fast8_type_node)
 497     builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
 498   if (int_fast16_type_node)
 499     builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
 500   if (int_fast32_type_node)
 501     builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
 502   if (int_fast64_type_node)
 503     builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
 504   if (uint_fast8_type_node)
 505     builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
 506   if (uint_fast16_type_node)
 507     builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
 508   if (uint_fast32_type_node)
 509     builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
 510   if (uint_fast64_type_node)
 511     builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
 512   if (intptr_type_node)
 513     builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
 514   if (uintptr_type_node)
 515     builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
 516 }
 517
 518 /* Adjust the optimization macros when a #pragma GCC optimization is done to
 519    reflect the current level.  */
 520 void
 521 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
 522                                 tree cur_tree)
 523 {
 524   struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
 525   struct cl_optimization *cur  = TREE_OPTIMIZATION (cur_tree);
 526   bool prev_fast_math;
 527   bool cur_fast_math;
 528
 529   /* -undef turns off target-specific built-ins.  */
 530   if (flag_undef)
 531     return;
 532
 533   /* Other target-independent built-ins determined by command-line
 534      options.  */
 535   if (!prev->x_optimize_size && cur->x_optimize_size)
 536     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 537   else if (prev->x_optimize_size && !cur->x_optimize_size)
 538     cpp_undef (pfile, "__OPTIMIZE_SIZE__");
 539
 540   if (!prev->x_optimize && cur->x_optimize)
 541     cpp_define (pfile, "__OPTIMIZE__");
 542   else if (prev->x_optimize && !cur->x_optimize)
 543     cpp_undef (pfile, "__OPTIMIZE__");
 544
 545   prev_fast_math = fast_math_flags_struct_set_p (prev);
 546   cur_fast_math  = fast_math_flags_struct_set_p (cur);
 547   if (!prev_fast_math && cur_fast_math)
 548     cpp_define (pfile, "__FAST_MATH__");
 549   else if (prev_fast_math && !cur_fast_math)
 550     cpp_undef (pfile, "__FAST_MATH__");
 551
 552   if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
 553     cpp_define (pfile, "__SUPPORT_SNAN__");
 554   else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
 555     cpp_undef (pfile, "__SUPPORT_SNAN__");
 556
 557   if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
 558     {
 559       cpp_undef (pfile, "__FINITE_MATH_ONLY__");
 560       cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 561     }
 562   else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
 563     {
 564       cpp_undef (pfile, "__FINITE_MATH_ONLY__");
 565       cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 566     }
 567 }
 568
 569
 570 /* This function will emit cpp macros to indicate the presence of various lock
 571    free atomic operations.  */
 572
 573 static void
 574 cpp_atomic_builtins (cpp_reader *pfile)
 575 {
 576   /* Set a flag for each size of object that compare and swap exists for up to
 577      a 16 byte object.  */
 578 #define SWAP_LIMIT  17
 579   bool have_swap[SWAP_LIMIT];
 580   unsigned int psize;
 581
 582   /* Clear the map of sizes compare_and swap exists for.  */
 583   memset (have_swap, 0, sizeof (have_swap));
 584
 585   /* Tell source code if the compiler makes sync_compare_and_swap
 586      builtins available.  */
 587 #ifndef HAVE_sync_compare_and_swapqi
 588 #define HAVE_sync_compare_and_swapqi 0
 589 #endif
 590 #ifndef HAVE_atomic_compare_and_swapqi
 591 #define HAVE_atomic_compare_and_swapqi 0
 592 #endif
 593
 594   if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
 595     {
 596       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 597       have_swap[1] = true;
 598     }
 599
 600 #ifndef HAVE_sync_compare_and_swaphi
 601 #define HAVE_sync_compare_and_swaphi 0
 602 #endif
 603 #ifndef HAVE_atomic_compare_and_swaphi
 604 #define HAVE_atomic_compare_and_swaphi 0
 605 #endif
 606   if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
 607     {
 608       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 609       have_swap[2] = true;
 610     }
 611
 612 #ifndef HAVE_sync_compare_and_swapsi
 613 #define HAVE_sync_compare_and_swapsi 0
 614 #endif
 615 #ifndef HAVE_atomic_compare_and_swapsi
 616 #define HAVE_atomic_compare_and_swapsi 0
 617 #endif
 618   if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
 619     {
 620       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 621       have_swap[4] = true;
 622     }
 623
 624 #ifndef HAVE_sync_compare_and_swapdi
 625 #define HAVE_sync_compare_and_swapdi 0
 626 #endif
 627 #ifndef HAVE_atomic_compare_and_swapdi
 628 #define HAVE_atomic_compare_and_swapdi 0
 629 #endif
 630   if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
 631     {
 632       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 633       have_swap[8] = true;
 634     }
 635
 636 #ifndef HAVE_sync_compare_and_swapti
 637 #define HAVE_sync_compare_and_swapti 0
 638 #endif
 639 #ifndef HAVE_atomic_compare_and_swapti
 640 #define HAVE_atomic_compare_and_swapti 0
 641 #endif
 642   if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
 643     {
 644       cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
 645       have_swap[16] = true;
 646     }
 647
 648   /* Tell the source code about various types.  These map to the C++11 and C11
 649      macros where 2 indicates lock-free always, and 1 indicates sometimes
 650      lock free.  */
 651 #define SIZEOF_NODE(T) (tree_low_cst (TYPE_SIZE_UNIT (T), 1))
 652 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
 653   builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
 654                         (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
 655   builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
 656                         (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
 657   builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
 658                         (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
 659   builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
 660                         (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
 661   builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
 662                         (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
 663   builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
 664                       (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
 665   builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
 666                         (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
 667   builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
 668                       (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
 669   builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
 670                 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
 671
 672   /* If we're dealing with a "set" value that doesn't exactly correspond
 673      to a boolean truth value, let the library work around that.  */
 674   builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
 675                                  targetm.atomic_test_and_set_trueval);
 676
 677   /* ptr_type_node can't be used here since ptr_mode is only set when
 678      toplev calls backend_init which is not done with -E  or pch.  */
 679   psize = POINTER_SIZE / BITS_PER_UNIT;
 680   if (psize >= SWAP_LIMIT)
 681     psize = 0;
 682   builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
 683                         (have_swap[psize]? 2 : 1));
 684 }
 685
 686 /* Hook that registers front end and target-specific built-ins.  */
 687 void
 688 c_cpp_builtins (cpp_reader *pfile)
 689 {
 690   /* -undef turns off target-specific built-ins.  */
 691   if (flag_undef)
 692     return;
 693
 694   define_language_independent_builtin_macros (pfile);
 695
 696   if (c_dialect_cxx ())
 697   {
 698     int major;
 699     parse_basever (&major, NULL, NULL);
 700     cpp_define_formatted (pfile, "__GNUG__=%d", major);
 701   }
 702
 703   /* For stddef.h.  They require macros defined in c-common.c.  */
 704   c_stddef_cpp_builtins ();
 705
 706   if (c_dialect_cxx ())
 707     {
 708       if (flag_weak && SUPPORTS_ONE_ONLY)
 709         cpp_define (pfile, "__GXX_WEAK__=1");
 710       else
 711         cpp_define (pfile, "__GXX_WEAK__=0");
 712       if (warn_deprecated)
 713         cpp_define (pfile, "__DEPRECATED");
 714       if (flag_rtti)
 715         cpp_define (pfile, "__GXX_RTTI");
 716       if (cxx_dialect >= cxx0x)
 717         cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
 718     }
 719   /* Note that we define this for C as well, so that we know if
 720      __attribute__((cleanup)) will interface with EH.  */
 721   if (flag_exceptions)
 722     cpp_define (pfile, "__EXCEPTIONS");
 723
 724   /* Represents the C++ ABI version, always defined so it can be used while
 725      preprocessing C and assembler.  */
 726   if (flag_abi_version == 0)
 727     /* Use a very large value so that:
 728
 729          #if __GXX_ABI_VERSION >= <value for version X>
 730
 731        will work whether the user explicitly says "-fabi-version=x" or
 732        "-fabi-version=0".  Do not use INT_MAX because that will be
 733        different from system to system.  */
 734     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
 735   else if (flag_abi_version == 1)
 736     /* Due to a historical accident, this version had the value
 737        "102".  */
 738     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
 739   else
 740     /* Newer versions have values 1002, 1003, ....  */
 741     builtin_define_with_int_value ("__GXX_ABI_VERSION",
 742                                    1000 + flag_abi_version);
 743
 744   /* libgcc needs to know this.  */
 745   if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
 746     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
 747
 748   /* limits.h and stdint.h need to know these.  */
 749   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
 750   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
 751   builtin_define_type_max ("__INT_MAX__", integer_type_node);
 752   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
 753   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
 754   builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
 755                               underlying_wchar_type_node);
 756   builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
 757   builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
 758   builtin_define_type_max ("__SIZE_MAX__", size_type_node);
 759
 760   /* stdint.h and the testsuite need to know these.  */
 761   builtin_define_stdint_macros ();
 762
 763   /* float.h needs to know this.  */
 764   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
 765                                  TARGET_FLT_EVAL_METHOD);
 766
 767   /* And decfloat.h needs this.  */
 768   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
 769                                  TARGET_DEC_EVAL_METHOD);
 770
 771   builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
 772   /* Cast the double precision constants.  This is needed when single
 773      precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
 774      is used.  The correct result is computed by the compiler when using
 775      macros that include a cast.  We use a different cast for C++ to avoid
 776      problems with -Wold-style-cast.  */
 777   builtin_define_float_constants ("DBL", "L",
 778                                   (c_dialect_cxx ()
 779                                    ? "double(%s)"
 780                                    : "((double)%s)"),
 781                                   "", double_type_node);
 782   builtin_define_float_constants ("LDBL", "L", "%s", "L",
 783                                   long_double_type_node);
 784
 785   /* For decfloat.h.  */
 786   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
 787   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
 788   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
 789
 790   /* For fixed-point fibt, ibit, max, min, and epsilon.  */
 791   if (targetm.fixed_point_supported_p ())
 792     {
 793       builtin_define_fixed_point_constants ("SFRACT", "HR",
 794                                             short_fract_type_node);
 795       builtin_define_fixed_point_constants ("USFRACT", "UHR",
 796                                             unsigned_short_fract_type_node);
 797       builtin_define_fixed_point_constants ("FRACT", "R",
 798                                             fract_type_node);
 799       builtin_define_fixed_point_constants ("UFRACT", "UR",
 800                                             unsigned_fract_type_node);
 801       builtin_define_fixed_point_constants ("LFRACT", "LR",
 802                                             long_fract_type_node);
 803       builtin_define_fixed_point_constants ("ULFRACT", "ULR",
 804                                             unsigned_long_fract_type_node);
 805       builtin_define_fixed_point_constants ("LLFRACT", "LLR",
 806                                             long_long_fract_type_node);
 807       builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
 808                                             unsigned_long_long_fract_type_node);
 809       builtin_define_fixed_point_constants ("SACCUM", "HK",
 810                                             short_accum_type_node);
 811       builtin_define_fixed_point_constants ("USACCUM", "UHK",
 812                                             unsigned_short_accum_type_node);
 813       builtin_define_fixed_point_constants ("ACCUM", "K",
 814                                             accum_type_node);
 815       builtin_define_fixed_point_constants ("UACCUM", "UK",
 816                                             unsigned_accum_type_node);
 817       builtin_define_fixed_point_constants ("LACCUM", "LK",
 818                                             long_accum_type_node);
 819       builtin_define_fixed_point_constants ("ULACCUM", "ULK",
 820                                             unsigned_long_accum_type_node);
 821       builtin_define_fixed_point_constants ("LLACCUM", "LLK",
 822                                             long_long_accum_type_node);
 823       builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
 824                                             unsigned_long_long_accum_type_node);
 825
 826       builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
 827       builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
 828       builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
 829       builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
 830       builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
 831       builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
 832       builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
 833       builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
 834       builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
 835       builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
 836       builtin_define_fixed_point_constants ("HA", "", ha_type_node);
 837       builtin_define_fixed_point_constants ("SA", "", sa_type_node);
 838       builtin_define_fixed_point_constants ("DA", "", da_type_node);
 839       builtin_define_fixed_point_constants ("TA", "", ta_type_node);
 840       builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
 841       builtin_define_fixed_point_constants ("USA", "", usa_type_node);
 842       builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
 843       builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
 844     }
 845
 846   /* For libgcc-internal use only.  */
 847   if (flag_building_libgcc)
 848     /* For libgcc enable-execute-stack.c.  */
 849     builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
 850                                    TRAMPOLINE_SIZE);
 851
 852   /* For use in assembly language.  */
 853   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
 854   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
 855
 856   /* Misc.  */
 857   if (flag_gnu89_inline)
 858     cpp_define (pfile, "__GNUC_GNU_INLINE__");
 859   else
 860     cpp_define (pfile, "__GNUC_STDC_INLINE__");
 861
 862   if (flag_no_inline)
 863     cpp_define (pfile, "__NO_INLINE__");
 864
 865   if (flag_iso)
 866     cpp_define (pfile, "__STRICT_ANSI__");
 867
 868   if (!flag_signed_char)
 869     cpp_define (pfile, "__CHAR_UNSIGNED__");
 870
 871   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
 872     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 873
 874   cpp_atomic_builtins (pfile);
 875
 876 #ifdef DWARF2_UNWIND_INFO
 877   if (dwarf2out_do_cfi_asm ())
 878     cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
 879 #endif
 880
 881   /* Make the choice of ObjC runtime visible to source code.  */
 882   if (c_dialect_objc () && flag_next_runtime)
 883     cpp_define (pfile, "__NEXT_RUNTIME__");
 884
 885   /* Show the availability of some target pragmas.  */
 886   cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 887
 888   /* Make the choice of the stack protector runtime visible to source code.
 889      The macro names and values here were chosen for compatibility with an
 890      earlier implementation, i.e. ProPolice.  */
 891   if (flag_stack_protect == 3)
 892     cpp_define (pfile, "__SSP_STRONG__=3");
 893   if (flag_stack_protect == 2)
 894     cpp_define (pfile, "__SSP_ALL__=2");
 895   else if (flag_stack_protect == 1)
 896     cpp_define (pfile, "__SSP__=1");
 897
 898   if (flag_openmp)
 899     cpp_define (pfile, "_OPENMP=201107");
 900
 901   if (int128_integer_type_node != NULL_TREE)
 902     builtin_define_type_sizeof ("__SIZEOF_INT128__",
 903                                 int128_integer_type_node);
 904   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
 905   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
 906   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
 907                               unsigned_ptrdiff_type_node);
 908
 909   /* A straightforward target hook doesn't work, because of problems
 910      linking that hook's body when part of non-C front ends.  */
 911 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 912 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 913 # define builtin_define(TXT) cpp_define (pfile, TXT)
 914 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 915   TARGET_CPU_CPP_BUILTINS ();
 916   TARGET_OS_CPP_BUILTINS ();
 917   TARGET_OBJFMT_CPP_BUILTINS ();
 918
 919   /* Support the __declspec keyword by turning them into attributes.
 920      Note that the current way we do this may result in a collision
 921      with predefined attributes later on.  This can be solved by using
 922      one attribute, say __declspec__, and passing args to it.  The
 923      problem with that approach is that args are not accumulated: each
 924      new appearance would clobber any existing args.  */
 925   if (TARGET_DECLSPEC)
 926     builtin_define ("__declspec(x)=__attribute__((x))");
 927
 928   /* If decimal floating point is supported, tell the user if the
 929      alternate format (BID) is used instead of the standard (DPD)
 930      format.  */
 931   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
 932     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
 933 }
 934
 935 /* Pass an object-like macro.  If it doesn't lie in the user's
 936    namespace, defines it unconditionally.  Otherwise define a version
 937    with two leading underscores, and another version with two leading
 938    and trailing underscores, and define the original only if an ISO
 939    standard was not nominated.
 940
 941    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 942    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 943    "_mips".  */
 944 void
 945 builtin_define_std (const char *macro)
 946 {
 947   size_t len = strlen (macro);
 948   char *buff = (char *) alloca (len + 5);
 949   char *p = buff + 2;
 950   char *q = p + len;
 951
 952   /* prepend __ (or maybe just _) if in user's namespace.  */
 953   memcpy (p, macro, len + 1);
 954   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 955     {
 956       if (*p != '_')
 957         *--p = '_';
 958       if (p[1] != '_')
 959         *--p = '_';
 960     }
 961   cpp_define (parse_in, p);
 962
 963   /* If it was in user's namespace...  */
 964   if (p != buff + 2)
 965     {
 966       /* Define the macro with leading and following __.  */
 967       if (q[-1] != '_')
 968         *q++ = '_';
 969       if (q[-2] != '_')
 970         *q++ = '_';
 971       *q = '\0';
 972       cpp_define (parse_in, p);
 973
 974       /* Finally, define the original macro if permitted.  */
 975       if (!flag_iso)
 976         cpp_define (parse_in, macro);
 977     }
 978 }
 979
 980 /* Pass an object-like macro and a value to define it to.  The third
 981    parameter says whether or not to turn the value into a string
 982    constant.  */
 983 void
 984 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 985 {
 986   char *buf;
 987   size_t mlen = strlen (macro);
 988   size_t elen = strlen (expansion);
 989   size_t extra = 2;  /* space for an = and a NUL */
 990
 991   if (is_str)
 992     extra += 2;  /* space for two quote marks */
 993
 994   buf = (char *) alloca (mlen + elen + extra);
 995   if (is_str)
 996     sprintf (buf, "%s=\"%s\"", macro, expansion);
 997   else
 998     sprintf (buf, "%s=%s", macro, expansion);
 999
1000   cpp_define (parse_in, buf);
1001 }
1002
1003
1004 /* Pass an object-like macro and an integer value to define it to.  */
1005 static void
1006 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1007 {
1008   char *buf;
1009   size_t mlen = strlen (macro);
1010   size_t vlen = 18;
1011   size_t extra = 2; /* space for = and NUL.  */
1012
1013   buf = (char *) alloca (mlen + vlen + extra);
1014   memcpy (buf, macro, mlen);
1015   buf[mlen] = '=';
1016   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1017
1018   cpp_define (parse_in, buf);
1019 }
1020
1021 /* builtin_define_with_hex_fp_value is very expensive, so the following
1022    array and function allows it to be done lazily when __DBL_MAX__
1023    etc. is first used.  */
1024
1025 struct GTY(()) lazy_hex_fp_value_struct
1026 {
1027   const char *hex_str;
1028   cpp_macro *macro;
1029   enum machine_mode mode;
1030   int digits;
1031   const char *fp_suffix;
1032 };
1033 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
1034 static GTY(()) int lazy_hex_fp_value_count;
1035
1036 static bool
1037 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1038                    cpp_hashnode *node)
1039 {
1040   REAL_VALUE_TYPE real;
1041   char dec_str[64], buf1[256];
1042   unsigned int idx;
1043   if (node->value.builtin < BT_FIRST_USER
1044       || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1045     return false;
1046
1047   idx = node->value.builtin - BT_FIRST_USER;
1048   real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1049   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1050                             lazy_hex_fp_values[idx].digits, 0,
1051                             lazy_hex_fp_values[idx].mode);
1052
1053   sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1054   node->flags &= ~(NODE_BUILTIN | NODE_USED);
1055   node->value.macro = lazy_hex_fp_values[idx].macro;
1056   for (idx = 0; idx < node->value.macro->count; idx++)
1057     if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1058       break;
1059   gcc_assert (idx < node->value.macro->count);
1060   node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1061   node->value.macro->exp.tokens[idx].val.str.text
1062     = (const unsigned char *) ggc_strdup (buf1);
1063   return true;
1064 }
1065
1066 /* Pass an object-like macro a hexadecimal floating-point value.  */
1067 static void
1068 builtin_define_with_hex_fp_value (const char *macro,
1069                                   tree type, int digits,
1070                                   const char *hex_str,
1071                                   const char *fp_suffix,
1072                                   const char *fp_cast)
1073 {
1074   REAL_VALUE_TYPE real;
1075   char dec_str[64], buf1[256], buf2[256];
1076
1077   /* This is very expensive, so if possible expand them lazily.  */
1078   if (lazy_hex_fp_value_count < 12
1079       && flag_dump_macros == 0
1080       && !cpp_get_options (parse_in)->traditional)
1081     {
1082       struct cpp_hashnode *node;
1083       if (lazy_hex_fp_value_count == 0)
1084         cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1085       sprintf (buf2, fp_cast, "1.1");
1086       sprintf (buf1, "%s=%s", macro, buf2);
1087       cpp_define (parse_in, buf1);
1088       node = C_CPP_HASHNODE (get_identifier (macro));
1089       lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1090         = ggc_strdup (hex_str);
1091       lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1092       lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1093       lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1094       lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1095       node->flags |= NODE_BUILTIN;
1096       node->value.builtin
1097         = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1098       lazy_hex_fp_value_count++;
1099       return;
1100     }
1101
1102   /* Hex values are really cool and convenient, except that they're
1103      not supported in strict ISO C90 mode.  First, the "p-" sequence
1104      is not valid as part of a preprocessor number.  Second, we get a
1105      pedwarn from the preprocessor, which has no context, so we can't
1106      suppress the warning with __extension__.
1107
1108      So instead what we do is construct the number in hex (because
1109      it's easy to get the exact correct value), parse it as a real,
1110      then print it back out as decimal.  */
1111
1112   real_from_string (&real, hex_str);
1113   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1114                             TYPE_MODE (type));
1115
1116   /* Assemble the macro in the following fashion
1117      macro = fp_cast [dec_str fp_suffix] */
1118   sprintf (buf1, "%s%s", dec_str, fp_suffix);
1119   sprintf (buf2, fp_cast, buf1);
1120   sprintf (buf1, "%s=%s", macro, buf2);
1121
1122   cpp_define (parse_in, buf1);
1123 }
1124
1125 /* Return a string constant for the suffix for a value of type TYPE
1126    promoted according to the integer promotions.  The type must be one
1127    of the standard integer type nodes.  */
1128
1129 static const char *
1130 type_suffix (tree type)
1131 {
1132   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1133   int unsigned_suffix;
1134   int is_long;
1135
1136   if (type == long_long_integer_type_node
1137       || type == long_long_unsigned_type_node)
1138     is_long = 2;
1139   else if (type == long_integer_type_node
1140            || type == long_unsigned_type_node)
1141     is_long = 1;
1142   else if (type == integer_type_node
1143            || type == unsigned_type_node
1144            || type == short_integer_type_node
1145            || type == short_unsigned_type_node
1146            || type == signed_char_type_node
1147            || type == unsigned_char_type_node
1148            /* ??? "char" is not a signed or unsigned integer type and
1149               so is not permitted for the standard typedefs, but some
1150               systems use it anyway.  */
1151            || type == char_type_node)
1152     is_long = 0;
1153   else
1154     gcc_unreachable ();
1155
1156   unsigned_suffix = TYPE_UNSIGNED (type);
1157   if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1158     unsigned_suffix = 0;
1159   return suffixes[is_long * 2 + unsigned_suffix];
1160 }
1161
1162 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE.  */
1163 static void
1164 builtin_define_constants (const char *macro, tree type)
1165 {
1166   const char *suffix;
1167   char *buf;
1168
1169   suffix = type_suffix (type);
1170
1171   if (suffix[0] == 0)
1172     {
1173       buf = (char *) alloca (strlen (macro) + 6);
1174       sprintf (buf, "%s(c)=c", macro);
1175     }
1176   else
1177     {
1178       buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1179       sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1180     }
1181
1182   cpp_define (parse_in, buf);
1183 }
1184
1185 /* Define MAX for TYPE based on the precision of the type.  */
1186
1187 static void
1188 builtin_define_type_max (const char *macro, tree type)
1189 {
1190   builtin_define_type_minmax (NULL, macro, type);
1191 }
1192
1193 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1194    precision of the type.  */
1195
1196 static void
1197 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1198                             tree type)
1199 {
1200   static const char *const values[]
1201     = { "127", "255",
1202         "32767", "65535",
1203         "2147483647", "4294967295",
1204         "9223372036854775807", "18446744073709551615",
1205         "170141183460469231731687303715884105727",
1206         "340282366920938463463374607431768211455" };
1207
1208   const char *value, *suffix;
1209   char *buf;
1210   size_t idx;
1211
1212   /* Pre-rendering the values mean we don't have to futz with printing a
1213      multi-word decimal value.  There are also a very limited number of
1214      precisions that we support, so it's really a waste of time.  */
1215   switch (TYPE_PRECISION (type))
1216     {
1217     case 8:     idx = 0; break;
1218     case 16:    idx = 2; break;
1219     case 32:    idx = 4; break;
1220     case 64:    idx = 6; break;
1221     case 128:   idx = 8; break;
1222     default:    gcc_unreachable ();
1223     }
1224
1225   value = values[idx + TYPE_UNSIGNED (type)];
1226   suffix = type_suffix (type);
1227
1228   buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1229                          + strlen (suffix) + 1);
1230   sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1231
1232   cpp_define (parse_in, buf);
1233
1234   if (min_macro)
1235     {
1236       if (TYPE_UNSIGNED (type))
1237         {
1238           buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1239           sprintf (buf, "%s=0%s", min_macro, suffix);
1240         }
1241       else
1242         {
1243           buf = (char *) alloca (strlen (min_macro) + 3
1244                                  + strlen (max_macro) + 6);
1245           sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1246         }
1247       cpp_define (parse_in, buf);
1248     }
1249 }
1250
1251 #include "gt-c-family-c-cppbuiltin.h"