gcc/c-cppbuiltin.c

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