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