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