1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2020 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
), false);
264 sprintf (name
, "__%s_MAX__", name_prefix
);
265 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
267 get_max_float (fmt
, buf
, sizeof (buf
), true);
269 sprintf (name
, "__%s_NORM_MAX__", name_prefix
);
270 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
272 /* The minimum normalized positive floating-point number,
274 sprintf (name
, "__%s_MIN__", name_prefix
);
275 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
276 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
278 /* The difference between 1 and the least value greater than 1 that is
279 representable in the given floating point type, b**(1-p). */
280 sprintf (name
, "__%s_EPSILON__", name_prefix
);
281 if (fmt
->pnan
< fmt
->p
)
282 /* This is an IBM extended double format, so 1.0 + any double is
283 representable precisely. */
284 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
286 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
287 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
289 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
290 The minimum denormalized positive floating-point number, b**(emin-p).
291 The minimum normalized positive floating-point number for formats
292 that don't support denormals. */
293 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
294 sprintf (buf
, "0x1p%d", fmt
->emin
- (fmt
->has_denorm
? fmt
->p
: 1));
295 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
296 buf
, fp_suffix
, fp_cast
);
298 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
299 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
301 /* For C++ std::numeric_limits<T>::has_infinity. */
302 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
303 builtin_define_with_int_value (name
,
304 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
305 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
306 predicate to distinguish a target that has both quiet and
307 signalling NaNs from a target that has only quiet NaNs or only
308 signalling NaNs, so we assume that a target that has any kind of
309 NaN has quiet NaNs. */
310 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
311 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
313 /* Note whether we have fast FMA. */
314 if (mode_has_fma (TYPE_MODE (type
)) && fma_suffix
!= NULL
)
316 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
317 builtin_define_with_int_value (name
, 1);
321 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
323 builtin_define_decimal_float_constants (const char *name_prefix
,
327 const struct real_format
*fmt
;
328 char name
[64], buf
[128], *p
;
331 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
333 /* The number of radix digits, p, in the significand. */
334 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
335 builtin_define_with_int_value (name
, fmt
->p
);
337 /* The minimum negative int x such that b**(x-1) is a normalized float. */
338 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
339 sprintf (buf
, "(%d)", fmt
->emin
);
340 builtin_define_with_value (name
, buf
, 0);
342 /* The maximum int x such that b**(x-1) is a representable float. */
343 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
344 builtin_define_with_int_value (name
, fmt
->emax
);
346 /* Compute the minimum representable value. */
347 sprintf (name
, "__%s_MIN__", name_prefix
);
348 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
349 builtin_define_with_value (name
, buf
, 0);
351 /* Compute the maximum representable value. */
352 sprintf (name
, "__%s_MAX__", name_prefix
);
354 for (digits
= fmt
->p
; digits
; digits
--)
357 if (digits
== fmt
->p
)
361 /* fmt->p plus 1, to account for the decimal point and fmt->emax
362 minus 1 because the digits are nines, not 1.0. */
363 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
364 builtin_define_with_value (name
, buf
, 0);
366 /* Compute epsilon (the difference between 1 and least value greater
367 than 1 representable). */
368 sprintf (name
, "__%s_EPSILON__", name_prefix
);
369 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
370 builtin_define_with_value (name
, buf
, 0);
372 /* Minimum subnormal positive decimal value. */
373 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
375 for (digits
= fmt
->p
; digits
> 1; digits
--)
378 if (digits
== fmt
->p
)
382 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
383 builtin_define_with_value (name
, buf
, 0);
386 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
389 builtin_define_fixed_point_constants (const char *name_prefix
,
393 char name
[64], buf
[256], *new_buf
;
396 sprintf (name
, "__%s_FBIT__", name_prefix
);
397 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
399 sprintf (name
, "__%s_IBIT__", name_prefix
);
400 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
402 /* If there is no suffix, defines are for fixed-point modes.
404 if (strcmp (suffix
, "") == 0)
407 if (TYPE_UNSIGNED (type
))
409 sprintf (name
, "__%s_MIN__", name_prefix
);
410 sprintf (buf
, "0.0%s", suffix
);
411 builtin_define_with_value (name
, buf
, 0);
415 sprintf (name
, "__%s_MIN__", name_prefix
);
416 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
417 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
418 TYPE_IBIT (type
) - 1, suffix
);
420 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
421 builtin_define_with_value (name
, buf
, 0);
424 sprintf (name
, "__%s_MAX__", name_prefix
);
427 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
429 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
430 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
431 sprintf (new_buf
++, "F");
432 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
433 builtin_define_with_value (name
, buf
, 0);
435 sprintf (name
, "__%s_EPSILON__", name_prefix
);
436 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
437 builtin_define_with_value (name
, buf
, 0);
440 /* Define macros used by <stdint.h>. */
442 builtin_define_stdint_macros (void)
444 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
445 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
446 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
447 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
448 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node
,
450 if (sig_atomic_type_node
)
452 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
453 sig_atomic_type_node
);
454 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node
,
458 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
460 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
462 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
464 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
466 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
467 if (c_uint16_type_node
)
468 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
469 if (c_uint32_type_node
)
470 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
471 if (c_uint64_type_node
)
472 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
473 if (int_least8_type_node
)
475 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
476 builtin_define_constants ("__INT8_C", int_least8_type_node
);
477 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node
,
478 uint_least8_type_node
);
480 if (int_least16_type_node
)
482 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
483 builtin_define_constants ("__INT16_C", int_least16_type_node
);
484 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
485 int_least16_type_node
,
486 uint_least16_type_node
);
488 if (int_least32_type_node
)
490 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
491 builtin_define_constants ("__INT32_C", int_least32_type_node
);
492 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
493 int_least32_type_node
,
494 uint_least32_type_node
);
496 if (int_least64_type_node
)
498 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
499 builtin_define_constants ("__INT64_C", int_least64_type_node
);
500 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
501 int_least64_type_node
,
502 uint_least64_type_node
);
504 if (uint_least8_type_node
)
506 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
507 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
509 if (uint_least16_type_node
)
511 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
512 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
514 if (uint_least32_type_node
)
516 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
517 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
519 if (uint_least64_type_node
)
521 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
522 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
524 if (int_fast8_type_node
)
526 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
527 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node
,
528 uint_fast8_type_node
);
530 if (int_fast16_type_node
)
532 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
533 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node
,
534 uint_fast16_type_node
);
536 if (int_fast32_type_node
)
538 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
539 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node
,
540 uint_fast32_type_node
);
542 if (int_fast64_type_node
)
544 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
545 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node
,
546 uint_fast64_type_node
);
548 if (uint_fast8_type_node
)
549 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
550 if (uint_fast16_type_node
)
551 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
552 if (uint_fast32_type_node
)
553 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
554 if (uint_fast64_type_node
)
555 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
556 if (intptr_type_node
)
558 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
559 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node
,
562 if (uintptr_type_node
)
563 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
566 /* Adjust the optimization macros when a #pragma GCC optimization is done to
567 reflect the current level. */
569 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
572 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
573 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
577 /* -undef turns off target-specific built-ins. */
581 /* Other target-independent built-ins determined by command-line
583 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
584 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
585 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
586 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
588 if (!prev
->x_optimize
&& cur
->x_optimize
)
589 cpp_define (pfile
, "__OPTIMIZE__");
590 else if (prev
->x_optimize
&& !cur
->x_optimize
)
591 cpp_undef (pfile
, "__OPTIMIZE__");
593 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
594 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
595 if (!prev_fast_math
&& cur_fast_math
)
596 cpp_define (pfile
, "__FAST_MATH__");
597 else if (prev_fast_math
&& !cur_fast_math
)
598 cpp_undef (pfile
, "__FAST_MATH__");
600 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
601 cpp_define (pfile
, "__SUPPORT_SNAN__");
602 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
603 cpp_undef (pfile
, "__SUPPORT_SNAN__");
605 if (!prev
->x_flag_errno_math
&& cur
->x_flag_errno_math
)
606 cpp_undef (pfile
, "__NO_MATH_ERRNO__");
607 else if (prev
->x_flag_errno_math
&& !cur
->x_flag_errno_math
)
608 cpp_define (pfile
, "__NO_MATH_ERRNO__");
610 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__=1");
615 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
617 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
618 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
623 /* This function will emit cpp macros to indicate the presence of various lock
624 free atomic operations. */
627 cpp_atomic_builtins (cpp_reader
*pfile
)
629 /* Set a flag for each size of object that compare and swap exists for up to
631 #define SWAP_LIMIT 17
632 bool have_swap
[SWAP_LIMIT
];
635 /* Clear the map of sizes compare_and swap exists for. */
636 memset (have_swap
, 0, sizeof (have_swap
));
638 /* Tell source code if the compiler makes sync_compare_and_swap
639 builtins available. */
640 #ifndef HAVE_sync_compare_and_swapqi
641 #define HAVE_sync_compare_and_swapqi 0
643 #ifndef HAVE_atomic_compare_and_swapqi
644 #define HAVE_atomic_compare_and_swapqi 0
647 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
649 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
653 #ifndef HAVE_sync_compare_and_swaphi
654 #define HAVE_sync_compare_and_swaphi 0
656 #ifndef HAVE_atomic_compare_and_swaphi
657 #define HAVE_atomic_compare_and_swaphi 0
659 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
661 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
665 #ifndef HAVE_sync_compare_and_swapsi
666 #define HAVE_sync_compare_and_swapsi 0
668 #ifndef HAVE_atomic_compare_and_swapsi
669 #define HAVE_atomic_compare_and_swapsi 0
671 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
673 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
677 #ifndef HAVE_sync_compare_and_swapdi
678 #define HAVE_sync_compare_and_swapdi 0
680 #ifndef HAVE_atomic_compare_and_swapdi
681 #define HAVE_atomic_compare_and_swapdi 0
683 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
685 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
689 #ifndef HAVE_sync_compare_and_swapti
690 #define HAVE_sync_compare_and_swapti 0
692 #ifndef HAVE_atomic_compare_and_swapti
693 #define HAVE_atomic_compare_and_swapti 0
695 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
697 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
698 have_swap
[16] = true;
701 /* Tell the source code about various types. These map to the C++11 and C11
702 macros where 2 indicates lock-free always, and 1 indicates sometimes
704 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
705 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
706 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
707 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
708 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
709 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
711 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR8_T_LOCK_FREE",
712 (have_swap
[SWAP_INDEX (char8_type_node
)]? 2 : 1));
713 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
714 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
715 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
716 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
717 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
718 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
719 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
720 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
721 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
722 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
723 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
724 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
725 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
726 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
728 /* If we're dealing with a "set" value that doesn't exactly correspond
729 to a boolean truth value, let the library work around that. */
730 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
731 targetm
.atomic_test_and_set_trueval
);
733 /* ptr_type_node can't be used here since ptr_mode is only set when
734 toplev calls backend_init which is not done with -E or pch. */
735 psize
= POINTER_SIZE_UNITS
;
736 if (psize
>= SWAP_LIMIT
)
738 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
739 (have_swap
[psize
]? 2 : 1));
742 /* Return TRUE if the implicit excess precision in which the back-end will
743 compute floating-point calculations is not more than the explicit
744 excess precision that the front-end will apply under
745 -fexcess-precision=[standard|fast].
747 More intuitively, return TRUE if the excess precision proposed by the
748 front-end is the excess precision that will actually be used. */
751 c_cpp_flt_eval_method_iec_559 (void)
753 enum excess_precision_type front_end_ept
754 = (flag_excess_precision
== EXCESS_PRECISION_STANDARD
755 ? EXCESS_PRECISION_TYPE_STANDARD
756 : EXCESS_PRECISION_TYPE_FAST
);
758 enum flt_eval_method back_end
759 = targetm
.c
.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT
);
761 enum flt_eval_method front_end
762 = targetm
.c
.excess_precision (front_end_ept
);
764 return excess_precision_mode_join (front_end
, back_end
) == front_end
;
767 /* Return the value for __GCC_IEC_559. */
769 cpp_iec_559_value (void)
771 /* The default is support for IEEE 754-2008. */
774 /* float and double must be binary32 and binary64. If they are but
775 with reversed NaN convention, at most IEEE 754-1985 is
777 const struct real_format
*ffmt
778 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
779 const struct real_format
*dfmt
780 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
781 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
786 || ffmt
->emin
!= -125
788 || ffmt
->signbit_rw
!= 31
789 || ffmt
->round_towards_zero
790 || !ffmt
->has_sign_dependent_rounding
794 || !ffmt
->has_signed_zero
798 || dfmt
->emin
!= -1021
799 || dfmt
->emax
!= 1024
800 || dfmt
->signbit_rw
!= 63
801 || dfmt
->round_towards_zero
802 || !dfmt
->has_sign_dependent_rounding
806 || !dfmt
->has_signed_zero
)
809 /* In strict C standards conformance mode, consider a back-end providing
810 more implicit excess precision than the explicit excess precision
811 the front-end options would require to mean a lack of IEEE 754
812 support. For C++, and outside strict conformance mode, do not consider
813 this to mean a lack of IEEE 754 support. */
817 && !c_cpp_flt_eval_method_iec_559 ())
822 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
825 /* Various options are contrary to IEEE 754 semantics. */
826 if (flag_unsafe_math_optimizations
827 || flag_associative_math
828 || flag_reciprocal_math
829 || flag_finite_math_only
830 || !flag_signed_zeros
831 || flag_single_precision_constant
)
834 /* If the target does not support IEEE 754 exceptions and rounding
835 modes, consider IEEE 754 support to be absent. */
836 if (!targetm
.float_exceptions_rounding_supported_p ())
842 /* Return the value for __GCC_IEC_559_COMPLEX. */
844 cpp_iec_559_complex_value (void)
846 /* The value is no bigger than that of __GCC_IEC_559. */
847 int ret
= cpp_iec_559_value ();
849 /* Some options are contrary to the required default state of the
850 CX_LIMITED_RANGE pragma. */
851 if (flag_complex_method
!= 2)
857 /* Hook that registers front end and target-specific built-ins. */
859 c_cpp_builtins (cpp_reader
*pfile
)
863 /* -undef turns off target-specific built-ins. */
867 define_language_independent_builtin_macros (pfile
);
869 if (c_dialect_cxx ())
872 parse_basever (&major
, NULL
, NULL
);
873 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
876 /* For stddef.h. They require macros defined in c-common.c. */
877 c_stddef_cpp_builtins ();
879 /* Set include test macros for all C/C++ (not for just C++11 etc.)
880 The builtins __has_include__ and __has_include_next__ are defined
882 cpp_define (pfile
, "__has_include(STR)=__has_include__(STR)");
883 cpp_define (pfile
, "__has_include_next(STR)=__has_include_next__(STR)");
885 if (c_dialect_cxx ())
887 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
888 cpp_define (pfile
, "__GXX_WEAK__=1");
890 cpp_define (pfile
, "__GXX_WEAK__=0");
893 cpp_define (pfile
, "__DEPRECATED");
897 cpp_define (pfile
, "__GXX_RTTI");
898 cpp_define (pfile
, "__cpp_rtti=199711L");
901 if (cxx_dialect
>= cxx11
)
902 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
904 /* Binary literals have been allowed in g++ before C++11
905 and were standardized for C++14. */
906 if (!pedantic
|| cxx_dialect
> cxx11
)
907 cpp_define (pfile
, "__cpp_binary_literals=201304L");
909 /* Similarly for hexadecimal floating point literals and C++17. */
910 if (!pedantic
|| cpp_get_options (parse_in
)->extended_numbers
)
911 cpp_define (pfile
, "__cpp_hex_float=201603L");
913 /* Arrays of runtime bound were removed from C++14, but we still
914 support GNU VLAs. Let's define this macro to a low number
915 (corresponding to the initial test release of GNU C++) if we won't
916 complain about use of VLAs. */
918 && (pedantic
? warn_vla
== 0 : warn_vla
<= 0))
919 cpp_define (pfile
, "__cpp_runtime_arrays=198712L");
921 if (cxx_dialect
>= cxx11
)
923 /* Set feature test macros for C++11. */
924 if (cxx_dialect
<= cxx14
)
925 cpp_define (pfile
, "__cpp_unicode_characters=200704L");
926 cpp_define (pfile
, "__cpp_raw_strings=200710L");
927 cpp_define (pfile
, "__cpp_unicode_literals=200710L");
928 cpp_define (pfile
, "__cpp_user_defined_literals=200809L");
929 cpp_define (pfile
, "__cpp_lambdas=200907L");
930 if (cxx_dialect
== cxx11
)
931 cpp_define (pfile
, "__cpp_constexpr=200704L");
932 if (cxx_dialect
<= cxx14
)
933 cpp_define (pfile
, "__cpp_range_based_for=200907L");
934 if (cxx_dialect
<= cxx14
)
935 cpp_define (pfile
, "__cpp_static_assert=200410L");
936 cpp_define (pfile
, "__cpp_decltype=200707L");
937 cpp_define (pfile
, "__cpp_attributes=200809L");
938 cpp_define (pfile
, "__cpp_rvalue_reference=200610L");
939 cpp_define (pfile
, "__cpp_rvalue_references=200610L");
940 cpp_define (pfile
, "__cpp_variadic_templates=200704L");
941 cpp_define (pfile
, "__cpp_initializer_lists=200806L");
942 cpp_define (pfile
, "__cpp_delegating_constructors=200604L");
943 cpp_define (pfile
, "__cpp_nsdmi=200809L");
944 if (!flag_new_inheriting_ctors
)
945 cpp_define (pfile
, "__cpp_inheriting_constructors=200802L");
947 cpp_define (pfile
, "__cpp_inheriting_constructors=201511L");
948 cpp_define (pfile
, "__cpp_ref_qualifiers=200710L");
949 cpp_define (pfile
, "__cpp_alias_templates=200704L");
951 if (cxx_dialect
> cxx11
)
953 /* Set feature test macros for C++14. */
954 cpp_define (pfile
, "__cpp_return_type_deduction=201304L");
955 if (cxx_dialect
<= cxx17
)
957 cpp_define (pfile
, "__cpp_init_captures=201304L");
958 cpp_define (pfile
, "__cpp_generic_lambdas=201304L");
960 if (cxx_dialect
<= cxx14
)
961 cpp_define (pfile
, "__cpp_constexpr=201304L");
962 cpp_define (pfile
, "__cpp_decltype_auto=201304L");
963 cpp_define (pfile
, "__cpp_aggregate_nsdmi=201304L");
964 cpp_define (pfile
, "__cpp_variable_templates=201304L");
965 cpp_define (pfile
, "__cpp_digit_separators=201309L");
967 if (cxx_dialect
> cxx14
)
969 /* Set feature test macros for C++17. */
970 cpp_define (pfile
, "__cpp_unicode_characters=201411L");
971 cpp_define (pfile
, "__cpp_static_assert=201411L");
972 cpp_define (pfile
, "__cpp_namespace_attributes=201411L");
973 cpp_define (pfile
, "__cpp_enumerator_attributes=201411L");
974 cpp_define (pfile
, "__cpp_nested_namespace_definitions=201411L");
975 cpp_define (pfile
, "__cpp_fold_expressions=201603L");
976 cpp_define (pfile
, "__cpp_nontype_template_args=201411L");
977 cpp_define (pfile
, "__cpp_range_based_for=201603L");
978 if (cxx_dialect
<= cxx17
)
979 cpp_define (pfile
, "__cpp_constexpr=201603L");
980 cpp_define (pfile
, "__cpp_if_constexpr=201606L");
981 cpp_define (pfile
, "__cpp_capture_star_this=201603L");
982 cpp_define (pfile
, "__cpp_inline_variables=201606L");
983 cpp_define (pfile
, "__cpp_aggregate_bases=201603L");
984 if (cxx_dialect
<= cxx17
)
985 cpp_define (pfile
, "__cpp_deduction_guides=201703L");
986 cpp_define (pfile
, "__cpp_noexcept_function_type=201510L");
987 /* Old macro, superseded by
988 __cpp_nontype_template_parameter_auto. */
989 cpp_define (pfile
, "__cpp_template_auto=201606L");
990 cpp_define (pfile
, "__cpp_structured_bindings=201606L");
991 cpp_define (pfile
, "__cpp_variadic_using=201611L");
992 cpp_define (pfile
, "__cpp_guaranteed_copy_elision=201606L");
993 cpp_define (pfile
, "__cpp_nontype_template_parameter_auto=201606L");
995 if (cxx_dialect
> cxx17
)
997 /* Set feature test macros for C++2a. */
998 cpp_define (pfile
, "__cpp_init_captures=201803L");
999 cpp_define (pfile
, "__cpp_generic_lambdas=201707L");
1000 cpp_define (pfile
, "__cpp_designated_initializers=201707L");
1001 cpp_define (pfile
, "__cpp_constexpr=201907L");
1002 cpp_define (pfile
, "__cpp_constexpr_in_decltype=201711L");
1003 cpp_define (pfile
, "__cpp_conditional_explicit=201806L");
1004 /* cpp_define (pfile, "__cpp_consteval=201811L"); */
1005 cpp_define (pfile
, "__cpp_constinit=201907L");
1006 cpp_define (pfile
, "__cpp_deduction_guides=201907L");
1007 cpp_define (pfile
, "__cpp_nontype_template_parameter_class=201806L");
1008 cpp_define (pfile
, "__cpp_impl_destroying_delete=201806L");
1009 cpp_define (pfile
, "__cpp_constexpr_dynamic_alloc=201907L");
1010 cpp_define (pfile
, "__cpp_impl_three_way_comparison=201907L");
1011 cpp_define (pfile
, "__cpp_aggregate_paren_init=201902L");
1015 if (cxx_dialect
>= cxx2a
)
1016 cpp_define (pfile
, "__cpp_concepts=201907L");
1018 cpp_define (pfile
, "__cpp_concepts=201507L");
1021 /* Use a value smaller than the 201505 specified in
1022 the TS, since we don't yet support atomic_cancel. */
1023 cpp_define (pfile
, "__cpp_transactional_memory=201500L");
1024 if (flag_sized_deallocation
)
1025 cpp_define (pfile
, "__cpp_sized_deallocation=201309L");
1026 if (aligned_new_threshold
)
1028 cpp_define (pfile
, "__cpp_aligned_new=201606L");
1029 cpp_define_formatted (pfile
, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
1030 aligned_new_threshold
);
1033 cpp_define (pfile
, "__cpp_template_template_args=201611L");
1034 if (flag_threadsafe_statics
)
1035 cpp_define (pfile
, "__cpp_threadsafe_static_init=200806L");
1037 cpp_define (pfile
, "__cpp_char8_t=201811L");
1039 /* Note that we define this for C as well, so that we know if
1040 __attribute__((cleanup)) will interface with EH. */
1041 if (flag_exceptions
)
1043 cpp_define (pfile
, "__EXCEPTIONS");
1044 if (c_dialect_cxx ())
1045 cpp_define (pfile
, "__cpp_exceptions=199711L");
1048 /* Represents the C++ ABI version, always defined so it can be used while
1049 preprocessing C and assembler. */
1050 if (flag_abi_version
== 0)
1051 /* We should have set this to something real in c_common_post_options. */
1053 else if (flag_abi_version
== 1)
1054 /* Due to a historical accident, this version had the value
1056 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1058 /* Newer versions have values 1002, 1003, .... */
1059 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1060 1000 + flag_abi_version
);
1062 /* libgcc needs to know this. */
1063 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
1064 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
1066 /* limits.h and stdint.h need to know these. */
1067 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
1068 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
1069 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
1070 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
1071 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
1072 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1073 underlying_wchar_type_node
);
1074 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
1075 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
1076 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
1078 /* These are needed for TS 18661-1. */
1079 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node
,
1080 unsigned_char_type_node
);
1081 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node
,
1082 short_unsigned_type_node
);
1083 builtin_define_type_width ("__INT_WIDTH__", integer_type_node
,
1084 unsigned_type_node
);
1085 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node
,
1086 long_unsigned_type_node
);
1087 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1088 long_long_integer_type_node
,
1089 long_long_unsigned_type_node
);
1090 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node
,
1092 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node
, NULL_TREE
);
1093 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node
, NULL_TREE
);
1094 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node
, NULL_TREE
);
1096 if (c_dialect_cxx ())
1097 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1098 if (int_n_enabled_p
[i
])
1102 /* These are used to configure the C++ library. */
1104 if (!flag_iso
|| int_n_data
[i
].bitsize
== POINTER_SIZE
)
1106 sprintf (buf
, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i
, int_n_data
[i
].bitsize
);
1107 cpp_define (parse_in
, buf
);
1109 sprintf (buf
, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i
, int_n_data
[i
].bitsize
);
1110 cpp_define (parse_in
, buf
);
1114 /* stdint.h and the testsuite need to know these. */
1115 builtin_define_stdint_macros ();
1117 /* Provide information for library headers to determine whether to
1118 define macros such as __STDC_IEC_559__ and
1119 __STDC_IEC_559_COMPLEX__. */
1120 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1121 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1122 cpp_iec_559_complex_value ());
1124 /* float.h needs these to correctly set FLT_EVAL_METHOD
1126 We define two values:
1129 Which, depending on the value given for
1130 -fpermitted-flt-eval-methods, may be limited to only those values
1131 for FLT_EVAL_METHOD defined in C99/C11.
1133 __FLT_EVAL_METHOD_TS_18661_3__
1134 Which always permits the values for FLT_EVAL_METHOD defined in
1135 ISO/IEC TS 18661-3. */
1136 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1137 c_flt_eval_method (true));
1138 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1139 c_flt_eval_method (false));
1141 /* And decfloat.h needs this. */
1142 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1143 TARGET_DEC_EVAL_METHOD
);
1145 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
1146 /* Cast the double precision constants. This is needed when single
1147 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1148 is used. The correct result is computed by the compiler when using
1149 macros that include a cast. We use a different cast for C++ to avoid
1150 problems with -Wold-style-cast. */
1151 builtin_define_float_constants ("DBL", "L",
1155 "", double_type_node
);
1156 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1157 long_double_type_node
);
1159 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1161 if (FLOATN_NX_TYPE_NODE (i
) == NULL_TREE
)
1163 char prefix
[20], csuffix
[20];
1164 sprintf (prefix
, "FLT%d%s", floatn_nx_types
[i
].n
,
1165 floatn_nx_types
[i
].extended
? "X" : "");
1166 sprintf (csuffix
, "F%d%s", floatn_nx_types
[i
].n
,
1167 floatn_nx_types
[i
].extended
? "x" : "");
1168 builtin_define_float_constants (prefix
, ggc_strdup (csuffix
), "%s",
1169 csuffix
, FLOATN_NX_TYPE_NODE (i
));
1173 if (targetm
.decimal_float_supported_p ())
1175 builtin_define_decimal_float_constants ("DEC32", "DF",
1176 dfloat32_type_node
);
1177 builtin_define_decimal_float_constants ("DEC64", "DD",
1178 dfloat64_type_node
);
1179 builtin_define_decimal_float_constants ("DEC128", "DL",
1180 dfloat128_type_node
);
1183 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1184 if (targetm
.fixed_point_supported_p ())
1186 builtin_define_fixed_point_constants ("SFRACT", "HR",
1187 short_fract_type_node
);
1188 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1189 unsigned_short_fract_type_node
);
1190 builtin_define_fixed_point_constants ("FRACT", "R",
1192 builtin_define_fixed_point_constants ("UFRACT", "UR",
1193 unsigned_fract_type_node
);
1194 builtin_define_fixed_point_constants ("LFRACT", "LR",
1195 long_fract_type_node
);
1196 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1197 unsigned_long_fract_type_node
);
1198 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1199 long_long_fract_type_node
);
1200 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1201 unsigned_long_long_fract_type_node
);
1202 builtin_define_fixed_point_constants ("SACCUM", "HK",
1203 short_accum_type_node
);
1204 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1205 unsigned_short_accum_type_node
);
1206 builtin_define_fixed_point_constants ("ACCUM", "K",
1208 builtin_define_fixed_point_constants ("UACCUM", "UK",
1209 unsigned_accum_type_node
);
1210 builtin_define_fixed_point_constants ("LACCUM", "LK",
1211 long_accum_type_node
);
1212 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1213 unsigned_long_accum_type_node
);
1214 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1215 long_long_accum_type_node
);
1216 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1217 unsigned_long_long_accum_type_node
);
1219 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
1220 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
1221 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
1222 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
1223 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
1224 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
1225 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
1226 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
1227 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
1228 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
1229 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
1230 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
1231 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
1232 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
1233 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
1234 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
1235 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
1236 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
1239 /* For libgcc-internal use only. */
1240 if (flag_building_libgcc
)
1242 /* Properties of floating-point modes for libgcc2.c. */
1243 opt_scalar_float_mode mode_iter
;
1244 FOR_EACH_MODE_IN_CLASS (mode_iter
, MODE_FLOAT
)
1246 scalar_float_mode mode
= mode_iter
.require ();
1247 const char *name
= GET_MODE_NAME (mode
);
1249 = (char *) alloca (strlen (name
)
1250 + sizeof ("__LIBGCC__MANT_DIG__"));
1251 sprintf (macro_name
, "__LIBGCC_%s_MANT_DIG__", name
);
1252 builtin_define_with_int_value (macro_name
,
1253 REAL_MODE_FORMAT (mode
)->p
);
1254 if (!targetm
.scalar_mode_supported_p (mode
)
1255 || !targetm
.libgcc_floating_mode_supported_p (mode
))
1257 macro_name
= (char *) alloca (strlen (name
)
1258 + sizeof ("__LIBGCC_HAS__MODE__"));
1259 sprintf (macro_name
, "__LIBGCC_HAS_%s_MODE__", name
);
1260 cpp_define (pfile
, macro_name
);
1261 macro_name
= (char *) alloca (strlen (name
)
1262 + sizeof ("__LIBGCC__FUNC_EXT__"));
1263 sprintf (macro_name
, "__LIBGCC_%s_FUNC_EXT__", name
);
1264 char suffix
[20] = "";
1265 if (mode
== TYPE_MODE (double_type_node
))
1266 ; /* Empty suffix correct. */
1267 else if (mode
== TYPE_MODE (float_type_node
))
1269 else if (mode
== TYPE_MODE (long_double_type_node
))
1273 bool found_suffix
= false;
1274 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
1275 if (FLOATN_NX_TYPE_NODE (i
) != NULL_TREE
1276 && mode
== TYPE_MODE (FLOATN_NX_TYPE_NODE (i
)))
1278 sprintf (suffix
, "f%d%s", floatn_nx_types
[i
].n
,
1279 floatn_nx_types
[i
].extended
? "x" : "");
1280 found_suffix
= true;
1283 gcc_assert (found_suffix
);
1285 builtin_define_with_value (macro_name
, suffix
, 0);
1287 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1288 eliminating excess precision from results assigned to
1289 variables - meaning it should be about the implicit excess
1291 bool excess_precision
= false;
1292 machine_mode float16_type_mode
= (float16_type_node
1293 ? TYPE_MODE (float16_type_node
)
1295 switch (targetm
.c
.excess_precision
1296 (EXCESS_PRECISION_TYPE_IMPLICIT
))
1298 case FLT_EVAL_METHOD_UNPREDICTABLE
:
1299 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE
:
1300 excess_precision
= (mode
== float16_type_mode
1301 || mode
== TYPE_MODE (float_type_node
)
1302 || mode
== TYPE_MODE (double_type_node
));
1305 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE
:
1306 excess_precision
= (mode
== float16_type_mode
1307 || mode
== TYPE_MODE (float_type_node
));
1309 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT
:
1310 excess_precision
= mode
== float16_type_mode
;
1312 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16
:
1313 excess_precision
= false;
1318 macro_name
= (char *) alloca (strlen (name
)
1319 + sizeof ("__LIBGCC__EXCESS_"
1321 sprintf (macro_name
, "__LIBGCC_%s_EXCESS_PRECISION__", name
);
1322 builtin_define_with_int_value (macro_name
, excess_precision
);
1325 /* For libgcc crtstuff.c and libgcc2.c. */
1326 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1327 EH_TABLES_CAN_BE_READ_ONLY
);
1328 #ifdef EH_FRAME_SECTION_NAME
1329 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1330 EH_FRAME_SECTION_NAME
, 1);
1332 #ifdef CTORS_SECTION_ASM_OP
1333 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1334 CTORS_SECTION_ASM_OP
, 1);
1336 #ifdef DTORS_SECTION_ASM_OP
1337 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1338 DTORS_SECTION_ASM_OP
, 1);
1340 #ifdef TEXT_SECTION_ASM_OP
1341 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1342 TEXT_SECTION_ASM_OP
, 1);
1344 #ifdef INIT_SECTION_ASM_OP
1345 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1346 INIT_SECTION_ASM_OP
, 1);
1348 #ifdef INIT_ARRAY_SECTION_ASM_OP
1349 /* Despite the name of this target macro, the expansion is not
1350 actually used, and may be empty rather than a string
1352 cpp_define (pfile
, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1355 /* For libgcc enable-execute-stack.c. */
1356 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1359 /* For libgcc generic-morestack.c and unwinder code. */
1360 if (STACK_GROWS_DOWNWARD
)
1361 cpp_define (pfile
, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1363 /* For libgcc unwinder code. */
1364 #ifdef DONT_USE_BUILTIN_SETJMP
1365 cpp_define (pfile
, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1367 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1368 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1369 DWARF_ALT_FRAME_RETURN_COLUMN
);
1371 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1372 DWARF_FRAME_REGISTERS
);
1373 #ifdef EH_RETURN_STACKADJ_RTX
1374 cpp_define (pfile
, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1377 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1380 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1381 STACK_POINTER_REGNUM
);
1384 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1385 TARGET_VTABLE_USES_DESCRIPTORS
);
1388 /* For use in assembly language. */
1389 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
1390 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
1393 if (flag_gnu89_inline
)
1394 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
1396 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
1399 cpp_define (pfile
, "__NO_INLINE__");
1402 cpp_define (pfile
, "__STRICT_ANSI__");
1404 if (!flag_signed_char
)
1405 cpp_define (pfile
, "__CHAR_UNSIGNED__");
1407 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
1408 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
1410 cpp_atomic_builtins (pfile
);
1412 /* Show support for __builtin_speculation_safe_value () if the target
1413 has been updated to fully support it. */
1414 if (targetm
.have_speculation_safe_value (false))
1415 cpp_define (pfile
, "__HAVE_SPECULATION_SAFE_VALUE");
1417 #ifdef DWARF2_UNWIND_INFO
1418 if (dwarf2out_do_cfi_asm ())
1419 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
1422 /* Make the choice of ObjC runtime visible to source code. */
1423 if (c_dialect_objc () && flag_next_runtime
)
1424 cpp_define (pfile
, "__NEXT_RUNTIME__");
1426 /* Show the availability of some target pragmas. */
1427 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
1429 /* Make the choice of the stack protector runtime visible to source code.
1430 The macro names and values here were chosen for compatibility with an
1431 earlier implementation, i.e. ProPolice. */
1432 if (flag_stack_protect
== 4)
1433 cpp_define (pfile
, "__SSP_EXPLICIT__=4");
1434 if (flag_stack_protect
== 3)
1435 cpp_define (pfile
, "__SSP_STRONG__=3");
1436 if (flag_stack_protect
== 2)
1437 cpp_define (pfile
, "__SSP_ALL__=2");
1438 else if (flag_stack_protect
== 1)
1439 cpp_define (pfile
, "__SSP__=1");
1442 cpp_define (pfile
, "_OPENACC=201306");
1445 cpp_define (pfile
, "_OPENMP=201511");
1447 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
1448 if (int_n_enabled_p
[i
])
1451 sprintf(buf
, "__SIZEOF_INT%d__", int_n_data
[i
].bitsize
);
1452 builtin_define_type_sizeof (buf
,
1453 int_n_trees
[i
].signed_type
);
1455 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1456 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1457 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1458 unsigned_ptrdiff_type_node
);
1460 /* A straightforward target hook doesn't work, because of problems
1461 linking that hook's body when part of non-C front ends. */
1462 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1463 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1464 # define builtin_define(TXT) cpp_define (pfile, TXT)
1465 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1466 TARGET_CPU_CPP_BUILTINS ();
1467 TARGET_OS_CPP_BUILTINS ();
1468 TARGET_OBJFMT_CPP_BUILTINS ();
1470 /* Support the __declspec keyword by turning them into attributes.
1471 Note that the current way we do this may result in a collision
1472 with predefined attributes later on. This can be solved by using
1473 one attribute, say __declspec__, and passing args to it. The
1474 problem with that approach is that args are not accumulated: each
1475 new appearance would clobber any existing args. */
1476 if (TARGET_DECLSPEC
)
1477 builtin_define ("__declspec(x)=__attribute__((x))");
1479 /* If decimal floating point is supported, tell the user if the
1480 alternate format (BID) is used instead of the standard (DPD)
1482 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1483 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1486 /* Pass an object-like macro. If it doesn't lie in the user's
1487 namespace, defines it unconditionally. Otherwise define a version
1488 with two leading underscores, and another version with two leading
1489 and trailing underscores, and define the original only if an ISO
1490 standard was not nominated.
1492 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1493 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1496 builtin_define_std (const char *macro
)
1498 size_t len
= strlen (macro
);
1499 char *buff
= (char *) alloca (len
+ 5);
1503 /* prepend __ (or maybe just _) if in user's namespace. */
1504 memcpy (p
, macro
, len
+ 1);
1505 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1512 cpp_define (parse_in
, p
);
1514 /* If it was in user's namespace... */
1517 /* Define the macro with leading and following __. */
1523 cpp_define (parse_in
, p
);
1525 /* Finally, define the original macro if permitted. */
1527 cpp_define (parse_in
, macro
);
1531 /* Pass an object-like macro and a value to define it to. The third
1532 parameter says whether or not to turn the value into a string
1535 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1538 size_t mlen
= strlen (macro
);
1539 size_t elen
= strlen (expansion
);
1540 size_t extra
= 2; /* space for an = and a NUL */
1544 char *quoted_expansion
= (char *) alloca (elen
* 4 + 1);
1547 extra
+= 2; /* space for two quote marks */
1548 for (p
= expansion
, q
= quoted_expansion
; *p
; p
++)
1573 if (ISPRINT ((unsigned char) *p
))
1577 sprintf (q
, "\\%03o", (unsigned char) *p
);
1583 expansion
= quoted_expansion
;
1584 elen
= q
- expansion
;
1587 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1589 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1591 sprintf (buf
, "%s=%s", macro
, expansion
);
1593 cpp_define (parse_in
, buf
);
1597 /* Pass an object-like macro and an integer value to define it to. */
1599 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1602 size_t mlen
= strlen (macro
);
1604 size_t extra
= 2; /* space for = and NUL. */
1606 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1607 memcpy (buf
, macro
, mlen
);
1609 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1611 cpp_define (parse_in
, buf
);
1614 /* builtin_define_with_hex_fp_value is very expensive, so the following
1615 array and function allows it to be done lazily when __DBL_MAX__
1616 etc. is first used. */
1618 struct GTY(()) lazy_hex_fp_value_struct
1620 const char *hex_str
;
1623 const char *fp_suffix
;
1625 /* Number of the expensive to compute macros we should evaluate lazily.
1626 Each builtin_define_float_constants invocation calls
1627 builtin_define_with_hex_fp_value 5 times and builtin_define_float_constants
1628 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1630 #define LAZY_HEX_FP_VALUES_CNT (5 * (3 + NUM_FLOATN_NX_TYPES))
1631 static GTY(()) struct lazy_hex_fp_value_struct
1632 lazy_hex_fp_values
[LAZY_HEX_FP_VALUES_CNT
];
1633 static GTY(()) unsigned lazy_hex_fp_value_count
;
1636 lazy_hex_fp_value (cpp_reader
*, cpp_macro
*macro
, unsigned num
)
1638 REAL_VALUE_TYPE real
;
1639 char dec_str
[64], buf1
[256];
1641 gcc_checking_assert (num
< lazy_hex_fp_value_count
);
1643 real_from_string (&real
, lazy_hex_fp_values
[num
].hex_str
);
1644 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1645 lazy_hex_fp_values
[num
].digits
, 0,
1646 lazy_hex_fp_values
[num
].mode
);
1649 = sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[num
].fp_suffix
);
1650 gcc_assert (len
< sizeof (buf1
));
1651 for (unsigned idx
= 0; idx
< macro
->count
; idx
++)
1652 if (macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1654 macro
->exp
.tokens
[idx
].val
.str
.len
= len
;
1655 macro
->exp
.tokens
[idx
].val
.str
.text
1656 = (const unsigned char *) ggc_strdup (buf1
);
1660 /* We must have replaced a token. */
1664 /* Pass an object-like macro a hexadecimal floating-point value. */
1666 builtin_define_with_hex_fp_value (const char *macro
,
1667 tree type
, int digits
,
1668 const char *hex_str
,
1669 const char *fp_suffix
,
1670 const char *fp_cast
)
1672 REAL_VALUE_TYPE real
;
1673 char dec_str
[64], buf
[256], buf1
[128], buf2
[64];
1675 /* This is very expensive, so if possible expand them lazily. */
1676 if (lazy_hex_fp_value_count
< LAZY_HEX_FP_VALUES_CNT
1677 && flag_dump_macros
== 0
1678 && flag_dump_go_spec
== NULL
1679 && !cpp_get_options (parse_in
)->traditional
)
1681 if (lazy_hex_fp_value_count
== 0)
1682 cpp_get_callbacks (parse_in
)->user_lazy_macro
= lazy_hex_fp_value
;
1683 sprintf (buf2
, fp_cast
, "1.1");
1684 sprintf (buf1
, "%s=%s", macro
, buf2
);
1685 cpp_define (parse_in
, buf1
);
1686 struct cpp_hashnode
*node
= C_CPP_HASHNODE (get_identifier (macro
));
1687 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1688 = ggc_strdup (hex_str
);
1689 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1690 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1691 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1692 cpp_define_lazily (parse_in
, node
, lazy_hex_fp_value_count
++);
1696 /* Hex values are really cool and convenient, except that they're
1697 not supported in strict ISO C90 mode. First, the "p-" sequence
1698 is not valid as part of a preprocessor number. Second, we get a
1699 pedwarn from the preprocessor, which has no context, so we can't
1700 suppress the warning with __extension__.
1702 So instead what we do is construct the number in hex (because
1703 it's easy to get the exact correct value), parse it as a real,
1704 then print it back out as decimal. */
1706 real_from_string (&real
, hex_str
);
1707 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1710 /* Assemble the macro in the following fashion
1711 macro = fp_cast [dec_str fp_suffix] */
1712 sprintf (buf2
, "%s%s", dec_str
, fp_suffix
);
1713 sprintf (buf1
, fp_cast
, buf2
);
1714 sprintf (buf
, "%s=%s", macro
, buf1
);
1716 cpp_define (parse_in
, buf
);
1719 /* Return a string constant for the suffix for a value of type TYPE
1720 promoted according to the integer promotions. The type must be one
1721 of the standard integer type nodes. */
1724 type_suffix (tree type
)
1726 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1727 int unsigned_suffix
;
1729 int tp
= TYPE_PRECISION (type
);
1731 if (type
== long_long_integer_type_node
1732 || type
== long_long_unsigned_type_node
1733 || tp
> TYPE_PRECISION (long_integer_type_node
))
1735 else if (type
== long_integer_type_node
1736 || type
== long_unsigned_type_node
1737 || tp
> TYPE_PRECISION (integer_type_node
))
1739 else if (type
== integer_type_node
1740 || type
== unsigned_type_node
1741 || type
== short_integer_type_node
1742 || type
== short_unsigned_type_node
1743 || type
== signed_char_type_node
1744 || type
== unsigned_char_type_node
1745 /* ??? "char" is not a signed or unsigned integer type and
1746 so is not permitted for the standard typedefs, but some
1747 systems use it anyway. */
1748 || type
== char_type_node
)
1753 unsigned_suffix
= TYPE_UNSIGNED (type
);
1754 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1755 unsigned_suffix
= 0;
1756 return suffixes
[is_long
* 2 + unsigned_suffix
];
1759 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1761 builtin_define_constants (const char *macro
, tree type
)
1766 suffix
= type_suffix (type
);
1770 buf
= (char *) alloca (strlen (macro
) + 6);
1771 sprintf (buf
, "%s(c)=c", macro
);
1775 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1776 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1779 cpp_define (parse_in
, buf
);
1782 /* Define MAX for TYPE based on the precision of the type. */
1785 builtin_define_type_max (const char *macro
, tree type
)
1787 builtin_define_type_minmax (NULL
, macro
, type
);
1790 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1791 representation of that value. For example, a COUNT of 10 would
1795 print_bits_of_hex (char *buf
, int bufsz
, int count
)
1797 gcc_assert (bufsz
> 3);
1802 gcc_assert (count
> 0);
1804 switch (count
% 4) {
1825 gcc_assert (bufsz
> 1);
1830 gcc_assert (bufsz
> 0);
1834 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1835 precision of the type. */
1838 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1841 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1842 char value
[PBOH_SZ
];
1848 bits
= TYPE_PRECISION (type
) + (TYPE_UNSIGNED (type
) ? 0 : -1);
1850 print_bits_of_hex (value
, PBOH_SZ
, bits
);
1852 suffix
= type_suffix (type
);
1854 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1855 + strlen (suffix
) + 1);
1856 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1858 cpp_define (parse_in
, buf
);
1862 if (TYPE_UNSIGNED (type
))
1864 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1865 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1869 buf
= (char *) alloca (strlen (min_macro
) + 3
1870 + strlen (max_macro
) + 6);
1871 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1873 cpp_define (parse_in
, buf
);
1877 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1878 both types must have the same width. */
1881 builtin_define_type_width (const char *width_macro
, tree type
, tree type2
)
1883 if (type2
!= NULL_TREE
)
1884 gcc_assert (TYPE_PRECISION (type
) == TYPE_PRECISION (type2
));
1885 builtin_define_with_int_value (width_macro
, TYPE_PRECISION (type
));
1888 #include "gt-c-family-c-cppbuiltin.h"