1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2016 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"
25 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
26 #include "stringpool.h"
27 #include "stor-layout.h"
30 #include "output.h" /* For user_label_prefix. */
31 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
32 #include "common/common-target.h"
33 #include "cpp-id-data.h"
34 #include "cppbuiltin.h"
36 #ifndef TARGET_OS_CPP_BUILTINS
37 # define TARGET_OS_CPP_BUILTINS()
40 #ifndef TARGET_OBJFMT_CPP_BUILTINS
41 # define TARGET_OBJFMT_CPP_BUILTINS()
44 #ifndef REGISTER_PREFIX
45 #define REGISTER_PREFIX ""
48 /* Non-static as some targets don't use it. */
49 static void builtin_define_with_hex_fp_value (const char *, tree
,
53 static void builtin_define_stdint_macros (void);
54 static void builtin_define_constants (const char *, tree
);
55 static void builtin_define_type_max (const char *, tree
);
56 static void builtin_define_type_minmax (const char *, const char *, tree
);
57 static void builtin_define_type_width (const char *, tree
, tree
);
58 static void builtin_define_float_constants (const char *,
64 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
65 Originally this function used the fma optab, but that doesn't work with
66 -save-temps, so just rely on the HAVE_fma macros for the standard floating
70 mode_has_fma (machine_mode mode
)
101 /* Define NAME with value TYPE size_unit. */
103 builtin_define_type_sizeof (const char *name
, tree type
)
105 builtin_define_with_int_value (name
,
106 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
109 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
112 builtin_define_float_constants (const char *name_prefix
,
113 const char *fp_suffix
,
115 const char *fma_suffix
,
118 /* Used to convert radix-based values to base 10 values in several cases.
120 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
121 least 6 significant digits for correct results. Using the fraction
122 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
123 intermediate; perhaps someone can find a better approximation, in the
124 mean time, I suspect using doubles won't harm the bootstrap here. */
126 const double log10_2
= .30102999566398119521;
128 const struct real_format
*fmt
;
129 const struct real_format
*widefmt
;
131 char name
[64], buf
[128];
132 int dig
, min_10_exp
, max_10_exp
;
134 int type_decimal_dig
;
136 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
137 gcc_assert (fmt
->b
!= 10);
138 widefmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
139 gcc_assert (widefmt
->b
!= 10);
140 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
142 tree wtype
= FLOATN_NX_TYPE_NODE (i
);
143 if (wtype
!= NULL_TREE
)
145 const struct real_format
*wfmt
146 = REAL_MODE_FORMAT (TYPE_MODE (wtype
));
147 gcc_assert (wfmt
->b
!= 10);
148 if (wfmt
->p
> widefmt
->p
)
153 /* The radix of the exponent representation. */
154 if (type
== float_type_node
)
155 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
158 /* The number of radix digits, p, in the floating-point significand. */
159 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
160 builtin_define_with_int_value (name
, fmt
->p
);
162 /* The number of decimal digits, q, such that any floating-point number
163 with q decimal digits can be rounded into a floating-point number with
164 p radix b digits and back again without change to the q decimal digits,
166 p log10 b if b is a power of 10
167 floor((p - 1) log10 b) otherwise
169 dig
= (fmt
->p
- 1) * log10_b
;
170 sprintf (name
, "__%s_DIG__", name_prefix
);
171 builtin_define_with_int_value (name
, dig
);
173 /* The minimum negative int x such that b**(x-1) is a normalized float. */
174 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
175 sprintf (buf
, "(%d)", fmt
->emin
);
176 builtin_define_with_value (name
, buf
, 0);
178 /* The minimum negative int x such that 10**x is a normalized float,
180 ceil (log10 (b ** (emin - 1)))
181 = ceil (log10 (b) * (emin - 1))
183 Recall that emin is negative, so the integer truncation calculates
184 the ceiling, not the floor, in this case. */
185 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
186 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
187 sprintf (buf
, "(%d)", min_10_exp
);
188 builtin_define_with_value (name
, buf
, 0);
190 /* The maximum int x such that b**(x-1) is a representable float. */
191 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
192 builtin_define_with_int_value (name
, fmt
->emax
);
194 /* The maximum int x such that 10**x is in the range of representable
195 finite floating-point numbers,
197 floor (log10((1 - b**-p) * b**emax))
198 = floor (log10(1 - b**-p) + log10(b**emax))
199 = floor (log10(1 - b**-p) + log10(b)*emax)
201 The safest thing to do here is to just compute this number. But since
202 we don't link cc1 with libm, we cannot. We could implement log10 here
203 a series expansion, but that seems too much effort because:
205 Note that the first term, for all extant p, is a number exceedingly close
206 to zero, but slightly negative. Note that the second term is an integer
207 scaling an irrational number, and that because of the floor we are only
208 interested in its integral portion.
210 In order for the first term to have any effect on the integral portion
211 of the second term, the second term has to be exceedingly close to an
212 integer itself (e.g. 123.000000000001 or something). Getting a result
213 that close to an integer requires that the irrational multiplicand have
214 a long series of zeros in its expansion, which doesn't occur in the
215 first 20 digits or so of log10(b).
217 Hand-waving aside, crunching all of the sets of constants above by hand
218 does not yield a case for which the first term is significant, which
219 in the end is all that matters. */
220 max_10_exp
= fmt
->emax
* log10_b
;
221 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
222 builtin_define_with_int_value (name
, max_10_exp
);
224 /* The number of decimal digits, n, such that any floating-point number
225 can be rounded to n decimal digits and back again without change to
228 p * log10(b) if b is a power of 10
229 ceil(1 + p * log10(b)) otherwise
231 The only macro we care about is this number for the widest supported
232 floating type, but we want this value for rendering constants below. */
235 = 1 + (fmt
->p
< widefmt
->p
? widefmt
->p
: fmt
->p
) * log10_b
;
236 decimal_dig
= d_decimal_dig
;
237 if (decimal_dig
< d_decimal_dig
)
240 /* Similar, for this type rather than long double. */
242 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
243 type_decimal_dig
= type_d_decimal_dig
;
244 if (type_decimal_dig
< type_d_decimal_dig
)
247 /* Arbitrarily, define __DECIMAL_DIG__ when defining macros for long
248 double, although it may be greater than the value for long
250 if (type
== long_double_type_node
)
251 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
252 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
253 builtin_define_with_int_value (name
, type_decimal_dig
);
255 /* Since, for the supported formats, B is always a power of 2, we
256 construct the following numbers directly as a hexadecimal
258 get_max_float (fmt
, buf
, sizeof (buf
));
260 sprintf (name
, "__%s_MAX__", name_prefix
);
261 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
263 /* The minimum normalized positive floating-point number,
265 sprintf (name
, "__%s_MIN__", name_prefix
);
266 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
267 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
269 /* The difference between 1 and the least value greater than 1 that is
270 representable in the given floating point type, b**(1-p). */
271 sprintf (name
, "__%s_EPSILON__", name_prefix
);
272 if (fmt
->pnan
< fmt
->p
)
273 /* This is an IBM extended double format, so 1.0 + any double is
274 representable precisely. */
275 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
277 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
278 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
280 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
281 The minimum denormalized positive floating-point number, b**(emin-p).
282 The minimum normalized positive floating-point number for formats
283 that don't support denormals. */
284 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
285 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
286 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
287 buf
, fp_suffix
, fp_cast
);
289 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
290 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
292 /* For C++ std::numeric_limits<T>::has_infinity. */
293 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
294 builtin_define_with_int_value (name
,
295 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
296 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
297 predicate to distinguish a target that has both quiet and
298 signalling NaNs from a target that has only quiet NaNs or only
299 signalling NaNs, so we assume that a target that has any kind of
300 NaN has quiet NaNs. */
301 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
302 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
304 /* Note whether we have fast FMA. */
305 if (mode_has_fma (TYPE_MODE (type
)) && fma_suffix
!= NULL
)
307 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
308 builtin_define_with_int_value (name
, 1);
312 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
314 builtin_define_decimal_float_constants (const char *name_prefix
,
318 const struct real_format
*fmt
;
319 char name
[64], buf
[128], *p
;
322 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
324 /* The number of radix digits, p, in the significand. */
325 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
326 builtin_define_with_int_value (name
, fmt
->p
);
328 /* The minimum negative int x such that b**(x-1) is a normalized float. */
329 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
330 sprintf (buf
, "(%d)", fmt
->emin
);
331 builtin_define_with_value (name
, buf
, 0);
333 /* The maximum int x such that b**(x-1) is a representable float. */
334 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
335 builtin_define_with_int_value (name
, fmt
->emax
);
337 /* Compute the minimum representable value. */
338 sprintf (name
, "__%s_MIN__", name_prefix
);
339 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
340 builtin_define_with_value (name
, buf
, 0);
342 /* Compute the maximum representable value. */
343 sprintf (name
, "__%s_MAX__", name_prefix
);
345 for (digits
= fmt
->p
; digits
; digits
--)
348 if (digits
== fmt
->p
)
352 /* fmt->p plus 1, to account for the decimal point and fmt->emax
353 minus 1 because the digits are nines, not 1.0. */
354 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
355 builtin_define_with_value (name
, buf
, 0);
357 /* Compute epsilon (the difference between 1 and least value greater
358 than 1 representable). */
359 sprintf (name
, "__%s_EPSILON__", name_prefix
);
360 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
361 builtin_define_with_value (name
, buf
, 0);
363 /* Minimum subnormal positive decimal value. */
364 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
366 for (digits
= fmt
->p
; digits
> 1; digits
--)
369 if (digits
== fmt
->p
)
373 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
374 builtin_define_with_value (name
, buf
, 0);
377 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
380 builtin_define_fixed_point_constants (const char *name_prefix
,
384 char name
[64], buf
[256], *new_buf
;
387 sprintf (name
, "__%s_FBIT__", name_prefix
);
388 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
390 sprintf (name
, "__%s_IBIT__", name_prefix
);
391 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
393 /* If there is no suffix, defines are for fixed-point modes.
395 if (strcmp (suffix
, "") == 0)
398 if (TYPE_UNSIGNED (type
))
400 sprintf (name
, "__%s_MIN__", name_prefix
);
401 sprintf (buf
, "0.0%s", suffix
);
402 builtin_define_with_value (name
, buf
, 0);
406 sprintf (name
, "__%s_MIN__", name_prefix
);
407 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
408 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
409 TYPE_IBIT (type
) - 1, suffix
);
411 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
412 builtin_define_with_value (name
, buf
, 0);
415 sprintf (name
, "__%s_MAX__", name_prefix
);
418 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
420 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
421 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
422 sprintf (new_buf
++, "F");
423 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
424 builtin_define_with_value (name
, buf
, 0);
426 sprintf (name
, "__%s_EPSILON__", name_prefix
);
427 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
428 builtin_define_with_value (name
, buf
, 0);
431 /* Define macros used by <stdint.h>. */
433 builtin_define_stdint_macros (void)
435 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
436 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
437 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
438 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
439 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node
,
441 if (sig_atomic_type_node
)
443 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
444 sig_atomic_type_node
);
445 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node
,
449 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
451 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
453 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
455 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
457 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
458 if (c_uint16_type_node
)
459 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
460 if (c_uint32_type_node
)
461 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
462 if (c_uint64_type_node
)
463 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
464 if (int_least8_type_node
)
466 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
467 builtin_define_constants ("__INT8_C", int_least8_type_node
);
468 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node
,
469 uint_least8_type_node
);
471 if (int_least16_type_node
)
473 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
474 builtin_define_constants ("__INT16_C", int_least16_type_node
);
475 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
476 int_least16_type_node
,
477 uint_least16_type_node
);
479 if (int_least32_type_node
)
481 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
482 builtin_define_constants ("__INT32_C", int_least32_type_node
);
483 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
484 int_least32_type_node
,
485 uint_least32_type_node
);
487 if (int_least64_type_node
)
489 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
490 builtin_define_constants ("__INT64_C", int_least64_type_node
);
491 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
492 int_least64_type_node
,
493 uint_least64_type_node
);
495 if (uint_least8_type_node
)
497 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
498 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
500 if (uint_least16_type_node
)
502 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
503 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
505 if (uint_least32_type_node
)
507 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
508 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
510 if (uint_least64_type_node
)
512 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
513 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
515 if (int_fast8_type_node
)
517 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
518 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node
,
519 uint_fast8_type_node
);
521 if (int_fast16_type_node
)
523 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
524 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node
,
525 uint_fast16_type_node
);
527 if (int_fast32_type_node
)
529 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
530 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node
,
531 uint_fast32_type_node
);
533 if (int_fast64_type_node
)
535 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
536 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node
,
537 uint_fast64_type_node
);
539 if (uint_fast8_type_node
)
540 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
541 if (uint_fast16_type_node
)
542 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
543 if (uint_fast32_type_node
)
544 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
545 if (uint_fast64_type_node
)
546 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
547 if (intptr_type_node
)
549 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
550 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node
,
553 if (uintptr_type_node
)
554 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
557 /* Adjust the optimization macros when a #pragma GCC optimization is done to
558 reflect the current level. */
560 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
563 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
564 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
568 /* -undef turns off target-specific built-ins. */
572 /* Other target-independent built-ins determined by command-line
574 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
575 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
576 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
577 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
579 if (!prev
->x_optimize
&& cur
->x_optimize
)
580 cpp_define (pfile
, "__OPTIMIZE__");
581 else if (prev
->x_optimize
&& !cur
->x_optimize
)
582 cpp_undef (pfile
, "__OPTIMIZE__");
584 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
585 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
586 if (!prev_fast_math
&& cur_fast_math
)
587 cpp_define (pfile
, "__FAST_MATH__");
588 else if (prev_fast_math
&& !cur_fast_math
)
589 cpp_undef (pfile
, "__FAST_MATH__");
591 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
592 cpp_define (pfile
, "__SUPPORT_SNAN__");
593 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
594 cpp_undef (pfile
, "__SUPPORT_SNAN__");
596 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
597 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
598 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
599 cpp_define (pfile
, "__NO_MATH_ERRNO__");
601 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
603 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
604 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
606 else 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__=0");
614 /* This function will emit cpp macros to indicate the presence of various lock
615 free atomic operations. */
618 cpp_atomic_builtins (cpp_reader
*pfile
)
620 /* Set a flag for each size of object that compare and swap exists for up to
622 #define SWAP_LIMIT 17
623 bool have_swap
[SWAP_LIMIT
];
626 /* Clear the map of sizes compare_and swap exists for. */
627 memset (have_swap
, 0, sizeof (have_swap
));
629 /* Tell source code if the compiler makes sync_compare_and_swap
630 builtins available. */
631 #ifndef HAVE_sync_compare_and_swapqi
632 #define HAVE_sync_compare_and_swapqi 0
634 #ifndef HAVE_atomic_compare_and_swapqi
635 #define HAVE_atomic_compare_and_swapqi 0
638 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
640 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
644 #ifndef HAVE_sync_compare_and_swaphi
645 #define HAVE_sync_compare_and_swaphi 0
647 #ifndef HAVE_atomic_compare_and_swaphi
648 #define HAVE_atomic_compare_and_swaphi 0
650 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
652 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
656 #ifndef HAVE_sync_compare_and_swapsi
657 #define HAVE_sync_compare_and_swapsi 0
659 #ifndef HAVE_atomic_compare_and_swapsi
660 #define HAVE_atomic_compare_and_swapsi 0
662 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
664 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
668 #ifndef HAVE_sync_compare_and_swapdi
669 #define HAVE_sync_compare_and_swapdi 0
671 #ifndef HAVE_atomic_compare_and_swapdi
672 #define HAVE_atomic_compare_and_swapdi 0
674 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
676 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
680 #ifndef HAVE_sync_compare_and_swapti
681 #define HAVE_sync_compare_and_swapti 0
683 #ifndef HAVE_atomic_compare_and_swapti
684 #define HAVE_atomic_compare_and_swapti 0
686 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
688 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
689 have_swap
[16] = true;
692 /* Tell the source code about various types. These map to the C++11 and C11
693 macros where 2 indicates lock-free always, and 1 indicates sometimes
695 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
696 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
697 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
698 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
699 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
700 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
701 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
702 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
703 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
704 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
705 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
706 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
707 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
708 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
709 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
710 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
711 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
712 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
713 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
714 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
716 /* If we're dealing with a "set" value that doesn't exactly correspond
717 to a boolean truth value, let the library work around that. */
718 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
719 targetm
.atomic_test_and_set_trueval
);
721 /* ptr_type_node can't be used here since ptr_mode is only set when
722 toplev calls backend_init which is not done with -E or pch. */
723 psize
= POINTER_SIZE_UNITS
;
724 if (psize
>= SWAP_LIMIT
)
726 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
727 (have_swap
[psize
]? 2 : 1));
730 /* Return the value for __GCC_IEC_559. */
732 cpp_iec_559_value (void)
734 /* The default is support for IEEE 754-2008. */
737 /* float and double must be binary32 and binary64. If they are but
738 with reversed NaN convention, at most IEEE 754-1985 is
740 const struct real_format
*ffmt
741 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
742 const struct real_format
*dfmt
743 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
744 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
749 || ffmt
->emin
!= -125
751 || ffmt
->signbit_rw
!= 31
752 || ffmt
->round_towards_zero
753 || !ffmt
->has_sign_dependent_rounding
757 || !ffmt
->has_signed_zero
761 || dfmt
->emin
!= -1021
762 || dfmt
->emax
!= 1024
763 || dfmt
->signbit_rw
!= 63
764 || dfmt
->round_towards_zero
765 || !dfmt
->has_sign_dependent_rounding
769 || !dfmt
->has_signed_zero
)
772 /* In strict C standards conformance mode, consider unpredictable
773 excess precision to mean lack of IEEE 754 support. The same
774 applies to unpredictable contraction. For C++, and outside
775 strict conformance mode, do not consider these options to mean
776 lack of IEEE 754 support. */
779 && TARGET_FLT_EVAL_METHOD
!= 0
780 && flag_excess_precision_cmdline
!= EXCESS_PRECISION_STANDARD
)
784 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
787 /* Various options are contrary to IEEE 754 semantics. */
788 if (flag_unsafe_math_optimizations
789 || flag_associative_math
790 || flag_reciprocal_math
791 || flag_finite_math_only
792 || !flag_signed_zeros
793 || flag_single_precision_constant
)
796 /* If the target does not support IEEE 754 exceptions and rounding
797 modes, consider IEEE 754 support to be absent. */
798 if (!targetm
.float_exceptions_rounding_supported_p ())
804 /* Return the value for __GCC_IEC_559_COMPLEX. */
806 cpp_iec_559_complex_value (void)
808 /* The value is no bigger than that of __GCC_IEC_559. */
809 int ret
= cpp_iec_559_value ();
811 /* Some options are contrary to the required default state of the
812 CX_LIMITED_RANGE pragma. */
813 if (flag_complex_method
!= 2)
819 /* Hook that registers front end and target-specific built-ins. */
821 c_cpp_builtins (cpp_reader
*pfile
)
825 /* -undef turns off target-specific built-ins. */
829 define_language_independent_builtin_macros (pfile
);
831 if (c_dialect_cxx ())
834 parse_basever (&major
, NULL
, NULL
);
835 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
838 /* For stddef.h. They require macros defined in c-common.c. */
839 c_stddef_cpp_builtins ();
841 /* Set include test macros for all C/C++ (not for just C++11 etc.)
842 The builtins __has_include__ and __has_include_next__ are defined
844 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
845 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
847 if (c_dialect_cxx ())
849 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
850 cpp_define (pfile
, "__GXX_WEAK__=1");
852 cpp_define (pfile
, "__GXX_WEAK__=0");
855 cpp_define (pfile
, "__DEPRECATED");
859 cpp_define (pfile
, "__GXX_RTTI");
860 cpp_define (pfile
, "__cpp_rtti=199711");
863 if (cxx_dialect
>= cxx11
)
864 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
866 /* Binary literals have been allowed in g++ before C++11
867 and were standardized for C++14. */
868 if (!pedantic
|| cxx_dialect
> cxx11
)
869 cpp_define (pfile
, "__cpp_binary_literals=201304");
871 /* Similarly for hexadecimal floating point literals and C++17. */
872 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
873 cpp_define (pfile
, "__cpp_hex_float=201603");
875 /* Arrays of runtime bound were removed from C++14, but we still
876 support GNU VLAs. Let's define this macro to a low number
877 (corresponding to the initial test release of GNU C++) if we won't
878 complain about use of VLAs. */
880 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
881 cpp_define (pfile
, "__cpp_runtime_arrays=198712");
883 if (cxx_dialect
>= cxx11
)
885 /* Set feature test macros for C++11. */
886 if (cxx_dialect
<= cxx14
)
887 cpp_define (pfile
, "__cpp_unicode_characters=200704");
888 cpp_define (pfile
, "__cpp_raw_strings=200710");
889 cpp_define (pfile
, "__cpp_unicode_literals=200710");
890 cpp_define (pfile
, "__cpp_user_defined_literals=200809");
891 cpp_define (pfile
, "__cpp_lambdas=200907");
892 if (cxx_dialect
== cxx11
)
893 cpp_define (pfile
, "__cpp_constexpr=200704");
894 if (cxx_dialect
<= cxx14
)
895 cpp_define (pfile
, "__cpp_range_based_for=200907");
896 if (cxx_dialect
<= cxx14
)
897 cpp_define (pfile
, "__cpp_static_assert=200410");
898 cpp_define (pfile
, "__cpp_decltype=200707");
899 cpp_define (pfile
, "__cpp_attributes=200809");
900 cpp_define (pfile
, "__cpp_rvalue_reference=200610");
901 cpp_define (pfile
, "__cpp_rvalue_references=200610");
902 cpp_define (pfile
, "__cpp_variadic_templates=200704");
903 cpp_define (pfile
, "__cpp_initializer_lists=200806");
904 cpp_define (pfile
, "__cpp_delegating_constructors=200604");
905 cpp_define (pfile
, "__cpp_nsdmi=200809");
906 cpp_define (pfile
, "__cpp_inheriting_constructors=200802");
907 cpp_define (pfile
, "__cpp_ref_qualifiers=200710");
908 cpp_define (pfile
, "__cpp_alias_templates=200704");
910 if (cxx_dialect
> cxx11
)
912 /* Set feature test macros for C++14. */
913 cpp_define (pfile
, "__cpp_return_type_deduction=201304");
914 cpp_define (pfile
, "__cpp_init_captures=201304");
915 cpp_define (pfile
, "__cpp_generic_lambdas=201304");
916 if (cxx_dialect
<= cxx14
)
917 cpp_define (pfile
, "__cpp_constexpr=201304");
918 cpp_define (pfile
, "__cpp_decltype_auto=201304");
919 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304");
920 cpp_define (pfile
, "__cpp_variable_templates=201304");
921 cpp_define (pfile
, "__cpp_digit_separators=201309");
923 if (cxx_dialect
> cxx14
)
925 /* Set feature test macros for C++1z. */
926 cpp_define (pfile
, "__cpp_unicode_characters=201411");
927 cpp_define (pfile
, "__cpp_static_assert=201411");
928 cpp_define (pfile
, "__cpp_namespace_attributes=201411");
929 cpp_define (pfile
, "__cpp_enumerator_attributes=201411");
930 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411");
931 cpp_define (pfile
, "__cpp_fold_expressions=201603");
932 cpp_define (pfile
, "__cpp_nontype_template_args=201411");
933 cpp_define (pfile
, "__cpp_range_based_for=201603");
934 cpp_define (pfile
, "__cpp_constexpr=201603");
935 cpp_define (pfile
, "__cpp_if_constexpr=201606");
938 /* Use a value smaller than the 201507 specified in
939 the TS, since we don't yet support extended auto. */
940 cpp_define (pfile
, "__cpp_concepts=201500");
942 /* Use a value smaller than the 201505 specified in
943 the TS, since we don't yet support atomic_cancel. */
944 cpp_define (pfile
, "__cpp_transactional_memory=210500");
945 if (flag_sized_deallocation
)
946 cpp_define (pfile
, "__cpp_sized_deallocation=201309");
948 /* Note that we define this for C as well, so that we know if
949 __attribute__((cleanup)) will interface with EH. */
952 cpp_define (pfile
, "__EXCEPTIONS");
953 if (c_dialect_cxx ())
954 cpp_define (pfile
, "__cpp_exceptions=199711");
957 /* Represents the C++ ABI version, always defined so it can be used while
958 preprocessing C and assembler. */
959 if (flag_abi_version
== 0)
960 /* We should have set this to something real in c_common_post_options. */
962 else if (flag_abi_version
== 1)
963 /* Due to a historical accident, this version had the value
965 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
967 /* Newer versions have values 1002, 1003, .... */
968 builtin_define_with_int_value ("__GXX_ABI_VERSION",
969 1000 + flag_abi_version
);
971 /* libgcc needs to know this. */
972 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
973 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
975 /* limits.h and stdint.h need to know these. */
976 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
977 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
978 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
979 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
980 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
981 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
982 underlying_wchar_type_node
);
983 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
984 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
985 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
987 /* These are needed for TS 18661-1. */
988 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node
,
989 unsigned_char_type_node
);
990 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node
,
991 short_unsigned_type_node
);
992 builtin_define_type_width ("__INT_WIDTH__", integer_type_node
,
994 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node
,
995 long_unsigned_type_node
);
996 builtin_define_type_width ("__LONG_LONG_WIDTH__",
997 long_long_integer_type_node
,
998 long_long_unsigned_type_node
);
999 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node
,
1001 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node
, NULL_TREE
);
1002 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node
, NULL_TREE
);
1003 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node
, NULL_TREE
);
1005 if (c_dialect_cxx ())
1006 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1007 if (int_n_enabled_p
[i
])
1011 /* These are used to configure the C++ library. */
1013 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
1015 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
1016 cpp_define (parse_in
, buf
);
1018 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
1019 cpp_define (parse_in
, buf
);
1023 /* stdint.h and the testsuite need to know these. */
1024 builtin_define_stdint_macros ();
1026 /* Provide information for library headers to determine whether to
1027 define macros such as __STDC_IEC_559__ and
1028 __STDC_IEC_559_COMPLEX__. */
1029 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1030 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1031 cpp_iec_559_complex_value ());
1033 /* float.h needs to know this. */
1034 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1035 TARGET_FLT_EVAL_METHOD
);
1037 /* And decfloat.h needs this. */
1038 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1039 TARGET_DEC_EVAL_METHOD
);
1041 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
1042 /* Cast the double precision constants. This is needed when single
1043 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1044 is used. The correct result is computed by the compiler when using
1045 macros that include a cast. We use a different cast for C++ to avoid
1046 problems with -Wold-style-cast. */
1047 builtin_define_float_constants ("DBL", "L",
1051 "", double_type_node
);
1052 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1053 long_double_type_node
);
1055 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1057 if (FLOATN_NX_TYPE_NODE (i
) == NULL_TREE
)
1059 char prefix
[20], csuffix
[20];
1060 sprintf (prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1061 floatn_nx_types
[i
].extended
? "X" : "");
1062 sprintf (csuffix
, "F%d%s", floatn_nx_types
[i
].n
,
1063 floatn_nx_types
[i
].extended
? "x" : "");
1064 builtin_define_float_constants (prefix
, csuffix
, "%s", NULL
,
1065 FLOATN_NX_TYPE_NODE (i
));
1068 /* For decfloat.h. */
1069 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
1070 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
1071 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
1073 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1074 if (targetm
.fixed_point_supported_p ())
1076 builtin_define_fixed_point_constants ("SFRACT", "HR",
1077 short_fract_type_node
);
1078 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1079 unsigned_short_fract_type_node
);
1080 builtin_define_fixed_point_constants ("FRACT", "R",
1082 builtin_define_fixed_point_constants ("UFRACT", "UR",
1083 unsigned_fract_type_node
);
1084 builtin_define_fixed_point_constants ("LFRACT", "LR",
1085 long_fract_type_node
);
1086 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1087 unsigned_long_fract_type_node
);
1088 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1089 long_long_fract_type_node
);
1090 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1091 unsigned_long_long_fract_type_node
);
1092 builtin_define_fixed_point_constants ("SACCUM", "HK",
1093 short_accum_type_node
);
1094 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1095 unsigned_short_accum_type_node
);
1096 builtin_define_fixed_point_constants ("ACCUM", "K",
1098 builtin_define_fixed_point_constants ("UACCUM", "UK",
1099 unsigned_accum_type_node
);
1100 builtin_define_fixed_point_constants ("LACCUM", "LK",
1101 long_accum_type_node
);
1102 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1103 unsigned_long_accum_type_node
);
1104 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1105 long_long_accum_type_node
);
1106 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1107 unsigned_long_long_accum_type_node
);
1109 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1110 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1111 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1112 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1113 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1114 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1115 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1116 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1117 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1118 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1119 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1120 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1121 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1122 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1123 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1124 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1125 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1126 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1129 /* For libgcc-internal use only. */
1130 if (flag_building_libgcc
)
1132 /* Properties of floating-point modes for libgcc2.c. */
1133 for (machine_mode mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1135 mode
= GET_MODE_WIDER_MODE (mode
))
1137 const char *name
= GET_MODE_NAME (mode
);
1139 = (char *) alloca (strlen (name
)
1140 + sizeof ("__LIBGCC__MANT_DIG__"));
1141 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1142 builtin_define_with_int_value (macro_name
,
1143 REAL_MODE_FORMAT (mode
)->p
);
1144 if (!targetm
.scalar_mode_supported_p (mode
)
1145 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1147 macro_name
= (char *) alloca (strlen (name
)
1148 + sizeof ("__LIBGCC_HAS__MODE__"));
1149 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1150 cpp_define (pfile
, macro_name
);
1151 macro_name
= (char *) alloca (strlen (name
)
1152 + sizeof ("__LIBGCC__FUNC_EXT__"));
1153 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1154 char suffix
[20] = "";
1155 if (mode
== TYPE_MODE (double_type_node
))
1156 ; /* Empty suffix correct. */
1157 else if (mode
== TYPE_MODE (float_type_node
))
1159 else if (mode
== TYPE_MODE (long_double_type_node
))
1163 bool found_suffix
= false;
1164 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1165 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
1166 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
1168 sprintf (suffix
, "f%d%s", floatn_nx_types
[i
].n
,
1169 floatn_nx_types
[i
].extended
? "x" : "");
1170 found_suffix
= true;
1173 gcc_assert (found_suffix
);
1175 builtin_define_with_value (macro_name
, suffix
, 0);
1176 bool excess_precision
= false;
1177 if (TARGET_FLT_EVAL_METHOD
!= 0
1178 && mode
!= TYPE_MODE (long_double_type_node
)
1179 && (mode
== TYPE_MODE (float_type_node
)
1180 || mode
== TYPE_MODE (double_type_node
)))
1181 switch (TARGET_FLT_EVAL_METHOD
)
1185 excess_precision
= true;
1189 excess_precision
= mode
== TYPE_MODE (float_type_node
);
1195 macro_name
= (char *) alloca (strlen (name
)
1196 + sizeof ("__LIBGCC__EXCESS_"
1198 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1199 builtin_define_with_int_value (macro_name
, excess_precision
);
1202 /* For libgcc crtstuff.c and libgcc2.c. */
1203 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1204 EH_TABLES_CAN_BE_READ_ONLY
);
1205 #ifdef EH_FRAME_SECTION_NAME
1206 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1207 EH_FRAME_SECTION_NAME
, 1);
1209 #ifdef JCR_SECTION_NAME
1210 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
1211 JCR_SECTION_NAME
, 1);
1213 #ifdef CTORS_SECTION_ASM_OP
1214 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1215 CTORS_SECTION_ASM_OP
, 1);
1217 #ifdef DTORS_SECTION_ASM_OP
1218 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1219 DTORS_SECTION_ASM_OP
, 1);
1221 #ifdef TEXT_SECTION_ASM_OP
1222 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1223 TEXT_SECTION_ASM_OP
, 1);
1225 #ifdef INIT_SECTION_ASM_OP
1226 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1227 INIT_SECTION_ASM_OP
, 1);
1229 #ifdef INIT_ARRAY_SECTION_ASM_OP
1230 /* Despite the name of this target macro, the expansion is not
1231 actually used, and may be empty rather than a string
1233 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1236 /* For libgcc enable-execute-stack.c. */
1237 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1240 /* For libgcc generic-morestack.c and unwinder code. */
1241 if (STACK_GROWS_DOWNWARD
)
1242 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1244 /* For libgcc unwinder code. */
1245 #ifdef DONT_USE_BUILTIN_SETJMP
1246 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1248 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1249 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1250 DWARF_ALT_FRAME_RETURN_COLUMN
);
1252 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1253 DWARF_FRAME_REGISTERS
);
1254 #ifdef EH_RETURN_STACKADJ_RTX
1255 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1258 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1261 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1262 STACK_POINTER_REGNUM
);
1265 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1266 TARGET_VTABLE_USES_DESCRIPTORS
);
1269 /* For use in assembly language. */
1270 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1271 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1274 if (flag_gnu89_inline
)
1275 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1277 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1280 cpp_define (pfile
, "__NO_INLINE__");
1283 cpp_define (pfile
, "__STRICT_ANSI__");
1285 if (!flag_signed_char
)
1286 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1288 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1289 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1291 cpp_atomic_builtins (pfile
);
1293 #ifdef DWARF2_UNWIND_INFO
1294 if (dwarf2out_do_cfi_asm ())
1295 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1298 /* Make the choice of ObjC runtime visible to source code. */
1299 if (c_dialect_objc () && flag_next_runtime
)
1300 cpp_define (pfile
, "__NEXT_RUNTIME__");
1302 /* Show the availability of some target pragmas. */
1303 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1305 /* Make the choice of the stack protector runtime visible to source code.
1306 The macro names and values here were chosen for compatibility with an
1307 earlier implementation, i.e. ProPolice. */
1308 if (flag_stack_protect
== 4)
1309 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1310 if (flag_stack_protect
== 3)
1311 cpp_define (pfile
, "__SSP_STRONG__=3");
1312 if (flag_stack_protect
== 2)
1313 cpp_define (pfile
, "__SSP_ALL__=2");
1314 else if (flag_stack_protect
== 1)
1315 cpp_define (pfile
, "__SSP__=1");
1318 cpp_define (pfile
, "_OPENACC=201306");
1321 cpp_define (pfile
, "_OPENMP=201511");
1323 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1324 if (int_n_enabled_p
[i
])
1327 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1328 builtin_define_type_sizeof (buf
,
1329 int_n_trees
[i
].signed_type
);
1331 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1332 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1333 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1334 unsigned_ptrdiff_type_node
);
1336 /* A straightforward target hook doesn't work, because of problems
1337 linking that hook's body when part of non-C front ends. */
1338 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1339 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1340 # define builtin_define(TXT) cpp_define (pfile, TXT)
1341 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1342 TARGET_CPU_CPP_BUILTINS ();
1343 TARGET_OS_CPP_BUILTINS ();
1344 TARGET_OBJFMT_CPP_BUILTINS ();
1346 /* Support the __declspec keyword by turning them into attributes.
1347 Note that the current way we do this may result in a collision
1348 with predefined attributes later on. This can be solved by using
1349 one attribute, say __declspec__, and passing args to it. The
1350 problem with that approach is that args are not accumulated: each
1351 new appearance would clobber any existing args. */
1352 if (TARGET_DECLSPEC
)
1353 builtin_define ("__declspec(x)=__attribute__((x))");
1355 /* If decimal floating point is supported, tell the user if the
1356 alternate format (BID) is used instead of the standard (DPD)
1358 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1359 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1362 /* Pass an object-like macro. If it doesn't lie in the user's
1363 namespace, defines it unconditionally. Otherwise define a version
1364 with two leading underscores, and another version with two leading
1365 and trailing underscores, and define the original only if an ISO
1366 standard was not nominated.
1368 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1369 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1372 builtin_define_std (const char *macro
)
1374 size_t len
= strlen (macro
);
1375 char *buff
= (char *) alloca (len
+ 5);
1379 /* prepend __ (or maybe just _) if in user's namespace. */
1380 memcpy (p
, macro
, len
+ 1);
1381 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1388 cpp_define (parse_in
, p
);
1390 /* If it was in user's namespace... */
1393 /* Define the macro with leading and following __. */
1399 cpp_define (parse_in
, p
);
1401 /* Finally, define the original macro if permitted. */
1403 cpp_define (parse_in
, macro
);
1407 /* Pass an object-like macro and a value to define it to. The third
1408 parameter says whether or not to turn the value into a string
1411 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1414 size_t mlen
= strlen (macro
);
1415 size_t elen
= strlen (expansion
);
1416 size_t extra
= 2; /* space for an = and a NUL */
1420 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1423 extra
+= 2; /* space for two quote marks */
1424 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1449 if (ISPRINT ((unsigned char) *p
))
1453 sprintf (q
, "\\%03o", (unsigned char) *p
);
1459 expansion
= quoted_expansion
;
1460 elen
= q
- expansion
;
1463 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1465 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1467 sprintf (buf
, "%s=%s", macro
, expansion
);
1469 cpp_define (parse_in
, buf
);
1473 /* Pass an object-like macro and an integer value to define it to. */
1475 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1478 size_t mlen
= strlen (macro
);
1480 size_t extra
= 2; /* space for = and NUL. */
1482 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1483 memcpy (buf
, macro
, mlen
);
1485 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1487 cpp_define (parse_in
, buf
);
1490 /* builtin_define_with_hex_fp_value is very expensive, so the following
1491 array and function allows it to be done lazily when __DBL_MAX__
1492 etc. is first used. */
1494 struct GTY(()) lazy_hex_fp_value_struct
1496 const char *hex_str
;
1500 const char *fp_suffix
;
1502 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1503 static GTY(()) int lazy_hex_fp_value_count
;
1506 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1509 REAL_VALUE_TYPE real
;
1510 char dec_str
[64], buf1
[256];
1512 if (node
->value
.builtin
< BT_FIRST_USER
1513 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1516 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1517 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1518 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1519 lazy_hex_fp_values
[idx
].digits
, 0,
1520 lazy_hex_fp_values
[idx
].mode
);
1522 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1523 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1524 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1525 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1526 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1528 gcc_assert (idx
< node
->value
.macro
->count
);
1529 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1530 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1531 = (const unsigned char *) ggc_strdup (buf1
);
1535 /* Pass an object-like macro a hexadecimal floating-point value. */
1537 builtin_define_with_hex_fp_value (const char *macro
,
1538 tree type
, int digits
,
1539 const char *hex_str
,
1540 const char *fp_suffix
,
1541 const char *fp_cast
)
1543 REAL_VALUE_TYPE real
;
1544 char dec_str
[64], buf1
[256], buf2
[256];
1546 /* This is very expensive, so if possible expand them lazily. */
1547 if (lazy_hex_fp_value_count
< 12
1548 && flag_dump_macros
== 0
1549 && !cpp_get_options (parse_in
)->traditional
)
1551 struct cpp_hashnode
*node
;
1552 if (lazy_hex_fp_value_count
== 0)
1553 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1554 sprintf (buf2
, fp_cast
, "1.1");
1555 sprintf (buf1
, "%s=%s", macro
, buf2
);
1556 cpp_define (parse_in
, buf1
);
1557 node
= C_CPP_HASHNODE (get_identifier (macro
));
1558 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1559 = ggc_strdup (hex_str
);
1560 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1561 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1562 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1563 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1564 node
->flags
|= NODE_BUILTIN
;
1566 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1567 lazy_hex_fp_value_count
++;
1571 /* Hex values are really cool and convenient, except that they're
1572 not supported in strict ISO C90 mode. First, the "p-" sequence
1573 is not valid as part of a preprocessor number. Second, we get a
1574 pedwarn from the preprocessor, which has no context, so we can't
1575 suppress the warning with __extension__.
1577 So instead what we do is construct the number in hex (because
1578 it's easy to get the exact correct value), parse it as a real,
1579 then print it back out as decimal. */
1581 real_from_string (&real
, hex_str
);
1582 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1585 /* Assemble the macro in the following fashion
1586 macro = fp_cast [dec_str fp_suffix] */
1587 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1588 sprintf (buf2
, fp_cast
, buf1
);
1589 sprintf (buf1
, "%s=%s", macro
, buf2
);
1591 cpp_define (parse_in
, buf1
);
1594 /* Return a string constant for the suffix for a value of type TYPE
1595 promoted according to the integer promotions. The type must be one
1596 of the standard integer type nodes. */
1599 type_suffix (tree type
)
1601 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1602 int unsigned_suffix
;
1604 int tp
= TYPE_PRECISION (type
);
1606 if (type
== long_long_integer_type_node
1607 || type
== long_long_unsigned_type_node
1608 || tp
> TYPE_PRECISION (long_integer_type_node
))
1610 else if (type
== long_integer_type_node
1611 || type
== long_unsigned_type_node
1612 || tp
> TYPE_PRECISION (integer_type_node
))
1614 else if (type
== integer_type_node
1615 || type
== unsigned_type_node
1616 || type
== short_integer_type_node
1617 || type
== short_unsigned_type_node
1618 || type
== signed_char_type_node
1619 || type
== unsigned_char_type_node
1620 /* ??? "char" is not a signed or unsigned integer type and
1621 so is not permitted for the standard typedefs, but some
1622 systems use it anyway. */
1623 || type
== char_type_node
)
1628 unsigned_suffix
= TYPE_UNSIGNED (type
);
1629 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1630 unsigned_suffix
= 0;
1631 return suffixes
[is_long
* 2 + unsigned_suffix
];
1634 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1636 builtin_define_constants (const char *macro
, tree type
)
1641 suffix
= type_suffix (type
);
1645 buf
= (char *) alloca (strlen (macro
) + 6);
1646 sprintf (buf
, "%s(c)=c", macro
);
1650 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1651 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1654 cpp_define (parse_in
, buf
);
1657 /* Define MAX for TYPE based on the precision of the type. */
1660 builtin_define_type_max (const char *macro
, tree type
)
1662 builtin_define_type_minmax (NULL
, macro
, type
);
1665 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1666 representation of that value. For example, a COUNT of 10 would
1670 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1672 gcc_assert (bufsz
> 3);
1677 gcc_assert (count
> 0);
1679 switch (count
% 4) {
1700 gcc_assert (bufsz
> 1);
1705 gcc_assert (bufsz
> 0);
1709 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1710 precision of the type. */
1713 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1716 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1717 char value
[PBOH_SZ
];
1723 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1725 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1727 suffix
= type_suffix (type
);
1729 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1730 + strlen (suffix
) + 1);
1731 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1733 cpp_define (parse_in
, buf
);
1737 if (TYPE_UNSIGNED (type
))
1739 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1740 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1744 buf
= (char *) alloca (strlen (min_macro
) + 3
1745 + strlen (max_macro
) + 6);
1746 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1748 cpp_define (parse_in
, buf
);
1752 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1753 both types must have the same width. */
1756 builtin_define_type_width (const char *width_macro
, tree type
, tree type2
)
1758 if (type2
!= NULL_TREE
)
1759 gcc_assert (TYPE_PRECISION (type
) == TYPE_PRECISION (type2
));
1760 builtin_define_with_int_value (width_macro
, TYPE_PRECISION (type
));
1763 #include "gt-c-family-c-cppbuiltin.h"