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