1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2022 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 3, 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 COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
27 #include "stringpool.h"
28 #include "stor-layout.h"
31 #include "output.h" /* For user_label_prefix. */
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
33 #include "common/common-target.h"
34 #include "cppbuiltin.h"
35 #include "configargs.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 static void builtin_define_with_hex_fp_value (const char *, tree
,
54 static void builtin_define_stdint_macros (void);
55 static void builtin_define_constants (const char *, tree
);
56 static void builtin_define_type_max (const char *, tree
);
57 static void builtin_define_type_minmax (const char *, const char *, tree
);
58 static void builtin_define_type_width (const char *, tree
, tree
);
59 static void builtin_define_float_constants (const char *,
65 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
66 Originally this function used the fma optab, but that doesn't work with
67 -save-temps, so just rely on the HAVE_fma macros for the standard floating
71 mode_has_fma (machine_mode mode
)
85 #ifdef HAVE_fmakf4 /* PowerPC if long double != __float128. */
107 /* Define NAME with value TYPE size_unit. */
109 builtin_define_type_sizeof (const char *name
, tree type
)
111 builtin_define_with_int_value (name
,
112 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
115 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
118 builtin_define_float_constants (const char *name_prefix
,
119 const char *fp_suffix
,
121 const char *fma_suffix
,
124 /* Used to convert radix-based values to base 10 values in several cases.
126 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
127 least 6 significant digits for correct results. Using the fraction
128 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
129 intermediate; perhaps someone can find a better approximation, in the
130 mean time, I suspect using doubles won't harm the bootstrap here. */
132 const double log10_2
= .30102999566398119521;
134 const struct real_format
*fmt
;
135 const struct real_format
*widefmt
;
137 char name
[64], buf
[128];
138 int dig
, min_10_exp
, max_10_exp
;
140 int type_decimal_dig
;
142 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
143 gcc_assert (fmt
->b
!= 10);
144 widefmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
145 gcc_assert (widefmt
->b
!= 10);
146 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
148 tree wtype
= FLOATN_NX_TYPE_NODE (i
);
149 if (wtype
!= NULL_TREE
)
151 const struct real_format
*wfmt
152 = REAL_MODE_FORMAT (TYPE_MODE (wtype
));
153 gcc_assert (wfmt
->b
!= 10);
154 if (wfmt
->p
> widefmt
->p
)
159 /* The radix of the exponent representation. */
160 if (type
== float_type_node
)
161 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
164 /* The number of radix digits, p, in the floating-point significand. */
165 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
166 builtin_define_with_int_value (name
, fmt
->p
);
168 /* The number of decimal digits, q, such that any floating-point number
169 with q decimal digits can be rounded into a floating-point number with
170 p radix b digits and back again without change to the q decimal digits,
172 p log10 b if b is a power of 10
173 floor((p - 1) log10 b) otherwise
175 dig
= (fmt
->p
- 1) * log10_b
;
176 sprintf (name
, "__%s_DIG__", name_prefix
);
177 builtin_define_with_int_value (name
, dig
);
179 /* The minimum negative int x such that b**(x-1) is a normalized float. */
180 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
181 sprintf (buf
, "(%d)", fmt
->emin
);
182 builtin_define_with_value (name
, buf
, 0);
184 /* The minimum negative int x such that 10**x is a normalized float,
186 ceil (log10 (b ** (emin - 1)))
187 = ceil (log10 (b) * (emin - 1))
189 Recall that emin is negative, so the integer truncation calculates
190 the ceiling, not the floor, in this case. */
191 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
192 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
193 sprintf (buf
, "(%d)", min_10_exp
);
194 builtin_define_with_value (name
, buf
, 0);
196 /* The maximum int x such that b**(x-1) is a representable float. */
197 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
198 builtin_define_with_int_value (name
, fmt
->emax
);
200 /* The maximum int x such that 10**x is in the range of representable
201 finite floating-point numbers,
203 floor (log10((1 - b**-p) * b**emax))
204 = floor (log10(1 - b**-p) + log10(b**emax))
205 = floor (log10(1 - b**-p) + log10(b)*emax)
207 The safest thing to do here is to just compute this number. But since
208 we don't link cc1 with libm, we cannot. We could implement log10 here
209 a series expansion, but that seems too much effort because:
211 Note that the first term, for all extant p, is a number exceedingly close
212 to zero, but slightly negative. Note that the second term is an integer
213 scaling an irrational number, and that because of the floor we are only
214 interested in its integral portion.
216 In order for the first term to have any effect on the integral portion
217 of the second term, the second term has to be exceedingly close to an
218 integer itself (e.g. 123.000000000001 or something). Getting a result
219 that close to an integer requires that the irrational multiplicand have
220 a long series of zeros in its expansion, which doesn't occur in the
221 first 20 digits or so of log10(b).
223 Hand-waving aside, crunching all of the sets of constants above by hand
224 does not yield a case for which the first term is significant, which
225 in the end is all that matters. */
226 max_10_exp
= fmt
->emax
* log10_b
;
227 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
228 builtin_define_with_int_value (name
, max_10_exp
);
230 /* The number of decimal digits, n, such that any floating-point number
231 can be rounded to n decimal digits and back again without change to
234 p * log10(b) if b is a power of 10
235 ceil(1 + p * log10(b)) otherwise
237 The only macro we care about is this number for the widest supported
238 floating type, but we want this value for rendering constants below. */
241 = 1 + (fmt
->p
< widefmt
->p
? widefmt
->p
: fmt
->p
) * log10_b
;
242 decimal_dig
= d_decimal_dig
;
243 if (decimal_dig
< d_decimal_dig
)
246 /* Similar, for this type rather than long double. */
248 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
249 type_decimal_dig
= type_d_decimal_dig
;
250 if (type_decimal_dig
< type_d_decimal_dig
)
253 /* Define __DECIMAL_DIG__ to the value for long double to be
254 compatible with C99 and C11; see DR#501 and N2108. */
255 if (type
== long_double_type_node
)
256 builtin_define_with_int_value ("__DECIMAL_DIG__", type_decimal_dig
);
257 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
258 builtin_define_with_int_value (name
, type_decimal_dig
);
260 /* Since, for the supported formats, B is always a power of 2, we
261 construct the following numbers directly as a hexadecimal
263 get_max_float (fmt
, buf
, sizeof (buf
), false);
265 sprintf (name
, "__%s_MAX__", name_prefix
);
266 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
268 get_max_float (fmt
, buf
, sizeof (buf
), true);
270 sprintf (name
, "__%s_NORM_MAX__", name_prefix
);
271 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
273 /* The minimum normalized positive floating-point number,
275 sprintf (name
, "__%s_MIN__", name_prefix
);
276 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
277 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
279 /* The difference between 1 and the least value greater than 1 that is
280 representable in the given floating point type, b**(1-p). */
281 sprintf (name
, "__%s_EPSILON__", name_prefix
);
282 if (fmt
->pnan
< fmt
->p
)
283 /* This is an IBM extended double format, so 1.0 + any double is
284 representable precisely. */
285 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
287 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
288 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
290 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
291 The minimum denormalized positive floating-point number, b**(emin-p).
292 The minimum normalized positive floating-point number for formats
293 that don't support denormals. */
294 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
295 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
296 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
297 buf
, fp_suffix
, fp_cast
);
299 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
300 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
302 /* For C++ std::numeric_limits<T>::has_infinity. */
303 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
304 builtin_define_with_int_value (name
,
305 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
306 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
307 predicate to distinguish a target that has both quiet and
308 signalling NaNs from a target that has only quiet NaNs or only
309 signalling NaNs, so we assume that a target that has any kind of
310 NaN has quiet NaNs. */
311 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
312 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
314 /* Note whether we have fast FMA. */
315 if (mode_has_fma (TYPE_MODE (type
)) && fma_suffix
!= NULL
)
317 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
318 builtin_define_with_int_value (name
, 1);
321 /* For C2x *_IS_IEC_60559. 0 means the type does not match an IEC
322 60559 format, 1 that it matches a format but not operations and 2
323 that it matches a format and operations (but may not conform to
324 Annex F; we take this as meaning exceptions and rounding modes
325 need not be supported). */
326 sprintf (name
, "__%s_IS_IEC_60559__", name_prefix
);
327 builtin_define_with_int_value (name
,
329 ? 0 : (fmt
->round_towards_zero
? 1 : 2)));
332 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
334 builtin_define_decimal_float_constants (const char *name_prefix
,
338 const struct real_format
*fmt
;
339 char name
[64], buf
[128], *p
;
342 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
344 /* The number of radix digits, p, in the significand. */
345 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
346 builtin_define_with_int_value (name
, fmt
->p
);
348 /* The minimum negative int x such that b**(x-1) is a normalized float. */
349 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
350 sprintf (buf
, "(%d)", fmt
->emin
);
351 builtin_define_with_value (name
, buf
, 0);
353 /* The maximum int x such that b**(x-1) is a representable float. */
354 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
355 builtin_define_with_int_value (name
, fmt
->emax
);
357 /* Compute the minimum representable value. */
358 sprintf (name
, "__%s_MIN__", name_prefix
);
359 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
360 builtin_define_with_value (name
, buf
, 0);
362 /* Compute the maximum representable value. */
363 sprintf (name
, "__%s_MAX__", name_prefix
);
365 for (digits
= fmt
->p
; digits
; digits
--)
368 if (digits
== fmt
->p
)
372 /* fmt->p plus 1, to account for the decimal point and fmt->emax
373 minus 1 because the digits are nines, not 1.0. */
374 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
375 builtin_define_with_value (name
, buf
, 0);
377 /* Compute epsilon (the difference between 1 and least value greater
378 than 1 representable). */
379 sprintf (name
, "__%s_EPSILON__", name_prefix
);
380 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
381 builtin_define_with_value (name
, buf
, 0);
383 /* Minimum subnormal positive decimal value. */
384 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
386 for (digits
= fmt
->p
; digits
> 1; digits
--)
389 if (digits
== fmt
->p
)
393 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
394 builtin_define_with_value (name
, buf
, 0);
397 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
400 builtin_define_fixed_point_constants (const char *name_prefix
,
404 char name
[64], buf
[256], *new_buf
;
407 sprintf (name
, "__%s_FBIT__", name_prefix
);
408 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
410 sprintf (name
, "__%s_IBIT__", name_prefix
);
411 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
413 /* If there is no suffix, defines are for fixed-point modes.
415 if (strcmp (suffix
, "") == 0)
418 if (TYPE_UNSIGNED (type
))
420 sprintf (name
, "__%s_MIN__", name_prefix
);
421 sprintf (buf
, "0.0%s", suffix
);
422 builtin_define_with_value (name
, buf
, 0);
426 sprintf (name
, "__%s_MIN__", name_prefix
);
427 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
428 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
429 TYPE_IBIT (type
) - 1, suffix
);
431 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
432 builtin_define_with_value (name
, buf
, 0);
435 sprintf (name
, "__%s_MAX__", name_prefix
);
438 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
440 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
441 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
442 sprintf (new_buf
++, "F");
443 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
444 builtin_define_with_value (name
, buf
, 0);
446 sprintf (name
, "__%s_EPSILON__", name_prefix
);
447 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
448 builtin_define_with_value (name
, buf
, 0);
451 /* Define macros used by <stdint.h>. */
453 builtin_define_stdint_macros (void)
455 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
456 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
457 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
458 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
459 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node
,
461 if (sig_atomic_type_node
)
463 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
464 sig_atomic_type_node
);
465 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node
,
469 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
471 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
473 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
475 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
477 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
478 if (c_uint16_type_node
)
479 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
480 if (c_uint32_type_node
)
481 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
482 if (c_uint64_type_node
)
483 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
484 if (int_least8_type_node
)
486 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
487 builtin_define_constants ("__INT8_C", int_least8_type_node
);
488 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node
,
489 uint_least8_type_node
);
491 if (int_least16_type_node
)
493 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
494 builtin_define_constants ("__INT16_C", int_least16_type_node
);
495 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
496 int_least16_type_node
,
497 uint_least16_type_node
);
499 if (int_least32_type_node
)
501 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
502 builtin_define_constants ("__INT32_C", int_least32_type_node
);
503 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
504 int_least32_type_node
,
505 uint_least32_type_node
);
507 if (int_least64_type_node
)
509 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
510 builtin_define_constants ("__INT64_C", int_least64_type_node
);
511 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
512 int_least64_type_node
,
513 uint_least64_type_node
);
515 if (uint_least8_type_node
)
517 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
518 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
520 if (uint_least16_type_node
)
522 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
523 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
525 if (uint_least32_type_node
)
527 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
528 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
530 if (uint_least64_type_node
)
532 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
533 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
535 if (int_fast8_type_node
)
537 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
538 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node
,
539 uint_fast8_type_node
);
541 if (int_fast16_type_node
)
543 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
544 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node
,
545 uint_fast16_type_node
);
547 if (int_fast32_type_node
)
549 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
550 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node
,
551 uint_fast32_type_node
);
553 if (int_fast64_type_node
)
555 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
556 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node
,
557 uint_fast64_type_node
);
559 if (uint_fast8_type_node
)
560 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
561 if (uint_fast16_type_node
)
562 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
563 if (uint_fast32_type_node
)
564 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
565 if (uint_fast64_type_node
)
566 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
567 if (intptr_type_node
)
569 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
570 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node
,
573 if (uintptr_type_node
)
574 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
577 /* Adjust the optimization macros when a #pragma GCC optimization is done to
578 reflect the current level. */
580 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
583 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
584 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
588 /* -undef turns off target-specific built-ins. */
592 /* Make sure all of the builtins about to be declared have
593 BUILTINS_LOCATION has their location_t. */
594 cpp_force_token_locations (parse_in
, BUILTINS_LOCATION
);
596 /* Other target-independent built-ins determined by command-line
598 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
599 cpp_define_unused (pfile
, "__OPTIMIZE_SIZE__");
600 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
601 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
603 if (!prev
->x_optimize
&& cur
->x_optimize
)
604 cpp_define_unused (pfile
, "__OPTIMIZE__");
605 else if (prev
->x_optimize
&& !cur
->x_optimize
)
606 cpp_undef (pfile
, "__OPTIMIZE__");
608 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
609 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
610 if (!prev_fast_math
&& cur_fast_math
)
611 cpp_define_unused (pfile
, "__FAST_MATH__");
612 else if (prev_fast_math
&& !cur_fast_math
)
613 cpp_undef (pfile
, "__FAST_MATH__");
615 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
616 cpp_define_unused (pfile
, "__SUPPORT_SNAN__");
617 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
618 cpp_undef (pfile
, "__SUPPORT_SNAN__");
620 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
621 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
622 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
623 cpp_define_unused (pfile
, "__NO_MATH_ERRNO__");
625 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
627 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
628 cpp_define_unused (pfile
, "__FINITE_MATH_ONLY__=1");
630 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
632 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
633 cpp_define_unused (pfile
, "__FINITE_MATH_ONLY__=0");
636 if (!prev
->x_flag_reciprocal_math
&& cur
->x_flag_reciprocal_math
)
637 cpp_define_unused (pfile
, "__RECIPROCAL_MATH__");
638 else if (prev
->x_flag_reciprocal_math
&& !cur
->x_flag_reciprocal_math
)
639 cpp_undef (pfile
, "__RECIPROCAL_MATH__");
641 if (!prev
->x_flag_signed_zeros
&& cur
->x_flag_signed_zeros
)
642 cpp_undef (pfile
, "__NO_SIGNED_ZEROS__");
643 else if (prev
->x_flag_signed_zeros
&& !cur
->x_flag_signed_zeros
)
644 cpp_define_unused (pfile
, "__NO_SIGNED_ZEROS__");
646 if (!prev
->x_flag_trapping_math
&& cur
->x_flag_trapping_math
)
647 cpp_undef (pfile
, "__NO_TRAPPING_MATH__");
648 else if (prev
->x_flag_trapping_math
&& !cur
->x_flag_trapping_math
)
649 cpp_define_unused (pfile
, "__NO_TRAPPING_MATH__");
651 if (!prev
->x_flag_associative_math
&& cur
->x_flag_associative_math
)
652 cpp_define_unused (pfile
, "__ASSOCIATIVE_MATH__");
653 else if (prev
->x_flag_associative_math
&& !cur
->x_flag_associative_math
)
654 cpp_undef (pfile
, "__ASSOCIATIVE_MATH__");
656 if (!prev
->x_flag_rounding_math
&& cur
->x_flag_rounding_math
)
657 cpp_define_unused (pfile
, "__ROUNDING_MATH__");
658 else if (prev
->x_flag_rounding_math
&& !cur
->x_flag_rounding_math
)
659 cpp_undef (pfile
, "__ROUNDING_MATH__");
661 cpp_stop_forcing_token_locations (parse_in
);
665 /* This function will emit cpp macros to indicate the presence of various lock
666 free atomic operations. */
669 cpp_atomic_builtins (cpp_reader
*pfile
)
671 /* Set a flag for each size of object that compare and swap exists for up to
673 #define SWAP_LIMIT 17
674 bool have_swap
[SWAP_LIMIT
];
677 /* Clear the map of sizes compare_and swap exists for. */
678 memset (have_swap
, 0, sizeof (have_swap
));
680 /* Tell source code if the compiler makes sync_compare_and_swap
681 builtins available. */
682 #ifndef HAVE_sync_compare_and_swapqi
683 #define HAVE_sync_compare_and_swapqi 0
685 #ifndef HAVE_atomic_compare_and_swapqi
686 #define HAVE_atomic_compare_and_swapqi 0
689 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
691 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
695 #ifndef HAVE_sync_compare_and_swaphi
696 #define HAVE_sync_compare_and_swaphi 0
698 #ifndef HAVE_atomic_compare_and_swaphi
699 #define HAVE_atomic_compare_and_swaphi 0
701 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
703 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
707 #ifndef HAVE_sync_compare_and_swapsi
708 #define HAVE_sync_compare_and_swapsi 0
710 #ifndef HAVE_atomic_compare_and_swapsi
711 #define HAVE_atomic_compare_and_swapsi 0
713 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
715 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
719 #ifndef HAVE_sync_compare_and_swapdi
720 #define HAVE_sync_compare_and_swapdi 0
722 #ifndef HAVE_atomic_compare_and_swapdi
723 #define HAVE_atomic_compare_and_swapdi 0
725 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
727 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
731 #ifndef HAVE_sync_compare_and_swapti
732 #define HAVE_sync_compare_and_swapti 0
734 #ifndef HAVE_atomic_compare_and_swapti
735 #define HAVE_atomic_compare_and_swapti 0
737 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
739 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
740 have_swap
[16] = true;
743 /* Tell the source code about various types. These map to the C++11 and C11
744 macros where 2 indicates lock-free always, and 1 indicates sometimes
746 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
747 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
748 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
749 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
750 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
751 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
753 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR8_T_LOCK_FREE",
754 (have_swap
[SWAP_INDEX (char8_type_node
)]? 2 : 1));
755 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
756 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
757 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
758 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
759 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
760 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
761 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
762 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
763 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
764 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
765 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
766 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
767 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
768 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
770 /* If we're dealing with a "set" value that doesn't exactly correspond
771 to a boolean truth value, let the library work around that. */
772 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
773 targetm
.atomic_test_and_set_trueval
);
775 /* Macros for C++17 hardware interference size constants. Either both or
776 neither should be set. */
777 gcc_assert (!param_destruct_interfere_size
778 == !param_construct_interfere_size
);
779 if (param_destruct_interfere_size
)
781 /* FIXME The way of communicating these values to the library should be
782 part of the C++ ABI, whether macro or builtin. */
783 builtin_define_with_int_value ("__GCC_DESTRUCTIVE_SIZE",
784 param_destruct_interfere_size
);
785 builtin_define_with_int_value ("__GCC_CONSTRUCTIVE_SIZE",
786 param_construct_interfere_size
);
789 /* ptr_type_node can't be used here since ptr_mode is only set when
790 toplev calls backend_init which is not done with -E or pch. */
791 psize
= POINTER_SIZE_UNITS
;
792 if (psize
>= SWAP_LIMIT
)
794 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
795 (have_swap
[psize
]? 2 : 1));
798 /* Return TRUE if the implicit excess precision in which the back-end will
799 compute floating-point calculations is not more than the explicit
800 excess precision that the front-end will apply under
801 -fexcess-precision=[standard|fast|16].
803 More intuitively, return TRUE if the excess precision proposed by the
804 front-end is the excess precision that will actually be used. */
807 c_cpp_flt_eval_method_iec_559 (void)
809 enum excess_precision_type front_end_ept
810 = (flag_excess_precision
== EXCESS_PRECISION_STANDARD
811 ? EXCESS_PRECISION_TYPE_STANDARD
812 : (flag_excess_precision
== EXCESS_PRECISION_FLOAT16
813 ? EXCESS_PRECISION_TYPE_FLOAT16
814 : EXCESS_PRECISION_TYPE_FAST
));
816 enum flt_eval_method back_end
817 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
819 enum flt_eval_method front_end
820 = targetm
.c
.excess_precision (front_end_ept
);
822 return excess_precision_mode_join (front_end
, back_end
) == front_end
;
825 /* Return the value for __GCC_IEC_559. */
827 cpp_iec_559_value (void)
829 /* The default is support for IEEE 754-2008. */
832 /* float and double must be binary32 and binary64. If they are but
833 with reversed NaN convention, at most IEEE 754-1985 is
835 const struct real_format
*ffmt
836 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
837 const struct real_format
*dfmt
838 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
839 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
844 || ffmt
->emin
!= -125
846 || ffmt
->signbit_rw
!= 31
847 || ffmt
->round_towards_zero
848 || !ffmt
->has_sign_dependent_rounding
852 || !ffmt
->has_signed_zero
856 || dfmt
->emin
!= -1021
857 || dfmt
->emax
!= 1024
858 || dfmt
->signbit_rw
!= 63
859 || dfmt
->round_towards_zero
860 || !dfmt
->has_sign_dependent_rounding
864 || !dfmt
->has_signed_zero
)
867 /* In strict C standards conformance mode, consider a back-end providing
868 more implicit excess precision than the explicit excess precision
869 the front-end options would require to mean a lack of IEEE 754
870 support. For C++, and outside strict conformance mode, do not consider
871 this to mean a lack of IEEE 754 support. */
875 && !c_cpp_flt_eval_method_iec_559 ())
880 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
883 /* Various options are contrary to IEEE 754 semantics. */
884 if (flag_unsafe_math_optimizations
885 || flag_associative_math
886 || flag_reciprocal_math
887 || flag_finite_math_only
888 || !flag_signed_zeros
889 || flag_single_precision_constant
)
892 /* If the target does not support IEEE 754 exceptions and rounding
893 modes, consider IEEE 754 support to be absent. */
894 if (!targetm
.float_exceptions_rounding_supported_p ())
900 /* Return the value for __GCC_IEC_559_COMPLEX. */
902 cpp_iec_559_complex_value (void)
904 /* The value is no bigger than that of __GCC_IEC_559. */
905 int ret
= cpp_iec_559_value ();
907 /* Some options are contrary to the required default state of the
908 CX_LIMITED_RANGE pragma. */
909 if (flag_complex_method
!= 2)
915 /* Hook that registers front end and target-specific built-ins. */
917 c_cpp_builtins (cpp_reader
*pfile
)
921 /* -undef turns off target-specific built-ins. */
925 define_language_independent_builtin_macros (pfile
);
927 /* encoding definitions used by users and libraries */
928 builtin_define_with_value ("__GNUC_EXECUTION_CHARSET_NAME",
929 cpp_get_narrow_charset_name (pfile
), 1);
930 builtin_define_with_value ("__GNUC_WIDE_EXECUTION_CHARSET_NAME",
931 cpp_get_wide_charset_name (pfile
), 1);
934 if (c_dialect_cxx ())
937 parse_basever (&major
, NULL
, NULL
);
938 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
941 /* For stddef.h. They require macros defined in c-common.cc. */
942 c_stddef_cpp_builtins ();
944 if (c_dialect_cxx ())
946 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
947 cpp_define (pfile
, "__GXX_WEAK__=1");
949 cpp_define (pfile
, "__GXX_WEAK__=0");
952 cpp_define (pfile
, "__DEPRECATED");
956 cpp_define (pfile
, "__GXX_RTTI");
957 cpp_define (pfile
, "__cpp_rtti=199711L");
960 if (cxx_dialect
>= cxx11
)
961 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
963 /* Binary literals have been allowed in g++ before C++11
964 and were standardized for C++14. */
965 if (!pedantic
|| cxx_dialect
> cxx11
)
966 cpp_define (pfile
, "__cpp_binary_literals=201304L");
968 /* Similarly for hexadecimal floating point literals and C++17. */
969 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
970 cpp_define (pfile
, "__cpp_hex_float=201603L");
972 /* Arrays of runtime bound were removed from C++14, but we still
973 support GNU VLAs. Let's define this macro to a low number
974 (corresponding to the initial test release of GNU C++) if we won't
975 complain about use of VLAs. */
977 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
978 cpp_define (pfile
, "__cpp_runtime_arrays=198712L");
980 if (cxx_dialect
>= cxx11
)
982 /* Set feature test macros for C++11. */
983 if (cxx_dialect
<= cxx14
)
984 cpp_define (pfile
, "__cpp_unicode_characters=200704L");
985 cpp_define (pfile
, "__cpp_raw_strings=200710L");
986 cpp_define (pfile
, "__cpp_unicode_literals=200710L");
987 cpp_define (pfile
, "__cpp_user_defined_literals=200809L");
988 cpp_define (pfile
, "__cpp_lambdas=200907L");
989 if (cxx_dialect
== cxx11
)
990 cpp_define (pfile
, "__cpp_constexpr=200704L");
991 if (cxx_dialect
<= cxx14
)
992 cpp_define (pfile
, "__cpp_range_based_for=200907L");
993 if (cxx_dialect
<= cxx14
)
994 cpp_define (pfile
, "__cpp_static_assert=200410L");
995 cpp_define (pfile
, "__cpp_decltype=200707L");
996 cpp_define (pfile
, "__cpp_attributes=200809L");
997 cpp_define (pfile
, "__cpp_rvalue_reference=200610L");
998 cpp_define (pfile
, "__cpp_rvalue_references=200610L");
999 cpp_define (pfile
, "__cpp_variadic_templates=200704L");
1000 cpp_define (pfile
, "__cpp_initializer_lists=200806L");
1001 cpp_define (pfile
, "__cpp_delegating_constructors=200604L");
1002 cpp_define (pfile
, "__cpp_nsdmi=200809L");
1003 if (!flag_new_inheriting_ctors
)
1004 cpp_define (pfile
, "__cpp_inheriting_constructors=200802L");
1006 cpp_define (pfile
, "__cpp_inheriting_constructors=201511L");
1007 cpp_define (pfile
, "__cpp_ref_qualifiers=200710L");
1008 cpp_define (pfile
, "__cpp_alias_templates=200704L");
1010 if (cxx_dialect
> cxx11
)
1012 /* Set feature test macros for C++14. */
1013 cpp_define (pfile
, "__cpp_return_type_deduction=201304L");
1014 if (cxx_dialect
<= cxx17
)
1016 cpp_define (pfile
, "__cpp_init_captures=201304L");
1017 cpp_define (pfile
, "__cpp_generic_lambdas=201304L");
1019 if (cxx_dialect
<= cxx14
)
1020 cpp_define (pfile
, "__cpp_constexpr=201304L");
1021 cpp_define (pfile
, "__cpp_decltype_auto=201304L");
1022 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304L");
1023 cpp_define (pfile
, "__cpp_variable_templates=201304L");
1024 cpp_define (pfile
, "__cpp_digit_separators=201309L");
1026 if (cxx_dialect
> cxx14
)
1028 /* Set feature test macros for C++17. */
1029 cpp_define (pfile
, "__cpp_unicode_characters=201411L");
1030 cpp_define (pfile
, "__cpp_static_assert=201411L");
1031 cpp_define (pfile
, "__cpp_namespace_attributes=201411L");
1032 cpp_define (pfile
, "__cpp_enumerator_attributes=201411L");
1033 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411L");
1034 cpp_define (pfile
, "__cpp_fold_expressions=201603L");
1035 if (cxx_dialect
<= cxx17
)
1036 cpp_define (pfile
, "__cpp_nontype_template_args=201411L");
1037 cpp_define (pfile
, "__cpp_range_based_for=201603L");
1038 if (cxx_dialect
<= cxx17
)
1039 cpp_define (pfile
, "__cpp_constexpr=201603L");
1040 cpp_define (pfile
, "__cpp_if_constexpr=201606L");
1041 cpp_define (pfile
, "__cpp_capture_star_this=201603L");
1042 cpp_define (pfile
, "__cpp_inline_variables=201606L");
1043 cpp_define (pfile
, "__cpp_aggregate_bases=201603L");
1044 if (cxx_dialect
<= cxx17
)
1045 cpp_define (pfile
, "__cpp_deduction_guides=201703L");
1046 cpp_define (pfile
, "__cpp_noexcept_function_type=201510L");
1047 /* Old macro, superseded by
1048 __cpp_nontype_template_parameter_auto. */
1049 cpp_define (pfile
, "__cpp_template_auto=201606L");
1050 cpp_define (pfile
, "__cpp_structured_bindings=201606L");
1051 cpp_define (pfile
, "__cpp_variadic_using=201611L");
1052 cpp_define (pfile
, "__cpp_guaranteed_copy_elision=201606L");
1053 cpp_define (pfile
, "__cpp_nontype_template_parameter_auto=201606L");
1055 if (cxx_dialect
> cxx17
)
1057 /* Set feature test macros for C++20. */
1058 cpp_define (pfile
, "__cpp_init_captures=201803L");
1059 cpp_define (pfile
, "__cpp_generic_lambdas=201707L");
1060 cpp_define (pfile
, "__cpp_designated_initializers=201707L");
1061 if (cxx_dialect
<= cxx20
)
1062 cpp_define (pfile
, "__cpp_constexpr=202002L");
1063 cpp_define (pfile
, "__cpp_constexpr_in_decltype=201711L");
1064 cpp_define (pfile
, "__cpp_conditional_explicit=201806L");
1065 cpp_define (pfile
, "__cpp_consteval=201811L");
1066 cpp_define (pfile
, "__cpp_constinit=201907L");
1067 cpp_define (pfile
, "__cpp_deduction_guides=201907L");
1068 cpp_define (pfile
, "__cpp_nontype_template_args=201911L");
1069 cpp_define (pfile
, "__cpp_nontype_template_parameter_class=201806L");
1070 cpp_define (pfile
, "__cpp_impl_destroying_delete=201806L");
1071 cpp_define (pfile
, "__cpp_constexpr_dynamic_alloc=201907L");
1072 cpp_define (pfile
, "__cpp_impl_three_way_comparison=201907L");
1073 cpp_define (pfile
, "__cpp_aggregate_paren_init=201902L");
1074 cpp_define (pfile
, "__cpp_using_enum=201907L");
1076 if (cxx_dialect
> cxx20
)
1078 /* Set feature test macros for C++23. */
1079 cpp_define (pfile
, "__cpp_size_t_suffix=202011L");
1080 cpp_define (pfile
, "__cpp_if_consteval=202106L");
1081 cpp_define (pfile
, "__cpp_constexpr=202110L");
1082 cpp_define (pfile
, "__cpp_multidimensional_subscript=202110L");
1083 cpp_define (pfile
, "__cpp_named_character_escapes=202207L");
1087 if (cxx_dialect
>= cxx20
)
1088 cpp_define (pfile
, "__cpp_concepts=202002L");
1090 cpp_define (pfile
, "__cpp_concepts=201507L");
1093 /* The std-defined value is 201907L, but I don't think we can
1094 claim victory yet. 201810 is the p1103 date. */
1095 cpp_define (pfile
, "__cpp_modules=201810L");
1096 if (flag_coroutines
)
1097 cpp_define (pfile
, "__cpp_impl_coroutine=201902L"); /* n4861, DIS */
1099 /* Use a value smaller than the 201505 specified in
1100 the TS, since we don't yet support atomic_cancel. */
1101 cpp_define (pfile
, "__cpp_transactional_memory=201500L");
1102 if (flag_sized_deallocation
)
1103 cpp_define (pfile
, "__cpp_sized_deallocation=201309L");
1104 if (aligned_new_threshold
)
1106 cpp_define (pfile
, "__cpp_aligned_new=201606L");
1107 cpp_define_formatted (pfile
, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
1108 aligned_new_threshold
);
1111 cpp_define (pfile
, "__cpp_template_template_args=201611L");
1112 if (flag_threadsafe_statics
)
1113 cpp_define (pfile
, "__cpp_threadsafe_static_init=200806L");
1115 cpp_define (pfile
, "__cpp_char8_t=202207L");
1116 #ifndef THREAD_MODEL_SPEC
1117 /* Targets that define THREAD_MODEL_SPEC need to define
1118 __STDCPP_THREADS__ in their config/XXX/XXX-c.c themselves. */
1119 if (cxx_dialect
>= cxx11
&& strcmp (thread_model
, "single") != 0)
1120 cpp_define (pfile
, "__STDCPP_THREADS__=1");
1122 if (flag_implicit_constexpr
)
1123 cpp_define (pfile
, "__cpp_implicit_constexpr=20211111L");
1125 /* Note that we define this for C as well, so that we know if
1126 __attribute__((cleanup)) will interface with EH. */
1127 if (flag_exceptions
)
1129 cpp_define (pfile
, "__EXCEPTIONS");
1130 if (c_dialect_cxx ())
1131 cpp_define (pfile
, "__cpp_exceptions=199711L");
1134 /* Represents the C++ ABI version, always defined so it can be used while
1135 preprocessing C and assembler. */
1136 if (flag_abi_version
== 0)
1137 /* We should have set this to something real in c_common_post_options. */
1139 else if (flag_abi_version
== 1)
1140 /* Due to a historical accident, this version had the value
1142 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1144 /* Newer versions have values 1002, 1003, .... */
1145 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1146 1000 + flag_abi_version
);
1148 /* libgcc needs to know this. */
1149 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1150 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
1152 /* limits.h and stdint.h need to know these. */
1153 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
1154 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
1155 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
1156 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
1157 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
1158 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1159 underlying_wchar_type_node
);
1160 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
1161 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
1162 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
1164 /* These are needed for TS 18661-1. */
1165 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node
,
1166 unsigned_char_type_node
);
1167 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node
,
1168 short_unsigned_type_node
);
1169 builtin_define_type_width ("__INT_WIDTH__", integer_type_node
,
1170 unsigned_type_node
);
1171 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node
,
1172 long_unsigned_type_node
);
1173 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1174 long_long_integer_type_node
,
1175 long_long_unsigned_type_node
);
1176 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node
,
1178 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node
, NULL_TREE
);
1179 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node
, NULL_TREE
);
1180 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node
, NULL_TREE
);
1182 if (c_dialect_cxx ())
1183 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1184 if (int_n_enabled_p
[i
])
1188 /* These are used to configure the C++ library. */
1190 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
1192 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
1193 cpp_define (parse_in
, buf
);
1195 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
1196 cpp_define (parse_in
, buf
);
1200 /* stdint.h and the testsuite need to know these. */
1201 builtin_define_stdint_macros ();
1203 /* Provide information for library headers to determine whether to
1204 define macros such as __STDC_IEC_559__ and
1205 __STDC_IEC_559_COMPLEX__. */
1206 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1207 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1208 cpp_iec_559_complex_value ());
1210 /* float.h needs these to correctly set FLT_EVAL_METHOD
1212 We define two values:
1215 Which, depending on the value given for
1216 -fpermitted-flt-eval-methods, may be limited to only those values
1217 for FLT_EVAL_METHOD defined in C99/C11.
1219 __FLT_EVAL_METHOD_TS_18661_3__
1220 Which always permits the values for FLT_EVAL_METHOD defined in
1221 ISO/IEC TS 18661-3. */
1222 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1223 c_flt_eval_method (true));
1224 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1225 c_flt_eval_method (false));
1227 /* And decfloat.h needs this. */
1228 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1229 TARGET_DEC_EVAL_METHOD
);
1231 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
1232 /* Cast the double precision constants. This is needed when single
1233 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1234 is used. The correct result is computed by the compiler when using
1235 macros that include a cast. We use a different cast for C++ to avoid
1236 problems with -Wold-style-cast. */
1237 builtin_define_float_constants ("DBL", "L",
1241 "", double_type_node
);
1242 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1243 long_double_type_node
);
1245 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1247 if (FLOATN_NX_TYPE_NODE (i
) == NULL_TREE
)
1249 char prefix
[20], csuffix
[20];
1250 sprintf (prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1251 floatn_nx_types
[i
].extended
? "X" : "");
1252 sprintf (csuffix
, "F%d%s", floatn_nx_types
[i
].n
,
1253 floatn_nx_types
[i
].extended
? "x" : "");
1254 builtin_define_float_constants (prefix
, ggc_strdup (csuffix
), "%s",
1255 csuffix
, FLOATN_NX_TYPE_NODE (i
));
1259 if (targetm
.decimal_float_supported_p ())
1261 builtin_define_decimal_float_constants ("DEC32", "DF",
1262 dfloat32_type_node
);
1263 builtin_define_decimal_float_constants ("DEC64", "DD",
1264 dfloat64_type_node
);
1265 builtin_define_decimal_float_constants ("DEC128", "DL",
1266 dfloat128_type_node
);
1269 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1270 if (targetm
.fixed_point_supported_p ())
1272 builtin_define_fixed_point_constants ("SFRACT", "HR",
1273 short_fract_type_node
);
1274 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1275 unsigned_short_fract_type_node
);
1276 builtin_define_fixed_point_constants ("FRACT", "R",
1278 builtin_define_fixed_point_constants ("UFRACT", "UR",
1279 unsigned_fract_type_node
);
1280 builtin_define_fixed_point_constants ("LFRACT", "LR",
1281 long_fract_type_node
);
1282 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1283 unsigned_long_fract_type_node
);
1284 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1285 long_long_fract_type_node
);
1286 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1287 unsigned_long_long_fract_type_node
);
1288 builtin_define_fixed_point_constants ("SACCUM", "HK",
1289 short_accum_type_node
);
1290 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1291 unsigned_short_accum_type_node
);
1292 builtin_define_fixed_point_constants ("ACCUM", "K",
1294 builtin_define_fixed_point_constants ("UACCUM", "UK",
1295 unsigned_accum_type_node
);
1296 builtin_define_fixed_point_constants ("LACCUM", "LK",
1297 long_accum_type_node
);
1298 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1299 unsigned_long_accum_type_node
);
1300 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1301 long_long_accum_type_node
);
1302 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1303 unsigned_long_long_accum_type_node
);
1305 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1306 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1307 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1308 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1309 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1310 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1311 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1312 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1313 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1314 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1315 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1316 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1317 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1318 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1319 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1320 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1321 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1322 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1325 /* For libgcc-internal use only. */
1326 if (flag_building_libgcc
)
1328 /* Properties of floating-point modes for libgcc2.c. */
1329 opt_scalar_float_mode mode_iter
;
1330 FOR_EACH_MODE_IN_CLASS (mode_iter
, MODE_FLOAT
)
1332 scalar_float_mode mode
= mode_iter
.require ();
1333 const char *name
= GET_MODE_NAME (mode
);
1334 const size_t name_len
= strlen (name
);
1335 char float_h_prefix
[16] = "";
1337 = XALLOCAVEC (char, name_len
+ sizeof ("__LIBGCC__MANT_DIG__"));
1338 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1339 builtin_define_with_int_value (macro_name
,
1340 REAL_MODE_FORMAT (mode
)->p
);
1341 if (!targetm
.scalar_mode_supported_p (mode
)
1342 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1344 macro_name
= XALLOCAVEC (char, name_len
1345 + sizeof ("__LIBGCC_HAS__MODE__"));
1346 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1347 cpp_define (pfile
, macro_name
);
1348 macro_name
= XALLOCAVEC (char, name_len
1349 + sizeof ("__LIBGCC__FUNC_EXT__"));
1350 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1351 char suffix
[20] = "";
1352 if (mode
== TYPE_MODE (double_type_node
))
1354 /* Empty suffix correct. */
1355 memcpy (float_h_prefix
, "DBL", 4);
1357 else if (mode
== TYPE_MODE (float_type_node
))
1360 memcpy (float_h_prefix
, "FLT", 4);
1362 else if (mode
== TYPE_MODE (long_double_type_node
))
1365 memcpy (float_h_prefix
, "LDBL", 5);
1369 bool found_suffix
= false;
1370 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1371 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
1372 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
1374 sprintf (suffix
, "f%d%s", floatn_nx_types
[i
].n
,
1375 floatn_nx_types
[i
].extended
? "x" : "");
1376 found_suffix
= true;
1377 sprintf (float_h_prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1378 floatn_nx_types
[i
].extended
? "X" : "");
1381 gcc_assert (found_suffix
);
1383 builtin_define_with_value (macro_name
, suffix
, 0);
1385 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1386 eliminating excess precision from results assigned to
1387 variables - meaning it should be about the implicit excess
1389 bool excess_precision
= false;
1390 machine_mode float16_type_mode
= (float16_type_node
1391 ? TYPE_MODE (float16_type_node
)
1393 switch (targetm
.c
.excess_precision
1394 (EXCESS_PRECISION_TYPE_IMPLICIT
))
1396 case FLT_EVAL_METHOD_UNPREDICTABLE
:
1397 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
1398 excess_precision
= (mode
== float16_type_mode
1399 || mode
== TYPE_MODE (float_type_node
)
1400 || mode
== TYPE_MODE (double_type_node
));
1403 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
1404 excess_precision
= (mode
== float16_type_mode
1405 || mode
== TYPE_MODE (float_type_node
));
1407 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
1408 excess_precision
= mode
== float16_type_mode
;
1410 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
:
1411 excess_precision
= false;
1416 macro_name
= XALLOCAVEC (char, name_len
1417 + sizeof ("__LIBGCC__EXCESS_PRECISION__"));
1418 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1419 builtin_define_with_int_value (macro_name
, excess_precision
);
1423 macro_name
= XALLOCAVEC (char, name_len
1424 + sizeof ("__LIBGCC__EPSILON__"));
1425 sprintf (macro_name
, "__LIBGCC_%s_EPSILON__", name
);
1426 sprintf (val_name
, "__%s_EPSILON__", float_h_prefix
);
1427 builtin_define_with_value (macro_name
, val_name
, 0);
1429 macro_name
= XALLOCAVEC (char, name_len
+ sizeof ("__LIBGCC__MAX__"));
1430 sprintf (macro_name
, "__LIBGCC_%s_MAX__", name
);
1431 sprintf (val_name
, "__%s_MAX__", float_h_prefix
);
1432 builtin_define_with_value (macro_name
, val_name
, 0);
1434 macro_name
= XALLOCAVEC (char, name_len
+ sizeof ("__LIBGCC__MIN__"));
1435 sprintf (macro_name
, "__LIBGCC_%s_MIN__", name
);
1436 sprintf (val_name
, "__%s_MIN__", float_h_prefix
);
1437 builtin_define_with_value (macro_name
, val_name
, 0);
1440 builtin_define_with_int_value ("__LIBGCC_HAVE_HWDBL__",
1445 /* For libgcc crtstuff.c and libgcc2.c. */
1446 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1447 EH_TABLES_CAN_BE_READ_ONLY
);
1448 #ifdef EH_FRAME_SECTION_NAME
1449 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1450 EH_FRAME_SECTION_NAME
, 1);
1452 #ifdef CTORS_SECTION_ASM_OP
1453 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1454 CTORS_SECTION_ASM_OP
, 1);
1456 #ifdef DTORS_SECTION_ASM_OP
1457 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1458 DTORS_SECTION_ASM_OP
, 1);
1460 #ifdef TEXT_SECTION_ASM_OP
1461 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1462 TEXT_SECTION_ASM_OP
, 1);
1464 #ifdef INIT_SECTION_ASM_OP
1465 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1466 INIT_SECTION_ASM_OP
, 1);
1468 #ifdef INIT_ARRAY_SECTION_ASM_OP
1469 /* Despite the name of this target macro, the expansion is not
1470 actually used, and may be empty rather than a string
1472 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1475 /* For libgcc enable-execute-stack.c. */
1476 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1479 /* For libgcc generic-morestack.c and unwinder code. */
1480 if (STACK_GROWS_DOWNWARD
)
1481 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1483 /* For libgcc unwinder code. */
1484 #ifdef DONT_USE_BUILTIN_SETJMP
1485 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1487 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1488 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1489 DWARF_ALT_FRAME_RETURN_COLUMN
);
1491 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1492 DWARF_FRAME_REGISTERS
);
1493 #ifdef EH_RETURN_STACKADJ_RTX
1494 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1497 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1500 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1501 STACK_POINTER_REGNUM
);
1504 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1505 TARGET_VTABLE_USES_DESCRIPTORS
);
1506 builtin_define_with_int_value ("__LIBGCC_GCOV_TYPE_SIZE",
1507 targetm
.gcov_type_size());
1510 /* For use in assembly language. */
1511 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1512 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1515 if (flag_gnu89_inline
)
1516 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1518 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1521 cpp_define (pfile
, "__NO_INLINE__");
1524 cpp_define (pfile
, "__STRICT_ANSI__");
1526 if (!flag_signed_char
)
1527 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1529 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1530 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1532 cpp_atomic_builtins (pfile
);
1534 /* Show support for __builtin_speculation_safe_value () if the target
1535 has been updated to fully support it. */
1536 if (targetm
.have_speculation_safe_value (false))
1537 cpp_define (pfile
, "__HAVE_SPECULATION_SAFE_VALUE");
1539 #ifdef DWARF2_UNWIND_INFO
1540 if (dwarf2out_do_cfi_asm ())
1541 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1544 /* Make the choice of ObjC runtime visible to source code. */
1545 if (c_dialect_objc () && flag_next_runtime
)
1546 cpp_define (pfile
, "__NEXT_RUNTIME__");
1548 /* Show the availability of some target pragmas. */
1549 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1551 /* Make the choice of the stack protector runtime visible to source code.
1552 The macro names and values here were chosen for compatibility with an
1553 earlier implementation, i.e. ProPolice. */
1554 if (flag_stack_protect
== SPCT_FLAG_EXPLICIT
)
1555 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1556 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1557 cpp_define (pfile
, "__SSP_STRONG__=3");
1558 if (flag_stack_protect
== SPCT_FLAG_ALL
)
1559 cpp_define (pfile
, "__SSP_ALL__=2");
1560 else if (flag_stack_protect
== SPCT_FLAG_DEFAULT
)
1561 cpp_define (pfile
, "__SSP__=1");
1564 cpp_define (pfile
, "_OPENACC=201711");
1567 cpp_define (pfile
, "_OPENMP=201511");
1569 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1570 if (int_n_enabled_p
[i
])
1573 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1574 builtin_define_type_sizeof (buf
,
1575 int_n_trees
[i
].signed_type
);
1577 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1578 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1579 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1580 unsigned_ptrdiff_type_node
);
1582 /* A straightforward target hook doesn't work, because of problems
1583 linking that hook's body when part of non-C front ends. */
1584 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1585 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1586 # define builtin_define(TXT) cpp_define (pfile, TXT)
1587 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1588 TARGET_CPU_CPP_BUILTINS ();
1589 TARGET_OS_CPP_BUILTINS ();
1590 TARGET_OBJFMT_CPP_BUILTINS ();
1592 /* Support the __declspec keyword by turning them into attributes.
1593 Note that the current way we do this may result in a collision
1594 with predefined attributes later on. This can be solved by using
1595 one attribute, say __declspec__, and passing args to it. The
1596 problem with that approach is that args are not accumulated: each
1597 new appearance would clobber any existing args. */
1598 if (TARGET_DECLSPEC
)
1599 builtin_define ("__declspec(x)=__attribute__((x))");
1601 /* If decimal floating point is supported, tell the user if the
1602 alternate format (BID) is used instead of the standard (DPD)
1604 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1605 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1608 /* Pass an object-like macro. If it doesn't lie in the user's
1609 namespace, defines it unconditionally. Otherwise define a version
1610 with two leading underscores, and another version with two leading
1611 and trailing underscores, and define the original only if an ISO
1612 standard was not nominated.
1614 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1615 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1618 builtin_define_std (const char *macro
)
1620 size_t len
= strlen (macro
);
1621 char *buff
= (char *) alloca (len
+ 5);
1625 /* prepend __ (or maybe just _) if in user's namespace. */
1626 memcpy (p
, macro
, len
+ 1);
1627 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1634 cpp_define (parse_in
, p
);
1636 /* If it was in user's namespace... */
1639 /* Define the macro with leading and following __. */
1645 cpp_define (parse_in
, p
);
1647 /* Finally, define the original macro if permitted. */
1649 cpp_define (parse_in
, macro
);
1653 /* Pass an object-like macro and a value to define it to. The third
1654 parameter says whether or not to turn the value into a string
1657 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1660 size_t mlen
= strlen (macro
);
1661 size_t elen
= strlen (expansion
);
1662 size_t extra
= 2; /* space for an = and a NUL */
1666 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1669 extra
+= 2; /* space for two quote marks */
1670 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1695 if (ISPRINT ((unsigned char) *p
))
1699 sprintf (q
, "\\%03o", (unsigned char) *p
);
1705 expansion
= quoted_expansion
;
1706 elen
= q
- expansion
;
1709 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1711 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1713 sprintf (buf
, "%s=%s", macro
, expansion
);
1715 cpp_define (parse_in
, buf
);
1719 /* Pass an object-like macro and an integer value to define it to. */
1721 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1724 size_t mlen
= strlen (macro
);
1726 size_t extra
= 2; /* space for = and NUL. */
1728 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1729 memcpy (buf
, macro
, mlen
);
1731 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1733 cpp_define (parse_in
, buf
);
1736 /* builtin_define_with_hex_fp_value is very expensive, so the following
1737 array and function allows it to be done lazily when __DBL_MAX__
1738 etc. is first used. */
1740 struct GTY(()) lazy_hex_fp_value_struct
1742 const char *hex_str
;
1745 const char *fp_suffix
;
1747 /* Number of the expensive to compute macros we should evaluate lazily.
1748 Each builtin_define_float_constants invocation calls
1749 builtin_define_with_hex_fp_value 5 times and builtin_define_float_constants
1750 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1752 #define LAZY_HEX_FP_VALUES_CNT (5 * (3 + NUM_FLOATN_NX_TYPES))
1753 static GTY(()) struct lazy_hex_fp_value_struct
1754 lazy_hex_fp_values
[LAZY_HEX_FP_VALUES_CNT
];
1755 static GTY(()) unsigned lazy_hex_fp_value_count
;
1758 lazy_hex_fp_value (cpp_reader
*, cpp_macro
*macro
, unsigned num
)
1760 REAL_VALUE_TYPE real
;
1761 char dec_str
[64], buf1
[256];
1763 gcc_checking_assert (num
< lazy_hex_fp_value_count
);
1765 real_from_string (&real
, lazy_hex_fp_values
[num
].hex_str
);
1766 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1767 lazy_hex_fp_values
[num
].digits
, 0,
1768 lazy_hex_fp_values
[num
].mode
);
1771 = sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[num
].fp_suffix
);
1772 gcc_assert (len
< sizeof (buf1
));
1773 for (unsigned idx
= 0; idx
< macro
->count
; idx
++)
1774 if (macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1776 macro
->exp
.tokens
[idx
].val
.str
.len
= len
;
1777 macro
->exp
.tokens
[idx
].val
.str
.text
1778 = (const unsigned char *) ggc_strdup (buf1
);
1782 /* We must have replaced a token. */
1786 /* Pass an object-like macro a hexadecimal floating-point value. */
1788 builtin_define_with_hex_fp_value (const char *macro
,
1789 tree type
, int digits
,
1790 const char *hex_str
,
1791 const char *fp_suffix
,
1792 const char *fp_cast
)
1794 REAL_VALUE_TYPE real
;
1795 char dec_str
[64], buf
[256], buf1
[128], buf2
[64];
1797 /* This is very expensive, so if possible expand them lazily. */
1798 if (lazy_hex_fp_value_count
< LAZY_HEX_FP_VALUES_CNT
1799 && flag_dump_macros
== 0
1800 && flag_dump_go_spec
== NULL
1801 && !cpp_get_options (parse_in
)->traditional
)
1803 if (lazy_hex_fp_value_count
== 0)
1804 cpp_get_callbacks (parse_in
)->user_lazy_macro
= lazy_hex_fp_value
;
1805 sprintf (buf2
, fp_cast
, "1.1");
1806 sprintf (buf1
, "%s=%s", macro
, buf2
);
1807 cpp_define (parse_in
, buf1
);
1808 struct cpp_hashnode
*node
= C_CPP_HASHNODE (get_identifier (macro
));
1809 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1810 = ggc_strdup (hex_str
);
1811 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1812 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1813 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1814 cpp_define_lazily (parse_in
, node
, lazy_hex_fp_value_count
++);
1818 /* Hex values are really cool and convenient, except that they're
1819 not supported in strict ISO C90 mode. First, the "p-" sequence
1820 is not valid as part of a preprocessor number. Second, we get a
1821 pedwarn from the preprocessor, which has no context, so we can't
1822 suppress the warning with __extension__.
1824 So instead what we do is construct the number in hex (because
1825 it's easy to get the exact correct value), parse it as a real,
1826 then print it back out as decimal. */
1828 real_from_string (&real
, hex_str
);
1829 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1832 /* Assemble the macro in the following fashion
1833 macro = fp_cast [dec_str fp_suffix] */
1834 sprintf (buf2
, "%s%s", dec_str
, fp_suffix
);
1835 sprintf (buf1
, fp_cast
, buf2
);
1836 sprintf (buf
, "%s=%s", macro
, buf1
);
1838 cpp_define (parse_in
, buf
);
1841 /* Return a string constant for the suffix for a value of type TYPE
1842 promoted according to the integer promotions. The type must be one
1843 of the standard integer type nodes. */
1846 type_suffix (tree type
)
1848 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1849 int unsigned_suffix
;
1851 int tp
= TYPE_PRECISION (type
);
1853 if (type
== long_long_integer_type_node
1854 || type
== long_long_unsigned_type_node
1855 || tp
> TYPE_PRECISION (long_integer_type_node
))
1857 else if (type
== long_integer_type_node
1858 || type
== long_unsigned_type_node
1859 || tp
> TYPE_PRECISION (integer_type_node
))
1861 else if (type
== integer_type_node
1862 || type
== unsigned_type_node
1863 || type
== short_integer_type_node
1864 || type
== short_unsigned_type_node
1865 || type
== signed_char_type_node
1866 || type
== unsigned_char_type_node
1867 /* ??? "char" is not a signed or unsigned integer type and
1868 so is not permitted for the standard typedefs, but some
1869 systems use it anyway. */
1870 || type
== char_type_node
)
1875 unsigned_suffix
= TYPE_UNSIGNED (type
);
1876 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1877 unsigned_suffix
= 0;
1878 return suffixes
[is_long
* 2 + unsigned_suffix
];
1881 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1883 builtin_define_constants (const char *macro
, tree type
)
1888 suffix
= type_suffix (type
);
1892 buf
= (char *) alloca (strlen (macro
) + 6);
1893 sprintf (buf
, "%s(c)=c", macro
);
1897 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1898 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1901 cpp_define (parse_in
, buf
);
1904 /* Define MAX for TYPE based on the precision of the type. */
1907 builtin_define_type_max (const char *macro
, tree type
)
1909 builtin_define_type_minmax (NULL
, macro
, type
);
1912 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1913 representation of that value. For example, a COUNT of 10 would
1917 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1919 gcc_assert (bufsz
> 3);
1924 gcc_assert (count
> 0);
1926 switch (count
% 4) {
1947 gcc_assert (bufsz
> 1);
1952 gcc_assert (bufsz
> 0);
1956 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1957 precision of the type. */
1960 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1963 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1964 char value
[PBOH_SZ
];
1970 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1972 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1974 suffix
= type_suffix (type
);
1976 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1977 + strlen (suffix
) + 1);
1978 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1980 cpp_define (parse_in
, buf
);
1984 if (TYPE_UNSIGNED (type
))
1986 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1987 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1991 buf
= (char *) alloca (strlen (min_macro
) + 3
1992 + strlen (max_macro
) + 6);
1993 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1995 cpp_define (parse_in
, buf
);
1999 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
2000 both types must have the same width. */
2003 builtin_define_type_width (const char *width_macro
, tree type
, tree type2
)
2005 if (type2
!= NULL_TREE
)
2006 gcc_assert (TYPE_PRECISION (type
) == TYPE_PRECISION (type2
));
2007 builtin_define_with_int_value (width_macro
, TYPE_PRECISION (type
));
2010 #include "gt-c-family-c-cppbuiltin.h"