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