gcc/c-cppbuiltin.c

   1 /* Define builtin-in macros for the C family front ends.
   2    Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 2, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING.  If not, write to the Free
  18 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301, USA.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "version.h"
  27 #include "flags.h"
  28 #include "real.h"
  29 #include "c-common.h"
  30 #include "c-pragma.h"
  31 #include "output.h"
  32 #include "except.h"             /* For USING_SJLJ_EXCEPTIONS.  */
  33 #include "toplev.h"
  34 #include "tm_p.h"               /* Target prototypes.  */
  35 #include "target.h"
  36
  37 #ifndef TARGET_OS_CPP_BUILTINS
  38 # define TARGET_OS_CPP_BUILTINS()
  39 #endif
  40
  41 #ifndef TARGET_OBJFMT_CPP_BUILTINS
  42 # define TARGET_OBJFMT_CPP_BUILTINS()
  43 #endif
  44
  45 #ifndef REGISTER_PREFIX
  46 #define REGISTER_PREFIX ""
  47 #endif
  48
  49 /* Non-static as some targets don't use it.  */
  50 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
  51 static void builtin_define_with_value_n (const char *, const char *,
  52                                          size_t);
  53 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
  54 static void builtin_define_with_hex_fp_value (const char *, tree,
  55                                               int, const char *,
  56                                               const char *,
  57                                               const char *);
  58 static void builtin_define_stdint_macros (void);
  59 static void builtin_define_type_max (const char *, tree, int);
  60 static void builtin_define_type_precision (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 the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
  75    and FP_CAST. */
  76 static void
  77 builtin_define_float_constants (const char *name_prefix,
  78                                 const char *fp_suffix,
  79                                 const char *fp_cast,
  80                                 tree type)
  81 {
  82   /* Used to convert radix-based values to base 10 values in several cases.
  83
  84      In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
  85      least 6 significant digits for correct results.  Using the fraction
  86      formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
  87      intermediate; perhaps someone can find a better approximation, in the
  88      mean time, I suspect using doubles won't harm the bootstrap here.  */
  89
  90   const double log10_2 = .30102999566398119521;
  91   double log10_b;
  92   const struct real_format *fmt;
  93
  94   char name[64], buf[128];
  95   int dig, min_10_exp, max_10_exp;
  96   int decimal_dig;
  97
  98   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
  99   gcc_assert (fmt->b != 10);
 100
 101   /* The radix of the exponent representation.  */
 102   if (type == float_type_node)
 103     builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
 104   log10_b = log10_2 * fmt->log2_b;
 105
 106   /* The number of radix digits, p, in the floating-point significand.  */
 107   sprintf (name, "__%s_MANT_DIG__", name_prefix);
 108   builtin_define_with_int_value (name, fmt->p);
 109
 110   /* The number of decimal digits, q, such that any floating-point number
 111      with q decimal digits can be rounded into a floating-point number with
 112      p radix b digits and back again without change to the q decimal digits,
 113
 114         p log10 b                       if b is a power of 10
 115         floor((p - 1) log10 b)          otherwise
 116   */
 117   dig = (fmt->p - 1) * log10_b;
 118   sprintf (name, "__%s_DIG__", name_prefix);
 119   builtin_define_with_int_value (name, dig);
 120
 121   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
 122   sprintf (name, "__%s_MIN_EXP__", name_prefix);
 123   sprintf (buf, "(%d)", fmt->emin);
 124   builtin_define_with_value (name, buf, 0);
 125
 126   /* The minimum negative int x such that 10**x is a normalized float,
 127
 128           ceil (log10 (b ** (emin - 1)))
 129         = ceil (log10 (b) * (emin - 1))
 130
 131      Recall that emin is negative, so the integer truncation calculates
 132      the ceiling, not the floor, in this case.  */
 133   min_10_exp = (fmt->emin - 1) * log10_b;
 134   sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
 135   sprintf (buf, "(%d)", min_10_exp);
 136   builtin_define_with_value (name, buf, 0);
 137
 138   /* The maximum int x such that b**(x-1) is a representable float.  */
 139   sprintf (name, "__%s_MAX_EXP__", name_prefix);
 140   builtin_define_with_int_value (name, fmt->emax);
 141
 142   /* The maximum int x such that 10**x is in the range of representable
 143      finite floating-point numbers,
 144
 145           floor (log10((1 - b**-p) * b**emax))
 146         = floor (log10(1 - b**-p) + log10(b**emax))
 147         = floor (log10(1 - b**-p) + log10(b)*emax)
 148
 149      The safest thing to do here is to just compute this number.  But since
 150      we don't link cc1 with libm, we cannot.  We could implement log10 here
 151      a series expansion, but that seems too much effort because:
 152
 153      Note that the first term, for all extant p, is a number exceedingly close
 154      to zero, but slightly negative.  Note that the second term is an integer
 155      scaling an irrational number, and that because of the floor we are only
 156      interested in its integral portion.
 157
 158      In order for the first term to have any effect on the integral portion
 159      of the second term, the second term has to be exceedingly close to an
 160      integer itself (e.g. 123.000000000001 or something).  Getting a result
 161      that close to an integer requires that the irrational multiplicand have
 162      a long series of zeros in its expansion, which doesn't occur in the
 163      first 20 digits or so of log10(b).
 164
 165      Hand-waving aside, crunching all of the sets of constants above by hand
 166      does not yield a case for which the first term is significant, which
 167      in the end is all that matters.  */
 168   max_10_exp = fmt->emax * log10_b;
 169   sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
 170   builtin_define_with_int_value (name, max_10_exp);
 171
 172   /* The number of decimal digits, n, such that any floating-point number
 173      can be rounded to n decimal digits and back again without change to
 174      the value.
 175
 176         p * log10(b)                    if b is a power of 10
 177         ceil(1 + p * log10(b))          otherwise
 178
 179      The only macro we care about is this number for the widest supported
 180      floating type, but we want this value for rendering constants below.  */
 181   {
 182     double d_decimal_dig = 1 + fmt->p * log10_b;
 183     decimal_dig = d_decimal_dig;
 184     if (decimal_dig < d_decimal_dig)
 185       decimal_dig++;
 186   }
 187   if (type == long_double_type_node)
 188     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
 189
 190   /* Since, for the supported formats, B is always a power of 2, we
 191      construct the following numbers directly as a hexadecimal
 192      constants.  */
 193
 194   /* The maximum representable finite floating-point number,
 195      (1 - b**-p) * b**emax  */
 196   {
 197     int i, n;
 198     char *p;
 199
 200     strcpy (buf, "0x0.");
 201     n = fmt->p * fmt->log2_b;
 202     for (i = 0, p = buf + 4; i + 3 < n; i += 4)
 203       *p++ = 'f';
 204     if (i < n)
 205       *p++ = "08ce"[n - i];
 206     sprintf (p, "p%d", fmt->emax * fmt->log2_b);
 207     if (fmt->pnan < fmt->p)
 208       {
 209         /* This is an IBM extended double format made up of two IEEE
 210            doubles.  The value of the long double is the sum of the
 211            values of the two parts.  The most significant part is
 212            required to be the value of the long double rounded to the
 213            nearest double.  Rounding means we need a slightly smaller
 214            value for LDBL_MAX.  */
 215         buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
 216       }
 217   }
 218   sprintf (name, "__%s_MAX__", name_prefix);
 219   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 220
 221   /* The minimum normalized positive floating-point number,
 222      b**(emin-1).  */
 223   sprintf (name, "__%s_MIN__", name_prefix);
 224   sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
 225   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 226
 227   /* The difference between 1 and the least value greater than 1 that is
 228      representable in the given floating point type, b**(1-p).  */
 229   sprintf (name, "__%s_EPSILON__", name_prefix);
 230   if (fmt->pnan < fmt->p)
 231     /* This is an IBM extended double format, so 1.0 + any double is
 232        representable precisely.  */
 233       sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
 234     else
 235       sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
 236   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
 237
 238   /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
 239      positive floating-point number, b**(emin-p).  Zero for formats that
 240      don't support denormals.  */
 241   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
 242   if (fmt->has_denorm)
 243     {
 244       sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
 245       builtin_define_with_hex_fp_value (name, type, decimal_dig,
 246                                         buf, fp_suffix, fp_cast);
 247     }
 248   else
 249     {
 250       sprintf (buf, "0.0%s", fp_suffix);
 251       builtin_define_with_value (name, buf, 0);
 252     }
 253
 254   sprintf (name, "__%s_HAS_DENORM__", name_prefix);
 255   builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
 256
 257   /* For C++ std::numeric_limits<T>::has_infinity.  */
 258   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
 259   builtin_define_with_int_value (name,
 260                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
 261   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
 262      predicate to distinguish a target that has both quiet and
 263      signalling NaNs from a target that has only quiet NaNs or only
 264      signalling NaNs, so we assume that a target that has any kind of
 265      NaN has quiet NaNs.  */
 266   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
 267   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
 268 }
 269
 270 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
 271 static void
 272 builtin_define_decimal_float_constants (const char *name_prefix,
 273                                         const char *suffix,
 274                                         tree type)
 275 {
 276   const struct real_format *fmt;
 277   char name[64], buf[128], *p;
 278   int digits;
 279
 280   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
 281
 282   /* The number of radix digits, p, in the significand.  */
 283   sprintf (name, "__%s_MANT_DIG__", name_prefix);
 284   builtin_define_with_int_value (name, fmt->p);
 285
 286   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
 287   sprintf (name, "__%s_MIN_EXP__", name_prefix);
 288   sprintf (buf, "(%d)", fmt->emin);
 289   builtin_define_with_value (name, buf, 0);
 290
 291   /* The maximum int x such that b**(x-1) is a representable float.  */
 292   sprintf (name, "__%s_MAX_EXP__", name_prefix);
 293   builtin_define_with_int_value (name, fmt->emax);
 294
 295   /* Compute the minimum representable value.  */
 296   sprintf (name, "__%s_MIN__", name_prefix);
 297   sprintf (buf, "1E%d%s", fmt->emin, suffix);
 298   builtin_define_with_value (name, buf, 0);
 299
 300   /* Compute the maximum representable value.  */
 301   sprintf (name, "__%s_MAX__", name_prefix);
 302   p = buf;
 303   for (digits = fmt->p; digits; digits--)
 304     {
 305       *p++ = '9';
 306       if (digits == fmt->p)
 307         *p++ = '.';
 308     }
 309   *p = 0;
 310   /* fmt->p plus 1, to account for the decimal point.  */
 311   sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix);
 312   builtin_define_with_value (name, buf, 0);
 313
 314   /* Compute epsilon (the difference between 1 and least value greater
 315      than 1 representable).  */
 316   sprintf (name, "__%s_EPSILON__", name_prefix);
 317   sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
 318   builtin_define_with_value (name, buf, 0);
 319
 320   /* Minimum denormalized postive decimal value.  */
 321   sprintf (name, "__%s_DEN__", name_prefix);
 322   p = buf;
 323   for (digits = fmt->p; digits > 1; digits--)
 324     {
 325       *p++ = '0';
 326       if (digits == fmt->p)
 327         *p++ = '.';
 328     }
 329   *p = 0;
 330   sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix);
 331   builtin_define_with_value (name, buf, 0);
 332 }
 333
 334 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__.  */
 335 static void
 336 define__GNUC__ (void)
 337 {
 338   /* The format of the version string, enforced below, is
 339      ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
 340   const char *q, *v = version_string;
 341
 342   while (*v && !ISDIGIT (*v))
 343     v++;
 344   gcc_assert (*v && (v <= version_string || v[-1] == '-'));
 345
 346   q = v;
 347   while (ISDIGIT (*v))
 348     v++;
 349   builtin_define_with_value_n ("__GNUC__", q, v - q);
 350   if (c_dialect_cxx ())
 351     builtin_define_with_value_n ("__GNUG__", q, v - q);
 352
 353   gcc_assert (*v == '.' && ISDIGIT (v[1]));
 354
 355   q = ++v;
 356   while (ISDIGIT (*v))
 357     v++;
 358   builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
 359
 360   if (*v == '.')
 361     {
 362       gcc_assert (ISDIGIT (v[1]));
 363       q = ++v;
 364       while (ISDIGIT (*v))
 365         v++;
 366       builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
 367     }
 368   else
 369     builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
 370
 371   gcc_assert (!*v || *v == ' ' || *v == '-');
 372 }
 373
 374 /* Define macros used by <stdint.h>.  Currently only defines limits
 375    for intmax_t, used by the testsuite.  */
 376 static void
 377 builtin_define_stdint_macros (void)
 378 {
 379   int intmax_long;
 380   if (intmax_type_node == long_long_integer_type_node)
 381     intmax_long = 2;
 382   else if (intmax_type_node == long_integer_type_node)
 383     intmax_long = 1;
 384   else if (intmax_type_node == integer_type_node)
 385     intmax_long = 0;
 386   else
 387     gcc_unreachable ();
 388   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
 389 }
 390
 391 /* Hook that registers front end and target-specific built-ins.  */
 392 void
 393 c_cpp_builtins (cpp_reader *pfile)
 394 {
 395   /* -undef turns off target-specific built-ins.  */
 396   if (flag_undef)
 397     return;
 398
 399   define__GNUC__ ();
 400
 401   /* For stddef.h.  They require macros defined in c-common.c.  */
 402   c_stddef_cpp_builtins ();
 403
 404   if (c_dialect_cxx ())
 405     {
 406       if (flag_weak && SUPPORTS_ONE_ONLY)
 407         cpp_define (pfile, "__GXX_WEAK__=1");
 408       else
 409         cpp_define (pfile, "__GXX_WEAK__=0");
 410       if (warn_deprecated)
 411         cpp_define (pfile, "__DEPRECATED");
 412       if (flag_cpp0x)
 413         cpp_define (pfile, "__GXX_EXPERIMENTAL_CPP0X__");
 414     }
 415   /* Note that we define this for C as well, so that we know if
 416      __attribute__((cleanup)) will interface with EH.  */
 417   if (flag_exceptions)
 418     cpp_define (pfile, "__EXCEPTIONS");
 419
 420   /* Represents the C++ ABI version, always defined so it can be used while
 421      preprocessing C and assembler.  */
 422   if (flag_abi_version == 0)
 423     /* Use a very large value so that:
 424
 425          #if __GXX_ABI_VERSION >= <value for version X>
 426
 427        will work whether the user explicitly says "-fabi-version=x" or
 428        "-fabi-version=0".  Do not use INT_MAX because that will be
 429        different from system to system.  */
 430     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
 431   else if (flag_abi_version == 1)
 432     /* Due to a historical accident, this version had the value
 433        "102".  */
 434     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
 435   else
 436     /* Newer versions have values 1002, 1003, ....  */
 437     builtin_define_with_int_value ("__GXX_ABI_VERSION",
 438                                    1000 + flag_abi_version);
 439
 440   /* libgcc needs to know this.  */
 441   if (USING_SJLJ_EXCEPTIONS)
 442     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
 443
 444   /* limits.h needs to know these.  */
 445   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
 446   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
 447   builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
 448   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
 449   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
 450   builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
 451
 452   builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
 453
 454   /* stdint.h (eventually) and the testsuite need to know these.  */
 455   builtin_define_stdint_macros ();
 456
 457   /* float.h needs to know these.  */
 458
 459   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
 460                                  TARGET_FLT_EVAL_METHOD);
 461
 462   /* And decfloat.h needs this.  */
 463   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
 464                                  TARGET_DEC_EVAL_METHOD);
 465
 466   builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
 467   /* Cast the double precision constants when single precision constants are
 468      specified. The correct result is computed by the compiler when using
 469      macros that include a cast. This has the side-effect of making the value
 470      unusable in const expressions. */
 471   if (flag_single_precision_constant)
 472     builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
 473   else
 474     builtin_define_float_constants ("DBL", "", "%s", double_type_node);
 475   builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
 476
 477   /* For decfloat.h.  */
 478   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
 479   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
 480   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
 481
 482   /* For use in assembly language.  */
 483   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
 484   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
 485
 486   /* Misc.  */
 487   builtin_define_with_value ("__VERSION__", version_string, 1);
 488
 489   /* Definitions for LP64 model.  */
 490   if (TYPE_PRECISION (long_integer_type_node) == 64
 491       && POINTER_SIZE == 64
 492       && TYPE_PRECISION (integer_type_node) == 32)
 493     {
 494       cpp_define (pfile, "_LP64");
 495       cpp_define (pfile, "__LP64__");
 496     }
 497
 498   /* Other target-independent built-ins determined by command-line
 499      options.  */
 500   if (optimize_size)
 501     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 502   if (optimize)
 503     cpp_define (pfile, "__OPTIMIZE__");
 504
 505   if (fast_math_flags_set_p ())
 506     cpp_define (pfile, "__FAST_MATH__");
 507   if (flag_really_no_inline)
 508     cpp_define (pfile, "__NO_INLINE__");
 509   if (flag_signaling_nans)
 510     cpp_define (pfile, "__SUPPORT_SNAN__");
 511   if (flag_finite_math_only)
 512     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 513   else
 514     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 515   if (flag_pic)
 516     {
 517       builtin_define_with_int_value ("__pic__", flag_pic);
 518       builtin_define_with_int_value ("__PIC__", flag_pic);
 519     }
 520
 521   if (flag_iso)
 522     cpp_define (pfile, "__STRICT_ANSI__");
 523
 524   if (!flag_signed_char)
 525     cpp_define (pfile, "__CHAR_UNSIGNED__");
 526
 527   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
 528     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 529
 530   /* Make the choice of ObjC runtime visible to source code.  */
 531   if (c_dialect_objc () && flag_next_runtime)
 532     cpp_define (pfile, "__NEXT_RUNTIME__");
 533
 534   /* Show the availability of some target pragmas.  */
 535   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
 536     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
 537
 538   if (targetm.handle_pragma_extern_prefix)
 539     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
 540
 541   /* Make the choice of the stack protector runtime visible to source code.
 542      The macro names and values here were chosen for compatibility with an
 543      earlier implementation, i.e. ProPolice.  */
 544   if (flag_stack_protect == 2)
 545     cpp_define (pfile, "__SSP_ALL__=2");
 546   else if (flag_stack_protect == 1)
 547     cpp_define (pfile, "__SSP__=1");
 548
 549   if (flag_openmp)
 550     cpp_define (pfile, "_OPENMP=200505");
 551
 552   /* A straightforward target hook doesn't work, because of problems
 553      linking that hook's body when part of non-C front ends.  */
 554 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 555 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 556 # define builtin_define(TXT) cpp_define (pfile, TXT)
 557 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 558   TARGET_CPU_CPP_BUILTINS ();
 559   TARGET_OS_CPP_BUILTINS ();
 560   TARGET_OBJFMT_CPP_BUILTINS ();
 561
 562   /* Support the __declspec keyword by turning them into attributes.
 563      Note that the current way we do this may result in a collision
 564      with predefined attributes later on.  This can be solved by using
 565      one attribute, say __declspec__, and passing args to it.  The
 566      problem with that approach is that args are not accumulated: each
 567      new appearance would clobber any existing args.  */
 568   if (TARGET_DECLSPEC)
 569     builtin_define ("__declspec(x)=__attribute__((x))");
 570 }
 571
 572 /* Pass an object-like macro.  If it doesn't lie in the user's
 573    namespace, defines it unconditionally.  Otherwise define a version
 574    with two leading underscores, and another version with two leading
 575    and trailing underscores, and define the original only if an ISO
 576    standard was not nominated.
 577
 578    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 579    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 580    "_mips".  */
 581 void
 582 builtin_define_std (const char *macro)
 583 {
 584   size_t len = strlen (macro);
 585   char *buff = (char *) alloca (len + 5);
 586   char *p = buff + 2;
 587   char *q = p + len;
 588
 589   /* prepend __ (or maybe just _) if in user's namespace.  */
 590   memcpy (p, macro, len + 1);
 591   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 592     {
 593       if (*p != '_')
 594         *--p = '_';
 595       if (p[1] != '_')
 596         *--p = '_';
 597     }
 598   cpp_define (parse_in, p);
 599
 600   /* If it was in user's namespace...  */
 601   if (p != buff + 2)
 602     {
 603       /* Define the macro with leading and following __.  */
 604       if (q[-1] != '_')
 605         *q++ = '_';
 606       if (q[-2] != '_')
 607         *q++ = '_';
 608       *q = '\0';
 609       cpp_define (parse_in, p);
 610
 611       /* Finally, define the original macro if permitted.  */
 612       if (!flag_iso)
 613         cpp_define (parse_in, macro);
 614     }
 615 }
 616
 617 /* Pass an object-like macro and a value to define it to.  The third
 618    parameter says whether or not to turn the value into a string
 619    constant.  */
 620 void
 621 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 622 {
 623   char *buf;
 624   size_t mlen = strlen (macro);
 625   size_t elen = strlen (expansion);
 626   size_t extra = 2;  /* space for an = and a NUL */
 627
 628   if (is_str)
 629     extra += 2;  /* space for two quote marks */
 630
 631   buf = (char *) alloca (mlen + elen + extra);
 632   if (is_str)
 633     sprintf (buf, "%s=\"%s\"", macro, expansion);
 634   else
 635     sprintf (buf, "%s=%s", macro, expansion);
 636
 637   cpp_define (parse_in, buf);
 638 }
 639
 640 /* Pass an object-like macro and a value to define it to.  The third
 641    parameter is the length of the expansion.  */
 642 static void
 643 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 644 {
 645   char *buf;
 646   size_t mlen = strlen (macro);
 647
 648   /* Space for an = and a NUL.  */
 649   buf = (char *) alloca (mlen + elen + 2);
 650   memcpy (buf, macro, mlen);
 651   buf[mlen] = '=';
 652   memcpy (buf + mlen + 1, expansion, elen);
 653   buf[mlen + elen + 1] = '\0';
 654
 655   cpp_define (parse_in, buf);
 656 }
 657
 658 /* Pass an object-like macro and an integer value to define it to.  */
 659 static void
 660 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 661 {
 662   char *buf;
 663   size_t mlen = strlen (macro);
 664   size_t vlen = 18;
 665   size_t extra = 2; /* space for = and NUL.  */
 666
 667   buf = (char *) alloca (mlen + vlen + extra);
 668   memcpy (buf, macro, mlen);
 669   buf[mlen] = '=';
 670   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 671
 672   cpp_define (parse_in, buf);
 673 }
 674
 675 /* Pass an object-like macro a hexadecimal floating-point value.  */
 676 static void
 677 builtin_define_with_hex_fp_value (const char *macro,
 678                                   tree type ATTRIBUTE_UNUSED, int digits,
 679                                   const char *hex_str,
 680                                   const char *fp_suffix,
 681                                   const char *fp_cast)
 682 {
 683   REAL_VALUE_TYPE real;
 684   char dec_str[64], buf1[256], buf2[256];
 685
 686   /* Hex values are really cool and convenient, except that they're
 687      not supported in strict ISO C90 mode.  First, the "p-" sequence
 688      is not valid as part of a preprocessor number.  Second, we get a
 689      pedwarn from the preprocessor, which has no context, so we can't
 690      suppress the warning with __extension__.
 691
 692      So instead what we do is construct the number in hex (because
 693      it's easy to get the exact correct value), parse it as a real,
 694      then print it back out as decimal.  */
 695
 696   real_from_string (&real, hex_str);
 697   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 698
 699   /* Assemble the macro in the following fashion
 700      macro = fp_cast [dec_str fp_suffix] */
 701   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 702   sprintf (buf2, fp_cast, buf1);
 703   sprintf (buf1, "%s=%s", macro, buf2);
 704
 705   cpp_define (parse_in, buf1);
 706 }
 707
 708 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 709    1 for type "long" and 2 for "long long".  We have to handle
 710    unsigned types, since wchar_t might be unsigned.  */
 711
 712 static void
 713 builtin_define_type_max (const char *macro, tree type, int is_long)
 714 {
 715   static const char *const values[]
 716     = { "127", "255",
 717         "32767", "65535",
 718         "2147483647", "4294967295",
 719         "9223372036854775807", "18446744073709551615",
 720         "170141183460469231731687303715884105727",
 721         "340282366920938463463374607431768211455" };
 722   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 723
 724   const char *value, *suffix;
 725   char *buf;
 726   size_t idx;
 727
 728   /* Pre-rendering the values mean we don't have to futz with printing a
 729      multi-word decimal value.  There are also a very limited number of
 730      precisions that we support, so it's really a waste of time.  */
 731   switch (TYPE_PRECISION (type))
 732     {
 733     case 8:     idx = 0; break;
 734     case 16:    idx = 2; break;
 735     case 32:    idx = 4; break;
 736     case 64:    idx = 6; break;
 737     case 128:   idx = 8; break;
 738     default:    gcc_unreachable ();
 739     }
 740
 741   value = values[idx + TYPE_UNSIGNED (type)];
 742   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
 743
 744   buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
 745                          + strlen (suffix) + 1);
 746   sprintf (buf, "%s=%s%s", macro, value, suffix);
 747
 748   cpp_define (parse_in, buf);
 749 }