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     {
 508       cpp_define (pfile, "__block=__attribute__((__blocks__(byref)))");
 509       cpp_define (pfile, "__BLOCKS__=1");
 510     }
 511   /* APPLE LOCAL end blocks */
 512   if (optimize_size)
 513     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 514   if (optimize)
 515     cpp_define (pfile, "__OPTIMIZE__");
 516
 517   if (fast_math_flags_set_p ())
 518     cpp_define (pfile, "__FAST_MATH__");
 519   if (flag_really_no_inline)
 520     cpp_define (pfile, "__NO_INLINE__");
 521   if (flag_signaling_nans)
 522     cpp_define (pfile, "__SUPPORT_SNAN__");
 523   if (flag_finite_math_only)
 524     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 525   else
 526     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 527   if (flag_pic)
 528     {
 529       builtin_define_with_int_value ("__pic__", flag_pic);
 530       builtin_define_with_int_value ("__PIC__", flag_pic);
 531     }
 532
 533   if (flag_iso)
 534     cpp_define (pfile, "__STRICT_ANSI__");
 535
 536   if (!flag_signed_char)
 537     cpp_define (pfile, "__CHAR_UNSIGNED__");
 538
 539   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
 540     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 541
 542   /* Make the choice of ObjC runtime visible to source code.  */
 543   if (c_dialect_objc () && flag_next_runtime)
 544     cpp_define (pfile, "__NEXT_RUNTIME__");
 545
 546   /* Show the availability of some target pragmas.  */
 547   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
 548     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 549
 550   if (targetm.handle_pragma_extern_prefix)
 551     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 552
 553   /* Make the choice of the stack protector runtime visible to source code.
 554      The macro names and values here were chosen for compatibility with an
 555      earlier implementation, i.e. ProPolice.  */
 556   if (flag_stack_protect == 3)
 557     cpp_define (pfile, "__SSP_STRONG__=3");
 558   else if (flag_stack_protect == 2)
 559     cpp_define (pfile, "__SSP_ALL__=2");
 560   else if (flag_stack_protect == 1)
 561     cpp_define (pfile, "__SSP__=1");
 562
 563   if (flag_openmp)
 564     cpp_define (pfile, "_OPENMP=200505");
 565
 566   /* A straightforward target hook doesn't work, because of problems
 567      linking that hook's body when part of non-C front ends.  */
 568 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 569 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 570 # define builtin_define(TXT) cpp_define (pfile, TXT)
 571 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 572   TARGET_CPU_CPP_BUILTINS ();
 573   TARGET_OS_CPP_BUILTINS ();
 574   TARGET_OBJFMT_CPP_BUILTINS ();
 575
 576   /* Support the __declspec keyword by turning them into attributes.
 577      Note that the current way we do this may result in a collision
 578      with predefined attributes later on.  This can be solved by using
 579      one attribute, say __declspec__, and passing args to it.  The
 580      problem with that approach is that args are not accumulated: each
 581      new appearance would clobber any existing args.  */
 582   if (TARGET_DECLSPEC)
 583     builtin_define ("__declspec(x)=__attribute__((x))");
 584 }
 585
 586 /* Pass an object-like macro.  If it doesn't lie in the user's
 587    namespace, defines it unconditionally.  Otherwise define a version
 588    with two leading underscores, and another version with two leading
 589    and trailing underscores, and define the original only if an ISO
 590    standard was not nominated.
 591
 592    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 593    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 594    "_mips".  */
 595 void
 596 builtin_define_std (const char *macro)
 597 {
 598   size_t len = strlen (macro);
 599   char *buff = (char *) alloca (len + 5);
 600   char *p = buff + 2;
 601   char *q = p + len;
 602
 603   /* prepend __ (or maybe just _) if in user's namespace.  */
 604   memcpy (p, macro, len + 1);
 605   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 606     {
 607       if (*p != '_')
 608         *--p = '_';
 609       if (p[1] != '_')
 610         *--p = '_';
 611     }
 612   cpp_define (parse_in, p);
 613
 614   /* If it was in user's namespace...  */
 615   if (p != buff + 2)
 616     {
 617       /* Define the macro with leading and following __.  */
 618       if (q[-1] != '_')
 619         *q++ = '_';
 620       if (q[-2] != '_')
 621         *q++ = '_';
 622       *q = '\0';
 623       cpp_define (parse_in, p);
 624
 625       /* Finally, define the original macro if permitted.  */
 626       if (!flag_iso)
 627         cpp_define (parse_in, macro);
 628     }
 629 }
 630
 631 /* Pass an object-like macro and a value to define it to.  The third
 632    parameter says whether or not to turn the value into a string
 633    constant.  */
 634 void
 635 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 636 {
 637   char *buf;
 638   size_t mlen = strlen (macro);
 639   size_t elen = strlen (expansion);
 640   size_t extra = 2;  /* space for an = and a NUL */
 641
 642   if (is_str)
 643     extra += 2;  /* space for two quote marks */
 644
 645   buf = (char *) alloca (mlen + elen + extra);
 646   if (is_str)
 647     sprintf (buf, "%s=\"%s\"", macro, expansion);
 648   else
 649     sprintf (buf, "%s=%s", macro, expansion);
 650
 651   cpp_define (parse_in, buf);
 652 }
 653
 654 /* Pass an object-like macro and a value to define it to.  The third
 655    parameter is the length of the expansion.  */
 656 static void
 657 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 658 {
 659   char *buf;
 660   size_t mlen = strlen (macro);
 661
 662   /* Space for an = and a NUL.  */
 663   buf = (char *) alloca (mlen + elen + 2);
 664   memcpy (buf, macro, mlen);
 665   buf[mlen] = '=';
 666   memcpy (buf + mlen + 1, expansion, elen);
 667   buf[mlen + elen + 1] = '\0';
 668
 669   cpp_define (parse_in, buf);
 670 }
 671
 672 /* Pass an object-like macro and an integer value to define it to.  */
 673 static void
 674 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 675 {
 676   char *buf;
 677   size_t mlen = strlen (macro);
 678   size_t vlen = 18;
 679   size_t extra = 2; /* space for = and NUL.  */
 680
 681   buf = (char *) alloca (mlen + vlen + extra);
 682   memcpy (buf, macro, mlen);
 683   buf[mlen] = '=';
 684   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 685
 686   cpp_define (parse_in, buf);
 687 }
 688
 689 /* Pass an object-like macro a hexadecimal floating-point value.  */
 690 static void
 691 builtin_define_with_hex_fp_value (const char *macro,
 692                                   tree type ATTRIBUTE_UNUSED, int digits,
 693                                   const char *hex_str,
 694                                   const char *fp_suffix,
 695                                   const char *fp_cast)
 696 {
 697   REAL_VALUE_TYPE real;
 698   char dec_str[64], buf1[256], buf2[256];
 699
 700   /* Hex values are really cool and convenient, except that they're
 701      not supported in strict ISO C90 mode.  First, the "p-" sequence
 702      is not valid as part of a preprocessor number.  Second, we get a
 703      pedwarn from the preprocessor, which has no context, so we can't
 704      suppress the warning with __extension__.
 705
 706      So instead what we do is construct the number in hex (because
 707      it's easy to get the exact correct value), parse it as a real,
 708      then print it back out as decimal.  */
 709
 710   real_from_string (&real, hex_str);
 711   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 712
 713   /* Assemble the macro in the following fashion
 714      macro = fp_cast [dec_str fp_suffix] */
 715   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 716   sprintf (buf2, fp_cast, buf1);
 717   sprintf (buf1, "%s=%s", macro, buf2);
 718
 719   cpp_define (parse_in, buf1);
 720 }
 721
 722 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 723    1 for type "long" and 2 for "long long".  We have to handle
 724    unsigned types, since wchar_t might be unsigned.  */
 725
 726 static void
 727 builtin_define_type_max (const char *macro, tree type, int is_long)
 728 {
 729   static const char *const values[]
 730     = { "127", "255",
 731         "32767", "65535",
 732         "2147483647", "4294967295",
 733         "9223372036854775807", "18446744073709551615",
 734         "170141183460469231731687303715884105727",
 735         "340282366920938463463374607431768211455" };
 736   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 737
 738   const char *value, *suffix;
 739   char *buf;
 740   size_t idx;
 741
 742   /* Pre-rendering the values mean we don't have to futz with printing a
 743      multi-word decimal value.  There are also a very limited number of
 744      precisions that we support, so it's really a waste of time.  */
 745   switch (TYPE_PRECISION (type))
 746     {
 747     case 8:     idx = 0; break;
 748     case 16:    idx = 2; break;
 749     case 32:    idx = 4; break;
 750     case 64:    idx = 6; break;
 751     case 128:   idx = 8; break;
 752     default:    gcc_unreachable ();
 753     }
 754
 755   value = values[idx + TYPE_UNSIGNED (type)];
 756   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
 757
 758   buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
 759                          + strlen (suffix) + 1);
 760   sprintf (buf, "%s=%s%s", macro, value, suffix);
 761
 762   cpp_define (parse_in, buf);
 763 }