1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002, 2003 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"
31 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
34 #ifndef REGISTER_PREFIX
35 #define REGISTER_PREFIX ""
38 static void builtin_define_std
PARAMS ((const char *));
39 static void builtin_define_with_value_n
PARAMS ((const char *, const char *,
41 static void builtin_define_with_int_value
PARAMS ((const char *,
43 static void builtin_define_with_hex_fp_value
PARAMS ((const char *, tree
,
46 static void builtin_define_type_max
PARAMS ((const char *, tree
, int));
47 static void builtin_define_type_precision
PARAMS ((const char *, tree
));
48 static void builtin_define_float_constants
PARAMS ((const char *,
50 static void define__GNUC__
PARAMS ((void));
52 /* Define NAME with value TYPE precision. */
54 builtin_define_type_precision (name
, type
)
58 builtin_define_with_int_value (name
, TYPE_PRECISION (type
));
61 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
63 builtin_define_float_constants (name_prefix
, fp_suffix
, type
)
64 const char *name_prefix
;
65 const char *fp_suffix
;
68 /* Used to convert radix-based values to base 10 values in several cases.
70 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
71 least 6 significant digits for correct results. Using the fraction
72 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
73 intermediate; perhaps someone can find a better approximation, in the
74 mean time, I suspect using doubles won't harm the bootstrap here. */
76 const double log10_2
= .30102999566398119521;
78 const struct real_format
*fmt
;
80 char name
[64], buf
[128];
81 int dig
, min_10_exp
, max_10_exp
;
84 fmt
= real_format_for_mode
[TYPE_MODE (type
) - QFmode
];
86 /* The radix of the exponent representation. */
87 if (type
== float_type_node
)
88 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
89 log10_b
= log10_2
* fmt
->log2_b
;
91 /* The number of radix digits, p, in the floating-point significand. */
92 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
93 builtin_define_with_int_value (name
, fmt
->p
);
95 /* The number of decimal digits, q, such that any floating-point number
96 with q decimal digits can be rounded into a floating-point number with
97 p radix b digits and back again without change to the q decimal digits,
99 p log10 b if b is a power of 10
100 floor((p - 1) log10 b) otherwise
102 dig
= (fmt
->p
- 1) * log10_b
;
103 sprintf (name
, "__%s_DIG__", name_prefix
);
104 builtin_define_with_int_value (name
, dig
);
106 /* The minimum negative int x such that b**(x-1) is a normalized float. */
107 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
108 sprintf (buf
, "(%d)", fmt
->emin
);
109 builtin_define_with_value (name
, buf
, 0);
111 /* The minimum negative int x such that 10**x is a normalized float,
113 ceil (log10 (b ** (emin - 1)))
114 = ceil (log10 (b) * (emin - 1))
116 Recall that emin is negative, so the integer truncation calculates
117 the ceiling, not the floor, in this case. */
118 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
119 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
120 sprintf (buf
, "(%d)", min_10_exp
);
121 builtin_define_with_value (name
, buf
, 0);
123 /* The maximum int x such that b**(x-1) is a representable float. */
124 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
125 builtin_define_with_int_value (name
, fmt
->emax
);
127 /* The maximum int x such that 10**x is in the range of representable
128 finite floating-point numbers,
130 floor (log10((1 - b**-p) * b**emax))
131 = floor (log10(1 - b**-p) + log10(b**emax))
132 = floor (log10(1 - b**-p) + log10(b)*emax)
134 The safest thing to do here is to just compute this number. But since
135 we don't link cc1 with libm, we cannot. We could implement log10 here
136 a series expansion, but that seems too much effort because:
138 Note that the first term, for all extant p, is a number exceedingly close
139 to zero, but slightly negative. Note that the second term is an integer
140 scaling an irrational number, and that because of the floor we are only
141 interested in its integral portion.
143 In order for the first term to have any effect on the integral portion
144 of the second term, the second term has to be exceedingly close to an
145 integer itself (e.g. 123.000000000001 or something). Getting a result
146 that close to an integer requires that the irrational multiplicand have
147 a long series of zeros in its expansion, which doesn't occur in the
148 first 20 digits or so of log10(b).
150 Hand-waving aside, crunching all of the sets of constants above by hand
151 does not yield a case for which the first term is significant, which
152 in the end is all that matters. */
153 max_10_exp
= fmt
->emax
* log10_b
;
154 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
155 builtin_define_with_int_value (name
, max_10_exp
);
157 /* The number of decimal digits, n, such that any floating-point number
158 can be rounded to n decimal digits and back again without change to
161 p * log10(b) if b is a power of 10
162 ceil(1 + p * log10(b)) otherwise
164 The only macro we care about is this number for the widest supported
165 floating type, but we want this value for rendering constants below. */
167 double d_decimal_dig
= 1 + fmt
->p
* log10_b
;
168 decimal_dig
= d_decimal_dig
;
169 if (decimal_dig
< d_decimal_dig
)
172 if (type
== long_double_type_node
)
173 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
175 /* Since, for the supported formats, B is always a power of 2, we
176 construct the following numbers directly as a hexadecimal
179 /* The maximum representable finite floating-point number,
180 (1 - b**-p) * b**emax */
185 strcpy (buf
, "0x0.");
186 n
= fmt
->p
* fmt
->log2_b
;
187 for (i
= 0, p
= buf
+ 4; i
+ 3 < n
; i
+= 4)
190 *p
++ = "08ce"[n
- i
];
191 sprintf (p
, "p%d", fmt
->emax
* fmt
->log2_b
);
193 sprintf (name
, "__%s_MAX__", name_prefix
);
194 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
196 /* The minimum normalized positive floating-point number,
198 sprintf (name
, "__%s_MIN__", name_prefix
);
199 sprintf (buf
, "0x1p%d", (fmt
->emin
- 1) * fmt
->log2_b
);
200 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
202 /* The difference between 1 and the least value greater than 1 that is
203 representable in the given floating point type, b**(1-p). */
204 sprintf (name
, "__%s_EPSILON__", name_prefix
);
205 sprintf (buf
, "0x1p%d", (1 - fmt
->p
) * fmt
->log2_b
);
206 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
208 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
209 positive floating-point number, b**(emin-p). Zero for formats that
210 don't support denormals. */
211 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
214 sprintf (buf
, "0x1p%d", (fmt
->emin
- fmt
->p
) * fmt
->log2_b
);
215 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
220 sprintf (buf
, "0.0%s", fp_suffix
);
221 builtin_define_with_value (name
, buf
, 0);
224 /* For C++ std::numeric_limits<T>::has_infinity. */
225 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
226 builtin_define_with_int_value (name
,
227 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
228 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
229 predicate to distinguish a target that has both quiet and
230 signalling NaNs from a target that has only quiet NaNs or only
231 signalling NaNs, so we assume that a target that has any kind of
232 NaN has quiet NaNs. */
233 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
234 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
237 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
241 /* The format of the version string, enforced below, is
242 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
243 const char *q
, *v
= version_string
;
245 while (*v
&& ! ISDIGIT (*v
))
247 if (!*v
|| (v
> version_string
&& v
[-1] != '-'))
253 builtin_define_with_value_n ("__GNUC__", q
, v
- q
);
254 if (c_language
== clk_cplusplus
)
255 builtin_define_with_value_n ("__GNUG__", q
, v
- q
);
257 if (*v
!= '.' || !ISDIGIT (v
[1]))
262 builtin_define_with_value_n ("__GNUC_MINOR__", q
, v
- q
);
271 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q
, v
- q
);
274 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
276 if (*v
&& *v
!= ' ' && *v
!= '-')
280 /* Hook that registers front end and target-specific built-ins. */
282 cb_register_builtins (pfile
)
285 /* -undef turns off target-specific built-ins. */
291 /* For stddef.h. They require macros defined in c-common.c. */
292 c_stddef_cpp_builtins ();
294 if (c_language
== clk_cplusplus
)
296 if (SUPPORTS_ONE_ONLY
)
297 cpp_define (pfile
, "__GXX_WEAK__=1");
299 cpp_define (pfile
, "__GXX_WEAK__=0");
301 cpp_define (pfile
, "__EXCEPTIONS");
303 cpp_define (pfile
, "__DEPRECATED");
306 /* represents the C++ ABI version, always defined so it can be used while
307 preprocessing C and assembler. */
308 cpp_define (pfile
, "__GXX_ABI_VERSION=102");
310 /* libgcc needs to know this. */
311 if (USING_SJLJ_EXCEPTIONS
)
312 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
314 /* limits.h needs to know these. */
315 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
, 0);
316 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
, 0);
317 builtin_define_type_max ("__INT_MAX__", integer_type_node
, 0);
318 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
, 1);
319 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
, 2);
320 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node
, 0);
322 builtin_define_type_precision ("__CHAR_BIT__", char_type_node
);
324 /* float.h needs to know these. */
326 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
327 TARGET_FLT_EVAL_METHOD
);
329 builtin_define_float_constants ("FLT", "F", float_type_node
);
330 builtin_define_float_constants ("DBL", "", double_type_node
);
331 builtin_define_float_constants ("LDBL", "L", long_double_type_node
);
333 /* For use in assembly language. */
334 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
335 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
338 builtin_define_with_value ("__VERSION__", version_string
, 1);
340 /* Other target-independent built-ins determined by command-line
343 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
345 cpp_define (pfile
, "__OPTIMIZE__");
348 cpp_define (pfile
, "__STDC_HOSTED__=1");
350 cpp_define (pfile
, "__STDC_HOSTED__=0");
352 if (fast_math_flags_set_p ())
353 cpp_define (pfile
, "__FAST_MATH__");
354 if (flag_really_no_inline
)
355 cpp_define (pfile
, "__NO_INLINE__");
356 if (flag_signaling_nans
)
357 cpp_define (pfile
, "__SUPPORT_SNAN__");
358 if (flag_finite_math_only
)
359 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
361 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
364 cpp_define (pfile
, "__STRICT_ANSI__");
366 if (!flag_signed_char
)
367 cpp_define (pfile
, "__CHAR_UNSIGNED__");
369 if (c_language
== clk_cplusplus
&& TREE_UNSIGNED (wchar_type_node
))
370 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
372 /* Make the choice of ObjC runtime visible to source code. */
373 if (flag_objc
&& flag_next_runtime
)
374 cpp_define (pfile
, "__NEXT_RUNTIME__");
376 /* A straightforward target hook doesn't work, because of problems
377 linking that hook's body when part of non-C front ends. */
378 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
379 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
380 # define builtin_define(TXT) cpp_define (pfile, TXT)
381 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
382 TARGET_CPU_CPP_BUILTINS ();
383 TARGET_OS_CPP_BUILTINS ();
386 /* Pass an object-like macro. If it doesn't lie in the user's
387 namespace, defines it unconditionally. Otherwise define a version
388 with two leading underscores, and another version with two leading
389 and trailing underscores, and define the original only if an ISO
390 standard was not nominated.
392 e.g. passing "unix" defines "__unix", "__unix__" and possibly
393 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
396 builtin_define_std (macro
)
399 size_t len
= strlen (macro
);
400 char *buff
= alloca (len
+ 5);
404 /* prepend __ (or maybe just _) if in user's namespace. */
405 memcpy (p
, macro
, len
+ 1);
406 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
413 cpp_define (parse_in
, p
);
415 /* If it was in user's namespace... */
418 /* Define the macro with leading and following __. */
424 cpp_define (parse_in
, p
);
426 /* Finally, define the original macro if permitted. */
428 cpp_define (parse_in
, macro
);
432 /* Pass an object-like macro and a value to define it to. The third
433 parameter says whether or not to turn the value into a string
436 builtin_define_with_value (macro
, expansion
, is_str
)
438 const char *expansion
;
442 size_t mlen
= strlen (macro
);
443 size_t elen
= strlen (expansion
);
444 size_t extra
= 2; /* space for an = and a NUL */
447 extra
+= 2; /* space for two quote marks */
449 buf
= alloca (mlen
+ elen
+ extra
);
451 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
453 sprintf (buf
, "%s=%s", macro
, expansion
);
455 cpp_define (parse_in
, buf
);
458 /* Pass an object-like macro and a value to define it to. The third
459 parameter is the length of the expansion. */
461 builtin_define_with_value_n (macro
, expansion
, elen
)
463 const char *expansion
;
467 size_t mlen
= strlen (macro
);
469 /* Space for an = and a NUL. */
470 buf
= alloca (mlen
+ elen
+ 2);
471 memcpy (buf
, macro
, mlen
);
473 memcpy (buf
+ mlen
+ 1, expansion
, elen
);
474 buf
[mlen
+ elen
+ 1] = '\0';
476 cpp_define (parse_in
, buf
);
479 /* Pass an object-like macro and an integer value to define it to. */
481 builtin_define_with_int_value (macro
, value
)
486 size_t mlen
= strlen (macro
);
488 size_t extra
= 2; /* space for = and NUL. */
490 buf
= alloca (mlen
+ vlen
+ extra
);
491 memcpy (buf
, macro
, mlen
);
493 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
495 cpp_define (parse_in
, buf
);
498 /* Pass an object-like macro a hexadecimal floating-point value. */
500 builtin_define_with_hex_fp_value (macro
, type
, digits
, hex_str
, fp_suffix
)
502 tree type ATTRIBUTE_UNUSED
;
505 const char *fp_suffix
;
507 REAL_VALUE_TYPE real
;
508 char dec_str
[64], buf
[256];
510 /* Hex values are really cool and convenient, except that they're
511 not supported in strict ISO C90 mode. First, the "p-" sequence
512 is not valid as part of a preprocessor number. Second, we get a
513 pedwarn from the preprocessor, which has no context, so we can't
514 suppress the warning with __extension__.
516 So instead what we do is construct the number in hex (because
517 it's easy to get the exact correct value), parse it as a real,
518 then print it back out as decimal. */
520 real_from_string (&real
, hex_str
);
521 real_to_decimal (dec_str
, &real
, sizeof (dec_str
), digits
, 0);
523 sprintf (buf
, "%s=%s%s", macro
, dec_str
, fp_suffix
);
524 cpp_define (parse_in
, buf
);
527 /* Define MAX for TYPE based on the precision of the type. IS_LONG is
528 1 for type "long" and 2 for "long long". We have to handle
529 unsigned types, since wchar_t might be unsigned. */
532 builtin_define_type_max (macro
, type
, is_long
)
537 static const char *const values
[]
540 "2147483647", "4294967295",
541 "9223372036854775807", "18446744073709551615",
542 "170141183460469231731687303715884105727",
543 "340282366920938463463374607431768211455" };
544 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
546 const char *value
, *suffix
;
550 /* Pre-rendering the values mean we don't have to futz with printing a
551 multi-word decimal value. There are also a very limited number of
552 precisions that we support, so it's really a waste of time. */
553 switch (TYPE_PRECISION (type
))
555 case 8: idx
= 0; break;
556 case 16: idx
= 2; break;
557 case 32: idx
= 4; break;
558 case 64: idx
= 6; break;
559 case 128: idx
= 8; break;
563 value
= values
[idx
+ TREE_UNSIGNED (type
)];
564 suffix
= suffixes
[is_long
* 2 + TREE_UNSIGNED (type
)];
566 buf
= alloca (strlen (macro
) + 1 + strlen (value
) + strlen (suffix
) + 1);
567 sprintf (buf
, "%s=%s%s", macro
, value
, suffix
);
569 cpp_define (parse_in
, buf
);