1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
32 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
33 #include "debug.h" /* For dwarf2out_do_frame. */
35 #include "tm_p.h" /* Target prototypes. */
38 #ifndef TARGET_OS_CPP_BUILTINS
39 # define TARGET_OS_CPP_BUILTINS()
42 #ifndef TARGET_OBJFMT_CPP_BUILTINS
43 # define TARGET_OBJFMT_CPP_BUILTINS()
46 #ifndef REGISTER_PREFIX
47 #define REGISTER_PREFIX ""
50 /* Non-static as some targets don't use it. */
51 void builtin_define_std (const char *) ATTRIBUTE_UNUSED
;
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
,
57 static void builtin_define_stdint_macros (void);
58 static void builtin_define_constants (const char *, tree
);
59 static void builtin_define_type_max (const char *, tree
);
60 static void builtin_define_type_minmax (const char *, const char *, tree
);
61 static void builtin_define_type_precision (const char *, tree
);
62 static void builtin_define_type_sizeof (const char *, tree
);
63 static void builtin_define_float_constants (const char *,
67 static void define__GNUC__ (void);
69 /* Define NAME with value TYPE precision. */
71 builtin_define_type_precision (const char *name
, tree type
)
73 builtin_define_with_int_value (name
, TYPE_PRECISION (type
));
76 /* Define NAME with value TYPE size_unit. */
78 builtin_define_type_sizeof (const char *name
, tree type
)
80 builtin_define_with_int_value (name
,
81 tree_low_cst (TYPE_SIZE_UNIT (type
), 1));
84 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
87 builtin_define_float_constants (const char *name_prefix
,
88 const char *fp_suffix
,
92 /* Used to convert radix-based values to base 10 values in several cases.
94 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
95 least 6 significant digits for correct results. Using the fraction
96 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
97 intermediate; perhaps someone can find a better approximation, in the
98 mean time, I suspect using doubles won't harm the bootstrap here. */
100 const double log10_2
= .30102999566398119521;
102 const struct real_format
*fmt
;
103 const struct real_format
*ldfmt
;
105 char name
[64], buf
[128];
106 int dig
, min_10_exp
, max_10_exp
;
109 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
110 gcc_assert (fmt
->b
!= 10);
111 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
112 gcc_assert (ldfmt
->b
!= 10);
114 /* The radix of the exponent representation. */
115 if (type
== float_type_node
)
116 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
119 /* The number of radix digits, p, in the floating-point significand. */
120 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
121 builtin_define_with_int_value (name
, fmt
->p
);
123 /* The number of decimal digits, q, such that any floating-point number
124 with q decimal digits can be rounded into a floating-point number with
125 p radix b digits and back again without change to the q decimal digits,
127 p log10 b if b is a power of 10
128 floor((p - 1) log10 b) otherwise
130 dig
= (fmt
->p
- 1) * log10_b
;
131 sprintf (name
, "__%s_DIG__", name_prefix
);
132 builtin_define_with_int_value (name
, dig
);
134 /* The minimum negative int x such that b**(x-1) is a normalized float. */
135 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
136 sprintf (buf
, "(%d)", fmt
->emin
);
137 builtin_define_with_value (name
, buf
, 0);
139 /* The minimum negative int x such that 10**x is a normalized float,
141 ceil (log10 (b ** (emin - 1)))
142 = ceil (log10 (b) * (emin - 1))
144 Recall that emin is negative, so the integer truncation calculates
145 the ceiling, not the floor, in this case. */
146 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
147 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
148 sprintf (buf
, "(%d)", min_10_exp
);
149 builtin_define_with_value (name
, buf
, 0);
151 /* The maximum int x such that b**(x-1) is a representable float. */
152 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
153 builtin_define_with_int_value (name
, fmt
->emax
);
155 /* The maximum int x such that 10**x is in the range of representable
156 finite floating-point numbers,
158 floor (log10((1 - b**-p) * b**emax))
159 = floor (log10(1 - b**-p) + log10(b**emax))
160 = floor (log10(1 - b**-p) + log10(b)*emax)
162 The safest thing to do here is to just compute this number. But since
163 we don't link cc1 with libm, we cannot. We could implement log10 here
164 a series expansion, but that seems too much effort because:
166 Note that the first term, for all extant p, is a number exceedingly close
167 to zero, but slightly negative. Note that the second term is an integer
168 scaling an irrational number, and that because of the floor we are only
169 interested in its integral portion.
171 In order for the first term to have any effect on the integral portion
172 of the second term, the second term has to be exceedingly close to an
173 integer itself (e.g. 123.000000000001 or something). Getting a result
174 that close to an integer requires that the irrational multiplicand have
175 a long series of zeros in its expansion, which doesn't occur in the
176 first 20 digits or so of log10(b).
178 Hand-waving aside, crunching all of the sets of constants above by hand
179 does not yield a case for which the first term is significant, which
180 in the end is all that matters. */
181 max_10_exp
= fmt
->emax
* log10_b
;
182 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
183 builtin_define_with_int_value (name
, max_10_exp
);
185 /* The number of decimal digits, n, such that any floating-point number
186 can be rounded to n decimal digits and back again without change to
189 p * log10(b) if b is a power of 10
190 ceil(1 + p * log10(b)) otherwise
192 The only macro we care about is this number for the widest supported
193 floating type, but we want this value for rendering constants below. */
196 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
197 decimal_dig
= d_decimal_dig
;
198 if (decimal_dig
< d_decimal_dig
)
201 if (type
== long_double_type_node
)
202 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
204 /* Since, for the supported formats, B is always a power of 2, we
205 construct the following numbers directly as a hexadecimal
207 get_max_float (fmt
, buf
, sizeof (buf
));
209 sprintf (name
, "__%s_MAX__", name_prefix
);
210 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
212 /* The minimum normalized positive floating-point number,
214 sprintf (name
, "__%s_MIN__", name_prefix
);
215 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
216 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
218 /* The difference between 1 and the least value greater than 1 that is
219 representable in the given floating point type, b**(1-p). */
220 sprintf (name
, "__%s_EPSILON__", name_prefix
);
221 if (fmt
->pnan
< fmt
->p
)
222 /* This is an IBM extended double format, so 1.0 + any double is
223 representable precisely. */
224 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
226 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
227 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
229 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
230 positive floating-point number, b**(emin-p). Zero for formats that
231 don't support denormals. */
232 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
235 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
236 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
237 buf
, fp_suffix
, fp_cast
);
241 sprintf (buf
, "0.0%s", fp_suffix
);
242 builtin_define_with_value (name
, buf
, 0);
245 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
246 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
248 /* For C++ std::numeric_limits<T>::has_infinity. */
249 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
250 builtin_define_with_int_value (name
,
251 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
252 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
253 predicate to distinguish a target that has both quiet and
254 signalling NaNs from a target that has only quiet NaNs or only
255 signalling NaNs, so we assume that a target that has any kind of
256 NaN has quiet NaNs. */
257 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
258 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
261 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
263 builtin_define_decimal_float_constants (const char *name_prefix
,
267 const struct real_format
*fmt
;
268 char name
[64], buf
[128], *p
;
271 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
273 /* The number of radix digits, p, in the significand. */
274 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
275 builtin_define_with_int_value (name
, fmt
->p
);
277 /* The minimum negative int x such that b**(x-1) is a normalized float. */
278 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
279 sprintf (buf
, "(%d)", fmt
->emin
);
280 builtin_define_with_value (name
, buf
, 0);
282 /* The maximum int x such that b**(x-1) is a representable float. */
283 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
284 builtin_define_with_int_value (name
, fmt
->emax
);
286 /* Compute the minimum representable value. */
287 sprintf (name
, "__%s_MIN__", name_prefix
);
288 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
289 builtin_define_with_value (name
, buf
, 0);
291 /* Compute the maximum representable value. */
292 sprintf (name
, "__%s_MAX__", name_prefix
);
294 for (digits
= fmt
->p
; digits
; digits
--)
297 if (digits
== fmt
->p
)
301 /* fmt->p plus 1, to account for the decimal point and fmt->emax
302 minus 1 because the digits are nines, not 1.0. */
303 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
304 builtin_define_with_value (name
, buf
, 0);
306 /* Compute epsilon (the difference between 1 and least value greater
307 than 1 representable). */
308 sprintf (name
, "__%s_EPSILON__", name_prefix
);
309 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
310 builtin_define_with_value (name
, buf
, 0);
312 /* Minimum subnormal positive decimal value. */
313 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
315 for (digits
= fmt
->p
; digits
> 1; digits
--)
318 if (digits
== fmt
->p
)
322 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
323 builtin_define_with_value (name
, buf
, 0);
326 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
329 builtin_define_fixed_point_constants (const char *name_prefix
,
333 char name
[64], buf
[256], *new_buf
;
336 sprintf (name
, "__%s_FBIT__", name_prefix
);
337 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
339 sprintf (name
, "__%s_IBIT__", name_prefix
);
340 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
342 /* If there is no suffix, defines are for fixed-point modes.
344 if (strcmp (suffix
, "") == 0)
347 if (TYPE_UNSIGNED (type
))
349 sprintf (name
, "__%s_MIN__", name_prefix
);
350 sprintf (buf
, "0.0%s", suffix
);
351 builtin_define_with_value (name
, buf
, 0);
355 sprintf (name
, "__%s_MIN__", name_prefix
);
356 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
357 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
358 TYPE_IBIT (type
) - 1, suffix
);
360 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
361 builtin_define_with_value (name
, buf
, 0);
364 sprintf (name
, "__%s_MAX__", name_prefix
);
367 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
369 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
370 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
371 sprintf (new_buf
++, "F");
372 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
373 builtin_define_with_value (name
, buf
, 0);
375 sprintf (name
, "__%s_EPSILON__", name_prefix
);
376 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
377 builtin_define_with_value (name
, buf
, 0);
380 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
382 define__GNUC__ (void)
384 int major
, minor
, patchlevel
;
386 if (sscanf (BASEVER
, "%d.%d.%d", &major
, &minor
, &patchlevel
) != 3)
388 sscanf (BASEVER
, "%d.%d", &major
, &minor
);
391 cpp_define_formatted (parse_in
, "__GNUC__=%d", major
);
392 cpp_define_formatted (parse_in
, "__GNUC_MINOR__=%d", minor
);
393 cpp_define_formatted (parse_in
, "__GNUC_PATCHLEVEL__=%d", patchlevel
);
395 if (c_dialect_cxx ())
396 cpp_define_formatted (parse_in
, "__GNUG__=%d", major
);
399 /* Define macros used by <stdint.h>. */
401 builtin_define_stdint_macros (void)
403 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
404 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
405 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
406 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
407 if (sig_atomic_type_node
)
408 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
409 sig_atomic_type_node
);
411 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
413 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
415 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
417 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
419 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
420 if (uint16_type_node
)
421 builtin_define_type_max ("__UINT16_MAX__", uint16_type_node
);
422 if (c_uint32_type_node
)
423 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
424 if (c_uint64_type_node
)
425 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
426 if (int_least8_type_node
)
428 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
429 builtin_define_constants ("__INT8_C", int_least8_type_node
);
431 if (int_least16_type_node
)
433 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
434 builtin_define_constants ("__INT16_C", int_least16_type_node
);
436 if (int_least32_type_node
)
438 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
439 builtin_define_constants ("__INT32_C", int_least32_type_node
);
441 if (int_least64_type_node
)
443 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
444 builtin_define_constants ("__INT64_C", int_least64_type_node
);
446 if (uint_least8_type_node
)
448 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
449 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
451 if (uint_least16_type_node
)
453 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
454 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
456 if (uint_least32_type_node
)
458 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
459 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
461 if (uint_least64_type_node
)
463 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
464 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
466 if (int_fast8_type_node
)
467 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
468 if (int_fast16_type_node
)
469 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
470 if (int_fast32_type_node
)
471 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
472 if (int_fast64_type_node
)
473 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
474 if (uint_fast8_type_node
)
475 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
476 if (uint_fast16_type_node
)
477 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
478 if (uint_fast32_type_node
)
479 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
480 if (uint_fast64_type_node
)
481 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
482 if (intptr_type_node
)
483 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
484 if (uintptr_type_node
)
485 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
488 /* Adjust the optimization macros when a #pragma GCC optimization is done to
489 reflect the current level. */
491 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
494 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
495 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
499 /* -undef turns off target-specific built-ins. */
503 /* Other target-independent built-ins determined by command-line
505 if (!prev
->optimize_size
&& cur
->optimize_size
)
506 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
507 else if (prev
->optimize_size
&& !cur
->optimize_size
)
508 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
510 if (!prev
->optimize
&& cur
->optimize
)
511 cpp_define (pfile
, "__OPTIMIZE__");
512 else if (prev
->optimize
&& !cur
->optimize
)
513 cpp_undef (pfile
, "__OPTIMIZE__");
515 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
516 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
517 if (!prev_fast_math
&& cur_fast_math
)
518 cpp_define (pfile
, "__FAST_MATH__");
519 else if (prev_fast_math
&& !cur_fast_math
)
520 cpp_undef (pfile
, "__FAST_MATH__");
522 if (!prev
->flag_signaling_nans
&& cur
->flag_signaling_nans
)
523 cpp_define (pfile
, "__SUPPORT_SNAN__");
524 else if (prev
->flag_signaling_nans
&& !cur
->flag_signaling_nans
)
525 cpp_undef (pfile
, "__SUPPORT_SNAN__");
527 if (!prev
->flag_finite_math_only
&& cur
->flag_finite_math_only
)
529 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
530 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
532 else if (!prev
->flag_finite_math_only
&& cur
->flag_finite_math_only
)
534 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
535 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
540 /* Hook that registers front end and target-specific built-ins. */
542 c_cpp_builtins (cpp_reader
*pfile
)
544 /* -undef turns off target-specific built-ins. */
550 /* For stddef.h. They require macros defined in c-common.c. */
551 c_stddef_cpp_builtins ();
553 if (c_dialect_cxx ())
555 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
556 cpp_define (pfile
, "__GXX_WEAK__=1");
558 cpp_define (pfile
, "__GXX_WEAK__=0");
560 cpp_define (pfile
, "__DEPRECATED");
562 cpp_define (pfile
, "__GXX_RTTI");
563 if (cxx_dialect
== cxx0x
)
564 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
566 /* Note that we define this for C as well, so that we know if
567 __attribute__((cleanup)) will interface with EH. */
569 cpp_define (pfile
, "__EXCEPTIONS");
571 /* Represents the C++ ABI version, always defined so it can be used while
572 preprocessing C and assembler. */
573 if (flag_abi_version
== 0)
574 /* Use a very large value so that:
576 #if __GXX_ABI_VERSION >= <value for version X>
578 will work whether the user explicitly says "-fabi-version=x" or
579 "-fabi-version=0". Do not use INT_MAX because that will be
580 different from system to system. */
581 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
582 else if (flag_abi_version
== 1)
583 /* Due to a historical accident, this version had the value
585 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
587 /* Newer versions have values 1002, 1003, .... */
588 builtin_define_with_int_value ("__GXX_ABI_VERSION",
589 1000 + flag_abi_version
);
591 /* libgcc needs to know this. */
592 if (USING_SJLJ_EXCEPTIONS
)
593 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
595 /* limits.h and stdint.h need to know these. */
596 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
597 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
598 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
599 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
600 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
601 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
602 underlying_wchar_type_node
);
603 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
604 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
605 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
607 builtin_define_type_precision ("__CHAR_BIT__", char_type_node
);
609 /* stdint.h and the testsuite need to know these. */
610 builtin_define_stdint_macros ();
612 /* float.h needs to know these. */
614 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
615 TARGET_FLT_EVAL_METHOD
);
617 /* And decfloat.h needs this. */
618 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
619 TARGET_DEC_EVAL_METHOD
);
621 builtin_define_float_constants ("FLT", "F", "%s", float_type_node
);
622 /* Cast the double precision constants when single precision constants are
623 specified. The correct result is computed by the compiler when using
624 macros that include a cast. This has the side-effect of making the value
625 unusable in const expressions. */
626 if (flag_single_precision_constant
)
627 builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node
);
629 builtin_define_float_constants ("DBL", "", "%s", double_type_node
);
630 builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node
);
632 /* For decfloat.h. */
633 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
634 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
635 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
637 /* For fixed-point fibt, ibit, max, min, and epsilon. */
638 if (targetm
.fixed_point_supported_p ())
640 builtin_define_fixed_point_constants ("SFRACT", "HR",
641 short_fract_type_node
);
642 builtin_define_fixed_point_constants ("USFRACT", "UHR",
643 unsigned_short_fract_type_node
);
644 builtin_define_fixed_point_constants ("FRACT", "R",
646 builtin_define_fixed_point_constants ("UFRACT", "UR",
647 unsigned_fract_type_node
);
648 builtin_define_fixed_point_constants ("LFRACT", "LR",
649 long_fract_type_node
);
650 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
651 unsigned_long_fract_type_node
);
652 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
653 long_long_fract_type_node
);
654 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
655 unsigned_long_long_fract_type_node
);
656 builtin_define_fixed_point_constants ("SACCUM", "HK",
657 short_accum_type_node
);
658 builtin_define_fixed_point_constants ("USACCUM", "UHK",
659 unsigned_short_accum_type_node
);
660 builtin_define_fixed_point_constants ("ACCUM", "K",
662 builtin_define_fixed_point_constants ("UACCUM", "UK",
663 unsigned_accum_type_node
);
664 builtin_define_fixed_point_constants ("LACCUM", "LK",
665 long_accum_type_node
);
666 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
667 unsigned_long_accum_type_node
);
668 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
669 long_long_accum_type_node
);
670 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
671 unsigned_long_long_accum_type_node
);
673 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
674 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
675 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
676 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
677 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
678 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
679 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
680 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
681 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
682 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
683 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
684 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
685 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
686 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
687 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
688 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
689 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
690 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
693 /* For use in assembly language. */
694 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
695 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
698 builtin_define_with_value ("__VERSION__", version_string
, 1);
700 if (flag_gnu89_inline
)
701 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
703 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
705 /* Definitions for LP64 model. */
706 if (TYPE_PRECISION (long_integer_type_node
) == 64
707 && POINTER_SIZE
== 64
708 && TYPE_PRECISION (integer_type_node
) == 32)
710 cpp_define (pfile
, "_LP64");
711 cpp_define (pfile
, "__LP64__");
714 /* Other target-independent built-ins determined by command-line
717 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
719 cpp_define (pfile
, "__OPTIMIZE__");
721 if (fast_math_flags_set_p ())
722 cpp_define (pfile
, "__FAST_MATH__");
724 cpp_define (pfile
, "__NO_INLINE__");
725 if (flag_signaling_nans
)
726 cpp_define (pfile
, "__SUPPORT_SNAN__");
727 if (flag_finite_math_only
)
728 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
730 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
733 builtin_define_with_int_value ("__pic__", flag_pic
);
734 builtin_define_with_int_value ("__PIC__", flag_pic
);
738 builtin_define_with_int_value ("__pie__", flag_pie
);
739 builtin_define_with_int_value ("__PIE__", flag_pie
);
743 cpp_define (pfile
, "__STRICT_ANSI__");
745 if (!flag_signed_char
)
746 cpp_define (pfile
, "__CHAR_UNSIGNED__");
748 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
749 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
751 /* Tell source code if the compiler makes sync_compare_and_swap
752 builtins available. */
753 #ifdef HAVE_sync_compare_and_swapqi
754 if (HAVE_sync_compare_and_swapqi
)
755 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
758 #ifdef HAVE_sync_compare_and_swaphi
759 if (HAVE_sync_compare_and_swaphi
)
760 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
763 #ifdef HAVE_sync_compare_and_swapsi
764 if (HAVE_sync_compare_and_swapsi
)
765 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
768 #ifdef HAVE_sync_compare_and_swapdi
769 if (HAVE_sync_compare_and_swapdi
)
770 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
773 #ifdef HAVE_sync_compare_and_swapti
774 if (HAVE_sync_compare_and_swapti
)
775 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
778 #ifdef DWARF2_UNWIND_INFO
779 if (dwarf2out_do_cfi_asm ())
780 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
783 /* Make the choice of ObjC runtime visible to source code. */
784 if (c_dialect_objc () && flag_next_runtime
)
785 cpp_define (pfile
, "__NEXT_RUNTIME__");
787 /* Show the availability of some target pragmas. */
788 if (flag_mudflap
|| targetm
.handle_pragma_redefine_extname
)
789 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
791 if (targetm
.handle_pragma_extern_prefix
)
792 cpp_define (pfile
, "__PRAGMA_EXTERN_PREFIX");
794 /* Make the choice of the stack protector runtime visible to source code.
795 The macro names and values here were chosen for compatibility with an
796 earlier implementation, i.e. ProPolice. */
797 if (flag_stack_protect
== 2)
798 cpp_define (pfile
, "__SSP_ALL__=2");
799 else if (flag_stack_protect
== 1)
800 cpp_define (pfile
, "__SSP__=1");
803 cpp_define (pfile
, "_OPENMP=200805");
805 builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node
);
806 builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node
);
807 builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
808 long_long_integer_type_node
);
809 builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node
);
810 builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node
);
811 builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node
);
812 builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node
);
813 builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node
);
814 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
815 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
816 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
817 unsigned_ptrdiff_type_node
);
818 /* ptr_type_node can't be used here since ptr_mode is only set when
819 toplev calls backend_init which is not done with -E switch. */
820 builtin_define_with_int_value ("__SIZEOF_POINTER__",
821 POINTER_SIZE
/ BITS_PER_UNIT
);
823 /* A straightforward target hook doesn't work, because of problems
824 linking that hook's body when part of non-C front ends. */
825 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
826 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
827 # define builtin_define(TXT) cpp_define (pfile, TXT)
828 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
829 TARGET_CPU_CPP_BUILTINS ();
830 TARGET_OS_CPP_BUILTINS ();
831 TARGET_OBJFMT_CPP_BUILTINS ();
833 /* Support the __declspec keyword by turning them into attributes.
834 Note that the current way we do this may result in a collision
835 with predefined attributes later on. This can be solved by using
836 one attribute, say __declspec__, and passing args to it. The
837 problem with that approach is that args are not accumulated: each
838 new appearance would clobber any existing args. */
840 builtin_define ("__declspec(x)=__attribute__((x))");
842 /* If decimal floating point is supported, tell the user if the
843 alternate format (BID) is used instead of the standard (DPD)
845 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
846 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
848 builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__",
849 BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
);
852 /* Pass an object-like macro. If it doesn't lie in the user's
853 namespace, defines it unconditionally. Otherwise define a version
854 with two leading underscores, and another version with two leading
855 and trailing underscores, and define the original only if an ISO
856 standard was not nominated.
858 e.g. passing "unix" defines "__unix", "__unix__" and possibly
859 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
862 builtin_define_std (const char *macro
)
864 size_t len
= strlen (macro
);
865 char *buff
= (char *) alloca (len
+ 5);
869 /* prepend __ (or maybe just _) if in user's namespace. */
870 memcpy (p
, macro
, len
+ 1);
871 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
878 cpp_define (parse_in
, p
);
880 /* If it was in user's namespace... */
883 /* Define the macro with leading and following __. */
889 cpp_define (parse_in
, p
);
891 /* Finally, define the original macro if permitted. */
893 cpp_define (parse_in
, macro
);
897 /* Pass an object-like macro and a value to define it to. The third
898 parameter says whether or not to turn the value into a string
901 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
904 size_t mlen
= strlen (macro
);
905 size_t elen
= strlen (expansion
);
906 size_t extra
= 2; /* space for an = and a NUL */
909 extra
+= 2; /* space for two quote marks */
911 buf
= (char *) alloca (mlen
+ elen
+ extra
);
913 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
915 sprintf (buf
, "%s=%s", macro
, expansion
);
917 cpp_define (parse_in
, buf
);
921 /* Pass an object-like macro and an integer value to define it to. */
923 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
926 size_t mlen
= strlen (macro
);
928 size_t extra
= 2; /* space for = and NUL. */
930 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
931 memcpy (buf
, macro
, mlen
);
933 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
935 cpp_define (parse_in
, buf
);
938 /* Pass an object-like macro a hexadecimal floating-point value. */
940 builtin_define_with_hex_fp_value (const char *macro
,
941 tree type
, int digits
,
943 const char *fp_suffix
,
946 REAL_VALUE_TYPE real
;
947 char dec_str
[64], buf1
[256], buf2
[256];
949 /* Hex values are really cool and convenient, except that they're
950 not supported in strict ISO C90 mode. First, the "p-" sequence
951 is not valid as part of a preprocessor number. Second, we get a
952 pedwarn from the preprocessor, which has no context, so we can't
953 suppress the warning with __extension__.
955 So instead what we do is construct the number in hex (because
956 it's easy to get the exact correct value), parse it as a real,
957 then print it back out as decimal. */
959 real_from_string (&real
, hex_str
);
960 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
963 /* Assemble the macro in the following fashion
964 macro = fp_cast [dec_str fp_suffix] */
965 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
966 sprintf (buf2
, fp_cast
, buf1
);
967 sprintf (buf1
, "%s=%s", macro
, buf2
);
969 cpp_define (parse_in
, buf1
);
972 /* Return a string constant for the suffix for a value of type TYPE
973 promoted according to the integer promotions. The type must be one
974 of the standard integer type nodes. */
977 type_suffix (tree type
)
979 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
983 if (type
== long_long_integer_type_node
984 || type
== long_long_unsigned_type_node
)
986 else if (type
== long_integer_type_node
987 || type
== long_unsigned_type_node
)
989 else if (type
== integer_type_node
990 || type
== unsigned_type_node
991 || type
== short_integer_type_node
992 || type
== short_unsigned_type_node
993 || type
== signed_char_type_node
994 || type
== unsigned_char_type_node
995 /* ??? "char" is not a signed or unsigned integer type and
996 so is not permitted for the standard typedefs, but some
997 systems use it anyway. */
998 || type
== char_type_node
)
1003 unsigned_suffix
= TYPE_UNSIGNED (type
);
1004 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1005 unsigned_suffix
= 0;
1006 return suffixes
[is_long
* 2 + unsigned_suffix
];
1009 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1011 builtin_define_constants (const char *macro
, tree type
)
1016 suffix
= type_suffix (type
);
1020 buf
= (char *) alloca (strlen (macro
) + 6);
1021 sprintf (buf
, "%s(c)=c", macro
);
1025 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1026 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1029 cpp_define (parse_in
, buf
);
1032 /* Define MAX for TYPE based on the precision of the type. */
1035 builtin_define_type_max (const char *macro
, tree type
)
1037 builtin_define_type_minmax (NULL
, macro
, type
);
1040 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1041 precision of the type. */
1044 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1047 static const char *const values
[]
1050 "2147483647", "4294967295",
1051 "9223372036854775807", "18446744073709551615",
1052 "170141183460469231731687303715884105727",
1053 "340282366920938463463374607431768211455" };
1055 const char *value
, *suffix
;
1059 /* Pre-rendering the values mean we don't have to futz with printing a
1060 multi-word decimal value. There are also a very limited number of
1061 precisions that we support, so it's really a waste of time. */
1062 switch (TYPE_PRECISION (type
))
1064 case 8: idx
= 0; break;
1065 case 16: idx
= 2; break;
1066 case 32: idx
= 4; break;
1067 case 64: idx
= 6; break;
1068 case 128: idx
= 8; break;
1069 default: gcc_unreachable ();
1072 value
= values
[idx
+ TYPE_UNSIGNED (type
)];
1073 suffix
= type_suffix (type
);
1075 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1076 + strlen (suffix
) + 1);
1077 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1079 cpp_define (parse_in
, buf
);
1083 if (TYPE_UNSIGNED (type
))
1085 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1086 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1090 buf
= (char *) alloca (strlen (min_macro
) + 3
1091 + strlen (max_macro
) + 6);
1092 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1094 cpp_define (parse_in
, buf
);