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