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_float_constants (const char *,
63 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
64 Originally this function used the fma optab, but that doesn't work with
65 -save-temps, so just rely on the HAVE_fma macros for the standard floating
69 mode_has_fma (machine_mode mode
)
100 /* Define NAME with value TYPE size_unit. */
102 builtin_define_type_sizeof (const char *name
, tree type
)
104 builtin_define_with_int_value (name
,
105 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
108 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
111 builtin_define_float_constants (const char *name_prefix
,
112 const char *fp_suffix
,
114 const char *fma_suffix
,
117 /* Used to convert radix-based values to base 10 values in several cases.
119 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
120 least 6 significant digits for correct results. Using the fraction
121 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
122 intermediate; perhaps someone can find a better approximation, in the
123 mean time, I suspect using doubles won't harm the bootstrap here. */
125 const double log10_2
= .30102999566398119521;
127 const struct real_format
*fmt
;
128 const struct real_format
*ldfmt
;
130 char name
[64], buf
[128];
131 int dig
, min_10_exp
, max_10_exp
;
133 int type_decimal_dig
;
135 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
136 gcc_assert (fmt
->b
!= 10);
137 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
138 gcc_assert (ldfmt
->b
!= 10);
140 /* The radix of the exponent representation. */
141 if (type
== float_type_node
)
142 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
145 /* The number of radix digits, p, in the floating-point significand. */
146 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
147 builtin_define_with_int_value (name
, fmt
->p
);
149 /* The number of decimal digits, q, such that any floating-point number
150 with q decimal digits can be rounded into a floating-point number with
151 p radix b digits and back again without change to the q decimal digits,
153 p log10 b if b is a power of 10
154 floor((p - 1) log10 b) otherwise
156 dig
= (fmt
->p
- 1) * log10_b
;
157 sprintf (name
, "__%s_DIG__", name_prefix
);
158 builtin_define_with_int_value (name
, dig
);
160 /* The minimum negative int x such that b**(x-1) is a normalized float. */
161 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
162 sprintf (buf
, "(%d)", fmt
->emin
);
163 builtin_define_with_value (name
, buf
, 0);
165 /* The minimum negative int x such that 10**x is a normalized float,
167 ceil (log10 (b ** (emin - 1)))
168 = ceil (log10 (b) * (emin - 1))
170 Recall that emin is negative, so the integer truncation calculates
171 the ceiling, not the floor, in this case. */
172 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
173 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
174 sprintf (buf
, "(%d)", min_10_exp
);
175 builtin_define_with_value (name
, buf
, 0);
177 /* The maximum int x such that b**(x-1) is a representable float. */
178 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
179 builtin_define_with_int_value (name
, fmt
->emax
);
181 /* The maximum int x such that 10**x is in the range of representable
182 finite floating-point numbers,
184 floor (log10((1 - b**-p) * b**emax))
185 = floor (log10(1 - b**-p) + log10(b**emax))
186 = floor (log10(1 - b**-p) + log10(b)*emax)
188 The safest thing to do here is to just compute this number. But since
189 we don't link cc1 with libm, we cannot. We could implement log10 here
190 a series expansion, but that seems too much effort because:
192 Note that the first term, for all extant p, is a number exceedingly close
193 to zero, but slightly negative. Note that the second term is an integer
194 scaling an irrational number, and that because of the floor we are only
195 interested in its integral portion.
197 In order for the first term to have any effect on the integral portion
198 of the second term, the second term has to be exceedingly close to an
199 integer itself (e.g. 123.000000000001 or something). Getting a result
200 that close to an integer requires that the irrational multiplicand have
201 a long series of zeros in its expansion, which doesn't occur in the
202 first 20 digits or so of log10(b).
204 Hand-waving aside, crunching all of the sets of constants above by hand
205 does not yield a case for which the first term is significant, which
206 in the end is all that matters. */
207 max_10_exp
= fmt
->emax
* log10_b
;
208 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
209 builtin_define_with_int_value (name
, max_10_exp
);
211 /* The number of decimal digits, n, such that any floating-point number
212 can be rounded to n decimal digits and back again without change to
215 p * log10(b) if b is a power of 10
216 ceil(1 + p * log10(b)) otherwise
218 The only macro we care about is this number for the widest supported
219 floating type, but we want this value for rendering constants below. */
222 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
223 decimal_dig
= d_decimal_dig
;
224 if (decimal_dig
< d_decimal_dig
)
227 /* Similar, for this type rather than long double. */
229 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
230 type_decimal_dig
= type_d_decimal_dig
;
231 if (type_decimal_dig
< type_d_decimal_dig
)
234 if (type
== long_double_type_node
)
235 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
238 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
239 builtin_define_with_int_value (name
, type_decimal_dig
);
242 /* Since, for the supported formats, B is always a power of 2, we
243 construct the following numbers directly as a hexadecimal
245 get_max_float (fmt
, buf
, sizeof (buf
));
247 sprintf (name
, "__%s_MAX__", name_prefix
);
248 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
250 /* The minimum normalized positive floating-point number,
252 sprintf (name
, "__%s_MIN__", name_prefix
);
253 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
254 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
256 /* The difference between 1 and the least value greater than 1 that is
257 representable in the given floating point type, b**(1-p). */
258 sprintf (name
, "__%s_EPSILON__", name_prefix
);
259 if (fmt
->pnan
< fmt
->p
)
260 /* This is an IBM extended double format, so 1.0 + any double is
261 representable precisely. */
262 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
264 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
265 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
267 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
268 The minimum denormalized positive floating-point number, b**(emin-p).
269 The minimum normalized positive floating-point number for formats
270 that don't support denormals. */
271 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
272 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
273 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
274 buf
, fp_suffix
, fp_cast
);
276 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
277 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
279 /* For C++ std::numeric_limits<T>::has_infinity. */
280 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
281 builtin_define_with_int_value (name
,
282 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
283 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
284 predicate to distinguish a target that has both quiet and
285 signalling NaNs from a target that has only quiet NaNs or only
286 signalling NaNs, so we assume that a target that has any kind of
287 NaN has quiet NaNs. */
288 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
289 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
291 /* Note whether we have fast FMA. */
292 if (mode_has_fma (TYPE_MODE (type
)))
294 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
295 builtin_define_with_int_value (name
, 1);
299 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
301 builtin_define_decimal_float_constants (const char *name_prefix
,
305 const struct real_format
*fmt
;
306 char name
[64], buf
[128], *p
;
309 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
311 /* The number of radix digits, p, in the significand. */
312 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
313 builtin_define_with_int_value (name
, fmt
->p
);
315 /* The minimum negative int x such that b**(x-1) is a normalized float. */
316 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
317 sprintf (buf
, "(%d)", fmt
->emin
);
318 builtin_define_with_value (name
, buf
, 0);
320 /* The maximum int x such that b**(x-1) is a representable float. */
321 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
322 builtin_define_with_int_value (name
, fmt
->emax
);
324 /* Compute the minimum representable value. */
325 sprintf (name
, "__%s_MIN__", name_prefix
);
326 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
327 builtin_define_with_value (name
, buf
, 0);
329 /* Compute the maximum representable value. */
330 sprintf (name
, "__%s_MAX__", name_prefix
);
332 for (digits
= fmt
->p
; digits
; digits
--)
335 if (digits
== fmt
->p
)
339 /* fmt->p plus 1, to account for the decimal point and fmt->emax
340 minus 1 because the digits are nines, not 1.0. */
341 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
342 builtin_define_with_value (name
, buf
, 0);
344 /* Compute epsilon (the difference between 1 and least value greater
345 than 1 representable). */
346 sprintf (name
, "__%s_EPSILON__", name_prefix
);
347 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
348 builtin_define_with_value (name
, buf
, 0);
350 /* Minimum subnormal positive decimal value. */
351 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
353 for (digits
= fmt
->p
; digits
> 1; digits
--)
356 if (digits
== fmt
->p
)
360 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
361 builtin_define_with_value (name
, buf
, 0);
364 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
367 builtin_define_fixed_point_constants (const char *name_prefix
,
371 char name
[64], buf
[256], *new_buf
;
374 sprintf (name
, "__%s_FBIT__", name_prefix
);
375 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
377 sprintf (name
, "__%s_IBIT__", name_prefix
);
378 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
380 /* If there is no suffix, defines are for fixed-point modes.
382 if (strcmp (suffix
, "") == 0)
385 if (TYPE_UNSIGNED (type
))
387 sprintf (name
, "__%s_MIN__", name_prefix
);
388 sprintf (buf
, "0.0%s", suffix
);
389 builtin_define_with_value (name
, buf
, 0);
393 sprintf (name
, "__%s_MIN__", name_prefix
);
394 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
395 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
396 TYPE_IBIT (type
) - 1, suffix
);
398 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
399 builtin_define_with_value (name
, buf
, 0);
402 sprintf (name
, "__%s_MAX__", name_prefix
);
405 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
407 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
408 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
409 sprintf (new_buf
++, "F");
410 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
411 builtin_define_with_value (name
, buf
, 0);
413 sprintf (name
, "__%s_EPSILON__", name_prefix
);
414 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
415 builtin_define_with_value (name
, buf
, 0);
418 /* Define macros used by <stdint.h>. */
420 builtin_define_stdint_macros (void)
422 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
423 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
424 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
425 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
426 if (sig_atomic_type_node
)
427 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
428 sig_atomic_type_node
);
430 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
432 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
434 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
436 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
438 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
439 if (c_uint16_type_node
)
440 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
441 if (c_uint32_type_node
)
442 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
443 if (c_uint64_type_node
)
444 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
445 if (int_least8_type_node
)
447 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
448 builtin_define_constants ("__INT8_C", int_least8_type_node
);
450 if (int_least16_type_node
)
452 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
453 builtin_define_constants ("__INT16_C", int_least16_type_node
);
455 if (int_least32_type_node
)
457 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
458 builtin_define_constants ("__INT32_C", int_least32_type_node
);
460 if (int_least64_type_node
)
462 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
463 builtin_define_constants ("__INT64_C", int_least64_type_node
);
465 if (uint_least8_type_node
)
467 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
468 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
470 if (uint_least16_type_node
)
472 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
473 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
475 if (uint_least32_type_node
)
477 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
478 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
480 if (uint_least64_type_node
)
482 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
483 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
485 if (int_fast8_type_node
)
486 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
487 if (int_fast16_type_node
)
488 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
489 if (int_fast32_type_node
)
490 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
491 if (int_fast64_type_node
)
492 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
493 if (uint_fast8_type_node
)
494 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
495 if (uint_fast16_type_node
)
496 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
497 if (uint_fast32_type_node
)
498 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
499 if (uint_fast64_type_node
)
500 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
501 if (intptr_type_node
)
502 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
503 if (uintptr_type_node
)
504 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
507 /* Adjust the optimization macros when a #pragma GCC optimization is done to
508 reflect the current level. */
510 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
513 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
514 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
518 /* -undef turns off target-specific built-ins. */
522 /* Other target-independent built-ins determined by command-line
524 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
525 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
526 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
527 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
529 if (!prev
->x_optimize
&& cur
->x_optimize
)
530 cpp_define (pfile
, "__OPTIMIZE__");
531 else if (prev
->x_optimize
&& !cur
->x_optimize
)
532 cpp_undef (pfile
, "__OPTIMIZE__");
534 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
535 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
536 if (!prev_fast_math
&& cur_fast_math
)
537 cpp_define (pfile
, "__FAST_MATH__");
538 else if (prev_fast_math
&& !cur_fast_math
)
539 cpp_undef (pfile
, "__FAST_MATH__");
541 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
542 cpp_define (pfile
, "__SUPPORT_SNAN__");
543 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
544 cpp_undef (pfile
, "__SUPPORT_SNAN__");
546 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
547 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
548 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
549 cpp_define (pfile
, "__NO_MATH_ERRNO__");
551 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
553 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
554 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
556 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
558 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
559 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
564 /* This function will emit cpp macros to indicate the presence of various lock
565 free atomic operations. */
568 cpp_atomic_builtins (cpp_reader
*pfile
)
570 /* Set a flag for each size of object that compare and swap exists for up to
572 #define SWAP_LIMIT 17
573 bool have_swap
[SWAP_LIMIT
];
576 /* Clear the map of sizes compare_and swap exists for. */
577 memset (have_swap
, 0, sizeof (have_swap
));
579 /* Tell source code if the compiler makes sync_compare_and_swap
580 builtins available. */
581 #ifndef HAVE_sync_compare_and_swapqi
582 #define HAVE_sync_compare_and_swapqi 0
584 #ifndef HAVE_atomic_compare_and_swapqi
585 #define HAVE_atomic_compare_and_swapqi 0
588 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
590 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
594 #ifndef HAVE_sync_compare_and_swaphi
595 #define HAVE_sync_compare_and_swaphi 0
597 #ifndef HAVE_atomic_compare_and_swaphi
598 #define HAVE_atomic_compare_and_swaphi 0
600 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
602 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
606 #ifndef HAVE_sync_compare_and_swapsi
607 #define HAVE_sync_compare_and_swapsi 0
609 #ifndef HAVE_atomic_compare_and_swapsi
610 #define HAVE_atomic_compare_and_swapsi 0
612 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
614 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
618 #ifndef HAVE_sync_compare_and_swapdi
619 #define HAVE_sync_compare_and_swapdi 0
621 #ifndef HAVE_atomic_compare_and_swapdi
622 #define HAVE_atomic_compare_and_swapdi 0
624 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
626 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
630 #ifndef HAVE_sync_compare_and_swapti
631 #define HAVE_sync_compare_and_swapti 0
633 #ifndef HAVE_atomic_compare_and_swapti
634 #define HAVE_atomic_compare_and_swapti 0
636 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
638 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
639 have_swap
[16] = true;
642 /* Tell the source code about various types. These map to the C++11 and C11
643 macros where 2 indicates lock-free always, and 1 indicates sometimes
645 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
646 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
647 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
648 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
649 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
650 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
651 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
652 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
653 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
654 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
655 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
656 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
657 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
658 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
659 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
660 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
661 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
662 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
663 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
664 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
666 /* If we're dealing with a "set" value that doesn't exactly correspond
667 to a boolean truth value, let the library work around that. */
668 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
669 targetm
.atomic_test_and_set_trueval
);
671 /* ptr_type_node can't be used here since ptr_mode is only set when
672 toplev calls backend_init which is not done with -E or pch. */
673 psize
= POINTER_SIZE_UNITS
;
674 if (psize
>= SWAP_LIMIT
)
676 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
677 (have_swap
[psize
]? 2 : 1));
680 /* Return the value for __GCC_IEC_559. */
682 cpp_iec_559_value (void)
684 /* The default is support for IEEE 754-2008. */
687 /* float and double must be binary32 and binary64. If they are but
688 with reversed NaN convention, at most IEEE 754-1985 is
690 const struct real_format
*ffmt
691 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
692 const struct real_format
*dfmt
693 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
694 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
699 || ffmt
->emin
!= -125
701 || ffmt
->signbit_rw
!= 31
702 || ffmt
->round_towards_zero
703 || !ffmt
->has_sign_dependent_rounding
707 || !ffmt
->has_signed_zero
711 || dfmt
->emin
!= -1021
712 || dfmt
->emax
!= 1024
713 || dfmt
->signbit_rw
!= 63
714 || dfmt
->round_towards_zero
715 || !dfmt
->has_sign_dependent_rounding
719 || !dfmt
->has_signed_zero
)
722 /* In strict C standards conformance mode, consider unpredictable
723 excess precision to mean lack of IEEE 754 support. The same
724 applies to unpredictable contraction. For C++, and outside
725 strict conformance mode, do not consider these options to mean
726 lack of IEEE 754 support. */
729 && TARGET_FLT_EVAL_METHOD
!= 0
730 && flag_excess_precision_cmdline
!= EXCESS_PRECISION_STANDARD
)
734 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
737 /* Various options are contrary to IEEE 754 semantics. */
738 if (flag_unsafe_math_optimizations
739 || flag_associative_math
740 || flag_reciprocal_math
741 || flag_finite_math_only
742 || !flag_signed_zeros
743 || flag_single_precision_constant
)
746 /* If the target does not support IEEE 754 exceptions and rounding
747 modes, consider IEEE 754 support to be absent. */
748 if (!targetm
.float_exceptions_rounding_supported_p ())
754 /* Return the value for __GCC_IEC_559_COMPLEX. */
756 cpp_iec_559_complex_value (void)
758 /* The value is no bigger than that of __GCC_IEC_559. */
759 int ret
= cpp_iec_559_value ();
761 /* Some options are contrary to the required default state of the
762 CX_LIMITED_RANGE pragma. */
763 if (flag_complex_method
!= 2)
769 /* Hook that registers front end and target-specific built-ins. */
771 c_cpp_builtins (cpp_reader
*pfile
)
775 /* -undef turns off target-specific built-ins. */
779 define_language_independent_builtin_macros (pfile
);
781 if (c_dialect_cxx ())
784 parse_basever (&major
, NULL
, NULL
);
785 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
788 /* For stddef.h. They require macros defined in c-common.c. */
789 c_stddef_cpp_builtins ();
791 /* Set include test macros for all C/C++ (not for just C++11 etc.)
792 The builtins __has_include__ and __has_include_next__ are defined
794 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
795 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
797 if (c_dialect_cxx ())
799 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
800 cpp_define (pfile
, "__GXX_WEAK__=1");
802 cpp_define (pfile
, "__GXX_WEAK__=0");
805 cpp_define (pfile
, "__DEPRECATED");
809 cpp_define (pfile
, "__GXX_RTTI");
810 cpp_define (pfile
, "__cpp_rtti=199711");
813 if (cxx_dialect
>= cxx11
)
814 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
816 /* Binary literals have been allowed in g++ before C++11
817 and were standardized for C++14. */
818 if (!pedantic
|| cxx_dialect
> cxx11
)
819 cpp_define (pfile
, "__cpp_binary_literals=201304");
821 /* Similarly for hexadecimal floating point literals and C++17. */
822 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
823 cpp_define (pfile
, "__cpp_hex_float=201603");
825 /* Arrays of runtime bound were removed from C++14, but we still
826 support GNU VLAs. Let's define this macro to a low number
827 (corresponding to the initial test release of GNU C++) if we won't
828 complain about use of VLAs. */
830 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
831 cpp_define (pfile
, "__cpp_runtime_arrays=198712");
833 if (cxx_dialect
>= cxx11
)
835 /* Set feature test macros for C++11. */
836 if (cxx_dialect
<= cxx14
)
837 cpp_define (pfile
, "__cpp_unicode_characters=200704");
838 cpp_define (pfile
, "__cpp_raw_strings=200710");
839 cpp_define (pfile
, "__cpp_unicode_literals=200710");
840 cpp_define (pfile
, "__cpp_user_defined_literals=200809");
841 cpp_define (pfile
, "__cpp_lambdas=200907");
842 if (cxx_dialect
== cxx11
)
843 cpp_define (pfile
, "__cpp_constexpr=200704");
844 if (cxx_dialect
<= cxx14
)
845 cpp_define (pfile
, "__cpp_range_based_for=200907");
846 if (cxx_dialect
<= cxx14
)
847 cpp_define (pfile
, "__cpp_static_assert=200410");
848 cpp_define (pfile
, "__cpp_decltype=200707");
849 cpp_define (pfile
, "__cpp_attributes=200809");
850 cpp_define (pfile
, "__cpp_rvalue_reference=200610");
851 cpp_define (pfile
, "__cpp_rvalue_references=200610");
852 cpp_define (pfile
, "__cpp_variadic_templates=200704");
853 cpp_define (pfile
, "__cpp_initializer_lists=200806");
854 cpp_define (pfile
, "__cpp_delegating_constructors=200604");
855 cpp_define (pfile
, "__cpp_nsdmi=200809");
856 cpp_define (pfile
, "__cpp_inheriting_constructors=200802");
857 cpp_define (pfile
, "__cpp_ref_qualifiers=200710");
858 cpp_define (pfile
, "__cpp_alias_templates=200704");
860 if (cxx_dialect
> cxx11
)
862 /* Set feature test macros for C++14. */
863 cpp_define (pfile
, "__cpp_return_type_deduction=201304");
864 cpp_define (pfile
, "__cpp_init_captures=201304");
865 cpp_define (pfile
, "__cpp_generic_lambdas=201304");
866 if (cxx_dialect
<= cxx14
)
867 cpp_define (pfile
, "__cpp_constexpr=201304");
868 cpp_define (pfile
, "__cpp_decltype_auto=201304");
869 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304");
870 cpp_define (pfile
, "__cpp_variable_templates=201304");
871 cpp_define (pfile
, "__cpp_digit_separators=201309");
873 if (cxx_dialect
> cxx14
)
875 /* Set feature test macros for C++1z. */
876 cpp_define (pfile
, "__cpp_unicode_characters=201411");
877 cpp_define (pfile
, "__cpp_static_assert=201411");
878 cpp_define (pfile
, "__cpp_namespace_attributes=201411");
879 cpp_define (pfile
, "__cpp_enumerator_attributes=201411");
880 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411");
881 cpp_define (pfile
, "__cpp_fold_expressions=201603");
882 cpp_define (pfile
, "__cpp_nontype_template_args=201411");
883 cpp_define (pfile
, "__cpp_range_based_for=201603");
884 cpp_define (pfile
, "__cpp_constexpr=201603");
885 cpp_define (pfile
, "__cpp_if_constexpr=201606");
888 /* Use a value smaller than the 201507 specified in
889 the TS, since we don't yet support extended auto. */
890 cpp_define (pfile
, "__cpp_concepts=201500");
892 /* Use a value smaller than the 201505 specified in
893 the TS, since we don't yet support atomic_cancel. */
894 cpp_define (pfile
, "__cpp_transactional_memory=210500");
895 if (flag_sized_deallocation
)
896 cpp_define (pfile
, "__cpp_sized_deallocation=201309");
898 /* Note that we define this for C as well, so that we know if
899 __attribute__((cleanup)) will interface with EH. */
902 cpp_define (pfile
, "__EXCEPTIONS");
903 if (c_dialect_cxx ())
904 cpp_define (pfile
, "__cpp_exceptions=199711");
907 /* Represents the C++ ABI version, always defined so it can be used while
908 preprocessing C and assembler. */
909 if (flag_abi_version
== 0)
910 /* We should have set this to something real in c_common_post_options. */
912 else if (flag_abi_version
== 1)
913 /* Due to a historical accident, this version had the value
915 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
917 /* Newer versions have values 1002, 1003, .... */
918 builtin_define_with_int_value ("__GXX_ABI_VERSION",
919 1000 + flag_abi_version
);
921 /* libgcc needs to know this. */
922 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
923 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
925 /* limits.h and stdint.h need to know these. */
926 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
927 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
928 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
929 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
930 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
931 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
932 underlying_wchar_type_node
);
933 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
934 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
935 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
937 if (c_dialect_cxx ())
938 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
939 if (int_n_enabled_p
[i
])
943 /* These are used to configure the C++ library. */
945 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
947 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
948 cpp_define (parse_in
, buf
);
950 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
951 cpp_define (parse_in
, buf
);
955 /* stdint.h and the testsuite need to know these. */
956 builtin_define_stdint_macros ();
958 /* Provide information for library headers to determine whether to
959 define macros such as __STDC_IEC_559__ and
960 __STDC_IEC_559_COMPLEX__. */
961 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
962 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
963 cpp_iec_559_complex_value ());
965 /* float.h needs to know this. */
966 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
967 TARGET_FLT_EVAL_METHOD
);
969 /* And decfloat.h needs this. */
970 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
971 TARGET_DEC_EVAL_METHOD
);
973 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
974 /* Cast the double precision constants. This is needed when single
975 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
976 is used. The correct result is computed by the compiler when using
977 macros that include a cast. We use a different cast for C++ to avoid
978 problems with -Wold-style-cast. */
979 builtin_define_float_constants ("DBL", "L",
983 "", double_type_node
);
984 builtin_define_float_constants ("LDBL", "L", "%s", "L",
985 long_double_type_node
);
987 /* For decfloat.h. */
988 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
989 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
990 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
992 /* For fixed-point fibt, ibit, max, min, and epsilon. */
993 if (targetm
.fixed_point_supported_p ())
995 builtin_define_fixed_point_constants ("SFRACT", "HR",
996 short_fract_type_node
);
997 builtin_define_fixed_point_constants ("USFRACT", "UHR",
998 unsigned_short_fract_type_node
);
999 builtin_define_fixed_point_constants ("FRACT", "R",
1001 builtin_define_fixed_point_constants ("UFRACT", "UR",
1002 unsigned_fract_type_node
);
1003 builtin_define_fixed_point_constants ("LFRACT", "LR",
1004 long_fract_type_node
);
1005 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1006 unsigned_long_fract_type_node
);
1007 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1008 long_long_fract_type_node
);
1009 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1010 unsigned_long_long_fract_type_node
);
1011 builtin_define_fixed_point_constants ("SACCUM", "HK",
1012 short_accum_type_node
);
1013 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1014 unsigned_short_accum_type_node
);
1015 builtin_define_fixed_point_constants ("ACCUM", "K",
1017 builtin_define_fixed_point_constants ("UACCUM", "UK",
1018 unsigned_accum_type_node
);
1019 builtin_define_fixed_point_constants ("LACCUM", "LK",
1020 long_accum_type_node
);
1021 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1022 unsigned_long_accum_type_node
);
1023 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1024 long_long_accum_type_node
);
1025 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1026 unsigned_long_long_accum_type_node
);
1028 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1029 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1030 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1031 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1032 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1033 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1034 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1035 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1036 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1037 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1038 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1039 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1040 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1041 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1042 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1043 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1044 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1045 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1048 /* For libgcc-internal use only. */
1049 if (flag_building_libgcc
)
1051 /* Properties of floating-point modes for libgcc2.c. */
1052 for (machine_mode mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1054 mode
= GET_MODE_WIDER_MODE (mode
))
1056 const char *name
= GET_MODE_NAME (mode
);
1058 = (char *) alloca (strlen (name
)
1059 + sizeof ("__LIBGCC__MANT_DIG__"));
1060 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1061 builtin_define_with_int_value (macro_name
,
1062 REAL_MODE_FORMAT (mode
)->p
);
1063 if (!targetm
.scalar_mode_supported_p (mode
)
1064 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1066 macro_name
= (char *) alloca (strlen (name
)
1067 + sizeof ("__LIBGCC_HAS__MODE__"));
1068 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1069 cpp_define (pfile
, macro_name
);
1070 macro_name
= (char *) alloca (strlen (name
)
1071 + sizeof ("__LIBGCC__FUNC_EXT__"));
1072 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1074 if (mode
== TYPE_MODE (double_type_node
))
1076 else if (mode
== TYPE_MODE (float_type_node
))
1078 else if (mode
== TYPE_MODE (long_double_type_node
))
1080 /* ??? The following assumes the built-in functions (defined
1081 in target-specific code) match the suffixes used for
1082 constants. Because in fact such functions are not
1083 defined for the 'w' suffix, 'l' is used there
1085 else if (mode
== targetm
.c
.mode_for_suffix ('q'))
1087 else if (mode
== targetm
.c
.mode_for_suffix ('w'))
1091 builtin_define_with_value (macro_name
, suffix
, 0);
1092 bool excess_precision
= false;
1093 if (TARGET_FLT_EVAL_METHOD
!= 0
1094 && mode
!= TYPE_MODE (long_double_type_node
)
1095 && (mode
== TYPE_MODE (float_type_node
)
1096 || mode
== TYPE_MODE (double_type_node
)))
1097 switch (TARGET_FLT_EVAL_METHOD
)
1101 excess_precision
= true;
1105 excess_precision
= mode
== TYPE_MODE (float_type_node
);
1111 macro_name
= (char *) alloca (strlen (name
)
1112 + sizeof ("__LIBGCC__EXCESS_"
1114 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1115 builtin_define_with_int_value (macro_name
, excess_precision
);
1118 /* For libgcc crtstuff.c and libgcc2.c. */
1119 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1120 EH_TABLES_CAN_BE_READ_ONLY
);
1121 #ifdef EH_FRAME_SECTION_NAME
1122 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1123 EH_FRAME_SECTION_NAME
, 1);
1125 #ifdef JCR_SECTION_NAME
1126 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
1127 JCR_SECTION_NAME
, 1);
1129 #ifdef CTORS_SECTION_ASM_OP
1130 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1131 CTORS_SECTION_ASM_OP
, 1);
1133 #ifdef DTORS_SECTION_ASM_OP
1134 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1135 DTORS_SECTION_ASM_OP
, 1);
1137 #ifdef TEXT_SECTION_ASM_OP
1138 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1139 TEXT_SECTION_ASM_OP
, 1);
1141 #ifdef INIT_SECTION_ASM_OP
1142 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1143 INIT_SECTION_ASM_OP
, 1);
1145 #ifdef INIT_ARRAY_SECTION_ASM_OP
1146 /* Despite the name of this target macro, the expansion is not
1147 actually used, and may be empty rather than a string
1149 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1152 /* For libgcc enable-execute-stack.c. */
1153 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1156 /* For libgcc generic-morestack.c and unwinder code. */
1157 if (STACK_GROWS_DOWNWARD
)
1158 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1160 /* For libgcc unwinder code. */
1161 #ifdef DONT_USE_BUILTIN_SETJMP
1162 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1164 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1165 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1166 DWARF_ALT_FRAME_RETURN_COLUMN
);
1168 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1169 DWARF_FRAME_REGISTERS
);
1170 #ifdef EH_RETURN_STACKADJ_RTX
1171 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1174 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1177 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1178 STACK_POINTER_REGNUM
);
1181 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1182 TARGET_VTABLE_USES_DESCRIPTORS
);
1185 /* For use in assembly language. */
1186 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1187 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1190 if (flag_gnu89_inline
)
1191 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1193 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1196 cpp_define (pfile
, "__NO_INLINE__");
1199 cpp_define (pfile
, "__STRICT_ANSI__");
1201 if (!flag_signed_char
)
1202 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1204 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1205 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1207 cpp_atomic_builtins (pfile
);
1209 #ifdef DWARF2_UNWIND_INFO
1210 if (dwarf2out_do_cfi_asm ())
1211 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1214 /* Make the choice of ObjC runtime visible to source code. */
1215 if (c_dialect_objc () && flag_next_runtime
)
1216 cpp_define (pfile
, "__NEXT_RUNTIME__");
1218 /* Show the availability of some target pragmas. */
1219 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1221 /* Make the choice of the stack protector runtime visible to source code.
1222 The macro names and values here were chosen for compatibility with an
1223 earlier implementation, i.e. ProPolice. */
1224 if (flag_stack_protect
== 4)
1225 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1226 if (flag_stack_protect
== 3)
1227 cpp_define (pfile
, "__SSP_STRONG__=3");
1228 if (flag_stack_protect
== 2)
1229 cpp_define (pfile
, "__SSP_ALL__=2");
1230 else if (flag_stack_protect
== 1)
1231 cpp_define (pfile
, "__SSP__=1");
1234 cpp_define (pfile
, "_OPENACC=201306");
1237 cpp_define (pfile
, "_OPENMP=201511");
1239 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1240 if (int_n_enabled_p
[i
])
1243 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1244 builtin_define_type_sizeof (buf
,
1245 int_n_trees
[i
].signed_type
);
1247 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1248 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1249 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1250 unsigned_ptrdiff_type_node
);
1252 /* A straightforward target hook doesn't work, because of problems
1253 linking that hook's body when part of non-C front ends. */
1254 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1255 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1256 # define builtin_define(TXT) cpp_define (pfile, TXT)
1257 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1258 TARGET_CPU_CPP_BUILTINS ();
1259 TARGET_OS_CPP_BUILTINS ();
1260 TARGET_OBJFMT_CPP_BUILTINS ();
1262 /* Support the __declspec keyword by turning them into attributes.
1263 Note that the current way we do this may result in a collision
1264 with predefined attributes later on. This can be solved by using
1265 one attribute, say __declspec__, and passing args to it. The
1266 problem with that approach is that args are not accumulated: each
1267 new appearance would clobber any existing args. */
1268 if (TARGET_DECLSPEC
)
1269 builtin_define ("__declspec(x)=__attribute__((x))");
1271 /* If decimal floating point is supported, tell the user if the
1272 alternate format (BID) is used instead of the standard (DPD)
1274 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1275 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1278 /* Pass an object-like macro. If it doesn't lie in the user's
1279 namespace, defines it unconditionally. Otherwise define a version
1280 with two leading underscores, and another version with two leading
1281 and trailing underscores, and define the original only if an ISO
1282 standard was not nominated.
1284 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1285 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1288 builtin_define_std (const char *macro
)
1290 size_t len
= strlen (macro
);
1291 char *buff
= (char *) alloca (len
+ 5);
1295 /* prepend __ (or maybe just _) if in user's namespace. */
1296 memcpy (p
, macro
, len
+ 1);
1297 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1304 cpp_define (parse_in
, p
);
1306 /* If it was in user's namespace... */
1309 /* Define the macro with leading and following __. */
1315 cpp_define (parse_in
, p
);
1317 /* Finally, define the original macro if permitted. */
1319 cpp_define (parse_in
, macro
);
1323 /* Pass an object-like macro and a value to define it to. The third
1324 parameter says whether or not to turn the value into a string
1327 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1330 size_t mlen
= strlen (macro
);
1331 size_t elen
= strlen (expansion
);
1332 size_t extra
= 2; /* space for an = and a NUL */
1336 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1339 extra
+= 2; /* space for two quote marks */
1340 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1365 if (ISPRINT ((unsigned char) *p
))
1369 sprintf (q
, "\\%03o", (unsigned char) *p
);
1375 expansion
= quoted_expansion
;
1376 elen
= q
- expansion
;
1379 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1381 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1383 sprintf (buf
, "%s=%s", macro
, expansion
);
1385 cpp_define (parse_in
, buf
);
1389 /* Pass an object-like macro and an integer value to define it to. */
1391 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1394 size_t mlen
= strlen (macro
);
1396 size_t extra
= 2; /* space for = and NUL. */
1398 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1399 memcpy (buf
, macro
, mlen
);
1401 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1403 cpp_define (parse_in
, buf
);
1406 /* builtin_define_with_hex_fp_value is very expensive, so the following
1407 array and function allows it to be done lazily when __DBL_MAX__
1408 etc. is first used. */
1410 struct GTY(()) lazy_hex_fp_value_struct
1412 const char *hex_str
;
1416 const char *fp_suffix
;
1418 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1419 static GTY(()) int lazy_hex_fp_value_count
;
1422 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1425 REAL_VALUE_TYPE real
;
1426 char dec_str
[64], buf1
[256];
1428 if (node
->value
.builtin
< BT_FIRST_USER
1429 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1432 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1433 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1434 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1435 lazy_hex_fp_values
[idx
].digits
, 0,
1436 lazy_hex_fp_values
[idx
].mode
);
1438 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1439 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1440 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1441 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1442 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1444 gcc_assert (idx
< node
->value
.macro
->count
);
1445 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1446 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1447 = (const unsigned char *) ggc_strdup (buf1
);
1451 /* Pass an object-like macro a hexadecimal floating-point value. */
1453 builtin_define_with_hex_fp_value (const char *macro
,
1454 tree type
, int digits
,
1455 const char *hex_str
,
1456 const char *fp_suffix
,
1457 const char *fp_cast
)
1459 REAL_VALUE_TYPE real
;
1460 char dec_str
[64], buf1
[256], buf2
[256];
1462 /* This is very expensive, so if possible expand them lazily. */
1463 if (lazy_hex_fp_value_count
< 12
1464 && flag_dump_macros
== 0
1465 && !cpp_get_options (parse_in
)->traditional
)
1467 struct cpp_hashnode
*node
;
1468 if (lazy_hex_fp_value_count
== 0)
1469 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1470 sprintf (buf2
, fp_cast
, "1.1");
1471 sprintf (buf1
, "%s=%s", macro
, buf2
);
1472 cpp_define (parse_in
, buf1
);
1473 node
= C_CPP_HASHNODE (get_identifier (macro
));
1474 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1475 = ggc_strdup (hex_str
);
1476 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1477 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1478 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1479 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1480 node
->flags
|= NODE_BUILTIN
;
1482 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1483 lazy_hex_fp_value_count
++;
1487 /* Hex values are really cool and convenient, except that they're
1488 not supported in strict ISO C90 mode. First, the "p-" sequence
1489 is not valid as part of a preprocessor number. Second, we get a
1490 pedwarn from the preprocessor, which has no context, so we can't
1491 suppress the warning with __extension__.
1493 So instead what we do is construct the number in hex (because
1494 it's easy to get the exact correct value), parse it as a real,
1495 then print it back out as decimal. */
1497 real_from_string (&real
, hex_str
);
1498 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1501 /* Assemble the macro in the following fashion
1502 macro = fp_cast [dec_str fp_suffix] */
1503 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1504 sprintf (buf2
, fp_cast
, buf1
);
1505 sprintf (buf1
, "%s=%s", macro
, buf2
);
1507 cpp_define (parse_in
, buf1
);
1510 /* Return a string constant for the suffix for a value of type TYPE
1511 promoted according to the integer promotions. The type must be one
1512 of the standard integer type nodes. */
1515 type_suffix (tree type
)
1517 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1518 int unsigned_suffix
;
1520 int tp
= TYPE_PRECISION (type
);
1522 if (type
== long_long_integer_type_node
1523 || type
== long_long_unsigned_type_node
1524 || tp
> TYPE_PRECISION (long_integer_type_node
))
1526 else if (type
== long_integer_type_node
1527 || type
== long_unsigned_type_node
1528 || tp
> TYPE_PRECISION (integer_type_node
))
1530 else if (type
== integer_type_node
1531 || type
== unsigned_type_node
1532 || type
== short_integer_type_node
1533 || type
== short_unsigned_type_node
1534 || type
== signed_char_type_node
1535 || type
== unsigned_char_type_node
1536 /* ??? "char" is not a signed or unsigned integer type and
1537 so is not permitted for the standard typedefs, but some
1538 systems use it anyway. */
1539 || type
== char_type_node
)
1544 unsigned_suffix
= TYPE_UNSIGNED (type
);
1545 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1546 unsigned_suffix
= 0;
1547 return suffixes
[is_long
* 2 + unsigned_suffix
];
1550 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1552 builtin_define_constants (const char *macro
, tree type
)
1557 suffix
= type_suffix (type
);
1561 buf
= (char *) alloca (strlen (macro
) + 6);
1562 sprintf (buf
, "%s(c)=c", macro
);
1566 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1567 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1570 cpp_define (parse_in
, buf
);
1573 /* Define MAX for TYPE based on the precision of the type. */
1576 builtin_define_type_max (const char *macro
, tree type
)
1578 builtin_define_type_minmax (NULL
, macro
, type
);
1581 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1582 representation of that value. For example, a COUNT of 10 would
1586 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1588 gcc_assert (bufsz
> 3);
1593 gcc_assert (count
> 0);
1595 switch (count
% 4) {
1616 gcc_assert (bufsz
> 1);
1621 gcc_assert (bufsz
> 0);
1625 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1626 precision of the type. */
1629 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1632 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1633 char value
[PBOH_SZ
];
1639 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1641 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1643 suffix
= type_suffix (type
);
1645 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1646 + strlen (suffix
) + 1);
1647 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1649 cpp_define (parse_in
, buf
);
1653 if (TYPE_UNSIGNED (type
))
1655 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1656 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1660 buf
= (char *) alloca (strlen (min_macro
) + 3
1661 + strlen (max_macro
) + 6);
1662 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1664 cpp_define (parse_in
, buf
);
1668 #include "gt-c-family-c-cppbuiltin.h"