gcc/c-cppbuiltin.c

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