1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
27 #include "stringpool.h"
28 #include "stor-layout.h"
31 #include "output.h" /* For user_label_prefix. */
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
33 #include "common/common-target.h"
34 #include "cppbuiltin.h"
36 #ifndef TARGET_OS_CPP_BUILTINS
37 # define TARGET_OS_CPP_BUILTINS()
40 #ifndef TARGET_OBJFMT_CPP_BUILTINS
41 # define TARGET_OBJFMT_CPP_BUILTINS()
44 #ifndef REGISTER_PREFIX
45 #define REGISTER_PREFIX ""
48 /* Non-static as some targets don't use it. */
49 static void builtin_define_with_hex_fp_value (const char *, tree
,
53 static void builtin_define_stdint_macros (void);
54 static void builtin_define_constants (const char *, tree
);
55 static void builtin_define_type_max (const char *, tree
);
56 static void builtin_define_type_minmax (const char *, const char *, tree
);
57 static void builtin_define_type_width (const char *, tree
, tree
);
58 static void builtin_define_float_constants (const char *,
64 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
65 Originally this function used the fma optab, but that doesn't work with
66 -save-temps, so just rely on the HAVE_fma macros for the standard floating
70 mode_has_fma (machine_mode mode
)
84 #ifdef HAVE_fmakf4 /* PowerPC if long double != __float128. */
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
*widefmt
;
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 widefmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
144 gcc_assert (widefmt
->b
!= 10);
145 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
147 tree wtype
= FLOATN_NX_TYPE_NODE (i
);
148 if (wtype
!= NULL_TREE
)
150 const struct real_format
*wfmt
151 = REAL_MODE_FORMAT (TYPE_MODE (wtype
));
152 gcc_assert (wfmt
->b
!= 10);
153 if (wfmt
->p
> widefmt
->p
)
158 /* The radix of the exponent representation. */
159 if (type
== float_type_node
)
160 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
163 /* The number of radix digits, p, in the floating-point significand. */
164 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
165 builtin_define_with_int_value (name
, fmt
->p
);
167 /* The number of decimal digits, q, such that any floating-point number
168 with q decimal digits can be rounded into a floating-point number with
169 p radix b digits and back again without change to the q decimal digits,
171 p log10 b if b is a power of 10
172 floor((p - 1) log10 b) otherwise
174 dig
= (fmt
->p
- 1) * log10_b
;
175 sprintf (name
, "__%s_DIG__", name_prefix
);
176 builtin_define_with_int_value (name
, dig
);
178 /* The minimum negative int x such that b**(x-1) is a normalized float. */
179 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
180 sprintf (buf
, "(%d)", fmt
->emin
);
181 builtin_define_with_value (name
, buf
, 0);
183 /* The minimum negative int x such that 10**x is a normalized float,
185 ceil (log10 (b ** (emin - 1)))
186 = ceil (log10 (b) * (emin - 1))
188 Recall that emin is negative, so the integer truncation calculates
189 the ceiling, not the floor, in this case. */
190 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
191 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
192 sprintf (buf
, "(%d)", min_10_exp
);
193 builtin_define_with_value (name
, buf
, 0);
195 /* The maximum int x such that b**(x-1) is a representable float. */
196 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
197 builtin_define_with_int_value (name
, fmt
->emax
);
199 /* The maximum int x such that 10**x is in the range of representable
200 finite floating-point numbers,
202 floor (log10((1 - b**-p) * b**emax))
203 = floor (log10(1 - b**-p) + log10(b**emax))
204 = floor (log10(1 - b**-p) + log10(b)*emax)
206 The safest thing to do here is to just compute this number. But since
207 we don't link cc1 with libm, we cannot. We could implement log10 here
208 a series expansion, but that seems too much effort because:
210 Note that the first term, for all extant p, is a number exceedingly close
211 to zero, but slightly negative. Note that the second term is an integer
212 scaling an irrational number, and that because of the floor we are only
213 interested in its integral portion.
215 In order for the first term to have any effect on the integral portion
216 of the second term, the second term has to be exceedingly close to an
217 integer itself (e.g. 123.000000000001 or something). Getting a result
218 that close to an integer requires that the irrational multiplicand have
219 a long series of zeros in its expansion, which doesn't occur in the
220 first 20 digits or so of log10(b).
222 Hand-waving aside, crunching all of the sets of constants above by hand
223 does not yield a case for which the first term is significant, which
224 in the end is all that matters. */
225 max_10_exp
= fmt
->emax
* log10_b
;
226 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
227 builtin_define_with_int_value (name
, max_10_exp
);
229 /* The number of decimal digits, n, such that any floating-point number
230 can be rounded to n decimal digits and back again without change to
233 p * log10(b) if b is a power of 10
234 ceil(1 + p * log10(b)) otherwise
236 The only macro we care about is this number for the widest supported
237 floating type, but we want this value for rendering constants below. */
240 = 1 + (fmt
->p
< widefmt
->p
? widefmt
->p
: fmt
->p
) * log10_b
;
241 decimal_dig
= d_decimal_dig
;
242 if (decimal_dig
< d_decimal_dig
)
245 /* Similar, for this type rather than long double. */
247 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
248 type_decimal_dig
= type_d_decimal_dig
;
249 if (type_decimal_dig
< type_d_decimal_dig
)
252 /* Define __DECIMAL_DIG__ to the value for long double to be
253 compatible with C99 and C11; see DR#501 and N2108. */
254 if (type
== long_double_type_node
)
255 builtin_define_with_int_value ("__DECIMAL_DIG__", type_decimal_dig
);
256 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
257 builtin_define_with_int_value (name
, type_decimal_dig
);
259 /* Since, for the supported formats, B is always a power of 2, we
260 construct the following numbers directly as a hexadecimal
262 get_max_float (fmt
, buf
, sizeof (buf
));
264 sprintf (name
, "__%s_MAX__", name_prefix
);
265 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
267 /* The minimum normalized positive floating-point number,
269 sprintf (name
, "__%s_MIN__", name_prefix
);
270 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
271 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
273 /* The difference between 1 and the least value greater than 1 that is
274 representable in the given floating point type, b**(1-p). */
275 sprintf (name
, "__%s_EPSILON__", name_prefix
);
276 if (fmt
->pnan
< fmt
->p
)
277 /* This is an IBM extended double format, so 1.0 + any double is
278 representable precisely. */
279 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
281 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
282 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
284 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
285 The minimum denormalized positive floating-point number, b**(emin-p).
286 The minimum normalized positive floating-point number for formats
287 that don't support denormals. */
288 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
289 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
290 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
291 buf
, fp_suffix
, fp_cast
);
293 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
294 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
296 /* For C++ std::numeric_limits<T>::has_infinity. */
297 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
298 builtin_define_with_int_value (name
,
299 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
300 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
301 predicate to distinguish a target that has both quiet and
302 signalling NaNs from a target that has only quiet NaNs or only
303 signalling NaNs, so we assume that a target that has any kind of
304 NaN has quiet NaNs. */
305 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
306 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
308 /* Note whether we have fast FMA. */
309 if (mode_has_fma (TYPE_MODE (type
)) && fma_suffix
!= NULL
)
311 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
312 builtin_define_with_int_value (name
, 1);
316 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
318 builtin_define_decimal_float_constants (const char *name_prefix
,
322 const struct real_format
*fmt
;
323 char name
[64], buf
[128], *p
;
326 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
328 /* The number of radix digits, p, in the significand. */
329 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
330 builtin_define_with_int_value (name
, fmt
->p
);
332 /* The minimum negative int x such that b**(x-1) is a normalized float. */
333 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
334 sprintf (buf
, "(%d)", fmt
->emin
);
335 builtin_define_with_value (name
, buf
, 0);
337 /* The maximum int x such that b**(x-1) is a representable float. */
338 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
339 builtin_define_with_int_value (name
, fmt
->emax
);
341 /* Compute the minimum representable value. */
342 sprintf (name
, "__%s_MIN__", name_prefix
);
343 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
344 builtin_define_with_value (name
, buf
, 0);
346 /* Compute the maximum representable value. */
347 sprintf (name
, "__%s_MAX__", name_prefix
);
349 for (digits
= fmt
->p
; digits
; digits
--)
352 if (digits
== fmt
->p
)
356 /* fmt->p plus 1, to account for the decimal point and fmt->emax
357 minus 1 because the digits are nines, not 1.0. */
358 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
359 builtin_define_with_value (name
, buf
, 0);
361 /* Compute epsilon (the difference between 1 and least value greater
362 than 1 representable). */
363 sprintf (name
, "__%s_EPSILON__", name_prefix
);
364 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
365 builtin_define_with_value (name
, buf
, 0);
367 /* Minimum subnormal positive decimal value. */
368 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
370 for (digits
= fmt
->p
; digits
> 1; digits
--)
373 if (digits
== fmt
->p
)
377 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
378 builtin_define_with_value (name
, buf
, 0);
381 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
384 builtin_define_fixed_point_constants (const char *name_prefix
,
388 char name
[64], buf
[256], *new_buf
;
391 sprintf (name
, "__%s_FBIT__", name_prefix
);
392 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
394 sprintf (name
, "__%s_IBIT__", name_prefix
);
395 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
397 /* If there is no suffix, defines are for fixed-point modes.
399 if (strcmp (suffix
, "") == 0)
402 if (TYPE_UNSIGNED (type
))
404 sprintf (name
, "__%s_MIN__", name_prefix
);
405 sprintf (buf
, "0.0%s", suffix
);
406 builtin_define_with_value (name
, buf
, 0);
410 sprintf (name
, "__%s_MIN__", name_prefix
);
411 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
412 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
413 TYPE_IBIT (type
) - 1, suffix
);
415 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
416 builtin_define_with_value (name
, buf
, 0);
419 sprintf (name
, "__%s_MAX__", name_prefix
);
422 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
424 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
425 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
426 sprintf (new_buf
++, "F");
427 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
428 builtin_define_with_value (name
, buf
, 0);
430 sprintf (name
, "__%s_EPSILON__", name_prefix
);
431 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
432 builtin_define_with_value (name
, buf
, 0);
435 /* Define macros used by <stdint.h>. */
437 builtin_define_stdint_macros (void)
439 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
440 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
441 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
442 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
443 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node
,
445 if (sig_atomic_type_node
)
447 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
448 sig_atomic_type_node
);
449 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node
,
453 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
455 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
457 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
459 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
461 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
462 if (c_uint16_type_node
)
463 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
464 if (c_uint32_type_node
)
465 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
466 if (c_uint64_type_node
)
467 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
468 if (int_least8_type_node
)
470 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
471 builtin_define_constants ("__INT8_C", int_least8_type_node
);
472 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node
,
473 uint_least8_type_node
);
475 if (int_least16_type_node
)
477 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
478 builtin_define_constants ("__INT16_C", int_least16_type_node
);
479 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
480 int_least16_type_node
,
481 uint_least16_type_node
);
483 if (int_least32_type_node
)
485 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
486 builtin_define_constants ("__INT32_C", int_least32_type_node
);
487 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
488 int_least32_type_node
,
489 uint_least32_type_node
);
491 if (int_least64_type_node
)
493 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
494 builtin_define_constants ("__INT64_C", int_least64_type_node
);
495 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
496 int_least64_type_node
,
497 uint_least64_type_node
);
499 if (uint_least8_type_node
)
501 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
502 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
504 if (uint_least16_type_node
)
506 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
507 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
509 if (uint_least32_type_node
)
511 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
512 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
514 if (uint_least64_type_node
)
516 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
517 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
519 if (int_fast8_type_node
)
521 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
522 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node
,
523 uint_fast8_type_node
);
525 if (int_fast16_type_node
)
527 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
528 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node
,
529 uint_fast16_type_node
);
531 if (int_fast32_type_node
)
533 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
534 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node
,
535 uint_fast32_type_node
);
537 if (int_fast64_type_node
)
539 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
540 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node
,
541 uint_fast64_type_node
);
543 if (uint_fast8_type_node
)
544 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
545 if (uint_fast16_type_node
)
546 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
547 if (uint_fast32_type_node
)
548 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
549 if (uint_fast64_type_node
)
550 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
551 if (intptr_type_node
)
553 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
554 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node
,
557 if (uintptr_type_node
)
558 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
561 /* Adjust the optimization macros when a #pragma GCC optimization is done to
562 reflect the current level. */
564 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
567 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
568 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
572 /* -undef turns off target-specific built-ins. */
576 /* Other target-independent built-ins determined by command-line
578 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
579 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
580 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
581 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
583 if (!prev
->x_optimize
&& cur
->x_optimize
)
584 cpp_define (pfile
, "__OPTIMIZE__");
585 else if (prev
->x_optimize
&& !cur
->x_optimize
)
586 cpp_undef (pfile
, "__OPTIMIZE__");
588 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
589 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
590 if (!prev_fast_math
&& cur_fast_math
)
591 cpp_define (pfile
, "__FAST_MATH__");
592 else if (prev_fast_math
&& !cur_fast_math
)
593 cpp_undef (pfile
, "__FAST_MATH__");
595 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
596 cpp_define (pfile
, "__SUPPORT_SNAN__");
597 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
598 cpp_undef (pfile
, "__SUPPORT_SNAN__");
600 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
601 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
602 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
603 cpp_define (pfile
, "__NO_MATH_ERRNO__");
605 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
607 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
608 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
610 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
612 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
613 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
618 /* This function will emit cpp macros to indicate the presence of various lock
619 free atomic operations. */
622 cpp_atomic_builtins (cpp_reader
*pfile
)
624 /* Set a flag for each size of object that compare and swap exists for up to
626 #define SWAP_LIMIT 17
627 bool have_swap
[SWAP_LIMIT
];
630 /* Clear the map of sizes compare_and swap exists for. */
631 memset (have_swap
, 0, sizeof (have_swap
));
633 /* Tell source code if the compiler makes sync_compare_and_swap
634 builtins available. */
635 #ifndef HAVE_sync_compare_and_swapqi
636 #define HAVE_sync_compare_and_swapqi 0
638 #ifndef HAVE_atomic_compare_and_swapqi
639 #define HAVE_atomic_compare_and_swapqi 0
642 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
644 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
648 #ifndef HAVE_sync_compare_and_swaphi
649 #define HAVE_sync_compare_and_swaphi 0
651 #ifndef HAVE_atomic_compare_and_swaphi
652 #define HAVE_atomic_compare_and_swaphi 0
654 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
656 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
660 #ifndef HAVE_sync_compare_and_swapsi
661 #define HAVE_sync_compare_and_swapsi 0
663 #ifndef HAVE_atomic_compare_and_swapsi
664 #define HAVE_atomic_compare_and_swapsi 0
666 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
668 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
672 #ifndef HAVE_sync_compare_and_swapdi
673 #define HAVE_sync_compare_and_swapdi 0
675 #ifndef HAVE_atomic_compare_and_swapdi
676 #define HAVE_atomic_compare_and_swapdi 0
678 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
680 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
684 #ifndef HAVE_sync_compare_and_swapti
685 #define HAVE_sync_compare_and_swapti 0
687 #ifndef HAVE_atomic_compare_and_swapti
688 #define HAVE_atomic_compare_and_swapti 0
690 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
692 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
693 have_swap
[16] = true;
696 /* Tell the source code about various types. These map to the C++11 and C11
697 macros where 2 indicates lock-free always, and 1 indicates sometimes
699 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
700 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
701 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
702 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
703 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
704 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
705 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
706 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
707 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
708 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
709 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
710 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
711 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
712 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
713 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
714 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
715 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
716 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
717 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
718 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
720 /* If we're dealing with a "set" value that doesn't exactly correspond
721 to a boolean truth value, let the library work around that. */
722 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
723 targetm
.atomic_test_and_set_trueval
);
725 /* ptr_type_node can't be used here since ptr_mode is only set when
726 toplev calls backend_init which is not done with -E or pch. */
727 psize
= POINTER_SIZE_UNITS
;
728 if (psize
>= SWAP_LIMIT
)
730 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
731 (have_swap
[psize
]? 2 : 1));
734 /* Return TRUE if the implicit excess precision in which the back-end will
735 compute floating-point calculations is not more than the explicit
736 excess precision that the front-end will apply under
737 -fexcess-precision=[standard|fast].
739 More intuitively, return TRUE if the excess precision proposed by the
740 front-end is the excess precision that will actually be used. */
743 c_cpp_flt_eval_method_iec_559 (void)
745 enum excess_precision_type front_end_ept
746 = (flag_excess_precision_cmdline
== EXCESS_PRECISION_STANDARD
747 ? EXCESS_PRECISION_TYPE_STANDARD
748 : EXCESS_PRECISION_TYPE_FAST
);
750 enum flt_eval_method back_end
751 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
753 enum flt_eval_method front_end
754 = targetm
.c
.excess_precision (front_end_ept
);
756 return excess_precision_mode_join (front_end
, back_end
) == front_end
;
759 /* Return the value for __GCC_IEC_559. */
761 cpp_iec_559_value (void)
763 /* The default is support for IEEE 754-2008. */
766 /* float and double must be binary32 and binary64. If they are but
767 with reversed NaN convention, at most IEEE 754-1985 is
769 const struct real_format
*ffmt
770 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
771 const struct real_format
*dfmt
772 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
773 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
778 || ffmt
->emin
!= -125
780 || ffmt
->signbit_rw
!= 31
781 || ffmt
->round_towards_zero
782 || !ffmt
->has_sign_dependent_rounding
786 || !ffmt
->has_signed_zero
790 || dfmt
->emin
!= -1021
791 || dfmt
->emax
!= 1024
792 || dfmt
->signbit_rw
!= 63
793 || dfmt
->round_towards_zero
794 || !dfmt
->has_sign_dependent_rounding
798 || !dfmt
->has_signed_zero
)
801 /* In strict C standards conformance mode, consider a back-end providing
802 more implicit excess precision than the explicit excess precision
803 the front-end options would require to mean a lack of IEEE 754
804 support. For C++, and outside strict conformance mode, do not consider
805 this to mean a lack of IEEE 754 support. */
809 && !c_cpp_flt_eval_method_iec_559 ())
814 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
817 /* Various options are contrary to IEEE 754 semantics. */
818 if (flag_unsafe_math_optimizations
819 || flag_associative_math
820 || flag_reciprocal_math
821 || flag_finite_math_only
822 || !flag_signed_zeros
823 || flag_single_precision_constant
)
826 /* If the target does not support IEEE 754 exceptions and rounding
827 modes, consider IEEE 754 support to be absent. */
828 if (!targetm
.float_exceptions_rounding_supported_p ())
834 /* Return the value for __GCC_IEC_559_COMPLEX. */
836 cpp_iec_559_complex_value (void)
838 /* The value is no bigger than that of __GCC_IEC_559. */
839 int ret
= cpp_iec_559_value ();
841 /* Some options are contrary to the required default state of the
842 CX_LIMITED_RANGE pragma. */
843 if (flag_complex_method
!= 2)
849 /* Hook that registers front end and target-specific built-ins. */
851 c_cpp_builtins (cpp_reader
*pfile
)
855 /* -undef turns off target-specific built-ins. */
859 define_language_independent_builtin_macros (pfile
);
861 if (c_dialect_cxx ())
864 parse_basever (&major
, NULL
, NULL
);
865 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
868 /* For stddef.h. They require macros defined in c-common.c. */
869 c_stddef_cpp_builtins ();
871 /* Set include test macros for all C/C++ (not for just C++11 etc.)
872 The builtins __has_include__ and __has_include_next__ are defined
874 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
875 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
877 if (c_dialect_cxx ())
879 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
880 cpp_define (pfile
, "__GXX_WEAK__=1");
882 cpp_define (pfile
, "__GXX_WEAK__=0");
885 cpp_define (pfile
, "__DEPRECATED");
889 cpp_define (pfile
, "__GXX_RTTI");
890 cpp_define (pfile
, "__cpp_rtti=199711");
893 if (cxx_dialect
>= cxx11
)
894 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
896 /* Binary literals have been allowed in g++ before C++11
897 and were standardized for C++14. */
898 if (!pedantic
|| cxx_dialect
> cxx11
)
899 cpp_define (pfile
, "__cpp_binary_literals=201304");
901 /* Similarly for hexadecimal floating point literals and C++17. */
902 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
903 cpp_define (pfile
, "__cpp_hex_float=201603");
905 /* Arrays of runtime bound were removed from C++14, but we still
906 support GNU VLAs. Let's define this macro to a low number
907 (corresponding to the initial test release of GNU C++) if we won't
908 complain about use of VLAs. */
910 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
911 cpp_define (pfile
, "__cpp_runtime_arrays=198712");
913 if (cxx_dialect
>= cxx11
)
915 /* Set feature test macros for C++11. */
916 if (cxx_dialect
<= cxx14
)
917 cpp_define (pfile
, "__cpp_unicode_characters=200704");
918 cpp_define (pfile
, "__cpp_raw_strings=200710");
919 cpp_define (pfile
, "__cpp_unicode_literals=200710");
920 cpp_define (pfile
, "__cpp_user_defined_literals=200809");
921 cpp_define (pfile
, "__cpp_lambdas=200907");
922 if (cxx_dialect
== cxx11
)
923 cpp_define (pfile
, "__cpp_constexpr=200704");
924 if (cxx_dialect
<= cxx14
)
925 cpp_define (pfile
, "__cpp_range_based_for=200907");
926 if (cxx_dialect
<= cxx14
)
927 cpp_define (pfile
, "__cpp_static_assert=200410");
928 cpp_define (pfile
, "__cpp_decltype=200707");
929 cpp_define (pfile
, "__cpp_attributes=200809");
930 cpp_define (pfile
, "__cpp_rvalue_reference=200610");
931 cpp_define (pfile
, "__cpp_rvalue_references=200610");
932 cpp_define (pfile
, "__cpp_variadic_templates=200704");
933 cpp_define (pfile
, "__cpp_initializer_lists=200806");
934 cpp_define (pfile
, "__cpp_delegating_constructors=200604");
935 cpp_define (pfile
, "__cpp_nsdmi=200809");
936 if (!flag_new_inheriting_ctors
)
937 cpp_define (pfile
, "__cpp_inheriting_constructors=200802");
939 cpp_define (pfile
, "__cpp_inheriting_constructors=201511");
940 cpp_define (pfile
, "__cpp_ref_qualifiers=200710");
941 cpp_define (pfile
, "__cpp_alias_templates=200704");
943 if (cxx_dialect
> cxx11
)
945 /* Set feature test macros for C++14. */
946 cpp_define (pfile
, "__cpp_return_type_deduction=201304");
947 cpp_define (pfile
, "__cpp_init_captures=201304");
948 cpp_define (pfile
, "__cpp_generic_lambdas=201304");
949 if (cxx_dialect
<= cxx14
)
950 cpp_define (pfile
, "__cpp_constexpr=201304");
951 cpp_define (pfile
, "__cpp_decltype_auto=201304");
952 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304");
953 cpp_define (pfile
, "__cpp_variable_templates=201304");
954 cpp_define (pfile
, "__cpp_digit_separators=201309");
956 if (cxx_dialect
> cxx14
)
958 /* Set feature test macros for C++17. */
959 cpp_define (pfile
, "__cpp_unicode_characters=201411");
960 cpp_define (pfile
, "__cpp_static_assert=201411");
961 cpp_define (pfile
, "__cpp_namespace_attributes=201411");
962 cpp_define (pfile
, "__cpp_enumerator_attributes=201411");
963 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411");
964 cpp_define (pfile
, "__cpp_fold_expressions=201603");
965 cpp_define (pfile
, "__cpp_nontype_template_args=201411");
966 cpp_define (pfile
, "__cpp_range_based_for=201603");
967 cpp_define (pfile
, "__cpp_constexpr=201603");
968 cpp_define (pfile
, "__cpp_if_constexpr=201606");
969 cpp_define (pfile
, "__cpp_capture_star_this=201603");
970 cpp_define (pfile
, "__cpp_inline_variables=201606");
971 cpp_define (pfile
, "__cpp_aggregate_bases=201603");
972 cpp_define (pfile
, "__cpp_deduction_guides=201703");
973 cpp_define (pfile
, "__cpp_noexcept_function_type=201510");
974 cpp_define (pfile
, "__cpp_template_auto=201606");
975 cpp_define (pfile
, "__cpp_structured_bindings=201606");
976 cpp_define (pfile
, "__cpp_variadic_using=201611");
978 if (cxx_dialect
> cxx17
)
980 /* Set feature test macros for C++2a. */
981 cpp_define (pfile
, "__cpp_explicit_bool=201806");
982 cpp_define (pfile
, "__cpp_nontype_template_parameter_class=201806");
985 cpp_define (pfile
, "__cpp_concepts=201507");
987 /* Use a value smaller than the 201505 specified in
988 the TS, since we don't yet support atomic_cancel. */
989 cpp_define (pfile
, "__cpp_transactional_memory=201500");
990 if (flag_sized_deallocation
)
991 cpp_define (pfile
, "__cpp_sized_deallocation=201309");
992 if (aligned_new_threshold
)
994 cpp_define (pfile
, "__cpp_aligned_new=201606");
995 cpp_define_formatted (pfile
, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
996 aligned_new_threshold
);
999 cpp_define (pfile
, "__cpp_template_template_args=201611");
1000 if (flag_threadsafe_statics
)
1001 cpp_define (pfile
, "__cpp_threadsafe_static_init=200806");
1003 /* Note that we define this for C as well, so that we know if
1004 __attribute__((cleanup)) will interface with EH. */
1005 if (flag_exceptions
)
1007 cpp_define (pfile
, "__EXCEPTIONS");
1008 if (c_dialect_cxx ())
1009 cpp_define (pfile
, "__cpp_exceptions=199711");
1012 /* Represents the C++ ABI version, always defined so it can be used while
1013 preprocessing C and assembler. */
1014 if (flag_abi_version
== 0)
1015 /* We should have set this to something real in c_common_post_options. */
1017 else if (flag_abi_version
== 1)
1018 /* Due to a historical accident, this version had the value
1020 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1022 /* Newer versions have values 1002, 1003, .... */
1023 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1024 1000 + flag_abi_version
);
1026 /* libgcc needs to know this. */
1027 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1028 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
1030 /* limits.h and stdint.h need to know these. */
1031 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
1032 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
1033 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
1034 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
1035 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
1036 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1037 underlying_wchar_type_node
);
1038 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
1039 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
1040 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
1042 /* These are needed for TS 18661-1. */
1043 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node
,
1044 unsigned_char_type_node
);
1045 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node
,
1046 short_unsigned_type_node
);
1047 builtin_define_type_width ("__INT_WIDTH__", integer_type_node
,
1048 unsigned_type_node
);
1049 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node
,
1050 long_unsigned_type_node
);
1051 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1052 long_long_integer_type_node
,
1053 long_long_unsigned_type_node
);
1054 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node
,
1056 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node
, NULL_TREE
);
1057 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node
, NULL_TREE
);
1058 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node
, NULL_TREE
);
1060 if (c_dialect_cxx ())
1061 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1062 if (int_n_enabled_p
[i
])
1066 /* These are used to configure the C++ library. */
1068 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
1070 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
1071 cpp_define (parse_in
, buf
);
1073 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
1074 cpp_define (parse_in
, buf
);
1078 /* stdint.h and the testsuite need to know these. */
1079 builtin_define_stdint_macros ();
1081 /* Provide information for library headers to determine whether to
1082 define macros such as __STDC_IEC_559__ and
1083 __STDC_IEC_559_COMPLEX__. */
1084 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1085 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1086 cpp_iec_559_complex_value ());
1088 /* float.h needs these to correctly set FLT_EVAL_METHOD
1090 We define two values:
1093 Which, depending on the value given for
1094 -fpermitted-flt-eval-methods, may be limited to only those values
1095 for FLT_EVAL_METHOD defined in C99/C11.
1097 __FLT_EVAL_METHOD_TS_18661_3__
1098 Which always permits the values for FLT_EVAL_METHOD defined in
1099 ISO/IEC TS 18661-3. */
1100 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1101 c_flt_eval_method (true));
1102 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1103 c_flt_eval_method (false));
1105 /* And decfloat.h needs this. */
1106 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1107 TARGET_DEC_EVAL_METHOD
);
1109 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
1110 /* Cast the double precision constants. This is needed when single
1111 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1112 is used. The correct result is computed by the compiler when using
1113 macros that include a cast. We use a different cast for C++ to avoid
1114 problems with -Wold-style-cast. */
1115 builtin_define_float_constants ("DBL", "L",
1119 "", double_type_node
);
1120 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1121 long_double_type_node
);
1123 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1125 if (FLOATN_NX_TYPE_NODE (i
) == NULL_TREE
)
1127 char prefix
[20], csuffix
[20];
1128 sprintf (prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1129 floatn_nx_types
[i
].extended
? "X" : "");
1130 sprintf (csuffix
, "F%d%s", floatn_nx_types
[i
].n
,
1131 floatn_nx_types
[i
].extended
? "x" : "");
1132 builtin_define_float_constants (prefix
, ggc_strdup (csuffix
), "%s",
1133 csuffix
, FLOATN_NX_TYPE_NODE (i
));
1136 /* For decfloat.h. */
1137 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
1138 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
1139 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
1141 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1142 if (targetm
.fixed_point_supported_p ())
1144 builtin_define_fixed_point_constants ("SFRACT", "HR",
1145 short_fract_type_node
);
1146 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1147 unsigned_short_fract_type_node
);
1148 builtin_define_fixed_point_constants ("FRACT", "R",
1150 builtin_define_fixed_point_constants ("UFRACT", "UR",
1151 unsigned_fract_type_node
);
1152 builtin_define_fixed_point_constants ("LFRACT", "LR",
1153 long_fract_type_node
);
1154 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1155 unsigned_long_fract_type_node
);
1156 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1157 long_long_fract_type_node
);
1158 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1159 unsigned_long_long_fract_type_node
);
1160 builtin_define_fixed_point_constants ("SACCUM", "HK",
1161 short_accum_type_node
);
1162 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1163 unsigned_short_accum_type_node
);
1164 builtin_define_fixed_point_constants ("ACCUM", "K",
1166 builtin_define_fixed_point_constants ("UACCUM", "UK",
1167 unsigned_accum_type_node
);
1168 builtin_define_fixed_point_constants ("LACCUM", "LK",
1169 long_accum_type_node
);
1170 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1171 unsigned_long_accum_type_node
);
1172 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1173 long_long_accum_type_node
);
1174 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1175 unsigned_long_long_accum_type_node
);
1177 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1178 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1179 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1180 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1181 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1182 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1183 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1184 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1185 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1186 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1187 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1188 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1189 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1190 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1191 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1192 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1193 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1194 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1197 /* For libgcc-internal use only. */
1198 if (flag_building_libgcc
)
1200 /* Properties of floating-point modes for libgcc2.c. */
1201 opt_scalar_float_mode mode_iter
;
1202 FOR_EACH_MODE_IN_CLASS (mode_iter
, MODE_FLOAT
)
1204 scalar_float_mode mode
= mode_iter
.require ();
1205 const char *name
= GET_MODE_NAME (mode
);
1207 = (char *) alloca (strlen (name
)
1208 + sizeof ("__LIBGCC__MANT_DIG__"));
1209 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1210 builtin_define_with_int_value (macro_name
,
1211 REAL_MODE_FORMAT (mode
)->p
);
1212 if (!targetm
.scalar_mode_supported_p (mode
)
1213 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1215 macro_name
= (char *) alloca (strlen (name
)
1216 + sizeof ("__LIBGCC_HAS__MODE__"));
1217 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1218 cpp_define (pfile
, macro_name
);
1219 macro_name
= (char *) alloca (strlen (name
)
1220 + sizeof ("__LIBGCC__FUNC_EXT__"));
1221 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1222 char suffix
[20] = "";
1223 if (mode
== TYPE_MODE (double_type_node
))
1224 ; /* Empty suffix correct. */
1225 else if (mode
== TYPE_MODE (float_type_node
))
1227 else if (mode
== TYPE_MODE (long_double_type_node
))
1231 bool found_suffix
= false;
1232 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1233 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
1234 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
1236 sprintf (suffix
, "f%d%s", floatn_nx_types
[i
].n
,
1237 floatn_nx_types
[i
].extended
? "x" : "");
1238 found_suffix
= true;
1241 gcc_assert (found_suffix
);
1243 builtin_define_with_value (macro_name
, suffix
, 0);
1245 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1246 eliminating excess precision from results assigned to
1247 variables - meaning it should be about the implicit excess
1249 bool excess_precision
= false;
1250 machine_mode float16_type_mode
= (float16_type_node
1251 ? TYPE_MODE (float16_type_node
)
1253 switch (targetm
.c
.excess_precision
1254 (EXCESS_PRECISION_TYPE_IMPLICIT
))
1256 case FLT_EVAL_METHOD_UNPREDICTABLE
:
1257 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
1258 excess_precision
= (mode
== float16_type_mode
1259 || mode
== TYPE_MODE (float_type_node
)
1260 || mode
== TYPE_MODE (double_type_node
));
1263 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
1264 excess_precision
= (mode
== float16_type_mode
1265 || mode
== TYPE_MODE (float_type_node
));
1267 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
1268 excess_precision
= mode
== float16_type_mode
;
1270 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
:
1271 excess_precision
= false;
1276 macro_name
= (char *) alloca (strlen (name
)
1277 + sizeof ("__LIBGCC__EXCESS_"
1279 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1280 builtin_define_with_int_value (macro_name
, excess_precision
);
1283 /* For libgcc crtstuff.c and libgcc2.c. */
1284 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1285 EH_TABLES_CAN_BE_READ_ONLY
);
1286 #ifdef EH_FRAME_SECTION_NAME
1287 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1288 EH_FRAME_SECTION_NAME
, 1);
1290 #ifdef CTORS_SECTION_ASM_OP
1291 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1292 CTORS_SECTION_ASM_OP
, 1);
1294 #ifdef DTORS_SECTION_ASM_OP
1295 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1296 DTORS_SECTION_ASM_OP
, 1);
1298 #ifdef TEXT_SECTION_ASM_OP
1299 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1300 TEXT_SECTION_ASM_OP
, 1);
1302 #ifdef INIT_SECTION_ASM_OP
1303 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1304 INIT_SECTION_ASM_OP
, 1);
1306 #ifdef INIT_ARRAY_SECTION_ASM_OP
1307 /* Despite the name of this target macro, the expansion is not
1308 actually used, and may be empty rather than a string
1310 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1313 /* For libgcc enable-execute-stack.c. */
1314 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1317 /* For libgcc generic-morestack.c and unwinder code. */
1318 if (STACK_GROWS_DOWNWARD
)
1319 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1321 /* For libgcc unwinder code. */
1322 #ifdef DONT_USE_BUILTIN_SETJMP
1323 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1325 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1326 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1327 DWARF_ALT_FRAME_RETURN_COLUMN
);
1329 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1330 DWARF_FRAME_REGISTERS
);
1331 #ifdef EH_RETURN_STACKADJ_RTX
1332 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1335 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1338 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1339 STACK_POINTER_REGNUM
);
1342 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1343 TARGET_VTABLE_USES_DESCRIPTORS
);
1346 /* For use in assembly language. */
1347 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1348 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1351 if (flag_gnu89_inline
)
1352 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1354 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1357 cpp_define (pfile
, "__NO_INLINE__");
1360 cpp_define (pfile
, "__STRICT_ANSI__");
1362 if (!flag_signed_char
)
1363 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1365 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1366 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1368 cpp_atomic_builtins (pfile
);
1370 /* Show support for __builtin_speculation_safe_value () if the target
1371 has been updated to fully support it. */
1372 if (targetm
.have_speculation_safe_value (false))
1373 cpp_define (pfile
, "__HAVE_SPECULATION_SAFE_VALUE");
1375 #ifdef DWARF2_UNWIND_INFO
1376 if (dwarf2out_do_cfi_asm ())
1377 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1380 /* Make the choice of ObjC runtime visible to source code. */
1381 if (c_dialect_objc () && flag_next_runtime
)
1382 cpp_define (pfile
, "__NEXT_RUNTIME__");
1384 /* Show the availability of some target pragmas. */
1385 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1387 /* Make the choice of the stack protector runtime visible to source code.
1388 The macro names and values here were chosen for compatibility with an
1389 earlier implementation, i.e. ProPolice. */
1390 if (flag_stack_protect
== 4)
1391 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1392 if (flag_stack_protect
== 3)
1393 cpp_define (pfile
, "__SSP_STRONG__=3");
1394 if (flag_stack_protect
== 2)
1395 cpp_define (pfile
, "__SSP_ALL__=2");
1396 else if (flag_stack_protect
== 1)
1397 cpp_define (pfile
, "__SSP__=1");
1400 cpp_define (pfile
, "_OPENACC=201306");
1403 cpp_define (pfile
, "_OPENMP=201511");
1405 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1406 if (int_n_enabled_p
[i
])
1409 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1410 builtin_define_type_sizeof (buf
,
1411 int_n_trees
[i
].signed_type
);
1413 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1414 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1415 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1416 unsigned_ptrdiff_type_node
);
1418 /* A straightforward target hook doesn't work, because of problems
1419 linking that hook's body when part of non-C front ends. */
1420 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1421 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1422 # define builtin_define(TXT) cpp_define (pfile, TXT)
1423 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1424 TARGET_CPU_CPP_BUILTINS ();
1425 TARGET_OS_CPP_BUILTINS ();
1426 TARGET_OBJFMT_CPP_BUILTINS ();
1428 /* Support the __declspec keyword by turning them into attributes.
1429 Note that the current way we do this may result in a collision
1430 with predefined attributes later on. This can be solved by using
1431 one attribute, say __declspec__, and passing args to it. The
1432 problem with that approach is that args are not accumulated: each
1433 new appearance would clobber any existing args. */
1434 if (TARGET_DECLSPEC
)
1435 builtin_define ("__declspec(x)=__attribute__((x))");
1437 /* If decimal floating point is supported, tell the user if the
1438 alternate format (BID) is used instead of the standard (DPD)
1440 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1441 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1444 /* Pass an object-like macro. If it doesn't lie in the user's
1445 namespace, defines it unconditionally. Otherwise define a version
1446 with two leading underscores, and another version with two leading
1447 and trailing underscores, and define the original only if an ISO
1448 standard was not nominated.
1450 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1451 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1454 builtin_define_std (const char *macro
)
1456 size_t len
= strlen (macro
);
1457 char *buff
= (char *) alloca (len
+ 5);
1461 /* prepend __ (or maybe just _) if in user's namespace. */
1462 memcpy (p
, macro
, len
+ 1);
1463 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1470 cpp_define (parse_in
, p
);
1472 /* If it was in user's namespace... */
1475 /* Define the macro with leading and following __. */
1481 cpp_define (parse_in
, p
);
1483 /* Finally, define the original macro if permitted. */
1485 cpp_define (parse_in
, macro
);
1489 /* Pass an object-like macro and a value to define it to. The third
1490 parameter says whether or not to turn the value into a string
1493 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1496 size_t mlen
= strlen (macro
);
1497 size_t elen
= strlen (expansion
);
1498 size_t extra
= 2; /* space for an = and a NUL */
1502 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1505 extra
+= 2; /* space for two quote marks */
1506 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1531 if (ISPRINT ((unsigned char) *p
))
1535 sprintf (q
, "\\%03o", (unsigned char) *p
);
1541 expansion
= quoted_expansion
;
1542 elen
= q
- expansion
;
1545 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1547 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1549 sprintf (buf
, "%s=%s", macro
, expansion
);
1551 cpp_define (parse_in
, buf
);
1555 /* Pass an object-like macro and an integer value to define it to. */
1557 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1560 size_t mlen
= strlen (macro
);
1562 size_t extra
= 2; /* space for = and NUL. */
1564 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1565 memcpy (buf
, macro
, mlen
);
1567 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1569 cpp_define (parse_in
, buf
);
1572 /* builtin_define_with_hex_fp_value is very expensive, so the following
1573 array and function allows it to be done lazily when __DBL_MAX__
1574 etc. is first used. */
1576 struct GTY(()) lazy_hex_fp_value_struct
1578 const char *hex_str
;
1581 const char *fp_suffix
;
1583 /* Number of the expensive to compute macros we should evaluate lazily.
1584 Each builtin_define_float_constants invocation calls
1585 builtin_define_with_hex_fp_value 4 times and builtin_define_float_constants
1586 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1588 #define LAZY_HEX_FP_VALUES_CNT (4 * (3 + NUM_FLOATN_NX_TYPES))
1589 static GTY(()) struct lazy_hex_fp_value_struct
1590 lazy_hex_fp_values
[LAZY_HEX_FP_VALUES_CNT
];
1591 static GTY(()) unsigned lazy_hex_fp_value_count
;
1594 lazy_hex_fp_value (cpp_reader
*, cpp_macro
*macro
, unsigned num
)
1596 REAL_VALUE_TYPE real
;
1597 char dec_str
[64], buf1
[256];
1599 gcc_checking_assert (num
< lazy_hex_fp_value_count
);
1601 real_from_string (&real
, lazy_hex_fp_values
[num
].hex_str
);
1602 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1603 lazy_hex_fp_values
[num
].digits
, 0,
1604 lazy_hex_fp_values
[num
].mode
);
1607 = sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[num
].fp_suffix
);
1608 gcc_assert (len
< sizeof (buf1
));
1609 for (unsigned idx
= 0; idx
< macro
->count
; idx
++)
1610 if (macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1612 macro
->exp
.tokens
[idx
].val
.str
.len
= len
;
1613 macro
->exp
.tokens
[idx
].val
.str
.text
1614 = (const unsigned char *) ggc_strdup (buf1
);
1618 /* We must have replaced a token. */
1622 /* Pass an object-like macro a hexadecimal floating-point value. */
1624 builtin_define_with_hex_fp_value (const char *macro
,
1625 tree type
, int digits
,
1626 const char *hex_str
,
1627 const char *fp_suffix
,
1628 const char *fp_cast
)
1630 REAL_VALUE_TYPE real
;
1631 char dec_str
[64], buf
[256], buf1
[128], buf2
[64];
1633 /* This is very expensive, so if possible expand them lazily. */
1634 if (lazy_hex_fp_value_count
< LAZY_HEX_FP_VALUES_CNT
1635 && flag_dump_macros
== 0
1636 && !cpp_get_options (parse_in
)->traditional
)
1638 if (lazy_hex_fp_value_count
== 0)
1639 cpp_get_callbacks (parse_in
)->user_lazy_macro
= lazy_hex_fp_value
;
1640 sprintf (buf2
, fp_cast
, "1.1");
1641 sprintf (buf1
, "%s=%s", macro
, buf2
);
1642 cpp_define (parse_in
, buf1
);
1643 struct cpp_hashnode
*node
= C_CPP_HASHNODE (get_identifier (macro
));
1644 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1645 = ggc_strdup (hex_str
);
1646 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1647 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1648 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1649 cpp_define_lazily (parse_in
, node
, lazy_hex_fp_value_count
++);
1653 /* Hex values are really cool and convenient, except that they're
1654 not supported in strict ISO C90 mode. First, the "p-" sequence
1655 is not valid as part of a preprocessor number. Second, we get a
1656 pedwarn from the preprocessor, which has no context, so we can't
1657 suppress the warning with __extension__.
1659 So instead what we do is construct the number in hex (because
1660 it's easy to get the exact correct value), parse it as a real,
1661 then print it back out as decimal. */
1663 real_from_string (&real
, hex_str
);
1664 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1667 /* Assemble the macro in the following fashion
1668 macro = fp_cast [dec_str fp_suffix] */
1669 sprintf (buf2
, "%s%s", dec_str
, fp_suffix
);
1670 sprintf (buf1
, fp_cast
, buf2
);
1671 sprintf (buf
, "%s=%s", macro
, buf1
);
1673 cpp_define (parse_in
, buf
);
1676 /* Return a string constant for the suffix for a value of type TYPE
1677 promoted according to the integer promotions. The type must be one
1678 of the standard integer type nodes. */
1681 type_suffix (tree type
)
1683 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1684 int unsigned_suffix
;
1686 int tp
= TYPE_PRECISION (type
);
1688 if (type
== long_long_integer_type_node
1689 || type
== long_long_unsigned_type_node
1690 || tp
> TYPE_PRECISION (long_integer_type_node
))
1692 else if (type
== long_integer_type_node
1693 || type
== long_unsigned_type_node
1694 || tp
> TYPE_PRECISION (integer_type_node
))
1696 else if (type
== integer_type_node
1697 || type
== unsigned_type_node
1698 || type
== short_integer_type_node
1699 || type
== short_unsigned_type_node
1700 || type
== signed_char_type_node
1701 || type
== unsigned_char_type_node
1702 /* ??? "char" is not a signed or unsigned integer type and
1703 so is not permitted for the standard typedefs, but some
1704 systems use it anyway. */
1705 || type
== char_type_node
)
1710 unsigned_suffix
= TYPE_UNSIGNED (type
);
1711 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1712 unsigned_suffix
= 0;
1713 return suffixes
[is_long
* 2 + unsigned_suffix
];
1716 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1718 builtin_define_constants (const char *macro
, tree type
)
1723 suffix
= type_suffix (type
);
1727 buf
= (char *) alloca (strlen (macro
) + 6);
1728 sprintf (buf
, "%s(c)=c", macro
);
1732 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1733 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1736 cpp_define (parse_in
, buf
);
1739 /* Define MAX for TYPE based on the precision of the type. */
1742 builtin_define_type_max (const char *macro
, tree type
)
1744 builtin_define_type_minmax (NULL
, macro
, type
);
1747 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1748 representation of that value. For example, a COUNT of 10 would
1752 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1754 gcc_assert (bufsz
> 3);
1759 gcc_assert (count
> 0);
1761 switch (count
% 4) {
1782 gcc_assert (bufsz
> 1);
1787 gcc_assert (bufsz
> 0);
1791 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1792 precision of the type. */
1795 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1798 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1799 char value
[PBOH_SZ
];
1805 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1807 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1809 suffix
= type_suffix (type
);
1811 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1812 + strlen (suffix
) + 1);
1813 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1815 cpp_define (parse_in
, buf
);
1819 if (TYPE_UNSIGNED (type
))
1821 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1822 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1826 buf
= (char *) alloca (strlen (min_macro
) + 3
1827 + strlen (max_macro
) + 6);
1828 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1830 cpp_define (parse_in
, buf
);
1834 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1835 both types must have the same width. */
1838 builtin_define_type_width (const char *width_macro
, tree type
, tree type2
)
1840 if (type2
!= NULL_TREE
)
1841 gcc_assert (TYPE_PRECISION (type
) == TYPE_PRECISION (type2
));
1842 builtin_define_with_int_value (width_macro
, TYPE_PRECISION (type
));
1845 #include "gt-c-family-c-cppbuiltin.h"