1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
31 #include "stor-layout.h"
32 #include "stringpool.h"
37 #include "output.h" /* For user_label_prefix. */
38 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
39 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
41 #include "common/common-target.h"
42 #include "cpp-id-data.h"
43 #include "cppbuiltin.h"
45 #ifndef TARGET_OS_CPP_BUILTINS
46 # define TARGET_OS_CPP_BUILTINS()
49 #ifndef TARGET_OBJFMT_CPP_BUILTINS
50 # define TARGET_OBJFMT_CPP_BUILTINS()
53 #ifndef REGISTER_PREFIX
54 #define REGISTER_PREFIX ""
57 /* Non-static as some targets don't use it. */
58 static void builtin_define_with_hex_fp_value (const char *, tree,
62 static void builtin_define_stdint_macros (void);
63 static void builtin_define_constants (const char *, tree);
64 static void builtin_define_type_max (const char *, tree);
65 static void builtin_define_type_minmax (const char *, const char *, tree);
66 static void builtin_define_float_constants (const char *,
72 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
73 Originally this function used the fma optab, but that doesn't work with
74 -save-temps, so just rely on the HAVE_fma macros for the standard floating
78 mode_has_fma (machine_mode mode)
109 /* Define NAME with value TYPE size_unit. */
111 builtin_define_type_sizeof (const char *name, tree type)
113 builtin_define_with_int_value (name,
114 tree_to_uhwi (TYPE_SIZE_UNIT (type)));
117 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
120 builtin_define_float_constants (const char *name_prefix,
121 const char *fp_suffix,
123 const char *fma_suffix,
126 /* Used to convert radix-based values to base 10 values in several cases.
128 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
129 least 6 significant digits for correct results. Using the fraction
130 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
131 intermediate; perhaps someone can find a better approximation, in the
132 mean time, I suspect using doubles won't harm the bootstrap here. */
134 const double log10_2 = .30102999566398119521;
136 const struct real_format *fmt;
137 const struct real_format *ldfmt;
139 char name[64], buf[128];
140 int dig, min_10_exp, max_10_exp;
142 int type_decimal_dig;
144 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
145 gcc_assert (fmt->b != 10);
146 ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
147 gcc_assert (ldfmt->b != 10);
149 /* The radix of the exponent representation. */
150 if (type == float_type_node)
151 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
154 /* The number of radix digits, p, in the floating-point significand. */
155 sprintf (name, "__%s_MANT_DIG__", name_prefix);
156 builtin_define_with_int_value (name, fmt->p);
158 /* The number of decimal digits, q, such that any floating-point number
159 with q decimal digits can be rounded into a floating-point number with
160 p radix b digits and back again without change to the q decimal digits,
162 p log10 b if b is a power of 10
163 floor((p - 1) log10 b) otherwise
165 dig = (fmt->p - 1) * log10_b;
166 sprintf (name, "__%s_DIG__", name_prefix);
167 builtin_define_with_int_value (name, dig);
169 /* The minimum negative int x such that b**(x-1) is a normalized float. */
170 sprintf (name, "__%s_MIN_EXP__", name_prefix);
171 sprintf (buf, "(%d)", fmt->emin);
172 builtin_define_with_value (name, buf, 0);
174 /* The minimum negative int x such that 10**x is a normalized float,
176 ceil (log10 (b ** (emin - 1)))
177 = ceil (log10 (b) * (emin - 1))
179 Recall that emin is negative, so the integer truncation calculates
180 the ceiling, not the floor, in this case. */
181 min_10_exp = (fmt->emin - 1) * log10_b;
182 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
183 sprintf (buf, "(%d)", min_10_exp);
184 builtin_define_with_value (name, buf, 0);
186 /* The maximum int x such that b**(x-1) is a representable float. */
187 sprintf (name, "__%s_MAX_EXP__", name_prefix);
188 builtin_define_with_int_value (name, fmt->emax);
190 /* The maximum int x such that 10**x is in the range of representable
191 finite floating-point numbers,
193 floor (log10((1 - b**-p) * b**emax))
194 = floor (log10(1 - b**-p) + log10(b**emax))
195 = floor (log10(1 - b**-p) + log10(b)*emax)
197 The safest thing to do here is to just compute this number. But since
198 we don't link cc1 with libm, we cannot. We could implement log10 here
199 a series expansion, but that seems too much effort because:
201 Note that the first term, for all extant p, is a number exceedingly close
202 to zero, but slightly negative. Note that the second term is an integer
203 scaling an irrational number, and that because of the floor we are only
204 interested in its integral portion.
206 In order for the first term to have any effect on the integral portion
207 of the second term, the second term has to be exceedingly close to an
208 integer itself (e.g. 123.000000000001 or something). Getting a result
209 that close to an integer requires that the irrational multiplicand have
210 a long series of zeros in its expansion, which doesn't occur in the
211 first 20 digits or so of log10(b).
213 Hand-waving aside, crunching all of the sets of constants above by hand
214 does not yield a case for which the first term is significant, which
215 in the end is all that matters. */
216 max_10_exp = fmt->emax * log10_b;
217 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
218 builtin_define_with_int_value (name, max_10_exp);
220 /* The number of decimal digits, n, such that any floating-point number
221 can be rounded to n decimal digits and back again without change to
224 p * log10(b) if b is a power of 10
225 ceil(1 + p * log10(b)) otherwise
227 The only macro we care about is this number for the widest supported
228 floating type, but we want this value for rendering constants below. */
231 = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
232 decimal_dig = d_decimal_dig;
233 if (decimal_dig < d_decimal_dig)
236 /* Similar, for this type rather than long double. */
238 double type_d_decimal_dig = 1 + fmt->p * log10_b;
239 type_decimal_dig = type_d_decimal_dig;
240 if (type_decimal_dig < type_d_decimal_dig)
243 if (type == long_double_type_node)
244 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
247 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
248 builtin_define_with_int_value (name, type_decimal_dig);
251 /* Since, for the supported formats, B is always a power of 2, we
252 construct the following numbers directly as a hexadecimal
254 get_max_float (fmt, buf, sizeof (buf));
256 sprintf (name, "__%s_MAX__", name_prefix);
257 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
259 /* The minimum normalized positive floating-point number,
261 sprintf (name, "__%s_MIN__", name_prefix);
262 sprintf (buf, "0x1p%d", fmt->emin - 1);
263 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
265 /* The difference between 1 and the least value greater than 1 that is
266 representable in the given floating point type, b**(1-p). */
267 sprintf (name, "__%s_EPSILON__", name_prefix);
268 if (fmt->pnan < fmt->p)
269 /* This is an IBM extended double format, so 1.0 + any double is
270 representable precisely. */
271 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
273 sprintf (buf, "0x1p%d", 1 - fmt->p);
274 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
276 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
277 The minimum denormalized positive floating-point number, b**(emin-p).
278 The minimum normalized positive floating-point number for formats
279 that don't support denormals. */
280 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
281 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
282 builtin_define_with_hex_fp_value (name, type, decimal_dig,
283 buf, fp_suffix, fp_cast);
285 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
286 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
288 /* For C++ std::numeric_limits<T>::has_infinity. */
289 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
290 builtin_define_with_int_value (name,
291 MODE_HAS_INFINITIES (TYPE_MODE (type)));
292 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
293 predicate to distinguish a target that has both quiet and
294 signalling NaNs from a target that has only quiet NaNs or only
295 signalling NaNs, so we assume that a target that has any kind of
296 NaN has quiet NaNs. */
297 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
298 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
300 /* Note whether we have fast FMA. */
301 if (mode_has_fma (TYPE_MODE (type)))
303 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
304 builtin_define_with_int_value (name, 1);
308 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
310 builtin_define_decimal_float_constants (const char *name_prefix,
314 const struct real_format *fmt;
315 char name[64], buf[128], *p;
318 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
320 /* The number of radix digits, p, in the significand. */
321 sprintf (name, "__%s_MANT_DIG__", name_prefix);
322 builtin_define_with_int_value (name, fmt->p);
324 /* The minimum negative int x such that b**(x-1) is a normalized float. */
325 sprintf (name, "__%s_MIN_EXP__", name_prefix);
326 sprintf (buf, "(%d)", fmt->emin);
327 builtin_define_with_value (name, buf, 0);
329 /* The maximum int x such that b**(x-1) is a representable float. */
330 sprintf (name, "__%s_MAX_EXP__", name_prefix);
331 builtin_define_with_int_value (name, fmt->emax);
333 /* Compute the minimum representable value. */
334 sprintf (name, "__%s_MIN__", name_prefix);
335 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
336 builtin_define_with_value (name, buf, 0);
338 /* Compute the maximum representable value. */
339 sprintf (name, "__%s_MAX__", name_prefix);
341 for (digits = fmt->p; digits; digits--)
344 if (digits == fmt->p)
348 /* fmt->p plus 1, to account for the decimal point and fmt->emax
349 minus 1 because the digits are nines, not 1.0. */
350 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
351 builtin_define_with_value (name, buf, 0);
353 /* Compute epsilon (the difference between 1 and least value greater
354 than 1 representable). */
355 sprintf (name, "__%s_EPSILON__", name_prefix);
356 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
357 builtin_define_with_value (name, buf, 0);
359 /* Minimum subnormal positive decimal value. */
360 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
362 for (digits = fmt->p; digits > 1; digits--)
365 if (digits == fmt->p)
369 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
370 builtin_define_with_value (name, buf, 0);
373 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
376 builtin_define_fixed_point_constants (const char *name_prefix,
380 char name[64], buf[256], *new_buf;
383 sprintf (name, "__%s_FBIT__", name_prefix);
384 builtin_define_with_int_value (name, TYPE_FBIT (type));
386 sprintf (name, "__%s_IBIT__", name_prefix);
387 builtin_define_with_int_value (name, TYPE_IBIT (type));
389 /* If there is no suffix, defines are for fixed-point modes.
391 if (strcmp (suffix, "") == 0)
394 if (TYPE_UNSIGNED (type))
396 sprintf (name, "__%s_MIN__", name_prefix);
397 sprintf (buf, "0.0%s", suffix);
398 builtin_define_with_value (name, buf, 0);
402 sprintf (name, "__%s_MIN__", name_prefix);
403 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
404 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
405 TYPE_IBIT (type) - 1, suffix);
407 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
408 builtin_define_with_value (name, buf, 0);
411 sprintf (name, "__%s_MAX__", name_prefix);
414 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
416 sprintf (new_buf++, "%x", (1 << mod) - 1);
417 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
418 sprintf (new_buf++, "F");
419 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
420 builtin_define_with_value (name, buf, 0);
422 sprintf (name, "__%s_EPSILON__", name_prefix);
423 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
424 builtin_define_with_value (name, buf, 0);
427 /* Define macros used by <stdint.h>. */
429 builtin_define_stdint_macros (void)
431 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
432 builtin_define_constants ("__INTMAX_C", intmax_type_node);
433 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
434 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
435 if (sig_atomic_type_node)
436 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
437 sig_atomic_type_node);
439 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
441 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
443 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
445 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
447 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
448 if (c_uint16_type_node)
449 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
450 if (c_uint32_type_node)
451 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
452 if (c_uint64_type_node)
453 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
454 if (int_least8_type_node)
456 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
457 builtin_define_constants ("__INT8_C", int_least8_type_node);
459 if (int_least16_type_node)
461 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
462 builtin_define_constants ("__INT16_C", int_least16_type_node);
464 if (int_least32_type_node)
466 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
467 builtin_define_constants ("__INT32_C", int_least32_type_node);
469 if (int_least64_type_node)
471 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
472 builtin_define_constants ("__INT64_C", int_least64_type_node);
474 if (uint_least8_type_node)
476 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
477 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
479 if (uint_least16_type_node)
481 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
482 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
484 if (uint_least32_type_node)
486 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
487 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
489 if (uint_least64_type_node)
491 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
492 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
494 if (int_fast8_type_node)
495 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
496 if (int_fast16_type_node)
497 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
498 if (int_fast32_type_node)
499 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
500 if (int_fast64_type_node)
501 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
502 if (uint_fast8_type_node)
503 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
504 if (uint_fast16_type_node)
505 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
506 if (uint_fast32_type_node)
507 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
508 if (uint_fast64_type_node)
509 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
510 if (intptr_type_node)
511 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
512 if (uintptr_type_node)
513 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
516 /* Adjust the optimization macros when a #pragma GCC optimization is done to
517 reflect the current level. */
519 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
522 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
523 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
527 /* -undef turns off target-specific built-ins. */
531 /* Other target-independent built-ins determined by command-line
533 if (!prev->x_optimize_size && cur->x_optimize_size)
534 cpp_define (pfile, "__OPTIMIZE_SIZE__");
535 else if (prev->x_optimize_size && !cur->x_optimize_size)
536 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
538 if (!prev->x_optimize && cur->x_optimize)
539 cpp_define (pfile, "__OPTIMIZE__");
540 else if (prev->x_optimize && !cur->x_optimize)
541 cpp_undef (pfile, "__OPTIMIZE__");
543 prev_fast_math = fast_math_flags_struct_set_p (prev);
544 cur_fast_math = fast_math_flags_struct_set_p (cur);
545 if (!prev_fast_math && cur_fast_math)
546 cpp_define (pfile, "__FAST_MATH__");
547 else if (prev_fast_math && !cur_fast_math)
548 cpp_undef (pfile, "__FAST_MATH__");
550 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
551 cpp_define (pfile, "__SUPPORT_SNAN__");
552 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
553 cpp_undef (pfile, "__SUPPORT_SNAN__");
555 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
556 cpp_undef (pfile, "__NO_MATH_ERRNO__");
557 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
558 cpp_define (pfile, "__NO_MATH_ERRNO__");
560 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
562 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
563 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
565 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
567 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
568 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
573 /* This function will emit cpp macros to indicate the presence of various lock
574 free atomic operations. */
577 cpp_atomic_builtins (cpp_reader *pfile)
579 /* Set a flag for each size of object that compare and swap exists for up to
581 #define SWAP_LIMIT 17
582 bool have_swap[SWAP_LIMIT];
585 /* Clear the map of sizes compare_and swap exists for. */
586 memset (have_swap, 0, sizeof (have_swap));
588 /* Tell source code if the compiler makes sync_compare_and_swap
589 builtins available. */
590 #ifndef HAVE_sync_compare_and_swapqi
591 #define HAVE_sync_compare_and_swapqi 0
593 #ifndef HAVE_atomic_compare_and_swapqi
594 #define HAVE_atomic_compare_and_swapqi 0
597 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
599 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
603 #ifndef HAVE_sync_compare_and_swaphi
604 #define HAVE_sync_compare_and_swaphi 0
606 #ifndef HAVE_atomic_compare_and_swaphi
607 #define HAVE_atomic_compare_and_swaphi 0
609 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
611 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
615 #ifndef HAVE_sync_compare_and_swapsi
616 #define HAVE_sync_compare_and_swapsi 0
618 #ifndef HAVE_atomic_compare_and_swapsi
619 #define HAVE_atomic_compare_and_swapsi 0
621 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
623 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
627 #ifndef HAVE_sync_compare_and_swapdi
628 #define HAVE_sync_compare_and_swapdi 0
630 #ifndef HAVE_atomic_compare_and_swapdi
631 #define HAVE_atomic_compare_and_swapdi 0
633 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
635 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
639 #ifndef HAVE_sync_compare_and_swapti
640 #define HAVE_sync_compare_and_swapti 0
642 #ifndef HAVE_atomic_compare_and_swapti
643 #define HAVE_atomic_compare_and_swapti 0
645 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
647 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
648 have_swap[16] = true;
651 /* Tell the source code about various types. These map to the C++11 and C11
652 macros where 2 indicates lock-free always, and 1 indicates sometimes
654 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
655 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
656 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
657 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
658 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
659 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
660 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
661 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
662 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
663 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
664 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
665 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
666 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
667 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
668 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
669 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
670 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
671 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
672 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
673 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
675 /* If we're dealing with a "set" value that doesn't exactly correspond
676 to a boolean truth value, let the library work around that. */
677 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
678 targetm.atomic_test_and_set_trueval);
680 /* ptr_type_node can't be used here since ptr_mode is only set when
681 toplev calls backend_init which is not done with -E or pch. */
682 psize = POINTER_SIZE_UNITS;
683 if (psize >= SWAP_LIMIT)
685 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
686 (have_swap[psize]? 2 : 1));
689 /* Return the value for __GCC_IEC_559. */
691 cpp_iec_559_value (void)
693 /* The default is support for IEEE 754-2008. */
696 /* float and double must be binary32 and binary64. If they are but
697 with reversed NaN convention, at most IEEE 754-1985 is
699 const struct real_format *ffmt
700 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
701 const struct real_format *dfmt
702 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
703 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
708 || ffmt->emin != -125
710 || ffmt->signbit_rw != 31
711 || ffmt->round_towards_zero
712 || !ffmt->has_sign_dependent_rounding
716 || !ffmt->has_signed_zero
720 || dfmt->emin != -1021
721 || dfmt->emax != 1024
722 || dfmt->signbit_rw != 63
723 || dfmt->round_towards_zero
724 || !dfmt->has_sign_dependent_rounding
728 || !dfmt->has_signed_zero)
731 /* In strict C standards conformance mode, consider unpredictable
732 excess precision to mean lack of IEEE 754 support. The same
733 applies to unpredictable contraction. For C++, and outside
734 strict conformance mode, do not consider these options to mean
735 lack of IEEE 754 support. */
738 && TARGET_FLT_EVAL_METHOD != 0
739 && flag_excess_precision_cmdline != EXCESS_PRECISION_STANDARD)
743 && flag_fp_contract_mode == FP_CONTRACT_FAST)
746 /* Various options are contrary to IEEE 754 semantics. */
747 if (flag_unsafe_math_optimizations
748 || flag_associative_math
749 || flag_reciprocal_math
750 || flag_finite_math_only
751 || !flag_signed_zeros
752 || flag_single_precision_constant)
755 /* If the target does not support IEEE 754 exceptions and rounding
756 modes, consider IEEE 754 support to be absent. */
757 if (!targetm.float_exceptions_rounding_supported_p ())
763 /* Return the value for __GCC_IEC_559_COMPLEX. */
765 cpp_iec_559_complex_value (void)
767 /* The value is no bigger than that of __GCC_IEC_559. */
768 int ret = cpp_iec_559_value ();
770 /* Some options are contrary to the required default state of the
771 CX_LIMITED_RANGE pragma. */
772 if (flag_complex_method != 2)
778 /* Hook that registers front end and target-specific built-ins. */
780 c_cpp_builtins (cpp_reader *pfile)
784 /* -undef turns off target-specific built-ins. */
788 define_language_independent_builtin_macros (pfile);
790 if (c_dialect_cxx ())
793 parse_basever (&major, NULL, NULL);
794 cpp_define_formatted (pfile, "__GNUG__=%d", major);
797 /* For stddef.h. They require macros defined in c-common.c. */
798 c_stddef_cpp_builtins ();
800 /* Set include test macros for all C/C++ (not for just C++11 etc.)
801 The builtins __has_include__ and __has_include_next__ are defined
803 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
804 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
806 if (c_dialect_cxx ())
808 if (flag_weak && SUPPORTS_ONE_ONLY)
809 cpp_define (pfile, "__GXX_WEAK__=1");
811 cpp_define (pfile, "__GXX_WEAK__=0");
814 cpp_define (pfile, "__DEPRECATED");
818 cpp_define (pfile, "__GXX_RTTI");
819 cpp_define (pfile, "__cpp_rtti=199711");
822 if (cxx_dialect >= cxx11)
823 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
825 /* Binary literals have been allowed in g++ before C++11
826 and were standardized for C++14. */
827 if (!pedantic || cxx_dialect > cxx11)
828 cpp_define (pfile, "__cpp_binary_literals=201304");
830 /* Arrays of runtime bound were removed from C++14, but we still
831 support GNU VLAs. Let's define this macro to a low number
832 (corresponding to the initial test release of GNU C++) if we won't
833 complain about use of VLAs. */
835 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
836 cpp_define (pfile, "__cpp_runtime_arrays=198712");
838 if (cxx_dialect >= cxx11)
840 /* Set feature test macros for C++11 */
841 cpp_define (pfile, "__cpp_unicode_characters=200704");
842 cpp_define (pfile, "__cpp_raw_strings=200710");
843 cpp_define (pfile, "__cpp_unicode_literals=200710");
844 cpp_define (pfile, "__cpp_user_defined_literals=200809");
845 cpp_define (pfile, "__cpp_lambdas=200907");
846 if (cxx_dialect == cxx11)
847 cpp_define (pfile, "__cpp_constexpr=200704");
848 cpp_define (pfile, "__cpp_range_based_for=200907");
849 cpp_define (pfile, "__cpp_static_assert=200410");
850 cpp_define (pfile, "__cpp_decltype=200707");
851 cpp_define (pfile, "__cpp_attributes=200809");
852 cpp_define (pfile, "__cpp_rvalue_reference=200610");
853 cpp_define (pfile, "__cpp_variadic_templates=200704");
854 cpp_define (pfile, "__cpp_initializer_lists=200806");
855 cpp_define (pfile, "__cpp_delegating_constructors=200604");
856 cpp_define (pfile, "__cpp_nsdmi=200809");
857 cpp_define (pfile, "__cpp_inheriting_constructors=200802");
858 cpp_define (pfile, "__cpp_ref_qualifiers=200710");
859 cpp_define (pfile, "__cpp_alias_templates=200704");
861 if (cxx_dialect > cxx11)
863 /* Set feature test macros for C++14 */
864 cpp_define (pfile, "__cpp_return_type_deduction=201304");
865 cpp_define (pfile, "__cpp_init_captures=201304");
866 cpp_define (pfile, "__cpp_generic_lambdas=201304");
867 cpp_define (pfile, "__cpp_constexpr=201304");
868 cpp_define (pfile, "__cpp_decltype_auto=201304");
869 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
870 cpp_define (pfile, "__cpp_variable_templates=201304");
871 cpp_define (pfile, "__cpp_digit_separators=201309");
873 if (flag_sized_deallocation)
874 cpp_define (pfile, "__cpp_sized_deallocation=201309");
876 /* Note that we define this for C as well, so that we know if
877 __attribute__((cleanup)) will interface with EH. */
880 cpp_define (pfile, "__EXCEPTIONS");
881 if (c_dialect_cxx ())
882 cpp_define (pfile, "__cpp_exceptions=199711");
885 /* Represents the C++ ABI version, always defined so it can be used while
886 preprocessing C and assembler. */
887 if (flag_abi_version == 0)
888 /* We should have set this to something real in c_common_post_options. */
890 else if (flag_abi_version == 1)
891 /* Due to a historical accident, this version had the value
893 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
895 /* Newer versions have values 1002, 1003, .... */
896 builtin_define_with_int_value ("__GXX_ABI_VERSION",
897 1000 + flag_abi_version);
899 /* libgcc needs to know this. */
900 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
901 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
903 /* limits.h and stdint.h need to know these. */
904 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
905 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
906 builtin_define_type_max ("__INT_MAX__", integer_type_node);
907 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
908 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
909 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
910 underlying_wchar_type_node);
911 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
912 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
913 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
915 if (c_dialect_cxx ())
916 for (i = 0; i < NUM_INT_N_ENTS; i ++)
917 if (int_n_enabled_p[i])
921 /* These are used to configure the C++ library. */
923 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
925 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
926 cpp_define (parse_in, buf);
928 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
929 cpp_define (parse_in, buf);
933 /* stdint.h and the testsuite need to know these. */
934 builtin_define_stdint_macros ();
936 /* Provide information for library headers to determine whether to
937 define macros such as __STDC_IEC_559__ and
938 __STDC_IEC_559_COMPLEX__. */
939 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
940 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
941 cpp_iec_559_complex_value ());
943 /* float.h needs to know this. */
944 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
945 TARGET_FLT_EVAL_METHOD);
947 /* And decfloat.h needs this. */
948 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
949 TARGET_DEC_EVAL_METHOD);
951 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
952 /* Cast the double precision constants. This is needed when single
953 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
954 is used. The correct result is computed by the compiler when using
955 macros that include a cast. We use a different cast for C++ to avoid
956 problems with -Wold-style-cast. */
957 builtin_define_float_constants ("DBL", "L",
961 "", double_type_node);
962 builtin_define_float_constants ("LDBL", "L", "%s", "L",
963 long_double_type_node);
965 /* For decfloat.h. */
966 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
967 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
968 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
970 /* For fixed-point fibt, ibit, max, min, and epsilon. */
971 if (targetm.fixed_point_supported_p ())
973 builtin_define_fixed_point_constants ("SFRACT", "HR",
974 short_fract_type_node);
975 builtin_define_fixed_point_constants ("USFRACT", "UHR",
976 unsigned_short_fract_type_node);
977 builtin_define_fixed_point_constants ("FRACT", "R",
979 builtin_define_fixed_point_constants ("UFRACT", "UR",
980 unsigned_fract_type_node);
981 builtin_define_fixed_point_constants ("LFRACT", "LR",
982 long_fract_type_node);
983 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
984 unsigned_long_fract_type_node);
985 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
986 long_long_fract_type_node);
987 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
988 unsigned_long_long_fract_type_node);
989 builtin_define_fixed_point_constants ("SACCUM", "HK",
990 short_accum_type_node);
991 builtin_define_fixed_point_constants ("USACCUM", "UHK",
992 unsigned_short_accum_type_node);
993 builtin_define_fixed_point_constants ("ACCUM", "K",
995 builtin_define_fixed_point_constants ("UACCUM", "UK",
996 unsigned_accum_type_node);
997 builtin_define_fixed_point_constants ("LACCUM", "LK",
998 long_accum_type_node);
999 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1000 unsigned_long_accum_type_node);
1001 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1002 long_long_accum_type_node);
1003 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1004 unsigned_long_long_accum_type_node);
1006 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
1007 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
1008 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
1009 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
1010 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
1011 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
1012 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
1013 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
1014 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
1015 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
1016 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
1017 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
1018 builtin_define_fixed_point_constants ("DA", "", da_type_node);
1019 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
1020 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
1021 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
1022 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
1023 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
1026 /* For libgcc-internal use only. */
1027 if (flag_building_libgcc)
1029 /* Properties of floating-point modes for libgcc2.c. */
1030 for (machine_mode mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
1032 mode = GET_MODE_WIDER_MODE (mode))
1034 const char *name = GET_MODE_NAME (mode);
1036 = (char *) alloca (strlen (name)
1037 + sizeof ("__LIBGCC__MANT_DIG__"));
1038 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
1039 builtin_define_with_int_value (macro_name,
1040 REAL_MODE_FORMAT (mode)->p);
1041 if (!targetm.scalar_mode_supported_p (mode)
1042 || !targetm.libgcc_floating_mode_supported_p (mode))
1044 macro_name = (char *) alloca (strlen (name)
1045 + sizeof ("__LIBGCC_HAS__MODE__"));
1046 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
1047 cpp_define (pfile, macro_name);
1048 macro_name = (char *) alloca (strlen (name)
1049 + sizeof ("__LIBGCC__FUNC_EXT__"));
1050 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
1052 if (mode == TYPE_MODE (double_type_node))
1054 else if (mode == TYPE_MODE (float_type_node))
1056 else if (mode == TYPE_MODE (long_double_type_node))
1058 /* ??? The following assumes the built-in functions (defined
1059 in target-specific code) match the suffixes used for
1060 constants. Because in fact such functions are not
1061 defined for the 'w' suffix, 'l' is used there
1063 else if (mode == targetm.c.mode_for_suffix ('q'))
1065 else if (mode == targetm.c.mode_for_suffix ('w'))
1069 builtin_define_with_value (macro_name, suffix, 0);
1070 bool excess_precision = false;
1071 if (TARGET_FLT_EVAL_METHOD != 0
1072 && mode != TYPE_MODE (long_double_type_node)
1073 && (mode == TYPE_MODE (float_type_node)
1074 || mode == TYPE_MODE (double_type_node)))
1075 switch (TARGET_FLT_EVAL_METHOD)
1079 excess_precision = true;
1083 excess_precision = mode == TYPE_MODE (float_type_node);
1089 macro_name = (char *) alloca (strlen (name)
1090 + sizeof ("__LIBGCC__EXCESS_"
1092 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
1093 builtin_define_with_int_value (macro_name, excess_precision);
1096 /* For libgcc crtstuff.c and libgcc2.c. */
1097 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1098 EH_TABLES_CAN_BE_READ_ONLY);
1099 #ifdef EH_FRAME_SECTION_NAME
1100 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1101 EH_FRAME_SECTION_NAME, 1);
1103 #ifdef JCR_SECTION_NAME
1104 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
1105 JCR_SECTION_NAME, 1);
1107 #ifdef CTORS_SECTION_ASM_OP
1108 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1109 CTORS_SECTION_ASM_OP, 1);
1111 #ifdef DTORS_SECTION_ASM_OP
1112 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1113 DTORS_SECTION_ASM_OP, 1);
1115 #ifdef TEXT_SECTION_ASM_OP
1116 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1117 TEXT_SECTION_ASM_OP, 1);
1119 #ifdef INIT_SECTION_ASM_OP
1120 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1121 INIT_SECTION_ASM_OP, 1);
1123 #ifdef INIT_ARRAY_SECTION_ASM_OP
1124 /* Despite the name of this target macro, the expansion is not
1125 actually used, and may be empty rather than a string
1127 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1130 /* For libgcc enable-execute-stack.c. */
1131 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1134 /* For libgcc generic-morestack.c and unwinder code. */
1135 if (STACK_GROWS_DOWNWARD)
1136 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1138 /* For libgcc unwinder code. */
1139 #ifdef DONT_USE_BUILTIN_SETJMP
1140 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1142 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1143 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1144 DWARF_ALT_FRAME_RETURN_COLUMN);
1146 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1147 DWARF_FRAME_REGISTERS);
1148 #ifdef EH_RETURN_STACKADJ_RTX
1149 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1152 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1155 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1156 STACK_POINTER_REGNUM);
1159 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1160 TARGET_VTABLE_USES_DESCRIPTORS);
1163 /* For use in assembly language. */
1164 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1165 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1168 if (flag_gnu89_inline)
1169 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1171 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1174 cpp_define (pfile, "__NO_INLINE__");
1177 cpp_define (pfile, "__STRICT_ANSI__");
1179 if (!flag_signed_char)
1180 cpp_define (pfile, "__CHAR_UNSIGNED__");
1182 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1183 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1185 cpp_atomic_builtins (pfile);
1187 #ifdef DWARF2_UNWIND_INFO
1188 if (dwarf2out_do_cfi_asm ())
1189 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1192 /* Make the choice of ObjC runtime visible to source code. */
1193 if (c_dialect_objc () && flag_next_runtime)
1194 cpp_define (pfile, "__NEXT_RUNTIME__");
1196 /* Show the availability of some target pragmas. */
1197 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1199 /* Make the choice of the stack protector runtime visible to source code.
1200 The macro names and values here were chosen for compatibility with an
1201 earlier implementation, i.e. ProPolice. */
1202 if (flag_stack_protect == 4)
1203 cpp_define (pfile, "__SSP_EXPLICIT__=4");
1204 if (flag_stack_protect == 3)
1205 cpp_define (pfile, "__SSP_STRONG__=3");
1206 if (flag_stack_protect == 2)
1207 cpp_define (pfile, "__SSP_ALL__=2");
1208 else if (flag_stack_protect == 1)
1209 cpp_define (pfile, "__SSP__=1");
1212 cpp_define (pfile, "_OPENACC=201306");
1215 cpp_define (pfile, "_OPENMP=201307");
1217 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1218 if (int_n_enabled_p[i])
1221 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1222 builtin_define_type_sizeof (buf,
1223 int_n_trees[i].signed_type);
1225 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1226 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1227 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1228 unsigned_ptrdiff_type_node);
1230 /* A straightforward target hook doesn't work, because of problems
1231 linking that hook's body when part of non-C front ends. */
1232 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1233 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1234 # define builtin_define(TXT) cpp_define (pfile, TXT)
1235 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1236 TARGET_CPU_CPP_BUILTINS ();
1237 TARGET_OS_CPP_BUILTINS ();
1238 TARGET_OBJFMT_CPP_BUILTINS ();
1240 /* Support the __declspec keyword by turning them into attributes.
1241 Note that the current way we do this may result in a collision
1242 with predefined attributes later on. This can be solved by using
1243 one attribute, say __declspec__, and passing args to it. The
1244 problem with that approach is that args are not accumulated: each
1245 new appearance would clobber any existing args. */
1246 if (TARGET_DECLSPEC)
1247 builtin_define ("__declspec(x)=__attribute__((x))");
1249 /* If decimal floating point is supported, tell the user if the
1250 alternate format (BID) is used instead of the standard (DPD)
1252 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1253 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1256 /* Pass an object-like macro. If it doesn't lie in the user's
1257 namespace, defines it unconditionally. Otherwise define a version
1258 with two leading underscores, and another version with two leading
1259 and trailing underscores, and define the original only if an ISO
1260 standard was not nominated.
1262 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1263 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1266 builtin_define_std (const char *macro)
1268 size_t len = strlen (macro);
1269 char *buff = (char *) alloca (len + 5);
1273 /* prepend __ (or maybe just _) if in user's namespace. */
1274 memcpy (p, macro, len + 1);
1275 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1282 cpp_define (parse_in, p);
1284 /* If it was in user's namespace... */
1287 /* Define the macro with leading and following __. */
1293 cpp_define (parse_in, p);
1295 /* Finally, define the original macro if permitted. */
1297 cpp_define (parse_in, macro);
1301 /* Pass an object-like macro and a value to define it to. The third
1302 parameter says whether or not to turn the value into a string
1305 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1308 size_t mlen = strlen (macro);
1309 size_t elen = strlen (expansion);
1310 size_t extra = 2; /* space for an = and a NUL */
1314 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1317 extra += 2; /* space for two quote marks */
1318 for (p = expansion, q = quoted_expansion; *p; p++)
1343 if (ISPRINT ((unsigned char) *p))
1347 sprintf (q, "\\%03o", (unsigned char) *p);
1353 expansion = quoted_expansion;
1354 elen = q - expansion;
1357 buf = (char *) alloca (mlen + elen + extra);
1359 sprintf (buf, "%s=\"%s\"", macro, expansion);
1361 sprintf (buf, "%s=%s", macro, expansion);
1363 cpp_define (parse_in, buf);
1367 /* Pass an object-like macro and an integer value to define it to. */
1369 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1372 size_t mlen = strlen (macro);
1374 size_t extra = 2; /* space for = and NUL. */
1376 buf = (char *) alloca (mlen + vlen + extra);
1377 memcpy (buf, macro, mlen);
1379 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1381 cpp_define (parse_in, buf);
1384 /* builtin_define_with_hex_fp_value is very expensive, so the following
1385 array and function allows it to be done lazily when __DBL_MAX__
1386 etc. is first used. */
1388 struct GTY(()) lazy_hex_fp_value_struct
1390 const char *hex_str;
1394 const char *fp_suffix;
1396 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
1397 static GTY(()) int lazy_hex_fp_value_count;
1400 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1403 REAL_VALUE_TYPE real;
1404 char dec_str[64], buf1[256];
1406 if (node->value.builtin < BT_FIRST_USER
1407 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1410 idx = node->value.builtin - BT_FIRST_USER;
1411 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1412 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1413 lazy_hex_fp_values[idx].digits, 0,
1414 lazy_hex_fp_values[idx].mode);
1416 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1417 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1418 node->value.macro = lazy_hex_fp_values[idx].macro;
1419 for (idx = 0; idx < node->value.macro->count; idx++)
1420 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1422 gcc_assert (idx < node->value.macro->count);
1423 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1424 node->value.macro->exp.tokens[idx].val.str.text
1425 = (const unsigned char *) ggc_strdup (buf1);
1429 /* Pass an object-like macro a hexadecimal floating-point value. */
1431 builtin_define_with_hex_fp_value (const char *macro,
1432 tree type, int digits,
1433 const char *hex_str,
1434 const char *fp_suffix,
1435 const char *fp_cast)
1437 REAL_VALUE_TYPE real;
1438 char dec_str[64], buf1[256], buf2[256];
1440 /* This is very expensive, so if possible expand them lazily. */
1441 if (lazy_hex_fp_value_count < 12
1442 && flag_dump_macros == 0
1443 && !cpp_get_options (parse_in)->traditional)
1445 struct cpp_hashnode *node;
1446 if (lazy_hex_fp_value_count == 0)
1447 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1448 sprintf (buf2, fp_cast, "1.1");
1449 sprintf (buf1, "%s=%s", macro, buf2);
1450 cpp_define (parse_in, buf1);
1451 node = C_CPP_HASHNODE (get_identifier (macro));
1452 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1453 = ggc_strdup (hex_str);
1454 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1455 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1456 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1457 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1458 node->flags |= NODE_BUILTIN;
1460 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1461 lazy_hex_fp_value_count++;
1465 /* Hex values are really cool and convenient, except that they're
1466 not supported in strict ISO C90 mode. First, the "p-" sequence
1467 is not valid as part of a preprocessor number. Second, we get a
1468 pedwarn from the preprocessor, which has no context, so we can't
1469 suppress the warning with __extension__.
1471 So instead what we do is construct the number in hex (because
1472 it's easy to get the exact correct value), parse it as a real,
1473 then print it back out as decimal. */
1475 real_from_string (&real, hex_str);
1476 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1479 /* Assemble the macro in the following fashion
1480 macro = fp_cast [dec_str fp_suffix] */
1481 sprintf (buf1, "%s%s", dec_str, fp_suffix);
1482 sprintf (buf2, fp_cast, buf1);
1483 sprintf (buf1, "%s=%s", macro, buf2);
1485 cpp_define (parse_in, buf1);
1488 /* Return a string constant for the suffix for a value of type TYPE
1489 promoted according to the integer promotions. The type must be one
1490 of the standard integer type nodes. */
1493 type_suffix (tree type)
1495 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1496 int unsigned_suffix;
1498 int tp = TYPE_PRECISION (type);
1500 if (type == long_long_integer_type_node
1501 || type == long_long_unsigned_type_node
1502 || tp > TYPE_PRECISION (long_integer_type_node))
1504 else if (type == long_integer_type_node
1505 || type == long_unsigned_type_node
1506 || tp > TYPE_PRECISION (integer_type_node))
1508 else if (type == integer_type_node
1509 || type == unsigned_type_node
1510 || type == short_integer_type_node
1511 || type == short_unsigned_type_node
1512 || type == signed_char_type_node
1513 || type == unsigned_char_type_node
1514 /* ??? "char" is not a signed or unsigned integer type and
1515 so is not permitted for the standard typedefs, but some
1516 systems use it anyway. */
1517 || type == char_type_node)
1522 unsigned_suffix = TYPE_UNSIGNED (type);
1523 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1524 unsigned_suffix = 0;
1525 return suffixes[is_long * 2 + unsigned_suffix];
1528 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1530 builtin_define_constants (const char *macro, tree type)
1535 suffix = type_suffix (type);
1539 buf = (char *) alloca (strlen (macro) + 6);
1540 sprintf (buf, "%s(c)=c", macro);
1544 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1545 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1548 cpp_define (parse_in, buf);
1551 /* Define MAX for TYPE based on the precision of the type. */
1554 builtin_define_type_max (const char *macro, tree type)
1556 builtin_define_type_minmax (NULL, macro, type);
1559 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1560 representation of that value. For example, a COUNT of 10 would
1564 print_bits_of_hex (char *buf, int bufsz, int count)
1566 gcc_assert (bufsz > 3);
1571 gcc_assert (count > 0);
1573 switch (count % 4) {
1594 gcc_assert (bufsz > 1);
1599 gcc_assert (bufsz > 0);
1603 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1604 precision of the type. */
1607 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1610 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1611 char value[PBOH_SZ];
1617 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1619 print_bits_of_hex (value, PBOH_SZ, bits);
1621 suffix = type_suffix (type);
1623 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1624 + strlen (suffix) + 1);
1625 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1627 cpp_define (parse_in, buf);
1631 if (TYPE_UNSIGNED (type))
1633 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1634 sprintf (buf, "%s=0%s", min_macro, suffix);
1638 buf = (char *) alloca (strlen (min_macro) + 3
1639 + strlen (max_macro) + 6);
1640 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1642 cpp_define (parse_in, buf);
1646 #include "gt-c-family-c-cppbuiltin.h"