contrib/gcc-4.4/gcc/c-cppbuiltin.c

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