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"
29 #include "output.h" /* For user_label_prefix. */
30 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
31 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
33 #include "common/common-target.h"
34 #include "cpp-id-data.h"
35 #include "cppbuiltin.h"
37 #ifndef TARGET_OS_CPP_BUILTINS
38 # define TARGET_OS_CPP_BUILTINS()
41 #ifndef TARGET_OBJFMT_CPP_BUILTINS
42 # define TARGET_OBJFMT_CPP_BUILTINS()
45 #ifndef REGISTER_PREFIX
46 #define REGISTER_PREFIX ""
49 /* Non-static as some targets don't use it. */
50 void builtin_define_std (const char *) ATTRIBUTE_UNUSED
;
51 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT
);
52 static void builtin_define_with_hex_fp_value (const char *, tree
,
56 static void builtin_define_stdint_macros (void);
57 static void builtin_define_constants (const char *, tree
);
58 static void builtin_define_type_max (const char *, tree
);
59 static void builtin_define_type_minmax (const char *, const char *, tree
);
60 static void builtin_define_type_sizeof (const char *, tree
);
61 static void builtin_define_float_constants (const char *,
67 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
68 Originally this function used the fma optab, but that doesn't work with
69 -save-temps, so just rely on the HAVE_fma macros for the standard floating
73 mode_has_fma (enum machine_mode mode
)
104 /* Define NAME with value TYPE size_unit. */
106 builtin_define_type_sizeof (const char *name
, tree type
)
108 builtin_define_with_int_value (name
,
109 tree_to_uhwi (TYPE_SIZE_UNIT (type
)));
112 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
115 builtin_define_float_constants (const char *name_prefix
,
116 const char *fp_suffix
,
118 const char *fma_suffix
,
121 /* Used to convert radix-based values to base 10 values in several cases.
123 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
124 least 6 significant digits for correct results. Using the fraction
125 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
126 intermediate; perhaps someone can find a better approximation, in the
127 mean time, I suspect using doubles won't harm the bootstrap here. */
129 const double log10_2
= .30102999566398119521;
131 const struct real_format
*fmt
;
132 const struct real_format
*ldfmt
;
134 char name
[64], buf
[128];
135 int dig
, min_10_exp
, max_10_exp
;
137 int type_decimal_dig
;
139 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
140 gcc_assert (fmt
->b
!= 10);
141 ldfmt
= REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node
));
142 gcc_assert (ldfmt
->b
!= 10);
144 /* The radix of the exponent representation. */
145 if (type
== float_type_node
)
146 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
149 /* The number of radix digits, p, in the floating-point significand. */
150 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
151 builtin_define_with_int_value (name
, fmt
->p
);
153 /* The number of decimal digits, q, such that any floating-point number
154 with q decimal digits can be rounded into a floating-point number with
155 p radix b digits and back again without change to the q decimal digits,
157 p log10 b if b is a power of 10
158 floor((p - 1) log10 b) otherwise
160 dig
= (fmt
->p
- 1) * log10_b
;
161 sprintf (name
, "__%s_DIG__", name_prefix
);
162 builtin_define_with_int_value (name
, dig
);
164 /* The minimum negative int x such that b**(x-1) is a normalized float. */
165 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
166 sprintf (buf
, "(%d)", fmt
->emin
);
167 builtin_define_with_value (name
, buf
, 0);
169 /* The minimum negative int x such that 10**x is a normalized float,
171 ceil (log10 (b ** (emin - 1)))
172 = ceil (log10 (b) * (emin - 1))
174 Recall that emin is negative, so the integer truncation calculates
175 the ceiling, not the floor, in this case. */
176 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
177 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
178 sprintf (buf
, "(%d)", min_10_exp
);
179 builtin_define_with_value (name
, buf
, 0);
181 /* The maximum int x such that b**(x-1) is a representable float. */
182 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
183 builtin_define_with_int_value (name
, fmt
->emax
);
185 /* The maximum int x such that 10**x is in the range of representable
186 finite floating-point numbers,
188 floor (log10((1 - b**-p) * b**emax))
189 = floor (log10(1 - b**-p) + log10(b**emax))
190 = floor (log10(1 - b**-p) + log10(b)*emax)
192 The safest thing to do here is to just compute this number. But since
193 we don't link cc1 with libm, we cannot. We could implement log10 here
194 a series expansion, but that seems too much effort because:
196 Note that the first term, for all extant p, is a number exceedingly close
197 to zero, but slightly negative. Note that the second term is an integer
198 scaling an irrational number, and that because of the floor we are only
199 interested in its integral portion.
201 In order for the first term to have any effect on the integral portion
202 of the second term, the second term has to be exceedingly close to an
203 integer itself (e.g. 123.000000000001 or something). Getting a result
204 that close to an integer requires that the irrational multiplicand have
205 a long series of zeros in its expansion, which doesn't occur in the
206 first 20 digits or so of log10(b).
208 Hand-waving aside, crunching all of the sets of constants above by hand
209 does not yield a case for which the first term is significant, which
210 in the end is all that matters. */
211 max_10_exp
= fmt
->emax
* log10_b
;
212 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
213 builtin_define_with_int_value (name
, max_10_exp
);
215 /* The number of decimal digits, n, such that any floating-point number
216 can be rounded to n decimal digits and back again without change to
219 p * log10(b) if b is a power of 10
220 ceil(1 + p * log10(b)) otherwise
222 The only macro we care about is this number for the widest supported
223 floating type, but we want this value for rendering constants below. */
226 = 1 + (fmt
->p
< ldfmt
->p
? ldfmt
->p
: fmt
->p
) * log10_b
;
227 decimal_dig
= d_decimal_dig
;
228 if (decimal_dig
< d_decimal_dig
)
231 /* Similar, for this type rather than long double. */
233 double type_d_decimal_dig
= 1 + fmt
->p
* log10_b
;
234 type_decimal_dig
= type_d_decimal_dig
;
235 if (type_decimal_dig
< type_d_decimal_dig
)
238 if (type
== long_double_type_node
)
239 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
242 sprintf (name
, "__%s_DECIMAL_DIG__", name_prefix
);
243 builtin_define_with_int_value (name
, type_decimal_dig
);
246 /* Since, for the supported formats, B is always a power of 2, we
247 construct the following numbers directly as a hexadecimal
249 get_max_float (fmt
, buf
, sizeof (buf
));
251 sprintf (name
, "__%s_MAX__", name_prefix
);
252 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
254 /* The minimum normalized positive floating-point number,
256 sprintf (name
, "__%s_MIN__", name_prefix
);
257 sprintf (buf
, "0x1p%d", fmt
->emin
- 1);
258 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
260 /* The difference between 1 and the least value greater than 1 that is
261 representable in the given floating point type, b**(1-p). */
262 sprintf (name
, "__%s_EPSILON__", name_prefix
);
263 if (fmt
->pnan
< fmt
->p
)
264 /* This is an IBM extended double format, so 1.0 + any double is
265 representable precisely. */
266 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
268 sprintf (buf
, "0x1p%d", 1 - fmt
->p
);
269 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
, fp_cast
);
271 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
272 positive floating-point number, b**(emin-p). Zero for formats that
273 don't support denormals. */
274 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
277 sprintf (buf
, "0x1p%d", fmt
->emin
- fmt
->p
);
278 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
279 buf
, fp_suffix
, fp_cast
);
283 sprintf (buf
, "0.0%s", fp_suffix
);
284 builtin_define_with_value (name
, buf
, 0);
287 sprintf (name
, "__%s_HAS_DENORM__", name_prefix
);
288 builtin_define_with_value (name
, fmt
->has_denorm
? "1" : "0", 0);
290 /* For C++ std::numeric_limits<T>::has_infinity. */
291 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
292 builtin_define_with_int_value (name
,
293 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
294 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
295 predicate to distinguish a target that has both quiet and
296 signalling NaNs from a target that has only quiet NaNs or only
297 signalling NaNs, so we assume that a target that has any kind of
298 NaN has quiet NaNs. */
299 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
300 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
302 /* Note whether we have fast FMA. */
303 if (mode_has_fma (TYPE_MODE (type
)))
305 sprintf (name
, "__FP_FAST_FMA%s", fma_suffix
);
306 builtin_define_with_int_value (name
, 1);
310 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
312 builtin_define_decimal_float_constants (const char *name_prefix
,
316 const struct real_format
*fmt
;
317 char name
[64], buf
[128], *p
;
320 fmt
= REAL_MODE_FORMAT (TYPE_MODE (type
));
322 /* The number of radix digits, p, in the significand. */
323 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
324 builtin_define_with_int_value (name
, fmt
->p
);
326 /* The minimum negative int x such that b**(x-1) is a normalized float. */
327 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
328 sprintf (buf
, "(%d)", fmt
->emin
);
329 builtin_define_with_value (name
, buf
, 0);
331 /* The maximum int x such that b**(x-1) is a representable float. */
332 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
333 builtin_define_with_int_value (name
, fmt
->emax
);
335 /* Compute the minimum representable value. */
336 sprintf (name
, "__%s_MIN__", name_prefix
);
337 sprintf (buf
, "1E%d%s", fmt
->emin
- 1, suffix
);
338 builtin_define_with_value (name
, buf
, 0);
340 /* Compute the maximum representable value. */
341 sprintf (name
, "__%s_MAX__", name_prefix
);
343 for (digits
= fmt
->p
; digits
; digits
--)
346 if (digits
== fmt
->p
)
350 /* fmt->p plus 1, to account for the decimal point and fmt->emax
351 minus 1 because the digits are nines, not 1.0. */
352 sprintf (&buf
[fmt
->p
+ 1], "E%d%s", fmt
->emax
- 1, suffix
);
353 builtin_define_with_value (name
, buf
, 0);
355 /* Compute epsilon (the difference between 1 and least value greater
356 than 1 representable). */
357 sprintf (name
, "__%s_EPSILON__", name_prefix
);
358 sprintf (buf
, "1E-%d%s", fmt
->p
- 1, suffix
);
359 builtin_define_with_value (name
, buf
, 0);
361 /* Minimum subnormal positive decimal value. */
362 sprintf (name
, "__%s_SUBNORMAL_MIN__", name_prefix
);
364 for (digits
= fmt
->p
; digits
> 1; digits
--)
367 if (digits
== fmt
->p
)
371 sprintf (&buf
[fmt
->p
], "1E%d%s", fmt
->emin
- 1, suffix
);
372 builtin_define_with_value (name
, buf
, 0);
375 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
378 builtin_define_fixed_point_constants (const char *name_prefix
,
382 char name
[64], buf
[256], *new_buf
;
385 sprintf (name
, "__%s_FBIT__", name_prefix
);
386 builtin_define_with_int_value (name
, TYPE_FBIT (type
));
388 sprintf (name
, "__%s_IBIT__", name_prefix
);
389 builtin_define_with_int_value (name
, TYPE_IBIT (type
));
391 /* If there is no suffix, defines are for fixed-point modes.
393 if (strcmp (suffix
, "") == 0)
396 if (TYPE_UNSIGNED (type
))
398 sprintf (name
, "__%s_MIN__", name_prefix
);
399 sprintf (buf
, "0.0%s", suffix
);
400 builtin_define_with_value (name
, buf
, 0);
404 sprintf (name
, "__%s_MIN__", name_prefix
);
405 if (ALL_ACCUM_MODE_P (TYPE_MODE (type
)))
406 sprintf (buf
, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type
) - 1, suffix
,
407 TYPE_IBIT (type
) - 1, suffix
);
409 sprintf (buf
, "(-0.5%s-0.5%s)", suffix
, suffix
);
410 builtin_define_with_value (name
, buf
, 0);
413 sprintf (name
, "__%s_MAX__", name_prefix
);
416 mod
= (TYPE_FBIT (type
) + TYPE_IBIT (type
)) % 4;
418 sprintf (new_buf
++, "%x", (1 << mod
) - 1);
419 for (i
= 0; i
< (TYPE_FBIT (type
) + TYPE_IBIT (type
)) / 4; i
++)
420 sprintf (new_buf
++, "F");
421 sprintf (new_buf
, "P-%d%s", TYPE_FBIT (type
), suffix
);
422 builtin_define_with_value (name
, buf
, 0);
424 sprintf (name
, "__%s_EPSILON__", name_prefix
);
425 sprintf (buf
, "0x1P-%d%s", TYPE_FBIT (type
), suffix
);
426 builtin_define_with_value (name
, buf
, 0);
429 /* Define macros used by <stdint.h>. */
431 builtin_define_stdint_macros (void)
433 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node
);
434 builtin_define_constants ("__INTMAX_C", intmax_type_node
);
435 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node
);
436 builtin_define_constants ("__UINTMAX_C", uintmax_type_node
);
437 if (sig_atomic_type_node
)
438 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
439 sig_atomic_type_node
);
441 builtin_define_type_max ("__INT8_MAX__", int8_type_node
);
443 builtin_define_type_max ("__INT16_MAX__", int16_type_node
);
445 builtin_define_type_max ("__INT32_MAX__", int32_type_node
);
447 builtin_define_type_max ("__INT64_MAX__", int64_type_node
);
449 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node
);
450 if (c_uint16_type_node
)
451 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node
);
452 if (c_uint32_type_node
)
453 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node
);
454 if (c_uint64_type_node
)
455 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node
);
456 if (int_least8_type_node
)
458 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node
);
459 builtin_define_constants ("__INT8_C", int_least8_type_node
);
461 if (int_least16_type_node
)
463 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node
);
464 builtin_define_constants ("__INT16_C", int_least16_type_node
);
466 if (int_least32_type_node
)
468 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node
);
469 builtin_define_constants ("__INT32_C", int_least32_type_node
);
471 if (int_least64_type_node
)
473 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node
);
474 builtin_define_constants ("__INT64_C", int_least64_type_node
);
476 if (uint_least8_type_node
)
478 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node
);
479 builtin_define_constants ("__UINT8_C", uint_least8_type_node
);
481 if (uint_least16_type_node
)
483 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node
);
484 builtin_define_constants ("__UINT16_C", uint_least16_type_node
);
486 if (uint_least32_type_node
)
488 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node
);
489 builtin_define_constants ("__UINT32_C", uint_least32_type_node
);
491 if (uint_least64_type_node
)
493 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node
);
494 builtin_define_constants ("__UINT64_C", uint_least64_type_node
);
496 if (int_fast8_type_node
)
497 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node
);
498 if (int_fast16_type_node
)
499 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node
);
500 if (int_fast32_type_node
)
501 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node
);
502 if (int_fast64_type_node
)
503 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node
);
504 if (uint_fast8_type_node
)
505 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node
);
506 if (uint_fast16_type_node
)
507 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node
);
508 if (uint_fast32_type_node
)
509 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node
);
510 if (uint_fast64_type_node
)
511 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node
);
512 if (intptr_type_node
)
513 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node
);
514 if (uintptr_type_node
)
515 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node
);
518 /* Adjust the optimization macros when a #pragma GCC optimization is done to
519 reflect the current level. */
521 c_cpp_builtins_optimize_pragma (cpp_reader
*pfile
, tree prev_tree
,
524 struct cl_optimization
*prev
= TREE_OPTIMIZATION (prev_tree
);
525 struct cl_optimization
*cur
= TREE_OPTIMIZATION (cur_tree
);
529 /* -undef turns off target-specific built-ins. */
533 /* Other target-independent built-ins determined by command-line
535 if (!prev
->x_optimize_size
&& cur
->x_optimize_size
)
536 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
537 else if (prev
->x_optimize_size
&& !cur
->x_optimize_size
)
538 cpp_undef (pfile
, "__OPTIMIZE_SIZE__");
540 if (!prev
->x_optimize
&& cur
->x_optimize
)
541 cpp_define (pfile
, "__OPTIMIZE__");
542 else if (prev
->x_optimize
&& !cur
->x_optimize
)
543 cpp_undef (pfile
, "__OPTIMIZE__");
545 prev_fast_math
= fast_math_flags_struct_set_p (prev
);
546 cur_fast_math
= fast_math_flags_struct_set_p (cur
);
547 if (!prev_fast_math
&& cur_fast_math
)
548 cpp_define (pfile
, "__FAST_MATH__");
549 else if (prev_fast_math
&& !cur_fast_math
)
550 cpp_undef (pfile
, "__FAST_MATH__");
552 if (!prev
->x_flag_signaling_nans
&& cur
->x_flag_signaling_nans
)
553 cpp_define (pfile
, "__SUPPORT_SNAN__");
554 else if (prev
->x_flag_signaling_nans
&& !cur
->x_flag_signaling_nans
)
555 cpp_undef (pfile
, "__SUPPORT_SNAN__");
557 if (!prev
->x_flag_finite_math_only
&& cur
->x_flag_finite_math_only
)
559 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
560 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
562 else if (prev
->x_flag_finite_math_only
&& !cur
->x_flag_finite_math_only
)
564 cpp_undef (pfile
, "__FINITE_MATH_ONLY__");
565 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
570 /* This function will emit cpp macros to indicate the presence of various lock
571 free atomic operations. */
574 cpp_atomic_builtins (cpp_reader
*pfile
)
576 /* Set a flag for each size of object that compare and swap exists for up to
578 #define SWAP_LIMIT 17
579 bool have_swap
[SWAP_LIMIT
];
582 /* Clear the map of sizes compare_and swap exists for. */
583 memset (have_swap
, 0, sizeof (have_swap
));
585 /* Tell source code if the compiler makes sync_compare_and_swap
586 builtins available. */
587 #ifndef HAVE_sync_compare_and_swapqi
588 #define HAVE_sync_compare_and_swapqi 0
590 #ifndef HAVE_atomic_compare_and_swapqi
591 #define HAVE_atomic_compare_and_swapqi 0
594 if (HAVE_sync_compare_and_swapqi
|| HAVE_atomic_compare_and_swapqi
)
596 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
600 #ifndef HAVE_sync_compare_and_swaphi
601 #define HAVE_sync_compare_and_swaphi 0
603 #ifndef HAVE_atomic_compare_and_swaphi
604 #define HAVE_atomic_compare_and_swaphi 0
606 if (HAVE_sync_compare_and_swaphi
|| HAVE_atomic_compare_and_swaphi
)
608 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
612 #ifndef HAVE_sync_compare_and_swapsi
613 #define HAVE_sync_compare_and_swapsi 0
615 #ifndef HAVE_atomic_compare_and_swapsi
616 #define HAVE_atomic_compare_and_swapsi 0
618 if (HAVE_sync_compare_and_swapsi
|| HAVE_atomic_compare_and_swapsi
)
620 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
624 #ifndef HAVE_sync_compare_and_swapdi
625 #define HAVE_sync_compare_and_swapdi 0
627 #ifndef HAVE_atomic_compare_and_swapdi
628 #define HAVE_atomic_compare_and_swapdi 0
630 if (HAVE_sync_compare_and_swapdi
|| HAVE_atomic_compare_and_swapdi
)
632 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
636 #ifndef HAVE_sync_compare_and_swapti
637 #define HAVE_sync_compare_and_swapti 0
639 #ifndef HAVE_atomic_compare_and_swapti
640 #define HAVE_atomic_compare_and_swapti 0
642 if (HAVE_sync_compare_and_swapti
|| HAVE_atomic_compare_and_swapti
)
644 cpp_define (pfile
, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
645 have_swap
[16] = true;
648 /* Tell the source code about various types. These map to the C++11 and C11
649 macros where 2 indicates lock-free always, and 1 indicates sometimes
651 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
652 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
653 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
654 (have_swap
[SWAP_INDEX (boolean_type_node
)]? 2 : 1));
655 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
656 (have_swap
[SWAP_INDEX (signed_char_type_node
)]? 2 : 1));
657 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
658 (have_swap
[SWAP_INDEX (char16_type_node
)]? 2 : 1));
659 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
660 (have_swap
[SWAP_INDEX (char32_type_node
)]? 2 : 1));
661 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
662 (have_swap
[SWAP_INDEX (wchar_type_node
)]? 2 : 1));
663 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
664 (have_swap
[SWAP_INDEX (short_integer_type_node
)]? 2 : 1));
665 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
666 (have_swap
[SWAP_INDEX (integer_type_node
)]? 2 : 1));
667 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
668 (have_swap
[SWAP_INDEX (long_integer_type_node
)]? 2 : 1));
669 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
670 (have_swap
[SWAP_INDEX (long_long_integer_type_node
)]? 2 : 1));
672 /* If we're dealing with a "set" value that doesn't exactly correspond
673 to a boolean truth value, let the library work around that. */
674 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
675 targetm
.atomic_test_and_set_trueval
);
677 /* ptr_type_node can't be used here since ptr_mode is only set when
678 toplev calls backend_init which is not done with -E or pch. */
679 psize
= POINTER_SIZE
/ BITS_PER_UNIT
;
680 if (psize
>= SWAP_LIMIT
)
682 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
683 (have_swap
[psize
]? 2 : 1));
686 /* Return the value for __GCC_IEC_559. */
688 cpp_iec_559_value (void)
690 /* The default is support for IEEE 754-2008. */
693 /* float and double must be binary32 and binary64. If they are but
694 with reversed NaN convention, at most IEEE 754-1985 is
696 const struct real_format
*ffmt
697 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node
));
698 const struct real_format
*dfmt
699 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node
));
700 if (!ffmt
->qnan_msb_set
|| !dfmt
->qnan_msb_set
)
705 || ffmt
->emin
!= -125
707 || ffmt
->signbit_rw
!= 31
708 || ffmt
->round_towards_zero
709 || !ffmt
->has_sign_dependent_rounding
713 || !ffmt
->has_signed_zero
717 || dfmt
->emin
!= -1021
718 || dfmt
->emax
!= 1024
719 || dfmt
->signbit_rw
!= 63
720 || dfmt
->round_towards_zero
721 || !dfmt
->has_sign_dependent_rounding
725 || !dfmt
->has_signed_zero
)
728 /* In strict C standards conformance mode, consider unpredictable
729 excess precision to mean lack of IEEE 754 support. ??? The same
730 should apply to unpredictable contraction, but at present
731 standards conformance options do not enable conforming
732 contraction. For C++, and outside strict conformance mode, do
733 not consider these options to mean lack of IEEE 754 support. */
736 && TARGET_FLT_EVAL_METHOD
!= 0
737 && flag_excess_precision
!= EXCESS_PRECISION_STANDARD
)
740 /* Various options are contrary to IEEE 754 semantics. */
741 if (flag_unsafe_math_optimizations
742 || flag_associative_math
743 || flag_reciprocal_math
744 || flag_finite_math_only
745 || !flag_signed_zeros
746 || flag_single_precision_constant
)
749 /* If the target does not support IEEE 754 exceptions and rounding
750 modes, consider IEEE 754 support to be absent. */
751 if (!targetm
.float_exceptions_rounding_supported_p ())
757 /* Return the value for __GCC_IEC_559_COMPLEX. */
759 cpp_iec_559_complex_value (void)
761 /* The value is no bigger than that of __GCC_IEC_559. */
762 int ret
= cpp_iec_559_value ();
764 /* Some options are contrary to the required default state of the
765 CX_LIMITED_RANGE pragma. */
766 if (flag_complex_method
!= 2)
772 /* Hook that registers front end and target-specific built-ins. */
774 c_cpp_builtins (cpp_reader
*pfile
)
776 /* -undef turns off target-specific built-ins. */
780 define_language_independent_builtin_macros (pfile
);
782 if (c_dialect_cxx ())
785 parse_basever (&major
, NULL
, NULL
);
786 cpp_define_formatted (pfile
, "__GNUG__=%d", major
);
789 /* For stddef.h. They require macros defined in c-common.c. */
790 c_stddef_cpp_builtins ();
792 if (c_dialect_cxx ())
794 if (flag_weak
&& SUPPORTS_ONE_ONLY
)
795 cpp_define (pfile
, "__GXX_WEAK__=1");
797 cpp_define (pfile
, "__GXX_WEAK__=0");
799 cpp_define (pfile
, "__DEPRECATED");
801 cpp_define (pfile
, "__GXX_RTTI");
802 if (cxx_dialect
>= cxx11
)
803 cpp_define (pfile
, "__GXX_EXPERIMENTAL_CXX0X__");
805 /* Note that we define this for C as well, so that we know if
806 __attribute__((cleanup)) will interface with EH. */
808 cpp_define (pfile
, "__EXCEPTIONS");
810 /* Represents the C++ ABI version, always defined so it can be used while
811 preprocessing C and assembler. */
812 if (flag_abi_version
== 0)
813 /* Use a very large value so that:
815 #if __GXX_ABI_VERSION >= <value for version X>
817 will work whether the user explicitly says "-fabi-version=x" or
818 "-fabi-version=0". Do not use INT_MAX because that will be
819 different from system to system. */
820 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
821 else if (flag_abi_version
== 1)
822 /* Due to a historical accident, this version had the value
824 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
826 /* Newer versions have values 1002, 1003, .... */
827 builtin_define_with_int_value ("__GXX_ABI_VERSION",
828 1000 + flag_abi_version
);
830 /* libgcc needs to know this. */
831 if (targetm_common
.except_unwind_info (&global_options
) == UI_SJLJ
)
832 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
834 /* limits.h and stdint.h need to know these. */
835 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
);
836 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
);
837 builtin_define_type_max ("__INT_MAX__", integer_type_node
);
838 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
);
839 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
);
840 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
841 underlying_wchar_type_node
);
842 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node
);
843 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node
);
844 builtin_define_type_max ("__SIZE_MAX__", size_type_node
);
846 /* stdint.h and the testsuite need to know these. */
847 builtin_define_stdint_macros ();
849 /* Provide information for library headers to determine whether to
850 define macros such as __STDC_IEC_559__ and
851 __STDC_IEC_559_COMPLEX__. */
852 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
853 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
854 cpp_iec_559_complex_value ());
856 /* float.h needs to know this. */
857 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
858 TARGET_FLT_EVAL_METHOD
);
860 /* And decfloat.h needs this. */
861 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
862 TARGET_DEC_EVAL_METHOD
);
864 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node
);
865 /* Cast the double precision constants. This is needed when single
866 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
867 is used. The correct result is computed by the compiler when using
868 macros that include a cast. We use a different cast for C++ to avoid
869 problems with -Wold-style-cast. */
870 builtin_define_float_constants ("DBL", "L",
874 "", double_type_node
);
875 builtin_define_float_constants ("LDBL", "L", "%s", "L",
876 long_double_type_node
);
878 /* For decfloat.h. */
879 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node
);
880 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node
);
881 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node
);
883 /* For fixed-point fibt, ibit, max, min, and epsilon. */
884 if (targetm
.fixed_point_supported_p ())
886 builtin_define_fixed_point_constants ("SFRACT", "HR",
887 short_fract_type_node
);
888 builtin_define_fixed_point_constants ("USFRACT", "UHR",
889 unsigned_short_fract_type_node
);
890 builtin_define_fixed_point_constants ("FRACT", "R",
892 builtin_define_fixed_point_constants ("UFRACT", "UR",
893 unsigned_fract_type_node
);
894 builtin_define_fixed_point_constants ("LFRACT", "LR",
895 long_fract_type_node
);
896 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
897 unsigned_long_fract_type_node
);
898 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
899 long_long_fract_type_node
);
900 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
901 unsigned_long_long_fract_type_node
);
902 builtin_define_fixed_point_constants ("SACCUM", "HK",
903 short_accum_type_node
);
904 builtin_define_fixed_point_constants ("USACCUM", "UHK",
905 unsigned_short_accum_type_node
);
906 builtin_define_fixed_point_constants ("ACCUM", "K",
908 builtin_define_fixed_point_constants ("UACCUM", "UK",
909 unsigned_accum_type_node
);
910 builtin_define_fixed_point_constants ("LACCUM", "LK",
911 long_accum_type_node
);
912 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
913 unsigned_long_accum_type_node
);
914 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
915 long_long_accum_type_node
);
916 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
917 unsigned_long_long_accum_type_node
);
919 builtin_define_fixed_point_constants ("QQ", "", qq_type_node
);
920 builtin_define_fixed_point_constants ("HQ", "", hq_type_node
);
921 builtin_define_fixed_point_constants ("SQ", "", sq_type_node
);
922 builtin_define_fixed_point_constants ("DQ", "", dq_type_node
);
923 builtin_define_fixed_point_constants ("TQ", "", tq_type_node
);
924 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node
);
925 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node
);
926 builtin_define_fixed_point_constants ("USQ", "", usq_type_node
);
927 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node
);
928 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node
);
929 builtin_define_fixed_point_constants ("HA", "", ha_type_node
);
930 builtin_define_fixed_point_constants ("SA", "", sa_type_node
);
931 builtin_define_fixed_point_constants ("DA", "", da_type_node
);
932 builtin_define_fixed_point_constants ("TA", "", ta_type_node
);
933 builtin_define_fixed_point_constants ("UHA", "", uha_type_node
);
934 builtin_define_fixed_point_constants ("USA", "", usa_type_node
);
935 builtin_define_fixed_point_constants ("UDA", "", uda_type_node
);
936 builtin_define_fixed_point_constants ("UTA", "", uta_type_node
);
939 /* For libgcc-internal use only. */
940 if (flag_building_libgcc
)
941 /* For libgcc enable-execute-stack.c. */
942 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
945 /* For use in assembly language. */
946 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
947 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
950 if (flag_gnu89_inline
)
951 cpp_define (pfile
, "__GNUC_GNU_INLINE__");
953 cpp_define (pfile
, "__GNUC_STDC_INLINE__");
956 cpp_define (pfile
, "__NO_INLINE__");
959 cpp_define (pfile
, "__STRICT_ANSI__");
961 if (!flag_signed_char
)
962 cpp_define (pfile
, "__CHAR_UNSIGNED__");
964 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node
))
965 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
967 cpp_atomic_builtins (pfile
);
969 #ifdef DWARF2_UNWIND_INFO
970 if (dwarf2out_do_cfi_asm ())
971 cpp_define (pfile
, "__GCC_HAVE_DWARF2_CFI_ASM");
974 /* Make the choice of ObjC runtime visible to source code. */
975 if (c_dialect_objc () && flag_next_runtime
)
976 cpp_define (pfile
, "__NEXT_RUNTIME__");
978 /* Show the availability of some target pragmas. */
979 cpp_define (pfile
, "__PRAGMA_REDEFINE_EXTNAME");
981 /* Make the choice of the stack protector runtime visible to source code.
982 The macro names and values here were chosen for compatibility with an
983 earlier implementation, i.e. ProPolice. */
984 if (flag_stack_protect
== 3)
985 cpp_define (pfile
, "__SSP_STRONG__=3");
986 if (flag_stack_protect
== 2)
987 cpp_define (pfile
, "__SSP_ALL__=2");
988 else if (flag_stack_protect
== 1)
989 cpp_define (pfile
, "__SSP__=1");
992 cpp_define (pfile
, "_OPENMP=201307");
994 if (int128_integer_type_node
!= NULL_TREE
)
995 builtin_define_type_sizeof ("__SIZEOF_INT128__",
996 int128_integer_type_node
);
997 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node
);
998 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node
);
999 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1000 unsigned_ptrdiff_type_node
);
1002 /* A straightforward target hook doesn't work, because of problems
1003 linking that hook's body when part of non-C front ends. */
1004 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1005 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1006 # define builtin_define(TXT) cpp_define (pfile, TXT)
1007 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1008 TARGET_CPU_CPP_BUILTINS ();
1009 TARGET_OS_CPP_BUILTINS ();
1010 TARGET_OBJFMT_CPP_BUILTINS ();
1012 /* Support the __declspec keyword by turning them into attributes.
1013 Note that the current way we do this may result in a collision
1014 with predefined attributes later on. This can be solved by using
1015 one attribute, say __declspec__, and passing args to it. The
1016 problem with that approach is that args are not accumulated: each
1017 new appearance would clobber any existing args. */
1018 if (TARGET_DECLSPEC
)
1019 builtin_define ("__declspec(x)=__attribute__((x))");
1021 /* If decimal floating point is supported, tell the user if the
1022 alternate format (BID) is used instead of the standard (DPD)
1024 if (ENABLE_DECIMAL_FLOAT
&& ENABLE_DECIMAL_BID_FORMAT
)
1025 cpp_define (pfile
, "__DECIMAL_BID_FORMAT__");
1028 /* Pass an object-like macro. If it doesn't lie in the user's
1029 namespace, defines it unconditionally. Otherwise define a version
1030 with two leading underscores, and another version with two leading
1031 and trailing underscores, and define the original only if an ISO
1032 standard was not nominated.
1034 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1035 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1038 builtin_define_std (const char *macro
)
1040 size_t len
= strlen (macro
);
1041 char *buff
= (char *) alloca (len
+ 5);
1045 /* prepend __ (or maybe just _) if in user's namespace. */
1046 memcpy (p
, macro
, len
+ 1);
1047 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
1054 cpp_define (parse_in
, p
);
1056 /* If it was in user's namespace... */
1059 /* Define the macro with leading and following __. */
1065 cpp_define (parse_in
, p
);
1067 /* Finally, define the original macro if permitted. */
1069 cpp_define (parse_in
, macro
);
1073 /* Pass an object-like macro and a value to define it to. The third
1074 parameter says whether or not to turn the value into a string
1077 builtin_define_with_value (const char *macro
, const char *expansion
, int is_str
)
1080 size_t mlen
= strlen (macro
);
1081 size_t elen
= strlen (expansion
);
1082 size_t extra
= 2; /* space for an = and a NUL */
1085 extra
+= 2; /* space for two quote marks */
1087 buf
= (char *) alloca (mlen
+ elen
+ extra
);
1089 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
1091 sprintf (buf
, "%s=%s", macro
, expansion
);
1093 cpp_define (parse_in
, buf
);
1097 /* Pass an object-like macro and an integer value to define it to. */
1099 builtin_define_with_int_value (const char *macro
, HOST_WIDE_INT value
)
1102 size_t mlen
= strlen (macro
);
1104 size_t extra
= 2; /* space for = and NUL. */
1106 buf
= (char *) alloca (mlen
+ vlen
+ extra
);
1107 memcpy (buf
, macro
, mlen
);
1109 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
1111 cpp_define (parse_in
, buf
);
1114 /* builtin_define_with_hex_fp_value is very expensive, so the following
1115 array and function allows it to be done lazily when __DBL_MAX__
1116 etc. is first used. */
1118 struct GTY(()) lazy_hex_fp_value_struct
1120 const char *hex_str
;
1122 enum machine_mode mode
;
1124 const char *fp_suffix
;
1126 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values
[12];
1127 static GTY(()) int lazy_hex_fp_value_count
;
1130 lazy_hex_fp_value (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
1133 REAL_VALUE_TYPE real
;
1134 char dec_str
[64], buf1
[256];
1136 if (node
->value
.builtin
< BT_FIRST_USER
1137 || (int) node
->value
.builtin
>= BT_FIRST_USER
+ lazy_hex_fp_value_count
)
1140 idx
= node
->value
.builtin
- BT_FIRST_USER
;
1141 real_from_string (&real
, lazy_hex_fp_values
[idx
].hex_str
);
1142 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
),
1143 lazy_hex_fp_values
[idx
].digits
, 0,
1144 lazy_hex_fp_values
[idx
].mode
);
1146 sprintf (buf1
, "%s%s", dec_str
, lazy_hex_fp_values
[idx
].fp_suffix
);
1147 node
->flags
&= ~(NODE_BUILTIN
| NODE_USED
);
1148 node
->value
.macro
= lazy_hex_fp_values
[idx
].macro
;
1149 for (idx
= 0; idx
< node
->value
.macro
->count
; idx
++)
1150 if (node
->value
.macro
->exp
.tokens
[idx
].type
== CPP_NUMBER
)
1152 gcc_assert (idx
< node
->value
.macro
->count
);
1153 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.len
= strlen (buf1
);
1154 node
->value
.macro
->exp
.tokens
[idx
].val
.str
.text
1155 = (const unsigned char *) ggc_strdup (buf1
);
1159 /* Pass an object-like macro a hexadecimal floating-point value. */
1161 builtin_define_with_hex_fp_value (const char *macro
,
1162 tree type
, int digits
,
1163 const char *hex_str
,
1164 const char *fp_suffix
,
1165 const char *fp_cast
)
1167 REAL_VALUE_TYPE real
;
1168 char dec_str
[64], buf1
[256], buf2
[256];
1170 /* This is very expensive, so if possible expand them lazily. */
1171 if (lazy_hex_fp_value_count
< 12
1172 && flag_dump_macros
== 0
1173 && !cpp_get_options (parse_in
)->traditional
)
1175 struct cpp_hashnode
*node
;
1176 if (lazy_hex_fp_value_count
== 0)
1177 cpp_get_callbacks (parse_in
)->user_builtin_macro
= lazy_hex_fp_value
;
1178 sprintf (buf2
, fp_cast
, "1.1");
1179 sprintf (buf1
, "%s=%s", macro
, buf2
);
1180 cpp_define (parse_in
, buf1
);
1181 node
= C_CPP_HASHNODE (get_identifier (macro
));
1182 lazy_hex_fp_values
[lazy_hex_fp_value_count
].hex_str
1183 = ggc_strdup (hex_str
);
1184 lazy_hex_fp_values
[lazy_hex_fp_value_count
].mode
= TYPE_MODE (type
);
1185 lazy_hex_fp_values
[lazy_hex_fp_value_count
].digits
= digits
;
1186 lazy_hex_fp_values
[lazy_hex_fp_value_count
].fp_suffix
= fp_suffix
;
1187 lazy_hex_fp_values
[lazy_hex_fp_value_count
].macro
= node
->value
.macro
;
1188 node
->flags
|= NODE_BUILTIN
;
1190 = (enum cpp_builtin_type
) (BT_FIRST_USER
+ lazy_hex_fp_value_count
);
1191 lazy_hex_fp_value_count
++;
1195 /* Hex values are really cool and convenient, except that they're
1196 not supported in strict ISO C90 mode. First, the "p-" sequence
1197 is not valid as part of a preprocessor number. Second, we get a
1198 pedwarn from the preprocessor, which has no context, so we can't
1199 suppress the warning with __extension__.
1201 So instead what we do is construct the number in hex (because
1202 it's easy to get the exact correct value), parse it as a real,
1203 then print it back out as decimal. */
1205 real_from_string (&real
, hex_str
);
1206 real_to_decimal_for_mode (dec_str
, &real
, sizeof (dec_str
), digits
, 0,
1209 /* Assemble the macro in the following fashion
1210 macro = fp_cast [dec_str fp_suffix] */
1211 sprintf (buf1
, "%s%s", dec_str
, fp_suffix
);
1212 sprintf (buf2
, fp_cast
, buf1
);
1213 sprintf (buf1
, "%s=%s", macro
, buf2
);
1215 cpp_define (parse_in
, buf1
);
1218 /* Return a string constant for the suffix for a value of type TYPE
1219 promoted according to the integer promotions. The type must be one
1220 of the standard integer type nodes. */
1223 type_suffix (tree type
)
1225 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
1226 int unsigned_suffix
;
1229 if (type
== long_long_integer_type_node
1230 || type
== long_long_unsigned_type_node
)
1232 else if (type
== long_integer_type_node
1233 || type
== long_unsigned_type_node
)
1235 else if (type
== integer_type_node
1236 || type
== unsigned_type_node
1237 || type
== short_integer_type_node
1238 || type
== short_unsigned_type_node
1239 || type
== signed_char_type_node
1240 || type
== unsigned_char_type_node
1241 /* ??? "char" is not a signed or unsigned integer type and
1242 so is not permitted for the standard typedefs, but some
1243 systems use it anyway. */
1244 || type
== char_type_node
)
1249 unsigned_suffix
= TYPE_UNSIGNED (type
);
1250 if (TYPE_PRECISION (type
) < TYPE_PRECISION (integer_type_node
))
1251 unsigned_suffix
= 0;
1252 return suffixes
[is_long
* 2 + unsigned_suffix
];
1255 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1257 builtin_define_constants (const char *macro
, tree type
)
1262 suffix
= type_suffix (type
);
1266 buf
= (char *) alloca (strlen (macro
) + 6);
1267 sprintf (buf
, "%s(c)=c", macro
);
1271 buf
= (char *) alloca (strlen (macro
) + 9 + strlen (suffix
) + 1);
1272 sprintf (buf
, "%s(c)=c ## %s", macro
, suffix
);
1275 cpp_define (parse_in
, buf
);
1278 /* Define MAX for TYPE based on the precision of the type. */
1281 builtin_define_type_max (const char *macro
, tree type
)
1283 builtin_define_type_minmax (NULL
, macro
, type
);
1286 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1287 precision of the type. */
1290 builtin_define_type_minmax (const char *min_macro
, const char *max_macro
,
1293 static const char *const values
[]
1296 "2147483647", "4294967295",
1297 "9223372036854775807", "18446744073709551615",
1298 "170141183460469231731687303715884105727",
1299 "340282366920938463463374607431768211455" };
1301 const char *value
, *suffix
;
1305 /* Pre-rendering the values mean we don't have to futz with printing a
1306 multi-word decimal value. There are also a very limited number of
1307 precisions that we support, so it's really a waste of time. */
1308 switch (TYPE_PRECISION (type
))
1310 case 8: idx
= 0; break;
1311 case 16: idx
= 2; break;
1312 case 32: idx
= 4; break;
1313 case 64: idx
= 6; break;
1314 case 128: idx
= 8; break;
1315 default: gcc_unreachable ();
1318 value
= values
[idx
+ TYPE_UNSIGNED (type
)];
1319 suffix
= type_suffix (type
);
1321 buf
= (char *) alloca (strlen (max_macro
) + 1 + strlen (value
)
1322 + strlen (suffix
) + 1);
1323 sprintf (buf
, "%s=%s%s", max_macro
, value
, suffix
);
1325 cpp_define (parse_in
, buf
);
1329 if (TYPE_UNSIGNED (type
))
1331 buf
= (char *) alloca (strlen (min_macro
) + 2 + strlen (suffix
) + 1);
1332 sprintf (buf
, "%s=0%s", min_macro
, suffix
);
1336 buf
= (char *) alloca (strlen (min_macro
) + 3
1337 + strlen (max_macro
) + 6);
1338 sprintf (buf
, "%s=(-%s - 1)", min_macro
, max_macro
);
1340 cpp_define (parse_in
, buf
);
1344 #include "gt-c-family-c-cppbuiltin.h"