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