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