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"
27 #include "double-int.h"
34 #include "stor-layout.h"
35 #include "stringpool.h"
40 #include "output.h" /* For user_label_prefix. */
41 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
42 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
44 #include "common/common-target.h"
45 #include "cpp-id-data.h"
46 #include "cppbuiltin.h"
48 #ifndef TARGET_OS_CPP_BUILTINS
49 # define TARGET_OS_CPP_BUILTINS()
52 #ifndef TARGET_OBJFMT_CPP_BUILTINS
53 # define TARGET_OBJFMT_CPP_BUILTINS()
56 #ifndef REGISTER_PREFIX
57 #define REGISTER_PREFIX ""
60 /* Non-static as some targets don't use it. */
61 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
62 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
63 static void builtin_define_with_hex_fp_value (const char *, tree,
67 static void builtin_define_stdint_macros (void);
68 static void builtin_define_constants (const char *, tree);
69 static void builtin_define_type_max (const char *, tree);
70 static void builtin_define_type_minmax (const char *, const char *, tree);
71 static void builtin_define_type_sizeof (const char *, tree);
72 static void builtin_define_float_constants (const char *,
78 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
79 Originally this function used the fma optab, but that doesn't work with
80 -save-temps, so just rely on the HAVE_fma macros for the standard floating
84 mode_has_fma (machine_mode mode)
100 return !!HAVE_fmaxf4;
105 return !!HAVE_fmatf4;
115 /* Define NAME with value TYPE size_unit. */
117 builtin_define_type_sizeof (const char *name, tree type)
119 builtin_define_with_int_value (name,
120 tree_to_uhwi (TYPE_SIZE_UNIT (type)));
123 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
126 builtin_define_float_constants (const char *name_prefix,
127 const char *fp_suffix,
129 const char *fma_suffix,
132 /* Used to convert radix-based values to base 10 values in several cases.
134 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
135 least 6 significant digits for correct results. Using the fraction
136 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
137 intermediate; perhaps someone can find a better approximation, in the
138 mean time, I suspect using doubles won't harm the bootstrap here. */
140 const double log10_2 = .30102999566398119521;
142 const struct real_format *fmt;
143 const struct real_format *ldfmt;
145 char name[64], buf[128];
146 int dig, min_10_exp, max_10_exp;
148 int type_decimal_dig;
150 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
151 gcc_assert (fmt->b != 10);
152 ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
153 gcc_assert (ldfmt->b != 10);
155 /* The radix of the exponent representation. */
156 if (type == float_type_node)
157 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
160 /* The number of radix digits, p, in the floating-point significand. */
161 sprintf (name, "__%s_MANT_DIG__", name_prefix);
162 builtin_define_with_int_value (name, fmt->p);
164 /* The number of decimal digits, q, such that any floating-point number
165 with q decimal digits can be rounded into a floating-point number with
166 p radix b digits and back again without change to the q decimal digits,
168 p log10 b if b is a power of 10
169 floor((p - 1) log10 b) otherwise
171 dig = (fmt->p - 1) * log10_b;
172 sprintf (name, "__%s_DIG__", name_prefix);
173 builtin_define_with_int_value (name, dig);
175 /* The minimum negative int x such that b**(x-1) is a normalized float. */
176 sprintf (name, "__%s_MIN_EXP__", name_prefix);
177 sprintf (buf, "(%d)", fmt->emin);
178 builtin_define_with_value (name, buf, 0);
180 /* The minimum negative int x such that 10**x is a normalized float,
182 ceil (log10 (b ** (emin - 1)))
183 = ceil (log10 (b) * (emin - 1))
185 Recall that emin is negative, so the integer truncation calculates
186 the ceiling, not the floor, in this case. */
187 min_10_exp = (fmt->emin - 1) * log10_b;
188 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
189 sprintf (buf, "(%d)", min_10_exp);
190 builtin_define_with_value (name, buf, 0);
192 /* The maximum int x such that b**(x-1) is a representable float. */
193 sprintf (name, "__%s_MAX_EXP__", name_prefix);
194 builtin_define_with_int_value (name, fmt->emax);
196 /* The maximum int x such that 10**x is in the range of representable
197 finite floating-point numbers,
199 floor (log10((1 - b**-p) * b**emax))
200 = floor (log10(1 - b**-p) + log10(b**emax))
201 = floor (log10(1 - b**-p) + log10(b)*emax)
203 The safest thing to do here is to just compute this number. But since
204 we don't link cc1 with libm, we cannot. We could implement log10 here
205 a series expansion, but that seems too much effort because:
207 Note that the first term, for all extant p, is a number exceedingly close
208 to zero, but slightly negative. Note that the second term is an integer
209 scaling an irrational number, and that because of the floor we are only
210 interested in its integral portion.
212 In order for the first term to have any effect on the integral portion
213 of the second term, the second term has to be exceedingly close to an
214 integer itself (e.g. 123.000000000001 or something). Getting a result
215 that close to an integer requires that the irrational multiplicand have
216 a long series of zeros in its expansion, which doesn't occur in the
217 first 20 digits or so of log10(b).
219 Hand-waving aside, crunching all of the sets of constants above by hand
220 does not yield a case for which the first term is significant, which
221 in the end is all that matters. */
222 max_10_exp = fmt->emax * log10_b;
223 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
224 builtin_define_with_int_value (name, max_10_exp);
226 /* The number of decimal digits, n, such that any floating-point number
227 can be rounded to n decimal digits and back again without change to
230 p * log10(b) if b is a power of 10
231 ceil(1 + p * log10(b)) otherwise
233 The only macro we care about is this number for the widest supported
234 floating type, but we want this value for rendering constants below. */
237 = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
238 decimal_dig = d_decimal_dig;
239 if (decimal_dig < d_decimal_dig)
242 /* Similar, for this type rather than long double. */
244 double type_d_decimal_dig = 1 + fmt->p * log10_b;
245 type_decimal_dig = type_d_decimal_dig;
246 if (type_decimal_dig < type_d_decimal_dig)
249 if (type == long_double_type_node)
250 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
253 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
254 builtin_define_with_int_value (name, type_decimal_dig);
257 /* Since, for the supported formats, B is always a power of 2, we
258 construct the following numbers directly as a hexadecimal
260 get_max_float (fmt, buf, sizeof (buf));
262 sprintf (name, "__%s_MAX__", name_prefix);
263 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
265 /* The minimum normalized positive floating-point number,
267 sprintf (name, "__%s_MIN__", name_prefix);
268 sprintf (buf, "0x1p%d", fmt->emin - 1);
269 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
271 /* The difference between 1 and the least value greater than 1 that is
272 representable in the given floating point type, b**(1-p). */
273 sprintf (name, "__%s_EPSILON__", name_prefix);
274 if (fmt->pnan < fmt->p)
275 /* This is an IBM extended double format, so 1.0 + any double is
276 representable precisely. */
277 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
279 sprintf (buf, "0x1p%d", 1 - fmt->p);
280 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
282 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
283 The minimum denormalized positive floating-point number, b**(emin-p).
284 The minimum normalized positive floating-point number for formats
285 that don't support denormals. */
286 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
287 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
288 builtin_define_with_hex_fp_value (name, type, decimal_dig,
289 buf, fp_suffix, fp_cast);
291 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
292 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
294 /* For C++ std::numeric_limits<T>::has_infinity. */
295 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
296 builtin_define_with_int_value (name,
297 MODE_HAS_INFINITIES (TYPE_MODE (type)));
298 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
299 predicate to distinguish a target that has both quiet and
300 signalling NaNs from a target that has only quiet NaNs or only
301 signalling NaNs, so we assume that a target that has any kind of
302 NaN has quiet NaNs. */
303 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
304 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
306 /* Note whether we have fast FMA. */
307 if (mode_has_fma (TYPE_MODE (type)))
309 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
310 builtin_define_with_int_value (name, 1);
314 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
316 builtin_define_decimal_float_constants (const char *name_prefix,
320 const struct real_format *fmt;
321 char name[64], buf[128], *p;
324 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
326 /* The number of radix digits, p, in the significand. */
327 sprintf (name, "__%s_MANT_DIG__", name_prefix);
328 builtin_define_with_int_value (name, fmt->p);
330 /* The minimum negative int x such that b**(x-1) is a normalized float. */
331 sprintf (name, "__%s_MIN_EXP__", name_prefix);
332 sprintf (buf, "(%d)", fmt->emin);
333 builtin_define_with_value (name, buf, 0);
335 /* The maximum int x such that b**(x-1) is a representable float. */
336 sprintf (name, "__%s_MAX_EXP__", name_prefix);
337 builtin_define_with_int_value (name, fmt->emax);
339 /* Compute the minimum representable value. */
340 sprintf (name, "__%s_MIN__", name_prefix);
341 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
342 builtin_define_with_value (name, buf, 0);
344 /* Compute the maximum representable value. */
345 sprintf (name, "__%s_MAX__", name_prefix);
347 for (digits = fmt->p; digits; digits--)
350 if (digits == fmt->p)
354 /* fmt->p plus 1, to account for the decimal point and fmt->emax
355 minus 1 because the digits are nines, not 1.0. */
356 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
357 builtin_define_with_value (name, buf, 0);
359 /* Compute epsilon (the difference between 1 and least value greater
360 than 1 representable). */
361 sprintf (name, "__%s_EPSILON__", name_prefix);
362 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
363 builtin_define_with_value (name, buf, 0);
365 /* Minimum subnormal positive decimal value. */
366 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
368 for (digits = fmt->p; digits > 1; digits--)
371 if (digits == fmt->p)
375 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
376 builtin_define_with_value (name, buf, 0);
379 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
382 builtin_define_fixed_point_constants (const char *name_prefix,
386 char name[64], buf[256], *new_buf;
389 sprintf (name, "__%s_FBIT__", name_prefix);
390 builtin_define_with_int_value (name, TYPE_FBIT (type));
392 sprintf (name, "__%s_IBIT__", name_prefix);
393 builtin_define_with_int_value (name, TYPE_IBIT (type));
395 /* If there is no suffix, defines are for fixed-point modes.
397 if (strcmp (suffix, "") == 0)
400 if (TYPE_UNSIGNED (type))
402 sprintf (name, "__%s_MIN__", name_prefix);
403 sprintf (buf, "0.0%s", suffix);
404 builtin_define_with_value (name, buf, 0);
408 sprintf (name, "__%s_MIN__", name_prefix);
409 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
410 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
411 TYPE_IBIT (type) - 1, suffix);
413 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
414 builtin_define_with_value (name, buf, 0);
417 sprintf (name, "__%s_MAX__", name_prefix);
420 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
422 sprintf (new_buf++, "%x", (1 << mod) - 1);
423 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
424 sprintf (new_buf++, "F");
425 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
426 builtin_define_with_value (name, buf, 0);
428 sprintf (name, "__%s_EPSILON__", name_prefix);
429 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
430 builtin_define_with_value (name, buf, 0);
433 /* Define macros used by <stdint.h>. */
435 builtin_define_stdint_macros (void)
437 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
438 builtin_define_constants ("__INTMAX_C", intmax_type_node);
439 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
440 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
441 if (sig_atomic_type_node)
442 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
443 sig_atomic_type_node);
445 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
447 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
449 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
451 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
453 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
454 if (c_uint16_type_node)
455 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
456 if (c_uint32_type_node)
457 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
458 if (c_uint64_type_node)
459 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
460 if (int_least8_type_node)
462 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
463 builtin_define_constants ("__INT8_C", int_least8_type_node);
465 if (int_least16_type_node)
467 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
468 builtin_define_constants ("__INT16_C", int_least16_type_node);
470 if (int_least32_type_node)
472 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
473 builtin_define_constants ("__INT32_C", int_least32_type_node);
475 if (int_least64_type_node)
477 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
478 builtin_define_constants ("__INT64_C", int_least64_type_node);
480 if (uint_least8_type_node)
482 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
483 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
485 if (uint_least16_type_node)
487 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
488 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
490 if (uint_least32_type_node)
492 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
493 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
495 if (uint_least64_type_node)
497 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
498 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
500 if (int_fast8_type_node)
501 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
502 if (int_fast16_type_node)
503 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
504 if (int_fast32_type_node)
505 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
506 if (int_fast64_type_node)
507 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
508 if (uint_fast8_type_node)
509 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
510 if (uint_fast16_type_node)
511 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
512 if (uint_fast32_type_node)
513 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
514 if (uint_fast64_type_node)
515 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
516 if (intptr_type_node)
517 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
518 if (uintptr_type_node)
519 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
522 /* Adjust the optimization macros when a #pragma GCC optimization is done to
523 reflect the current level. */
525 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
528 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
529 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
533 /* -undef turns off target-specific built-ins. */
537 /* Other target-independent built-ins determined by command-line
539 if (!prev->x_optimize_size && cur->x_optimize_size)
540 cpp_define (pfile, "__OPTIMIZE_SIZE__");
541 else if (prev->x_optimize_size && !cur->x_optimize_size)
542 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
544 if (!prev->x_optimize && cur->x_optimize)
545 cpp_define (pfile, "__OPTIMIZE__");
546 else if (prev->x_optimize && !cur->x_optimize)
547 cpp_undef (pfile, "__OPTIMIZE__");
549 prev_fast_math = fast_math_flags_struct_set_p (prev);
550 cur_fast_math = fast_math_flags_struct_set_p (cur);
551 if (!prev_fast_math && cur_fast_math)
552 cpp_define (pfile, "__FAST_MATH__");
553 else if (prev_fast_math && !cur_fast_math)
554 cpp_undef (pfile, "__FAST_MATH__");
556 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
557 cpp_define (pfile, "__SUPPORT_SNAN__");
558 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
559 cpp_undef (pfile, "__SUPPORT_SNAN__");
561 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
562 cpp_undef (pfile, "__NO_MATH_ERRNO__");
563 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
564 cpp_define (pfile, "__NO_MATH_ERRNO__");
566 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
568 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
569 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
571 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
573 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
574 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
579 /* This function will emit cpp macros to indicate the presence of various lock
580 free atomic operations. */
583 cpp_atomic_builtins (cpp_reader *pfile)
585 /* Set a flag for each size of object that compare and swap exists for up to
587 #define SWAP_LIMIT 17
588 bool have_swap[SWAP_LIMIT];
591 /* Clear the map of sizes compare_and swap exists for. */
592 memset (have_swap, 0, sizeof (have_swap));
594 /* Tell source code if the compiler makes sync_compare_and_swap
595 builtins available. */
596 #ifndef HAVE_sync_compare_and_swapqi
597 #define HAVE_sync_compare_and_swapqi 0
599 #ifndef HAVE_atomic_compare_and_swapqi
600 #define HAVE_atomic_compare_and_swapqi 0
603 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
605 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
609 #ifndef HAVE_sync_compare_and_swaphi
610 #define HAVE_sync_compare_and_swaphi 0
612 #ifndef HAVE_atomic_compare_and_swaphi
613 #define HAVE_atomic_compare_and_swaphi 0
615 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
617 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
621 #ifndef HAVE_sync_compare_and_swapsi
622 #define HAVE_sync_compare_and_swapsi 0
624 #ifndef HAVE_atomic_compare_and_swapsi
625 #define HAVE_atomic_compare_and_swapsi 0
627 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
629 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
633 #ifndef HAVE_sync_compare_and_swapdi
634 #define HAVE_sync_compare_and_swapdi 0
636 #ifndef HAVE_atomic_compare_and_swapdi
637 #define HAVE_atomic_compare_and_swapdi 0
639 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
641 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
645 #ifndef HAVE_sync_compare_and_swapti
646 #define HAVE_sync_compare_and_swapti 0
648 #ifndef HAVE_atomic_compare_and_swapti
649 #define HAVE_atomic_compare_and_swapti 0
651 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
653 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
654 have_swap[16] = true;
657 /* Tell the source code about various types. These map to the C++11 and C11
658 macros where 2 indicates lock-free always, and 1 indicates sometimes
660 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
661 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
662 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
663 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
664 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
665 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
666 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
667 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
668 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
669 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
670 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
671 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
672 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
673 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
674 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
675 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
676 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
677 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
678 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
679 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
681 /* If we're dealing with a "set" value that doesn't exactly correspond
682 to a boolean truth value, let the library work around that. */
683 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
684 targetm.atomic_test_and_set_trueval);
686 /* ptr_type_node can't be used here since ptr_mode is only set when
687 toplev calls backend_init which is not done with -E or pch. */
688 psize = POINTER_SIZE_UNITS;
689 if (psize >= SWAP_LIMIT)
691 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
692 (have_swap[psize]? 2 : 1));
695 /* Return the value for __GCC_IEC_559. */
697 cpp_iec_559_value (void)
699 /* The default is support for IEEE 754-2008. */
702 /* float and double must be binary32 and binary64. If they are but
703 with reversed NaN convention, at most IEEE 754-1985 is
705 const struct real_format *ffmt
706 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
707 const struct real_format *dfmt
708 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
709 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
714 || ffmt->emin != -125
716 || ffmt->signbit_rw != 31
717 || ffmt->round_towards_zero
718 || !ffmt->has_sign_dependent_rounding
722 || !ffmt->has_signed_zero
726 || dfmt->emin != -1021
727 || dfmt->emax != 1024
728 || dfmt->signbit_rw != 63
729 || dfmt->round_towards_zero
730 || !dfmt->has_sign_dependent_rounding
734 || !dfmt->has_signed_zero)
737 /* In strict C standards conformance mode, consider unpredictable
738 excess precision to mean lack of IEEE 754 support. The same
739 applies to unpredictable contraction. For C++, and outside
740 strict conformance mode, do not consider these options to mean
741 lack of IEEE 754 support. */
744 && TARGET_FLT_EVAL_METHOD != 0
745 && flag_excess_precision_cmdline != EXCESS_PRECISION_STANDARD)
749 && flag_fp_contract_mode == FP_CONTRACT_FAST)
752 /* Various options are contrary to IEEE 754 semantics. */
753 if (flag_unsafe_math_optimizations
754 || flag_associative_math
755 || flag_reciprocal_math
756 || flag_finite_math_only
757 || !flag_signed_zeros
758 || flag_single_precision_constant)
761 /* If the target does not support IEEE 754 exceptions and rounding
762 modes, consider IEEE 754 support to be absent. */
763 if (!targetm.float_exceptions_rounding_supported_p ())
769 /* Return the value for __GCC_IEC_559_COMPLEX. */
771 cpp_iec_559_complex_value (void)
773 /* The value is no bigger than that of __GCC_IEC_559. */
774 int ret = cpp_iec_559_value ();
776 /* Some options are contrary to the required default state of the
777 CX_LIMITED_RANGE pragma. */
778 if (flag_complex_method != 2)
784 /* Hook that registers front end and target-specific built-ins. */
786 c_cpp_builtins (cpp_reader *pfile)
790 /* -undef turns off target-specific built-ins. */
794 define_language_independent_builtin_macros (pfile);
796 if (c_dialect_cxx ())
799 parse_basever (&major, NULL, NULL);
800 cpp_define_formatted (pfile, "__GNUG__=%d", major);
803 /* For stddef.h. They require macros defined in c-common.c. */
804 c_stddef_cpp_builtins ();
806 /* Set include test macros for all C/C++ (not for just C++11 etc.)
807 The builtins __has_include__ and __has_include_next__ are defined
809 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
810 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
812 if (c_dialect_cxx ())
814 if (flag_weak && SUPPORTS_ONE_ONLY)
815 cpp_define (pfile, "__GXX_WEAK__=1");
817 cpp_define (pfile, "__GXX_WEAK__=0");
820 cpp_define (pfile, "__DEPRECATED");
824 cpp_define (pfile, "__GXX_RTTI");
825 cpp_define (pfile, "__cpp_rtti=199711");
828 if (cxx_dialect >= cxx11)
829 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
831 /* Binary literals have been allowed in g++ before C++11
832 and were standardized for C++14. */
833 if (!pedantic || cxx_dialect > cxx11)
834 cpp_define (pfile, "__cpp_binary_literals=201304");
836 /* Arrays of runtime bound were removed from C++14, but we still
837 support GNU VLAs. Let's define this macro to a low number
838 (corresponding to the initial test release of GNU C++) if we won't
839 complain about use of VLAs. */
841 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
842 cpp_define (pfile, "__cpp_runtime_arrays=198712");
844 if (cxx_dialect >= cxx11)
846 /* Set feature test macros for C++11 */
847 cpp_define (pfile, "__cpp_unicode_characters=200704");
848 cpp_define (pfile, "__cpp_raw_strings=200710");
849 cpp_define (pfile, "__cpp_unicode_literals=200710");
850 cpp_define (pfile, "__cpp_user_defined_literals=200809");
851 cpp_define (pfile, "__cpp_lambdas=200907");
852 if (cxx_dialect == cxx11)
853 cpp_define (pfile, "__cpp_constexpr=200704");
854 cpp_define (pfile, "__cpp_range_based_for=200907");
855 cpp_define (pfile, "__cpp_static_assert=200410");
856 cpp_define (pfile, "__cpp_decltype=200707");
857 cpp_define (pfile, "__cpp_attributes=200809");
858 cpp_define (pfile, "__cpp_rvalue_reference=200610");
859 cpp_define (pfile, "__cpp_variadic_templates=200704");
860 cpp_define (pfile, "__cpp_initializer_lists=200806");
861 cpp_define (pfile, "__cpp_delegating_constructors=200604");
862 cpp_define (pfile, "__cpp_nsdmi=200809");
863 cpp_define (pfile, "__cpp_inheriting_constructors=200802");
864 cpp_define (pfile, "__cpp_ref_qualifiers=200710");
865 cpp_define (pfile, "__cpp_alias_templates=200704");
867 if (cxx_dialect > cxx11)
869 /* Set feature test macros for C++14 */
870 cpp_define (pfile, "__cpp_return_type_deduction=201304");
871 cpp_define (pfile, "__cpp_init_captures=201304");
872 cpp_define (pfile, "__cpp_generic_lambdas=201304");
873 cpp_define (pfile, "__cpp_constexpr=201304");
874 cpp_define (pfile, "__cpp_decltype_auto=201304");
875 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
876 cpp_define (pfile, "__cpp_variable_templates=201304");
877 cpp_define (pfile, "__cpp_digit_separators=201309");
879 if (flag_sized_deallocation)
880 cpp_define (pfile, "__cpp_sized_deallocation=201309");
882 /* Note that we define this for C as well, so that we know if
883 __attribute__((cleanup)) will interface with EH. */
886 cpp_define (pfile, "__EXCEPTIONS");
887 if (c_dialect_cxx ())
888 cpp_define (pfile, "__cpp_exceptions=199711");
891 /* Represents the C++ ABI version, always defined so it can be used while
892 preprocessing C and assembler. */
893 if (flag_abi_version == 0)
894 /* Use a very large value so that:
896 #if __GXX_ABI_VERSION >= <value for version X>
898 will work whether the user explicitly says "-fabi-version=x" or
899 "-fabi-version=0". Do not use INT_MAX because that will be
900 different from system to system. */
901 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
902 else if (flag_abi_version == 1)
903 /* Due to a historical accident, this version had the value
905 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
907 /* Newer versions have values 1002, 1003, .... */
908 builtin_define_with_int_value ("__GXX_ABI_VERSION",
909 1000 + flag_abi_version);
911 /* libgcc needs to know this. */
912 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
913 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
915 /* limits.h and stdint.h need to know these. */
916 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
917 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
918 builtin_define_type_max ("__INT_MAX__", integer_type_node);
919 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
920 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
921 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
922 underlying_wchar_type_node);
923 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
924 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
925 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
927 if (c_dialect_cxx ())
928 for (i = 0; i < NUM_INT_N_ENTS; i ++)
929 if (int_n_enabled_p[i])
933 /* These are used to configure the C++ library. */
935 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
937 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
938 cpp_define (parse_in, buf);
940 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
941 cpp_define (parse_in, buf);
945 /* stdint.h and the testsuite need to know these. */
946 builtin_define_stdint_macros ();
948 /* Provide information for library headers to determine whether to
949 define macros such as __STDC_IEC_559__ and
950 __STDC_IEC_559_COMPLEX__. */
951 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
952 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
953 cpp_iec_559_complex_value ());
955 /* float.h needs to know this. */
956 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
957 TARGET_FLT_EVAL_METHOD);
959 /* And decfloat.h needs this. */
960 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
961 TARGET_DEC_EVAL_METHOD);
963 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
964 /* Cast the double precision constants. This is needed when single
965 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
966 is used. The correct result is computed by the compiler when using
967 macros that include a cast. We use a different cast for C++ to avoid
968 problems with -Wold-style-cast. */
969 builtin_define_float_constants ("DBL", "L",
973 "", double_type_node);
974 builtin_define_float_constants ("LDBL", "L", "%s", "L",
975 long_double_type_node);
977 /* For decfloat.h. */
978 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
979 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
980 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
982 /* For fixed-point fibt, ibit, max, min, and epsilon. */
983 if (targetm.fixed_point_supported_p ())
985 builtin_define_fixed_point_constants ("SFRACT", "HR",
986 short_fract_type_node);
987 builtin_define_fixed_point_constants ("USFRACT", "UHR",
988 unsigned_short_fract_type_node);
989 builtin_define_fixed_point_constants ("FRACT", "R",
991 builtin_define_fixed_point_constants ("UFRACT", "UR",
992 unsigned_fract_type_node);
993 builtin_define_fixed_point_constants ("LFRACT", "LR",
994 long_fract_type_node);
995 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
996 unsigned_long_fract_type_node);
997 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
998 long_long_fract_type_node);
999 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1000 unsigned_long_long_fract_type_node);
1001 builtin_define_fixed_point_constants ("SACCUM", "HK",
1002 short_accum_type_node);
1003 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1004 unsigned_short_accum_type_node);
1005 builtin_define_fixed_point_constants ("ACCUM", "K",
1007 builtin_define_fixed_point_constants ("UACCUM", "UK",
1008 unsigned_accum_type_node);
1009 builtin_define_fixed_point_constants ("LACCUM", "LK",
1010 long_accum_type_node);
1011 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1012 unsigned_long_accum_type_node);
1013 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1014 long_long_accum_type_node);
1015 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1016 unsigned_long_long_accum_type_node);
1018 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
1019 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
1020 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
1021 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
1022 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
1023 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
1024 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
1025 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
1026 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
1027 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
1028 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
1029 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
1030 builtin_define_fixed_point_constants ("DA", "", da_type_node);
1031 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
1032 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
1033 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
1034 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
1035 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
1038 /* For libgcc-internal use only. */
1039 if (flag_building_libgcc)
1041 /* Properties of floating-point modes for libgcc2.c. */
1042 for (machine_mode mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
1044 mode = GET_MODE_WIDER_MODE (mode))
1046 const char *name = GET_MODE_NAME (mode);
1048 = (char *) alloca (strlen (name)
1049 + sizeof ("__LIBGCC__MANT_DIG__"));
1050 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
1051 builtin_define_with_int_value (macro_name,
1052 REAL_MODE_FORMAT (mode)->p);
1053 if (!targetm.scalar_mode_supported_p (mode)
1054 || !targetm.libgcc_floating_mode_supported_p (mode))
1056 macro_name = (char *) alloca (strlen (name)
1057 + sizeof ("__LIBGCC_HAS__MODE__"));
1058 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
1059 cpp_define (pfile, macro_name);
1060 macro_name = (char *) alloca (strlen (name)
1061 + sizeof ("__LIBGCC__FUNC_EXT__"));
1062 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
1064 if (mode == TYPE_MODE (double_type_node))
1066 else if (mode == TYPE_MODE (float_type_node))
1068 else if (mode == TYPE_MODE (long_double_type_node))
1070 /* ??? The following assumes the built-in functions (defined
1071 in target-specific code) match the suffixes used for
1072 constants. Because in fact such functions are not
1073 defined for the 'w' suffix, 'l' is used there
1075 else if (mode == targetm.c.mode_for_suffix ('q'))
1077 else if (mode == targetm.c.mode_for_suffix ('w'))
1081 builtin_define_with_value (macro_name, suffix, 0);
1082 bool excess_precision = false;
1083 if (TARGET_FLT_EVAL_METHOD != 0
1084 && mode != TYPE_MODE (long_double_type_node)
1085 && (mode == TYPE_MODE (float_type_node)
1086 || mode == TYPE_MODE (double_type_node)))
1087 switch (TARGET_FLT_EVAL_METHOD)
1091 excess_precision = true;
1095 excess_precision = mode == TYPE_MODE (float_type_node);
1101 macro_name = (char *) alloca (strlen (name)
1102 + sizeof ("__LIBGCC__EXCESS_"
1104 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
1105 builtin_define_with_int_value (macro_name, excess_precision);
1108 /* For libgcc crtstuff.c and libgcc2.c. */
1109 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1110 EH_TABLES_CAN_BE_READ_ONLY);
1111 #ifdef EH_FRAME_SECTION_NAME
1112 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1113 EH_FRAME_SECTION_NAME, 1);
1115 #ifdef JCR_SECTION_NAME
1116 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
1117 JCR_SECTION_NAME, 1);
1119 #ifdef CTORS_SECTION_ASM_OP
1120 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1121 CTORS_SECTION_ASM_OP, 1);
1123 #ifdef DTORS_SECTION_ASM_OP
1124 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1125 DTORS_SECTION_ASM_OP, 1);
1127 #ifdef TEXT_SECTION_ASM_OP
1128 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1129 TEXT_SECTION_ASM_OP, 1);
1131 #ifdef INIT_SECTION_ASM_OP
1132 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1133 INIT_SECTION_ASM_OP, 1);
1135 #ifdef INIT_ARRAY_SECTION_ASM_OP
1136 /* Despite the name of this target macro, the expansion is not
1137 actually used, and may be empty rather than a string
1139 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1142 /* For libgcc enable-execute-stack.c. */
1143 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1146 /* For libgcc generic-morestack.c and unwinder code. */
1147 #ifdef STACK_GROWS_DOWNWARD
1148 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1151 /* For libgcc unwinder code. */
1152 #ifdef DONT_USE_BUILTIN_SETJMP
1153 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1155 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1156 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1157 DWARF_ALT_FRAME_RETURN_COLUMN);
1159 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1160 DWARF_FRAME_REGISTERS);
1161 #ifdef EH_RETURN_STACKADJ_RTX
1162 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1165 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1168 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1169 STACK_POINTER_REGNUM);
1172 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1173 TARGET_VTABLE_USES_DESCRIPTORS);
1176 /* For use in assembly language. */
1177 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1178 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1181 if (flag_gnu89_inline)
1182 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1184 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1187 cpp_define (pfile, "__NO_INLINE__");
1190 cpp_define (pfile, "__STRICT_ANSI__");
1192 if (!flag_signed_char)
1193 cpp_define (pfile, "__CHAR_UNSIGNED__");
1195 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1196 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1198 cpp_atomic_builtins (pfile);
1200 #ifdef DWARF2_UNWIND_INFO
1201 if (dwarf2out_do_cfi_asm ())
1202 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1205 /* Make the choice of ObjC runtime visible to source code. */
1206 if (c_dialect_objc () && flag_next_runtime)
1207 cpp_define (pfile, "__NEXT_RUNTIME__");
1209 /* Show the availability of some target pragmas. */
1210 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1212 /* Make the choice of the stack protector runtime visible to source code.
1213 The macro names and values here were chosen for compatibility with an
1214 earlier implementation, i.e. ProPolice. */
1215 if (flag_stack_protect == 4)
1216 cpp_define (pfile, "__SSP_EXPLICIT__=4");
1217 if (flag_stack_protect == 3)
1218 cpp_define (pfile, "__SSP_STRONG__=3");
1219 if (flag_stack_protect == 2)
1220 cpp_define (pfile, "__SSP_ALL__=2");
1221 else if (flag_stack_protect == 1)
1222 cpp_define (pfile, "__SSP__=1");
1225 cpp_define (pfile, "_OPENACC=201306");
1228 cpp_define (pfile, "_OPENMP=201307");
1230 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1231 if (int_n_enabled_p[i])
1234 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1235 builtin_define_type_sizeof (buf,
1236 int_n_trees[i].signed_type);
1238 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1239 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1240 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1241 unsigned_ptrdiff_type_node);
1243 /* A straightforward target hook doesn't work, because of problems
1244 linking that hook's body when part of non-C front ends. */
1245 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1246 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1247 # define builtin_define(TXT) cpp_define (pfile, TXT)
1248 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1249 TARGET_CPU_CPP_BUILTINS ();
1250 TARGET_OS_CPP_BUILTINS ();
1251 TARGET_OBJFMT_CPP_BUILTINS ();
1253 /* Support the __declspec keyword by turning them into attributes.
1254 Note that the current way we do this may result in a collision
1255 with predefined attributes later on. This can be solved by using
1256 one attribute, say __declspec__, and passing args to it. The
1257 problem with that approach is that args are not accumulated: each
1258 new appearance would clobber any existing args. */
1259 if (TARGET_DECLSPEC)
1260 builtin_define ("__declspec(x)=__attribute__((x))");
1262 /* If decimal floating point is supported, tell the user if the
1263 alternate format (BID) is used instead of the standard (DPD)
1265 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1266 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1269 /* Pass an object-like macro. If it doesn't lie in the user's
1270 namespace, defines it unconditionally. Otherwise define a version
1271 with two leading underscores, and another version with two leading
1272 and trailing underscores, and define the original only if an ISO
1273 standard was not nominated.
1275 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1276 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1279 builtin_define_std (const char *macro)
1281 size_t len = strlen (macro);
1282 char *buff = (char *) alloca (len + 5);
1286 /* prepend __ (or maybe just _) if in user's namespace. */
1287 memcpy (p, macro, len + 1);
1288 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1295 cpp_define (parse_in, p);
1297 /* If it was in user's namespace... */
1300 /* Define the macro with leading and following __. */
1306 cpp_define (parse_in, p);
1308 /* Finally, define the original macro if permitted. */
1310 cpp_define (parse_in, macro);
1314 /* Pass an object-like macro and a value to define it to. The third
1315 parameter says whether or not to turn the value into a string
1318 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1321 size_t mlen = strlen (macro);
1322 size_t elen = strlen (expansion);
1323 size_t extra = 2; /* space for an = and a NUL */
1327 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1330 extra += 2; /* space for two quote marks */
1331 for (p = expansion, q = quoted_expansion; *p; p++)
1356 if (ISPRINT ((unsigned char) *p))
1360 sprintf (q, "\\%03o", (unsigned char) *p);
1366 expansion = quoted_expansion;
1367 elen = q - expansion;
1370 buf = (char *) alloca (mlen + elen + extra);
1372 sprintf (buf, "%s=\"%s\"", macro, expansion);
1374 sprintf (buf, "%s=%s", macro, expansion);
1376 cpp_define (parse_in, buf);
1380 /* Pass an object-like macro and an integer value to define it to. */
1382 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1385 size_t mlen = strlen (macro);
1387 size_t extra = 2; /* space for = and NUL. */
1389 buf = (char *) alloca (mlen + vlen + extra);
1390 memcpy (buf, macro, mlen);
1392 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1394 cpp_define (parse_in, buf);
1397 /* builtin_define_with_hex_fp_value is very expensive, so the following
1398 array and function allows it to be done lazily when __DBL_MAX__
1399 etc. is first used. */
1401 struct GTY(()) lazy_hex_fp_value_struct
1403 const char *hex_str;
1407 const char *fp_suffix;
1409 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
1410 static GTY(()) int lazy_hex_fp_value_count;
1413 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1416 REAL_VALUE_TYPE real;
1417 char dec_str[64], buf1[256];
1419 if (node->value.builtin < BT_FIRST_USER
1420 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1423 idx = node->value.builtin - BT_FIRST_USER;
1424 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1425 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1426 lazy_hex_fp_values[idx].digits, 0,
1427 lazy_hex_fp_values[idx].mode);
1429 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1430 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1431 node->value.macro = lazy_hex_fp_values[idx].macro;
1432 for (idx = 0; idx < node->value.macro->count; idx++)
1433 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1435 gcc_assert (idx < node->value.macro->count);
1436 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1437 node->value.macro->exp.tokens[idx].val.str.text
1438 = (const unsigned char *) ggc_strdup (buf1);
1442 /* Pass an object-like macro a hexadecimal floating-point value. */
1444 builtin_define_with_hex_fp_value (const char *macro,
1445 tree type, int digits,
1446 const char *hex_str,
1447 const char *fp_suffix,
1448 const char *fp_cast)
1450 REAL_VALUE_TYPE real;
1451 char dec_str[64], buf1[256], buf2[256];
1453 /* This is very expensive, so if possible expand them lazily. */
1454 if (lazy_hex_fp_value_count < 12
1455 && flag_dump_macros == 0
1456 && !cpp_get_options (parse_in)->traditional)
1458 struct cpp_hashnode *node;
1459 if (lazy_hex_fp_value_count == 0)
1460 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1461 sprintf (buf2, fp_cast, "1.1");
1462 sprintf (buf1, "%s=%s", macro, buf2);
1463 cpp_define (parse_in, buf1);
1464 node = C_CPP_HASHNODE (get_identifier (macro));
1465 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1466 = ggc_strdup (hex_str);
1467 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1468 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1469 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1470 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1471 node->flags |= NODE_BUILTIN;
1473 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1474 lazy_hex_fp_value_count++;
1478 /* Hex values are really cool and convenient, except that they're
1479 not supported in strict ISO C90 mode. First, the "p-" sequence
1480 is not valid as part of a preprocessor number. Second, we get a
1481 pedwarn from the preprocessor, which has no context, so we can't
1482 suppress the warning with __extension__.
1484 So instead what we do is construct the number in hex (because
1485 it's easy to get the exact correct value), parse it as a real,
1486 then print it back out as decimal. */
1488 real_from_string (&real, hex_str);
1489 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1492 /* Assemble the macro in the following fashion
1493 macro = fp_cast [dec_str fp_suffix] */
1494 sprintf (buf1, "%s%s", dec_str, fp_suffix);
1495 sprintf (buf2, fp_cast, buf1);
1496 sprintf (buf1, "%s=%s", macro, buf2);
1498 cpp_define (parse_in, buf1);
1501 /* Return a string constant for the suffix for a value of type TYPE
1502 promoted according to the integer promotions. The type must be one
1503 of the standard integer type nodes. */
1506 type_suffix (tree type)
1508 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1509 int unsigned_suffix;
1511 int tp = TYPE_PRECISION (type);
1513 if (type == long_long_integer_type_node
1514 || type == long_long_unsigned_type_node
1515 || tp > TYPE_PRECISION (long_integer_type_node))
1517 else if (type == long_integer_type_node
1518 || type == long_unsigned_type_node
1519 || tp > TYPE_PRECISION (integer_type_node))
1521 else if (type == integer_type_node
1522 || type == unsigned_type_node
1523 || type == short_integer_type_node
1524 || type == short_unsigned_type_node
1525 || type == signed_char_type_node
1526 || type == unsigned_char_type_node
1527 /* ??? "char" is not a signed or unsigned integer type and
1528 so is not permitted for the standard typedefs, but some
1529 systems use it anyway. */
1530 || type == char_type_node)
1535 unsigned_suffix = TYPE_UNSIGNED (type);
1536 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1537 unsigned_suffix = 0;
1538 return suffixes[is_long * 2 + unsigned_suffix];
1541 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1543 builtin_define_constants (const char *macro, tree type)
1548 suffix = type_suffix (type);
1552 buf = (char *) alloca (strlen (macro) + 6);
1553 sprintf (buf, "%s(c)=c", macro);
1557 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1558 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1561 cpp_define (parse_in, buf);
1564 /* Define MAX for TYPE based on the precision of the type. */
1567 builtin_define_type_max (const char *macro, tree type)
1569 builtin_define_type_minmax (NULL, macro, type);
1572 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1573 representation of that value. For example, a COUNT of 10 would
1577 print_bits_of_hex (char *buf, int bufsz, int count)
1579 gcc_assert (bufsz > 3);
1584 gcc_assert (count > 0);
1586 switch (count % 4) {
1607 gcc_assert (bufsz > 1);
1612 gcc_assert (bufsz > 0);
1616 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1617 precision of the type. */
1620 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1623 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1624 char value[PBOH_SZ];
1630 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1632 print_bits_of_hex (value, PBOH_SZ, bits);
1634 suffix = type_suffix (type);
1636 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1637 + strlen (suffix) + 1);
1638 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1640 cpp_define (parse_in, buf);
1644 if (TYPE_UNSIGNED (type))
1646 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1647 sprintf (buf, "%s=0%s", min_macro, suffix);
1651 buf = (char *) alloca (strlen (min_macro) + 3
1652 + strlen (max_macro) + 6);
1653 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1655 cpp_define (parse_in, buf);
1659 #include "gt-c-family-c-cppbuiltin.h"