gcc/c-family/c-cppbuiltin.c

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