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