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   }
 197   sprintf (name, "__%s_MAX__", name_prefix);
 198   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
 199
 200   /* The minimum normalized positive floating-point number,
 201      b**(emin-1).  */
 202   sprintf (name, "__%s_MIN__", name_prefix);
 203   sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
 204   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
 205
 206   /* The difference between 1 and the least value greater than 1 that is
 207      representable in the given floating point type, b**(1-p).  */
 208   sprintf (name, "__%s_EPSILON__", name_prefix);
 209   sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
 210   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
 211
 212   /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
 213      positive floating-point number, b**(emin-p).  Zero for formats that
 214      don't support denormals.  */
 215   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
 216   if (fmt->has_denorm)
 217     {
 218       sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
 219       builtin_define_with_hex_fp_value (name, type, decimal_dig,
 220                                         buf, fp_suffix);
 221     }
 222   else
 223     {
 224       sprintf (buf, "0.0%s", fp_suffix);
 225       builtin_define_with_value (name, buf, 0);
 226     }
 227
 228   /* For C++ std::numeric_limits<T>::has_infinity.  */
 229   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
 230   builtin_define_with_int_value (name,
 231                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
 232   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
 233      predicate to distinguish a target that has both quiet and
 234      signalling NaNs from a target that has only quiet NaNs or only
 235      signalling NaNs, so we assume that a target that has any kind of
 236      NaN has quiet NaNs.  */
 237   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
 238   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
 239 }
 240
 241 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__.  */
 242 static void
 243 define__GNUC__ (void)
 244 {
 245   /* The format of the version string, enforced below, is
 246      ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
 247   const char *q, *v = version_string;
 248
 249   while (*v && ! ISDIGIT (*v))
 250     v++;
 251   if (!*v || (v > version_string && v[-1] != '-'))
 252     abort ();
 253
 254   q = v;
 255   while (ISDIGIT (*v))
 256     v++;
 257   builtin_define_with_value_n ("__GNUC__", q, v - q);
 258   if (c_dialect_cxx ())
 259     builtin_define_with_value_n ("__GNUG__", q, v - q);
 260
 261   if (*v != '.' || !ISDIGIT (v[1]))
 262     abort ();
 263   q = ++v;
 264   while (ISDIGIT (*v))
 265     v++;
 266   builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
 267
 268   if (*v == '.')
 269     {
 270       if (!ISDIGIT (v[1]))
 271         abort ();
 272       q = ++v;
 273       while (ISDIGIT (*v))
 274         v++;
 275       builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
 276     }
 277   else
 278     builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
 279
 280   if (*v && *v != ' ' && *v != '-')
 281     abort ();
 282 }
 283
 284 /* Hook that registers front end and target-specific built-ins.  */
 285 void
 286 c_cpp_builtins (cpp_reader *pfile)
 287 {
 288   /* -undef turns off target-specific built-ins.  */
 289   if (flag_undef)
 290     return;
 291
 292   define__GNUC__ ();
 293
 294   /* For stddef.h.  They require macros defined in c-common.c.  */
 295   c_stddef_cpp_builtins ();
 296
 297   if (c_dialect_cxx ())
 298     {
 299       if (SUPPORTS_ONE_ONLY)
 300         cpp_define (pfile, "__GXX_WEAK__=1");
 301       else
 302         cpp_define (pfile, "__GXX_WEAK__=0");
 303       if (warn_deprecated)
 304         cpp_define (pfile, "__DEPRECATED");
 305     }
 306   /* Note that we define this for C as well, so that we know if
 307      __attribute__((cleanup)) will interface with EH.  */
 308   if (flag_exceptions)
 309     cpp_define (pfile, "__EXCEPTIONS");
 310
 311   /* Represents the C++ ABI version, always defined so it can be used while
 312      preprocessing C and assembler.  */
 313   if (flag_abi_version == 0)
 314     /* Use a very large value so that:
 315
 316          #if __GXX_ABI_VERSION >= <value for version X>
 317
 318        will work whether the user explicitly says "-fabi-version=x" or
 319        "-fabi-version=0".  Do not use INT_MAX because that will be
 320        different from system to system.  */
 321     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
 322   else if (flag_abi_version == 1)
 323     /* Due to an historical accident, this version had the value
 324        "102".  */
 325     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
 326   else
 327     /* Newer versions have values 1002, 1003, ....  */
 328     builtin_define_with_int_value ("__GXX_ABI_VERSION",
 329                                    1000 + flag_abi_version);
 330
 331   /* libgcc needs to know this.  */
 332   if (USING_SJLJ_EXCEPTIONS)
 333     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
 334
 335   /* limits.h needs to know these.  */
 336   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
 337   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
 338   builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
 339   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
 340   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
 341   builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
 342
 343   builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
 344
 345   /* float.h needs to know these.  */
 346
 347   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
 348                                  TARGET_FLT_EVAL_METHOD);
 349
 350   builtin_define_float_constants ("FLT", "F", float_type_node);
 351   builtin_define_float_constants ("DBL", "", double_type_node);
 352   builtin_define_float_constants ("LDBL", "L", long_double_type_node);
 353
 354   /* For use in assembly language.  */
 355   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
 356   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
 357
 358   /* Misc.  */
 359   builtin_define_with_value ("__VERSION__", version_string, 1);
 360
 361   /* Definitions for LP64 model.  */
 362   if (TYPE_PRECISION (long_integer_type_node) == 64
 363       && POINTER_SIZE == 64
 364       && TYPE_PRECISION (integer_type_node) == 32)
 365     {
 366       cpp_define (pfile, "_LP64");
 367       cpp_define (pfile, "__LP64__");
 368     }
 369
 370   /* Other target-independent built-ins determined by command-line
 371      options.  */
 372   if (optimize_size)
 373     cpp_define (pfile, "__OPTIMIZE_SIZE__");
 374   if (optimize)
 375     cpp_define (pfile, "__OPTIMIZE__");
 376
 377   if (fast_math_flags_set_p ())
 378     cpp_define (pfile, "__FAST_MATH__");
 379   if (flag_really_no_inline)
 380     cpp_define (pfile, "__NO_INLINE__");
 381   if (flag_signaling_nans)
 382     cpp_define (pfile, "__SUPPORT_SNAN__");
 383   if (flag_finite_math_only)
 384     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
 385   else
 386     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
 387
 388   if (flag_iso)
 389     cpp_define (pfile, "__STRICT_ANSI__");
 390
 391   if (!flag_signed_char)
 392     cpp_define (pfile, "__CHAR_UNSIGNED__");
 393
 394   if (c_dialect_cxx () && TREE_UNSIGNED (wchar_type_node))
 395     cpp_define (pfile, "__WCHAR_UNSIGNED__");
 396
 397   /* Make the choice of ObjC runtime visible to source code.  */
 398   if (c_dialect_objc () && flag_next_runtime)
 399     cpp_define (pfile, "__NEXT_RUNTIME__");
 400
 401   /* A straightforward target hook doesn't work, because of problems
 402      linking that hook's body when part of non-C front ends.  */
 403 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
 404 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
 405 # define builtin_define(TXT) cpp_define (pfile, TXT)
 406 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 407   TARGET_CPU_CPP_BUILTINS ();
 408   TARGET_OS_CPP_BUILTINS ();
 409   TARGET_OBJFMT_CPP_BUILTINS ();
 410 }
 411
 412 /* Pass an object-like macro.  If it doesn't lie in the user's
 413    namespace, defines it unconditionally.  Otherwise define a version
 414    with two leading underscores, and another version with two leading
 415    and trailing underscores, and define the original only if an ISO
 416    standard was not nominated.
 417
 418    e.g. passing "unix" defines "__unix", "__unix__" and possibly
 419    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
 420    "_mips".  */
 421 void
 422 builtin_define_std (const char *macro)
 423 {
 424   size_t len = strlen (macro);
 425   char *buff = alloca (len + 5);
 426   char *p = buff + 2;
 427   char *q = p + len;
 428
 429   /* prepend __ (or maybe just _) if in user's namespace.  */
 430   memcpy (p, macro, len + 1);
 431   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
 432     {
 433       if (*p != '_')
 434         *--p = '_';
 435       if (p[1] != '_')
 436         *--p = '_';
 437     }
 438   cpp_define (parse_in, p);
 439
 440   /* If it was in user's namespace...  */
 441   if (p != buff + 2)
 442     {
 443       /* Define the macro with leading and following __.  */
 444       if (q[-1] != '_')
 445         *q++ = '_';
 446       if (q[-2] != '_')
 447         *q++ = '_';
 448       *q = '\0';
 449       cpp_define (parse_in, p);
 450
 451       /* Finally, define the original macro if permitted.  */
 452       if (!flag_iso)
 453         cpp_define (parse_in, macro);
 454     }
 455 }
 456
 457 /* Pass an object-like macro and a value to define it to.  The third
 458    parameter says whether or not to turn the value into a string
 459    constant.  */
 460 void
 461 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
 462 {
 463   char *buf;
 464   size_t mlen = strlen (macro);
 465   size_t elen = strlen (expansion);
 466   size_t extra = 2;  /* space for an = and a NUL */
 467
 468   if (is_str)
 469     extra += 2;  /* space for two quote marks */
 470
 471   buf = alloca (mlen + elen + extra);
 472   if (is_str)
 473     sprintf (buf, "%s=\"%s\"", macro, expansion);
 474   else
 475     sprintf (buf, "%s=%s", macro, expansion);
 476
 477   cpp_define (parse_in, buf);
 478 }
 479
 480 /* Pass an object-like macro and a value to define it to.  The third
 481    parameter is the length of the expansion.  */
 482 static void
 483 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
 484 {
 485   char *buf;
 486   size_t mlen = strlen (macro);
 487
 488   /* Space for an = and a NUL.  */
 489   buf = alloca (mlen + elen + 2);
 490   memcpy (buf, macro, mlen);
 491   buf[mlen] = '=';
 492   memcpy (buf + mlen + 1, expansion, elen);
 493   buf[mlen + elen + 1] = '\0';
 494
 495   cpp_define (parse_in, buf);
 496 }
 497
 498 /* Pass an object-like macro and an integer value to define it to.  */
 499 static void
 500 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
 501 {
 502   char *buf;
 503   size_t mlen = strlen (macro);
 504   size_t vlen = 18;
 505   size_t extra = 2; /* space for = and NUL.  */
 506
 507   buf = alloca (mlen + vlen + extra);
 508   memcpy (buf, macro, mlen);
 509   buf[mlen] = '=';
 510   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
 511
 512   cpp_define (parse_in, buf);
 513 }
 514
 515 /* Pass an object-like macro a hexadecimal floating-point value.  */
 516 static void
 517 builtin_define_with_hex_fp_value (const char *macro,
 518                                   tree type ATTRIBUTE_UNUSED, int digits,
 519                                   const char *hex_str, const char *fp_suffix)
 520 {
 521   REAL_VALUE_TYPE real;
 522   char dec_str[64], buf[256];
 523
 524   /* Hex values are really cool and convenient, except that they're
 525      not supported in strict ISO C90 mode.  First, the "p-" sequence
 526      is not valid as part of a preprocessor number.  Second, we get a
 527      pedwarn from the preprocessor, which has no context, so we can't
 528      suppress the warning with __extension__.
 529
 530      So instead what we do is construct the number in hex (because
 531      it's easy to get the exact correct value), parse it as a real,
 532      then print it back out as decimal.  */
 533
 534   real_from_string (&real, hex_str);
 535   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
 536
 537   sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
 538   cpp_define (parse_in, buf);
 539 }
 540
 541 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
 542    1 for type "long" and 2 for "long long".  We have to handle
 543    unsigned types, since wchar_t might be unsigned.  */
 544
 545 static void
 546 builtin_define_type_max (const char *macro, tree type, int is_long)
 547 {
 548   static const char *const values[]
 549     = { "127", "255",
 550         "32767", "65535",
 551         "2147483647", "4294967295",
 552         "9223372036854775807", "18446744073709551615",
 553         "170141183460469231731687303715884105727",
 554         "340282366920938463463374607431768211455" };
 555   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
 556
 557   const char *value, *suffix;
 558   char *buf;
 559   size_t idx;
 560
 561   /* Pre-rendering the values mean we don't have to futz with printing a
 562      multi-word decimal value.  There are also a very limited number of
 563      precisions that we support, so it's really a waste of time.  */
 564   switch (TYPE_PRECISION (type))
 565     {
 566     case 8:     idx = 0; break;
 567     case 16:    idx = 2; break;
 568     case 32:    idx = 4; break;
 569     case 64:    idx = 6; break;
 570     case 128:   idx = 8; break;
 571     default:    abort ();
 572     }
 573
 574   value = values[idx + TREE_UNSIGNED (type)];
 575   suffix = suffixes[is_long * 2 + TREE_UNSIGNED (type)];
 576
 577   buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
 578   sprintf (buf, "%s=%s%s", macro, value, suffix);
 579
 580   cpp_define (parse_in, buf);
 581 }