gcc/c-cppbuiltin.c

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