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   cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 786
 787   if (targetm.handle_pragma_extern_prefix)
 788     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 789
 790   /* Make the choice of the stack protector runtime visible to source code.
 791      The macro names and values here were chosen for compatibility with an
 792      earlier implementation, i.e. ProPolice.  */
 793   if (flag_stack_protect == 2)
 794     cpp_define (pfile, "__SSP_ALL__=2");
 795   else if (flag_stack_protect == 1)
 796     cpp_define (pfile, "__SSP__=1");
 797
 798   if (flag_openmp)
 799     cpp_define (pfile, "_OPENMP=200805");
 800
 801   builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
 802   builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
 803   builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
 804                               long_long_integer_type_node);
 805   builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
 806   builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
 807   builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
 808   builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
 809   builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
 810   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
 811   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
 812   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
 813                               unsigned_ptrdiff_type_node);
 814   /* ptr_type_node can't be used here since ptr_mode is only set when
 815      toplev calls backend_init which is not done with -E switch.  */
 816   builtin_define_with_int_value ("__SIZEOF_POINTER__",
 817                                  POINTER_SIZE / BITS_PER_UNIT);
 818
 819   /* A straightforward target hook doesn't work, because of problems
 820      linking that hook's body when part of non-C front ends.  */
 821 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 822 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 823 # define builtin_define(TXT) cpp_define (pfile, TXT)
 824 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 825   TARGET_CPU_CPP_BUILTINS ();
 826   TARGET_OS_CPP_BUILTINS ();
 827   TARGET_OBJFMT_CPP_BUILTINS ();
 828
 829   /* Support the __declspec keyword by turning them into attributes.
 830      Note that the current way we do this may result in a collision
 831      with predefined attributes later on.  This can be solved by using
 832      one attribute, say __declspec__, and passing args to it.  The
 833      problem with that approach is that args are not accumulated: each
 834      new appearance would clobber any existing args.  */
 835   if (TARGET_DECLSPEC)
 836     builtin_define ("__declspec(x)=__attribute__((x))");
 837
 838   /* If decimal floating point is supported, tell the user if the
 839      alternate format (BID) is used instead of the standard (DPD)
 840      format.  */
 841   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
 842     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
 843
 844   builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__",
 845                                  BIGGEST_ALIGNMENT / BITS_PER_UNIT);
 846 }
 847
 848 /* Pass an object-like macro.  If it doesn't lie in the user's
 849    namespace, defines it unconditionally.  Otherwise define a version
 850    with two leading underscores, and another version with two leading
 851    and trailing underscores, and define the original only if an ISO
 852    standard was not nominated.
 853
 854    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 855    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 856    "_mips".  */
 857 void
 858 builtin_define_std (const char *macro)
 859 {
 860   size_t len = strlen (macro);
 861   char *buff = (char *) alloca (len + 5);
 862   char *p = buff + 2;
 863   char *q = p + len;
 864
 865   /* prepend __ (or maybe just _) if in user's namespace.  */
 866   memcpy (p, macro, len + 1);
 867   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 868     {
 869       if (*p != '_')
 870         *--p = '_';
 871       if (p[1] != '_')
 872         *--p = '_';
 873     }
 874   cpp_define (parse_in, p);
 875
 876   /* If it was in user's namespace...  */
 877   if (p != buff + 2)
 878     {
 879       /* Define the macro with leading and following __.  */
 880       if (q[-1] != '_')
 881         *q++ = '_';
 882       if (q[-2] != '_')
 883         *q++ = '_';
 884       *q = '\0';
 885       cpp_define (parse_in, p);
 886
 887       /* Finally, define the original macro if permitted.  */
 888       if (!flag_iso)
 889         cpp_define (parse_in, macro);
 890     }
 891 }
 892
 893 /* Pass an object-like macro and a value to define it to.  The third
 894    parameter says whether or not to turn the value into a string
 895    constant.  */
 896 void
 897 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 898 {
 899   char *buf;
 900   size_t mlen = strlen (macro);
 901   size_t elen = strlen (expansion);
 902   size_t extra = 2;  /* space for an = and a NUL */
 903
 904   if (is_str)
 905     extra += 2;  /* space for two quote marks */
 906
 907   buf = (char *) alloca (mlen + elen + extra);
 908   if (is_str)
 909     sprintf (buf, "%s=\"%s\"", macro, expansion);
 910   else
 911     sprintf (buf, "%s=%s", macro, expansion);
 912
 913   cpp_define (parse_in, buf);
 914 }
 915
 916
 917 /* Pass an object-like macro and an integer value to define it to.  */
 918 static void
 919 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 920 {
 921   char *buf;
 922   size_t mlen = strlen (macro);
 923   size_t vlen = 18;
 924   size_t extra = 2; /* space for = and NUL.  */
 925
 926   buf = (char *) alloca (mlen + vlen + extra);
 927   memcpy (buf, macro, mlen);
 928   buf[mlen] = '=';
 929   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 930
 931   cpp_define (parse_in, buf);
 932 }
 933
 934 /* Pass an object-like macro a hexadecimal floating-point value.  */
 935 static void
 936 builtin_define_with_hex_fp_value (const char *macro,
 937                                   tree type, int digits,
 938                                   const char *hex_str,
 939                                   const char *fp_suffix,
 940                                   const char *fp_cast)
 941 {
 942   REAL_VALUE_TYPE real;
 943   char dec_str[64], buf1[256], buf2[256];
 944
 945   /* Hex values are really cool and convenient, except that they're
 946      not supported in strict ISO C90 mode.  First, the "p-" sequence
 947      is not valid as part of a preprocessor number.  Second, we get a
 948      pedwarn from the preprocessor, which has no context, so we can't
 949      suppress the warning with __extension__.
 950
 951      So instead what we do is construct the number in hex (because
 952      it's easy to get the exact correct value), parse it as a real,
 953      then print it back out as decimal.  */
 954
 955   real_from_string (&real, hex_str);
 956   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
 957                             TYPE_MODE (type));
 958
 959   /* Assemble the macro in the following fashion
 960      macro = fp_cast [dec_str fp_suffix] */
 961   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 962   sprintf (buf2, fp_cast, buf1);
 963   sprintf (buf1, "%s=%s", macro, buf2);
 964
 965   cpp_define (parse_in, buf1);
 966 }
 967
 968 /* Return a string constant for the suffix for a value of type TYPE
 969    promoted according to the integer promotions.  The type must be one
 970    of the standard integer type nodes.  */
 971
 972 static const char *
 973 type_suffix (tree type)
 974 {
 975   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 976   int unsigned_suffix;
 977   int is_long;
 978
 979   if (type == long_long_integer_type_node
 980       || type == long_long_unsigned_type_node)
 981     is_long = 2;
 982   else if (type == long_integer_type_node
 983            || type == long_unsigned_type_node)
 984     is_long = 1;
 985   else if (type == integer_type_node
 986            || type == unsigned_type_node
 987            || type == short_integer_type_node
 988            || type == short_unsigned_type_node
 989            || type == signed_char_type_node
 990            || type == unsigned_char_type_node
 991            /* ??? "char" is not a signed or unsigned integer type and
 992               so is not permitted for the standard typedefs, but some
 993               systems use it anyway.  */
 994            || type == char_type_node)
 995     is_long = 0;
 996   else
 997     gcc_unreachable ();
 998
 999   unsigned_suffix = TYPE_UNSIGNED (type);
1000   if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1001     unsigned_suffix = 0;
1002   return suffixes[is_long * 2 + unsigned_suffix];
1003 }
1004
1005 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE.  */
1006 static void
1007 builtin_define_constants (const char *macro, tree type)
1008 {
1009   const char *suffix;
1010   char *buf;
1011
1012   suffix = type_suffix (type);
1013
1014   if (suffix[0] == 0)
1015     {
1016       buf = (char *) alloca (strlen (macro) + 6);
1017       sprintf (buf, "%s(c)=c", macro);
1018     }
1019   else
1020     {
1021       buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1022       sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1023     }
1024
1025   cpp_define (parse_in, buf);
1026 }
1027
1028 /* Define MAX for TYPE based on the precision of the type.  */
1029
1030 static void
1031 builtin_define_type_max (const char *macro, tree type)
1032 {
1033   builtin_define_type_minmax (NULL, macro, type);
1034 }
1035
1036 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1037    precision of the type.  */
1038
1039 static void
1040 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1041                             tree type)
1042 {
1043   static const char *const values[]
1044     = { "127", "255",
1045         "32767", "65535",
1046         "2147483647", "4294967295",
1047         "9223372036854775807", "18446744073709551615",
1048         "170141183460469231731687303715884105727",
1049         "340282366920938463463374607431768211455" };
1050
1051   const char *value, *suffix;
1052   char *buf;
1053   size_t idx;
1054
1055   /* Pre-rendering the values mean we don't have to futz with printing a
1056      multi-word decimal value.  There are also a very limited number of
1057      precisions that we support, so it's really a waste of time.  */
1058   switch (TYPE_PRECISION (type))
1059     {
1060     case 8:     idx = 0; break;
1061     case 16:    idx = 2; break;
1062     case 32:    idx = 4; break;
1063     case 64:    idx = 6; break;
1064     case 128:   idx = 8; break;
1065     default:    gcc_unreachable ();
1066     }
1067
1068   value = values[idx + TYPE_UNSIGNED (type)];
1069   suffix = type_suffix (type);
1070
1071   buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1072                          + strlen (suffix) + 1);
1073   sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1074
1075   cpp_define (parse_in, buf);
1076
1077   if (min_macro)
1078     {
1079       if (TYPE_UNSIGNED (type))
1080         {
1081           buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1082           sprintf (buf, "%s=0%s", min_macro, suffix);
1083         }
1084       else
1085         {
1086           buf = (char *) alloca (strlen (min_macro) + 3
1087                                  + strlen (max_macro) + 6);
1088           sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1089         }
1090       cpp_define (parse_in, buf);
1091     }
1092 }