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