1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2017 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
)
102 /* Define NAME with value TYPE size_unit. */
104 builtin_define_type_sizeof (const char *name
, tree type
)
106 builtin_define_with_int_value (name
,
107 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
110 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
113 builtin_define_float_constants (const char *name_prefix
,
114 const char *fp_suffix
,
116 const char *fma_suffix
,
119 /* Used to convert radix-based values to base 10 values in several cases.
121 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
122 least 6 significant digits for correct results. Using the fraction
123 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
124 intermediate; perhaps someone can find a better approximation, in the
125 mean time, I suspect using doubles won't harm the bootstrap here. */
127 const double log10_2
= .30102999566398119521;
129 const struct real_format
*fmt
;
130 const struct real_format
*widefmt
;
132 char name
[64], buf
[128];
133 int dig
, min_10_exp
, max_10_exp
;
135 int type_decimal_dig
;
137 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
138 gcc_assert (fmt
->b
!= 10);
139 widefmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
140 gcc_assert (widefmt
->b
!= 10);
141 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
143 tree wtype
= FLOATN_NX_TYPE_NODE (i
);
144 if (wtype
!= NULL_TREE
)
146 const struct real_format
*wfmt
147 = REAL_MODE_FORMAT (TYPE_MODE (wtype
));
148 gcc_assert (wfmt
->b
!= 10);
149 if (wfmt
->p
> widefmt
->p
)
154 /* The radix of the exponent representation. */
155 if (type
== float_type_node
)
156 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
159 /* The number of radix digits, p, in the floating-point significand. */
160 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
161 builtin_define_with_int_value (name
, fmt
->p
);
163 /* The number of decimal digits, q, such that any floating-point number
164 with q decimal digits can be rounded into a floating-point number with
165 p radix b digits and back again without change to the q decimal digits,
167 p log10 b if b is a power of 10
168 floor((p - 1) log10 b) otherwise
170 dig
= (fmt
->p
- 1) * log10_b
;
171 sprintf (name
, "__%s_DIG__", name_prefix
);
172 builtin_define_with_int_value (name
, dig
);
174 /* The minimum negative int x such that b**(x-1) is a normalized float. */
175 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
176 sprintf (buf
, "(%d)", fmt
->emin
);
177 builtin_define_with_value (name
, buf
, 0);
179 /* The minimum negative int x such that 10**x is a normalized float,
181 ceil (log10 (b ** (emin - 1)))
182 = ceil (log10 (b) * (emin - 1))
184 Recall that emin is negative, so the integer truncation calculates
185 the ceiling, not the floor, in this case. */
186 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
187 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
188 sprintf (buf
, "(%d)", min_10_exp
);
189 builtin_define_with_value (name
, buf
, 0);
191 /* The maximum int x such that b**(x-1) is a representable float. */
192 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
193 builtin_define_with_int_value (name
, fmt
->emax
);
195 /* The maximum int x such that 10**x is in the range of representable
196 finite floating-point numbers,
198 floor (log10((1 - b**-p) * b**emax))
199 = floor (log10(1 - b**-p) + log10(b**emax))
200 = floor (log10(1 - b**-p) + log10(b)*emax)
202 The safest thing to do here is to just compute this number. But since
203 we don't link cc1 with libm, we cannot. We could implement log10 here
204 a series expansion, but that seems too much effort because:
206 Note that the first term, for all extant p, is a number exceedingly close
207 to zero, but slightly negative. Note that the second term is an integer
208 scaling an irrational number, and that because of the floor we are only
209 interested in its integral portion.
211 In order for the first term to have any effect on the integral portion
212 of the second term, the second term has to be exceedingly close to an
213 integer itself (e.g. 123.000000000001 or something). Getting a result
214 that close to an integer requires that the irrational multiplicand have
215 a long series of zeros in its expansion, which doesn't occur in the
216 first 20 digits or so of log10(b).
218 Hand-waving aside, crunching all of the sets of constants above by hand
219 does not yield a case for which the first term is significant, which
220 in the end is all that matters. */
221 max_10_exp
= fmt
->emax
* log10_b
;
222 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
223 builtin_define_with_int_value (name
, max_10_exp
);
225 /* The number of decimal digits, n, such that any floating-point number
226 can be rounded to n decimal digits and back again without change to
229 p * log10(b) if b is a power of 10
230 ceil(1 + p * log10(b)) otherwise
232 The only macro we care about is this number for the widest supported
233 floating type, but we want this value for rendering constants below. */
236 = 1 + (fmt
->p
< widefmt
->p
? widefmt
->p
: fmt
->p
) * log10_b
;
237 decimal_dig
= d_decimal_dig
;
238 if (decimal_dig
< d_decimal_dig
)
241 /* Similar, for this type rather than long double. */
243 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
244 type_decimal_dig
= type_d_decimal_dig
;
245 if (type_decimal_dig
< type_d_decimal_dig
)
248 /* Arbitrarily, define __DECIMAL_DIG__ when defining macros for long
249 double, although it may be greater than the value for long
251 if (type
== long_double_type_node
)
252 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
253 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
254 builtin_define_with_int_value (name
, type_decimal_dig
);
256 /* Since, for the supported formats, B is always a power of 2, we
257 construct the following numbers directly as a hexadecimal
259 get_max_float (fmt
, buf
, sizeof (buf
));
261 sprintf (name
, "__%s_MAX__", name_prefix
);
262 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
264 /* The minimum normalized positive floating-point number,
266 sprintf (name
, "__%s_MIN__", name_prefix
);
267 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
268 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
270 /* The difference between 1 and the least value greater than 1 that is
271 representable in the given floating point type, b**(1-p). */
272 sprintf (name
, "__%s_EPSILON__", name_prefix
);
273 if (fmt
->pnan
< fmt
->p
)
274 /* This is an IBM extended double format, so 1.0 + any double is
275 representable precisely. */
276 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
278 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
279 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
281 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
282 The minimum denormalized positive floating-point number, b**(emin-p).
283 The minimum normalized positive floating-point number for formats
284 that don't support denormals. */
285 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
286 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
287 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
288 buf
, fp_suffix
, fp_cast
);
290 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
291 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
293 /* For C++ std::numeric_limits<T>::has_infinity. */
294 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
295 builtin_define_with_int_value (name
,
296 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
297 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
298 predicate to distinguish a target that has both quiet and
299 signalling NaNs from a target that has only quiet NaNs or only
300 signalling NaNs, so we assume that a target that has any kind of
301 NaN has quiet NaNs. */
302 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
303 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
305 /* Note whether we have fast FMA. */
306 if (mode_has_fma (TYPE_MODE (type
)) && fma_suffix
!= NULL
)
308 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
309 builtin_define_with_int_value (name
, 1);
313 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
315 builtin_define_decimal_float_constants (const char *name_prefix
,
319 const struct real_format
*fmt
;
320 char name
[64], buf
[128], *p
;
323 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
325 /* The number of radix digits, p, in the significand. */
326 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
327 builtin_define_with_int_value (name
, fmt
->p
);
329 /* The minimum negative int x such that b**(x-1) is a normalized float. */
330 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
331 sprintf (buf
, "(%d)", fmt
->emin
);
332 builtin_define_with_value (name
, buf
, 0);
334 /* The maximum int x such that b**(x-1) is a representable float. */
335 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
336 builtin_define_with_int_value (name
, fmt
->emax
);
338 /* Compute the minimum representable value. */
339 sprintf (name
, "__%s_MIN__", name_prefix
);
340 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
341 builtin_define_with_value (name
, buf
, 0);
343 /* Compute the maximum representable value. */
344 sprintf (name
, "__%s_MAX__", name_prefix
);
346 for (digits
= fmt
->p
; digits
; digits
--)
349 if (digits
== fmt
->p
)
353 /* fmt->p plus 1, to account for the decimal point and fmt->emax
354 minus 1 because the digits are nines, not 1.0. */
355 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
356 builtin_define_with_value (name
, buf
, 0);
358 /* Compute epsilon (the difference between 1 and least value greater
359 than 1 representable). */
360 sprintf (name
, "__%s_EPSILON__", name_prefix
);
361 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
362 builtin_define_with_value (name
, buf
, 0);
364 /* Minimum subnormal positive decimal value. */
365 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
367 for (digits
= fmt
->p
; digits
> 1; digits
--)
370 if (digits
== fmt
->p
)
374 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
375 builtin_define_with_value (name
, buf
, 0);
378 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
381 builtin_define_fixed_point_constants (const char *name_prefix
,
385 char name
[64], buf
[256], *new_buf
;
388 sprintf (name
, "__%s_FBIT__", name_prefix
);
389 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
391 sprintf (name
, "__%s_IBIT__", name_prefix
);
392 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
394 /* If there is no suffix, defines are for fixed-point modes.
396 if (strcmp (suffix
, "") == 0)
399 if (TYPE_UNSIGNED (type
))
401 sprintf (name
, "__%s_MIN__", name_prefix
);
402 sprintf (buf
, "0.0%s", suffix
);
403 builtin_define_with_value (name
, buf
, 0);
407 sprintf (name
, "__%s_MIN__", name_prefix
);
408 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
409 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
410 TYPE_IBIT (type
) - 1, suffix
);
412 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
413 builtin_define_with_value (name
, buf
, 0);
416 sprintf (name
, "__%s_MAX__", name_prefix
);
419 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
421 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
422 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
423 sprintf (new_buf
++, "F");
424 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
425 builtin_define_with_value (name
, buf
, 0);
427 sprintf (name
, "__%s_EPSILON__", name_prefix
);
428 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
429 builtin_define_with_value (name
, buf
, 0);
432 /* Define macros used by <stdint.h>. */
434 builtin_define_stdint_macros (void)
436 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
437 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
438 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
439 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
440 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node
,
442 if (sig_atomic_type_node
)
444 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
445 sig_atomic_type_node
);
446 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node
,
450 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
452 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
454 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
456 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
458 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
459 if (c_uint16_type_node
)
460 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
461 if (c_uint32_type_node
)
462 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
463 if (c_uint64_type_node
)
464 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
465 if (int_least8_type_node
)
467 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
468 builtin_define_constants ("__INT8_C", int_least8_type_node
);
469 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node
,
470 uint_least8_type_node
);
472 if (int_least16_type_node
)
474 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
475 builtin_define_constants ("__INT16_C", int_least16_type_node
);
476 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
477 int_least16_type_node
,
478 uint_least16_type_node
);
480 if (int_least32_type_node
)
482 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
483 builtin_define_constants ("__INT32_C", int_least32_type_node
);
484 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
485 int_least32_type_node
,
486 uint_least32_type_node
);
488 if (int_least64_type_node
)
490 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
491 builtin_define_constants ("__INT64_C", int_least64_type_node
);
492 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
493 int_least64_type_node
,
494 uint_least64_type_node
);
496 if (uint_least8_type_node
)
498 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
499 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
501 if (uint_least16_type_node
)
503 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
504 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
506 if (uint_least32_type_node
)
508 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
509 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
511 if (uint_least64_type_node
)
513 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
514 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
516 if (int_fast8_type_node
)
518 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
519 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node
,
520 uint_fast8_type_node
);
522 if (int_fast16_type_node
)
524 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
525 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node
,
526 uint_fast16_type_node
);
528 if (int_fast32_type_node
)
530 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
531 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node
,
532 uint_fast32_type_node
);
534 if (int_fast64_type_node
)
536 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
537 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node
,
538 uint_fast64_type_node
);
540 if (uint_fast8_type_node
)
541 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
542 if (uint_fast16_type_node
)
543 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
544 if (uint_fast32_type_node
)
545 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
546 if (uint_fast64_type_node
)
547 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
548 if (intptr_type_node
)
550 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
551 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node
,
554 if (uintptr_type_node
)
555 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
558 /* Adjust the optimization macros when a #pragma GCC optimization is done to
559 reflect the current level. */
561 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
564 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
565 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
569 /* -undef turns off target-specific built-ins. */
573 /* Other target-independent built-ins determined by command-line
575 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
576 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
577 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
578 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
580 if (!prev
->x_optimize
&& cur
->x_optimize
)
581 cpp_define (pfile
, "__OPTIMIZE__");
582 else if (prev
->x_optimize
&& !cur
->x_optimize
)
583 cpp_undef (pfile
, "__OPTIMIZE__");
585 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
586 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
587 if (!prev_fast_math
&& cur_fast_math
)
588 cpp_define (pfile
, "__FAST_MATH__");
589 else if (prev_fast_math
&& !cur_fast_math
)
590 cpp_undef (pfile
, "__FAST_MATH__");
592 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
593 cpp_define (pfile
, "__SUPPORT_SNAN__");
594 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
595 cpp_undef (pfile
, "__SUPPORT_SNAN__");
597 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
598 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
599 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
600 cpp_define (pfile
, "__NO_MATH_ERRNO__");
602 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
604 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
605 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
607 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
609 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
610 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
615 /* This function will emit cpp macros to indicate the presence of various lock
616 free atomic operations. */
619 cpp_atomic_builtins (cpp_reader
*pfile
)
621 /* Set a flag for each size of object that compare and swap exists for up to
623 #define SWAP_LIMIT 17
624 bool have_swap
[SWAP_LIMIT
];
627 /* Clear the map of sizes compare_and swap exists for. */
628 memset (have_swap
, 0, sizeof (have_swap
));
630 /* Tell source code if the compiler makes sync_compare_and_swap
631 builtins available. */
632 #ifndef HAVE_sync_compare_and_swapqi
633 #define HAVE_sync_compare_and_swapqi 0
635 #ifndef HAVE_atomic_compare_and_swapqi
636 #define HAVE_atomic_compare_and_swapqi 0
639 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
641 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
645 #ifndef HAVE_sync_compare_and_swaphi
646 #define HAVE_sync_compare_and_swaphi 0
648 #ifndef HAVE_atomic_compare_and_swaphi
649 #define HAVE_atomic_compare_and_swaphi 0
651 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
653 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
657 #ifndef HAVE_sync_compare_and_swapsi
658 #define HAVE_sync_compare_and_swapsi 0
660 #ifndef HAVE_atomic_compare_and_swapsi
661 #define HAVE_atomic_compare_and_swapsi 0
663 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
665 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
669 #ifndef HAVE_sync_compare_and_swapdi
670 #define HAVE_sync_compare_and_swapdi 0
672 #ifndef HAVE_atomic_compare_and_swapdi
673 #define HAVE_atomic_compare_and_swapdi 0
675 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
677 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
681 #ifndef HAVE_sync_compare_and_swapti
682 #define HAVE_sync_compare_and_swapti 0
684 #ifndef HAVE_atomic_compare_and_swapti
685 #define HAVE_atomic_compare_and_swapti 0
687 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
689 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
690 have_swap
[16] = true;
693 /* Tell the source code about various types. These map to the C++11 and C11
694 macros where 2 indicates lock-free always, and 1 indicates sometimes
696 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
697 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
698 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
699 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
700 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
701 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
702 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
703 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
704 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
705 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
706 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
707 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
708 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
709 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
710 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
711 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
712 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
713 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
714 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
715 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
717 /* If we're dealing with a "set" value that doesn't exactly correspond
718 to a boolean truth value, let the library work around that. */
719 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
720 targetm
.atomic_test_and_set_trueval
);
722 /* ptr_type_node can't be used here since ptr_mode is only set when
723 toplev calls backend_init which is not done with -E or pch. */
724 psize
= POINTER_SIZE_UNITS
;
725 if (psize
>= SWAP_LIMIT
)
727 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
728 (have_swap
[psize
]? 2 : 1));
731 /* Return TRUE if the implicit excess precision in which the back-end will
732 compute floating-point calculations is not more than the explicit
733 excess precision that the front-end will apply under
734 -fexcess-precision=[standard|fast].
736 More intuitively, return TRUE if the excess precision proposed by the
737 front-end is the excess precision that will actually be used. */
740 c_cpp_flt_eval_method_iec_559 (void)
742 enum excess_precision_type front_end_ept
743 = (flag_excess_precision_cmdline
== EXCESS_PRECISION_STANDARD
744 ? EXCESS_PRECISION_TYPE_STANDARD
745 : EXCESS_PRECISION_TYPE_FAST
);
747 enum flt_eval_method back_end
748 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
750 enum flt_eval_method front_end
751 = targetm
.c
.excess_precision (front_end_ept
);
753 return excess_precision_mode_join (front_end
, back_end
) == front_end
;
756 /* Return the value for __GCC_IEC_559. */
758 cpp_iec_559_value (void)
760 /* The default is support for IEEE 754-2008. */
763 /* float and double must be binary32 and binary64. If they are but
764 with reversed NaN convention, at most IEEE 754-1985 is
766 const struct real_format
*ffmt
767 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
768 const struct real_format
*dfmt
769 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
770 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
775 || ffmt
->emin
!= -125
777 || ffmt
->signbit_rw
!= 31
778 || ffmt
->round_towards_zero
779 || !ffmt
->has_sign_dependent_rounding
783 || !ffmt
->has_signed_zero
787 || dfmt
->emin
!= -1021
788 || dfmt
->emax
!= 1024
789 || dfmt
->signbit_rw
!= 63
790 || dfmt
->round_towards_zero
791 || !dfmt
->has_sign_dependent_rounding
795 || !dfmt
->has_signed_zero
)
798 /* In strict C standards conformance mode, consider a back-end providing
799 more implicit excess precision than the explicit excess precision
800 the front-end options would require to mean a lack of IEEE 754
801 support. For C++, and outside strict conformance mode, do not consider
802 this to mean a lack of IEEE 754 support. */
806 && !c_cpp_flt_eval_method_iec_559 ())
811 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
814 /* Various options are contrary to IEEE 754 semantics. */
815 if (flag_unsafe_math_optimizations
816 || flag_associative_math
817 || flag_reciprocal_math
818 || flag_finite_math_only
819 || !flag_signed_zeros
820 || flag_single_precision_constant
)
823 /* If the target does not support IEEE 754 exceptions and rounding
824 modes, consider IEEE 754 support to be absent. */
825 if (!targetm
.float_exceptions_rounding_supported_p ())
831 /* Return the value for __GCC_IEC_559_COMPLEX. */
833 cpp_iec_559_complex_value (void)
835 /* The value is no bigger than that of __GCC_IEC_559. */
836 int ret
= cpp_iec_559_value ();
838 /* Some options are contrary to the required default state of the
839 CX_LIMITED_RANGE pragma. */
840 if (flag_complex_method
!= 2)
846 /* Hook that registers front end and target-specific built-ins. */
848 c_cpp_builtins (cpp_reader
*pfile
)
852 /* -undef turns off target-specific built-ins. */
856 define_language_independent_builtin_macros (pfile
);
858 if (c_dialect_cxx ())
861 parse_basever (&major
, NULL
, NULL
);
862 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
865 /* For stddef.h. They require macros defined in c-common.c. */
866 c_stddef_cpp_builtins ();
868 /* Set include test macros for all C/C++ (not for just C++11 etc.)
869 The builtins __has_include__ and __has_include_next__ are defined
871 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
872 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
874 if (c_dialect_cxx ())
876 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
877 cpp_define (pfile
, "__GXX_WEAK__=1");
879 cpp_define (pfile
, "__GXX_WEAK__=0");
882 cpp_define (pfile
, "__DEPRECATED");
886 cpp_define (pfile
, "__GXX_RTTI");
887 cpp_define (pfile
, "__cpp_rtti=199711");
890 if (cxx_dialect
>= cxx11
)
891 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
893 /* Binary literals have been allowed in g++ before C++11
894 and were standardized for C++14. */
895 if (!pedantic
|| cxx_dialect
> cxx11
)
896 cpp_define (pfile
, "__cpp_binary_literals=201304");
898 /* Similarly for hexadecimal floating point literals and C++17. */
899 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
900 cpp_define (pfile
, "__cpp_hex_float=201603");
902 /* Arrays of runtime bound were removed from C++14, but we still
903 support GNU VLAs. Let's define this macro to a low number
904 (corresponding to the initial test release of GNU C++) if we won't
905 complain about use of VLAs. */
907 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
908 cpp_define (pfile
, "__cpp_runtime_arrays=198712");
910 if (cxx_dialect
>= cxx11
)
912 /* Set feature test macros for C++11. */
913 if (cxx_dialect
<= cxx14
)
914 cpp_define (pfile
, "__cpp_unicode_characters=200704");
915 cpp_define (pfile
, "__cpp_raw_strings=200710");
916 cpp_define (pfile
, "__cpp_unicode_literals=200710");
917 cpp_define (pfile
, "__cpp_user_defined_literals=200809");
918 cpp_define (pfile
, "__cpp_lambdas=200907");
919 if (cxx_dialect
== cxx11
)
920 cpp_define (pfile
, "__cpp_constexpr=200704");
921 if (cxx_dialect
<= cxx14
)
922 cpp_define (pfile
, "__cpp_range_based_for=200907");
923 if (cxx_dialect
<= cxx14
)
924 cpp_define (pfile
, "__cpp_static_assert=200410");
925 cpp_define (pfile
, "__cpp_decltype=200707");
926 cpp_define (pfile
, "__cpp_attributes=200809");
927 cpp_define (pfile
, "__cpp_rvalue_reference=200610");
928 cpp_define (pfile
, "__cpp_rvalue_references=200610");
929 cpp_define (pfile
, "__cpp_variadic_templates=200704");
930 cpp_define (pfile
, "__cpp_initializer_lists=200806");
931 cpp_define (pfile
, "__cpp_delegating_constructors=200604");
932 cpp_define (pfile
, "__cpp_nsdmi=200809");
933 if (!flag_new_inheriting_ctors
)
934 cpp_define (pfile
, "__cpp_inheriting_constructors=200802");
936 cpp_define (pfile
, "__cpp_inheriting_constructors=201511");
937 cpp_define (pfile
, "__cpp_ref_qualifiers=200710");
938 cpp_define (pfile
, "__cpp_alias_templates=200704");
940 if (cxx_dialect
> cxx11
)
942 /* Set feature test macros for C++14. */
943 cpp_define (pfile
, "__cpp_return_type_deduction=201304");
944 cpp_define (pfile
, "__cpp_init_captures=201304");
945 cpp_define (pfile
, "__cpp_generic_lambdas=201304");
946 if (cxx_dialect
<= cxx14
)
947 cpp_define (pfile
, "__cpp_constexpr=201304");
948 cpp_define (pfile
, "__cpp_decltype_auto=201304");
949 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304");
950 cpp_define (pfile
, "__cpp_variable_templates=201304");
951 cpp_define (pfile
, "__cpp_digit_separators=201309");
953 if (cxx_dialect
> cxx14
)
955 /* Set feature test macros for C++1z. */
956 cpp_define (pfile
, "__cpp_unicode_characters=201411");
957 cpp_define (pfile
, "__cpp_static_assert=201411");
958 cpp_define (pfile
, "__cpp_namespace_attributes=201411");
959 cpp_define (pfile
, "__cpp_enumerator_attributes=201411");
960 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411");
961 cpp_define (pfile
, "__cpp_fold_expressions=201603");
962 cpp_define (pfile
, "__cpp_nontype_template_args=201411");
963 cpp_define (pfile
, "__cpp_range_based_for=201603");
964 cpp_define (pfile
, "__cpp_constexpr=201603");
965 cpp_define (pfile
, "__cpp_if_constexpr=201606");
966 cpp_define (pfile
, "__cpp_capture_star_this=201603");
967 cpp_define (pfile
, "__cpp_inline_variables=201606");
968 cpp_define (pfile
, "__cpp_aggregate_bases=201603");
969 cpp_define (pfile
, "__cpp_deduction_guides=201606");
970 cpp_define (pfile
, "__cpp_noexcept_function_type=201510");
971 cpp_define (pfile
, "__cpp_template_auto=201606");
972 cpp_define (pfile
, "__cpp_structured_bindings=201606");
973 cpp_define (pfile
, "__cpp_variadic_using=201611");
976 cpp_define (pfile
, "__cpp_concepts=201507");
978 /* Use a value smaller than the 201505 specified in
979 the TS, since we don't yet support atomic_cancel. */
980 cpp_define (pfile
, "__cpp_transactional_memory=210500");
981 if (flag_sized_deallocation
)
982 cpp_define (pfile
, "__cpp_sized_deallocation=201309");
983 if (aligned_new_threshold
)
985 cpp_define (pfile
, "__cpp_aligned_new=201606");
986 cpp_define_formatted (pfile
, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
987 aligned_new_threshold
);
990 cpp_define (pfile
, "__cpp_template_template_args=201611");
992 /* Note that we define this for C as well, so that we know if
993 __attribute__((cleanup)) will interface with EH. */
996 cpp_define (pfile
, "__EXCEPTIONS");
997 if (c_dialect_cxx ())
998 cpp_define (pfile
, "__cpp_exceptions=199711");
1001 /* Represents the C++ ABI version, always defined so it can be used while
1002 preprocessing C and assembler. */
1003 if (flag_abi_version
== 0)
1004 /* We should have set this to something real in c_common_post_options. */
1006 else if (flag_abi_version
== 1)
1007 /* Due to a historical accident, this version had the value
1009 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1011 /* Newer versions have values 1002, 1003, .... */
1012 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1013 1000 + flag_abi_version
);
1015 /* libgcc needs to know this. */
1016 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1017 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
1019 /* limits.h and stdint.h need to know these. */
1020 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
1021 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
1022 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
1023 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
1024 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
1025 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1026 underlying_wchar_type_node
);
1027 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
1028 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
1029 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
1031 /* These are needed for TS 18661-1. */
1032 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node
,
1033 unsigned_char_type_node
);
1034 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node
,
1035 short_unsigned_type_node
);
1036 builtin_define_type_width ("__INT_WIDTH__", integer_type_node
,
1037 unsigned_type_node
);
1038 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node
,
1039 long_unsigned_type_node
);
1040 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1041 long_long_integer_type_node
,
1042 long_long_unsigned_type_node
);
1043 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node
,
1045 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node
, NULL_TREE
);
1046 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node
, NULL_TREE
);
1047 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node
, NULL_TREE
);
1049 if (c_dialect_cxx ())
1050 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1051 if (int_n_enabled_p
[i
])
1055 /* These are used to configure the C++ library. */
1057 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
1059 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
1060 cpp_define (parse_in
, buf
);
1062 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
1063 cpp_define (parse_in
, buf
);
1067 /* stdint.h and the testsuite need to know these. */
1068 builtin_define_stdint_macros ();
1070 /* Provide information for library headers to determine whether to
1071 define macros such as __STDC_IEC_559__ and
1072 __STDC_IEC_559_COMPLEX__. */
1073 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1074 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1075 cpp_iec_559_complex_value ());
1077 /* float.h needs these to correctly set FLT_EVAL_METHOD
1079 We define two values:
1082 Which, depending on the value given for
1083 -fpermitted-flt-eval-methods, may be limited to only those values
1084 for FLT_EVAL_METHOD defined in C99/C11.
1086 __FLT_EVAL_METHOD_TS_18661_3__
1087 Which always permits the values for FLT_EVAL_METHOD defined in
1088 ISO/IEC TS 18661-3. */
1089 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1090 c_flt_eval_method (true));
1091 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1092 c_flt_eval_method (false));
1094 /* And decfloat.h needs this. */
1095 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1096 TARGET_DEC_EVAL_METHOD
);
1098 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
1099 /* Cast the double precision constants. This is needed when single
1100 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1101 is used. The correct result is computed by the compiler when using
1102 macros that include a cast. We use a different cast for C++ to avoid
1103 problems with -Wold-style-cast. */
1104 builtin_define_float_constants ("DBL", "L",
1108 "", double_type_node
);
1109 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1110 long_double_type_node
);
1112 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1114 if (FLOATN_NX_TYPE_NODE (i
) == NULL_TREE
)
1116 char prefix
[20], csuffix
[20];
1117 sprintf (prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1118 floatn_nx_types
[i
].extended
? "X" : "");
1119 sprintf (csuffix
, "F%d%s", floatn_nx_types
[i
].n
,
1120 floatn_nx_types
[i
].extended
? "x" : "");
1121 builtin_define_float_constants (prefix
, csuffix
, "%s", NULL
,
1122 FLOATN_NX_TYPE_NODE (i
));
1125 /* For decfloat.h. */
1126 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
1127 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
1128 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
1130 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1131 if (targetm
.fixed_point_supported_p ())
1133 builtin_define_fixed_point_constants ("SFRACT", "HR",
1134 short_fract_type_node
);
1135 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1136 unsigned_short_fract_type_node
);
1137 builtin_define_fixed_point_constants ("FRACT", "R",
1139 builtin_define_fixed_point_constants ("UFRACT", "UR",
1140 unsigned_fract_type_node
);
1141 builtin_define_fixed_point_constants ("LFRACT", "LR",
1142 long_fract_type_node
);
1143 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1144 unsigned_long_fract_type_node
);
1145 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1146 long_long_fract_type_node
);
1147 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1148 unsigned_long_long_fract_type_node
);
1149 builtin_define_fixed_point_constants ("SACCUM", "HK",
1150 short_accum_type_node
);
1151 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1152 unsigned_short_accum_type_node
);
1153 builtin_define_fixed_point_constants ("ACCUM", "K",
1155 builtin_define_fixed_point_constants ("UACCUM", "UK",
1156 unsigned_accum_type_node
);
1157 builtin_define_fixed_point_constants ("LACCUM", "LK",
1158 long_accum_type_node
);
1159 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1160 unsigned_long_accum_type_node
);
1161 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1162 long_long_accum_type_node
);
1163 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1164 unsigned_long_long_accum_type_node
);
1166 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1167 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1168 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1169 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1170 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1171 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1172 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1173 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1174 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1175 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1176 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1177 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1178 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1179 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1180 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1181 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1182 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1183 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1186 /* For libgcc-internal use only. */
1187 if (flag_building_libgcc
)
1189 /* Properties of floating-point modes for libgcc2.c. */
1190 for (machine_mode mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1192 mode
= GET_MODE_WIDER_MODE (mode
))
1194 const char *name
= GET_MODE_NAME (mode
);
1196 = (char *) alloca (strlen (name
)
1197 + sizeof ("__LIBGCC__MANT_DIG__"));
1198 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1199 builtin_define_with_int_value (macro_name
,
1200 REAL_MODE_FORMAT (mode
)->p
);
1201 if (!targetm
.scalar_mode_supported_p (mode
)
1202 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1204 macro_name
= (char *) alloca (strlen (name
)
1205 + sizeof ("__LIBGCC_HAS__MODE__"));
1206 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1207 cpp_define (pfile
, macro_name
);
1208 macro_name
= (char *) alloca (strlen (name
)
1209 + sizeof ("__LIBGCC__FUNC_EXT__"));
1210 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1211 char suffix
[20] = "";
1212 if (mode
== TYPE_MODE (double_type_node
))
1213 ; /* Empty suffix correct. */
1214 else if (mode
== TYPE_MODE (float_type_node
))
1216 else if (mode
== TYPE_MODE (long_double_type_node
))
1220 bool found_suffix
= false;
1221 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1222 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
1223 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
1225 sprintf (suffix
, "f%d%s", floatn_nx_types
[i
].n
,
1226 floatn_nx_types
[i
].extended
? "x" : "");
1227 found_suffix
= true;
1230 gcc_assert (found_suffix
);
1232 builtin_define_with_value (macro_name
, suffix
, 0);
1234 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1235 eliminating excess precision from results assigned to
1236 variables - meaning it should be about the implicit excess
1238 bool excess_precision
= false;
1239 machine_mode float16_type_mode
= (float16_type_node
1240 ? TYPE_MODE (float16_type_node
)
1242 switch (targetm
.c
.excess_precision
1243 (EXCESS_PRECISION_TYPE_IMPLICIT
))
1245 case FLT_EVAL_METHOD_UNPREDICTABLE
:
1246 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
1247 excess_precision
= (mode
== float16_type_mode
1248 || mode
== TYPE_MODE (float_type_node
)
1249 || mode
== TYPE_MODE (double_type_node
));
1252 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
1253 excess_precision
= (mode
== float16_type_mode
1254 || mode
== TYPE_MODE (float_type_node
));
1256 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
1257 excess_precision
= mode
== float16_type_mode
;
1259 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
:
1260 excess_precision
= false;
1265 macro_name
= (char *) alloca (strlen (name
)
1266 + sizeof ("__LIBGCC__EXCESS_"
1268 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1269 builtin_define_with_int_value (macro_name
, excess_precision
);
1272 /* For libgcc crtstuff.c and libgcc2.c. */
1273 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1274 EH_TABLES_CAN_BE_READ_ONLY
);
1275 #ifdef EH_FRAME_SECTION_NAME
1276 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1277 EH_FRAME_SECTION_NAME
, 1);
1279 #ifdef CTORS_SECTION_ASM_OP
1280 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1281 CTORS_SECTION_ASM_OP
, 1);
1283 #ifdef DTORS_SECTION_ASM_OP
1284 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1285 DTORS_SECTION_ASM_OP
, 1);
1287 #ifdef TEXT_SECTION_ASM_OP
1288 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1289 TEXT_SECTION_ASM_OP
, 1);
1291 #ifdef INIT_SECTION_ASM_OP
1292 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1293 INIT_SECTION_ASM_OP
, 1);
1295 #ifdef INIT_ARRAY_SECTION_ASM_OP
1296 /* Despite the name of this target macro, the expansion is not
1297 actually used, and may be empty rather than a string
1299 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1302 /* For libgcc enable-execute-stack.c. */
1303 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1306 /* For libgcc generic-morestack.c and unwinder code. */
1307 if (STACK_GROWS_DOWNWARD
)
1308 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1310 /* For libgcc unwinder code. */
1311 #ifdef DONT_USE_BUILTIN_SETJMP
1312 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1314 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1315 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1316 DWARF_ALT_FRAME_RETURN_COLUMN
);
1318 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1319 DWARF_FRAME_REGISTERS
);
1320 #ifdef EH_RETURN_STACKADJ_RTX
1321 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1324 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1327 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1328 STACK_POINTER_REGNUM
);
1331 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1332 TARGET_VTABLE_USES_DESCRIPTORS
);
1335 /* For use in assembly language. */
1336 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1337 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1340 if (flag_gnu89_inline
)
1341 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1343 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1346 cpp_define (pfile
, "__NO_INLINE__");
1349 cpp_define (pfile
, "__STRICT_ANSI__");
1351 if (!flag_signed_char
)
1352 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1354 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1355 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1357 cpp_atomic_builtins (pfile
);
1359 #ifdef DWARF2_UNWIND_INFO
1360 if (dwarf2out_do_cfi_asm ())
1361 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1364 /* Make the choice of ObjC runtime visible to source code. */
1365 if (c_dialect_objc () && flag_next_runtime
)
1366 cpp_define (pfile
, "__NEXT_RUNTIME__");
1368 /* Show the availability of some target pragmas. */
1369 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1371 /* Make the choice of the stack protector runtime visible to source code.
1372 The macro names and values here were chosen for compatibility with an
1373 earlier implementation, i.e. ProPolice. */
1374 if (flag_stack_protect
== 4)
1375 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1376 if (flag_stack_protect
== 3)
1377 cpp_define (pfile
, "__SSP_STRONG__=3");
1378 if (flag_stack_protect
== 2)
1379 cpp_define (pfile
, "__SSP_ALL__=2");
1380 else if (flag_stack_protect
== 1)
1381 cpp_define (pfile
, "__SSP__=1");
1384 cpp_define (pfile
, "_OPENACC=201306");
1387 cpp_define (pfile
, "_OPENMP=201511");
1389 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1390 if (int_n_enabled_p
[i
])
1393 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1394 builtin_define_type_sizeof (buf
,
1395 int_n_trees
[i
].signed_type
);
1397 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1398 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1399 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1400 unsigned_ptrdiff_type_node
);
1402 /* A straightforward target hook doesn't work, because of problems
1403 linking that hook's body when part of non-C front ends. */
1404 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1405 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1406 # define builtin_define(TXT) cpp_define (pfile, TXT)
1407 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1408 TARGET_CPU_CPP_BUILTINS ();
1409 TARGET_OS_CPP_BUILTINS ();
1410 TARGET_OBJFMT_CPP_BUILTINS ();
1412 /* Support the __declspec keyword by turning them into attributes.
1413 Note that the current way we do this may result in a collision
1414 with predefined attributes later on. This can be solved by using
1415 one attribute, say __declspec__, and passing args to it. The
1416 problem with that approach is that args are not accumulated: each
1417 new appearance would clobber any existing args. */
1418 if (TARGET_DECLSPEC
)
1419 builtin_define ("__declspec(x)=__attribute__((x))");
1421 /* If decimal floating point is supported, tell the user if the
1422 alternate format (BID) is used instead of the standard (DPD)
1424 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1425 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1428 /* Pass an object-like macro. If it doesn't lie in the user's
1429 namespace, defines it unconditionally. Otherwise define a version
1430 with two leading underscores, and another version with two leading
1431 and trailing underscores, and define the original only if an ISO
1432 standard was not nominated.
1434 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1435 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1438 builtin_define_std (const char *macro
)
1440 size_t len
= strlen (macro
);
1441 char *buff
= (char *) alloca (len
+ 5);
1445 /* prepend __ (or maybe just _) if in user's namespace. */
1446 memcpy (p
, macro
, len
+ 1);
1447 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1454 cpp_define (parse_in
, p
);
1456 /* If it was in user's namespace... */
1459 /* Define the macro with leading and following __. */
1465 cpp_define (parse_in
, p
);
1467 /* Finally, define the original macro if permitted. */
1469 cpp_define (parse_in
, macro
);
1473 /* Pass an object-like macro and a value to define it to. The third
1474 parameter says whether or not to turn the value into a string
1477 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1480 size_t mlen
= strlen (macro
);
1481 size_t elen
= strlen (expansion
);
1482 size_t extra
= 2; /* space for an = and a NUL */
1486 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1489 extra
+= 2; /* space for two quote marks */
1490 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1515 if (ISPRINT ((unsigned char) *p
))
1519 sprintf (q
, "\\%03o", (unsigned char) *p
);
1525 expansion
= quoted_expansion
;
1526 elen
= q
- expansion
;
1529 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1531 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1533 sprintf (buf
, "%s=%s", macro
, expansion
);
1535 cpp_define (parse_in
, buf
);
1539 /* Pass an object-like macro and an integer value to define it to. */
1541 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1544 size_t mlen
= strlen (macro
);
1546 size_t extra
= 2; /* space for = and NUL. */
1548 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1549 memcpy (buf
, macro
, mlen
);
1551 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1553 cpp_define (parse_in
, buf
);
1556 /* builtin_define_with_hex_fp_value is very expensive, so the following
1557 array and function allows it to be done lazily when __DBL_MAX__
1558 etc. is first used. */
1560 struct GTY(()) lazy_hex_fp_value_struct
1562 const char *hex_str
;
1566 const char *fp_suffix
;
1568 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1569 static GTY(()) int lazy_hex_fp_value_count
;
1572 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1575 REAL_VALUE_TYPE real
;
1576 char dec_str
[64], buf1
[256];
1578 if (node
->value
.builtin
< BT_FIRST_USER
1579 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1582 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1583 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1584 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1585 lazy_hex_fp_values
[idx
].digits
, 0,
1586 lazy_hex_fp_values
[idx
].mode
);
1588 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1589 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1590 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1591 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1592 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1594 gcc_assert (idx
< node
->value
.macro
->count
);
1595 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1596 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1597 = (const unsigned char *) ggc_strdup (buf1
);
1601 /* Pass an object-like macro a hexadecimal floating-point value. */
1603 builtin_define_with_hex_fp_value (const char *macro
,
1604 tree type
, int digits
,
1605 const char *hex_str
,
1606 const char *fp_suffix
,
1607 const char *fp_cast
)
1609 REAL_VALUE_TYPE real
;
1610 char dec_str
[64], buf1
[256], buf2
[256];
1612 /* This is very expensive, so if possible expand them lazily. */
1613 if (lazy_hex_fp_value_count
< 12
1614 && flag_dump_macros
== 0
1615 && !cpp_get_options (parse_in
)->traditional
)
1617 struct cpp_hashnode
*node
;
1618 if (lazy_hex_fp_value_count
== 0)
1619 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1620 sprintf (buf2
, fp_cast
, "1.1");
1621 sprintf (buf1
, "%s=%s", macro
, buf2
);
1622 cpp_define (parse_in
, buf1
);
1623 node
= C_CPP_HASHNODE (get_identifier (macro
));
1624 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1625 = ggc_strdup (hex_str
);
1626 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1627 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1628 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1629 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1630 node
->flags
|= NODE_BUILTIN
;
1632 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1633 lazy_hex_fp_value_count
++;
1637 /* Hex values are really cool and convenient, except that they're
1638 not supported in strict ISO C90 mode. First, the "p-" sequence
1639 is not valid as part of a preprocessor number. Second, we get a
1640 pedwarn from the preprocessor, which has no context, so we can't
1641 suppress the warning with __extension__.
1643 So instead what we do is construct the number in hex (because
1644 it's easy to get the exact correct value), parse it as a real,
1645 then print it back out as decimal. */
1647 real_from_string (&real
, hex_str
);
1648 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1651 /* Assemble the macro in the following fashion
1652 macro = fp_cast [dec_str fp_suffix] */
1653 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1654 sprintf (buf2
, fp_cast
, buf1
);
1655 sprintf (buf1
, "%s=%s", macro
, buf2
);
1657 cpp_define (parse_in
, buf1
);
1660 /* Return a string constant for the suffix for a value of type TYPE
1661 promoted according to the integer promotions. The type must be one
1662 of the standard integer type nodes. */
1665 type_suffix (tree type
)
1667 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1668 int unsigned_suffix
;
1670 int tp
= TYPE_PRECISION (type
);
1672 if (type
== long_long_integer_type_node
1673 || type
== long_long_unsigned_type_node
1674 || tp
> TYPE_PRECISION (long_integer_type_node
))
1676 else if (type
== long_integer_type_node
1677 || type
== long_unsigned_type_node
1678 || tp
> TYPE_PRECISION (integer_type_node
))
1680 else if (type
== integer_type_node
1681 || type
== unsigned_type_node
1682 || type
== short_integer_type_node
1683 || type
== short_unsigned_type_node
1684 || type
== signed_char_type_node
1685 || type
== unsigned_char_type_node
1686 /* ??? "char" is not a signed or unsigned integer type and
1687 so is not permitted for the standard typedefs, but some
1688 systems use it anyway. */
1689 || type
== char_type_node
)
1694 unsigned_suffix
= TYPE_UNSIGNED (type
);
1695 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1696 unsigned_suffix
= 0;
1697 return suffixes
[is_long
* 2 + unsigned_suffix
];
1700 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1702 builtin_define_constants (const char *macro
, tree type
)
1707 suffix
= type_suffix (type
);
1711 buf
= (char *) alloca (strlen (macro
) + 6);
1712 sprintf (buf
, "%s(c)=c", macro
);
1716 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1717 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1720 cpp_define (parse_in
, buf
);
1723 /* Define MAX for TYPE based on the precision of the type. */
1726 builtin_define_type_max (const char *macro
, tree type
)
1728 builtin_define_type_minmax (NULL
, macro
, type
);
1731 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1732 representation of that value. For example, a COUNT of 10 would
1736 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1738 gcc_assert (bufsz
> 3);
1743 gcc_assert (count
> 0);
1745 switch (count
% 4) {
1766 gcc_assert (bufsz
> 1);
1771 gcc_assert (bufsz
> 0);
1775 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1776 precision of the type. */
1779 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1782 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1783 char value
[PBOH_SZ
];
1789 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1791 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1793 suffix
= type_suffix (type
);
1795 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1796 + strlen (suffix
) + 1);
1797 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1799 cpp_define (parse_in
, buf
);
1803 if (TYPE_UNSIGNED (type
))
1805 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1806 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1810 buf
= (char *) alloca (strlen (min_macro
) + 3
1811 + strlen (max_macro
) + 6);
1812 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1814 cpp_define (parse_in
, buf
);
1818 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1819 both types must have the same width. */
1822 builtin_define_type_width (const char *width_macro
, tree type
, tree type2
)
1824 if (type2
!= NULL_TREE
)
1825 gcc_assert (TYPE_PRECISION (type
) == TYPE_PRECISION (type2
));
1826 builtin_define_with_int_value (width_macro
, TYPE_PRECISION (type
));
1829 #include "gt-c-family-c-cppbuiltin.h"