contrib/gcc/c-cppbuiltin.c

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