1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2014 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 "stor-layout.h"
26 #include "stringpool.h"
31 #include "output.h" /* For user_label_prefix. */
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
33 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
35 #include "common/common-target.h"
36 #include "cpp-id-data.h"
37 #include "cppbuiltin.h"
39 #ifndef TARGET_OS_CPP_BUILTINS
40 # define TARGET_OS_CPP_BUILTINS()
43 #ifndef TARGET_OBJFMT_CPP_BUILTINS
44 # define TARGET_OBJFMT_CPP_BUILTINS()
47 #ifndef REGISTER_PREFIX
48 #define REGISTER_PREFIX ""
51 /* Non-static as some targets don't use it. */
52 void builtin_define_std (const char *) ATTRIBUTE_UNUSED
;
53 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT
);
54 static void builtin_define_with_hex_fp_value (const char *, tree
,
58 static void builtin_define_stdint_macros (void);
59 static void builtin_define_constants (const char *, tree
);
60 static void builtin_define_type_max (const char *, tree
);
61 static void builtin_define_type_minmax (const char *, const char *, tree
);
62 static void builtin_define_type_sizeof (const char *, tree
);
63 static void builtin_define_float_constants (const char *,
69 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
70 Originally this function used the fma optab, but that doesn't work with
71 -save-temps, so just rely on the HAVE_fma macros for the standard floating
75 mode_has_fma (machine_mode mode
)
106 /* Define NAME with value TYPE size_unit. */
108 builtin_define_type_sizeof (const char *name
, tree type
)
110 builtin_define_with_int_value (name
,
111 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
114 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
117 builtin_define_float_constants (const char *name_prefix
,
118 const char *fp_suffix
,
120 const char *fma_suffix
,
123 /* Used to convert radix-based values to base 10 values in several cases.
125 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
126 least 6 significant digits for correct results. Using the fraction
127 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
128 intermediate; perhaps someone can find a better approximation, in the
129 mean time, I suspect using doubles won't harm the bootstrap here. */
131 const double log10_2
= .30102999566398119521;
133 const struct real_format
*fmt
;
134 const struct real_format
*ldfmt
;
136 char name
[64], buf
[128];
137 int dig
, min_10_exp
, max_10_exp
;
139 int type_decimal_dig
;
141 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
142 gcc_assert (fmt
->b
!= 10);
143 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
144 gcc_assert (ldfmt
->b
!= 10);
146 /* The radix of the exponent representation. */
147 if (type
== float_type_node
)
148 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
151 /* The number of radix digits, p, in the floating-point significand. */
152 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
153 builtin_define_with_int_value (name
, fmt
->p
);
155 /* The number of decimal digits, q, such that any floating-point number
156 with q decimal digits can be rounded into a floating-point number with
157 p radix b digits and back again without change to the q decimal digits,
159 p log10 b if b is a power of 10
160 floor((p - 1) log10 b) otherwise
162 dig
= (fmt
->p
- 1) * log10_b
;
163 sprintf (name
, "__%s_DIG__", name_prefix
);
164 builtin_define_with_int_value (name
, dig
);
166 /* The minimum negative int x such that b**(x-1) is a normalized float. */
167 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
168 sprintf (buf
, "(%d)", fmt
->emin
);
169 builtin_define_with_value (name
, buf
, 0);
171 /* The minimum negative int x such that 10**x is a normalized float,
173 ceil (log10 (b ** (emin - 1)))
174 = ceil (log10 (b) * (emin - 1))
176 Recall that emin is negative, so the integer truncation calculates
177 the ceiling, not the floor, in this case. */
178 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
179 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
180 sprintf (buf
, "(%d)", min_10_exp
);
181 builtin_define_with_value (name
, buf
, 0);
183 /* The maximum int x such that b**(x-1) is a representable float. */
184 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
185 builtin_define_with_int_value (name
, fmt
->emax
);
187 /* The maximum int x such that 10**x is in the range of representable
188 finite floating-point numbers,
190 floor (log10((1 - b**-p) * b**emax))
191 = floor (log10(1 - b**-p) + log10(b**emax))
192 = floor (log10(1 - b**-p) + log10(b)*emax)
194 The safest thing to do here is to just compute this number. But since
195 we don't link cc1 with libm, we cannot. We could implement log10 here
196 a series expansion, but that seems too much effort because:
198 Note that the first term, for all extant p, is a number exceedingly close
199 to zero, but slightly negative. Note that the second term is an integer
200 scaling an irrational number, and that because of the floor we are only
201 interested in its integral portion.
203 In order for the first term to have any effect on the integral portion
204 of the second term, the second term has to be exceedingly close to an
205 integer itself (e.g. 123.000000000001 or something). Getting a result
206 that close to an integer requires that the irrational multiplicand have
207 a long series of zeros in its expansion, which doesn't occur in the
208 first 20 digits or so of log10(b).
210 Hand-waving aside, crunching all of the sets of constants above by hand
211 does not yield a case for which the first term is significant, which
212 in the end is all that matters. */
213 max_10_exp
= fmt
->emax
* log10_b
;
214 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
215 builtin_define_with_int_value (name
, max_10_exp
);
217 /* The number of decimal digits, n, such that any floating-point number
218 can be rounded to n decimal digits and back again without change to
221 p * log10(b) if b is a power of 10
222 ceil(1 + p * log10(b)) otherwise
224 The only macro we care about is this number for the widest supported
225 floating type, but we want this value for rendering constants below. */
228 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
229 decimal_dig
= d_decimal_dig
;
230 if (decimal_dig
< d_decimal_dig
)
233 /* Similar, for this type rather than long double. */
235 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
236 type_decimal_dig
= type_d_decimal_dig
;
237 if (type_decimal_dig
< type_d_decimal_dig
)
240 if (type
== long_double_type_node
)
241 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
244 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
245 builtin_define_with_int_value (name
, type_decimal_dig
);
248 /* Since, for the supported formats, B is always a power of 2, we
249 construct the following numbers directly as a hexadecimal
251 get_max_float (fmt
, buf
, sizeof (buf
));
253 sprintf (name
, "__%s_MAX__", name_prefix
);
254 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
256 /* The minimum normalized positive floating-point number,
258 sprintf (name
, "__%s_MIN__", name_prefix
);
259 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
260 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
262 /* The difference between 1 and the least value greater than 1 that is
263 representable in the given floating point type, b**(1-p). */
264 sprintf (name
, "__%s_EPSILON__", name_prefix
);
265 if (fmt
->pnan
< fmt
->p
)
266 /* This is an IBM extended double format, so 1.0 + any double is
267 representable precisely. */
268 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
270 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
271 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
273 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
274 The minimum denormalized positive floating-point number, b**(emin-p).
275 The minimum normalized positive floating-point number for formats
276 that don't support denormals. */
277 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
278 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
279 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
280 buf
, fp_suffix
, fp_cast
);
282 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
283 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
285 /* For C++ std::numeric_limits<T>::has_infinity. */
286 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
287 builtin_define_with_int_value (name
,
288 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
289 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
290 predicate to distinguish a target that has both quiet and
291 signalling NaNs from a target that has only quiet NaNs or only
292 signalling NaNs, so we assume that a target that has any kind of
293 NaN has quiet NaNs. */
294 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
295 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
297 /* Note whether we have fast FMA. */
298 if (mode_has_fma (TYPE_MODE (type
)))
300 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
301 builtin_define_with_int_value (name
, 1);
305 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
307 builtin_define_decimal_float_constants (const char *name_prefix
,
311 const struct real_format
*fmt
;
312 char name
[64], buf
[128], *p
;
315 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
317 /* The number of radix digits, p, in the significand. */
318 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
319 builtin_define_with_int_value (name
, fmt
->p
);
321 /* The minimum negative int x such that b**(x-1) is a normalized float. */
322 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
323 sprintf (buf
, "(%d)", fmt
->emin
);
324 builtin_define_with_value (name
, buf
, 0);
326 /* The maximum int x such that b**(x-1) is a representable float. */
327 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
328 builtin_define_with_int_value (name
, fmt
->emax
);
330 /* Compute the minimum representable value. */
331 sprintf (name
, "__%s_MIN__", name_prefix
);
332 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
333 builtin_define_with_value (name
, buf
, 0);
335 /* Compute the maximum representable value. */
336 sprintf (name
, "__%s_MAX__", name_prefix
);
338 for (digits
= fmt
->p
; digits
; digits
--)
341 if (digits
== fmt
->p
)
345 /* fmt->p plus 1, to account for the decimal point and fmt->emax
346 minus 1 because the digits are nines, not 1.0. */
347 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
348 builtin_define_with_value (name
, buf
, 0);
350 /* Compute epsilon (the difference between 1 and least value greater
351 than 1 representable). */
352 sprintf (name
, "__%s_EPSILON__", name_prefix
);
353 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
354 builtin_define_with_value (name
, buf
, 0);
356 /* Minimum subnormal positive decimal value. */
357 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
359 for (digits
= fmt
->p
; digits
> 1; digits
--)
362 if (digits
== fmt
->p
)
366 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
367 builtin_define_with_value (name
, buf
, 0);
370 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
373 builtin_define_fixed_point_constants (const char *name_prefix
,
377 char name
[64], buf
[256], *new_buf
;
380 sprintf (name
, "__%s_FBIT__", name_prefix
);
381 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
383 sprintf (name
, "__%s_IBIT__", name_prefix
);
384 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
386 /* If there is no suffix, defines are for fixed-point modes.
388 if (strcmp (suffix
, "") == 0)
391 if (TYPE_UNSIGNED (type
))
393 sprintf (name
, "__%s_MIN__", name_prefix
);
394 sprintf (buf
, "0.0%s", suffix
);
395 builtin_define_with_value (name
, buf
, 0);
399 sprintf (name
, "__%s_MIN__", name_prefix
);
400 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
401 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
402 TYPE_IBIT (type
) - 1, suffix
);
404 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
405 builtin_define_with_value (name
, buf
, 0);
408 sprintf (name
, "__%s_MAX__", name_prefix
);
411 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
413 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
414 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
415 sprintf (new_buf
++, "F");
416 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
417 builtin_define_with_value (name
, buf
, 0);
419 sprintf (name
, "__%s_EPSILON__", name_prefix
);
420 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
421 builtin_define_with_value (name
, buf
, 0);
424 /* Define macros used by <stdint.h>. */
426 builtin_define_stdint_macros (void)
428 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
429 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
430 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
431 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
432 if (sig_atomic_type_node
)
433 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
434 sig_atomic_type_node
);
436 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
438 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
440 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
442 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
444 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
445 if (c_uint16_type_node
)
446 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
447 if (c_uint32_type_node
)
448 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
449 if (c_uint64_type_node
)
450 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
451 if (int_least8_type_node
)
453 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
454 builtin_define_constants ("__INT8_C", int_least8_type_node
);
456 if (int_least16_type_node
)
458 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
459 builtin_define_constants ("__INT16_C", int_least16_type_node
);
461 if (int_least32_type_node
)
463 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
464 builtin_define_constants ("__INT32_C", int_least32_type_node
);
466 if (int_least64_type_node
)
468 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
469 builtin_define_constants ("__INT64_C", int_least64_type_node
);
471 if (uint_least8_type_node
)
473 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
474 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
476 if (uint_least16_type_node
)
478 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
479 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
481 if (uint_least32_type_node
)
483 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
484 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
486 if (uint_least64_type_node
)
488 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
489 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
491 if (int_fast8_type_node
)
492 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
493 if (int_fast16_type_node
)
494 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
495 if (int_fast32_type_node
)
496 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
497 if (int_fast64_type_node
)
498 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
499 if (uint_fast8_type_node
)
500 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
501 if (uint_fast16_type_node
)
502 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
503 if (uint_fast32_type_node
)
504 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
505 if (uint_fast64_type_node
)
506 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
507 if (intptr_type_node
)
508 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
509 if (uintptr_type_node
)
510 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
513 /* Adjust the optimization macros when a #pragma GCC optimization is done to
514 reflect the current level. */
516 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
519 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
520 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
524 /* -undef turns off target-specific built-ins. */
528 /* Other target-independent built-ins determined by command-line
530 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
531 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
532 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
533 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
535 if (!prev
->x_optimize
&& cur
->x_optimize
)
536 cpp_define (pfile
, "__OPTIMIZE__");
537 else if (prev
->x_optimize
&& !cur
->x_optimize
)
538 cpp_undef (pfile
, "__OPTIMIZE__");
540 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
541 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
542 if (!prev_fast_math
&& cur_fast_math
)
543 cpp_define (pfile
, "__FAST_MATH__");
544 else if (prev_fast_math
&& !cur_fast_math
)
545 cpp_undef (pfile
, "__FAST_MATH__");
547 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
548 cpp_define (pfile
, "__SUPPORT_SNAN__");
549 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
550 cpp_undef (pfile
, "__SUPPORT_SNAN__");
552 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
553 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
554 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
555 cpp_define (pfile
, "__NO_MATH_ERRNO__");
557 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
559 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
560 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
562 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
564 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
565 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
570 /* This function will emit cpp macros to indicate the presence of various lock
571 free atomic operations. */
574 cpp_atomic_builtins (cpp_reader
*pfile
)
576 /* Set a flag for each size of object that compare and swap exists for up to
578 #define SWAP_LIMIT 17
579 bool have_swap
[SWAP_LIMIT
];
582 /* Clear the map of sizes compare_and swap exists for. */
583 memset (have_swap
, 0, sizeof (have_swap
));
585 /* Tell source code if the compiler makes sync_compare_and_swap
586 builtins available. */
587 #ifndef HAVE_sync_compare_and_swapqi
588 #define HAVE_sync_compare_and_swapqi 0
590 #ifndef HAVE_atomic_compare_and_swapqi
591 #define HAVE_atomic_compare_and_swapqi 0
594 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
596 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
600 #ifndef HAVE_sync_compare_and_swaphi
601 #define HAVE_sync_compare_and_swaphi 0
603 #ifndef HAVE_atomic_compare_and_swaphi
604 #define HAVE_atomic_compare_and_swaphi 0
606 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
608 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
612 #ifndef HAVE_sync_compare_and_swapsi
613 #define HAVE_sync_compare_and_swapsi 0
615 #ifndef HAVE_atomic_compare_and_swapsi
616 #define HAVE_atomic_compare_and_swapsi 0
618 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
620 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
624 #ifndef HAVE_sync_compare_and_swapdi
625 #define HAVE_sync_compare_and_swapdi 0
627 #ifndef HAVE_atomic_compare_and_swapdi
628 #define HAVE_atomic_compare_and_swapdi 0
630 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
632 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
636 #ifndef HAVE_sync_compare_and_swapti
637 #define HAVE_sync_compare_and_swapti 0
639 #ifndef HAVE_atomic_compare_and_swapti
640 #define HAVE_atomic_compare_and_swapti 0
642 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
644 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
645 have_swap
[16] = true;
648 /* Tell the source code about various types. These map to the C++11 and C11
649 macros where 2 indicates lock-free always, and 1 indicates sometimes
651 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
652 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
653 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
654 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
655 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
656 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
657 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
658 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
659 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
660 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
661 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
662 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
663 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
664 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
665 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
666 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
667 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
668 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
669 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
670 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
672 /* If we're dealing with a "set" value that doesn't exactly correspond
673 to a boolean truth value, let the library work around that. */
674 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
675 targetm
.atomic_test_and_set_trueval
);
677 /* ptr_type_node can't be used here since ptr_mode is only set when
678 toplev calls backend_init which is not done with -E or pch. */
679 psize
= POINTER_SIZE_UNITS
;
680 if (psize
>= SWAP_LIMIT
)
682 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
683 (have_swap
[psize
]? 2 : 1));
686 /* Return the value for __GCC_IEC_559. */
688 cpp_iec_559_value (void)
690 /* The default is support for IEEE 754-2008. */
693 /* float and double must be binary32 and binary64. If they are but
694 with reversed NaN convention, at most IEEE 754-1985 is
696 const struct real_format
*ffmt
697 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
698 const struct real_format
*dfmt
699 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
700 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
705 || ffmt
->emin
!= -125
707 || ffmt
->signbit_rw
!= 31
708 || ffmt
->round_towards_zero
709 || !ffmt
->has_sign_dependent_rounding
713 || !ffmt
->has_signed_zero
717 || dfmt
->emin
!= -1021
718 || dfmt
->emax
!= 1024
719 || dfmt
->signbit_rw
!= 63
720 || dfmt
->round_towards_zero
721 || !dfmt
->has_sign_dependent_rounding
725 || !dfmt
->has_signed_zero
)
728 /* In strict C standards conformance mode, consider unpredictable
729 excess precision to mean lack of IEEE 754 support. The same
730 applies to unpredictable contraction. For C++, and outside
731 strict conformance mode, do not consider these options to mean
732 lack of IEEE 754 support. */
735 && TARGET_FLT_EVAL_METHOD
!= 0
736 && flag_excess_precision_cmdline
!= EXCESS_PRECISION_STANDARD
)
740 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
743 /* Various options are contrary to IEEE 754 semantics. */
744 if (flag_unsafe_math_optimizations
745 || flag_associative_math
746 || flag_reciprocal_math
747 || flag_finite_math_only
748 || !flag_signed_zeros
749 || flag_single_precision_constant
)
752 /* If the target does not support IEEE 754 exceptions and rounding
753 modes, consider IEEE 754 support to be absent. */
754 if (!targetm
.float_exceptions_rounding_supported_p ())
760 /* Return the value for __GCC_IEC_559_COMPLEX. */
762 cpp_iec_559_complex_value (void)
764 /* The value is no bigger than that of __GCC_IEC_559. */
765 int ret
= cpp_iec_559_value ();
767 /* Some options are contrary to the required default state of the
768 CX_LIMITED_RANGE pragma. */
769 if (flag_complex_method
!= 2)
775 /* Hook that registers front end and target-specific built-ins. */
777 c_cpp_builtins (cpp_reader
*pfile
)
781 /* -undef turns off target-specific built-ins. */
785 define_language_independent_builtin_macros (pfile
);
787 if (c_dialect_cxx ())
790 parse_basever (&major
, NULL
, NULL
);
791 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
794 /* For stddef.h. They require macros defined in c-common.c. */
795 c_stddef_cpp_builtins ();
797 /* Set include test macros for all C/C++ (not for just C++11 etc.)
798 The builtins __has_include__ and __has_include_next__ are defined
800 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
801 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
803 /* Set attribute test macros for all C/C++ (not for just C++11 etc.)
804 The builtin __has_attribute__ is defined in libcpp. */
805 cpp_define (pfile
, "__has_attribute(STR)=__has_attribute__(STR)");
806 cpp_define (pfile
, "__has_cpp_attribute(STR)=__has_attribute__(STR)");
808 if (c_dialect_cxx ())
810 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
811 cpp_define (pfile
, "__GXX_WEAK__=1");
813 cpp_define (pfile
, "__GXX_WEAK__=0");
816 cpp_define (pfile
, "__DEPRECATED");
820 cpp_define (pfile
, "__GXX_RTTI");
821 cpp_define (pfile
, "__cpp_rtti=199711");
824 if (cxx_dialect
>= cxx11
)
825 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
827 /* Binary literals have been allowed in g++ before C++11
828 and were standardized for C++14. */
829 if (!pedantic
|| cxx_dialect
> cxx11
)
830 cpp_define (pfile
, "__cpp_binary_literals=201304");
832 /* Arrays of runtime bound were removed from C++14, but we still
833 support GNU VLAs. Let's define this macro to a low number
834 (corresponding to the initial test release of GNU C++) if we won't
835 complain about use of VLAs. */
837 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
838 cpp_define (pfile
, "__cpp_runtime_arrays=198712");
840 if (cxx_dialect
>= cxx11
)
842 /* Set feature test macros for C++11 */
843 cpp_define (pfile
, "__cpp_unicode_characters=200704");
844 cpp_define (pfile
, "__cpp_raw_strings=200710");
845 cpp_define (pfile
, "__cpp_unicode_literals=200710");
846 cpp_define (pfile
, "__cpp_user_defined_literals=200809");
847 cpp_define (pfile
, "__cpp_lambdas=200907");
848 if (cxx_dialect
== cxx11
)
849 cpp_define (pfile
, "__cpp_constexpr=200704");
850 cpp_define (pfile
, "__cpp_range_based_for=200907");
851 cpp_define (pfile
, "__cpp_static_assert=200410");
852 cpp_define (pfile
, "__cpp_decltype=200707");
853 cpp_define (pfile
, "__cpp_attributes=200809");
854 cpp_define (pfile
, "__cpp_rvalue_reference=200610");
855 cpp_define (pfile
, "__cpp_variadic_templates=200704");
856 cpp_define (pfile
, "__cpp_initializer_lists=200806");
857 cpp_define (pfile
, "__cpp_delegating_constructors=200604");
858 cpp_define (pfile
, "__cpp_nsdmi=200809");
859 cpp_define (pfile
, "__cpp_inheriting_constructors=200802");
860 cpp_define (pfile
, "__cpp_ref_qualifiers=200710");
861 cpp_define (pfile
, "__cpp_alias_templates=200704");
863 if (cxx_dialect
> cxx11
)
865 /* Set feature test macros for C++14 */
866 cpp_define (pfile
, "__cpp_return_type_deduction=201304");
867 cpp_define (pfile
, "__cpp_init_captures=201304");
868 cpp_define (pfile
, "__cpp_generic_lambdas=201304");
869 cpp_define (pfile
, "__cpp_constexpr=201304");
870 cpp_define (pfile
, "__cpp_decltype_auto=201304");
871 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304");
872 cpp_define (pfile
, "__cpp_variable_templates=201304");
873 cpp_define (pfile
, "__cpp_digit_separators=201309");
874 //cpp_define (pfile, "__cpp_sized_deallocation=201309");
877 /* Note that we define this for C as well, so that we know if
878 __attribute__((cleanup)) will interface with EH. */
881 cpp_define (pfile
, "__EXCEPTIONS");
882 if (c_dialect_cxx ())
883 cpp_define (pfile
, "__cpp_exceptions=199711");
886 /* Represents the C++ ABI version, always defined so it can be used while
887 preprocessing C and assembler. */
888 if (flag_abi_version
== 0)
889 /* Use a very large value so that:
891 #if __GXX_ABI_VERSION >= <value for version X>
893 will work whether the user explicitly says "-fabi-version=x" or
894 "-fabi-version=0". Do not use INT_MAX because that will be
895 different from system to system. */
896 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
897 else if (flag_abi_version
== 1)
898 /* Due to a historical accident, this version had the value
900 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
902 /* Newer versions have values 1002, 1003, .... */
903 builtin_define_with_int_value ("__GXX_ABI_VERSION",
904 1000 + flag_abi_version
);
906 /* libgcc needs to know this. */
907 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
908 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
910 /* limits.h and stdint.h need to know these. */
911 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
912 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
913 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
914 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
915 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
916 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
917 underlying_wchar_type_node
);
918 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
919 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
920 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
922 if (c_dialect_cxx ())
923 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
924 if (int_n_enabled_p
[i
])
928 /* These are used to configure the C++ library. */
930 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
932 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
933 cpp_define (parse_in
, buf
);
935 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
936 cpp_define (parse_in
, buf
);
940 /* stdint.h and the testsuite need to know these. */
941 builtin_define_stdint_macros ();
943 /* Provide information for library headers to determine whether to
944 define macros such as __STDC_IEC_559__ and
945 __STDC_IEC_559_COMPLEX__. */
946 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
947 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
948 cpp_iec_559_complex_value ());
950 /* float.h needs to know this. */
951 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
952 TARGET_FLT_EVAL_METHOD
);
954 /* And decfloat.h needs this. */
955 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
956 TARGET_DEC_EVAL_METHOD
);
958 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
959 /* Cast the double precision constants. This is needed when single
960 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
961 is used. The correct result is computed by the compiler when using
962 macros that include a cast. We use a different cast for C++ to avoid
963 problems with -Wold-style-cast. */
964 builtin_define_float_constants ("DBL", "L",
968 "", double_type_node
);
969 builtin_define_float_constants ("LDBL", "L", "%s", "L",
970 long_double_type_node
);
972 /* For decfloat.h. */
973 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
974 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
975 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
977 /* For fixed-point fibt, ibit, max, min, and epsilon. */
978 if (targetm
.fixed_point_supported_p ())
980 builtin_define_fixed_point_constants ("SFRACT", "HR",
981 short_fract_type_node
);
982 builtin_define_fixed_point_constants ("USFRACT", "UHR",
983 unsigned_short_fract_type_node
);
984 builtin_define_fixed_point_constants ("FRACT", "R",
986 builtin_define_fixed_point_constants ("UFRACT", "UR",
987 unsigned_fract_type_node
);
988 builtin_define_fixed_point_constants ("LFRACT", "LR",
989 long_fract_type_node
);
990 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
991 unsigned_long_fract_type_node
);
992 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
993 long_long_fract_type_node
);
994 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
995 unsigned_long_long_fract_type_node
);
996 builtin_define_fixed_point_constants ("SACCUM", "HK",
997 short_accum_type_node
);
998 builtin_define_fixed_point_constants ("USACCUM", "UHK",
999 unsigned_short_accum_type_node
);
1000 builtin_define_fixed_point_constants ("ACCUM", "K",
1002 builtin_define_fixed_point_constants ("UACCUM", "UK",
1003 unsigned_accum_type_node
);
1004 builtin_define_fixed_point_constants ("LACCUM", "LK",
1005 long_accum_type_node
);
1006 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1007 unsigned_long_accum_type_node
);
1008 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1009 long_long_accum_type_node
);
1010 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1011 unsigned_long_long_accum_type_node
);
1013 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1014 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1015 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1016 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1017 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1018 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1019 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1020 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1021 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1022 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1023 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1024 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1025 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1026 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1027 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1028 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1029 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1030 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1033 /* For libgcc-internal use only. */
1034 if (flag_building_libgcc
)
1036 /* Properties of floating-point modes for libgcc2.c. */
1037 for (machine_mode mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
);
1039 mode
= GET_MODE_WIDER_MODE (mode
))
1041 const char *name
= GET_MODE_NAME (mode
);
1043 = (char *) alloca (strlen (name
)
1044 + sizeof ("__LIBGCC__MANT_DIG__"));
1045 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1046 builtin_define_with_int_value (macro_name
,
1047 REAL_MODE_FORMAT (mode
)->p
);
1048 if (!targetm
.scalar_mode_supported_p (mode
)
1049 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1051 macro_name
= (char *) alloca (strlen (name
)
1052 + sizeof ("__LIBGCC_HAS__MODE__"));
1053 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1054 cpp_define (pfile
, macro_name
);
1055 macro_name
= (char *) alloca (strlen (name
)
1056 + sizeof ("__LIBGCC__FUNC_EXT__"));
1057 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1059 if (mode
== TYPE_MODE (double_type_node
))
1061 else if (mode
== TYPE_MODE (float_type_node
))
1063 else if (mode
== TYPE_MODE (long_double_type_node
))
1065 /* ??? The following assumes the built-in functions (defined
1066 in target-specific code) match the suffixes used for
1067 constants. Because in fact such functions are not
1068 defined for the 'w' suffix, 'l' is used there
1070 else if (mode
== targetm
.c
.mode_for_suffix ('q'))
1072 else if (mode
== targetm
.c
.mode_for_suffix ('w'))
1076 builtin_define_with_value (macro_name
, suffix
, 0);
1077 bool excess_precision
= false;
1078 if (TARGET_FLT_EVAL_METHOD
!= 0
1079 && mode
!= TYPE_MODE (long_double_type_node
)
1080 && (mode
== TYPE_MODE (float_type_node
)
1081 || mode
== TYPE_MODE (double_type_node
)))
1082 switch (TARGET_FLT_EVAL_METHOD
)
1086 excess_precision
= true;
1090 excess_precision
= mode
== TYPE_MODE (float_type_node
);
1096 macro_name
= (char *) alloca (strlen (name
)
1097 + sizeof ("__LIBGCC__EXCESS_"
1099 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1100 builtin_define_with_int_value (macro_name
, excess_precision
);
1103 /* For libgcc crtstuff.c and libgcc2.c. */
1104 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1105 EH_TABLES_CAN_BE_READ_ONLY
);
1106 #ifdef EH_FRAME_SECTION_NAME
1107 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1108 EH_FRAME_SECTION_NAME
, 1);
1110 #ifdef JCR_SECTION_NAME
1111 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
1112 JCR_SECTION_NAME
, 1);
1114 #ifdef CTORS_SECTION_ASM_OP
1115 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1116 CTORS_SECTION_ASM_OP
, 1);
1118 #ifdef DTORS_SECTION_ASM_OP
1119 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1120 DTORS_SECTION_ASM_OP
, 1);
1122 #ifdef TEXT_SECTION_ASM_OP
1123 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1124 TEXT_SECTION_ASM_OP
, 1);
1126 #ifdef INIT_SECTION_ASM_OP
1127 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1128 INIT_SECTION_ASM_OP
, 1);
1130 #ifdef INIT_ARRAY_SECTION_ASM_OP
1131 /* Despite the name of this target macro, the expansion is not
1132 actually used, and may be empty rather than a string
1134 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1137 /* For libgcc enable-execute-stack.c. */
1138 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1141 /* For libgcc generic-morestack.c and unwinder code. */
1142 #ifdef STACK_GROWS_DOWNWARD
1143 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1146 /* For libgcc unwinder code. */
1147 #ifdef DONT_USE_BUILTIN_SETJMP
1148 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1150 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1151 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1152 DWARF_ALT_FRAME_RETURN_COLUMN
);
1154 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1155 DWARF_FRAME_REGISTERS
);
1156 #ifdef EH_RETURN_STACKADJ_RTX
1157 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1160 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1163 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1164 STACK_POINTER_REGNUM
);
1167 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1168 TARGET_VTABLE_USES_DESCRIPTORS
);
1171 /* For use in assembly language. */
1172 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1173 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1176 if (flag_gnu89_inline
)
1177 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1179 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1182 cpp_define (pfile
, "__NO_INLINE__");
1185 cpp_define (pfile
, "__STRICT_ANSI__");
1187 if (!flag_signed_char
)
1188 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1190 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1191 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1193 cpp_atomic_builtins (pfile
);
1195 #ifdef DWARF2_UNWIND_INFO
1196 if (dwarf2out_do_cfi_asm ())
1197 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1200 /* Make the choice of ObjC runtime visible to source code. */
1201 if (c_dialect_objc () && flag_next_runtime
)
1202 cpp_define (pfile
, "__NEXT_RUNTIME__");
1204 /* Show the availability of some target pragmas. */
1205 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1207 /* Make the choice of the stack protector runtime visible to source code.
1208 The macro names and values here were chosen for compatibility with an
1209 earlier implementation, i.e. ProPolice. */
1210 if (flag_stack_protect
== 3)
1211 cpp_define (pfile
, "__SSP_STRONG__=3");
1212 if (flag_stack_protect
== 2)
1213 cpp_define (pfile
, "__SSP_ALL__=2");
1214 else if (flag_stack_protect
== 1)
1215 cpp_define (pfile
, "__SSP__=1");
1218 cpp_define (pfile
, "_OPENACC=201306");
1221 cpp_define (pfile
, "_OPENMP=201307");
1223 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1224 if (int_n_enabled_p
[i
])
1227 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1228 builtin_define_type_sizeof (buf
,
1229 int_n_trees
[i
].signed_type
);
1231 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1232 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1233 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1234 unsigned_ptrdiff_type_node
);
1236 /* A straightforward target hook doesn't work, because of problems
1237 linking that hook's body when part of non-C front ends. */
1238 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1239 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1240 # define builtin_define(TXT) cpp_define (pfile, TXT)
1241 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1242 TARGET_CPU_CPP_BUILTINS ();
1243 TARGET_OS_CPP_BUILTINS ();
1244 TARGET_OBJFMT_CPP_BUILTINS ();
1246 /* Support the __declspec keyword by turning them into attributes.
1247 Note that the current way we do this may result in a collision
1248 with predefined attributes later on. This can be solved by using
1249 one attribute, say __declspec__, and passing args to it. The
1250 problem with that approach is that args are not accumulated: each
1251 new appearance would clobber any existing args. */
1252 if (TARGET_DECLSPEC
)
1253 builtin_define ("__declspec(x)=__attribute__((x))");
1255 /* If decimal floating point is supported, tell the user if the
1256 alternate format (BID) is used instead of the standard (DPD)
1258 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1259 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1262 /* Pass an object-like macro. If it doesn't lie in the user's
1263 namespace, defines it unconditionally. Otherwise define a version
1264 with two leading underscores, and another version with two leading
1265 and trailing underscores, and define the original only if an ISO
1266 standard was not nominated.
1268 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1269 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1272 builtin_define_std (const char *macro
)
1274 size_t len
= strlen (macro
);
1275 char *buff
= (char *) alloca (len
+ 5);
1279 /* prepend __ (or maybe just _) if in user's namespace. */
1280 memcpy (p
, macro
, len
+ 1);
1281 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1288 cpp_define (parse_in
, p
);
1290 /* If it was in user's namespace... */
1293 /* Define the macro with leading and following __. */
1299 cpp_define (parse_in
, p
);
1301 /* Finally, define the original macro if permitted. */
1303 cpp_define (parse_in
, macro
);
1307 /* Pass an object-like macro and a value to define it to. The third
1308 parameter says whether or not to turn the value into a string
1311 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1314 size_t mlen
= strlen (macro
);
1315 size_t elen
= strlen (expansion
);
1316 size_t extra
= 2; /* space for an = and a NUL */
1320 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1323 extra
+= 2; /* space for two quote marks */
1324 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1349 if (ISPRINT ((unsigned char) *p
))
1353 sprintf (q
, "\\%03o", (unsigned char) *p
);
1359 expansion
= quoted_expansion
;
1360 elen
= q
- expansion
;
1363 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1365 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1367 sprintf (buf
, "%s=%s", macro
, expansion
);
1369 cpp_define (parse_in
, buf
);
1373 /* Pass an object-like macro and an integer value to define it to. */
1375 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1378 size_t mlen
= strlen (macro
);
1380 size_t extra
= 2; /* space for = and NUL. */
1382 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1383 memcpy (buf
, macro
, mlen
);
1385 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1387 cpp_define (parse_in
, buf
);
1390 /* builtin_define_with_hex_fp_value is very expensive, so the following
1391 array and function allows it to be done lazily when __DBL_MAX__
1392 etc. is first used. */
1394 struct GTY(()) lazy_hex_fp_value_struct
1396 const char *hex_str
;
1400 const char *fp_suffix
;
1402 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1403 static GTY(()) int lazy_hex_fp_value_count
;
1406 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1409 REAL_VALUE_TYPE real
;
1410 char dec_str
[64], buf1
[256];
1412 if (node
->value
.builtin
< BT_FIRST_USER
1413 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1416 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1417 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1418 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1419 lazy_hex_fp_values
[idx
].digits
, 0,
1420 lazy_hex_fp_values
[idx
].mode
);
1422 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1423 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1424 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1425 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1426 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1428 gcc_assert (idx
< node
->value
.macro
->count
);
1429 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1430 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1431 = (const unsigned char *) ggc_strdup (buf1
);
1435 /* Pass an object-like macro a hexadecimal floating-point value. */
1437 builtin_define_with_hex_fp_value (const char *macro
,
1438 tree type
, int digits
,
1439 const char *hex_str
,
1440 const char *fp_suffix
,
1441 const char *fp_cast
)
1443 REAL_VALUE_TYPE real
;
1444 char dec_str
[64], buf1
[256], buf2
[256];
1446 /* This is very expensive, so if possible expand them lazily. */
1447 if (lazy_hex_fp_value_count
< 12
1448 && flag_dump_macros
== 0
1449 && !cpp_get_options (parse_in
)->traditional
)
1451 struct cpp_hashnode
*node
;
1452 if (lazy_hex_fp_value_count
== 0)
1453 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1454 sprintf (buf2
, fp_cast
, "1.1");
1455 sprintf (buf1
, "%s=%s", macro
, buf2
);
1456 cpp_define (parse_in
, buf1
);
1457 node
= C_CPP_HASHNODE (get_identifier (macro
));
1458 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1459 = ggc_strdup (hex_str
);
1460 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1461 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1462 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1463 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1464 node
->flags
|= NODE_BUILTIN
;
1466 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1467 lazy_hex_fp_value_count
++;
1471 /* Hex values are really cool and convenient, except that they're
1472 not supported in strict ISO C90 mode. First, the "p-" sequence
1473 is not valid as part of a preprocessor number. Second, we get a
1474 pedwarn from the preprocessor, which has no context, so we can't
1475 suppress the warning with __extension__.
1477 So instead what we do is construct the number in hex (because
1478 it's easy to get the exact correct value), parse it as a real,
1479 then print it back out as decimal. */
1481 real_from_string (&real
, hex_str
);
1482 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1485 /* Assemble the macro in the following fashion
1486 macro = fp_cast [dec_str fp_suffix] */
1487 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1488 sprintf (buf2
, fp_cast
, buf1
);
1489 sprintf (buf1
, "%s=%s", macro
, buf2
);
1491 cpp_define (parse_in
, buf1
);
1494 /* Return a string constant for the suffix for a value of type TYPE
1495 promoted according to the integer promotions. The type must be one
1496 of the standard integer type nodes. */
1499 type_suffix (tree type
)
1501 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1502 int unsigned_suffix
;
1504 int tp
= TYPE_PRECISION (type
);
1506 if (type
== long_long_integer_type_node
1507 || type
== long_long_unsigned_type_node
1508 || tp
> TYPE_PRECISION (long_integer_type_node
))
1510 else if (type
== long_integer_type_node
1511 || type
== long_unsigned_type_node
1512 || tp
> TYPE_PRECISION (integer_type_node
))
1514 else if (type
== integer_type_node
1515 || type
== unsigned_type_node
1516 || type
== short_integer_type_node
1517 || type
== short_unsigned_type_node
1518 || type
== signed_char_type_node
1519 || type
== unsigned_char_type_node
1520 /* ??? "char" is not a signed or unsigned integer type and
1521 so is not permitted for the standard typedefs, but some
1522 systems use it anyway. */
1523 || type
== char_type_node
)
1528 unsigned_suffix
= TYPE_UNSIGNED (type
);
1529 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1530 unsigned_suffix
= 0;
1531 return suffixes
[is_long
* 2 + unsigned_suffix
];
1534 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1536 builtin_define_constants (const char *macro
, tree type
)
1541 suffix
= type_suffix (type
);
1545 buf
= (char *) alloca (strlen (macro
) + 6);
1546 sprintf (buf
, "%s(c)=c", macro
);
1550 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1551 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1554 cpp_define (parse_in
, buf
);
1557 /* Define MAX for TYPE based on the precision of the type. */
1560 builtin_define_type_max (const char *macro
, tree type
)
1562 builtin_define_type_minmax (NULL
, macro
, type
);
1565 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1566 representation of that value. For example, a COUNT of 10 would
1570 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1572 gcc_assert (bufsz
> 3);
1577 gcc_assert (count
> 0);
1579 switch (count
% 4) {
1600 gcc_assert (bufsz
> 1);
1605 gcc_assert (bufsz
> 0);
1609 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1610 precision of the type. */
1613 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1616 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1617 char value
[PBOH_SZ
];
1623 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1625 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1627 suffix
= type_suffix (type
);
1629 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1630 + strlen (suffix
) + 1);
1631 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1633 cpp_define (parse_in
, buf
);
1637 if (TYPE_UNSIGNED (type
))
1639 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1640 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1644 buf
= (char *) alloca (strlen (min_macro
) + 3
1645 + strlen (max_macro
) + 6);
1646 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1648 cpp_define (parse_in
, buf
);
1652 #include "gt-c-family-c-cppbuiltin.h"