1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2018 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 "cpp-id-data.h"
35 #include "cppbuiltin.h"
37 #ifndef TARGET_OS_CPP_BUILTINS
38 # define TARGET_OS_CPP_BUILTINS()
41 #ifndef TARGET_OBJFMT_CPP_BUILTINS
42 # define TARGET_OBJFMT_CPP_BUILTINS()
45 #ifndef REGISTER_PREFIX
46 #define REGISTER_PREFIX ""
49 /* Non-static as some targets don't use it. */
50 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));
265 sprintf (name, "__%s_MAX__", name_prefix);
266 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
268 /* The minimum normalized positive floating-point number,
270 sprintf (name, "__%s_MIN__", name_prefix);
271 sprintf (buf, "0x1p%d", fmt->emin - 1);
272 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
274 /* The difference between 1 and the least value greater than 1 that is
275 representable in the given floating point type, b**(1-p). */
276 sprintf (name, "__%s_EPSILON__", name_prefix);
277 if (fmt->pnan < fmt->p)
278 /* This is an IBM extended double format, so 1.0 + any double is
279 representable precisely. */
280 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
282 sprintf (buf, "0x1p%d", 1 - fmt->p);
283 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
285 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
286 The minimum denormalized positive floating-point number, b**(emin-p).
287 The minimum normalized positive floating-point number for formats
288 that don't support denormals. */
289 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
290 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
291 builtin_define_with_hex_fp_value (name, type, decimal_dig,
292 buf, fp_suffix, fp_cast);
294 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
295 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
297 /* For C++ std::numeric_limits<T>::has_infinity. */
298 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
299 builtin_define_with_int_value (name,
300 MODE_HAS_INFINITIES (TYPE_MODE (type)));
301 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
302 predicate to distinguish a target that has both quiet and
303 signalling NaNs from a target that has only quiet NaNs or only
304 signalling NaNs, so we assume that a target that has any kind of
305 NaN has quiet NaNs. */
306 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
307 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
309 /* Note whether we have fast FMA. */
310 if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
312 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
313 builtin_define_with_int_value (name, 1);
317 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
319 builtin_define_decimal_float_constants (const char *name_prefix,
323 const struct real_format *fmt;
324 char name[64], buf[128], *p;
327 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
329 /* The number of radix digits, p, in the significand. */
330 sprintf (name, "__%s_MANT_DIG__", name_prefix);
331 builtin_define_with_int_value (name, fmt->p);
333 /* The minimum negative int x such that b**(x-1) is a normalized float. */
334 sprintf (name, "__%s_MIN_EXP__", name_prefix);
335 sprintf (buf, "(%d)", fmt->emin);
336 builtin_define_with_value (name, buf, 0);
338 /* The maximum int x such that b**(x-1) is a representable float. */
339 sprintf (name, "__%s_MAX_EXP__", name_prefix);
340 builtin_define_with_int_value (name, fmt->emax);
342 /* Compute the minimum representable value. */
343 sprintf (name, "__%s_MIN__", name_prefix);
344 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
345 builtin_define_with_value (name, buf, 0);
347 /* Compute the maximum representable value. */
348 sprintf (name, "__%s_MAX__", name_prefix);
350 for (digits = fmt->p; digits; digits--)
353 if (digits == fmt->p)
357 /* fmt->p plus 1, to account for the decimal point and fmt->emax
358 minus 1 because the digits are nines, not 1.0. */
359 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
360 builtin_define_with_value (name, buf, 0);
362 /* Compute epsilon (the difference between 1 and least value greater
363 than 1 representable). */
364 sprintf (name, "__%s_EPSILON__", name_prefix);
365 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
366 builtin_define_with_value (name, buf, 0);
368 /* Minimum subnormal positive decimal value. */
369 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
371 for (digits = fmt->p; digits > 1; digits--)
374 if (digits == fmt->p)
378 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
379 builtin_define_with_value (name, buf, 0);
382 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
385 builtin_define_fixed_point_constants (const char *name_prefix,
389 char name[64], buf[256], *new_buf;
392 sprintf (name, "__%s_FBIT__", name_prefix);
393 builtin_define_with_int_value (name, TYPE_FBIT (type));
395 sprintf (name, "__%s_IBIT__", name_prefix);
396 builtin_define_with_int_value (name, TYPE_IBIT (type));
398 /* If there is no suffix, defines are for fixed-point modes.
400 if (strcmp (suffix, "") == 0)
403 if (TYPE_UNSIGNED (type))
405 sprintf (name, "__%s_MIN__", name_prefix);
406 sprintf (buf, "0.0%s", suffix);
407 builtin_define_with_value (name, buf, 0);
411 sprintf (name, "__%s_MIN__", name_prefix);
412 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
413 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
414 TYPE_IBIT (type) - 1, suffix);
416 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
417 builtin_define_with_value (name, buf, 0);
420 sprintf (name, "__%s_MAX__", name_prefix);
423 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
425 sprintf (new_buf++, "%x", (1 << mod) - 1);
426 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
427 sprintf (new_buf++, "F");
428 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
429 builtin_define_with_value (name, buf, 0);
431 sprintf (name, "__%s_EPSILON__", name_prefix);
432 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
433 builtin_define_with_value (name, buf, 0);
436 /* Define macros used by <stdint.h>. */
438 builtin_define_stdint_macros (void)
440 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
441 builtin_define_constants ("__INTMAX_C", intmax_type_node);
442 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
443 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
444 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node,
446 if (sig_atomic_type_node)
448 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
449 sig_atomic_type_node);
450 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node,
454 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
456 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
458 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
460 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
462 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
463 if (c_uint16_type_node)
464 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
465 if (c_uint32_type_node)
466 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
467 if (c_uint64_type_node)
468 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
469 if (int_least8_type_node)
471 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
472 builtin_define_constants ("__INT8_C", int_least8_type_node);
473 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node,
474 uint_least8_type_node);
476 if (int_least16_type_node)
478 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
479 builtin_define_constants ("__INT16_C", int_least16_type_node);
480 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
481 int_least16_type_node,
482 uint_least16_type_node);
484 if (int_least32_type_node)
486 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
487 builtin_define_constants ("__INT32_C", int_least32_type_node);
488 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
489 int_least32_type_node,
490 uint_least32_type_node);
492 if (int_least64_type_node)
494 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
495 builtin_define_constants ("__INT64_C", int_least64_type_node);
496 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
497 int_least64_type_node,
498 uint_least64_type_node);
500 if (uint_least8_type_node)
502 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
503 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
505 if (uint_least16_type_node)
507 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
508 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
510 if (uint_least32_type_node)
512 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
513 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
515 if (uint_least64_type_node)
517 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
518 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
520 if (int_fast8_type_node)
522 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
523 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node,
524 uint_fast8_type_node);
526 if (int_fast16_type_node)
528 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
529 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node,
530 uint_fast16_type_node);
532 if (int_fast32_type_node)
534 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
535 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node,
536 uint_fast32_type_node);
538 if (int_fast64_type_node)
540 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
541 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node,
542 uint_fast64_type_node);
544 if (uint_fast8_type_node)
545 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
546 if (uint_fast16_type_node)
547 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
548 if (uint_fast32_type_node)
549 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
550 if (uint_fast64_type_node)
551 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
552 if (intptr_type_node)
554 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
555 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node,
558 if (uintptr_type_node)
559 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
562 /* Adjust the optimization macros when a #pragma GCC optimization is done to
563 reflect the current level. */
565 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
568 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
569 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
573 /* -undef turns off target-specific built-ins. */
577 /* Other target-independent built-ins determined by command-line
579 if (!prev->x_optimize_size && cur->x_optimize_size)
580 cpp_define (pfile, "__OPTIMIZE_SIZE__");
581 else if (prev->x_optimize_size && !cur->x_optimize_size)
582 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
584 if (!prev->x_optimize && cur->x_optimize)
585 cpp_define (pfile, "__OPTIMIZE__");
586 else if (prev->x_optimize && !cur->x_optimize)
587 cpp_undef (pfile, "__OPTIMIZE__");
589 prev_fast_math = fast_math_flags_struct_set_p (prev);
590 cur_fast_math = fast_math_flags_struct_set_p (cur);
591 if (!prev_fast_math && cur_fast_math)
592 cpp_define (pfile, "__FAST_MATH__");
593 else if (prev_fast_math && !cur_fast_math)
594 cpp_undef (pfile, "__FAST_MATH__");
596 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
597 cpp_define (pfile, "__SUPPORT_SNAN__");
598 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
599 cpp_undef (pfile, "__SUPPORT_SNAN__");
601 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
602 cpp_undef (pfile, "__NO_MATH_ERRNO__");
603 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
604 cpp_define (pfile, "__NO_MATH_ERRNO__");
606 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
608 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
609 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
611 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
613 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
614 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
619 /* This function will emit cpp macros to indicate the presence of various lock
620 free atomic operations. */
623 cpp_atomic_builtins (cpp_reader *pfile)
625 /* Set a flag for each size of object that compare and swap exists for up to
627 #define SWAP_LIMIT 17
628 bool have_swap[SWAP_LIMIT];
631 /* Clear the map of sizes compare_and swap exists for. */
632 memset (have_swap, 0, sizeof (have_swap));
634 /* Tell source code if the compiler makes sync_compare_and_swap
635 builtins available. */
636 #ifndef HAVE_sync_compare_and_swapqi
637 #define HAVE_sync_compare_and_swapqi 0
639 #ifndef HAVE_atomic_compare_and_swapqi
640 #define HAVE_atomic_compare_and_swapqi 0
643 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
645 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
649 #ifndef HAVE_sync_compare_and_swaphi
650 #define HAVE_sync_compare_and_swaphi 0
652 #ifndef HAVE_atomic_compare_and_swaphi
653 #define HAVE_atomic_compare_and_swaphi 0
655 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
657 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
661 #ifndef HAVE_sync_compare_and_swapsi
662 #define HAVE_sync_compare_and_swapsi 0
664 #ifndef HAVE_atomic_compare_and_swapsi
665 #define HAVE_atomic_compare_and_swapsi 0
667 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
669 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
673 #ifndef HAVE_sync_compare_and_swapdi
674 #define HAVE_sync_compare_and_swapdi 0
676 #ifndef HAVE_atomic_compare_and_swapdi
677 #define HAVE_atomic_compare_and_swapdi 0
679 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
681 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
685 #ifndef HAVE_sync_compare_and_swapti
686 #define HAVE_sync_compare_and_swapti 0
688 #ifndef HAVE_atomic_compare_and_swapti
689 #define HAVE_atomic_compare_and_swapti 0
691 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
693 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
694 have_swap[16] = true;
697 /* Tell the source code about various types. These map to the C++11 and C11
698 macros where 2 indicates lock-free always, and 1 indicates sometimes
700 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
701 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
702 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
703 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
704 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
705 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
706 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
707 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
708 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
709 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
710 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
711 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
712 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
713 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
714 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
715 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
716 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
717 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
718 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
719 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
721 /* If we're dealing with a "set" value that doesn't exactly correspond
722 to a boolean truth value, let the library work around that. */
723 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
724 targetm.atomic_test_and_set_trueval);
726 /* ptr_type_node can't be used here since ptr_mode is only set when
727 toplev calls backend_init which is not done with -E or pch. */
728 psize = POINTER_SIZE_UNITS;
729 if (psize >= SWAP_LIMIT)
731 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
732 (have_swap[psize]? 2 : 1));
735 /* Return TRUE if the implicit excess precision in which the back-end will
736 compute floating-point calculations is not more than the explicit
737 excess precision that the front-end will apply under
738 -fexcess-precision=[standard|fast].
740 More intuitively, return TRUE if the excess precision proposed by the
741 front-end is the excess precision that will actually be used. */
744 c_cpp_flt_eval_method_iec_559 (void)
746 enum excess_precision_type front_end_ept
747 = (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
748 ? EXCESS_PRECISION_TYPE_STANDARD
749 : EXCESS_PRECISION_TYPE_FAST);
751 enum flt_eval_method back_end
752 = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
754 enum flt_eval_method front_end
755 = targetm.c.excess_precision (front_end_ept);
757 return excess_precision_mode_join (front_end, back_end) == front_end;
760 /* Return the value for __GCC_IEC_559. */
762 cpp_iec_559_value (void)
764 /* The default is support for IEEE 754-2008. */
767 /* float and double must be binary32 and binary64. If they are but
768 with reversed NaN convention, at most IEEE 754-1985 is
770 const struct real_format *ffmt
771 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
772 const struct real_format *dfmt
773 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
774 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
779 || ffmt->emin != -125
781 || ffmt->signbit_rw != 31
782 || ffmt->round_towards_zero
783 || !ffmt->has_sign_dependent_rounding
787 || !ffmt->has_signed_zero
791 || dfmt->emin != -1021
792 || dfmt->emax != 1024
793 || dfmt->signbit_rw != 63
794 || dfmt->round_towards_zero
795 || !dfmt->has_sign_dependent_rounding
799 || !dfmt->has_signed_zero)
802 /* In strict C standards conformance mode, consider a back-end providing
803 more implicit excess precision than the explicit excess precision
804 the front-end options would require to mean a lack of IEEE 754
805 support. For C++, and outside strict conformance mode, do not consider
806 this to mean a lack of IEEE 754 support. */
810 && !c_cpp_flt_eval_method_iec_559 ())
815 && flag_fp_contract_mode == FP_CONTRACT_FAST)
818 /* Various options are contrary to IEEE 754 semantics. */
819 if (flag_unsafe_math_optimizations
820 || flag_associative_math
821 || flag_reciprocal_math
822 || flag_finite_math_only
823 || !flag_signed_zeros
824 || flag_single_precision_constant)
827 /* If the target does not support IEEE 754 exceptions and rounding
828 modes, consider IEEE 754 support to be absent. */
829 if (!targetm.float_exceptions_rounding_supported_p ())
835 /* Return the value for __GCC_IEC_559_COMPLEX. */
837 cpp_iec_559_complex_value (void)
839 /* The value is no bigger than that of __GCC_IEC_559. */
840 int ret = cpp_iec_559_value ();
842 /* Some options are contrary to the required default state of the
843 CX_LIMITED_RANGE pragma. */
844 if (flag_complex_method != 2)
850 /* Hook that registers front end and target-specific built-ins. */
852 c_cpp_builtins (cpp_reader *pfile)
856 /* -undef turns off target-specific built-ins. */
860 define_language_independent_builtin_macros (pfile);
862 if (c_dialect_cxx ())
865 parse_basever (&major, NULL, NULL);
866 cpp_define_formatted (pfile, "__GNUG__=%d", major);
869 /* For stddef.h. They require macros defined in c-common.c. */
870 c_stddef_cpp_builtins ();
872 /* Set include test macros for all C/C++ (not for just C++11 etc.)
873 The builtins __has_include__ and __has_include_next__ are defined
875 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
876 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
878 if (c_dialect_cxx ())
880 if (flag_weak && SUPPORTS_ONE_ONLY)
881 cpp_define (pfile, "__GXX_WEAK__=1");
883 cpp_define (pfile, "__GXX_WEAK__=0");
886 cpp_define (pfile, "__DEPRECATED");
890 cpp_define (pfile, "__GXX_RTTI");
891 cpp_define (pfile, "__cpp_rtti=199711");
894 if (cxx_dialect >= cxx11)
895 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
897 /* Binary literals have been allowed in g++ before C++11
898 and were standardized for C++14. */
899 if (!pedantic || cxx_dialect > cxx11)
900 cpp_define (pfile, "__cpp_binary_literals=201304");
902 /* Similarly for hexadecimal floating point literals and C++17. */
903 if (!pedantic || cpp_get_options (parse_in)->extended_numbers)
904 cpp_define (pfile, "__cpp_hex_float=201603");
906 /* Arrays of runtime bound were removed from C++14, but we still
907 support GNU VLAs. Let's define this macro to a low number
908 (corresponding to the initial test release of GNU C++) if we won't
909 complain about use of VLAs. */
911 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
912 cpp_define (pfile, "__cpp_runtime_arrays=198712");
914 if (cxx_dialect >= cxx11)
916 /* Set feature test macros for C++11. */
917 if (cxx_dialect <= cxx14)
918 cpp_define (pfile, "__cpp_unicode_characters=200704");
919 cpp_define (pfile, "__cpp_raw_strings=200710");
920 cpp_define (pfile, "__cpp_unicode_literals=200710");
921 cpp_define (pfile, "__cpp_user_defined_literals=200809");
922 cpp_define (pfile, "__cpp_lambdas=200907");
923 if (cxx_dialect == cxx11)
924 cpp_define (pfile, "__cpp_constexpr=200704");
925 if (cxx_dialect <= cxx14)
926 cpp_define (pfile, "__cpp_range_based_for=200907");
927 if (cxx_dialect <= cxx14)
928 cpp_define (pfile, "__cpp_static_assert=200410");
929 cpp_define (pfile, "__cpp_decltype=200707");
930 cpp_define (pfile, "__cpp_attributes=200809");
931 cpp_define (pfile, "__cpp_rvalue_reference=200610");
932 cpp_define (pfile, "__cpp_rvalue_references=200610");
933 cpp_define (pfile, "__cpp_variadic_templates=200704");
934 cpp_define (pfile, "__cpp_initializer_lists=200806");
935 cpp_define (pfile, "__cpp_delegating_constructors=200604");
936 cpp_define (pfile, "__cpp_nsdmi=200809");
937 if (!flag_new_inheriting_ctors)
938 cpp_define (pfile, "__cpp_inheriting_constructors=200802");
940 cpp_define (pfile, "__cpp_inheriting_constructors=201511");
941 cpp_define (pfile, "__cpp_ref_qualifiers=200710");
942 cpp_define (pfile, "__cpp_alias_templates=200704");
944 if (cxx_dialect > cxx11)
946 /* Set feature test macros for C++14. */
947 cpp_define (pfile, "__cpp_return_type_deduction=201304");
948 cpp_define (pfile, "__cpp_init_captures=201304");
949 cpp_define (pfile, "__cpp_generic_lambdas=201304");
950 if (cxx_dialect <= cxx14)
951 cpp_define (pfile, "__cpp_constexpr=201304");
952 cpp_define (pfile, "__cpp_decltype_auto=201304");
953 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
954 cpp_define (pfile, "__cpp_variable_templates=201304");
955 cpp_define (pfile, "__cpp_digit_separators=201309");
957 if (cxx_dialect > cxx14)
959 /* Set feature test macros for C++1z. */
960 cpp_define (pfile, "__cpp_unicode_characters=201411");
961 cpp_define (pfile, "__cpp_static_assert=201411");
962 cpp_define (pfile, "__cpp_namespace_attributes=201411");
963 cpp_define (pfile, "__cpp_enumerator_attributes=201411");
964 cpp_define (pfile, "__cpp_nested_namespace_definitions=201411");
965 cpp_define (pfile, "__cpp_fold_expressions=201603");
966 cpp_define (pfile, "__cpp_nontype_template_args=201411");
967 cpp_define (pfile, "__cpp_range_based_for=201603");
968 cpp_define (pfile, "__cpp_constexpr=201603");
969 cpp_define (pfile, "__cpp_if_constexpr=201606");
970 cpp_define (pfile, "__cpp_capture_star_this=201603");
971 cpp_define (pfile, "__cpp_inline_variables=201606");
972 cpp_define (pfile, "__cpp_aggregate_bases=201603");
973 cpp_define (pfile, "__cpp_deduction_guides=201611");
974 cpp_define (pfile, "__cpp_noexcept_function_type=201510");
975 /* Old macro, superseded by
976 __cpp_nontype_template_parameter_auto. */
977 cpp_define (pfile, "__cpp_template_auto=201606");
978 cpp_define (pfile, "__cpp_structured_bindings=201606");
979 cpp_define (pfile, "__cpp_variadic_using=201611");
980 cpp_define (pfile, "__cpp_guaranteed_copy_elision=201606");
981 cpp_define (pfile, "__cpp_nontype_template_parameter_auto=201606");
984 cpp_define (pfile, "__cpp_concepts=201507");
986 /* Use a value smaller than the 201505 specified in
987 the TS, since we don't yet support atomic_cancel. */
988 cpp_define (pfile, "__cpp_transactional_memory=210500");
989 if (flag_sized_deallocation)
990 cpp_define (pfile, "__cpp_sized_deallocation=201309");
991 if (aligned_new_threshold)
993 cpp_define (pfile, "__cpp_aligned_new=201606");
994 cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
995 aligned_new_threshold);
998 cpp_define (pfile, "__cpp_template_template_args=201611");
999 if (flag_threadsafe_statics)
1000 cpp_define (pfile, "__cpp_threadsafe_static_init=200806");
1002 /* Note that we define this for C as well, so that we know if
1003 __attribute__((cleanup)) will interface with EH. */
1004 if (flag_exceptions)
1006 cpp_define (pfile, "__EXCEPTIONS");
1007 if (c_dialect_cxx ())
1008 cpp_define (pfile, "__cpp_exceptions=199711");
1011 /* Represents the C++ ABI version, always defined so it can be used while
1012 preprocessing C and assembler. */
1013 if (flag_abi_version == 0)
1014 /* We should have set this to something real in c_common_post_options. */
1016 else if (flag_abi_version == 1)
1017 /* Due to a historical accident, this version had the value
1019 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1021 /* Newer versions have values 1002, 1003, .... */
1022 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1023 1000 + flag_abi_version);
1025 /* libgcc needs to know this. */
1026 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1027 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
1029 /* limits.h and stdint.h need to know these. */
1030 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
1031 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
1032 builtin_define_type_max ("__INT_MAX__", integer_type_node);
1033 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
1034 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
1035 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1036 underlying_wchar_type_node);
1037 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
1038 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
1039 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
1041 /* These are needed for TS 18661-1. */
1042 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
1043 unsigned_char_type_node);
1044 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
1045 short_unsigned_type_node);
1046 builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
1047 unsigned_type_node);
1048 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
1049 long_unsigned_type_node);
1050 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1051 long_long_integer_type_node,
1052 long_long_unsigned_type_node);
1053 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
1055 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
1056 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
1057 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
1059 if (c_dialect_cxx ())
1060 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1061 if (int_n_enabled_p[i])
1065 /* These are used to configure the C++ library. */
1067 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
1069 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
1070 cpp_define (parse_in, buf);
1072 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
1073 cpp_define (parse_in, buf);
1077 /* stdint.h and the testsuite need to know these. */
1078 builtin_define_stdint_macros ();
1080 /* Provide information for library headers to determine whether to
1081 define macros such as __STDC_IEC_559__ and
1082 __STDC_IEC_559_COMPLEX__. */
1083 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1084 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1085 cpp_iec_559_complex_value ());
1087 /* float.h needs these to correctly set FLT_EVAL_METHOD
1089 We define two values:
1092 Which, depending on the value given for
1093 -fpermitted-flt-eval-methods, may be limited to only those values
1094 for FLT_EVAL_METHOD defined in C99/C11.
1096 __FLT_EVAL_METHOD_TS_18661_3__
1097 Which always permits the values for FLT_EVAL_METHOD defined in
1098 ISO/IEC TS 18661-3. */
1099 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1100 c_flt_eval_method (true));
1101 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1102 c_flt_eval_method (false));
1104 /* And decfloat.h needs this. */
1105 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1106 TARGET_DEC_EVAL_METHOD);
1108 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
1109 /* Cast the double precision constants. This is needed when single
1110 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1111 is used. The correct result is computed by the compiler when using
1112 macros that include a cast. We use a different cast for C++ to avoid
1113 problems with -Wold-style-cast. */
1114 builtin_define_float_constants ("DBL", "L",
1118 "", double_type_node);
1119 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1120 long_double_type_node);
1122 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1124 if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
1126 char prefix[20], csuffix[20];
1127 sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
1128 floatn_nx_types[i].extended ? "X" : "");
1129 sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
1130 floatn_nx_types[i].extended ? "x" : "");
1131 builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s",
1132 csuffix, FLOATN_NX_TYPE_NODE (i));
1135 /* For decfloat.h. */
1136 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
1137 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
1138 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
1140 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1141 if (targetm.fixed_point_supported_p ())
1143 builtin_define_fixed_point_constants ("SFRACT", "HR",
1144 short_fract_type_node);
1145 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1146 unsigned_short_fract_type_node);
1147 builtin_define_fixed_point_constants ("FRACT", "R",
1149 builtin_define_fixed_point_constants ("UFRACT", "UR",
1150 unsigned_fract_type_node);
1151 builtin_define_fixed_point_constants ("LFRACT", "LR",
1152 long_fract_type_node);
1153 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1154 unsigned_long_fract_type_node);
1155 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1156 long_long_fract_type_node);
1157 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1158 unsigned_long_long_fract_type_node);
1159 builtin_define_fixed_point_constants ("SACCUM", "HK",
1160 short_accum_type_node);
1161 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1162 unsigned_short_accum_type_node);
1163 builtin_define_fixed_point_constants ("ACCUM", "K",
1165 builtin_define_fixed_point_constants ("UACCUM", "UK",
1166 unsigned_accum_type_node);
1167 builtin_define_fixed_point_constants ("LACCUM", "LK",
1168 long_accum_type_node);
1169 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1170 unsigned_long_accum_type_node);
1171 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1172 long_long_accum_type_node);
1173 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1174 unsigned_long_long_accum_type_node);
1176 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
1177 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
1178 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
1179 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
1180 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
1181 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
1182 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
1183 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
1184 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
1185 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
1186 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
1187 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
1188 builtin_define_fixed_point_constants ("DA", "", da_type_node);
1189 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
1190 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
1191 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
1192 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
1193 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
1196 /* For libgcc-internal use only. */
1197 if (flag_building_libgcc)
1199 /* Properties of floating-point modes for libgcc2.c. */
1200 opt_scalar_float_mode mode_iter;
1201 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
1203 scalar_float_mode mode = mode_iter.require ();
1204 const char *name = GET_MODE_NAME (mode);
1206 = (char *) alloca (strlen (name)
1207 + sizeof ("__LIBGCC__MANT_DIG__"));
1208 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
1209 builtin_define_with_int_value (macro_name,
1210 REAL_MODE_FORMAT (mode)->p);
1211 if (!targetm.scalar_mode_supported_p (mode)
1212 || !targetm.libgcc_floating_mode_supported_p (mode))
1214 macro_name = (char *) alloca (strlen (name)
1215 + sizeof ("__LIBGCC_HAS__MODE__"));
1216 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
1217 cpp_define (pfile, macro_name);
1218 macro_name = (char *) alloca (strlen (name)
1219 + sizeof ("__LIBGCC__FUNC_EXT__"));
1220 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
1221 char suffix[20] = "";
1222 if (mode == TYPE_MODE (double_type_node))
1223 ; /* Empty suffix correct. */
1224 else if (mode == TYPE_MODE (float_type_node))
1226 else if (mode == TYPE_MODE (long_double_type_node))
1230 bool found_suffix = false;
1231 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1232 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
1233 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
1235 sprintf (suffix, "f%d%s", floatn_nx_types[i].n,
1236 floatn_nx_types[i].extended ? "x" : "");
1237 found_suffix = true;
1240 gcc_assert (found_suffix);
1242 builtin_define_with_value (macro_name, suffix, 0);
1244 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1245 eliminating excess precision from results assigned to
1246 variables - meaning it should be about the implicit excess
1248 bool excess_precision = false;
1249 machine_mode float16_type_mode = (float16_type_node
1250 ? TYPE_MODE (float16_type_node)
1252 switch (targetm.c.excess_precision
1253 (EXCESS_PRECISION_TYPE_IMPLICIT))
1255 case FLT_EVAL_METHOD_UNPREDICTABLE:
1256 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
1257 excess_precision = (mode == float16_type_mode
1258 || mode == TYPE_MODE (float_type_node)
1259 || mode == TYPE_MODE (double_type_node));
1262 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
1263 excess_precision = (mode == float16_type_mode
1264 || mode == TYPE_MODE (float_type_node));
1266 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
1267 excess_precision = mode == float16_type_mode;
1269 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
1270 excess_precision = false;
1275 macro_name = (char *) alloca (strlen (name)
1276 + sizeof ("__LIBGCC__EXCESS_"
1278 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
1279 builtin_define_with_int_value (macro_name, excess_precision);
1282 /* For libgcc crtstuff.c and libgcc2.c. */
1283 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1284 EH_TABLES_CAN_BE_READ_ONLY);
1285 #ifdef EH_FRAME_SECTION_NAME
1286 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1287 EH_FRAME_SECTION_NAME, 1);
1289 #ifdef CTORS_SECTION_ASM_OP
1290 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1291 CTORS_SECTION_ASM_OP, 1);
1293 #ifdef DTORS_SECTION_ASM_OP
1294 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1295 DTORS_SECTION_ASM_OP, 1);
1297 #ifdef TEXT_SECTION_ASM_OP
1298 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1299 TEXT_SECTION_ASM_OP, 1);
1301 #ifdef INIT_SECTION_ASM_OP
1302 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1303 INIT_SECTION_ASM_OP, 1);
1305 #ifdef INIT_ARRAY_SECTION_ASM_OP
1306 /* Despite the name of this target macro, the expansion is not
1307 actually used, and may be empty rather than a string
1309 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1312 /* For libgcc enable-execute-stack.c. */
1313 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1316 /* For libgcc generic-morestack.c and unwinder code. */
1317 if (STACK_GROWS_DOWNWARD)
1318 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1320 /* For libgcc unwinder code. */
1321 #ifdef DONT_USE_BUILTIN_SETJMP
1322 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1324 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1325 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1326 DWARF_ALT_FRAME_RETURN_COLUMN);
1328 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1329 DWARF_FRAME_REGISTERS);
1330 #ifdef EH_RETURN_STACKADJ_RTX
1331 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1334 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1337 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1338 STACK_POINTER_REGNUM);
1341 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1342 TARGET_VTABLE_USES_DESCRIPTORS);
1345 /* For use in assembly language. */
1346 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1347 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1350 if (flag_gnu89_inline)
1351 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1353 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1356 cpp_define (pfile, "__NO_INLINE__");
1359 cpp_define (pfile, "__STRICT_ANSI__");
1361 if (!flag_signed_char)
1362 cpp_define (pfile, "__CHAR_UNSIGNED__");
1364 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1365 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1367 cpp_atomic_builtins (pfile);
1369 #ifdef DWARF2_UNWIND_INFO
1370 if (dwarf2out_do_cfi_asm ())
1371 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1374 /* Make the choice of ObjC runtime visible to source code. */
1375 if (c_dialect_objc () && flag_next_runtime)
1376 cpp_define (pfile, "__NEXT_RUNTIME__");
1378 /* Show the availability of some target pragmas. */
1379 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1381 /* Make the choice of the stack protector runtime visible to source code.
1382 The macro names and values here were chosen for compatibility with an
1383 earlier implementation, i.e. ProPolice. */
1384 if (flag_stack_protect == 4)
1385 cpp_define (pfile, "__SSP_EXPLICIT__=4");
1386 if (flag_stack_protect == 3)
1387 cpp_define (pfile, "__SSP_STRONG__=3");
1388 if (flag_stack_protect == 2)
1389 cpp_define (pfile, "__SSP_ALL__=2");
1390 else if (flag_stack_protect == 1)
1391 cpp_define (pfile, "__SSP__=1");
1394 cpp_define (pfile, "_OPENACC=201306");
1397 cpp_define (pfile, "_OPENMP=201511");
1399 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1400 if (int_n_enabled_p[i])
1403 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1404 builtin_define_type_sizeof (buf,
1405 int_n_trees[i].signed_type);
1407 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1408 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1409 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1410 unsigned_ptrdiff_type_node);
1412 /* A straightforward target hook doesn't work, because of problems
1413 linking that hook's body when part of non-C front ends. */
1414 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1415 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1416 # define builtin_define(TXT) cpp_define (pfile, TXT)
1417 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1418 TARGET_CPU_CPP_BUILTINS ();
1419 TARGET_OS_CPP_BUILTINS ();
1420 TARGET_OBJFMT_CPP_BUILTINS ();
1422 /* Support the __declspec keyword by turning them into attributes.
1423 Note that the current way we do this may result in a collision
1424 with predefined attributes later on. This can be solved by using
1425 one attribute, say __declspec__, and passing args to it. The
1426 problem with that approach is that args are not accumulated: each
1427 new appearance would clobber any existing args. */
1428 if (TARGET_DECLSPEC)
1429 builtin_define ("__declspec(x)=__attribute__((x))");
1431 /* If decimal floating point is supported, tell the user if the
1432 alternate format (BID) is used instead of the standard (DPD)
1434 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1435 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1438 /* Pass an object-like macro. If it doesn't lie in the user's
1439 namespace, defines it unconditionally. Otherwise define a version
1440 with two leading underscores, and another version with two leading
1441 and trailing underscores, and define the original only if an ISO
1442 standard was not nominated.
1444 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1445 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1448 builtin_define_std (const char *macro)
1450 size_t len = strlen (macro);
1451 char *buff = (char *) alloca (len + 5);
1455 /* prepend __ (or maybe just _) if in user's namespace. */
1456 memcpy (p, macro, len + 1);
1457 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1464 cpp_define (parse_in, p);
1466 /* If it was in user's namespace... */
1469 /* Define the macro with leading and following __. */
1475 cpp_define (parse_in, p);
1477 /* Finally, define the original macro if permitted. */
1479 cpp_define (parse_in, macro);
1483 /* Pass an object-like macro and a value to define it to. The third
1484 parameter says whether or not to turn the value into a string
1487 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1490 size_t mlen = strlen (macro);
1491 size_t elen = strlen (expansion);
1492 size_t extra = 2; /* space for an = and a NUL */
1496 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1499 extra += 2; /* space for two quote marks */
1500 for (p = expansion, q = quoted_expansion; *p; p++)
1525 if (ISPRINT ((unsigned char) *p))
1529 sprintf (q, "\\%03o", (unsigned char) *p);
1535 expansion = quoted_expansion;
1536 elen = q - expansion;
1539 buf = (char *) alloca (mlen + elen + extra);
1541 sprintf (buf, "%s=\"%s\"", macro, expansion);
1543 sprintf (buf, "%s=%s", macro, expansion);
1545 cpp_define (parse_in, buf);
1549 /* Pass an object-like macro and an integer value to define it to. */
1551 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1554 size_t mlen = strlen (macro);
1556 size_t extra = 2; /* space for = and NUL. */
1558 buf = (char *) alloca (mlen + vlen + extra);
1559 memcpy (buf, macro, mlen);
1561 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1563 cpp_define (parse_in, buf);
1566 /* builtin_define_with_hex_fp_value is very expensive, so the following
1567 array and function allows it to be done lazily when __DBL_MAX__
1568 etc. is first used. */
1570 struct GTY(()) lazy_hex_fp_value_struct
1572 const char *hex_str;
1576 const char *fp_suffix;
1578 /* Number of the expensive to compute macros we should evaluate lazily.
1579 Each builtin_define_float_constants invocation calls
1580 builtin_define_with_hex_fp_value 4 times and builtin_define_float_constants
1581 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1583 #define LAZY_HEX_FP_VALUES_CNT (4 * (3 + NUM_FLOATN_NX_TYPES))
1584 static GTY(()) struct lazy_hex_fp_value_struct
1585 lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT];
1586 static GTY(()) int lazy_hex_fp_value_count;
1589 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1592 REAL_VALUE_TYPE real;
1593 char dec_str[64], buf1[256];
1595 if (node->value.builtin < BT_FIRST_USER
1596 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1599 idx = node->value.builtin - BT_FIRST_USER;
1600 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1601 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1602 lazy_hex_fp_values[idx].digits, 0,
1603 lazy_hex_fp_values[idx].mode);
1605 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1606 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1607 node->value.macro = lazy_hex_fp_values[idx].macro;
1608 for (idx = 0; idx < node->value.macro->count; idx++)
1609 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1611 gcc_assert (idx < node->value.macro->count);
1612 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1613 node->value.macro->exp.tokens[idx].val.str.text
1614 = (const unsigned char *) ggc_strdup (buf1);
1618 /* Pass an object-like macro a hexadecimal floating-point value. */
1620 builtin_define_with_hex_fp_value (const char *macro,
1621 tree type, int digits,
1622 const char *hex_str,
1623 const char *fp_suffix,
1624 const char *fp_cast)
1626 REAL_VALUE_TYPE real;
1627 char dec_str[64], buf[256], buf1[128], buf2[64];
1629 /* This is very expensive, so if possible expand them lazily. */
1630 if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT
1631 && flag_dump_macros == 0
1632 && !cpp_get_options (parse_in)->traditional)
1634 struct cpp_hashnode *node;
1635 if (lazy_hex_fp_value_count == 0)
1636 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1637 sprintf (buf2, fp_cast, "1.1");
1638 sprintf (buf1, "%s=%s", macro, buf2);
1639 cpp_define (parse_in, buf1);
1640 node = C_CPP_HASHNODE (get_identifier (macro));
1641 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1642 = ggc_strdup (hex_str);
1643 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1644 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1645 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1646 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1647 node->flags |= NODE_BUILTIN;
1649 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1650 lazy_hex_fp_value_count++;
1654 /* Hex values are really cool and convenient, except that they're
1655 not supported in strict ISO C90 mode. First, the "p-" sequence
1656 is not valid as part of a preprocessor number. Second, we get a
1657 pedwarn from the preprocessor, which has no context, so we can't
1658 suppress the warning with __extension__.
1660 So instead what we do is construct the number in hex (because
1661 it's easy to get the exact correct value), parse it as a real,
1662 then print it back out as decimal. */
1664 real_from_string (&real, hex_str);
1665 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1668 /* Assemble the macro in the following fashion
1669 macro = fp_cast [dec_str fp_suffix] */
1670 sprintf (buf2, "%s%s", dec_str, fp_suffix);
1671 sprintf (buf1, fp_cast, buf2);
1672 sprintf (buf, "%s=%s", macro, buf1);
1674 cpp_define (parse_in, buf);
1677 /* Return a string constant for the suffix for a value of type TYPE
1678 promoted according to the integer promotions. The type must be one
1679 of the standard integer type nodes. */
1682 type_suffix (tree type)
1684 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1685 int unsigned_suffix;
1687 int tp = TYPE_PRECISION (type);
1689 if (type == long_long_integer_type_node
1690 || type == long_long_unsigned_type_node
1691 || tp > TYPE_PRECISION (long_integer_type_node))
1693 else if (type == long_integer_type_node
1694 || type == long_unsigned_type_node
1695 || tp > TYPE_PRECISION (integer_type_node))
1697 else if (type == integer_type_node
1698 || type == unsigned_type_node
1699 || type == short_integer_type_node
1700 || type == short_unsigned_type_node
1701 || type == signed_char_type_node
1702 || type == unsigned_char_type_node
1703 /* ??? "char" is not a signed or unsigned integer type and
1704 so is not permitted for the standard typedefs, but some
1705 systems use it anyway. */
1706 || type == char_type_node)
1711 unsigned_suffix = TYPE_UNSIGNED (type);
1712 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1713 unsigned_suffix = 0;
1714 return suffixes[is_long * 2 + unsigned_suffix];
1717 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1719 builtin_define_constants (const char *macro, tree type)
1724 suffix = type_suffix (type);
1728 buf = (char *) alloca (strlen (macro) + 6);
1729 sprintf (buf, "%s(c)=c", macro);
1733 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1734 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1737 cpp_define (parse_in, buf);
1740 /* Define MAX for TYPE based on the precision of the type. */
1743 builtin_define_type_max (const char *macro, tree type)
1745 builtin_define_type_minmax (NULL, macro, type);
1748 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1749 representation of that value. For example, a COUNT of 10 would
1753 print_bits_of_hex (char *buf, int bufsz, int count)
1755 gcc_assert (bufsz > 3);
1760 gcc_assert (count > 0);
1762 switch (count % 4) {
1783 gcc_assert (bufsz > 1);
1788 gcc_assert (bufsz > 0);
1792 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1793 precision of the type. */
1796 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1799 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1800 char value[PBOH_SZ];
1806 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1808 print_bits_of_hex (value, PBOH_SZ, bits);
1810 suffix = type_suffix (type);
1812 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1813 + strlen (suffix) + 1);
1814 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1816 cpp_define (parse_in, buf);
1820 if (TYPE_UNSIGNED (type))
1822 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1823 sprintf (buf, "%s=0%s", min_macro, suffix);
1827 buf = (char *) alloca (strlen (min_macro) + 3
1828 + strlen (max_macro) + 6);
1829 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1831 cpp_define (parse_in, buf);
1835 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1836 both types must have the same width. */
1839 builtin_define_type_width (const char *width_macro, tree type, tree type2)
1841 if (type2 != NULL_TREE)
1842 gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
1843 builtin_define_with_int_value (width_macro, TYPE_PRECISION (type));
1846 #include "gt-c-family-c-cppbuiltin.h"