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   /* A straightforward target hook doesn't work, because of problems
 548      linking that hook's body when part of non-C front ends.  */
 549 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 550 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 551 # define builtin_define(TXT) cpp_define (pfile, TXT)
 552 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 553   TARGET_CPU_CPP_BUILTINS ();
 554   TARGET_OS_CPP_BUILTINS ();
 555   TARGET_OBJFMT_CPP_BUILTINS ();
 556
 557   /* Support the __declspec keyword by turning them into attributes.
 558      Note that the current way we do this may result in a collision
 559      with predefined attributes later on.  This can be solved by using
 560      one attribute, say __declspec__, and passing args to it.  The
 561      problem with that approach is that args are not accumulated: each
 562      new appearance would clobber any existing args.  */
 563   if (TARGET_DECLSPEC)
 564     builtin_define ("__declspec(x)=__attribute__((x))");
 565 }
 566
 567 /* Pass an object-like macro.  If it doesn't lie in the user's
 568    namespace, defines it unconditionally.  Otherwise define a version
 569    with two leading underscores, and another version with two leading
 570    and trailing underscores, and define the original only if an ISO
 571    standard was not nominated.
 572
 573    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 574    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 575    "_mips".  */
 576 void
 577 builtin_define_std (const char *macro)
 578 {
 579   size_t len = strlen (macro);
 580   char *buff = (char *) alloca (len + 5);
 581   char *p = buff + 2;
 582   char *q = p + len;
 583
 584   /* prepend __ (or maybe just _) if in user's namespace.  */
 585   memcpy (p, macro, len + 1);
 586   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 587     {
 588       if (*p != '_')
 589         *--p = '_';
 590       if (p[1] != '_')
 591         *--p = '_';
 592     }
 593   cpp_define (parse_in, p);
 594
 595   /* If it was in user's namespace...  */
 596   if (p != buff + 2)
 597     {
 598       /* Define the macro with leading and following __.  */
 599       if (q[-1] != '_')
 600         *q++ = '_';
 601       if (q[-2] != '_')
 602         *q++ = '_';
 603       *q = '\0';
 604       cpp_define (parse_in, p);
 605
 606       /* Finally, define the original macro if permitted.  */
 607       if (!flag_iso)
 608         cpp_define (parse_in, macro);
 609     }
 610 }
 611
 612 /* Pass an object-like macro and a value to define it to.  The third
 613    parameter says whether or not to turn the value into a string
 614    constant.  */
 615 void
 616 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 617 {
 618   char *buf;
 619   size_t mlen = strlen (macro);
 620   size_t elen = strlen (expansion);
 621   size_t extra = 2;  /* space for an = and a NUL */
 622
 623   if (is_str)
 624     extra += 2;  /* space for two quote marks */
 625
 626   buf = (char *) alloca (mlen + elen + extra);
 627   if (is_str)
 628     sprintf (buf, "%s=\"%s\"", macro, expansion);
 629   else
 630     sprintf (buf, "%s=%s", macro, expansion);
 631
 632   cpp_define (parse_in, buf);
 633 }
 634
 635 /* Pass an object-like macro and a value to define it to.  The third
 636    parameter is the length of the expansion.  */
 637 static void
 638 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 639 {
 640   char *buf;
 641   size_t mlen = strlen (macro);
 642
 643   /* Space for an = and a NUL.  */
 644   buf = (char *) alloca (mlen + elen + 2);
 645   memcpy (buf, macro, mlen);
 646   buf[mlen] = '=';
 647   memcpy (buf + mlen + 1, expansion, elen);
 648   buf[mlen + elen + 1] = '\0';
 649
 650   cpp_define (parse_in, buf);
 651 }
 652
 653 /* Pass an object-like macro and an integer value to define it to.  */
 654 static void
 655 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 656 {
 657   char *buf;
 658   size_t mlen = strlen (macro);
 659   size_t vlen = 18;
 660   size_t extra = 2; /* space for = and NUL.  */
 661
 662   buf = (char *) alloca (mlen + vlen + extra);
 663   memcpy (buf, macro, mlen);
 664   buf[mlen] = '=';
 665   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 666
 667   cpp_define (parse_in, buf);
 668 }
 669
 670 /* Pass an object-like macro a hexadecimal floating-point value.  */
 671 static void
 672 builtin_define_with_hex_fp_value (const char *macro,
 673                                   tree type ATTRIBUTE_UNUSED, int digits,
 674                                   const char *hex_str,
 675                                   const char *fp_suffix,
 676                                   const char *fp_cast)
 677 {
 678   REAL_VALUE_TYPE real;
 679   char dec_str[64], buf1[256], buf2[256];
 680
 681   /* Hex values are really cool and convenient, except that they're
 682      not supported in strict ISO C90 mode.  First, the "p-" sequence
 683      is not valid as part of a preprocessor number.  Second, we get a
 684      pedwarn from the preprocessor, which has no context, so we can't
 685      suppress the warning with __extension__.
 686
 687      So instead what we do is construct the number in hex (because
 688      it's easy to get the exact correct value), parse it as a real,
 689      then print it back out as decimal.  */
 690
 691   real_from_string (&real, hex_str);
 692   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 693
 694   /* Assemble the macro in the following fashion
 695      macro = fp_cast [dec_str fp_suffix] */
 696   sprintf (buf1, "%s%s", dec_str, fp_suffix);
 697   sprintf (buf2, fp_cast, buf1);
 698   sprintf (buf1, "%s=%s", macro, buf2);
 699
 700   cpp_define (parse_in, buf1);
 701 }
 702
 703 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 704    1 for type "long" and 2 for "long long".  We have to handle
 705    unsigned types, since wchar_t might be unsigned.  */
 706
 707 static void
 708 builtin_define_type_max (const char *macro, tree type, int is_long)
 709 {
 710   static const char *const values[]
 711     = { "127", "255",
 712         "32767", "65535",
 713         "2147483647", "4294967295",
 714         "9223372036854775807", "18446744073709551615",
 715         "170141183460469231731687303715884105727",
 716         "340282366920938463463374607431768211455" };
 717   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 718
 719   const char *value, *suffix;
 720   char *buf;
 721   size_t idx;
 722
 723   /* Pre-rendering the values mean we don't have to futz with printing a
 724      multi-word decimal value.  There are also a very limited number of
 725      precisions that we support, so it's really a waste of time.  */
 726   switch (TYPE_PRECISION (type))
 727     {
 728     case 8:     idx = 0; break;
 729     case 16:    idx = 2; break;
 730     case 32:    idx = 4; break;
 731     case 64:    idx = 6; break;
 732     case 128:   idx = 8; break;
 733     default:    gcc_unreachable ();
 734     }
 735
 736   value = values[idx + TYPE_UNSIGNED (type)];
 737   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
 738
 739   buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
 740                          + strlen (suffix) + 1);
 741   sprintf (buf, "%s=%s%s", macro, value, suffix);
 742
 743   cpp_define (parse_in, buf);
 744 }