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
&& (c_dialect_cxx () || !flag_isoc2x
))
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 necessarily
324 sprintf (name
, "__%s_IS_IEC_60559__", name_prefix
);
325 builtin_define_with_int_value (name
, fmt
->ieee_bits
!= 0);
328 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
330 builtin_define_decimal_float_constants (const char *name_prefix
,
334 const struct real_format
*fmt
;
335 char name
[64], buf
[128], *p
;
338 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
340 /* The number of radix digits, p, in the significand. */
341 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
342 builtin_define_with_int_value (name
, fmt
->p
);
344 /* The minimum negative int x such that b**(x-1) is a normalized float. */
345 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
346 sprintf (buf
, "(%d)", fmt
->emin
);
347 builtin_define_with_value (name
, buf
, 0);
349 /* The maximum int x such that b**(x-1) is a representable float. */
350 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
351 builtin_define_with_int_value (name
, fmt
->emax
);
353 /* Compute the minimum representable value. */
354 sprintf (name
, "__%s_MIN__", name_prefix
);
355 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
356 builtin_define_with_value (name
, buf
, 0);
358 /* Compute the maximum representable value. */
359 sprintf (name
, "__%s_MAX__", name_prefix
);
361 for (digits
= fmt
->p
; digits
; digits
--)
364 if (digits
== fmt
->p
)
368 /* fmt->p plus 1, to account for the decimal point and fmt->emax
369 minus 1 because the digits are nines, not 1.0. */
370 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
371 builtin_define_with_value (name
, buf
, 0);
373 /* Compute epsilon (the difference between 1 and least value greater
374 than 1 representable). */
375 sprintf (name
, "__%s_EPSILON__", name_prefix
);
376 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
377 builtin_define_with_value (name
, buf
, 0);
379 /* Minimum subnormal positive decimal value. */
380 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
382 for (digits
= fmt
->p
; digits
> 1; digits
--)
385 if (digits
== fmt
->p
)
389 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
390 builtin_define_with_value (name
, buf
, 0);
393 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
396 builtin_define_fixed_point_constants (const char *name_prefix
,
400 char name
[64], buf
[256], *new_buf
;
403 sprintf (name
, "__%s_FBIT__", name_prefix
);
404 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
406 sprintf (name
, "__%s_IBIT__", name_prefix
);
407 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
409 /* If there is no suffix, defines are for fixed-point modes.
411 if (strcmp (suffix
, "") == 0)
414 if (TYPE_UNSIGNED (type
))
416 sprintf (name
, "__%s_MIN__", name_prefix
);
417 sprintf (buf
, "0.0%s", suffix
);
418 builtin_define_with_value (name
, buf
, 0);
422 sprintf (name
, "__%s_MIN__", name_prefix
);
423 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
424 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
425 TYPE_IBIT (type
) - 1, suffix
);
427 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
428 builtin_define_with_value (name
, buf
, 0);
431 sprintf (name
, "__%s_MAX__", name_prefix
);
434 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
436 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
437 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
438 sprintf (new_buf
++, "F");
439 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
440 builtin_define_with_value (name
, buf
, 0);
442 sprintf (name
, "__%s_EPSILON__", name_prefix
);
443 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
444 builtin_define_with_value (name
, buf
, 0);
447 /* Define macros used by <stdint.h>. */
449 builtin_define_stdint_macros (void)
451 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
452 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
453 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
454 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
455 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node
,
457 if (sig_atomic_type_node
)
459 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
460 sig_atomic_type_node
);
461 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node
,
465 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
467 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
469 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
471 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
473 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
474 if (c_uint16_type_node
)
475 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
476 if (c_uint32_type_node
)
477 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
478 if (c_uint64_type_node
)
479 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
480 if (int_least8_type_node
)
482 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
483 builtin_define_constants ("__INT8_C", int_least8_type_node
);
484 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node
,
485 uint_least8_type_node
);
487 if (int_least16_type_node
)
489 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
490 builtin_define_constants ("__INT16_C", int_least16_type_node
);
491 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
492 int_least16_type_node
,
493 uint_least16_type_node
);
495 if (int_least32_type_node
)
497 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
498 builtin_define_constants ("__INT32_C", int_least32_type_node
);
499 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
500 int_least32_type_node
,
501 uint_least32_type_node
);
503 if (int_least64_type_node
)
505 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
506 builtin_define_constants ("__INT64_C", int_least64_type_node
);
507 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
508 int_least64_type_node
,
509 uint_least64_type_node
);
511 if (uint_least8_type_node
)
513 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
514 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
516 if (uint_least16_type_node
)
518 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
519 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
521 if (uint_least32_type_node
)
523 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
524 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
526 if (uint_least64_type_node
)
528 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
529 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
531 if (int_fast8_type_node
)
533 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
534 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node
,
535 uint_fast8_type_node
);
537 if (int_fast16_type_node
)
539 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
540 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node
,
541 uint_fast16_type_node
);
543 if (int_fast32_type_node
)
545 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
546 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node
,
547 uint_fast32_type_node
);
549 if (int_fast64_type_node
)
551 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
552 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node
,
553 uint_fast64_type_node
);
555 if (uint_fast8_type_node
)
556 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
557 if (uint_fast16_type_node
)
558 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
559 if (uint_fast32_type_node
)
560 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
561 if (uint_fast64_type_node
)
562 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
563 if (intptr_type_node
)
565 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
566 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node
,
569 if (uintptr_type_node
)
570 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
573 /* Adjust the optimization macros when a #pragma GCC optimization is done to
574 reflect the current level. */
576 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
579 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
580 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
584 /* -undef turns off target-specific built-ins. */
588 /* Make sure all of the builtins about to be declared have
589 BUILTINS_LOCATION has their location_t. */
590 cpp_force_token_locations (parse_in
, BUILTINS_LOCATION
);
592 /* Other target-independent built-ins determined by command-line
594 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
595 cpp_define_unused (pfile
, "__OPTIMIZE_SIZE__");
596 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
597 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
599 if (!prev
->x_optimize
&& cur
->x_optimize
)
600 cpp_define_unused (pfile
, "__OPTIMIZE__");
601 else if (prev
->x_optimize
&& !cur
->x_optimize
)
602 cpp_undef (pfile
, "__OPTIMIZE__");
604 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
605 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
606 if (!prev_fast_math
&& cur_fast_math
)
607 cpp_define_unused (pfile
, "__FAST_MATH__");
608 else if (prev_fast_math
&& !cur_fast_math
)
609 cpp_undef (pfile
, "__FAST_MATH__");
611 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
612 cpp_define_unused (pfile
, "__SUPPORT_SNAN__");
613 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
614 cpp_undef (pfile
, "__SUPPORT_SNAN__");
616 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
617 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
618 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
619 cpp_define_unused (pfile
, "__NO_MATH_ERRNO__");
621 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
623 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
624 cpp_define_unused (pfile
, "__FINITE_MATH_ONLY__=1");
626 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
628 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
629 cpp_define_unused (pfile
, "__FINITE_MATH_ONLY__=0");
632 if (!prev
->x_flag_reciprocal_math
&& cur
->x_flag_reciprocal_math
)
633 cpp_define_unused (pfile
, "__RECIPROCAL_MATH__");
634 else if (prev
->x_flag_reciprocal_math
&& !cur
->x_flag_reciprocal_math
)
635 cpp_undef (pfile
, "__RECIPROCAL_MATH__");
637 if (!prev
->x_flag_signed_zeros
&& cur
->x_flag_signed_zeros
)
638 cpp_undef (pfile
, "__NO_SIGNED_ZEROS__");
639 else if (prev
->x_flag_signed_zeros
&& !cur
->x_flag_signed_zeros
)
640 cpp_define_unused (pfile
, "__NO_SIGNED_ZEROS__");
642 if (!prev
->x_flag_trapping_math
&& cur
->x_flag_trapping_math
)
643 cpp_undef (pfile
, "__NO_TRAPPING_MATH__");
644 else if (prev
->x_flag_trapping_math
&& !cur
->x_flag_trapping_math
)
645 cpp_define_unused (pfile
, "__NO_TRAPPING_MATH__");
647 if (!prev
->x_flag_associative_math
&& cur
->x_flag_associative_math
)
648 cpp_define_unused (pfile
, "__ASSOCIATIVE_MATH__");
649 else if (prev
->x_flag_associative_math
&& !cur
->x_flag_associative_math
)
650 cpp_undef (pfile
, "__ASSOCIATIVE_MATH__");
652 if (!prev
->x_flag_rounding_math
&& cur
->x_flag_rounding_math
)
653 cpp_define_unused (pfile
, "__ROUNDING_MATH__");
654 else if (prev
->x_flag_rounding_math
&& !cur
->x_flag_rounding_math
)
655 cpp_undef (pfile
, "__ROUNDING_MATH__");
657 cpp_stop_forcing_token_locations (parse_in
);
661 /* This function will emit cpp macros to indicate the presence of various lock
662 free atomic operations. */
665 cpp_atomic_builtins (cpp_reader
*pfile
)
667 /* Set a flag for each size of object that compare and swap exists for up to
669 #define SWAP_LIMIT 17
670 bool have_swap
[SWAP_LIMIT
];
673 /* Clear the map of sizes compare_and swap exists for. */
674 memset (have_swap
, 0, sizeof (have_swap
));
676 /* Tell source code if the compiler makes sync_compare_and_swap
677 builtins available. */
678 #ifndef HAVE_sync_compare_and_swapqi
679 #define HAVE_sync_compare_and_swapqi 0
681 #ifndef HAVE_atomic_compare_and_swapqi
682 #define HAVE_atomic_compare_and_swapqi 0
685 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
687 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
691 #ifndef HAVE_sync_compare_and_swaphi
692 #define HAVE_sync_compare_and_swaphi 0
694 #ifndef HAVE_atomic_compare_and_swaphi
695 #define HAVE_atomic_compare_and_swaphi 0
697 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
699 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
703 #ifndef HAVE_sync_compare_and_swapsi
704 #define HAVE_sync_compare_and_swapsi 0
706 #ifndef HAVE_atomic_compare_and_swapsi
707 #define HAVE_atomic_compare_and_swapsi 0
709 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
711 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
715 #ifndef HAVE_sync_compare_and_swapdi
716 #define HAVE_sync_compare_and_swapdi 0
718 #ifndef HAVE_atomic_compare_and_swapdi
719 #define HAVE_atomic_compare_and_swapdi 0
721 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
723 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
727 #ifndef HAVE_sync_compare_and_swapti
728 #define HAVE_sync_compare_and_swapti 0
730 #ifndef HAVE_atomic_compare_and_swapti
731 #define HAVE_atomic_compare_and_swapti 0
733 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
735 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
736 have_swap
[16] = true;
739 /* Tell the source code about various types. These map to the C++11 and C11
740 macros where 2 indicates lock-free always, and 1 indicates sometimes
742 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
743 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
744 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
745 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
746 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
747 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
749 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR8_T_LOCK_FREE",
750 (have_swap
[SWAP_INDEX (char8_type_node
)]? 2 : 1));
751 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
752 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
753 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
754 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
755 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
756 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
757 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
758 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
759 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
760 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
761 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
762 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
763 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
764 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
766 /* If we're dealing with a "set" value that doesn't exactly correspond
767 to a boolean truth value, let the library work around that. */
768 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
769 targetm
.atomic_test_and_set_trueval
);
771 /* Macros for C++17 hardware interference size constants. Either both or
772 neither should be set. */
773 gcc_assert (!param_destruct_interfere_size
774 == !param_construct_interfere_size
);
775 if (param_destruct_interfere_size
)
777 /* FIXME The way of communicating these values to the library should be
778 part of the C++ ABI, whether macro or builtin. */
779 builtin_define_with_int_value ("__GCC_DESTRUCTIVE_SIZE",
780 param_destruct_interfere_size
);
781 builtin_define_with_int_value ("__GCC_CONSTRUCTIVE_SIZE",
782 param_construct_interfere_size
);
785 /* ptr_type_node can't be used here since ptr_mode is only set when
786 toplev calls backend_init which is not done with -E or pch. */
787 psize
= POINTER_SIZE_UNITS
;
788 if (psize
>= SWAP_LIMIT
)
790 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
791 (have_swap
[psize
]? 2 : 1));
794 /* Return TRUE if the implicit excess precision in which the back-end will
795 compute floating-point calculations is not more than the explicit
796 excess precision that the front-end will apply under
797 -fexcess-precision=[standard|fast|16].
799 More intuitively, return TRUE if the excess precision proposed by the
800 front-end is the excess precision that will actually be used. */
803 c_cpp_flt_eval_method_iec_559 (void)
805 enum excess_precision_type front_end_ept
806 = (flag_excess_precision
== EXCESS_PRECISION_STANDARD
807 ? EXCESS_PRECISION_TYPE_STANDARD
808 : (flag_excess_precision
== EXCESS_PRECISION_FLOAT16
809 ? EXCESS_PRECISION_TYPE_FLOAT16
810 : EXCESS_PRECISION_TYPE_FAST
));
812 enum flt_eval_method back_end
813 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
815 enum flt_eval_method front_end
816 = targetm
.c
.excess_precision (front_end_ept
);
818 return excess_precision_mode_join (front_end
, back_end
) == front_end
;
821 /* Return the value for __GCC_IEC_559. */
823 cpp_iec_559_value (void)
825 /* The default is support for IEEE 754-2008. */
828 /* float and double must be binary32 and binary64. If they are but
829 with reversed NaN convention, at most IEEE 754-1985 is
831 const struct real_format
*ffmt
832 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
833 const struct real_format
*dfmt
834 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
835 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
840 || ffmt
->emin
!= -125
842 || ffmt
->signbit_rw
!= 31
843 || ffmt
->round_towards_zero
844 || !ffmt
->has_sign_dependent_rounding
848 || !ffmt
->has_signed_zero
852 || dfmt
->emin
!= -1021
853 || dfmt
->emax
!= 1024
854 || dfmt
->signbit_rw
!= 63
855 || dfmt
->round_towards_zero
856 || !dfmt
->has_sign_dependent_rounding
860 || !dfmt
->has_signed_zero
)
863 /* In strict C standards conformance mode, consider a back-end providing
864 more implicit excess precision than the explicit excess precision
865 the front-end options would require to mean a lack of IEEE 754
866 support. For C++, and outside strict conformance mode, do not consider
867 this to mean a lack of IEEE 754 support. */
871 && !c_cpp_flt_eval_method_iec_559 ())
876 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
879 /* Various options are contrary to IEEE 754 semantics. */
880 if (flag_unsafe_math_optimizations
881 || flag_associative_math
882 || flag_reciprocal_math
883 || flag_finite_math_only
884 || !flag_signed_zeros
885 || flag_single_precision_constant
)
888 /* If the target does not support IEEE 754 exceptions and rounding
889 modes, consider IEEE 754 support to be absent. */
890 if (!targetm
.float_exceptions_rounding_supported_p ())
896 /* Return the value for __GCC_IEC_559_COMPLEX. */
898 cpp_iec_559_complex_value (void)
900 /* The value is no bigger than that of __GCC_IEC_559. */
901 int ret
= cpp_iec_559_value ();
903 /* Some options are contrary to the required default state of the
904 CX_LIMITED_RANGE pragma. */
905 if (flag_complex_method
!= 2)
911 /* Hook that registers front end and target-specific built-ins. */
913 c_cpp_builtins (cpp_reader
*pfile
)
917 /* -undef turns off target-specific built-ins. */
921 define_language_independent_builtin_macros (pfile
);
923 /* encoding definitions used by users and libraries */
924 builtin_define_with_value ("__GNUC_EXECUTION_CHARSET_NAME",
925 cpp_get_narrow_charset_name (pfile
), 1);
926 builtin_define_with_value ("__GNUC_WIDE_EXECUTION_CHARSET_NAME",
927 cpp_get_wide_charset_name (pfile
), 1);
930 if (c_dialect_cxx ())
933 parse_basever (&major
, NULL
, NULL
);
934 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
937 /* For stddef.h. They require macros defined in c-common.cc. */
938 c_stddef_cpp_builtins ();
940 if (c_dialect_cxx ())
942 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
943 cpp_define (pfile
, "__GXX_WEAK__=1");
945 cpp_define (pfile
, "__GXX_WEAK__=0");
948 cpp_define (pfile
, "__DEPRECATED");
952 cpp_define (pfile
, "__GXX_RTTI");
953 cpp_define (pfile
, "__cpp_rtti=199711L");
956 if (cxx_dialect
>= cxx11
)
957 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
959 /* Binary literals have been allowed in g++ before C++11
960 and were standardized for C++14. */
961 if (!pedantic
|| cxx_dialect
> cxx11
)
962 cpp_define (pfile
, "__cpp_binary_literals=201304L");
964 /* Similarly for hexadecimal floating point literals and C++17. */
965 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
966 cpp_define (pfile
, "__cpp_hex_float=201603L");
968 /* Arrays of runtime bound were removed from C++14, but we still
969 support GNU VLAs. Let's define this macro to a low number
970 (corresponding to the initial test release of GNU C++) if we won't
971 complain about use of VLAs. */
973 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
974 cpp_define (pfile
, "__cpp_runtime_arrays=198712L");
976 if (cxx_dialect
>= cxx11
)
978 /* Set feature test macros for C++11. */
979 if (cxx_dialect
<= cxx14
)
980 cpp_define (pfile
, "__cpp_unicode_characters=200704L");
981 cpp_define (pfile
, "__cpp_raw_strings=200710L");
982 cpp_define (pfile
, "__cpp_unicode_literals=200710L");
983 cpp_define (pfile
, "__cpp_user_defined_literals=200809L");
984 cpp_define (pfile
, "__cpp_lambdas=200907L");
985 if (cxx_dialect
== cxx11
)
986 cpp_define (pfile
, "__cpp_constexpr=200704L");
987 if (cxx_dialect
<= cxx14
)
988 cpp_define (pfile
, "__cpp_range_based_for=200907L");
989 if (cxx_dialect
<= cxx14
)
990 cpp_define (pfile
, "__cpp_static_assert=200410L");
991 cpp_define (pfile
, "__cpp_decltype=200707L");
992 cpp_define (pfile
, "__cpp_attributes=200809L");
993 cpp_define (pfile
, "__cpp_rvalue_reference=200610L");
994 cpp_define (pfile
, "__cpp_rvalue_references=200610L");
995 cpp_define (pfile
, "__cpp_variadic_templates=200704L");
996 cpp_define (pfile
, "__cpp_initializer_lists=200806L");
997 cpp_define (pfile
, "__cpp_delegating_constructors=200604L");
998 cpp_define (pfile
, "__cpp_nsdmi=200809L");
999 if (!flag_new_inheriting_ctors
)
1000 cpp_define (pfile
, "__cpp_inheriting_constructors=200802L");
1002 cpp_define (pfile
, "__cpp_inheriting_constructors=201511L");
1003 cpp_define (pfile
, "__cpp_ref_qualifiers=200710L");
1004 cpp_define (pfile
, "__cpp_alias_templates=200704L");
1006 if (cxx_dialect
> cxx11
)
1008 /* Set feature test macros for C++14. */
1009 cpp_define (pfile
, "__cpp_return_type_deduction=201304L");
1010 if (cxx_dialect
<= cxx17
)
1012 cpp_define (pfile
, "__cpp_init_captures=201304L");
1013 cpp_define (pfile
, "__cpp_generic_lambdas=201304L");
1015 if (cxx_dialect
<= cxx14
)
1016 cpp_define (pfile
, "__cpp_constexpr=201304L");
1017 cpp_define (pfile
, "__cpp_decltype_auto=201304L");
1018 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304L");
1019 cpp_define (pfile
, "__cpp_variable_templates=201304L");
1020 cpp_define (pfile
, "__cpp_digit_separators=201309L");
1022 if (cxx_dialect
> cxx14
)
1024 /* Set feature test macros for C++17. */
1025 cpp_define (pfile
, "__cpp_unicode_characters=201411L");
1026 cpp_define (pfile
, "__cpp_static_assert=201411L");
1027 cpp_define (pfile
, "__cpp_namespace_attributes=201411L");
1028 cpp_define (pfile
, "__cpp_enumerator_attributes=201411L");
1029 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411L");
1030 cpp_define (pfile
, "__cpp_fold_expressions=201603L");
1031 if (cxx_dialect
<= cxx17
)
1032 cpp_define (pfile
, "__cpp_nontype_template_args=201411L");
1033 cpp_define (pfile
, "__cpp_range_based_for=201603L");
1034 if (cxx_dialect
<= cxx17
)
1035 cpp_define (pfile
, "__cpp_constexpr=201603L");
1036 cpp_define (pfile
, "__cpp_if_constexpr=201606L");
1037 cpp_define (pfile
, "__cpp_capture_star_this=201603L");
1038 cpp_define (pfile
, "__cpp_inline_variables=201606L");
1039 cpp_define (pfile
, "__cpp_aggregate_bases=201603L");
1040 if (cxx_dialect
<= cxx17
)
1041 cpp_define (pfile
, "__cpp_deduction_guides=201703L");
1042 cpp_define (pfile
, "__cpp_noexcept_function_type=201510L");
1043 /* Old macro, superseded by
1044 __cpp_nontype_template_parameter_auto. */
1045 cpp_define (pfile
, "__cpp_template_auto=201606L");
1046 cpp_define (pfile
, "__cpp_structured_bindings=201606L");
1047 cpp_define (pfile
, "__cpp_variadic_using=201611L");
1048 cpp_define (pfile
, "__cpp_guaranteed_copy_elision=201606L");
1049 cpp_define (pfile
, "__cpp_nontype_template_parameter_auto=201606L");
1051 if (cxx_dialect
> cxx17
)
1053 /* Set feature test macros for C++20. */
1054 cpp_define (pfile
, "__cpp_init_captures=201803L");
1055 cpp_define (pfile
, "__cpp_generic_lambdas=201707L");
1056 cpp_define (pfile
, "__cpp_designated_initializers=201707L");
1057 if (cxx_dialect
<= cxx20
)
1058 cpp_define (pfile
, "__cpp_constexpr=202002L");
1059 cpp_define (pfile
, "__cpp_constexpr_in_decltype=201711L");
1060 cpp_define (pfile
, "__cpp_conditional_explicit=201806L");
1061 cpp_define (pfile
, "__cpp_consteval=201811L");
1062 cpp_define (pfile
, "__cpp_constinit=201907L");
1063 cpp_define (pfile
, "__cpp_deduction_guides=201907L");
1064 cpp_define (pfile
, "__cpp_nontype_template_args=201911L");
1065 cpp_define (pfile
, "__cpp_nontype_template_parameter_class=201806L");
1066 cpp_define (pfile
, "__cpp_impl_destroying_delete=201806L");
1067 cpp_define (pfile
, "__cpp_constexpr_dynamic_alloc=201907L");
1068 cpp_define (pfile
, "__cpp_impl_three_way_comparison=201907L");
1069 cpp_define (pfile
, "__cpp_aggregate_paren_init=201902L");
1070 cpp_define (pfile
, "__cpp_using_enum=201907L");
1072 if (cxx_dialect
> cxx20
)
1074 /* Set feature test macros for C++23. */
1075 cpp_define (pfile
, "__cpp_size_t_suffix=202011L");
1076 cpp_define (pfile
, "__cpp_if_consteval=202106L");
1077 cpp_define (pfile
, "__cpp_constexpr=202110L");
1078 cpp_define (pfile
, "__cpp_multidimensional_subscript=202110L");
1079 cpp_define (pfile
, "__cpp_named_character_escapes=202207L");
1080 cpp_define (pfile
, "__cpp_static_call_operator=202207L");
1081 cpp_define (pfile
, "__cpp_implicit_move=202207L");
1085 if (cxx_dialect
>= cxx20
)
1086 cpp_define (pfile
, "__cpp_concepts=202002L");
1088 cpp_define (pfile
, "__cpp_concepts=201507L");
1091 /* The std-defined value is 201907L, but I don't think we can
1092 claim victory yet. 201810 is the p1103 date. */
1093 cpp_define (pfile
, "__cpp_modules=201810L");
1094 if (flag_coroutines
)
1095 cpp_define (pfile
, "__cpp_impl_coroutine=201902L"); /* n4861, DIS */
1097 /* Use a value smaller than the 201505 specified in
1098 the TS, since we don't yet support atomic_cancel. */
1099 cpp_define (pfile
, "__cpp_transactional_memory=201500L");
1100 if (flag_sized_deallocation
)
1101 cpp_define (pfile
, "__cpp_sized_deallocation=201309L");
1102 if (aligned_new_threshold
)
1104 cpp_define (pfile
, "__cpp_aligned_new=201606L");
1105 cpp_define_formatted (pfile
, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
1106 aligned_new_threshold
);
1109 cpp_define (pfile
, "__cpp_template_template_args=201611L");
1110 if (flag_threadsafe_statics
)
1111 cpp_define (pfile
, "__cpp_threadsafe_static_init=200806L");
1113 cpp_define (pfile
, "__cpp_char8_t=202207L");
1114 #ifndef THREAD_MODEL_SPEC
1115 /* Targets that define THREAD_MODEL_SPEC need to define
1116 __STDCPP_THREADS__ in their config/XXX/XXX-c.c themselves. */
1117 if (cxx_dialect
>= cxx11
&& strcmp (thread_model
, "single") != 0)
1118 cpp_define (pfile
, "__STDCPP_THREADS__=1");
1120 if (flag_implicit_constexpr
)
1121 cpp_define (pfile
, "__cpp_implicit_constexpr=20211111L");
1123 /* Note that we define this for C as well, so that we know if
1124 __attribute__((cleanup)) will interface with EH. */
1125 if (flag_exceptions
)
1127 cpp_define (pfile
, "__EXCEPTIONS");
1128 if (c_dialect_cxx ())
1129 cpp_define (pfile
, "__cpp_exceptions=199711L");
1132 /* Represents the C++ ABI version, always defined so it can be used while
1133 preprocessing C and assembler. */
1134 if (flag_abi_version
== 0)
1135 /* We should have set this to something real in c_common_post_options. */
1137 else if (flag_abi_version
== 1)
1138 /* Due to a historical accident, this version had the value
1140 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1142 /* Newer versions have values 1002, 1003, .... */
1143 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1144 1000 + flag_abi_version
);
1146 /* libgcc needs to know this. */
1147 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1148 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
1150 /* limits.h and stdint.h need to know these. */
1151 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
1152 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
1153 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
1154 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
1155 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
1156 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1157 underlying_wchar_type_node
);
1158 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
1159 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
1160 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
1162 /* These are needed for TS 18661-1. */
1163 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node
,
1164 unsigned_char_type_node
);
1165 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node
,
1166 short_unsigned_type_node
);
1167 builtin_define_type_width ("__INT_WIDTH__", integer_type_node
,
1168 unsigned_type_node
);
1169 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node
,
1170 long_unsigned_type_node
);
1171 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1172 long_long_integer_type_node
,
1173 long_long_unsigned_type_node
);
1174 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node
,
1176 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node
, NULL_TREE
);
1177 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node
, NULL_TREE
);
1178 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node
, NULL_TREE
);
1180 if (c_dialect_cxx ())
1181 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1182 if (int_n_enabled_p
[i
])
1186 /* These are used to configure the C++ library. */
1188 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
1190 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
1191 cpp_define (parse_in
, buf
);
1193 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
1194 cpp_define (parse_in
, buf
);
1198 /* stdint.h and the testsuite need to know these. */
1199 builtin_define_stdint_macros ();
1201 /* Provide information for library headers to determine whether to
1202 define macros such as __STDC_IEC_559__ and
1203 __STDC_IEC_559_COMPLEX__. */
1204 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1205 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1206 cpp_iec_559_complex_value ());
1208 /* float.h needs these to correctly set FLT_EVAL_METHOD
1210 We define two values:
1213 Which, depending on the value given for
1214 -fpermitted-flt-eval-methods, may be limited to only those values
1215 for FLT_EVAL_METHOD defined in C99/C11.
1217 __FLT_EVAL_METHOD_TS_18661_3__
1218 Which always permits the values for FLT_EVAL_METHOD defined in
1219 ISO/IEC TS 18661-3. */
1220 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1221 c_flt_eval_method (true));
1222 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1223 c_flt_eval_method (false));
1225 /* And decfloat.h needs this. */
1226 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1227 TARGET_DEC_EVAL_METHOD
);
1229 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
1230 /* Cast the double precision constants. This is needed when single
1231 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1232 is used. The correct result is computed by the compiler when using
1233 macros that include a cast. We use a different cast for C++ to avoid
1234 problems with -Wold-style-cast. */
1235 builtin_define_float_constants ("DBL", "L",
1239 "", double_type_node
);
1240 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1241 long_double_type_node
);
1243 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1245 if (FLOATN_NX_TYPE_NODE (i
) == NULL_TREE
)
1247 if (c_dialect_cxx ()
1248 && cxx_dialect
> cxx20
1249 && !floatn_nx_types
[i
].extended
)
1251 char name
[sizeof ("__STDCPP_FLOAT128_T__=1")];
1252 sprintf (name
, "__STDCPP_FLOAT%d_T__=1", floatn_nx_types
[i
].n
);
1253 cpp_define (pfile
, name
);
1255 char prefix
[20], csuffix
[20];
1256 sprintf (prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1257 floatn_nx_types
[i
].extended
? "X" : "");
1258 sprintf (csuffix
, "F%d%s", floatn_nx_types
[i
].n
,
1259 floatn_nx_types
[i
].extended
? "x" : "");
1260 builtin_define_float_constants (prefix
, ggc_strdup (csuffix
), "%s",
1261 csuffix
, FLOATN_NX_TYPE_NODE (i
));
1263 if (bfloat16_type_node
)
1265 if (c_dialect_cxx () && cxx_dialect
> cxx20
)
1266 cpp_define (pfile
, "__STDCPP_BFLOAT16_T__=1");
1267 builtin_define_float_constants ("BFLT16", "BF16", "%s",
1268 "BF16", bfloat16_type_node
);
1272 if (targetm
.decimal_float_supported_p ())
1274 builtin_define_decimal_float_constants ("DEC32", "DF",
1275 dfloat32_type_node
);
1276 builtin_define_decimal_float_constants ("DEC64", "DD",
1277 dfloat64_type_node
);
1278 builtin_define_decimal_float_constants ("DEC128", "DL",
1279 dfloat128_type_node
);
1282 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1283 if (targetm
.fixed_point_supported_p ())
1285 builtin_define_fixed_point_constants ("SFRACT", "HR",
1286 short_fract_type_node
);
1287 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1288 unsigned_short_fract_type_node
);
1289 builtin_define_fixed_point_constants ("FRACT", "R",
1291 builtin_define_fixed_point_constants ("UFRACT", "UR",
1292 unsigned_fract_type_node
);
1293 builtin_define_fixed_point_constants ("LFRACT", "LR",
1294 long_fract_type_node
);
1295 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1296 unsigned_long_fract_type_node
);
1297 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1298 long_long_fract_type_node
);
1299 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1300 unsigned_long_long_fract_type_node
);
1301 builtin_define_fixed_point_constants ("SACCUM", "HK",
1302 short_accum_type_node
);
1303 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1304 unsigned_short_accum_type_node
);
1305 builtin_define_fixed_point_constants ("ACCUM", "K",
1307 builtin_define_fixed_point_constants ("UACCUM", "UK",
1308 unsigned_accum_type_node
);
1309 builtin_define_fixed_point_constants ("LACCUM", "LK",
1310 long_accum_type_node
);
1311 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1312 unsigned_long_accum_type_node
);
1313 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1314 long_long_accum_type_node
);
1315 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1316 unsigned_long_long_accum_type_node
);
1318 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1319 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1320 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1321 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1322 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1323 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1324 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1325 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1326 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1327 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1328 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1329 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1330 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1331 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1332 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1333 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1334 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1335 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1338 /* For libgcc-internal use only. */
1339 if (flag_building_libgcc
)
1341 /* Properties of floating-point modes for libgcc2.c. */
1342 opt_scalar_float_mode mode_iter
;
1343 FOR_EACH_MODE_IN_CLASS (mode_iter
, MODE_FLOAT
)
1345 scalar_float_mode mode
= mode_iter
.require ();
1346 const char *name
= GET_MODE_NAME (mode
);
1347 const size_t name_len
= strlen (name
);
1348 char float_h_prefix
[16] = "";
1350 = XALLOCAVEC (char, name_len
+ sizeof ("__LIBGCC__MANT_DIG__"));
1351 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1352 builtin_define_with_int_value (macro_name
,
1353 REAL_MODE_FORMAT (mode
)->p
);
1354 if (!targetm
.scalar_mode_supported_p (mode
)
1355 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1357 macro_name
= XALLOCAVEC (char, name_len
1358 + sizeof ("__LIBGCC_HAS__MODE__"));
1359 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1360 cpp_define (pfile
, macro_name
);
1361 macro_name
= XALLOCAVEC (char, name_len
1362 + sizeof ("__LIBGCC__FUNC_EXT__"));
1363 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1364 char suffix
[20] = "";
1365 if (mode
== TYPE_MODE (double_type_node
))
1367 /* Empty suffix correct. */
1368 memcpy (float_h_prefix
, "DBL", 4);
1370 else if (mode
== TYPE_MODE (float_type_node
))
1373 memcpy (float_h_prefix
, "FLT", 4);
1375 else if (mode
== TYPE_MODE (long_double_type_node
))
1378 memcpy (float_h_prefix
, "LDBL", 5);
1380 else if (bfloat16_type_node
1381 && mode
== TYPE_MODE (bfloat16_type_node
))
1383 memcpy (suffix
, "bf16", 5);
1384 memcpy (float_h_prefix
, "BFLT16", 7);
1388 bool found_suffix
= false;
1389 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1390 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
1391 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
1393 sprintf (suffix
, "f%d%s", floatn_nx_types
[i
].n
,
1394 floatn_nx_types
[i
].extended
? "x" : "");
1395 found_suffix
= true;
1396 sprintf (float_h_prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1397 floatn_nx_types
[i
].extended
? "X" : "");
1400 gcc_assert (found_suffix
);
1402 builtin_define_with_value (macro_name
, suffix
, 0);
1404 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1405 eliminating excess precision from results assigned to
1406 variables - meaning it should be about the implicit excess
1408 bool excess_precision
= false;
1409 machine_mode float16_type_mode
= (float16_type_node
1410 ? TYPE_MODE (float16_type_node
)
1412 machine_mode bfloat16_type_mode
= (bfloat16_type_node
1413 ? TYPE_MODE (bfloat16_type_node
)
1415 switch (targetm
.c
.excess_precision
1416 (EXCESS_PRECISION_TYPE_IMPLICIT
))
1418 case FLT_EVAL_METHOD_UNPREDICTABLE
:
1419 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
1420 excess_precision
= (mode
== float16_type_mode
1421 || mode
== bfloat16_type_mode
1422 || mode
== TYPE_MODE (float_type_node
)
1423 || mode
== TYPE_MODE (double_type_node
));
1426 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
1427 excess_precision
= (mode
== float16_type_mode
1428 || mode
== bfloat16_type_mode
1429 || mode
== TYPE_MODE (float_type_node
));
1431 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
1432 excess_precision
= (mode
== float16_type_mode
1433 || mode
== bfloat16_type_mode
);
1435 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
:
1436 excess_precision
= false;
1441 macro_name
= XALLOCAVEC (char, name_len
1442 + sizeof ("__LIBGCC__EXCESS_PRECISION__"));
1443 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1444 builtin_define_with_int_value (macro_name
, excess_precision
);
1448 macro_name
= XALLOCAVEC (char, name_len
1449 + sizeof ("__LIBGCC__EPSILON__"));
1450 sprintf (macro_name
, "__LIBGCC_%s_EPSILON__", name
);
1451 sprintf (val_name
, "__%s_EPSILON__", float_h_prefix
);
1452 builtin_define_with_value (macro_name
, val_name
, 0);
1454 macro_name
= XALLOCAVEC (char, name_len
+ sizeof ("__LIBGCC__MAX__"));
1455 sprintf (macro_name
, "__LIBGCC_%s_MAX__", name
);
1456 sprintf (val_name
, "__%s_MAX__", float_h_prefix
);
1457 builtin_define_with_value (macro_name
, val_name
, 0);
1459 macro_name
= XALLOCAVEC (char, name_len
+ sizeof ("__LIBGCC__MIN__"));
1460 sprintf (macro_name
, "__LIBGCC_%s_MIN__", name
);
1461 sprintf (val_name
, "__%s_MIN__", float_h_prefix
);
1462 builtin_define_with_value (macro_name
, val_name
, 0);
1465 builtin_define_with_int_value ("__LIBGCC_HAVE_HWDBL__",
1470 /* For libgcc crtstuff.c and libgcc2.c. */
1471 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1472 EH_TABLES_CAN_BE_READ_ONLY
);
1473 #ifdef EH_FRAME_SECTION_NAME
1474 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1475 EH_FRAME_SECTION_NAME
, 1);
1477 #ifdef CTORS_SECTION_ASM_OP
1478 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1479 CTORS_SECTION_ASM_OP
, 1);
1481 #ifdef DTORS_SECTION_ASM_OP
1482 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1483 DTORS_SECTION_ASM_OP
, 1);
1485 #ifdef TEXT_SECTION_ASM_OP
1486 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1487 TEXT_SECTION_ASM_OP
, 1);
1489 #ifdef INIT_SECTION_ASM_OP
1490 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1491 INIT_SECTION_ASM_OP
, 1);
1493 #ifdef INIT_ARRAY_SECTION_ASM_OP
1494 /* Despite the name of this target macro, the expansion is not
1495 actually used, and may be empty rather than a string
1497 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1500 /* For libgcc enable-execute-stack.c. */
1501 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1504 /* For libgcc generic-morestack.c and unwinder code. */
1505 if (STACK_GROWS_DOWNWARD
)
1506 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1508 /* For libgcc unwinder code. */
1509 #ifdef DONT_USE_BUILTIN_SETJMP
1510 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1512 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1513 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1514 DWARF_ALT_FRAME_RETURN_COLUMN
);
1516 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1517 DWARF_FRAME_REGISTERS
);
1518 #ifdef EH_RETURN_STACKADJ_RTX
1519 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1522 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1525 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1526 STACK_POINTER_REGNUM
);
1529 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1530 TARGET_VTABLE_USES_DESCRIPTORS
);
1531 builtin_define_with_int_value ("__LIBGCC_GCOV_TYPE_SIZE",
1532 targetm
.gcov_type_size());
1535 /* For use in assembly language. */
1536 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1537 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1540 if (flag_gnu89_inline
)
1541 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1543 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1546 cpp_define (pfile
, "__NO_INLINE__");
1549 cpp_define (pfile
, "__STRICT_ANSI__");
1551 if (!flag_signed_char
)
1552 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1554 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1555 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1557 cpp_atomic_builtins (pfile
);
1559 /* Show support for __builtin_speculation_safe_value () if the target
1560 has been updated to fully support it. */
1561 if (targetm
.have_speculation_safe_value (false))
1562 cpp_define (pfile
, "__HAVE_SPECULATION_SAFE_VALUE");
1564 #ifdef DWARF2_UNWIND_INFO
1565 if (dwarf2out_do_cfi_asm ())
1566 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1569 /* Make the choice of ObjC runtime visible to source code. */
1570 if (c_dialect_objc () && flag_next_runtime
)
1571 cpp_define (pfile
, "__NEXT_RUNTIME__");
1573 /* Show the availability of some target pragmas. */
1574 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1576 /* Make the choice of the stack protector runtime visible to source code.
1577 The macro names and values here were chosen for compatibility with an
1578 earlier implementation, i.e. ProPolice. */
1579 if (flag_stack_protect
== SPCT_FLAG_EXPLICIT
)
1580 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1581 if (flag_stack_protect
== SPCT_FLAG_STRONG
)
1582 cpp_define (pfile
, "__SSP_STRONG__=3");
1583 if (flag_stack_protect
== SPCT_FLAG_ALL
)
1584 cpp_define (pfile
, "__SSP_ALL__=2");
1585 else if (flag_stack_protect
== SPCT_FLAG_DEFAULT
)
1586 cpp_define (pfile
, "__SSP__=1");
1589 cpp_define (pfile
, "_OPENACC=201711");
1592 cpp_define (pfile
, "_OPENMP=201511");
1594 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1595 if (int_n_enabled_p
[i
])
1598 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1599 builtin_define_type_sizeof (buf
,
1600 int_n_trees
[i
].signed_type
);
1602 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1603 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1604 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1605 unsigned_ptrdiff_type_node
);
1607 /* A straightforward target hook doesn't work, because of problems
1608 linking that hook's body when part of non-C front ends. */
1609 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1610 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1611 # define builtin_define(TXT) cpp_define (pfile, TXT)
1612 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1613 TARGET_CPU_CPP_BUILTINS ();
1614 TARGET_OS_CPP_BUILTINS ();
1615 TARGET_OBJFMT_CPP_BUILTINS ();
1617 /* Support the __declspec keyword by turning them into attributes.
1618 Note that the current way we do this may result in a collision
1619 with predefined attributes later on. This can be solved by using
1620 one attribute, say __declspec__, and passing args to it. The
1621 problem with that approach is that args are not accumulated: each
1622 new appearance would clobber any existing args. */
1623 if (TARGET_DECLSPEC
)
1624 builtin_define ("__declspec(x)=__attribute__((x))");
1626 /* If decimal floating point is supported, tell the user if the
1627 alternate format (BID) is used instead of the standard (DPD)
1629 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1630 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1633 /* Pass an object-like macro. If it doesn't lie in the user's
1634 namespace, defines it unconditionally. Otherwise define a version
1635 with two leading underscores, and another version with two leading
1636 and trailing underscores, and define the original only if an ISO
1637 standard was not nominated.
1639 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1640 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1643 builtin_define_std (const char *macro
)
1645 size_t len
= strlen (macro
);
1646 char *buff
= (char *) alloca (len
+ 5);
1650 /* prepend __ (or maybe just _) if in user's namespace. */
1651 memcpy (p
, macro
, len
+ 1);
1652 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1659 cpp_define (parse_in
, p
);
1661 /* If it was in user's namespace... */
1664 /* Define the macro with leading and following __. */
1670 cpp_define (parse_in
, p
);
1672 /* Finally, define the original macro if permitted. */
1674 cpp_define (parse_in
, macro
);
1678 /* Pass an object-like macro and a value to define it to. The third
1679 parameter says whether or not to turn the value into a string
1682 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1685 size_t mlen
= strlen (macro
);
1686 size_t elen
= strlen (expansion
);
1687 size_t extra
= 2; /* space for an = and a NUL */
1691 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1694 extra
+= 2; /* space for two quote marks */
1695 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1720 if (ISPRINT ((unsigned char) *p
))
1724 sprintf (q
, "\\%03o", (unsigned char) *p
);
1730 expansion
= quoted_expansion
;
1731 elen
= q
- expansion
;
1734 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1736 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1738 sprintf (buf
, "%s=%s", macro
, expansion
);
1740 cpp_define (parse_in
, buf
);
1744 /* Pass an object-like macro and an integer value to define it to. */
1746 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1749 size_t mlen
= strlen (macro
);
1751 size_t extra
= 2; /* space for = and NUL. */
1753 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1754 memcpy (buf
, macro
, mlen
);
1756 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1758 cpp_define (parse_in
, buf
);
1761 /* builtin_define_with_hex_fp_value is very expensive, so the following
1762 array and function allows it to be done lazily when __DBL_MAX__
1763 etc. is first used. */
1765 struct GTY(()) lazy_hex_fp_value_struct
1767 const char *hex_str
;
1770 const char *fp_suffix
;
1772 /* Number of the expensive to compute macros we should evaluate lazily.
1773 Each builtin_define_float_constants invocation calls
1774 builtin_define_with_hex_fp_value 5 times and builtin_define_float_constants
1775 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1777 #define LAZY_HEX_FP_VALUES_CNT (5 * (3 + NUM_FLOATN_NX_TYPES))
1778 static GTY(()) struct lazy_hex_fp_value_struct
1779 lazy_hex_fp_values
[LAZY_HEX_FP_VALUES_CNT
];
1780 static GTY(()) unsigned lazy_hex_fp_value_count
;
1783 lazy_hex_fp_value (cpp_reader
*, cpp_macro
*macro
, unsigned num
)
1785 REAL_VALUE_TYPE real
;
1786 char dec_str
[64], buf1
[256];
1788 gcc_checking_assert (num
< lazy_hex_fp_value_count
);
1790 real_from_string (&real
, lazy_hex_fp_values
[num
].hex_str
);
1791 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1792 lazy_hex_fp_values
[num
].digits
, 0,
1793 lazy_hex_fp_values
[num
].mode
);
1796 = sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[num
].fp_suffix
);
1797 gcc_assert (len
< sizeof (buf1
));
1798 for (unsigned idx
= 0; idx
< macro
->count
; idx
++)
1799 if (macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1801 macro
->exp
.tokens
[idx
].val
.str
.len
= len
;
1802 macro
->exp
.tokens
[idx
].val
.str
.text
1803 = (const unsigned char *) ggc_strdup (buf1
);
1807 /* We must have replaced a token. */
1811 /* Pass an object-like macro a hexadecimal floating-point value. */
1813 builtin_define_with_hex_fp_value (const char *macro
,
1814 tree type
, int digits
,
1815 const char *hex_str
,
1816 const char *fp_suffix
,
1817 const char *fp_cast
)
1819 REAL_VALUE_TYPE real
;
1820 char dec_str
[64], buf
[256], buf1
[128], buf2
[64];
1822 /* This is very expensive, so if possible expand them lazily. */
1823 if (lazy_hex_fp_value_count
< LAZY_HEX_FP_VALUES_CNT
1824 && flag_dump_macros
== 0
1825 && flag_dump_go_spec
== NULL
1826 && !cpp_get_options (parse_in
)->traditional
)
1828 if (lazy_hex_fp_value_count
== 0)
1829 cpp_get_callbacks (parse_in
)->user_lazy_macro
= lazy_hex_fp_value
;
1830 sprintf (buf2
, fp_cast
, "1.1");
1831 sprintf (buf1
, "%s=%s", macro
, buf2
);
1832 cpp_define (parse_in
, buf1
);
1833 struct cpp_hashnode
*node
= C_CPP_HASHNODE (get_identifier (macro
));
1834 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1835 = ggc_strdup (hex_str
);
1836 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1837 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1838 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1839 cpp_define_lazily (parse_in
, node
, lazy_hex_fp_value_count
++);
1843 /* Hex values are really cool and convenient, except that they're
1844 not supported in strict ISO C90 mode. First, the "p-" sequence
1845 is not valid as part of a preprocessor number. Second, we get a
1846 pedwarn from the preprocessor, which has no context, so we can't
1847 suppress the warning with __extension__.
1849 So instead what we do is construct the number in hex (because
1850 it's easy to get the exact correct value), parse it as a real,
1851 then print it back out as decimal. */
1853 real_from_string (&real
, hex_str
);
1854 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1857 /* Assemble the macro in the following fashion
1858 macro = fp_cast [dec_str fp_suffix] */
1859 sprintf (buf2
, "%s%s", dec_str
, fp_suffix
);
1860 sprintf (buf1
, fp_cast
, buf2
);
1861 sprintf (buf
, "%s=%s", macro
, buf1
);
1863 cpp_define (parse_in
, buf
);
1866 /* Return a string constant for the suffix for a value of type TYPE
1867 promoted according to the integer promotions. The type must be one
1868 of the standard integer type nodes. */
1871 type_suffix (tree type
)
1873 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1874 int unsigned_suffix
;
1876 int tp
= TYPE_PRECISION (type
);
1878 if (type
== long_long_integer_type_node
1879 || type
== long_long_unsigned_type_node
1880 || tp
> TYPE_PRECISION (long_integer_type_node
))
1882 else if (type
== long_integer_type_node
1883 || type
== long_unsigned_type_node
1884 || tp
> TYPE_PRECISION (integer_type_node
))
1886 else if (type
== integer_type_node
1887 || type
== unsigned_type_node
1888 || type
== short_integer_type_node
1889 || type
== short_unsigned_type_node
1890 || type
== signed_char_type_node
1891 || type
== unsigned_char_type_node
1892 /* ??? "char" is not a signed or unsigned integer type and
1893 so is not permitted for the standard typedefs, but some
1894 systems use it anyway. */
1895 || type
== char_type_node
)
1900 unsigned_suffix
= TYPE_UNSIGNED (type
);
1901 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1902 unsigned_suffix
= 0;
1903 return suffixes
[is_long
* 2 + unsigned_suffix
];
1906 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1908 builtin_define_constants (const char *macro
, tree type
)
1913 suffix
= type_suffix (type
);
1917 buf
= (char *) alloca (strlen (macro
) + 6);
1918 sprintf (buf
, "%s(c)=c", macro
);
1922 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1923 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1926 cpp_define (parse_in
, buf
);
1929 /* Define MAX for TYPE based on the precision of the type. */
1932 builtin_define_type_max (const char *macro
, tree type
)
1934 builtin_define_type_minmax (NULL
, macro
, type
);
1937 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1938 representation of that value. For example, a COUNT of 10 would
1942 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1944 gcc_assert (bufsz
> 3);
1949 gcc_assert (count
> 0);
1951 switch (count
% 4) {
1972 gcc_assert (bufsz
> 1);
1977 gcc_assert (bufsz
> 0);
1981 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1982 precision of the type. */
1985 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1988 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1989 char value
[PBOH_SZ
];
1995 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1997 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1999 suffix
= type_suffix (type
);
2001 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
2002 + strlen (suffix
) + 1);
2003 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
2005 cpp_define (parse_in
, buf
);
2009 if (TYPE_UNSIGNED (type
))
2011 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
2012 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
2016 buf
= (char *) alloca (strlen (min_macro
) + 3
2017 + strlen (max_macro
) + 6);
2018 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
2020 cpp_define (parse_in
, buf
);
2024 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
2025 both types must have the same width. */
2028 builtin_define_type_width (const char *width_macro
, tree type
, tree type2
)
2030 if (type2
!= NULL_TREE
)
2031 gcc_assert (TYPE_PRECISION (type
) == TYPE_PRECISION (type2
));
2032 builtin_define_with_int_value (width_macro
, TYPE_PRECISION (type
));
2035 #include "gt-c-family-c-cppbuiltin.h"