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