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