1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "stor-layout.h"
27 #include "stringpool.h"
32 #include "output.h" /* For user_label_prefix. */
33 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
34 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
36 #include "common/common-target.h"
37 #include "cpp-id-data.h"
38 #include "cppbuiltin.h"
40 #ifndef TARGET_OS_CPP_BUILTINS
41 # define TARGET_OS_CPP_BUILTINS()
44 #ifndef TARGET_OBJFMT_CPP_BUILTINS
45 # define TARGET_OBJFMT_CPP_BUILTINS()
48 #ifndef REGISTER_PREFIX
49 #define REGISTER_PREFIX ""
52 /* Non-static as some targets don't use it. */
53 static void builtin_define_with_hex_fp_value (const char *, tree
,
57 static void builtin_define_stdint_macros (void);
58 static void builtin_define_constants (const char *, tree
);
59 static void builtin_define_type_max (const char *, tree
);
60 static void builtin_define_type_minmax (const char *, const char *, tree
);
61 static void builtin_define_float_constants (const char *,
67 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
68 Originally this function used the fma optab, but that doesn't work with
69 -save-temps, so just rely on the HAVE_fma macros for the standard floating
73 mode_has_fma (machine_mode mode
)
104 /* Define NAME with value TYPE size_unit. */
106 builtin_define_type_sizeof (const char *name
, tree type
)
108 builtin_define_with_int_value (name
,
109 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
112 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
115 builtin_define_float_constants (const char *name_prefix
,
116 const char *fp_suffix
,
118 const char *fma_suffix
,
121 /* Used to convert radix-based values to base 10 values in several cases.
123 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
124 least 6 significant digits for correct results. Using the fraction
125 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
126 intermediate; perhaps someone can find a better approximation, in the
127 mean time, I suspect using doubles won't harm the bootstrap here. */
129 const double log10_2
= .30102999566398119521;
131 const struct real_format
*fmt
;
132 const struct real_format
*ldfmt
;
134 char name
[64], buf
[128];
135 int dig
, min_10_exp
, max_10_exp
;
137 int type_decimal_dig
;
139 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
140 gcc_assert (fmt
->b
!= 10);
141 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
142 gcc_assert (ldfmt
->b
!= 10);
144 /* The radix of the exponent representation. */
145 if (type
== float_type_node
)
146 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
149 /* The number of radix digits, p, in the floating-point significand. */
150 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
151 builtin_define_with_int_value (name
, fmt
->p
);
153 /* The number of decimal digits, q, such that any floating-point number
154 with q decimal digits can be rounded into a floating-point number with
155 p radix b digits and back again without change to the q decimal digits,
157 p log10 b if b is a power of 10
158 floor((p - 1) log10 b) otherwise
160 dig
= (fmt
->p
- 1) * log10_b
;
161 sprintf (name
, "__%s_DIG__", name_prefix
);
162 builtin_define_with_int_value (name
, dig
);
164 /* The minimum negative int x such that b**(x-1) is a normalized float. */
165 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
166 sprintf (buf
, "(%d)", fmt
->emin
);
167 builtin_define_with_value (name
, buf
, 0);
169 /* The minimum negative int x such that 10**x is a normalized float,
171 ceil (log10 (b ** (emin - 1)))
172 = ceil (log10 (b) * (emin - 1))
174 Recall that emin is negative, so the integer truncation calculates
175 the ceiling, not the floor, in this case. */
176 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
177 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
178 sprintf (buf
, "(%d)", min_10_exp
);
179 builtin_define_with_value (name
, buf
, 0);
181 /* The maximum int x such that b**(x-1) is a representable float. */
182 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
183 builtin_define_with_int_value (name
, fmt
->emax
);
185 /* The maximum int x such that 10**x is in the range of representable
186 finite floating-point numbers,
188 floor (log10((1 - b**-p) * b**emax))
189 = floor (log10(1 - b**-p) + log10(b**emax))
190 = floor (log10(1 - b**-p) + log10(b)*emax)
192 The safest thing to do here is to just compute this number. But since
193 we don't link cc1 with libm, we cannot. We could implement log10 here
194 a series expansion, but that seems too much effort because:
196 Note that the first term, for all extant p, is a number exceedingly close
197 to zero, but slightly negative. Note that the second term is an integer
198 scaling an irrational number, and that because of the floor we are only
199 interested in its integral portion.
201 In order for the first term to have any effect on the integral portion
202 of the second term, the second term has to be exceedingly close to an
203 integer itself (e.g. 123.000000000001 or something). Getting a result
204 that close to an integer requires that the irrational multiplicand have
205 a long series of zeros in its expansion, which doesn't occur in the
206 first 20 digits or so of log10(b).
208 Hand-waving aside, crunching all of the sets of constants above by hand
209 does not yield a case for which the first term is significant, which
210 in the end is all that matters. */
211 max_10_exp
= fmt
->emax
* log10_b
;
212 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
213 builtin_define_with_int_value (name
, max_10_exp
);
215 /* The number of decimal digits, n, such that any floating-point number
216 can be rounded to n decimal digits and back again without change to
219 p * log10(b) if b is a power of 10
220 ceil(1 + p * log10(b)) otherwise
222 The only macro we care about is this number for the widest supported
223 floating type, but we want this value for rendering constants below. */
226 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
227 decimal_dig
= d_decimal_dig
;
228 if (decimal_dig
< d_decimal_dig
)
231 /* Similar, for this type rather than long double. */
233 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
234 type_decimal_dig
= type_d_decimal_dig
;
235 if (type_decimal_dig
< type_d_decimal_dig
)
238 if (type
== long_double_type_node
)
239 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
242 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
243 builtin_define_with_int_value (name
, type_decimal_dig
);
246 /* Since, for the supported formats, B is always a power of 2, we
247 construct the following numbers directly as a hexadecimal
249 get_max_float (fmt
, buf
, sizeof (buf
));
251 sprintf (name
, "__%s_MAX__", name_prefix
);
252 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
254 /* The minimum normalized positive floating-point number,
256 sprintf (name
, "__%s_MIN__", name_prefix
);
257 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
258 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
260 /* The difference between 1 and the least value greater than 1 that is
261 representable in the given floating point type, b**(1-p). */
262 sprintf (name
, "__%s_EPSILON__", name_prefix
);
263 if (fmt
->pnan
< fmt
->p
)
264 /* This is an IBM extended double format, so 1.0 + any double is
265 representable precisely. */
266 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
268 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
269 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
271 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
272 The minimum denormalized positive floating-point number, b**(emin-p).
273 The minimum normalized positive floating-point number for formats
274 that don't support denormals. */
275 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
276 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
277 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
278 buf
, fp_suffix
, fp_cast
);
280 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
281 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
283 /* For C++ std::numeric_limits<T>::has_infinity. */
284 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
285 builtin_define_with_int_value (name
,
286 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
287 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
288 predicate to distinguish a target that has both quiet and
289 signalling NaNs from a target that has only quiet NaNs or only
290 signalling NaNs, so we assume that a target that has any kind of
291 NaN has quiet NaNs. */
292 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
293 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
295 /* Note whether we have fast FMA. */
296 if (mode_has_fma (TYPE_MODE (type
)))
298 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
299 builtin_define_with_int_value (name
, 1);
303 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
305 builtin_define_decimal_float_constants (const char *name_prefix
,
309 const struct real_format
*fmt
;
310 char name
[64], buf
[128], *p
;
313 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
315 /* The number of radix digits, p, in the significand. */
316 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
317 builtin_define_with_int_value (name
, fmt
->p
);
319 /* The minimum negative int x such that b**(x-1) is a normalized float. */
320 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
321 sprintf (buf
, "(%d)", fmt
->emin
);
322 builtin_define_with_value (name
, buf
, 0);
324 /* The maximum int x such that b**(x-1) is a representable float. */
325 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
326 builtin_define_with_int_value (name
, fmt
->emax
);
328 /* Compute the minimum representable value. */
329 sprintf (name
, "__%s_MIN__", name_prefix
);
330 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
331 builtin_define_with_value (name
, buf
, 0);
333 /* Compute the maximum representable value. */
334 sprintf (name
, "__%s_MAX__", name_prefix
);
336 for (digits
= fmt
->p
; digits
; digits
--)
339 if (digits
== fmt
->p
)
343 /* fmt->p plus 1, to account for the decimal point and fmt->emax
344 minus 1 because the digits are nines, not 1.0. */
345 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
346 builtin_define_with_value (name
, buf
, 0);
348 /* Compute epsilon (the difference between 1 and least value greater
349 than 1 representable). */
350 sprintf (name
, "__%s_EPSILON__", name_prefix
);
351 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
352 builtin_define_with_value (name
, buf
, 0);
354 /* Minimum subnormal positive decimal value. */
355 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
357 for (digits
= fmt
->p
; digits
> 1; digits
--)
360 if (digits
== fmt
->p
)
364 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
365 builtin_define_with_value (name
, buf
, 0);
368 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
371 builtin_define_fixed_point_constants (const char *name_prefix
,
375 char name
[64], buf
[256], *new_buf
;
378 sprintf (name
, "__%s_FBIT__", name_prefix
);
379 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
381 sprintf (name
, "__%s_IBIT__", name_prefix
);
382 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
384 /* If there is no suffix, defines are for fixed-point modes.
386 if (strcmp (suffix
, "") == 0)
389 if (TYPE_UNSIGNED (type
))
391 sprintf (name
, "__%s_MIN__", name_prefix
);
392 sprintf (buf
, "0.0%s", suffix
);
393 builtin_define_with_value (name
, buf
, 0);
397 sprintf (name
, "__%s_MIN__", name_prefix
);
398 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
399 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
400 TYPE_IBIT (type
) - 1, suffix
);
402 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
403 builtin_define_with_value (name
, buf
, 0);
406 sprintf (name
, "__%s_MAX__", name_prefix
);
409 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
411 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
412 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
413 sprintf (new_buf
++, "F");
414 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
415 builtin_define_with_value (name
, buf
, 0);
417 sprintf (name
, "__%s_EPSILON__", name_prefix
);
418 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
419 builtin_define_with_value (name
, buf
, 0);
422 /* Define macros used by <stdint.h>. */
424 builtin_define_stdint_macros (void)
426 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
427 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
428 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
429 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
430 if (sig_atomic_type_node
)
431 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
432 sig_atomic_type_node
);
434 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
436 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
438 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
440 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
442 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
443 if (c_uint16_type_node
)
444 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
445 if (c_uint32_type_node
)
446 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
447 if (c_uint64_type_node
)
448 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
449 if (int_least8_type_node
)
451 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
452 builtin_define_constants ("__INT8_C", int_least8_type_node
);
454 if (int_least16_type_node
)
456 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
457 builtin_define_constants ("__INT16_C", int_least16_type_node
);
459 if (int_least32_type_node
)
461 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
462 builtin_define_constants ("__INT32_C", int_least32_type_node
);
464 if (int_least64_type_node
)
466 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
467 builtin_define_constants ("__INT64_C", int_least64_type_node
);
469 if (uint_least8_type_node
)
471 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
472 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
474 if (uint_least16_type_node
)
476 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
477 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
479 if (uint_least32_type_node
)
481 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
482 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
484 if (uint_least64_type_node
)
486 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
487 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
489 if (int_fast8_type_node
)
490 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
491 if (int_fast16_type_node
)
492 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
493 if (int_fast32_type_node
)
494 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
495 if (int_fast64_type_node
)
496 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
497 if (uint_fast8_type_node
)
498 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
499 if (uint_fast16_type_node
)
500 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
501 if (uint_fast32_type_node
)
502 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
503 if (uint_fast64_type_node
)
504 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
505 if (intptr_type_node
)
506 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
507 if (uintptr_type_node
)
508 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
511 /* Adjust the optimization macros when a #pragma GCC optimization is done to
512 reflect the current level. */
514 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
517 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
518 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
522 /* -undef turns off target-specific built-ins. */
526 /* Other target-independent built-ins determined by command-line
528 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
529 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
530 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
531 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
533 if (!prev
->x_optimize
&& cur
->x_optimize
)
534 cpp_define (pfile
, "__OPTIMIZE__");
535 else if (prev
->x_optimize
&& !cur
->x_optimize
)
536 cpp_undef (pfile
, "__OPTIMIZE__");
538 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
539 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
540 if (!prev_fast_math
&& cur_fast_math
)
541 cpp_define (pfile
, "__FAST_MATH__");
542 else if (prev_fast_math
&& !cur_fast_math
)
543 cpp_undef (pfile
, "__FAST_MATH__");
545 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
546 cpp_define (pfile
, "__SUPPORT_SNAN__");
547 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
548 cpp_undef (pfile
, "__SUPPORT_SNAN__");
550 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
551 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
552 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
553 cpp_define (pfile
, "__NO_MATH_ERRNO__");
555 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
557 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
558 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
560 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
562 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
563 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
568 /* This function will emit cpp macros to indicate the presence of various lock
569 free atomic operations. */
572 cpp_atomic_builtins (cpp_reader
*pfile
)
574 /* Set a flag for each size of object that compare and swap exists for up to
576 #define SWAP_LIMIT 17
577 bool have_swap
[SWAP_LIMIT
];
580 /* Clear the map of sizes compare_and swap exists for. */
581 memset (have_swap
, 0, sizeof (have_swap
));
583 /* Tell source code if the compiler makes sync_compare_and_swap
584 builtins available. */
585 #ifndef HAVE_sync_compare_and_swapqi
586 #define HAVE_sync_compare_and_swapqi 0
588 #ifndef HAVE_atomic_compare_and_swapqi
589 #define HAVE_atomic_compare_and_swapqi 0
592 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
594 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
598 #ifndef HAVE_sync_compare_and_swaphi
599 #define HAVE_sync_compare_and_swaphi 0
601 #ifndef HAVE_atomic_compare_and_swaphi
602 #define HAVE_atomic_compare_and_swaphi 0
604 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
606 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
610 #ifndef HAVE_sync_compare_and_swapsi
611 #define HAVE_sync_compare_and_swapsi 0
613 #ifndef HAVE_atomic_compare_and_swapsi
614 #define HAVE_atomic_compare_and_swapsi 0
616 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
618 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
622 #ifndef HAVE_sync_compare_and_swapdi
623 #define HAVE_sync_compare_and_swapdi 0
625 #ifndef HAVE_atomic_compare_and_swapdi
626 #define HAVE_atomic_compare_and_swapdi 0
628 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
630 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
634 #ifndef HAVE_sync_compare_and_swapti
635 #define HAVE_sync_compare_and_swapti 0
637 #ifndef HAVE_atomic_compare_and_swapti
638 #define HAVE_atomic_compare_and_swapti 0
640 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
642 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
643 have_swap
[16] = true;
646 /* Tell the source code about various types. These map to the C++11 and C11
647 macros where 2 indicates lock-free always, and 1 indicates sometimes
649 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
650 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
651 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
652 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
653 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
654 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
655 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
656 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
657 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
658 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
659 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
660 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
661 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
662 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
663 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
664 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
665 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
666 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
667 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
668 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
670 /* If we're dealing with a "set" value that doesn't exactly correspond
671 to a boolean truth value, let the library work around that. */
672 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
673 targetm
.atomic_test_and_set_trueval
);
675 /* ptr_type_node can't be used here since ptr_mode is only set when
676 toplev calls backend_init which is not done with -E or pch. */
677 psize
= POINTER_SIZE_UNITS
;
678 if (psize
>= SWAP_LIMIT
)
680 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
681 (have_swap
[psize
]? 2 : 1));
684 /* Return the value for __GCC_IEC_559. */
686 cpp_iec_559_value (void)
688 /* The default is support for IEEE 754-2008. */
691 /* float and double must be binary32 and binary64. If they are but
692 with reversed NaN convention, at most IEEE 754-1985 is
694 const struct real_format
*ffmt
695 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
696 const struct real_format
*dfmt
697 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
698 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
703 || ffmt
->emin
!= -125
705 || ffmt
->signbit_rw
!= 31
706 || ffmt
->round_towards_zero
707 || !ffmt
->has_sign_dependent_rounding
711 || !ffmt
->has_signed_zero
715 || dfmt
->emin
!= -1021
716 || dfmt
->emax
!= 1024
717 || dfmt
->signbit_rw
!= 63
718 || dfmt
->round_towards_zero
719 || !dfmt
->has_sign_dependent_rounding
723 || !dfmt
->has_signed_zero
)
726 /* In strict C standards conformance mode, consider unpredictable
727 excess precision to mean lack of IEEE 754 support. The same
728 applies to unpredictable contraction. For C++, and outside
729 strict conformance mode, do not consider these options to mean
730 lack of IEEE 754 support. */
733 && TARGET_FLT_EVAL_METHOD
!= 0
734 && flag_excess_precision_cmdline
!= EXCESS_PRECISION_STANDARD
)
738 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
741 /* Various options are contrary to IEEE 754 semantics. */
742 if (flag_unsafe_math_optimizations
743 || flag_associative_math
744 || flag_reciprocal_math
745 || flag_finite_math_only
746 || !flag_signed_zeros
747 || flag_single_precision_constant
)
750 /* If the target does not support IEEE 754 exceptions and rounding
751 modes, consider IEEE 754 support to be absent. */
752 if (!targetm
.float_exceptions_rounding_supported_p ())
758 /* Return the value for __GCC_IEC_559_COMPLEX. */
760 cpp_iec_559_complex_value (void)
762 /* The value is no bigger than that of __GCC_IEC_559. */
763 int ret
= cpp_iec_559_value ();
765 /* Some options are contrary to the required default state of the
766 CX_LIMITED_RANGE pragma. */
767 if (flag_complex_method
!= 2)
773 /* Hook that registers front end and target-specific built-ins. */
775 c_cpp_builtins (cpp_reader
*pfile
)
779 /* -undef turns off target-specific built-ins. */
783 define_language_independent_builtin_macros (pfile
);
785 if (c_dialect_cxx ())
788 parse_basever (&major
, NULL
, NULL
);
789 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
792 /* For stddef.h. They require macros defined in c-common.c. */
793 c_stddef_cpp_builtins ();
795 /* Set include test macros for all C/C++ (not for just C++11 etc.)
796 The builtins __has_include__ and __has_include_next__ are defined
798 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
799 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
801 if (c_dialect_cxx ())
803 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
804 cpp_define (pfile
, "__GXX_WEAK__=1");
806 cpp_define (pfile
, "__GXX_WEAK__=0");
809 cpp_define (pfile
, "__DEPRECATED");
813 cpp_define (pfile
, "__GXX_RTTI");
814 cpp_define (pfile
, "__cpp_rtti=199711");
817 if (cxx_dialect
>= cxx11
)
818 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
820 /* Binary literals have been allowed in g++ before C++11
821 and were standardized for C++14. */
822 if (!pedantic
|| cxx_dialect
> cxx11
)
823 cpp_define (pfile
, "__cpp_binary_literals=201304");
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 cpp_define (pfile
, "__cpp_unicode_characters=200704");
837 cpp_define (pfile
, "__cpp_raw_strings=200710");
838 cpp_define (pfile
, "__cpp_unicode_literals=200710");
839 cpp_define (pfile
, "__cpp_user_defined_literals=200809");
840 cpp_define (pfile
, "__cpp_lambdas=200907");
841 if (cxx_dialect
== cxx11
)
842 cpp_define (pfile
, "__cpp_constexpr=200704");
843 cpp_define (pfile
, "__cpp_range_based_for=200907");
844 if (cxx_dialect
<= cxx14
)
845 cpp_define (pfile
, "__cpp_static_assert=200410");
846 cpp_define (pfile
, "__cpp_decltype=200707");
847 cpp_define (pfile
, "__cpp_attributes=200809");
848 cpp_define (pfile
, "__cpp_rvalue_reference=200610");
849 cpp_define (pfile
, "__cpp_variadic_templates=200704");
850 cpp_define (pfile
, "__cpp_initializer_lists=200806");
851 cpp_define (pfile
, "__cpp_delegating_constructors=200604");
852 cpp_define (pfile
, "__cpp_nsdmi=200809");
853 cpp_define (pfile
, "__cpp_inheriting_constructors=200802");
854 cpp_define (pfile
, "__cpp_ref_qualifiers=200710");
855 cpp_define (pfile
, "__cpp_alias_templates=200704");
857 if (cxx_dialect
> cxx11
)
859 /* Set feature test macros for C++14. */
860 cpp_define (pfile
, "__cpp_return_type_deduction=201304");
861 cpp_define (pfile
, "__cpp_init_captures=201304");
862 cpp_define (pfile
, "__cpp_generic_lambdas=201304");
863 cpp_define (pfile
, "__cpp_constexpr=201304");
864 cpp_define (pfile
, "__cpp_decltype_auto=201304");
865 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304");
866 cpp_define (pfile
, "__cpp_variable_templates=201304");
867 cpp_define (pfile
, "__cpp_digit_separators=201309");
869 if (cxx_dialect
> cxx14
)
871 /* Set feature test macros for C++1z. */
872 cpp_define (pfile
, "__cpp_static_assert=201411");
873 cpp_define (pfile
, "__cpp_namespace_attributes=201411");
874 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411");
877 /* Use a value smaller than the 201507 specified in
878 the TS, since we don't yet support extended auto. */
879 cpp_define (pfile
, "__cpp_concepts=201500");
881 /* Use a value smaller than the 201505 specified in
882 the TS, since we don't yet support atomic_cancel. */
883 cpp_define (pfile
, "__cpp_transactional_memory=210500");
884 if (flag_sized_deallocation
)
885 cpp_define (pfile
, "__cpp_sized_deallocation=201309");
887 /* Note that we define this for C as well, so that we know if
888 __attribute__((cleanup)) will interface with EH. */
891 cpp_define (pfile
, "__EXCEPTIONS");
892 if (c_dialect_cxx ())
893 cpp_define (pfile
, "__cpp_exceptions=199711");
896 /* Represents the C++ ABI version, always defined so it can be used while
897 preprocessing C and assembler. */
898 if (flag_abi_version
== 0)
899 /* We should have set this to something real in c_common_post_options. */
901 else if (flag_abi_version
== 1)
902 /* Due to a historical accident, this version had the value
904 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
906 /* Newer versions have values 1002, 1003, .... */
907 builtin_define_with_int_value ("__GXX_ABI_VERSION",
908 1000 + flag_abi_version
);
910 /* libgcc needs to know this. */
911 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
912 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
914 /* limits.h and stdint.h need to know these. */
915 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
916 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
917 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
918 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
919 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
920 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
921 underlying_wchar_type_node
);
922 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
923 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
924 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
926 if (c_dialect_cxx ())
927 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
928 if (int_n_enabled_p
[i
])
932 /* These are used to configure the C++ library. */
934 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
936 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
937 cpp_define (parse_in
, buf
);
939 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
940 cpp_define (parse_in
, buf
);
944 /* stdint.h and the testsuite need to know these. */
945 builtin_define_stdint_macros ();
947 /* Provide information for library headers to determine whether to
948 define macros such as __STDC_IEC_559__ and
949 __STDC_IEC_559_COMPLEX__. */
950 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
951 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
952 cpp_iec_559_complex_value ());
954 /* float.h needs to know this. */
955 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
956 TARGET_FLT_EVAL_METHOD
);
958 /* And decfloat.h needs this. */
959 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
960 TARGET_DEC_EVAL_METHOD
);
962 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
963 /* Cast the double precision constants. This is needed when single
964 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
965 is used. The correct result is computed by the compiler when using
966 macros that include a cast. We use a different cast for C++ to avoid
967 problems with -Wold-style-cast. */
968 builtin_define_float_constants ("DBL", "L",
972 "", double_type_node
);
973 builtin_define_float_constants ("LDBL", "L", "%s", "L",
974 long_double_type_node
);
976 /* For decfloat.h. */
977 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
978 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
979 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
981 /* For fixed-point fibt, ibit, max, min, and epsilon. */
982 if (targetm
.fixed_point_supported_p ())
984 builtin_define_fixed_point_constants ("SFRACT", "HR",
985 short_fract_type_node
);
986 builtin_define_fixed_point_constants ("USFRACT", "UHR",
987 unsigned_short_fract_type_node
);
988 builtin_define_fixed_point_constants ("FRACT", "R",
990 builtin_define_fixed_point_constants ("UFRACT", "UR",
991 unsigned_fract_type_node
);
992 builtin_define_fixed_point_constants ("LFRACT", "LR",
993 long_fract_type_node
);
994 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
995 unsigned_long_fract_type_node
);
996 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
997 long_long_fract_type_node
);
998 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
999 unsigned_long_long_fract_type_node
);
1000 builtin_define_fixed_point_constants ("SACCUM", "HK",
1001 short_accum_type_node
);
1002 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1003 unsigned_short_accum_type_node
);
1004 builtin_define_fixed_point_constants ("ACCUM", "K",
1006 builtin_define_fixed_point_constants ("UACCUM", "UK",
1007 unsigned_accum_type_node
);
1008 builtin_define_fixed_point_constants ("LACCUM", "LK",
1009 long_accum_type_node
);
1010 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1011 unsigned_long_accum_type_node
);
1012 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1013 long_long_accum_type_node
);
1014 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1015 unsigned_long_long_accum_type_node
);
1017 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1018 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1019 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1020 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1021 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1022 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1023 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1024 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1025 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1026 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1027 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1028 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1029 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1030 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1031 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1032 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1033 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1034 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1037 /* For libgcc-internal use only. */
1038 if (flag_building_libgcc
)
1040 /* Properties of floating-point modes for libgcc2.c. */
1041 for (machine_mode mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1043 mode
= GET_MODE_WIDER_MODE (mode
))
1045 const char *name
= GET_MODE_NAME (mode
);
1047 = (char *) alloca (strlen (name
)
1048 + sizeof ("__LIBGCC__MANT_DIG__"));
1049 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1050 builtin_define_with_int_value (macro_name
,
1051 REAL_MODE_FORMAT (mode
)->p
);
1052 if (!targetm
.scalar_mode_supported_p (mode
)
1053 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1055 macro_name
= (char *) alloca (strlen (name
)
1056 + sizeof ("__LIBGCC_HAS__MODE__"));
1057 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1058 cpp_define (pfile
, macro_name
);
1059 macro_name
= (char *) alloca (strlen (name
)
1060 + sizeof ("__LIBGCC__FUNC_EXT__"));
1061 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1063 if (mode
== TYPE_MODE (double_type_node
))
1065 else if (mode
== TYPE_MODE (float_type_node
))
1067 else if (mode
== TYPE_MODE (long_double_type_node
))
1069 /* ??? The following assumes the built-in functions (defined
1070 in target-specific code) match the suffixes used for
1071 constants. Because in fact such functions are not
1072 defined for the 'w' suffix, 'l' is used there
1074 else if (mode
== targetm
.c
.mode_for_suffix ('q'))
1076 else if (mode
== targetm
.c
.mode_for_suffix ('w'))
1080 builtin_define_with_value (macro_name
, suffix
, 0);
1081 bool excess_precision
= false;
1082 if (TARGET_FLT_EVAL_METHOD
!= 0
1083 && mode
!= TYPE_MODE (long_double_type_node
)
1084 && (mode
== TYPE_MODE (float_type_node
)
1085 || mode
== TYPE_MODE (double_type_node
)))
1086 switch (TARGET_FLT_EVAL_METHOD
)
1090 excess_precision
= true;
1094 excess_precision
= mode
== TYPE_MODE (float_type_node
);
1100 macro_name
= (char *) alloca (strlen (name
)
1101 + sizeof ("__LIBGCC__EXCESS_"
1103 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1104 builtin_define_with_int_value (macro_name
, excess_precision
);
1107 /* For libgcc crtstuff.c and libgcc2.c. */
1108 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1109 EH_TABLES_CAN_BE_READ_ONLY
);
1110 #ifdef EH_FRAME_SECTION_NAME
1111 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1112 EH_FRAME_SECTION_NAME
, 1);
1114 #ifdef JCR_SECTION_NAME
1115 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
1116 JCR_SECTION_NAME
, 1);
1118 #ifdef CTORS_SECTION_ASM_OP
1119 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1120 CTORS_SECTION_ASM_OP
, 1);
1122 #ifdef DTORS_SECTION_ASM_OP
1123 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1124 DTORS_SECTION_ASM_OP
, 1);
1126 #ifdef TEXT_SECTION_ASM_OP
1127 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1128 TEXT_SECTION_ASM_OP
, 1);
1130 #ifdef INIT_SECTION_ASM_OP
1131 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1132 INIT_SECTION_ASM_OP
, 1);
1134 #ifdef INIT_ARRAY_SECTION_ASM_OP
1135 /* Despite the name of this target macro, the expansion is not
1136 actually used, and may be empty rather than a string
1138 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1141 /* For libgcc enable-execute-stack.c. */
1142 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1145 /* For libgcc generic-morestack.c and unwinder code. */
1146 if (STACK_GROWS_DOWNWARD
)
1147 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1149 /* For libgcc unwinder code. */
1150 #ifdef DONT_USE_BUILTIN_SETJMP
1151 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1153 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1154 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1155 DWARF_ALT_FRAME_RETURN_COLUMN
);
1157 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1158 DWARF_FRAME_REGISTERS
);
1159 #ifdef EH_RETURN_STACKADJ_RTX
1160 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1163 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1166 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1167 STACK_POINTER_REGNUM
);
1170 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1171 TARGET_VTABLE_USES_DESCRIPTORS
);
1174 /* For use in assembly language. */
1175 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1176 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1179 if (flag_gnu89_inline
)
1180 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1182 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1185 cpp_define (pfile
, "__NO_INLINE__");
1188 cpp_define (pfile
, "__STRICT_ANSI__");
1190 if (!flag_signed_char
)
1191 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1193 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1194 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1196 cpp_atomic_builtins (pfile
);
1198 #ifdef DWARF2_UNWIND_INFO
1199 if (dwarf2out_do_cfi_asm ())
1200 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1203 /* Make the choice of ObjC runtime visible to source code. */
1204 if (c_dialect_objc () && flag_next_runtime
)
1205 cpp_define (pfile
, "__NEXT_RUNTIME__");
1207 /* Show the availability of some target pragmas. */
1208 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1210 /* Make the choice of the stack protector runtime visible to source code.
1211 The macro names and values here were chosen for compatibility with an
1212 earlier implementation, i.e. ProPolice. */
1213 if (flag_stack_protect
== 4)
1214 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1215 if (flag_stack_protect
== 3)
1216 cpp_define (pfile
, "__SSP_STRONG__=3");
1217 if (flag_stack_protect
== 2)
1218 cpp_define (pfile
, "__SSP_ALL__=2");
1219 else if (flag_stack_protect
== 1)
1220 cpp_define (pfile
, "__SSP__=1");
1223 cpp_define (pfile
, "_OPENACC=201306");
1226 cpp_define (pfile
, "_OPENMP=201307");
1228 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1229 if (int_n_enabled_p
[i
])
1232 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1233 builtin_define_type_sizeof (buf
,
1234 int_n_trees
[i
].signed_type
);
1236 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1237 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1238 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1239 unsigned_ptrdiff_type_node
);
1241 /* A straightforward target hook doesn't work, because of problems
1242 linking that hook's body when part of non-C front ends. */
1243 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1244 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1245 # define builtin_define(TXT) cpp_define (pfile, TXT)
1246 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1247 TARGET_CPU_CPP_BUILTINS ();
1248 TARGET_OS_CPP_BUILTINS ();
1249 TARGET_OBJFMT_CPP_BUILTINS ();
1251 /* Support the __declspec keyword by turning them into attributes.
1252 Note that the current way we do this may result in a collision
1253 with predefined attributes later on. This can be solved by using
1254 one attribute, say __declspec__, and passing args to it. The
1255 problem with that approach is that args are not accumulated: each
1256 new appearance would clobber any existing args. */
1257 if (TARGET_DECLSPEC
)
1258 builtin_define ("__declspec(x)=__attribute__((x))");
1260 /* If decimal floating point is supported, tell the user if the
1261 alternate format (BID) is used instead of the standard (DPD)
1263 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1264 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1267 /* Pass an object-like macro. If it doesn't lie in the user's
1268 namespace, defines it unconditionally. Otherwise define a version
1269 with two leading underscores, and another version with two leading
1270 and trailing underscores, and define the original only if an ISO
1271 standard was not nominated.
1273 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1274 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1277 builtin_define_std (const char *macro
)
1279 size_t len
= strlen (macro
);
1280 char *buff
= (char *) alloca (len
+ 5);
1284 /* prepend __ (or maybe just _) if in user's namespace. */
1285 memcpy (p
, macro
, len
+ 1);
1286 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1293 cpp_define (parse_in
, p
);
1295 /* If it was in user's namespace... */
1298 /* Define the macro with leading and following __. */
1304 cpp_define (parse_in
, p
);
1306 /* Finally, define the original macro if permitted. */
1308 cpp_define (parse_in
, macro
);
1312 /* Pass an object-like macro and a value to define it to. The third
1313 parameter says whether or not to turn the value into a string
1316 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1319 size_t mlen
= strlen (macro
);
1320 size_t elen
= strlen (expansion
);
1321 size_t extra
= 2; /* space for an = and a NUL */
1325 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1328 extra
+= 2; /* space for two quote marks */
1329 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1354 if (ISPRINT ((unsigned char) *p
))
1358 sprintf (q
, "\\%03o", (unsigned char) *p
);
1364 expansion
= quoted_expansion
;
1365 elen
= q
- expansion
;
1368 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1370 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1372 sprintf (buf
, "%s=%s", macro
, expansion
);
1374 cpp_define (parse_in
, buf
);
1378 /* Pass an object-like macro and an integer value to define it to. */
1380 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1383 size_t mlen
= strlen (macro
);
1385 size_t extra
= 2; /* space for = and NUL. */
1387 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1388 memcpy (buf
, macro
, mlen
);
1390 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1392 cpp_define (parse_in
, buf
);
1395 /* builtin_define_with_hex_fp_value is very expensive, so the following
1396 array and function allows it to be done lazily when __DBL_MAX__
1397 etc. is first used. */
1399 struct GTY(()) lazy_hex_fp_value_struct
1401 const char *hex_str
;
1405 const char *fp_suffix
;
1407 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1408 static GTY(()) int lazy_hex_fp_value_count
;
1411 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1414 REAL_VALUE_TYPE real
;
1415 char dec_str
[64], buf1
[256];
1417 if (node
->value
.builtin
< BT_FIRST_USER
1418 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1421 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1422 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1423 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1424 lazy_hex_fp_values
[idx
].digits
, 0,
1425 lazy_hex_fp_values
[idx
].mode
);
1427 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1428 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1429 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1430 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1431 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1433 gcc_assert (idx
< node
->value
.macro
->count
);
1434 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1435 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1436 = (const unsigned char *) ggc_strdup (buf1
);
1440 /* Pass an object-like macro a hexadecimal floating-point value. */
1442 builtin_define_with_hex_fp_value (const char *macro
,
1443 tree type
, int digits
,
1444 const char *hex_str
,
1445 const char *fp_suffix
,
1446 const char *fp_cast
)
1448 REAL_VALUE_TYPE real
;
1449 char dec_str
[64], buf1
[256], buf2
[256];
1451 /* This is very expensive, so if possible expand them lazily. */
1452 if (lazy_hex_fp_value_count
< 12
1453 && flag_dump_macros
== 0
1454 && !cpp_get_options (parse_in
)->traditional
)
1456 struct cpp_hashnode
*node
;
1457 if (lazy_hex_fp_value_count
== 0)
1458 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1459 sprintf (buf2
, fp_cast
, "1.1");
1460 sprintf (buf1
, "%s=%s", macro
, buf2
);
1461 cpp_define (parse_in
, buf1
);
1462 node
= C_CPP_HASHNODE (get_identifier (macro
));
1463 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1464 = ggc_strdup (hex_str
);
1465 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1466 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1467 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1468 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1469 node
->flags
|= NODE_BUILTIN
;
1471 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1472 lazy_hex_fp_value_count
++;
1476 /* Hex values are really cool and convenient, except that they're
1477 not supported in strict ISO C90 mode. First, the "p-" sequence
1478 is not valid as part of a preprocessor number. Second, we get a
1479 pedwarn from the preprocessor, which has no context, so we can't
1480 suppress the warning with __extension__.
1482 So instead what we do is construct the number in hex (because
1483 it's easy to get the exact correct value), parse it as a real,
1484 then print it back out as decimal. */
1486 real_from_string (&real
, hex_str
);
1487 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1490 /* Assemble the macro in the following fashion
1491 macro = fp_cast [dec_str fp_suffix] */
1492 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1493 sprintf (buf2
, fp_cast
, buf1
);
1494 sprintf (buf1
, "%s=%s", macro
, buf2
);
1496 cpp_define (parse_in
, buf1
);
1499 /* Return a string constant for the suffix for a value of type TYPE
1500 promoted according to the integer promotions. The type must be one
1501 of the standard integer type nodes. */
1504 type_suffix (tree type
)
1506 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1507 int unsigned_suffix
;
1509 int tp
= TYPE_PRECISION (type
);
1511 if (type
== long_long_integer_type_node
1512 || type
== long_long_unsigned_type_node
1513 || tp
> TYPE_PRECISION (long_integer_type_node
))
1515 else if (type
== long_integer_type_node
1516 || type
== long_unsigned_type_node
1517 || tp
> TYPE_PRECISION (integer_type_node
))
1519 else if (type
== integer_type_node
1520 || type
== unsigned_type_node
1521 || type
== short_integer_type_node
1522 || type
== short_unsigned_type_node
1523 || type
== signed_char_type_node
1524 || type
== unsigned_char_type_node
1525 /* ??? "char" is not a signed or unsigned integer type and
1526 so is not permitted for the standard typedefs, but some
1527 systems use it anyway. */
1528 || type
== char_type_node
)
1533 unsigned_suffix
= TYPE_UNSIGNED (type
);
1534 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1535 unsigned_suffix
= 0;
1536 return suffixes
[is_long
* 2 + unsigned_suffix
];
1539 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1541 builtin_define_constants (const char *macro
, tree type
)
1546 suffix
= type_suffix (type
);
1550 buf
= (char *) alloca (strlen (macro
) + 6);
1551 sprintf (buf
, "%s(c)=c", macro
);
1555 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1556 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1559 cpp_define (parse_in
, buf
);
1562 /* Define MAX for TYPE based on the precision of the type. */
1565 builtin_define_type_max (const char *macro
, tree type
)
1567 builtin_define_type_minmax (NULL
, macro
, type
);
1570 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1571 representation of that value. For example, a COUNT of 10 would
1575 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1577 gcc_assert (bufsz
> 3);
1582 gcc_assert (count
> 0);
1584 switch (count
% 4) {
1605 gcc_assert (bufsz
> 1);
1610 gcc_assert (bufsz
> 0);
1614 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1615 precision of the type. */
1618 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1621 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1622 char value
[PBOH_SZ
];
1628 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1630 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1632 suffix
= type_suffix (type
);
1634 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1635 + strlen (suffix
) + 1);
1636 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1638 cpp_define (parse_in
, buf
);
1642 if (TYPE_UNSIGNED (type
))
1644 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1645 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1649 buf
= (char *) alloca (strlen (min_macro
) + 3
1650 + strlen (max_macro
) + 6);
1651 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1653 cpp_define (parse_in
, buf
);
1657 #include "gt-c-family-c-cppbuiltin.h"