1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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
23 #include "coretypes.h"
32 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
34 #include "tm_p.h" /* Target prototypes. */
36 #ifndef TARGET_OS_CPP_BUILTINS
37 # define TARGET_OS_CPP_BUILTINS()
40 #ifndef TARGET_OBJFMT_CPP_BUILTINS
41 # define TARGET_OBJFMT_CPP_BUILTINS()
44 #ifndef REGISTER_PREFIX
45 #define REGISTER_PREFIX ""
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 *,
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,
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 *,
60 static void define__GNUC__ (void);
62 /* Define NAME with value TYPE precision. */
64 builtin_define_type_precision (const char *name, tree type)
66 builtin_define_with_int_value (name, TYPE_PRECISION (type));
69 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
71 builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, tree type)
73 /* Used to convert radix-based values to base 10 values in several cases.
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. */
81 const double log10_2 = .30102999566398119521;
83 const struct real_format *fmt;
85 char name[64], buf[128];
86 int dig, min_10_exp, max_10_exp;
89 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
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;
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);
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,
104 p log10 b if b is a power of 10
105 floor((p - 1) log10 b) otherwise
107 dig = (fmt->p - 1) * log10_b;
108 sprintf (name, "__%s_DIG__", name_prefix);
109 builtin_define_with_int_value (name, dig);
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);
116 /* The minimum negative int x such that 10**x is a normalized float,
118 ceil (log10 (b ** (emin - 1)))
119 = ceil (log10 (b) * (emin - 1))
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);
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);
132 /* The maximum int x such that 10**x is in the range of representable
133 finite floating-point numbers,
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)
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:
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.
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).
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);
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
166 p * log10(b) if b is a power of 10
167 ceil(1 + p * log10(b)) otherwise
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. */
172 double d_decimal_dig = 1 + fmt->p * log10_b;
173 decimal_dig = d_decimal_dig;
174 if (decimal_dig < d_decimal_dig)
177 if (type == long_double_type_node)
178 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
180 /* Since, for the supported formats, B is always a power of 2, we
181 construct the following numbers directly as a hexadecimal
184 /* The maximum representable finite floating-point number,
185 (1 - b**-p) * b**emax */
190 strcpy (buf, "0x0.");
191 n = fmt->p * fmt->log2_b;
192 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
195 *p++ = "08ce"[n - i];
196 sprintf (p, "p%d", fmt->emax * fmt->log2_b);
197 if (fmt->pnan < fmt->p)
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];
208 sprintf (name, "__%s_MAX__", name_prefix);
209 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix);
211 /* The minimum normalized positive floating-point number,
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);
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);
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);
229 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
230 builtin_define_with_hex_fp_value (name, type, decimal_dig,
235 sprintf (buf, "0.0%s", fp_suffix);
236 builtin_define_with_value (name, buf, 0);
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)));
252 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
254 define__GNUC__ (void)
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;
260 while (*v && ! ISDIGIT (*v))
262 if (!*v || (v > version_string && v[-1] != '-'))
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);
272 if (*v != '.' || !ISDIGIT (v[1]))
277 builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
286 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
289 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
291 if (*v && *v != ' ' && *v != '-')
295 /* Hook that registers front end and target-specific built-ins. */
297 c_cpp_builtins (cpp_reader *pfile)
299 /* -undef turns off target-specific built-ins. */
305 /* For stddef.h. They require macros defined in c-common.c. */
306 c_stddef_cpp_builtins ();
308 if (c_dialect_cxx ())
310 if (SUPPORTS_ONE_ONLY)
311 cpp_define (pfile, "__GXX_WEAK__=1");
313 cpp_define (pfile, "__GXX_WEAK__=0");
315 cpp_define (pfile, "__DEPRECATED");
317 /* Note that we define this for C as well, so that we know if
318 __attribute__((cleanup)) will interface with EH. */
320 cpp_define (pfile, "__EXCEPTIONS");
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:
327 #if __GXX_ABI_VERSION >= <value for version X>
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
336 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
338 /* Newer versions have values 1002, 1003, .... */
339 builtin_define_with_int_value ("__GXX_ABI_VERSION",
340 1000 + flag_abi_version);
342 /* libgcc needs to know this. */
343 if (USING_SJLJ_EXCEPTIONS)
344 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
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);
354 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
356 /* float.h needs to know these. */
358 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
359 TARGET_FLT_EVAL_METHOD);
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);
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);
370 builtin_define_with_value ("__VERSION__", version_string, 1);
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)
377 cpp_define (pfile, "_LP64");
378 cpp_define (pfile, "__LP64__");
381 /* Other target-independent built-ins determined by command-line
384 cpp_define (pfile, "__OPTIMIZE_SIZE__");
386 cpp_define (pfile, "__OPTIMIZE__");
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");
397 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
400 cpp_define (pfile, "__STRICT_ANSI__");
402 if (!flag_signed_char)
403 cpp_define (pfile, "__CHAR_UNSIGNED__");
405 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
406 cpp_define (pfile, "__WCHAR_UNSIGNED__");
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__");
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 ();
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.
429 e.g. passing "unix" defines "__unix", "__unix__" and possibly
430 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
433 builtin_define_std (const char *macro)
435 size_t len = strlen (macro);
436 char *buff = alloca (len + 5);
440 /* prepend __ (or maybe just _) if in user's namespace. */
441 memcpy (p, macro, len + 1);
442 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
449 cpp_define (parse_in, p);
451 /* If it was in user's namespace... */
454 /* Define the macro with leading and following __. */
460 cpp_define (parse_in, p);
462 /* Finally, define the original macro if permitted. */
464 cpp_define (parse_in, macro);
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
472 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
475 size_t mlen = strlen (macro);
476 size_t elen = strlen (expansion);
477 size_t extra = 2; /* space for an = and a NUL */
480 extra += 2; /* space for two quote marks */
482 buf = alloca (mlen + elen + extra);
484 sprintf (buf, "%s=\"%s\"", macro, expansion);
486 sprintf (buf, "%s=%s", macro, expansion);
488 cpp_define (parse_in, buf);
491 /* Pass an object-like macro and a value to define it to. The third
492 parameter is the length of the expansion. */
494 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
497 size_t mlen = strlen (macro);
499 /* Space for an = and a NUL. */
500 buf = alloca (mlen + elen + 2);
501 memcpy (buf, macro, mlen);
503 memcpy (buf + mlen + 1, expansion, elen);
504 buf[mlen + elen + 1] = '\0';
506 cpp_define (parse_in, buf);
509 /* Pass an object-like macro and an integer value to define it to. */
511 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
514 size_t mlen = strlen (macro);
516 size_t extra = 2; /* space for = and NUL. */
518 buf = alloca (mlen + vlen + extra);
519 memcpy (buf, macro, mlen);
521 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
523 cpp_define (parse_in, buf);
526 /* Pass an object-like macro a hexadecimal floating-point value. */
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)
532 REAL_VALUE_TYPE real;
533 char dec_str[64], buf[256];
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__.
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. */
545 real_from_string (&real, hex_str);
546 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
548 sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
549 cpp_define (parse_in, buf);
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. */
557 builtin_define_type_max (const char *macro, tree type, int is_long)
559 static const char *const values[]
562 "2147483647", "4294967295",
563 "9223372036854775807", "18446744073709551615",
564 "170141183460469231731687303715884105727",
565 "340282366920938463463374607431768211455" };
566 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
568 const char *value, *suffix;
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))
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;
585 value = values[idx + TYPE_UNSIGNED (type)];
586 suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
588 buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
589 sprintf (buf, "%s=%s%s", macro, value, suffix);
591 cpp_define (parse_in, buf);