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