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 #ifdef HAVE_sync_compare_and_swapqi
 762   if (HAVE_sync_compare_and_swapqi)
 763     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 764 #endif
 765
 766 #ifdef HAVE_sync_compare_and_swaphi
 767   if (HAVE_sync_compare_and_swaphi)
 768     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 769 #endif
 770
 771 #ifdef HAVE_sync_compare_and_swapsi
 772   if (HAVE_sync_compare_and_swapsi)
 773     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 774 #endif
 775
 776 #ifdef HAVE_sync_compare_and_swapdi
 777   if (HAVE_sync_compare_and_swapdi)
 778     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 779 #endif
 780
 781 #ifdef HAVE_sync_compare_and_swapti
 782   if (HAVE_sync_compare_and_swapti)
 783     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
 784 #endif
 785
 786 #ifdef DWARF2_UNWIND_INFO
 787   if (dwarf2out_do_cfi_asm ())
 788     cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
 789 #endif
 790
 791   /* Make the choice of ObjC runtime visible to source code.  */
 792   if (c_dialect_objc () && flag_next_runtime)
 793     cpp_define (pfile, "__NEXT_RUNTIME__");
 794
 795   /* Show the availability of some target pragmas.  */
 796   cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 797
 798   if (targetm.handle_pragma_extern_prefix)
 799     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 800
 801   /* Make the choice of the stack protector runtime visible to source code.
 802      The macro names and values here were chosen for compatibility with an
 803      earlier implementation, i.e. ProPolice.  */
 804   if (flag_stack_protect == 2)
 805     cpp_define (pfile, "__SSP_ALL__=2");
 806   else if (flag_stack_protect == 1)
 807     cpp_define (pfile, "__SSP__=1");
 808
 809   if (flag_openmp)
 810     cpp_define (pfile, "_OPENMP=201107");
 811
 812   if (int128_integer_type_node != NULL_TREE)
 813     builtin_define_type_sizeof ("__SIZEOF_INT128__",
 814                                 int128_integer_type_node);
 815   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
 816   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
 817   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
 818                               unsigned_ptrdiff_type_node);
 819
 820   /* A straightforward target hook doesn't work, because of problems
 821      linking that hook's body when part of non-C front ends.  */
 822 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 823 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 824 # define builtin_define(TXT) cpp_define (pfile, TXT)
 825 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 826   TARGET_CPU_CPP_BUILTINS ();
 827   TARGET_OS_CPP_BUILTINS ();
 828   TARGET_OBJFMT_CPP_BUILTINS ();
 829
 830   /* Support the __declspec keyword by turning them into attributes.
 831      Note that the current way we do this may result in a collision
 832      with predefined attributes later on.  This can be solved by using
 833      one attribute, say __declspec__, and passing args to it.  The
 834      problem with that approach is that args are not accumulated: each
 835      new appearance would clobber any existing args.  */
 836   if (TARGET_DECLSPEC)
 837     builtin_define ("__declspec(x)=__attribute__((x))");
 838
 839   /* If decimal floating point is supported, tell the user if the
 840      alternate format (BID) is used instead of the standard (DPD)
 841      format.  */
 842   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
 843     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
 844 }
 845
 846 /* Pass an object-like macro.  If it doesn't lie in the user's
 847    namespace, defines it unconditionally.  Otherwise define a version
 848    with two leading underscores, and another version with two leading
 849    and trailing underscores, and define the original only if an ISO
 850    standard was not nominated.
 851
 852    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 853    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 854    "_mips".  */
 855 void
 856 builtin_define_std (const char *macro)
 857 {
 858   size_t len = strlen (macro);
 859   char *buff = (char *) alloca (len + 5);
 860   char *p = buff + 2;
 861   char *q = p + len;
 862
 863   /* prepend __ (or maybe just _) if in user's namespace.  */
 864   memcpy (p, macro, len + 1);
 865   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 866     {
 867       if (*p != '_')
 868         *--p = '_';
 869       if (p[1] != '_')
 870         *--p = '_';
 871     }
 872   cpp_define (parse_in, p);
 873
 874   /* If it was in user's namespace...  */
 875   if (p != buff + 2)
 876     {
 877       /* Define the macro with leading and following __.  */
 878       if (q[-1] != '_')
 879         *q++ = '_';
 880       if (q[-2] != '_')
 881         *q++ = '_';
 882       *q = '\0';
 883       cpp_define (parse_in, p);
 884
 885       /* Finally, define the original macro if permitted.  */
 886       if (!flag_iso)
 887         cpp_define (parse_in, macro);
 888     }
 889 }
 890
 891 /* Pass an object-like macro and a value to define it to.  The third
 892    parameter says whether or not to turn the value into a string
 893    constant.  */
 894 void
 895 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 896 {
 897   char *buf;
 898   size_t mlen = strlen (macro);
 899   size_t elen = strlen (expansion);
 900   size_t extra = 2;  /* space for an = and a NUL */
 901
 902   if (is_str)
 903     extra += 2;  /* space for two quote marks */
 904
 905   buf = (char *) alloca (mlen + elen + extra);
 906   if (is_str)
 907     sprintf (buf, "%s=\"%s\"", macro, expansion);
 908   else
 909     sprintf (buf, "%s=%s", macro, expansion);
 910
 911   cpp_define (parse_in, buf);
 912 }
 913
 914
 915 /* Pass an object-like macro and an integer value to define it to.  */
 916 static void
 917 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 918 {
 919   char *buf;
 920   size_t mlen = strlen (macro);
 921   size_t vlen = 18;
 922   size_t extra = 2; /* space for = and NUL.  */
 923
 924   buf = (char *) alloca (mlen + vlen + extra);
 925   memcpy (buf, macro, mlen);
 926   buf[mlen] = '=';
 927   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 928
 929   cpp_define (parse_in, buf);
 930 }
 931
 932 /* builtin_define_with_hex_fp_value is very expensive, so the following
 933    array and function allows it to be done lazily when __DBL_MAX__
 934    etc. is first used.  */
 935
 936 struct GTY(()) lazy_hex_fp_value_struct
 937 {
 938   const char *hex_str;
 939   cpp_macro *macro;
 940   enum machine_mode mode;
 941   int digits;
 942   const char *fp_suffix;
 943 };
 944 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
 945 static GTY(()) int lazy_hex_fp_value_count;
 946
 947 static bool
 948 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
 949                    cpp_hashnode *node)
 950 {
 951   REAL_VALUE_TYPE real;
 952   char dec_str[64], buf1[256];
 953   unsigned int idx;
 954   if (node->value.builtin < BT_FIRST_USER
 955       || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
 956     return false;
 957
 958   idx = node->value.builtin - BT_FIRST_USER;
 959   real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
 960   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
 961                             lazy_hex_fp_values[idx].digits, 0,
 962                             lazy_hex_fp_values[idx].mode);
 963
 964   sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
 965   node->flags &= ~(NODE_BUILTIN | NODE_USED);
 966   node->value.macro = lazy_hex_fp_values[idx].macro;
 967   for (idx = 0; idx < node->value.macro->count; idx++)
 968     if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
 969       break;
 970   gcc_assert (idx < node->value.macro->count);
 971   node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
 972   node->value.macro->exp.tokens[idx].val.str.text
 973     = (const unsigned char *) ggc_strdup (buf1);
 974   return true;
 975 }
 976
 977 /* Pass an object-like macro a hexadecimal floating-point value.  */
 978 static void
 979 builtin_define_with_hex_fp_value (const char *macro,
 980                                   tree type, int digits,
 981                                   const char *hex_str,
 982                                   const char *fp_suffix,
 983                                   const char *fp_cast)
 984 {
 985   REAL_VALUE_TYPE real;
 986   char dec_str[64], buf1[256], buf2[256];
 987
 988   /* This is very expensive, so if possible expand them lazily.  */
 989   if (lazy_hex_fp_value_count < 12
 990       && flag_dump_macros == 0
 991       && !cpp_get_options (parse_in)->traditional)
 992     {
 993       struct cpp_hashnode *node;
 994       if (lazy_hex_fp_value_count == 0)
 995         cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
 996       sprintf (buf2, fp_cast, "1.1");
 997       sprintf (buf1, "%s=%s", macro, buf2);
 998       cpp_define (parse_in, buf1);
 999       node = C_CPP_HASHNODE (get_identifier (macro));
1000       lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1001         = ggc_strdup (hex_str);
1002       lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1003       lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1004       lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1005       lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1006       node->flags |= NODE_BUILTIN;
1007       node->value.builtin
1008         = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1009       lazy_hex_fp_value_count++;
1010       return;
1011     }
1012
1013   /* Hex values are really cool and convenient, except that they're
1014      not supported in strict ISO C90 mode.  First, the "p-" sequence
1015      is not valid as part of a preprocessor number.  Second, we get a
1016      pedwarn from the preprocessor, which has no context, so we can't
1017      suppress the warning with __extension__.
1018
1019      So instead what we do is construct the number in hex (because
1020      it's easy to get the exact correct value), parse it as a real,
1021      then print it back out as decimal.  */
1022
1023   real_from_string (&real, hex_str);
1024   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1025                             TYPE_MODE (type));
1026
1027   /* Assemble the macro in the following fashion
1028      macro = fp_cast [dec_str fp_suffix] */
1029   sprintf (buf1, "%s%s", dec_str, fp_suffix);
1030   sprintf (buf2, fp_cast, buf1);
1031   sprintf (buf1, "%s=%s", macro, buf2);
1032
1033   cpp_define (parse_in, buf1);
1034 }
1035
1036 /* Return a string constant for the suffix for a value of type TYPE
1037    promoted according to the integer promotions.  The type must be one
1038    of the standard integer type nodes.  */
1039
1040 static const char *
1041 type_suffix (tree type)
1042 {
1043   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1044   int unsigned_suffix;
1045   int is_long;
1046
1047   if (type == long_long_integer_type_node
1048       || type == long_long_unsigned_type_node)
1049     is_long = 2;
1050   else if (type == long_integer_type_node
1051            || type == long_unsigned_type_node)
1052     is_long = 1;
1053   else if (type == integer_type_node
1054            || type == unsigned_type_node
1055            || type == short_integer_type_node
1056            || type == short_unsigned_type_node
1057            || type == signed_char_type_node
1058            || type == unsigned_char_type_node
1059            /* ??? "char" is not a signed or unsigned integer type and
1060               so is not permitted for the standard typedefs, but some
1061               systems use it anyway.  */
1062            || type == char_type_node)
1063     is_long = 0;
1064   else
1065     gcc_unreachable ();
1066
1067   unsigned_suffix = TYPE_UNSIGNED (type);
1068   if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1069     unsigned_suffix = 0;
1070   return suffixes[is_long * 2 + unsigned_suffix];
1071 }
1072
1073 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE.  */
1074 static void
1075 builtin_define_constants (const char *macro, tree type)
1076 {
1077   const char *suffix;
1078   char *buf;
1079
1080   suffix = type_suffix (type);
1081
1082   if (suffix[0] == 0)
1083     {
1084       buf = (char *) alloca (strlen (macro) + 6);
1085       sprintf (buf, "%s(c)=c", macro);
1086     }
1087   else
1088     {
1089       buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1090       sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1091     }
1092
1093   cpp_define (parse_in, buf);
1094 }
1095
1096 /* Define MAX for TYPE based on the precision of the type.  */
1097
1098 static void
1099 builtin_define_type_max (const char *macro, tree type)
1100 {
1101   builtin_define_type_minmax (NULL, macro, type);
1102 }
1103
1104 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1105    precision of the type.  */
1106
1107 static void
1108 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1109                             tree type)
1110 {
1111   static const char *const values[]
1112     = { "127", "255",
1113         "32767", "65535",
1114         "2147483647", "4294967295",
1115         "9223372036854775807", "18446744073709551615",
1116         "170141183460469231731687303715884105727",
1117         "340282366920938463463374607431768211455" };
1118
1119   const char *value, *suffix;
1120   char *buf;
1121   size_t idx;
1122
1123   /* Pre-rendering the values mean we don't have to futz with printing a
1124      multi-word decimal value.  There are also a very limited number of
1125      precisions that we support, so it's really a waste of time.  */
1126   switch (TYPE_PRECISION (type))
1127     {
1128     case 8:     idx = 0; break;
1129     case 16:    idx = 2; break;
1130     case 32:    idx = 4; break;
1131     case 64:    idx = 6; break;
1132     case 128:   idx = 8; break;
1133     default:    gcc_unreachable ();
1134     }
1135
1136   value = values[idx + TYPE_UNSIGNED (type)];
1137   suffix = type_suffix (type);
1138
1139   buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1140                          + strlen (suffix) + 1);
1141   sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1142
1143   cpp_define (parse_in, buf);
1144
1145   if (min_macro)
1146     {
1147       if (TYPE_UNSIGNED (type))
1148         {
1149           buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1150           sprintf (buf, "%s=0%s", min_macro, suffix);
1151         }
1152       else
1153         {
1154           buf = (char *) alloca (strlen (min_macro) + 3
1155                                  + strlen (max_macro) + 6);
1156           sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1157         }
1158       cpp_define (parse_in, buf);
1159     }
1160 }
1161
1162 #include "gt-c-family-c-cppbuiltin.h"