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