1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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"
31 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
32 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
34 #include "cpp-id-data.h"
35 #include "cppbuiltin.h"
37 #ifndef TARGET_OS_CPP_BUILTINS
38 # define TARGET_OS_CPP_BUILTINS()
41 #ifndef TARGET_OBJFMT_CPP_BUILTINS
42 # define TARGET_OBJFMT_CPP_BUILTINS()
45 #ifndef REGISTER_PREFIX
46 #define REGISTER_PREFIX ""
49 /* Non-static as some targets don't use it. */
50 void builtin_define_std (const char *) ATTRIBUTE_UNUSED
;
51 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT
);
52 static void builtin_define_with_hex_fp_value (const char *, tree
,
56 static void builtin_define_stdint_macros (void);
57 static void builtin_define_constants (const char *, tree
);
58 static void builtin_define_type_max (const char *, tree
);
59 static void builtin_define_type_minmax (const char *, const char *, tree
);
60 static void builtin_define_type_sizeof (const char *, tree
);
61 static void builtin_define_float_constants (const char *,
67 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
68 Originally this function used the fma optab, but that doesn't work with
69 -save-temps, so just rely on the HAVE_fma macros for the standard floating
73 mode_has_fma (enum machine_mode mode
)
104 /* Define NAME with value TYPE size_unit. */
106 builtin_define_type_sizeof (const char *name
, tree type
)
108 builtin_define_with_int_value (name
,
109 tree_low_cst (TYPE_SIZE_UNIT (type
), 1));
112 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
115 builtin_define_float_constants (const char *name_prefix
,
116 const char *fp_suffix
,
118 const char *fma_suffix
,
121 /* Used to convert radix-based values to base 10 values in several cases.
123 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
124 least 6 significant digits for correct results. Using the fraction
125 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
126 intermediate; perhaps someone can find a better approximation, in the
127 mean time, I suspect using doubles won't harm the bootstrap here. */
129 const double log10_2
= .30102999566398119521;
131 const struct real_format
*fmt
;
132 const struct real_format
*ldfmt
;
134 char name
[64], buf
[128];
135 int dig
, min_10_exp
, max_10_exp
;
137 int type_decimal_dig
;
139 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
140 gcc_assert (fmt
->b
!= 10);
141 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
142 gcc_assert (ldfmt
->b
!= 10);
144 /* The radix of the exponent representation. */
145 if (type
== float_type_node
)
146 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
149 /* The number of radix digits, p, in the floating-point significand. */
150 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
151 builtin_define_with_int_value (name
, fmt
->p
);
153 /* The number of decimal digits, q, such that any floating-point number
154 with q decimal digits can be rounded into a floating-point number with
155 p radix b digits and back again without change to the q decimal digits,
157 p log10 b if b is a power of 10
158 floor((p - 1) log10 b) otherwise
160 dig
= (fmt
->p
- 1) * log10_b
;
161 sprintf (name
, "__%s_DIG__", name_prefix
);
162 builtin_define_with_int_value (name
, dig
);
164 /* The minimum negative int x such that b**(x-1) is a normalized float. */
165 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
166 sprintf (buf
, "(%d)", fmt
->emin
);
167 builtin_define_with_value (name
, buf
, 0);
169 /* The minimum negative int x such that 10**x is a normalized float,
171 ceil (log10 (b ** (emin - 1)))
172 = ceil (log10 (b) * (emin - 1))
174 Recall that emin is negative, so the integer truncation calculates
175 the ceiling, not the floor, in this case. */
176 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
177 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
178 sprintf (buf
, "(%d)", min_10_exp
);
179 builtin_define_with_value (name
, buf
, 0);
181 /* The maximum int x such that b**(x-1) is a representable float. */
182 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
183 builtin_define_with_int_value (name
, fmt
->emax
);
185 /* The maximum int x such that 10**x is in the range of representable
186 finite floating-point numbers,
188 floor (log10((1 - b**-p) * b**emax))
189 = floor (log10(1 - b**-p) + log10(b**emax))
190 = floor (log10(1 - b**-p) + log10(b)*emax)
192 The safest thing to do here is to just compute this number. But since
193 we don't link cc1 with libm, we cannot. We could implement log10 here
194 a series expansion, but that seems too much effort because:
196 Note that the first term, for all extant p, is a number exceedingly close
197 to zero, but slightly negative. Note that the second term is an integer
198 scaling an irrational number, and that because of the floor we are only
199 interested in its integral portion.
201 In order for the first term to have any effect on the integral portion
202 of the second term, the second term has to be exceedingly close to an
203 integer itself (e.g. 123.000000000001 or something). Getting a result
204 that close to an integer requires that the irrational multiplicand have
205 a long series of zeros in its expansion, which doesn't occur in the
206 first 20 digits or so of log10(b).
208 Hand-waving aside, crunching all of the sets of constants above by hand
209 does not yield a case for which the first term is significant, which
210 in the end is all that matters. */
211 max_10_exp
= fmt
->emax
* log10_b
;
212 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
213 builtin_define_with_int_value (name
, max_10_exp
);
215 /* The number of decimal digits, n, such that any floating-point number
216 can be rounded to n decimal digits and back again without change to
219 p * log10(b) if b is a power of 10
220 ceil(1 + p * log10(b)) otherwise
222 The only macro we care about is this number for the widest supported
223 floating type, but we want this value for rendering constants below. */
226 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
227 decimal_dig
= d_decimal_dig
;
228 if (decimal_dig
< d_decimal_dig
)
231 /* Similar, for this type rather than long double. */
233 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
234 type_decimal_dig
= type_d_decimal_dig
;
235 if (type_decimal_dig
< type_d_decimal_dig
)
238 if (type
== long_double_type_node
)
239 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
242 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
243 builtin_define_with_int_value (name
, type_decimal_dig
);
246 /* Since, for the supported formats, B is always a power of 2, we
247 construct the following numbers directly as a hexadecimal
249 get_max_float (fmt
, buf
, sizeof (buf
));
251 sprintf (name
, "__%s_MAX__", name_prefix
);
252 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
254 /* The minimum normalized positive floating-point number,
256 sprintf (name
, "__%s_MIN__", name_prefix
);
257 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
258 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
260 /* The difference between 1 and the least value greater than 1 that is
261 representable in the given floating point type, b**(1-p). */
262 sprintf (name
, "__%s_EPSILON__", name_prefix
);
263 if (fmt
->pnan
< fmt
->p
)
264 /* This is an IBM extended double format, so 1.0 + any double is
265 representable precisely. */
266 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
268 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
269 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
271 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
272 positive floating-point number, b**(emin-p). Zero for formats that
273 don't support denormals. */
274 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
277 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
278 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
279 buf
, fp_suffix
, fp_cast
);
283 sprintf (buf
, "0.0%s", fp_suffix
);
284 builtin_define_with_value (name
, buf
, 0);
287 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
288 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
290 /* For C++ std::numeric_limits<T>::has_infinity. */
291 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
292 builtin_define_with_int_value (name
,
293 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
294 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
295 predicate to distinguish a target that has both quiet and
296 signalling NaNs from a target that has only quiet NaNs or only
297 signalling NaNs, so we assume that a target that has any kind of
298 NaN has quiet NaNs. */
299 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
300 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
302 /* Note whether we have fast FMA. */
303 if (mode_has_fma (TYPE_MODE (type
)))
305 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
306 builtin_define_with_int_value (name
, 1);
310 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
312 builtin_define_decimal_float_constants (const char *name_prefix
,
316 const struct real_format
*fmt
;
317 char name
[64], buf
[128], *p
;
320 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
322 /* The number of radix digits, p, in the significand. */
323 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
324 builtin_define_with_int_value (name
, fmt
->p
);
326 /* The minimum negative int x such that b**(x-1) is a normalized float. */
327 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
328 sprintf (buf
, "(%d)", fmt
->emin
);
329 builtin_define_with_value (name
, buf
, 0);
331 /* The maximum int x such that b**(x-1) is a representable float. */
332 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
333 builtin_define_with_int_value (name
, fmt
->emax
);
335 /* Compute the minimum representable value. */
336 sprintf (name
, "__%s_MIN__", name_prefix
);
337 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
338 builtin_define_with_value (name
, buf
, 0);
340 /* Compute the maximum representable value. */
341 sprintf (name
, "__%s_MAX__", name_prefix
);
343 for (digits
= fmt
->p
; digits
; digits
--)
346 if (digits
== fmt
->p
)
350 /* fmt->p plus 1, to account for the decimal point and fmt->emax
351 minus 1 because the digits are nines, not 1.0. */
352 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
353 builtin_define_with_value (name
, buf
, 0);
355 /* Compute epsilon (the difference between 1 and least value greater
356 than 1 representable). */
357 sprintf (name
, "__%s_EPSILON__", name_prefix
);
358 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
359 builtin_define_with_value (name
, buf
, 0);
361 /* Minimum subnormal positive decimal value. */
362 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
364 for (digits
= fmt
->p
; digits
> 1; digits
--)
367 if (digits
== fmt
->p
)
371 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
372 builtin_define_with_value (name
, buf
, 0);
375 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
378 builtin_define_fixed_point_constants (const char *name_prefix
,
382 char name
[64], buf
[256], *new_buf
;
385 sprintf (name
, "__%s_FBIT__", name_prefix
);
386 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
388 sprintf (name
, "__%s_IBIT__", name_prefix
);
389 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
391 /* If there is no suffix, defines are for fixed-point modes.
393 if (strcmp (suffix
, "") == 0)
396 if (TYPE_UNSIGNED (type
))
398 sprintf (name
, "__%s_MIN__", name_prefix
);
399 sprintf (buf
, "0.0%s", suffix
);
400 builtin_define_with_value (name
, buf
, 0);
404 sprintf (name
, "__%s_MIN__", name_prefix
);
405 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
406 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
407 TYPE_IBIT (type
) - 1, suffix
);
409 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
410 builtin_define_with_value (name
, buf
, 0);
413 sprintf (name
, "__%s_MAX__", name_prefix
);
416 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
418 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
419 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
420 sprintf (new_buf
++, "F");
421 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
422 builtin_define_with_value (name
, buf
, 0);
424 sprintf (name
, "__%s_EPSILON__", name_prefix
);
425 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
426 builtin_define_with_value (name
, buf
, 0);
429 /* Define macros used by <stdint.h>. */
431 builtin_define_stdint_macros (void)
433 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
434 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
435 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
436 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
437 if (sig_atomic_type_node
)
438 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
439 sig_atomic_type_node
);
441 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
443 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
445 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
447 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
449 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
450 if (uint16_type_node
)
451 builtin_define_type_max ("__UINT16_MAX__", uint16_type_node
);
452 if (c_uint32_type_node
)
453 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
454 if (c_uint64_type_node
)
455 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
456 if (int_least8_type_node
)
458 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
459 builtin_define_constants ("__INT8_C", int_least8_type_node
);
461 if (int_least16_type_node
)
463 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
464 builtin_define_constants ("__INT16_C", int_least16_type_node
);
466 if (int_least32_type_node
)
468 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
469 builtin_define_constants ("__INT32_C", int_least32_type_node
);
471 if (int_least64_type_node
)
473 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
474 builtin_define_constants ("__INT64_C", int_least64_type_node
);
476 if (uint_least8_type_node
)
478 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
479 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
481 if (uint_least16_type_node
)
483 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
484 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
486 if (uint_least32_type_node
)
488 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
489 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
491 if (uint_least64_type_node
)
493 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
494 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
496 if (int_fast8_type_node
)
497 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
498 if (int_fast16_type_node
)
499 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
500 if (int_fast32_type_node
)
501 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
502 if (int_fast64_type_node
)
503 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
504 if (uint_fast8_type_node
)
505 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
506 if (uint_fast16_type_node
)
507 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
508 if (uint_fast32_type_node
)
509 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
510 if (uint_fast64_type_node
)
511 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
512 if (intptr_type_node
)
513 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
514 if (uintptr_type_node
)
515 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
518 /* Adjust the optimization macros when a #pragma GCC optimization is done to
519 reflect the current level. */
521 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
524 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
525 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
529 /* -undef turns off target-specific built-ins. */
533 /* Other target-independent built-ins determined by command-line
535 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
536 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
537 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
538 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
540 if (!prev
->x_optimize
&& cur
->x_optimize
)
541 cpp_define (pfile
, "__OPTIMIZE__");
542 else if (prev
->x_optimize
&& !cur
->x_optimize
)
543 cpp_undef (pfile
, "__OPTIMIZE__");
545 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
546 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
547 if (!prev_fast_math
&& cur_fast_math
)
548 cpp_define (pfile
, "__FAST_MATH__");
549 else if (prev_fast_math
&& !cur_fast_math
)
550 cpp_undef (pfile
, "__FAST_MATH__");
552 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
553 cpp_define (pfile
, "__SUPPORT_SNAN__");
554 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
555 cpp_undef (pfile
, "__SUPPORT_SNAN__");
557 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
559 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
560 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
562 else if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
564 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
565 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
570 /* Hook that registers front end and target-specific built-ins. */
572 c_cpp_builtins (cpp_reader
*pfile
)
574 /* -undef turns off target-specific built-ins. */
578 define_language_independent_builtin_macros (pfile
);
580 if (c_dialect_cxx ())
583 parse_basever (&major
, NULL
, NULL
);
584 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
587 /* For stddef.h. They require macros defined in c-common.c. */
588 c_stddef_cpp_builtins ();
590 if (c_dialect_cxx ())
592 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
593 cpp_define (pfile
, "__GXX_WEAK__=1");
595 cpp_define (pfile
, "__GXX_WEAK__=0");
597 cpp_define (pfile
, "__DEPRECATED");
599 cpp_define (pfile
, "__GXX_RTTI");
600 if (cxx_dialect
== cxx0x
)
601 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
603 /* Note that we define this for C as well, so that we know if
604 __attribute__((cleanup)) will interface with EH. */
606 cpp_define (pfile
, "__EXCEPTIONS");
608 /* Represents the C++ ABI version, always defined so it can be used while
609 preprocessing C and assembler. */
610 if (flag_abi_version
== 0)
611 /* Use a very large value so that:
613 #if __GXX_ABI_VERSION >= <value for version X>
615 will work whether the user explicitly says "-fabi-version=x" or
616 "-fabi-version=0". Do not use INT_MAX because that will be
617 different from system to system. */
618 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
619 else if (flag_abi_version
== 1)
620 /* Due to a historical accident, this version had the value
622 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
624 /* Newer versions have values 1002, 1003, .... */
625 builtin_define_with_int_value ("__GXX_ABI_VERSION",
626 1000 + flag_abi_version
);
628 /* libgcc needs to know this. */
629 if (targetm
.except_unwind_info (&global_options
) == UI_SJLJ
)
630 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
632 /* limits.h and stdint.h need to know these. */
633 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
634 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
635 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
636 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
637 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
638 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
639 underlying_wchar_type_node
);
640 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
641 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
642 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
644 /* stdint.h and the testsuite need to know these. */
645 builtin_define_stdint_macros ();
647 /* float.h needs to know this. */
648 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
649 TARGET_FLT_EVAL_METHOD
);
651 /* And decfloat.h needs this. */
652 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
653 TARGET_DEC_EVAL_METHOD
);
655 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
656 /* Cast the double precision constants. This is needed when single
657 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
658 is used. The correct result is computed by the compiler when using
659 macros that include a cast. We use a different cast for C++ to avoid
660 problems with -Wold-style-cast. */
661 builtin_define_float_constants ("DBL", "L",
665 "", double_type_node
);
666 builtin_define_float_constants ("LDBL", "L", "%s", "L",
667 long_double_type_node
);
669 /* For decfloat.h. */
670 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
671 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
672 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
674 /* For fixed-point fibt, ibit, max, min, and epsilon. */
675 if (targetm
.fixed_point_supported_p ())
677 builtin_define_fixed_point_constants ("SFRACT", "HR",
678 short_fract_type_node
);
679 builtin_define_fixed_point_constants ("USFRACT", "UHR",
680 unsigned_short_fract_type_node
);
681 builtin_define_fixed_point_constants ("FRACT", "R",
683 builtin_define_fixed_point_constants ("UFRACT", "UR",
684 unsigned_fract_type_node
);
685 builtin_define_fixed_point_constants ("LFRACT", "LR",
686 long_fract_type_node
);
687 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
688 unsigned_long_fract_type_node
);
689 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
690 long_long_fract_type_node
);
691 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
692 unsigned_long_long_fract_type_node
);
693 builtin_define_fixed_point_constants ("SACCUM", "HK",
694 short_accum_type_node
);
695 builtin_define_fixed_point_constants ("USACCUM", "UHK",
696 unsigned_short_accum_type_node
);
697 builtin_define_fixed_point_constants ("ACCUM", "K",
699 builtin_define_fixed_point_constants ("UACCUM", "UK",
700 unsigned_accum_type_node
);
701 builtin_define_fixed_point_constants ("LACCUM", "LK",
702 long_accum_type_node
);
703 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
704 unsigned_long_accum_type_node
);
705 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
706 long_long_accum_type_node
);
707 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
708 unsigned_long_long_accum_type_node
);
710 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
711 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
712 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
713 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
714 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
715 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
716 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
717 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
718 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
719 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
720 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
721 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
722 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
723 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
724 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
725 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
726 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
727 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
730 /* For libgcc-internal use only. */
731 if (flag_building_libgcc
)
732 /* For libgcc enable-execute-stack.c. */
733 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
736 /* For use in assembly language. */
737 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
738 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
741 if (flag_gnu89_inline
)
742 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
744 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
747 cpp_define (pfile
, "__NO_INLINE__");
750 cpp_define (pfile
, "__STRICT_ANSI__");
752 if (!flag_signed_char
)
753 cpp_define (pfile
, "__CHAR_UNSIGNED__");
755 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
756 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
758 /* Tell source code if the compiler makes sync_compare_and_swap
759 builtins available. */
760 #ifdef HAVE_sync_compare_and_swapqi
761 if (HAVE_sync_compare_and_swapqi
)
762 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
765 #ifdef HAVE_sync_compare_and_swaphi
766 if (HAVE_sync_compare_and_swaphi
)
767 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
770 #ifdef HAVE_sync_compare_and_swapsi
771 if (HAVE_sync_compare_and_swapsi
)
772 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
775 #ifdef HAVE_sync_compare_and_swapdi
776 if (HAVE_sync_compare_and_swapdi
)
777 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
780 #ifdef HAVE_sync_compare_and_swapti
781 if (HAVE_sync_compare_and_swapti
)
782 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
785 #ifdef DWARF2_UNWIND_INFO
786 if (dwarf2out_do_cfi_asm ())
787 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
790 /* Make the choice of ObjC runtime visible to source code. */
791 if (c_dialect_objc () && flag_next_runtime
)
792 cpp_define (pfile
, "__NEXT_RUNTIME__");
794 /* Show the availability of some target pragmas. */
795 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
797 if (targetm
.handle_pragma_extern_prefix
)
798 cpp_define (pfile
, "__PRAGMA_EXTERN_PREFIX");
800 /* Make the choice of the stack protector runtime visible to source code.
801 The macro names and values here were chosen for compatibility with an
802 earlier implementation, i.e. ProPolice. */
803 if (flag_stack_protect
== 2)
804 cpp_define (pfile
, "__SSP_ALL__=2");
805 else if (flag_stack_protect
== 1)
806 cpp_define (pfile
, "__SSP__=1");
809 cpp_define (pfile
, "_OPENMP=200805");
811 if (int128_integer_type_node
!= NULL_TREE
)
812 builtin_define_type_sizeof ("__SIZEOF_INT128__",
813 int128_integer_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
);
819 /* A straightforward target hook doesn't work, because of problems
820 linking that hook's body when part of non-C front ends. */
821 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
822 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
823 # define builtin_define(TXT) cpp_define (pfile, TXT)
824 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
825 TARGET_CPU_CPP_BUILTINS ();
826 TARGET_OS_CPP_BUILTINS ();
827 TARGET_OBJFMT_CPP_BUILTINS ();
829 /* Support the __declspec keyword by turning them into attributes.
830 Note that the current way we do this may result in a collision
831 with predefined attributes later on. This can be solved by using
832 one attribute, say __declspec__, and passing args to it. The
833 problem with that approach is that args are not accumulated: each
834 new appearance would clobber any existing args. */
836 builtin_define ("__declspec(x)=__attribute__((x))");
838 /* If decimal floating point is supported, tell the user if the
839 alternate format (BID) is used instead of the standard (DPD)
841 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
842 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
845 /* Pass an object-like macro. If it doesn't lie in the user's
846 namespace, defines it unconditionally. Otherwise define a version
847 with two leading underscores, and another version with two leading
848 and trailing underscores, and define the original only if an ISO
849 standard was not nominated.
851 e.g. passing "unix" defines "__unix", "__unix__" and possibly
852 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
855 builtin_define_std (const char *macro
)
857 size_t len
= strlen (macro
);
858 char *buff
= (char *) alloca (len
+ 5);
862 /* prepend __ (or maybe just _) if in user's namespace. */
863 memcpy (p
, macro
, len
+ 1);
864 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
871 cpp_define (parse_in
, p
);
873 /* If it was in user's namespace... */
876 /* Define the macro with leading and following __. */
882 cpp_define (parse_in
, p
);
884 /* Finally, define the original macro if permitted. */
886 cpp_define (parse_in
, macro
);
890 /* Pass an object-like macro and a value to define it to. The third
891 parameter says whether or not to turn the value into a string
894 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
897 size_t mlen
= strlen (macro
);
898 size_t elen
= strlen (expansion
);
899 size_t extra
= 2; /* space for an = and a NUL */
902 extra
+= 2; /* space for two quote marks */
904 buf
= (char *) alloca (mlen
+ elen
+ extra
);
906 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
908 sprintf (buf
, "%s=%s", macro
, expansion
);
910 cpp_define (parse_in
, buf
);
914 /* Pass an object-like macro and an integer value to define it to. */
916 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
919 size_t mlen
= strlen (macro
);
921 size_t extra
= 2; /* space for = and NUL. */
923 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
924 memcpy (buf
, macro
, mlen
);
926 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
928 cpp_define (parse_in
, buf
);
931 /* builtin_define_with_hex_fp_value is very expensive, so the following
932 array and function allows it to be done lazily when __DBL_MAX__
933 etc. is first used. */
935 struct GTY(()) lazy_hex_fp_value_struct
939 enum machine_mode mode
;
941 const char *fp_suffix
;
943 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
944 static GTY(()) int lazy_hex_fp_value_count
;
947 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
950 REAL_VALUE_TYPE real
;
951 char dec_str
[64], buf1
[256];
953 if (node
->value
.builtin
< BT_FIRST_USER
954 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
957 idx
= node
->value
.builtin
- BT_FIRST_USER
;
958 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
959 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
960 lazy_hex_fp_values
[idx
].digits
, 0,
961 lazy_hex_fp_values
[idx
].mode
);
963 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
964 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
965 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
966 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
967 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
969 gcc_assert (idx
< node
->value
.macro
->count
);
970 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
971 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
972 = (const unsigned char *) ggc_strdup (buf1
);
976 /* Pass an object-like macro a hexadecimal floating-point value. */
978 builtin_define_with_hex_fp_value (const char *macro
,
979 tree type
, int digits
,
981 const char *fp_suffix
,
984 REAL_VALUE_TYPE real
;
985 char dec_str
[64], buf1
[256], buf2
[256];
987 /* This is very expensive, so if possible expand them lazily. */
988 if (lazy_hex_fp_value_count
< 12
989 && flag_dump_macros
== 0
990 && !cpp_get_options (parse_in
)->traditional
)
992 struct cpp_hashnode
*node
;
993 if (lazy_hex_fp_value_count
== 0)
994 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
995 sprintf (buf2
, fp_cast
, "1.1");
996 sprintf (buf1
, "%s=%s", macro
, buf2
);
997 cpp_define (parse_in
, buf1
);
998 node
= C_CPP_HASHNODE (get_identifier (macro
));
999 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1000 = ggc_strdup (hex_str
);
1001 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1002 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1003 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1004 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1005 node
->flags
|= NODE_BUILTIN
;
1007 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1008 lazy_hex_fp_value_count
++;
1012 /* Hex values are really cool and convenient, except that they're
1013 not supported in strict ISO C90 mode. First, the "p-" sequence
1014 is not valid as part of a preprocessor number. Second, we get a
1015 pedwarn from the preprocessor, which has no context, so we can't
1016 suppress the warning with __extension__.
1018 So instead what we do is construct the number in hex (because
1019 it's easy to get the exact correct value), parse it as a real,
1020 then print it back out as decimal. */
1022 real_from_string (&real
, hex_str
);
1023 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1026 /* Assemble the macro in the following fashion
1027 macro = fp_cast [dec_str fp_suffix] */
1028 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1029 sprintf (buf2
, fp_cast
, buf1
);
1030 sprintf (buf1
, "%s=%s", macro
, buf2
);
1032 cpp_define (parse_in
, buf1
);
1035 /* Return a string constant for the suffix for a value of type TYPE
1036 promoted according to the integer promotions. The type must be one
1037 of the standard integer type nodes. */
1040 type_suffix (tree type
)
1042 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1043 int unsigned_suffix
;
1046 if (type
== long_long_integer_type_node
1047 || type
== long_long_unsigned_type_node
)
1049 else if (type
== long_integer_type_node
1050 || type
== long_unsigned_type_node
)
1052 else if (type
== integer_type_node
1053 || type
== unsigned_type_node
1054 || type
== short_integer_type_node
1055 || type
== short_unsigned_type_node
1056 || type
== signed_char_type_node
1057 || type
== unsigned_char_type_node
1058 /* ??? "char" is not a signed or unsigned integer type and
1059 so is not permitted for the standard typedefs, but some
1060 systems use it anyway. */
1061 || type
== char_type_node
)
1066 unsigned_suffix
= TYPE_UNSIGNED (type
);
1067 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1068 unsigned_suffix
= 0;
1069 return suffixes
[is_long
* 2 + unsigned_suffix
];
1072 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1074 builtin_define_constants (const char *macro
, tree type
)
1079 suffix
= type_suffix (type
);
1083 buf
= (char *) alloca (strlen (macro
) + 6);
1084 sprintf (buf
, "%s(c)=c", macro
);
1088 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1089 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1092 cpp_define (parse_in
, buf
);
1095 /* Define MAX for TYPE based on the precision of the type. */
1098 builtin_define_type_max (const char *macro
, tree type
)
1100 builtin_define_type_minmax (NULL
, macro
, type
);
1103 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1104 precision of the type. */
1107 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1110 static const char *const values
[]
1113 "2147483647", "4294967295",
1114 "9223372036854775807", "18446744073709551615",
1115 "170141183460469231731687303715884105727",
1116 "340282366920938463463374607431768211455" };
1118 const char *value
, *suffix
;
1122 /* Pre-rendering the values mean we don't have to futz with printing a
1123 multi-word decimal value. There are also a very limited number of
1124 precisions that we support, so it's really a waste of time. */
1125 switch (TYPE_PRECISION (type
))
1127 case 8: idx
= 0; break;
1128 case 16: idx
= 2; break;
1129 case 32: idx
= 4; break;
1130 case 64: idx
= 6; break;
1131 case 128: idx
= 8; break;
1132 default: gcc_unreachable ();
1135 value
= values
[idx
+ TYPE_UNSIGNED (type
)];
1136 suffix
= type_suffix (type
);
1138 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1139 + strlen (suffix
) + 1);
1140 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1142 cpp_define (parse_in
, buf
);
1146 if (TYPE_UNSIGNED (type
))
1148 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1149 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1153 buf
= (char *) alloca (strlen (min_macro
) + 3
1154 + strlen (max_macro
) + 6);
1155 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1157 cpp_define (parse_in
, buf
);
1161 #include "gt-c-family-c-cppbuiltin.h"