gcc/c-cppbuiltin.c

   1 /* Define builtin-in macros for the C family front ends.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
   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 "toplev.h"
  34 #include "tm_p.h"               /* Target prototypes.  */
  35 #include "target.h"
  36
  37 #ifndef TARGET_OS_CPP_BUILTINS
  38 # define TARGET_OS_CPP_BUILTINS()
  39 #endif
  40
  41 #ifndef TARGET_OBJFMT_CPP_BUILTINS
  42 # define TARGET_OBJFMT_CPP_BUILTINS()
  43 #endif
  44
  45 #ifndef REGISTER_PREFIX
  46 #define REGISTER_PREFIX ""
  47 #endif
  48
  49 /* Non-static as some targets don't use it.  */
  50 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
  51 static void builtin_define_with_value_n (const char *, const char *,
  52                                          size_t);
  53 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
  54 static void builtin_define_with_hex_fp_value (const char *, tree,
  55                                               int, const char *,
  56                                               const char *,
  57                                               const char *);
  58 static void builtin_define_stdint_macros (void);
  59 static void builtin_define_type_max (const char *, tree, int);
  60 static void builtin_define_type_precision (const char *, tree);
  61 static void builtin_define_type_sizeof (const char *, tree);
  62 static void builtin_define_float_constants (const char *,
  63                                             const char *,
  64                                             const char *,
  65                                             tree);
  66 static void define__GNUC__ (void);
  67
  68 /* Define NAME with value TYPE precision.  */
  69 static void
  70 builtin_define_type_precision (const char *name, tree type)
  71 {
  72   builtin_define_with_int_value (name, TYPE_PRECISION (type));
  73 }
  74
  75 /* Define NAME with value TYPE size_unit.  */
  76 static void
  77 builtin_define_type_sizeof (const char *name, tree type)
  78 {
  79   builtin_define_with_int_value (name,
  80                                  tree_low_cst (TYPE_SIZE_UNIT (type), 1));
  81 }
  82
  83 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
  84    and FP_CAST. */
  85 static void
  86 builtin_define_float_constants (const char *name_prefix,
  87                                 const char *fp_suffix,
  88                                 const char *fp_cast,
  89                                 tree type)
  90 {
  91   /* Used to convert radix-based values to base 10 values in several cases.
  92
  93      In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
  94      least 6 significant digits for correct results.  Using the fraction
  95      formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
  96      intermediate; perhaps someone can find a better approximation, in the
  97      mean time, I suspect using doubles won't harm the bootstrap here.  */
  98
  99   const double log10_2 = .30102999566398119521;
 100   double log10_b;
 101   const struct real_format *fmt;
 102
 103   char name[64], buf[128];
 104   int dig, min_10_exp, max_10_exp;
 105   int decimal_dig;
 106
 107   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
 108   gcc_assert (fmt->b != 10);
 109
 110   /* The radix of the exponent representation.  */
 111   if (type == float_type_node)
 112     builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
 113   log10_b = log10_2;
 114
 115   /* The number of radix digits, p, in the floating-point significand.  */
 116   sprintf (name, "__%s_MANT_DIG__", name_prefix);
 117   builtin_define_with_int_value (name, fmt->p);
 118
 119   /* The number of decimal digits, q, such that any floating-point number
 120      with q decimal digits can be rounded into a floating-point number with
 121      p radix b digits and back again without change to the q decimal digits,
 122
 123         p log10 b                       if b is a power of 10
 124         floor((p - 1) log10 b)          otherwise
 125   */
 126   dig = (fmt->p - 1) * log10_b;
 127   sprintf (name, "__%s_DIG__", name_prefix);
 128   builtin_define_with_int_value (name, dig);
 129
 130   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
 131   sprintf (name, "__%s_MIN_EXP__", name_prefix);
 132   sprintf (buf, "(%d)", fmt->emin);
 133   builtin_define_with_value (name, buf, 0);
 134
 135   /* The minimum negative int x such that 10**x is a normalized float,
 136
 137           ceil (log10 (b ** (emin - 1)))
 138         = ceil (log10 (b) * (emin - 1))
 139
 140      Recall that emin is negative, so the integer truncation calculates
 141      the ceiling, not the floor, in this case.  */
 142   min_10_exp = (fmt->emin - 1) * log10_b;
 143   sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
 144   sprintf (buf, "(%d)", min_10_exp);
 145   builtin_define_with_value (name, buf, 0);
 146
 147   /* The maximum int x such that b**(x-1) is a representable float.  */
 148   sprintf (name, "__%s_MAX_EXP__", name_prefix);
 149   builtin_define_with_int_value (name, fmt->emax);
 150
 151   /* The maximum int x such that 10**x is in the range of representable
 152      finite floating-point numbers,
 153
 154           floor (log10((1 - b**-p) * b**emax))
 155         = floor (log10(1 - b**-p) + log10(b**emax))
 156         = floor (log10(1 - b**-p) + log10(b)*emax)
 157
 158      The safest thing to do here is to just compute this number.  But since
 159      we don't link cc1 with libm, we cannot.  We could implement log10 here
 160      a series expansion, but that seems too much effort because:
 161
 162      Note that the first term, for all extant p, is a number exceedingly close
 163      to zero, but slightly negative.  Note that the second term is an integer
 164      scaling an irrational number, and that because of the floor we are only
 165      interested in its integral portion.
 166
 167      In order for the first term to have any effect on the integral portion
 168      of the second term, the second term has to be exceedingly close to an
 169      integer itself (e.g. 123.000000000001 or something).  Getting a result
 170      that close to an integer requires that the irrational multiplicand have
 171      a long series of zeros in its expansion, which doesn't occur in the
 172      first 20 digits or so of log10(b).
 173
 174      Hand-waving aside, crunching all of the sets of constants above by hand
 175      does not yield a case for which the first term is significant, which
 176      in the end is all that matters.  */
 177   max_10_exp = fmt->emax * log10_b;
 178   sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
 179   builtin_define_with_int_value (name, max_10_exp);
 180
 181   /* The number of decimal digits, n, such that any floating-point number
 182      can be rounded to n decimal digits and back again without change to
 183      the value.
 184
 185         p * log10(b)                    if b is a power of 10
 186         ceil(1 + p * log10(b))          otherwise
 187
 188      The only macro we care about is this number for the widest supported
 189      floating type, but we want this value for rendering constants below.  */
 190   {
 191     double d_decimal_dig = 1 + fmt->p * log10_b;
 192     decimal_dig = d_decimal_dig;
 193     if (decimal_dig < d_decimal_dig)
 194       decimal_dig++;
 195   }
 196   if (type == long_double_type_node)
 197     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
 198
 199   /* Since, for the supported formats, B is always a power of 2, we
 200      construct the following numbers directly as a hexadecimal
 201      constants.  */
 202   get_max_float (fmt, buf, sizeof (buf));
 203
 204   sprintf (name, "__%s_MAX__", name_prefix);
 205   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 206
 207   /* The minimum normalized positive floating-point number,
 208      b**(emin-1).  */
 209   sprintf (name, "__%s_MIN__", name_prefix);
 210   sprintf (buf, "0x1p%d", fmt->emin - 1);
 211   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 212
 213   /* The difference between 1 and the least value greater than 1 that is
 214      representable in the given floating point type, b**(1-p).  */
 215   sprintf (name, "__%s_EPSILON__", name_prefix);
 216   if (fmt->pnan < fmt->p)
 217     /* This is an IBM extended double format, so 1.0 + any double is
 218        representable precisely.  */
 219       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
 220     else
 221       sprintf (buf, "0x1p%d", 1 - fmt->p);
 222   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 223
 224   /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
 225      positive floating-point number, b**(emin-p).  Zero for formats that
 226      don't support denormals.  */
 227   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
 228   if (fmt->has_denorm)
 229     {
 230       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
 231       builtin_define_with_hex_fp_value (name, type, decimal_dig,
 232                                         buf, fp_suffix, fp_cast);
 233     }
 234   else
 235     {
 236       sprintf (buf, "0.0%s", fp_suffix);
 237       builtin_define_with_value (name, buf, 0);
 238     }
 239
 240   sprintf (name, "__%s_HAS_DENORM__", name_prefix);
 241   builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
 242
 243   /* For C++ std::numeric_limits<T>::has_infinity.  */
 244   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
 245   builtin_define_with_int_value (name,
 246                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
 247   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
 248      predicate to distinguish a target that has both quiet and
 249      signalling NaNs from a target that has only quiet NaNs or only
 250      signalling NaNs, so we assume that a target that has any kind of
 251      NaN has quiet NaNs.  */
 252   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
 253   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
 254 }
 255
 256 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
 257 static void
 258 builtin_define_decimal_float_constants (const char *name_prefix,
 259                                         const char *suffix,
 260                                         tree type)
 261 {
 262   const struct real_format *fmt;
 263   char name[64], buf[128], *p;
 264   int digits;
 265
 266   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
 267
 268   /* The number of radix digits, p, in the significand.  */
 269   sprintf (name, "__%s_MANT_DIG__", name_prefix);
 270   builtin_define_with_int_value (name, fmt->p);
 271
 272   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
 273   sprintf (name, "__%s_MIN_EXP__", name_prefix);
 274   sprintf (buf, "(%d)", fmt->emin);
 275   builtin_define_with_value (name, buf, 0);
 276
 277   /* The maximum int x such that b**(x-1) is a representable float.  */
 278   sprintf (name, "__%s_MAX_EXP__", name_prefix);
 279   builtin_define_with_int_value (name, fmt->emax);
 280
 281   /* Compute the minimum representable value.  */
 282   sprintf (name, "__%s_MIN__", name_prefix);
 283   sprintf (buf, "1E%d%s", fmt->emin, suffix);
 284   builtin_define_with_value (name, buf, 0);
 285
 286   /* Compute the maximum representable value.  */
 287   sprintf (name, "__%s_MAX__", name_prefix);
 288   p = buf;
 289   for (digits = fmt->p; digits; digits--)
 290     {
 291       *p++ = '9';
 292       if (digits == fmt->p)
 293         *p++ = '.';
 294     }
 295   *p = 0;
 296   /* fmt->p plus 1, to account for the decimal point.  */
 297   sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix);
 298   builtin_define_with_value (name, buf, 0);
 299
 300   /* Compute epsilon (the difference between 1 and least value greater
 301      than 1 representable).  */
 302   sprintf (name, "__%s_EPSILON__", name_prefix);
 303   sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
 304   builtin_define_with_value (name, buf, 0);
 305
 306   /* Minimum denormalized postive decimal value.  */
 307   sprintf (name, "__%s_DEN__", name_prefix);
 308   p = buf;
 309   for (digits = fmt->p; digits > 1; digits--)
 310     {
 311       *p++ = '0';
 312       if (digits == fmt->p)
 313         *p++ = '.';
 314     }
 315   *p = 0;
 316   sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix);
 317   builtin_define_with_value (name, buf, 0);
 318 }
 319
 320 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__.  */
 321 static void
 322 define__GNUC__ (void)
 323 {
 324   /* The format of the version string, enforced below, is
 325      ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
 326   const char *q, *v = version_string;
 327
 328   while (*v && !ISDIGIT (*v))
 329     v++;
 330   gcc_assert (*v && (v <= version_string || v[-1] == '-'));
 331
 332   q = v;
 333   while (ISDIGIT (*v))
 334     v++;
 335   builtin_define_with_value_n ("__GNUC__", q, v - q);
 336   if (c_dialect_cxx ())
 337     builtin_define_with_value_n ("__GNUG__", q, v - q);
 338
 339   gcc_assert (*v == '.' && ISDIGIT (v[1]));
 340
 341   q = ++v;
 342   while (ISDIGIT (*v))
 343     v++;
 344   builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
 345
 346   if (*v == '.')
 347     {
 348       gcc_assert (ISDIGIT (v[1]));
 349       q = ++v;
 350       while (ISDIGIT (*v))
 351         v++;
 352       builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
 353     }
 354   else
 355     builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
 356
 357   gcc_assert (!*v || *v == ' ' || *v == '-');
 358 }
 359
 360 /* Define macros used by <stdint.h>.  Currently only defines limits
 361    for intmax_t, used by the testsuite.  */
 362 static void
 363 builtin_define_stdint_macros (void)
 364 {
 365   int intmax_long;
 366   if (intmax_type_node == long_long_integer_type_node)
 367     intmax_long = 2;
 368   else if (intmax_type_node == long_integer_type_node)
 369     intmax_long = 1;
 370   else if (intmax_type_node == integer_type_node)
 371     intmax_long = 0;
 372   else
 373     gcc_unreachable ();
 374   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
 375 }
 376
 377 /* Hook that registers front end and target-specific built-ins.  */
 378 void
 379 c_cpp_builtins (cpp_reader *pfile)
 380 {
 381   /* -undef turns off target-specific built-ins.  */
 382   if (flag_undef)
 383     return;
 384
 385   define__GNUC__ ();
 386
 387   /* For stddef.h.  They require macros defined in c-common.c.  */
 388   c_stddef_cpp_builtins ();
 389
 390   if (c_dialect_cxx ())
 391     {
 392       if (flag_weak && SUPPORTS_ONE_ONLY)
 393         cpp_define (pfile, "__GXX_WEAK__=1");
 394       else
 395         cpp_define (pfile, "__GXX_WEAK__=0");
 396       if (warn_deprecated)
 397         cpp_define (pfile, "__DEPRECATED");
 398       if (cxx_dialect == cxx0x)
 399         cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
 400     }
 401   /* Note that we define this for C as well, so that we know if
 402      __attribute__((cleanup)) will interface with EH.  */
 403   if (flag_exceptions)
 404     cpp_define (pfile, "__EXCEPTIONS");
 405
 406   /* Represents the C++ ABI version, always defined so it can be used while
 407      preprocessing C and assembler.  */
 408   if (flag_abi_version == 0)
 409     /* Use a very large value so that:
 410
 411          #if __GXX_ABI_VERSION >= <value for version X>
 412
 413        will work whether the user explicitly says "-fabi-version=x" or
 414        "-fabi-version=0".  Do not use INT_MAX because that will be
 415        different from system to system.  */
 416     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
 417   else if (flag_abi_version == 1)
 418     /* Due to a historical accident, this version had the value
 419        "102".  */
 420     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
 421   else
 422     /* Newer versions have values 1002, 1003, ....  */
 423     builtin_define_with_int_value ("__GXX_ABI_VERSION",
 424                                    1000 + flag_abi_version);
 425
 426   /* libgcc needs to know this.  */
 427   if (USING_SJLJ_EXCEPTIONS)
 428     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
 429
 430   /* limits.h needs to know these.  */
 431   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
 432   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
 433   builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
 434   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
 435   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
 436   builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
 437
 438   builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
 439
 440   /* stdint.h (eventually) and the testsuite need to know these.  */
 441   builtin_define_stdint_macros ();
 442
 443   /* float.h needs to know these.  */
 444
 445   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
 446                                  TARGET_FLT_EVAL_METHOD);
 447
 448   /* And decfloat.h needs this.  */
 449   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
 450                                  TARGET_DEC_EVAL_METHOD);
 451
 452   builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
 453   /* Cast the double precision constants when single precision constants are
 454      specified. The correct result is computed by the compiler when using
 455      macros that include a cast. This has the side-effect of making the value
 456      unusable in const expressions. */
 457   if (flag_single_precision_constant)
 458     builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
 459   else
 460     builtin_define_float_constants ("DBL", "", "%s", double_type_node);
 461   builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
 462
 463   /* For decfloat.h.  */
 464   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
 465   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
 466   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
 467
 468   /* For use in assembly language.  */
 469   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
 470   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
 471
 472   /* Misc.  */
 473   builtin_define_with_value ("__VERSION__", version_string, 1);
 474
 475   if (flag_gnu89_inline)
 476     cpp_define (pfile, "__GNUC_GNU_INLINE__");
 477   else
 478     cpp_define (pfile, "__GNUC_STDC_INLINE__");
 479
 480   /* Definitions for LP64 model.  */
 481   if (TYPE_PRECISION (long_integer_type_node) == 64
 482       && POINTER_SIZE == 64
 483       && TYPE_PRECISION (integer_type_node) == 32)
 484     {
 485       cpp_define (pfile, "_LP64");
 486       cpp_define (pfile, "__LP64__");
 487     }
 488
 489   /* Other target-independent built-ins determined by command-line
 490      options.  */
 491   if (optimize_size)
 492     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 493   if (optimize)
 494     cpp_define (pfile, "__OPTIMIZE__");
 495
 496   if (fast_math_flags_set_p ())
 497     cpp_define (pfile, "__FAST_MATH__");
 498   if (flag_really_no_inline)
 499     cpp_define (pfile, "__NO_INLINE__");
 500   if (flag_signaling_nans)
 501     cpp_define (pfile, "__SUPPORT_SNAN__");
 502   if (flag_finite_math_only)
 503     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 504   else
 505     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 506   if (flag_pic)
 507     {
 508       builtin_define_with_int_value ("__pic__", flag_pic);
 509       builtin_define_with_int_value ("__PIC__", flag_pic);
 510     }
 511   if (flag_pie)
 512     {
 513       builtin_define_with_int_value ("__pie__", flag_pie);
 514       builtin_define_with_int_value ("__PIE__", flag_pie);
 515     }
 516
 517   if (flag_iso)
 518     cpp_define (pfile, "__STRICT_ANSI__");
 519
 520   if (!flag_signed_char)
 521     cpp_define (pfile, "__CHAR_UNSIGNED__");
 522
 523   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
 524     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 525
 526   /* Tell source code if the compiler makes sync_compare_and_swap
 527      builtins available.  */
 528 #ifdef HAVE_sync_compare_and_swapqi
 529   if (HAVE_sync_compare_and_swapqi)
 530     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 531 #endif
 532
 533 #ifdef HAVE_sync_compare_and_swaphi
 534   if (HAVE_sync_compare_and_swaphi)
 535     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 536 #endif
 537
 538 #ifdef HAVE_sync_compare_and_swapsi
 539   if (HAVE_sync_compare_and_swapsi)
 540     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 541 #endif
 542
 543 #ifdef HAVE_sync_compare_and_swapdi
 544   if (HAVE_sync_compare_and_swapdi)
 545     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 546 #endif
 547
 548 #ifdef HAVE_sync_compare_and_swapti
 549   if (HAVE_sync_compare_and_swapti)
 550     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
 551 #endif
 552
 553   /* Make the choice of ObjC runtime visible to source code.  */
 554   if (c_dialect_objc () && flag_next_runtime)
 555     cpp_define (pfile, "__NEXT_RUNTIME__");
 556
 557   /* Show the availability of some target pragmas.  */
 558   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
 559     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 560
 561   if (targetm.handle_pragma_extern_prefix)
 562     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 563
 564   /* Make the choice of the stack protector runtime visible to source code.
 565      The macro names and values here were chosen for compatibility with an
 566      earlier implementation, i.e. ProPolice.  */
 567   if (flag_stack_protect == 2)
 568     cpp_define (pfile, "__SSP_ALL__=2");
 569   else if (flag_stack_protect == 1)
 570     cpp_define (pfile, "__SSP__=1");
 571
 572   if (flag_openmp)
 573     cpp_define (pfile, "_OPENMP=200505");
 574
 575   if (lang_fortran)
 576     cpp_define (pfile, "__GFORTRAN__=1");
 577
 578   builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
 579   builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
 580   builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
 581                               long_long_integer_type_node);
 582   builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
 583   builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
 584   builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
 585   builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
 586   builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
 587   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
 588   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
 589   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
 590                               unsigned_ptrdiff_type_node);
 591   /* ptr_type_node can't be used here since ptr_mode is only set when
 592      toplev calls backend_init which is not done with -E switch.  */
 593   builtin_define_with_int_value ("__SIZEOF_POINTER__",
 594                                  POINTER_SIZE / BITS_PER_UNIT);
 595
 596   /* A straightforward target hook doesn't work, because of problems
 597      linking that hook's body when part of non-C front ends.  */
 598 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 599 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 600 # define builtin_define(TXT) cpp_define (pfile, TXT)
 601 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 602   TARGET_CPU_CPP_BUILTINS ();
 603   TARGET_OS_CPP_BUILTINS ();
 604   TARGET_OBJFMT_CPP_BUILTINS ();
 605
 606   /* Support the __declspec keyword by turning them into attributes.
 607      Note that the current way we do this may result in a collision
 608      with predefined attributes later on.  This can be solved by using
 609      one attribute, say __declspec__, and passing args to it.  The
 610      problem with that approach is that args are not accumulated: each
 611      new appearance would clobber any existing args.  */
 612   if (TARGET_DECLSPEC)
 613     builtin_define ("__declspec(x)=__attribute__((x))");
 614
 615   /* If decimal floating point is supported, tell the user if the
 616      alternate format (BID) is used instead of the standard (DPD)
 617      format.  */
 618   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
 619     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
 620 }
 621
 622 /* Pass an object-like macro.  If it doesn't lie in the user's
 623    namespace, defines it unconditionally.  Otherwise define a version
 624    with two leading underscores, and another version with two leading
 625    and trailing underscores, and define the original only if an ISO
 626    standard was not nominated.
 627
 628    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 629    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 630    "_mips".  */
 631 void
 632 builtin_define_std (const char *macro)
 633 {
 634   size_t len = strlen (macro);
 635   char *buff = (char *) alloca (len + 5);
 636   char *p = buff + 2;
 637   char *q = p + len;
 638
 639   /* prepend __ (or maybe just _) if in user's namespace.  */
 640   memcpy (p, macro, len + 1);
 641   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 642     {
 643       if (*p != '_')
 644         *--p = '_';
 645       if (p[1] != '_')
 646         *--p = '_';
 647     }
 648   cpp_define (parse_in, p);
 649
 650   /* If it was in user's namespace...  */
 651   if (p != buff + 2)
 652     {
 653       /* Define the macro with leading and following __.  */
 654       if (q[-1] != '_')
 655         *q++ = '_';
 656       if (q[-2] != '_')
 657         *q++ = '_';
 658       *q = '\0';
 659       cpp_define (parse_in, p);
 660
 661       /* Finally, define the original macro if permitted.  */
 662       if (!flag_iso)
 663         cpp_define (parse_in, macro);
 664     }
 665 }
 666
 667 /* Pass an object-like macro and a value to define it to.  The third
 668    parameter says whether or not to turn the value into a string
 669    constant.  */
 670 void
 671 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 672 {
 673   char *buf;
 674   size_t mlen = strlen (macro);
 675   size_t elen = strlen (expansion);
 676   size_t extra = 2;  /* space for an = and a NUL */
 677
 678   if (is_str)
 679     extra += 2;  /* space for two quote marks */
 680
 681   buf = (char *) alloca (mlen + elen + extra);
 682   if (is_str)
 683     sprintf (buf, "%s=\"%s\"", macro, expansion);
 684   else
 685     sprintf (buf, "%s=%s", macro, expansion);
 686
 687   cpp_define (parse_in, buf);
 688 }
 689
 690 /* Pass an object-like macro and a value to define it to.  The third
 691    parameter is the length of the expansion.  */
 692 static void
 693 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 694 {
 695   char *buf;
 696   size_t mlen = strlen (macro);
 697
 698   /* Space for an = and a NUL.  */
 699   buf = (char *) alloca (mlen + elen + 2);
 700   memcpy (buf, macro, mlen);
 701   buf[mlen] = '=';
 702   memcpy (buf + mlen + 1, expansion, elen);
 703   buf[mlen + elen + 1] = '\0';
 704
 705   cpp_define (parse_in, buf);
 706 }
 707
 708 /* Pass an object-like macro and an integer value to define it to.  */
 709 static void
 710 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 711 {
 712   char *buf;
 713   size_t mlen = strlen (macro);
 714   size_t vlen = 18;
 715   size_t extra = 2; /* space for = and NUL.  */
 716
 717   buf = (char *) alloca (mlen + vlen + extra);
 718   memcpy (buf, macro, mlen);
 719   buf[mlen] = '=';
 720   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 721
 722   cpp_define (parse_in, buf);
 723 }
 724
 725 /* Pass an object-like macro a hexadecimal floating-point value.  */
 726 static void
 727 builtin_define_with_hex_fp_value (const char *macro,
 728                                   tree type ATTRIBUTE_UNUSED, int digits,
 729                                   const char *hex_str,
 730                                   const char *fp_suffix,
 731                                   const char *fp_cast)
 732 {
 733   REAL_VALUE_TYPE real;
 734   char dec_str[64], buf1[256], buf2[256];
 735
 736   /* Hex values are really cool and convenient, except that they're
 737      not supported in strict ISO C90 mode.  First, the "p-" sequence
 738      is not valid as part of a preprocessor number.  Second, we get a
 739      pedwarn from the preprocessor, which has no context, so we can't
 740      suppress the warning with __extension__.
 741
 742      So instead what we do is construct the number in hex (because
 743      it's easy to get the exact correct value), parse it as a real,
 744      then print it back out as decimal.  */
 745
 746   real_from_string (&real, hex_str);
 747   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 748
 749   /* Assemble the macro in the following fashion
 750      macro = fp_cast [dec_str fp_suffix] */
 751   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 752   sprintf (buf2, fp_cast, buf1);
 753   sprintf (buf1, "%s=%s", macro, buf2);
 754
 755   cpp_define (parse_in, buf1);
 756 }
 757
 758 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 759    1 for type "long" and 2 for "long long".  We have to handle
 760    unsigned types, since wchar_t might be unsigned.  */
 761
 762 static void
 763 builtin_define_type_max (const char *macro, tree type, int is_long)
 764 {
 765   static const char *const values[]
 766     = { "127", "255",
 767         "32767", "65535",
 768         "2147483647", "4294967295",
 769         "9223372036854775807", "18446744073709551615",
 770         "170141183460469231731687303715884105727",
 771         "340282366920938463463374607431768211455" };
 772   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 773
 774   const char *value, *suffix;
 775   char *buf;
 776   size_t idx;
 777
 778   /* Pre-rendering the values mean we don't have to futz with printing a
 779      multi-word decimal value.  There are also a very limited number of
 780      precisions that we support, so it's really a waste of time.  */
 781   switch (TYPE_PRECISION (type))
 782     {
 783     case 8:     idx = 0; break;
 784     case 16:    idx = 2; break;
 785     case 32:    idx = 4; break;
 786     case 64:    idx = 6; break;
 787     case 128:   idx = 8; break;
 788     default:    gcc_unreachable ();
 789     }
 790
 791   value = values[idx + TYPE_UNSIGNED (type)];
 792   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
 793
 794   buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
 795                          + strlen (suffix) + 1);
 796   sprintf (buf, "%s=%s%s", macro, value, suffix);
 797
 798   cpp_define (parse_in, buf);
 799 }