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