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