1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2013 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"
30 #include "output.h" /* For user_label_prefix. */
31 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
32 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
34 #include "common/common-target.h"
35 #include "cpp-id-data.h"
36 #include "cppbuiltin.h"
38 #ifndef TARGET_OS_CPP_BUILTINS
39 # define TARGET_OS_CPP_BUILTINS()
42 #ifndef TARGET_OBJFMT_CPP_BUILTINS
43 # define TARGET_OBJFMT_CPP_BUILTINS()
46 #ifndef REGISTER_PREFIX
47 #define REGISTER_PREFIX ""
50 /* Non-static as some targets don't use it. */
51 void builtin_define_std (const char *) ATTRIBUTE_UNUSED
;
52 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT
);
53 static void builtin_define_with_hex_fp_value (const char *, tree
,
57 static void builtin_define_stdint_macros (void);
58 static void builtin_define_constants (const char *, tree
);
59 static void builtin_define_type_max (const char *, tree
);
60 static void builtin_define_type_minmax (const char *, const char *, tree
);
61 static void builtin_define_type_sizeof (const char *, tree
);
62 static void builtin_define_float_constants (const char *,
68 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
69 Originally this function used the fma optab, but that doesn't work with
70 -save-temps, so just rely on the HAVE_fma macros for the standard floating
74 mode_has_fma (enum machine_mode mode
)
105 /* Define NAME with value TYPE size_unit. */
107 builtin_define_type_sizeof (const char *name
, tree type
)
109 builtin_define_with_int_value (name
,
110 tree_low_cst (TYPE_SIZE_UNIT (type
), 1));
113 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
116 builtin_define_float_constants (const char *name_prefix
,
117 const char *fp_suffix
,
119 const char *fma_suffix
,
122 /* Used to convert radix-based values to base 10 values in several cases.
124 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
125 least 6 significant digits for correct results. Using the fraction
126 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
127 intermediate; perhaps someone can find a better approximation, in the
128 mean time, I suspect using doubles won't harm the bootstrap here. */
130 const double log10_2
= .30102999566398119521;
132 const struct real_format
*fmt
;
133 const struct real_format
*ldfmt
;
135 char name
[64], buf
[128];
136 int dig
, min_10_exp
, max_10_exp
;
138 int type_decimal_dig
;
140 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
141 gcc_assert (fmt
->b
!= 10);
142 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
143 gcc_assert (ldfmt
->b
!= 10);
145 /* The radix of the exponent representation. */
146 if (type
== float_type_node
)
147 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
150 /* The number of radix digits, p, in the floating-point significand. */
151 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
152 builtin_define_with_int_value (name
, fmt
->p
);
154 /* The number of decimal digits, q, such that any floating-point number
155 with q decimal digits can be rounded into a floating-point number with
156 p radix b digits and back again without change to the q decimal digits,
158 p log10 b if b is a power of 10
159 floor((p - 1) log10 b) otherwise
161 dig
= (fmt
->p
- 1) * log10_b
;
162 sprintf (name
, "__%s_DIG__", name_prefix
);
163 builtin_define_with_int_value (name
, dig
);
165 /* The minimum negative int x such that b**(x-1) is a normalized float. */
166 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
167 sprintf (buf
, "(%d)", fmt
->emin
);
168 builtin_define_with_value (name
, buf
, 0);
170 /* The minimum negative int x such that 10**x is a normalized float,
172 ceil (log10 (b ** (emin - 1)))
173 = ceil (log10 (b) * (emin - 1))
175 Recall that emin is negative, so the integer truncation calculates
176 the ceiling, not the floor, in this case. */
177 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
178 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
179 sprintf (buf
, "(%d)", min_10_exp
);
180 builtin_define_with_value (name
, buf
, 0);
182 /* The maximum int x such that b**(x-1) is a representable float. */
183 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
184 builtin_define_with_int_value (name
, fmt
->emax
);
186 /* The maximum int x such that 10**x is in the range of representable
187 finite floating-point numbers,
189 floor (log10((1 - b**-p) * b**emax))
190 = floor (log10(1 - b**-p) + log10(b**emax))
191 = floor (log10(1 - b**-p) + log10(b)*emax)
193 The safest thing to do here is to just compute this number. But since
194 we don't link cc1 with libm, we cannot. We could implement log10 here
195 a series expansion, but that seems too much effort because:
197 Note that the first term, for all extant p, is a number exceedingly close
198 to zero, but slightly negative. Note that the second term is an integer
199 scaling an irrational number, and that because of the floor we are only
200 interested in its integral portion.
202 In order for the first term to have any effect on the integral portion
203 of the second term, the second term has to be exceedingly close to an
204 integer itself (e.g. 123.000000000001 or something). Getting a result
205 that close to an integer requires that the irrational multiplicand have
206 a long series of zeros in its expansion, which doesn't occur in the
207 first 20 digits or so of log10(b).
209 Hand-waving aside, crunching all of the sets of constants above by hand
210 does not yield a case for which the first term is significant, which
211 in the end is all that matters. */
212 max_10_exp
= fmt
->emax
* log10_b
;
213 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
214 builtin_define_with_int_value (name
, max_10_exp
);
216 /* The number of decimal digits, n, such that any floating-point number
217 can be rounded to n decimal digits and back again without change to
220 p * log10(b) if b is a power of 10
221 ceil(1 + p * log10(b)) otherwise
223 The only macro we care about is this number for the widest supported
224 floating type, but we want this value for rendering constants below. */
227 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
228 decimal_dig
= d_decimal_dig
;
229 if (decimal_dig
< d_decimal_dig
)
232 /* Similar, for this type rather than long double. */
234 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
235 type_decimal_dig
= type_d_decimal_dig
;
236 if (type_decimal_dig
< type_d_decimal_dig
)
239 if (type
== long_double_type_node
)
240 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
243 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
244 builtin_define_with_int_value (name
, type_decimal_dig
);
247 /* Since, for the supported formats, B is always a power of 2, we
248 construct the following numbers directly as a hexadecimal
250 get_max_float (fmt
, buf
, sizeof (buf
));
252 sprintf (name
, "__%s_MAX__", name_prefix
);
253 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
255 /* The minimum normalized positive floating-point number,
257 sprintf (name
, "__%s_MIN__", name_prefix
);
258 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
259 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
261 /* The difference between 1 and the least value greater than 1 that is
262 representable in the given floating point type, b**(1-p). */
263 sprintf (name
, "__%s_EPSILON__", name_prefix
);
264 if (fmt
->pnan
< fmt
->p
)
265 /* This is an IBM extended double format, so 1.0 + any double is
266 representable precisely. */
267 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
269 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
270 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
272 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
273 positive floating-point number, b**(emin-p). Zero for formats that
274 don't support denormals. */
275 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
278 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
279 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
280 buf
, fp_suffix
, fp_cast
);
284 sprintf (buf
, "0.0%s", fp_suffix
);
285 builtin_define_with_value (name
, buf
, 0);
288 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
289 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
291 /* For C++ std::numeric_limits<T>::has_infinity. */
292 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
293 builtin_define_with_int_value (name
,
294 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
295 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
296 predicate to distinguish a target that has both quiet and
297 signalling NaNs from a target that has only quiet NaNs or only
298 signalling NaNs, so we assume that a target that has any kind of
299 NaN has quiet NaNs. */
300 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
301 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
303 /* Note whether we have fast FMA. */
304 if (mode_has_fma (TYPE_MODE (type
)))
306 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
307 builtin_define_with_int_value (name
, 1);
311 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
313 builtin_define_decimal_float_constants (const char *name_prefix
,
317 const struct real_format
*fmt
;
318 char name
[64], buf
[128], *p
;
321 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
323 /* The number of radix digits, p, in the significand. */
324 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
325 builtin_define_with_int_value (name
, fmt
->p
);
327 /* The minimum negative int x such that b**(x-1) is a normalized float. */
328 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
329 sprintf (buf
, "(%d)", fmt
->emin
);
330 builtin_define_with_value (name
, buf
, 0);
332 /* The maximum int x such that b**(x-1) is a representable float. */
333 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
334 builtin_define_with_int_value (name
, fmt
->emax
);
336 /* Compute the minimum representable value. */
337 sprintf (name
, "__%s_MIN__", name_prefix
);
338 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
339 builtin_define_with_value (name
, buf
, 0);
341 /* Compute the maximum representable value. */
342 sprintf (name
, "__%s_MAX__", name_prefix
);
344 for (digits
= fmt
->p
; digits
; digits
--)
347 if (digits
== fmt
->p
)
351 /* fmt->p plus 1, to account for the decimal point and fmt->emax
352 minus 1 because the digits are nines, not 1.0. */
353 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
354 builtin_define_with_value (name
, buf
, 0);
356 /* Compute epsilon (the difference between 1 and least value greater
357 than 1 representable). */
358 sprintf (name
, "__%s_EPSILON__", name_prefix
);
359 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
360 builtin_define_with_value (name
, buf
, 0);
362 /* Minimum subnormal positive decimal value. */
363 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
365 for (digits
= fmt
->p
; digits
> 1; digits
--)
368 if (digits
== fmt
->p
)
372 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
373 builtin_define_with_value (name
, buf
, 0);
376 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
379 builtin_define_fixed_point_constants (const char *name_prefix
,
383 char name
[64], buf
[256], *new_buf
;
386 sprintf (name
, "__%s_FBIT__", name_prefix
);
387 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
389 sprintf (name
, "__%s_IBIT__", name_prefix
);
390 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
392 /* If there is no suffix, defines are for fixed-point modes.
394 if (strcmp (suffix
, "") == 0)
397 if (TYPE_UNSIGNED (type
))
399 sprintf (name
, "__%s_MIN__", name_prefix
);
400 sprintf (buf
, "0.0%s", suffix
);
401 builtin_define_with_value (name
, buf
, 0);
405 sprintf (name
, "__%s_MIN__", name_prefix
);
406 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
407 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
408 TYPE_IBIT (type
) - 1, suffix
);
410 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
411 builtin_define_with_value (name
, buf
, 0);
414 sprintf (name
, "__%s_MAX__", name_prefix
);
417 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
419 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
420 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
421 sprintf (new_buf
++, "F");
422 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
423 builtin_define_with_value (name
, buf
, 0);
425 sprintf (name
, "__%s_EPSILON__", name_prefix
);
426 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
427 builtin_define_with_value (name
, buf
, 0);
430 /* Define macros used by <stdint.h>. */
432 builtin_define_stdint_macros (void)
434 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
435 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
436 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
437 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
438 if (sig_atomic_type_node
)
439 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
440 sig_atomic_type_node
);
442 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
444 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
446 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
448 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
450 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
451 if (c_uint16_type_node
)
452 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
453 if (c_uint32_type_node
)
454 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
455 if (c_uint64_type_node
)
456 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
457 if (int_least8_type_node
)
459 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
460 builtin_define_constants ("__INT8_C", int_least8_type_node
);
462 if (int_least16_type_node
)
464 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
465 builtin_define_constants ("__INT16_C", int_least16_type_node
);
467 if (int_least32_type_node
)
469 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
470 builtin_define_constants ("__INT32_C", int_least32_type_node
);
472 if (int_least64_type_node
)
474 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
475 builtin_define_constants ("__INT64_C", int_least64_type_node
);
477 if (uint_least8_type_node
)
479 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
480 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
482 if (uint_least16_type_node
)
484 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
485 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
487 if (uint_least32_type_node
)
489 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
490 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
492 if (uint_least64_type_node
)
494 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
495 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
497 if (int_fast8_type_node
)
498 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
499 if (int_fast16_type_node
)
500 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
501 if (int_fast32_type_node
)
502 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
503 if (int_fast64_type_node
)
504 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
505 if (uint_fast8_type_node
)
506 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
507 if (uint_fast16_type_node
)
508 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
509 if (uint_fast32_type_node
)
510 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
511 if (uint_fast64_type_node
)
512 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
513 if (intptr_type_node
)
514 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
515 if (uintptr_type_node
)
516 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
519 /* Adjust the optimization macros when a #pragma GCC optimization is done to
520 reflect the current level. */
522 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
525 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
526 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
530 /* -undef turns off target-specific built-ins. */
534 /* Other target-independent built-ins determined by command-line
536 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
537 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
538 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
539 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
541 if (!prev
->x_optimize
&& cur
->x_optimize
)
542 cpp_define (pfile
, "__OPTIMIZE__");
543 else if (prev
->x_optimize
&& !cur
->x_optimize
)
544 cpp_undef (pfile
, "__OPTIMIZE__");
546 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
547 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
548 if (!prev_fast_math
&& cur_fast_math
)
549 cpp_define (pfile
, "__FAST_MATH__");
550 else if (prev_fast_math
&& !cur_fast_math
)
551 cpp_undef (pfile
, "__FAST_MATH__");
553 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
554 cpp_define (pfile
, "__SUPPORT_SNAN__");
555 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
556 cpp_undef (pfile
, "__SUPPORT_SNAN__");
558 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
560 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
561 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
563 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
565 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
566 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
571 /* This function will emit cpp macros to indicate the presence of various lock
572 free atomic operations. */
575 cpp_atomic_builtins (cpp_reader
*pfile
)
577 /* Set a flag for each size of object that compare and swap exists for up to
579 #define SWAP_LIMIT 17
580 bool have_swap
[SWAP_LIMIT
];
583 /* Clear the map of sizes compare_and swap exists for. */
584 memset (have_swap
, 0, sizeof (have_swap
));
586 /* Tell source code if the compiler makes sync_compare_and_swap
587 builtins available. */
588 #ifndef HAVE_sync_compare_and_swapqi
589 #define HAVE_sync_compare_and_swapqi 0
591 #ifndef HAVE_atomic_compare_and_swapqi
592 #define HAVE_atomic_compare_and_swapqi 0
595 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
597 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
601 #ifndef HAVE_sync_compare_and_swaphi
602 #define HAVE_sync_compare_and_swaphi 0
604 #ifndef HAVE_atomic_compare_and_swaphi
605 #define HAVE_atomic_compare_and_swaphi 0
607 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
609 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
613 #ifndef HAVE_sync_compare_and_swapsi
614 #define HAVE_sync_compare_and_swapsi 0
616 #ifndef HAVE_atomic_compare_and_swapsi
617 #define HAVE_atomic_compare_and_swapsi 0
619 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
621 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
625 #ifndef HAVE_sync_compare_and_swapdi
626 #define HAVE_sync_compare_and_swapdi 0
628 #ifndef HAVE_atomic_compare_and_swapdi
629 #define HAVE_atomic_compare_and_swapdi 0
631 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
633 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
637 #ifndef HAVE_sync_compare_and_swapti
638 #define HAVE_sync_compare_and_swapti 0
640 #ifndef HAVE_atomic_compare_and_swapti
641 #define HAVE_atomic_compare_and_swapti 0
643 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
645 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
646 have_swap
[16] = true;
649 /* Tell the source code about various types. These map to the C++11 and C11
650 macros where 2 indicates lock-free always, and 1 indicates sometimes
652 #define SIZEOF_NODE(T) (tree_low_cst (TYPE_SIZE_UNIT (T), 1))
653 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
654 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
655 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
656 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
657 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
658 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
659 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
660 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
661 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
662 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
663 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
664 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
665 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
666 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
667 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
668 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
669 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
670 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
671 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
673 /* If we're dealing with a "set" value that doesn't exactly correspond
674 to a boolean truth value, let the library work around that. */
675 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
676 targetm
.atomic_test_and_set_trueval
);
678 /* ptr_type_node can't be used here since ptr_mode is only set when
679 toplev calls backend_init which is not done with -E or pch. */
680 psize
= POINTER_SIZE
/ BITS_PER_UNIT
;
681 if (psize
>= SWAP_LIMIT
)
683 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
684 (have_swap
[psize
]? 2 : 1));
687 /* Return the value for __GCC_IEC_559. */
689 cpp_iec_559_value (void)
691 /* The default is support for IEEE 754-2008. */
694 /* float and double must be binary32 and binary64. If they are but
695 with reversed NaN convention, at most IEEE 754-1985 is
697 const struct real_format
*ffmt
698 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
699 const struct real_format
*dfmt
700 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
701 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
706 || ffmt
->emin
!= -125
708 || ffmt
->signbit_rw
!= 31
709 || ffmt
->round_towards_zero
710 || !ffmt
->has_sign_dependent_rounding
714 || !ffmt
->has_signed_zero
718 || dfmt
->emin
!= -1021
719 || dfmt
->emax
!= 1024
720 || dfmt
->signbit_rw
!= 63
721 || dfmt
->round_towards_zero
722 || !dfmt
->has_sign_dependent_rounding
726 || !dfmt
->has_signed_zero
)
729 /* In strict C standards conformance mode, consider unpredictable
730 excess precision to mean lack of IEEE 754 support. The same
731 applies to unpredictable contraction. For C++, and outside
732 strict conformance mode, do not consider these options to mean
733 lack of IEEE 754 support. */
736 && TARGET_FLT_EVAL_METHOD
!= 0
737 && flag_excess_precision_cmdline
!= EXCESS_PRECISION_STANDARD
)
741 && flag_fp_contract_mode
== FP_CONTRACT_FAST
)
744 /* Various options are contrary to IEEE 754 semantics. */
745 if (flag_unsafe_math_optimizations
746 || flag_associative_math
747 || flag_reciprocal_math
748 || flag_finite_math_only
749 || !flag_signed_zeros
750 || flag_single_precision_constant
)
753 /* If the target does not support IEEE 754 exceptions and rounding
754 modes, consider IEEE 754 support to be absent. */
755 if (!targetm
.float_exceptions_rounding_supported_p ())
761 /* Return the value for __GCC_IEC_559_COMPLEX. */
763 cpp_iec_559_complex_value (void)
765 /* The value is no bigger than that of __GCC_IEC_559. */
766 int ret
= cpp_iec_559_value ();
768 /* Some options are contrary to the required default state of the
769 CX_LIMITED_RANGE pragma. */
770 if (flag_complex_method
!= 2)
776 /* Hook that registers front end and target-specific built-ins. */
778 c_cpp_builtins (cpp_reader
*pfile
)
780 /* -undef turns off target-specific built-ins. */
784 define_language_independent_builtin_macros (pfile
);
786 if (c_dialect_cxx ())
789 parse_basever (&major
, NULL
, NULL
);
790 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
793 /* For stddef.h. They require macros defined in c-common.c. */
794 c_stddef_cpp_builtins ();
796 if (c_dialect_cxx ())
798 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
799 cpp_define (pfile
, "__GXX_WEAK__=1");
801 cpp_define (pfile
, "__GXX_WEAK__=0");
803 cpp_define (pfile
, "__DEPRECATED");
805 cpp_define (pfile
, "__GXX_RTTI");
806 if (cxx_dialect
>= cxx11
)
807 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
809 /* Note that we define this for C as well, so that we know if
810 __attribute__((cleanup)) will interface with EH. */
812 cpp_define (pfile
, "__EXCEPTIONS");
814 /* Represents the C++ ABI version, always defined so it can be used while
815 preprocessing C and assembler. */
816 if (flag_abi_version
== 0)
817 /* Use a very large value so that:
819 #if __GXX_ABI_VERSION >= <value for version X>
821 will work whether the user explicitly says "-fabi-version=x" or
822 "-fabi-version=0". Do not use INT_MAX because that will be
823 different from system to system. */
824 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
825 else if (flag_abi_version
== 1)
826 /* Due to a historical accident, this version had the value
828 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
830 /* Newer versions have values 1002, 1003, .... */
831 builtin_define_with_int_value ("__GXX_ABI_VERSION",
832 1000 + flag_abi_version
);
834 /* libgcc needs to know this. */
835 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
836 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
838 /* limits.h and stdint.h need to know these. */
839 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
840 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
841 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
842 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
843 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
844 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
845 underlying_wchar_type_node
);
846 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
847 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
848 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
850 /* stdint.h and the testsuite need to know these. */
851 builtin_define_stdint_macros ();
853 /* Provide information for library headers to determine whether to
854 define macros such as __STDC_IEC_559__ and
855 __STDC_IEC_559_COMPLEX__. */
856 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
857 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
858 cpp_iec_559_complex_value ());
860 /* float.h needs to know this. */
861 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
862 TARGET_FLT_EVAL_METHOD
);
864 /* And decfloat.h needs this. */
865 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
866 TARGET_DEC_EVAL_METHOD
);
868 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
869 /* Cast the double precision constants. This is needed when single
870 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
871 is used. The correct result is computed by the compiler when using
872 macros that include a cast. We use a different cast for C++ to avoid
873 problems with -Wold-style-cast. */
874 builtin_define_float_constants ("DBL", "L",
878 "", double_type_node
);
879 builtin_define_float_constants ("LDBL", "L", "%s", "L",
880 long_double_type_node
);
882 /* For decfloat.h. */
883 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
884 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
885 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
887 /* For fixed-point fibt, ibit, max, min, and epsilon. */
888 if (targetm
.fixed_point_supported_p ())
890 builtin_define_fixed_point_constants ("SFRACT", "HR",
891 short_fract_type_node
);
892 builtin_define_fixed_point_constants ("USFRACT", "UHR",
893 unsigned_short_fract_type_node
);
894 builtin_define_fixed_point_constants ("FRACT", "R",
896 builtin_define_fixed_point_constants ("UFRACT", "UR",
897 unsigned_fract_type_node
);
898 builtin_define_fixed_point_constants ("LFRACT", "LR",
899 long_fract_type_node
);
900 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
901 unsigned_long_fract_type_node
);
902 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
903 long_long_fract_type_node
);
904 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
905 unsigned_long_long_fract_type_node
);
906 builtin_define_fixed_point_constants ("SACCUM", "HK",
907 short_accum_type_node
);
908 builtin_define_fixed_point_constants ("USACCUM", "UHK",
909 unsigned_short_accum_type_node
);
910 builtin_define_fixed_point_constants ("ACCUM", "K",
912 builtin_define_fixed_point_constants ("UACCUM", "UK",
913 unsigned_accum_type_node
);
914 builtin_define_fixed_point_constants ("LACCUM", "LK",
915 long_accum_type_node
);
916 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
917 unsigned_long_accum_type_node
);
918 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
919 long_long_accum_type_node
);
920 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
921 unsigned_long_long_accum_type_node
);
923 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
924 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
925 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
926 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
927 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
928 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
929 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
930 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
931 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
932 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
933 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
934 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
935 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
936 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
937 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
938 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
939 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
940 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
943 /* For libgcc-internal use only. */
944 if (flag_building_libgcc
)
945 /* For libgcc enable-execute-stack.c. */
946 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
949 /* For use in assembly language. */
950 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
951 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
954 if (flag_gnu89_inline
)
955 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
957 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
960 cpp_define (pfile
, "__NO_INLINE__");
963 cpp_define (pfile
, "__STRICT_ANSI__");
965 if (!flag_signed_char
)
966 cpp_define (pfile
, "__CHAR_UNSIGNED__");
968 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
969 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
971 cpp_atomic_builtins (pfile
);
973 #ifdef DWARF2_UNWIND_INFO
974 if (dwarf2out_do_cfi_asm ())
975 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
978 /* Make the choice of ObjC runtime visible to source code. */
979 if (c_dialect_objc () && flag_next_runtime
)
980 cpp_define (pfile
, "__NEXT_RUNTIME__");
982 /* Show the availability of some target pragmas. */
983 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
985 /* Make the choice of the stack protector runtime visible to source code.
986 The macro names and values here were chosen for compatibility with an
987 earlier implementation, i.e. ProPolice. */
988 if (flag_stack_protect
== 3)
989 cpp_define (pfile
, "__SSP_STRONG__=3");
990 if (flag_stack_protect
== 2)
991 cpp_define (pfile
, "__SSP_ALL__=2");
992 else if (flag_stack_protect
== 1)
993 cpp_define (pfile
, "__SSP__=1");
996 cpp_define (pfile
, "_OPENMP=201307");
998 /* Add UPC defines */
999 if (c_dialect_upc ())
1000 upc_cpp_builtins (pfile
);
1002 if (int128_integer_type_node
!= NULL_TREE
)
1003 builtin_define_type_sizeof ("__SIZEOF_INT128__",
1004 int128_integer_type_node
);
1005 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
1006 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
1007 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1008 unsigned_ptrdiff_type_node
);
1010 /* A straightforward target hook doesn't work, because of problems
1011 linking that hook's body when part of non-C front ends. */
1012 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1013 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1014 # define builtin_define(TXT) cpp_define (pfile, TXT)
1015 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1016 TARGET_CPU_CPP_BUILTINS ();
1017 TARGET_OS_CPP_BUILTINS ();
1018 TARGET_OBJFMT_CPP_BUILTINS ();
1020 /* Support the __declspec keyword by turning them into attributes.
1021 Note that the current way we do this may result in a collision
1022 with predefined attributes later on. This can be solved by using
1023 one attribute, say __declspec__, and passing args to it. The
1024 problem with that approach is that args are not accumulated: each
1025 new appearance would clobber any existing args. */
1026 if (TARGET_DECLSPEC
)
1027 builtin_define ("__declspec(x)=__attribute__((x))");
1029 /* If decimal floating point is supported, tell the user if the
1030 alternate format (BID) is used instead of the standard (DPD)
1032 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1033 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1036 /* Pass an object-like macro. If it doesn't lie in the user's
1037 namespace, defines it unconditionally. Otherwise define a version
1038 with two leading underscores, and another version with two leading
1039 and trailing underscores, and define the original only if an ISO
1040 standard was not nominated.
1042 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1043 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1046 builtin_define_std (const char *macro
)
1048 size_t len
= strlen (macro
);
1049 char *buff
= (char *) alloca (len
+ 5);
1053 /* prepend __ (or maybe just _) if in user's namespace. */
1054 memcpy (p
, macro
, len
+ 1);
1055 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1062 cpp_define (parse_in
, p
);
1064 /* If it was in user's namespace... */
1067 /* Define the macro with leading and following __. */
1073 cpp_define (parse_in
, p
);
1075 /* Finally, define the original macro if permitted. */
1077 cpp_define (parse_in
, macro
);
1081 /* Pass an object-like macro and a value to define it to. The third
1082 parameter says whether or not to turn the value into a string
1085 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1088 size_t mlen
= strlen (macro
);
1089 size_t elen
= strlen (expansion
);
1090 size_t extra
= 2; /* space for an = and a NUL */
1093 extra
+= 2; /* space for two quote marks */
1095 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1097 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1099 sprintf (buf
, "%s=%s", macro
, expansion
);
1101 cpp_define (parse_in
, buf
);
1105 /* Pass an object-like macro and an integer value to define it to. */
1107 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1110 size_t mlen
= strlen (macro
);
1112 size_t extra
= 2; /* space for = and NUL. */
1114 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1115 memcpy (buf
, macro
, mlen
);
1117 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1119 cpp_define (parse_in
, buf
);
1122 /* builtin_define_with_hex_fp_value is very expensive, so the following
1123 array and function allows it to be done lazily when __DBL_MAX__
1124 etc. is first used. */
1126 struct GTY(()) lazy_hex_fp_value_struct
1128 const char *hex_str
;
1130 enum machine_mode mode
;
1132 const char *fp_suffix
;
1134 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1135 static GTY(()) int lazy_hex_fp_value_count
;
1138 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1141 REAL_VALUE_TYPE real
;
1142 char dec_str
[64], buf1
[256];
1144 if (node
->value
.builtin
< BT_FIRST_USER
1145 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1148 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1149 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1150 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1151 lazy_hex_fp_values
[idx
].digits
, 0,
1152 lazy_hex_fp_values
[idx
].mode
);
1154 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1155 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1156 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1157 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1158 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1160 gcc_assert (idx
< node
->value
.macro
->count
);
1161 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1162 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1163 = (const unsigned char *) ggc_strdup (buf1
);
1167 /* Pass an object-like macro a hexadecimal floating-point value. */
1169 builtin_define_with_hex_fp_value (const char *macro
,
1170 tree type
, int digits
,
1171 const char *hex_str
,
1172 const char *fp_suffix
,
1173 const char *fp_cast
)
1175 REAL_VALUE_TYPE real
;
1176 char dec_str
[64], buf1
[256], buf2
[256];
1178 /* This is very expensive, so if possible expand them lazily. */
1179 if (lazy_hex_fp_value_count
< 12
1180 && flag_dump_macros
== 0
1181 && !cpp_get_options (parse_in
)->traditional
)
1183 struct cpp_hashnode
*node
;
1184 if (lazy_hex_fp_value_count
== 0)
1185 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1186 sprintf (buf2
, fp_cast
, "1.1");
1187 sprintf (buf1
, "%s=%s", macro
, buf2
);
1188 cpp_define (parse_in
, buf1
);
1189 node
= C_CPP_HASHNODE (get_identifier (macro
));
1190 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1191 = ggc_strdup (hex_str
);
1192 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1193 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1194 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1195 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1196 node
->flags
|= NODE_BUILTIN
;
1198 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1199 lazy_hex_fp_value_count
++;
1203 /* Hex values are really cool and convenient, except that they're
1204 not supported in strict ISO C90 mode. First, the "p-" sequence
1205 is not valid as part of a preprocessor number. Second, we get a
1206 pedwarn from the preprocessor, which has no context, so we can't
1207 suppress the warning with __extension__.
1209 So instead what we do is construct the number in hex (because
1210 it's easy to get the exact correct value), parse it as a real,
1211 then print it back out as decimal. */
1213 real_from_string (&real
, hex_str
);
1214 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1217 /* Assemble the macro in the following fashion
1218 macro = fp_cast [dec_str fp_suffix] */
1219 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1220 sprintf (buf2
, fp_cast
, buf1
);
1221 sprintf (buf1
, "%s=%s", macro
, buf2
);
1223 cpp_define (parse_in
, buf1
);
1226 /* Return a string constant for the suffix for a value of type TYPE
1227 promoted according to the integer promotions. The type must be one
1228 of the standard integer type nodes. */
1231 type_suffix (tree type
)
1233 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1234 int unsigned_suffix
;
1237 if (type
== long_long_integer_type_node
1238 || type
== long_long_unsigned_type_node
)
1240 else if (type
== long_integer_type_node
1241 || type
== long_unsigned_type_node
)
1243 else if (type
== integer_type_node
1244 || type
== unsigned_type_node
1245 || type
== short_integer_type_node
1246 || type
== short_unsigned_type_node
1247 || type
== signed_char_type_node
1248 || type
== unsigned_char_type_node
1249 /* ??? "char" is not a signed or unsigned integer type and
1250 so is not permitted for the standard typedefs, but some
1251 systems use it anyway. */
1252 || type
== char_type_node
)
1257 unsigned_suffix
= TYPE_UNSIGNED (type
);
1258 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1259 unsigned_suffix
= 0;
1260 return suffixes
[is_long
* 2 + unsigned_suffix
];
1263 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1265 builtin_define_constants (const char *macro
, tree type
)
1270 suffix
= type_suffix (type
);
1274 buf
= (char *) alloca (strlen (macro
) + 6);
1275 sprintf (buf
, "%s(c)=c", macro
);
1279 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1280 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1283 cpp_define (parse_in
, buf
);
1286 /* Define MAX for TYPE based on the precision of the type. */
1289 builtin_define_type_max (const char *macro
, tree type
)
1291 builtin_define_type_minmax (NULL
, macro
, type
);
1294 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1295 precision of the type. */
1298 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1301 static const char *const values
[]
1304 "2147483647", "4294967295",
1305 "9223372036854775807", "18446744073709551615",
1306 "170141183460469231731687303715884105727",
1307 "340282366920938463463374607431768211455" };
1309 const char *value
, *suffix
;
1313 /* Pre-rendering the values mean we don't have to futz with printing a
1314 multi-word decimal value. There are also a very limited number of
1315 precisions that we support, so it's really a waste of time. */
1316 switch (TYPE_PRECISION (type
))
1318 case 8: idx
= 0; break;
1319 case 16: idx
= 2; break;
1320 case 32: idx
= 4; break;
1321 case 64: idx
= 6; break;
1322 case 128: idx
= 8; break;
1323 default: gcc_unreachable ();
1326 value
= values
[idx
+ TYPE_UNSIGNED (type
)];
1327 suffix
= type_suffix (type
);
1329 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1330 + strlen (suffix
) + 1);
1331 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1333 cpp_define (parse_in
, buf
);
1337 if (TYPE_UNSIGNED (type
))
1339 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1340 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1344 buf
= (char *) alloca (strlen (min_macro
) + 3
1345 + strlen (max_macro
) + 6);
1346 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1348 cpp_define (parse_in
, buf
);
1352 #include "gt-c-family-c-cppbuiltin.h"