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