gcc/c-cppbuiltin.c

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