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
 431 /* Pass an object-like macro.  If it doesn't lie in the user's
 432    namespace, defines it unconditionally.  Otherwise define a version
 433    with two leading underscores, and another version with two leading
 434    and trailing underscores, and define the original only if an ISO
 435    standard was not nominated.
 436
 437    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 438    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 439    "_mips".  */
 440 void
 441 builtin_define_std (const char *macro)
 442 {
 443   size_t len = strlen (macro);
 444   char *buff = alloca (len + 5);
 445   char *p = buff + 2;
 446   char *q = p + len;
 447
 448   /* prepend __ (or maybe just _) if in user's namespace.  */
 449   memcpy (p, macro, len + 1);
 450   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 451     {
 452       if (*p != '_')
 453         *--p = '_';
 454       if (p[1] != '_')
 455         *--p = '_';
 456     }
 457   cpp_define (parse_in, p);
 458
 459   /* If it was in user's namespace...  */
 460   if (p != buff + 2)
 461     {
 462       /* Define the macro with leading and following __.  */
 463       if (q[-1] != '_')
 464         *q++ = '_';
 465       if (q[-2] != '_')
 466         *q++ = '_';
 467       *q = '\0';
 468       cpp_define (parse_in, p);
 469
 470       /* Finally, define the original macro if permitted.  */
 471       if (!flag_iso)
 472         cpp_define (parse_in, macro);
 473     }
 474 }
 475
 476 /* Pass an object-like macro and a value to define it to.  The third
 477    parameter says whether or not to turn the value into a string
 478    constant.  */
 479 void
 480 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 481 {
 482   char *buf;
 483   size_t mlen = strlen (macro);
 484   size_t elen = strlen (expansion);
 485   size_t extra = 2;  /* space for an = and a NUL */
 486
 487   if (is_str)
 488     extra += 2;  /* space for two quote marks */
 489
 490   buf = alloca (mlen + elen + extra);
 491   if (is_str)
 492     sprintf (buf, "%s=\"%s\"", macro, expansion);
 493   else
 494     sprintf (buf, "%s=%s", macro, expansion);
 495
 496   cpp_define (parse_in, buf);
 497 }
 498
 499 /* Pass an object-like macro and a value to define it to.  The third
 500    parameter is the length of the expansion.  */
 501 static void
 502 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 503 {
 504   char *buf;
 505   size_t mlen = strlen (macro);
 506
 507   /* Space for an = and a NUL.  */
 508   buf = alloca (mlen + elen + 2);
 509   memcpy (buf, macro, mlen);
 510   buf[mlen] = '=';
 511   memcpy (buf + mlen + 1, expansion, elen);
 512   buf[mlen + elen + 1] = '\0';
 513
 514   cpp_define (parse_in, buf);
 515 }
 516
 517 /* Pass an object-like macro and an integer value to define it to.  */
 518 static void
 519 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 520 {
 521   char *buf;
 522   size_t mlen = strlen (macro);
 523   size_t vlen = 18;
 524   size_t extra = 2; /* space for = and NUL.  */
 525
 526   buf = alloca (mlen + vlen + extra);
 527   memcpy (buf, macro, mlen);
 528   buf[mlen] = '=';
 529   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 530
 531   cpp_define (parse_in, buf);
 532 }
 533
 534 /* Pass an object-like macro a hexadecimal floating-point value.  */
 535 static void
 536 builtin_define_with_hex_fp_value (const char *macro,
 537                                   tree type ATTRIBUTE_UNUSED, int digits,
 538                                   const char *hex_str, const char *fp_suffix)
 539 {
 540   REAL_VALUE_TYPE real;
 541   char dec_str[64], buf[256];
 542
 543   /* Hex values are really cool and convenient, except that they're
 544      not supported in strict ISO C90 mode.  First, the "p-" sequence
 545      is not valid as part of a preprocessor number.  Second, we get a
 546      pedwarn from the preprocessor, which has no context, so we can't
 547      suppress the warning with __extension__.
 548
 549      So instead what we do is construct the number in hex (because
 550      it's easy to get the exact correct value), parse it as a real,
 551      then print it back out as decimal.  */
 552
 553   real_from_string (&real, hex_str);
 554   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 555
 556   sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
 557   cpp_define (parse_in, buf);
 558 }
 559
 560 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 561    1 for type "long" and 2 for "long long".  We have to handle
 562    unsigned types, since wchar_t might be unsigned.  */
 563
 564 static void
 565 builtin_define_type_max (const char *macro, tree type, int is_long)
 566 {
 567   static const char *const values[]
 568     = { "127", "255",
 569         "32767", "65535",
 570         "2147483647", "4294967295",
 571         "9223372036854775807", "18446744073709551615",
 572         "170141183460469231731687303715884105727",
 573         "340282366920938463463374607431768211455" };
 574   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 575
 576   const char *value, *suffix;
 577   char *buf;
 578   size_t idx;
 579
 580   /* Pre-rendering the values mean we don't have to futz with printing a
 581      multi-word decimal value.  There are also a very limited number of
 582      precisions that we support, so it's really a waste of time.  */
 583   switch (TYPE_PRECISION (type))
 584     {
 585     case 8:     idx = 0; break;
 586     case 16:    idx = 2; break;
 587     case 32:    idx = 4; break;
 588     case 64:    idx = 6; break;
 589     case 128:   idx = 8; break;
 590     default:    abort ();
 591     }
 592
 593   value = values[idx + TYPE_UNSIGNED (type)];
 594   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
 595
 596   buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
 597   sprintf (buf, "%s=%s%s", macro, value, suffix);
 598
 599   cpp_define (parse_in, buf);
 600 }