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 when single precision constants are
 623      specified. The correct result is computed by the compiler when using
 624      macros that include a cast. This has the side-effect of making the value
 625      unusable in const expressions. */
 626   if (flag_single_precision_constant)
 627     builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
 628   else
 629     builtin_define_float_constants ("DBL", "", "%s", double_type_node);
 630   builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
 631
 632   /* For decfloat.h.  */
 633   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
 634   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
 635   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
 636
 637   /* For fixed-point fibt, ibit, max, min, and epsilon.  */
 638   if (targetm.fixed_point_supported_p ())
 639     {
 640       builtin_define_fixed_point_constants ("SFRACT", "HR",
 641                                             short_fract_type_node);
 642       builtin_define_fixed_point_constants ("USFRACT", "UHR",
 643                                             unsigned_short_fract_type_node);
 644       builtin_define_fixed_point_constants ("FRACT", "R",
 645                                             fract_type_node);
 646       builtin_define_fixed_point_constants ("UFRACT", "UR",
 647                                             unsigned_fract_type_node);
 648       builtin_define_fixed_point_constants ("LFRACT", "LR",
 649                                             long_fract_type_node);
 650       builtin_define_fixed_point_constants ("ULFRACT", "ULR",
 651                                             unsigned_long_fract_type_node);
 652       builtin_define_fixed_point_constants ("LLFRACT", "LLR",
 653                                             long_long_fract_type_node);
 654       builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
 655                                             unsigned_long_long_fract_type_node);
 656       builtin_define_fixed_point_constants ("SACCUM", "HK",
 657                                             short_accum_type_node);
 658       builtin_define_fixed_point_constants ("USACCUM", "UHK",
 659                                             unsigned_short_accum_type_node);
 660       builtin_define_fixed_point_constants ("ACCUM", "K",
 661                                             accum_type_node);
 662       builtin_define_fixed_point_constants ("UACCUM", "UK",
 663                                             unsigned_accum_type_node);
 664       builtin_define_fixed_point_constants ("LACCUM", "LK",
 665                                             long_accum_type_node);
 666       builtin_define_fixed_point_constants ("ULACCUM", "ULK",
 667                                             unsigned_long_accum_type_node);
 668       builtin_define_fixed_point_constants ("LLACCUM", "LLK",
 669                                             long_long_accum_type_node);
 670       builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
 671                                             unsigned_long_long_accum_type_node);
 672
 673       builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
 674       builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
 675       builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
 676       builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
 677       builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
 678       builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
 679       builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
 680       builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
 681       builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
 682       builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
 683       builtin_define_fixed_point_constants ("HA", "", ha_type_node);
 684       builtin_define_fixed_point_constants ("SA", "", sa_type_node);
 685       builtin_define_fixed_point_constants ("DA", "", da_type_node);
 686       builtin_define_fixed_point_constants ("TA", "", ta_type_node);
 687       builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
 688       builtin_define_fixed_point_constants ("USA", "", usa_type_node);
 689       builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
 690       builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
 691     }
 692
 693   /* For use in assembly language.  */
 694   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
 695   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
 696
 697   /* Misc.  */
 698   builtin_define_with_value ("__VERSION__", version_string, 1);
 699
 700   if (flag_gnu89_inline)
 701     cpp_define (pfile, "__GNUC_GNU_INLINE__");
 702   else
 703     cpp_define (pfile, "__GNUC_STDC_INLINE__");
 704
 705   /* Definitions for LP64 model.  */
 706   if (TYPE_PRECISION (long_integer_type_node) == 64
 707       && POINTER_SIZE == 64
 708       && TYPE_PRECISION (integer_type_node) == 32)
 709     {
 710       cpp_define (pfile, "_LP64");
 711       cpp_define (pfile, "__LP64__");
 712     }
 713
 714   /* Other target-independent built-ins determined by command-line
 715      options.  */
 716   if (optimize_size)
 717     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 718   if (optimize)
 719     cpp_define (pfile, "__OPTIMIZE__");
 720
 721   if (fast_math_flags_set_p ())
 722     cpp_define (pfile, "__FAST_MATH__");
 723   if (flag_no_inline)
 724     cpp_define (pfile, "__NO_INLINE__");
 725   if (flag_signaling_nans)
 726     cpp_define (pfile, "__SUPPORT_SNAN__");
 727   if (flag_finite_math_only)
 728     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 729   else
 730     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 731   if (flag_pic)
 732     {
 733       builtin_define_with_int_value ("__pic__", flag_pic);
 734       builtin_define_with_int_value ("__PIC__", flag_pic);
 735     }
 736   if (flag_pie)
 737     {
 738       builtin_define_with_int_value ("__pie__", flag_pie);
 739       builtin_define_with_int_value ("__PIE__", flag_pie);
 740     }
 741
 742   if (flag_iso)
 743     cpp_define (pfile, "__STRICT_ANSI__");
 744
 745   if (!flag_signed_char)
 746     cpp_define (pfile, "__CHAR_UNSIGNED__");
 747
 748   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
 749     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 750
 751   /* Tell source code if the compiler makes sync_compare_and_swap
 752      builtins available.  */
 753 #ifdef HAVE_sync_compare_and_swapqi
 754   if (HAVE_sync_compare_and_swapqi)
 755     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 756 #endif
 757
 758 #ifdef HAVE_sync_compare_and_swaphi
 759   if (HAVE_sync_compare_and_swaphi)
 760     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 761 #endif
 762
 763 #ifdef HAVE_sync_compare_and_swapsi
 764   if (HAVE_sync_compare_and_swapsi)
 765     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 766 #endif
 767
 768 #ifdef HAVE_sync_compare_and_swapdi
 769   if (HAVE_sync_compare_and_swapdi)
 770     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 771 #endif
 772
 773 #ifdef HAVE_sync_compare_and_swapti
 774   if (HAVE_sync_compare_and_swapti)
 775     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
 776 #endif
 777
 778 #ifdef DWARF2_UNWIND_INFO
 779   if (dwarf2out_do_cfi_asm ())
 780     cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
 781 #endif
 782
 783   /* Make the choice of ObjC runtime visible to source code.  */
 784   if (c_dialect_objc () && flag_next_runtime)
 785     cpp_define (pfile, "__NEXT_RUNTIME__");
 786
 787   /* Show the availability of some target pragmas.  */
 788   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
 789     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 790
 791   if (targetm.handle_pragma_extern_prefix)
 792     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 793
 794   /* Make the choice of the stack protector runtime visible to source code.
 795      The macro names and values here were chosen for compatibility with an
 796      earlier implementation, i.e. ProPolice.  */
 797   if (flag_stack_protect == 2)
 798     cpp_define (pfile, "__SSP_ALL__=2");
 799   else if (flag_stack_protect == 1)
 800     cpp_define (pfile, "__SSP__=1");
 801
 802   if (flag_openmp)
 803     cpp_define (pfile, "_OPENMP=200805");
 804
 805   builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
 806   builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
 807   builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
 808                               long_long_integer_type_node);
 809   builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
 810   builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
 811   builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
 812   builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
 813   builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
 814   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
 815   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
 816   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
 817                               unsigned_ptrdiff_type_node);
 818   /* ptr_type_node can't be used here since ptr_mode is only set when
 819      toplev calls backend_init which is not done with -E switch.  */
 820   builtin_define_with_int_value ("__SIZEOF_POINTER__",
 821                                  POINTER_SIZE / BITS_PER_UNIT);
 822
 823   /* A straightforward target hook doesn't work, because of problems
 824      linking that hook's body when part of non-C front ends.  */
 825 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 826 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 827 # define builtin_define(TXT) cpp_define (pfile, TXT)
 828 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 829   TARGET_CPU_CPP_BUILTINS ();
 830   TARGET_OS_CPP_BUILTINS ();
 831   TARGET_OBJFMT_CPP_BUILTINS ();
 832
 833   /* Support the __declspec keyword by turning them into attributes.
 834      Note that the current way we do this may result in a collision
 835      with predefined attributes later on.  This can be solved by using
 836      one attribute, say __declspec__, and passing args to it.  The
 837      problem with that approach is that args are not accumulated: each
 838      new appearance would clobber any existing args.  */
 839   if (TARGET_DECLSPEC)
 840     builtin_define ("__declspec(x)=__attribute__((x))");
 841
 842   /* If decimal floating point is supported, tell the user if the
 843      alternate format (BID) is used instead of the standard (DPD)
 844      format.  */
 845   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
 846     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
 847
 848   builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__",
 849                                  BIGGEST_ALIGNMENT / BITS_PER_UNIT);
 850 }
 851
 852 /* Pass an object-like macro.  If it doesn't lie in the user's
 853    namespace, defines it unconditionally.  Otherwise define a version
 854    with two leading underscores, and another version with two leading
 855    and trailing underscores, and define the original only if an ISO
 856    standard was not nominated.
 857
 858    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 859    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 860    "_mips".  */
 861 void
 862 builtin_define_std (const char *macro)
 863 {
 864   size_t len = strlen (macro);
 865   char *buff = (char *) alloca (len + 5);
 866   char *p = buff + 2;
 867   char *q = p + len;
 868
 869   /* prepend __ (or maybe just _) if in user's namespace.  */
 870   memcpy (p, macro, len + 1);
 871   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 872     {
 873       if (*p != '_')
 874         *--p = '_';
 875       if (p[1] != '_')
 876         *--p = '_';
 877     }
 878   cpp_define (parse_in, p);
 879
 880   /* If it was in user's namespace...  */
 881   if (p != buff + 2)
 882     {
 883       /* Define the macro with leading and following __.  */
 884       if (q[-1] != '_')
 885         *q++ = '_';
 886       if (q[-2] != '_')
 887         *q++ = '_';
 888       *q = '\0';
 889       cpp_define (parse_in, p);
 890
 891       /* Finally, define the original macro if permitted.  */
 892       if (!flag_iso)
 893         cpp_define (parse_in, macro);
 894     }
 895 }
 896
 897 /* Pass an object-like macro and a value to define it to.  The third
 898    parameter says whether or not to turn the value into a string
 899    constant.  */
 900 void
 901 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 902 {
 903   char *buf;
 904   size_t mlen = strlen (macro);
 905   size_t elen = strlen (expansion);
 906   size_t extra = 2;  /* space for an = and a NUL */
 907
 908   if (is_str)
 909     extra += 2;  /* space for two quote marks */
 910
 911   buf = (char *) alloca (mlen + elen + extra);
 912   if (is_str)
 913     sprintf (buf, "%s=\"%s\"", macro, expansion);
 914   else
 915     sprintf (buf, "%s=%s", macro, expansion);
 916
 917   cpp_define (parse_in, buf);
 918 }
 919
 920
 921 /* Pass an object-like macro and an integer value to define it to.  */
 922 static void
 923 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 924 {
 925   char *buf;
 926   size_t mlen = strlen (macro);
 927   size_t vlen = 18;
 928   size_t extra = 2; /* space for = and NUL.  */
 929
 930   buf = (char *) alloca (mlen + vlen + extra);
 931   memcpy (buf, macro, mlen);
 932   buf[mlen] = '=';
 933   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 934
 935   cpp_define (parse_in, buf);
 936 }
 937
 938 /* Pass an object-like macro a hexadecimal floating-point value.  */
 939 static void
 940 builtin_define_with_hex_fp_value (const char *macro,
 941                                   tree type, int digits,
 942                                   const char *hex_str,
 943                                   const char *fp_suffix,
 944                                   const char *fp_cast)
 945 {
 946   REAL_VALUE_TYPE real;
 947   char dec_str[64], buf1[256], buf2[256];
 948
 949   /* Hex values are really cool and convenient, except that they're
 950      not supported in strict ISO C90 mode.  First, the "p-" sequence
 951      is not valid as part of a preprocessor number.  Second, we get a
 952      pedwarn from the preprocessor, which has no context, so we can't
 953      suppress the warning with __extension__.
 954
 955      So instead what we do is construct the number in hex (because
 956      it's easy to get the exact correct value), parse it as a real,
 957      then print it back out as decimal.  */
 958
 959   real_from_string (&real, hex_str);
 960   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
 961                             TYPE_MODE (type));
 962
 963   /* Assemble the macro in the following fashion
 964      macro = fp_cast [dec_str fp_suffix] */
 965   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 966   sprintf (buf2, fp_cast, buf1);
 967   sprintf (buf1, "%s=%s", macro, buf2);
 968
 969   cpp_define (parse_in, buf1);
 970 }
 971
 972 /* Return a string constant for the suffix for a value of type TYPE
 973    promoted according to the integer promotions.  The type must be one
 974    of the standard integer type nodes.  */
 975
 976 static const char *
 977 type_suffix (tree type)
 978 {
 979   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 980   int unsigned_suffix;
 981   int is_long;
 982
 983   if (type == long_long_integer_type_node
 984       || type == long_long_unsigned_type_node)
 985     is_long = 2;
 986   else if (type == long_integer_type_node
 987            || type == long_unsigned_type_node)
 988     is_long = 1;
 989   else if (type == integer_type_node
 990            || type == unsigned_type_node
 991            || type == short_integer_type_node
 992            || type == short_unsigned_type_node
 993            || type == signed_char_type_node
 994            || type == unsigned_char_type_node
 995            /* ??? "char" is not a signed or unsigned integer type and
 996               so is not permitted for the standard typedefs, but some
 997               systems use it anyway.  */
 998            || type == char_type_node)
 999     is_long = 0;
1000   else
1001     gcc_unreachable ();
1002
1003   unsigned_suffix = TYPE_UNSIGNED (type);
1004   if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1005     unsigned_suffix = 0;
1006   return suffixes[is_long * 2 + unsigned_suffix];
1007 }
1008
1009 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE.  */
1010 static void
1011 builtin_define_constants (const char *macro, tree type)
1012 {
1013   const char *suffix;
1014   char *buf;
1015
1016   suffix = type_suffix (type);
1017
1018   if (suffix[0] == 0)
1019     {
1020       buf = (char *) alloca (strlen (macro) + 6);
1021       sprintf (buf, "%s(c)=c", macro);
1022     }
1023   else
1024     {
1025       buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1026       sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1027     }
1028
1029   cpp_define (parse_in, buf);
1030 }
1031
1032 /* Define MAX for TYPE based on the precision of the type.  */
1033
1034 static void
1035 builtin_define_type_max (const char *macro, tree type)
1036 {
1037   builtin_define_type_minmax (NULL, macro, type);
1038 }
1039
1040 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1041    precision of the type.  */
1042
1043 static void
1044 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1045                             tree type)
1046 {
1047   static const char *const values[]
1048     = { "127", "255",
1049         "32767", "65535",
1050         "2147483647", "4294967295",
1051         "9223372036854775807", "18446744073709551615",
1052         "170141183460469231731687303715884105727",
1053         "340282366920938463463374607431768211455" };
1054
1055   const char *value, *suffix;
1056   char *buf;
1057   size_t idx;
1058
1059   /* Pre-rendering the values mean we don't have to futz with printing a
1060      multi-word decimal value.  There are also a very limited number of
1061      precisions that we support, so it's really a waste of time.  */
1062   switch (TYPE_PRECISION (type))
1063     {
1064     case 8:     idx = 0; break;
1065     case 16:    idx = 2; break;
1066     case 32:    idx = 4; break;
1067     case 64:    idx = 6; break;
1068     case 128:   idx = 8; break;
1069     default:    gcc_unreachable ();
1070     }
1071
1072   value = values[idx + TYPE_UNSIGNED (type)];
1073   suffix = type_suffix (type);
1074
1075   buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1076                          + strlen (suffix) + 1);
1077   sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1078
1079   cpp_define (parse_in, buf);
1080
1081   if (min_macro)
1082     {
1083       if (TYPE_UNSIGNED (type))
1084         {
1085           buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1086           sprintf (buf, "%s=0%s", min_macro, suffix);
1087         }
1088       else
1089         {
1090           buf = (char *) alloca (strlen (min_macro) + 3
1091                                  + strlen (max_macro) + 6);
1092           sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1093         }
1094       cpp_define (parse_in, buf);
1095     }
1096 }