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