gcc/c-cppbuiltin.c

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