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 (cxx_dialect == cxx0x)
 453         cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
 454     }
 455   /* Note that we define this for C as well, so that we know if
 456      __attribute__((cleanup)) will interface with EH.  */
 457   if (flag_exceptions)
 458     cpp_define (pfile, "__EXCEPTIONS");
 459
 460   /* Represents the C++ ABI version, always defined so it can be used while
 461      preprocessing C and assembler.  */
 462   if (flag_abi_version == 0)
 463     /* Use a very large value so that:
 464
 465          #if __GXX_ABI_VERSION >= <value for version X>
 466
 467        will work whether the user explicitly says "-fabi-version=x" or
 468        "-fabi-version=0".  Do not use INT_MAX because that will be
 469        different from system to system.  */
 470     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
 471   else if (flag_abi_version == 1)
 472     /* Due to a historical accident, this version had the value
 473        "102".  */
 474     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
 475   else
 476     /* Newer versions have values 1002, 1003, ....  */
 477     builtin_define_with_int_value ("__GXX_ABI_VERSION",
 478                                    1000 + flag_abi_version);
 479
 480   /* libgcc needs to know this.  */
 481   if (USING_SJLJ_EXCEPTIONS)
 482     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
 483
 484   /* limits.h needs to know these.  */
 485   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
 486   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
 487   builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
 488   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
 489   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
 490   builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
 491
 492   builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
 493
 494   /* stdint.h (eventually) and the testsuite need to know these.  */
 495   builtin_define_stdint_macros ();
 496
 497   /* float.h needs to know these.  */
 498
 499   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
 500                                  TARGET_FLT_EVAL_METHOD);
 501
 502   /* And decfloat.h needs this.  */
 503   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
 504                                  TARGET_DEC_EVAL_METHOD);
 505
 506   builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
 507   /* Cast the double precision constants when single precision constants are
 508      specified. The correct result is computed by the compiler when using
 509      macros that include a cast. This has the side-effect of making the value
 510      unusable in const expressions. */
 511   if (flag_single_precision_constant)
 512     builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
 513   else
 514     builtin_define_float_constants ("DBL", "", "%s", double_type_node);
 515   builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
 516
 517   /* For decfloat.h.  */
 518   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
 519   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
 520   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
 521
 522   /* For fixed-point fibt, ibit, max, min, and epsilon.  */
 523   if (targetm.fixed_point_supported_p ())
 524     {
 525       builtin_define_fixed_point_constants ("SFRACT", "HR",
 526                                             short_fract_type_node);
 527       builtin_define_fixed_point_constants ("USFRACT", "UHR",
 528                                             unsigned_short_fract_type_node);
 529       builtin_define_fixed_point_constants ("FRACT", "R",
 530                                             fract_type_node);
 531       builtin_define_fixed_point_constants ("UFRACT", "UR",
 532                                             unsigned_fract_type_node);
 533       builtin_define_fixed_point_constants ("LFRACT", "LR",
 534                                             long_fract_type_node);
 535       builtin_define_fixed_point_constants ("ULFRACT", "ULR",
 536                                             unsigned_long_fract_type_node);
 537       builtin_define_fixed_point_constants ("LLFRACT", "LLR",
 538                                             long_long_fract_type_node);
 539       builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
 540                                             unsigned_long_long_fract_type_node);
 541       builtin_define_fixed_point_constants ("SACCUM", "HK",
 542                                             short_accum_type_node);
 543       builtin_define_fixed_point_constants ("USACCUM", "UHK",
 544                                             unsigned_short_accum_type_node);
 545       builtin_define_fixed_point_constants ("ACCUM", "K",
 546                                             accum_type_node);
 547       builtin_define_fixed_point_constants ("UACCUM", "UK",
 548                                             unsigned_accum_type_node);
 549       builtin_define_fixed_point_constants ("LACCUM", "LK",
 550                                             long_accum_type_node);
 551       builtin_define_fixed_point_constants ("ULACCUM", "ULK",
 552                                             unsigned_long_accum_type_node);
 553       builtin_define_fixed_point_constants ("LLACCUM", "LLK",
 554                                             long_long_accum_type_node);
 555       builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
 556                                             unsigned_long_long_accum_type_node);
 557
 558       builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
 559       builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
 560       builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
 561       builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
 562       builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
 563       builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
 564       builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
 565       builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
 566       builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
 567       builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
 568       builtin_define_fixed_point_constants ("HA", "", ha_type_node);
 569       builtin_define_fixed_point_constants ("SA", "", sa_type_node);
 570       builtin_define_fixed_point_constants ("DA", "", da_type_node);
 571       builtin_define_fixed_point_constants ("TA", "", ta_type_node);
 572       builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
 573       builtin_define_fixed_point_constants ("USA", "", usa_type_node);
 574       builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
 575       builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
 576     }
 577
 578   /* For use in assembly language.  */
 579   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
 580   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
 581
 582   /* Misc.  */
 583   builtin_define_with_value ("__VERSION__", version_string, 1);
 584
 585   if (flag_gnu89_inline)
 586     cpp_define (pfile, "__GNUC_GNU_INLINE__");
 587   else
 588     cpp_define (pfile, "__GNUC_STDC_INLINE__");
 589
 590   /* Definitions for LP64 model.  */
 591   if (TYPE_PRECISION (long_integer_type_node) == 64
 592       && POINTER_SIZE == 64
 593       && TYPE_PRECISION (integer_type_node) == 32)
 594     {
 595       cpp_define (pfile, "_LP64");
 596       cpp_define (pfile, "__LP64__");
 597     }
 598
 599   /* Other target-independent built-ins determined by command-line
 600      options.  */
 601   if (optimize_size)
 602     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 603   if (optimize)
 604     cpp_define (pfile, "__OPTIMIZE__");
 605
 606   if (fast_math_flags_set_p ())
 607     cpp_define (pfile, "__FAST_MATH__");
 608   if (flag_really_no_inline)
 609     cpp_define (pfile, "__NO_INLINE__");
 610   if (flag_signaling_nans)
 611     cpp_define (pfile, "__SUPPORT_SNAN__");
 612   if (flag_finite_math_only)
 613     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 614   else
 615     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 616   if (flag_pic)
 617     {
 618       builtin_define_with_int_value ("__pic__", flag_pic);
 619       builtin_define_with_int_value ("__PIC__", flag_pic);
 620     }
 621   if (flag_pie)
 622     {
 623       builtin_define_with_int_value ("__pie__", flag_pie);
 624       builtin_define_with_int_value ("__PIE__", flag_pie);
 625     }
 626
 627   if (flag_iso)
 628     cpp_define (pfile, "__STRICT_ANSI__");
 629
 630   if (!flag_signed_char)
 631     cpp_define (pfile, "__CHAR_UNSIGNED__");
 632
 633   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
 634     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 635
 636   /* Tell source code if the compiler makes sync_compare_and_swap
 637      builtins available.  */
 638 #ifdef HAVE_sync_compare_and_swapqi
 639   if (HAVE_sync_compare_and_swapqi)
 640     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
 641 #endif
 642
 643 #ifdef HAVE_sync_compare_and_swaphi
 644   if (HAVE_sync_compare_and_swaphi)
 645     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
 646 #endif
 647
 648 #ifdef HAVE_sync_compare_and_swapsi
 649   if (HAVE_sync_compare_and_swapsi)
 650     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
 651 #endif
 652
 653 #ifdef HAVE_sync_compare_and_swapdi
 654   if (HAVE_sync_compare_and_swapdi)
 655     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 656 #endif
 657
 658 #ifdef HAVE_sync_compare_and_swapti
 659   if (HAVE_sync_compare_and_swapti)
 660     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
 661 #endif
 662
 663   /* Make the choice of ObjC runtime visible to source code.  */
 664   if (c_dialect_objc () && flag_next_runtime)
 665     cpp_define (pfile, "__NEXT_RUNTIME__");
 666
 667   /* Show the availability of some target pragmas.  */
 668   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
 669     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 670
 671   if (targetm.handle_pragma_extern_prefix)
 672     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 673
 674   /* Make the choice of the stack protector runtime visible to source code.
 675      The macro names and values here were chosen for compatibility with an
 676      earlier implementation, i.e. ProPolice.  */
 677   if (flag_stack_protect == 2)
 678     cpp_define (pfile, "__SSP_ALL__=2");
 679   else if (flag_stack_protect == 1)
 680     cpp_define (pfile, "__SSP__=1");
 681
 682   if (flag_openmp)
 683     cpp_define (pfile, "_OPENMP=200505");
 684
 685   if (lang_fortran)
 686     cpp_define (pfile, "__GFORTRAN__=1");
 687
 688   builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
 689   builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
 690   builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
 691                               long_long_integer_type_node);
 692   builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
 693   builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
 694   builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
 695   builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
 696   builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
 697   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
 698   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
 699   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
 700                               unsigned_ptrdiff_type_node);
 701   /* ptr_type_node can't be used here since ptr_mode is only set when
 702      toplev calls backend_init which is not done with -E switch.  */
 703   builtin_define_with_int_value ("__SIZEOF_POINTER__",
 704                                  POINTER_SIZE / BITS_PER_UNIT);
 705
 706   /* A straightforward target hook doesn't work, because of problems
 707      linking that hook's body when part of non-C front ends.  */
 708 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 709 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 710 # define builtin_define(TXT) cpp_define (pfile, TXT)
 711 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 712   TARGET_CPU_CPP_BUILTINS ();
 713   TARGET_OS_CPP_BUILTINS ();
 714   TARGET_OBJFMT_CPP_BUILTINS ();
 715
 716   /* Support the __declspec keyword by turning them into attributes.
 717      Note that the current way we do this may result in a collision
 718      with predefined attributes later on.  This can be solved by using
 719      one attribute, say __declspec__, and passing args to it.  The
 720      problem with that approach is that args are not accumulated: each
 721      new appearance would clobber any existing args.  */
 722   if (TARGET_DECLSPEC)
 723     builtin_define ("__declspec(x)=__attribute__((x))");
 724
 725   /* If decimal floating point is supported, tell the user if the
 726      alternate format (BID) is used instead of the standard (DPD)
 727      format.  */
 728   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
 729     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
 730 }
 731
 732 /* Pass an object-like macro.  If it doesn't lie in the user's
 733    namespace, defines it unconditionally.  Otherwise define a version
 734    with two leading underscores, and another version with two leading
 735    and trailing underscores, and define the original only if an ISO
 736    standard was not nominated.
 737
 738    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 739    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 740    "_mips".  */
 741 void
 742 builtin_define_std (const char *macro)
 743 {
 744   size_t len = strlen (macro);
 745   char *buff = (char *) alloca (len + 5);
 746   char *p = buff + 2;
 747   char *q = p + len;
 748
 749   /* prepend __ (or maybe just _) if in user's namespace.  */
 750   memcpy (p, macro, len + 1);
 751   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 752     {
 753       if (*p != '_')
 754         *--p = '_';
 755       if (p[1] != '_')
 756         *--p = '_';
 757     }
 758   cpp_define (parse_in, p);
 759
 760   /* If it was in user's namespace...  */
 761   if (p != buff + 2)
 762     {
 763       /* Define the macro with leading and following __.  */
 764       if (q[-1] != '_')
 765         *q++ = '_';
 766       if (q[-2] != '_')
 767         *q++ = '_';
 768       *q = '\0';
 769       cpp_define (parse_in, p);
 770
 771       /* Finally, define the original macro if permitted.  */
 772       if (!flag_iso)
 773         cpp_define (parse_in, macro);
 774     }
 775 }
 776
 777 /* Pass an object-like macro and a value to define it to.  The third
 778    parameter says whether or not to turn the value into a string
 779    constant.  */
 780 void
 781 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 782 {
 783   char *buf;
 784   size_t mlen = strlen (macro);
 785   size_t elen = strlen (expansion);
 786   size_t extra = 2;  /* space for an = and a NUL */
 787
 788   if (is_str)
 789     extra += 2;  /* space for two quote marks */
 790
 791   buf = (char *) alloca (mlen + elen + extra);
 792   if (is_str)
 793     sprintf (buf, "%s=\"%s\"", macro, expansion);
 794   else
 795     sprintf (buf, "%s=%s", macro, expansion);
 796
 797   cpp_define (parse_in, buf);
 798 }
 799
 800 /* Pass an object-like macro and a value to define it to.  The third
 801    parameter is the length of the expansion.  */
 802 static void
 803 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 804 {
 805   char *buf;
 806   size_t mlen = strlen (macro);
 807
 808   /* Space for an = and a NUL.  */
 809   buf = (char *) alloca (mlen + elen + 2);
 810   memcpy (buf, macro, mlen);
 811   buf[mlen] = '=';
 812   memcpy (buf + mlen + 1, expansion, elen);
 813   buf[mlen + elen + 1] = '\0';
 814
 815   cpp_define (parse_in, buf);
 816 }
 817
 818 /* Pass an object-like macro and an integer value to define it to.  */
 819 static void
 820 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 821 {
 822   char *buf;
 823   size_t mlen = strlen (macro);
 824   size_t vlen = 18;
 825   size_t extra = 2; /* space for = and NUL.  */
 826
 827   buf = (char *) alloca (mlen + vlen + extra);
 828   memcpy (buf, macro, mlen);
 829   buf[mlen] = '=';
 830   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 831
 832   cpp_define (parse_in, buf);
 833 }
 834
 835 /* Pass an object-like macro a hexadecimal floating-point value.  */
 836 static void
 837 builtin_define_with_hex_fp_value (const char *macro,
 838                                   tree type ATTRIBUTE_UNUSED, int digits,
 839                                   const char *hex_str,
 840                                   const char *fp_suffix,
 841                                   const char *fp_cast)
 842 {
 843   REAL_VALUE_TYPE real;
 844   char dec_str[64], buf1[256], buf2[256];
 845
 846   /* Hex values are really cool and convenient, except that they're
 847      not supported in strict ISO C90 mode.  First, the "p-" sequence
 848      is not valid as part of a preprocessor number.  Second, we get a
 849      pedwarn from the preprocessor, which has no context, so we can't
 850      suppress the warning with __extension__.
 851
 852      So instead what we do is construct the number in hex (because
 853      it's easy to get the exact correct value), parse it as a real,
 854      then print it back out as decimal.  */
 855
 856   real_from_string (&real, hex_str);
 857   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 858
 859   /* Assemble the macro in the following fashion
 860      macro = fp_cast [dec_str fp_suffix] */
 861   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 862   sprintf (buf2, fp_cast, buf1);
 863   sprintf (buf1, "%s=%s", macro, buf2);
 864
 865   cpp_define (parse_in, buf1);
 866 }
 867
 868 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 869    1 for type "long" and 2 for "long long".  We have to handle
 870    unsigned types, since wchar_t might be unsigned.  */
 871
 872 static void
 873 builtin_define_type_max (const char *macro, tree type, int is_long)
 874 {
 875   static const char *const values[]
 876     = { "127", "255",
 877         "32767", "65535",
 878         "2147483647", "4294967295",
 879         "9223372036854775807", "18446744073709551615",
 880         "170141183460469231731687303715884105727",
 881         "340282366920938463463374607431768211455" };
 882   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 883
 884   const char *value, *suffix;
 885   char *buf;
 886   size_t idx;
 887
 888   /* Pre-rendering the values mean we don't have to futz with printing a
 889      multi-word decimal value.  There are also a very limited number of
 890      precisions that we support, so it's really a waste of time.  */
 891   switch (TYPE_PRECISION (type))
 892     {
 893     case 8:     idx = 0; break;
 894     case 16:    idx = 2; break;
 895     case 32:    idx = 4; break;
 896     case 64:    idx = 6; break;
 897     case 128:   idx = 8; break;
 898     default:    gcc_unreachable ();
 899     }
 900
 901   value = values[idx + TYPE_UNSIGNED (type)];
 902   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
 903
 904   buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
 905                          + strlen (suffix) + 1);
 906   sprintf (buf, "%s=%s%s", macro, value, suffix);
 907
 908   cpp_define (parse_in, buf);
 909 }