Use -fbuilding-libgcc for more target macros used in libgcc.
[official-gcc.git] / gcc / c-family / c-cppbuiltin.c
bloba47473534b55f4f7cf92382088a94fffb7e88c0f
1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2014 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
9 version.
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
14 for more details.
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/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "tree.h"
25 #include "stor-layout.h"
26 #include "stringpool.h"
27 #include "version.h"
28 #include "flags.h"
29 #include "c-common.h"
30 #include "c-pragma.h"
31 #include "output.h" /* For user_label_prefix. */
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
33 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
34 #include "target.h"
35 #include "common/common-target.h"
36 #include "cpp-id-data.h"
37 #include "cppbuiltin.h"
39 #ifndef TARGET_OS_CPP_BUILTINS
40 # define TARGET_OS_CPP_BUILTINS()
41 #endif
43 #ifndef TARGET_OBJFMT_CPP_BUILTINS
44 # define TARGET_OBJFMT_CPP_BUILTINS()
45 #endif
47 #ifndef REGISTER_PREFIX
48 #define REGISTER_PREFIX ""
49 #endif
51 /* Non-static as some targets don't use it. */
52 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
53 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
54 static void builtin_define_with_hex_fp_value (const char *, tree,
55 int, const char *,
56 const char *,
57 const char *);
58 static void builtin_define_stdint_macros (void);
59 static void builtin_define_constants (const char *, tree);
60 static void builtin_define_type_max (const char *, tree);
61 static void builtin_define_type_minmax (const char *, const char *, tree);
62 static void builtin_define_type_sizeof (const char *, tree);
63 static void builtin_define_float_constants (const char *,
64 const char *,
65 const char *,
66 const char *,
67 tree);
69 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
70 Originally this function used the fma optab, but that doesn't work with
71 -save-temps, so just rely on the HAVE_fma macros for the standard floating
72 point types. */
74 static bool
75 mode_has_fma (enum machine_mode mode)
77 switch (mode)
79 #ifdef HAVE_fmasf4
80 case SFmode:
81 return !!HAVE_fmasf4;
82 #endif
84 #ifdef HAVE_fmadf4
85 case DFmode:
86 return !!HAVE_fmadf4;
87 #endif
89 #ifdef HAVE_fmaxf4
90 case XFmode:
91 return !!HAVE_fmaxf4;
92 #endif
94 #ifdef HAVE_fmatf4
95 case TFmode:
96 return !!HAVE_fmatf4;
97 #endif
99 default:
100 break;
103 return false;
106 /* Define NAME with value TYPE size_unit. */
107 static void
108 builtin_define_type_sizeof (const char *name, tree type)
110 builtin_define_with_int_value (name,
111 tree_to_uhwi (TYPE_SIZE_UNIT (type)));
114 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
115 and FP_CAST. */
116 static void
117 builtin_define_float_constants (const char *name_prefix,
118 const char *fp_suffix,
119 const char *fp_cast,
120 const char *fma_suffix,
121 tree type)
123 /* Used to convert radix-based values to base 10 values in several cases.
125 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
126 least 6 significant digits for correct results. Using the fraction
127 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
128 intermediate; perhaps someone can find a better approximation, in the
129 mean time, I suspect using doubles won't harm the bootstrap here. */
131 const double log10_2 = .30102999566398119521;
132 double log10_b;
133 const struct real_format *fmt;
134 const struct real_format *ldfmt;
136 char name[64], buf[128];
137 int dig, min_10_exp, max_10_exp;
138 int decimal_dig;
139 int type_decimal_dig;
141 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
142 gcc_assert (fmt->b != 10);
143 ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
144 gcc_assert (ldfmt->b != 10);
146 /* The radix of the exponent representation. */
147 if (type == float_type_node)
148 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
149 log10_b = log10_2;
151 /* The number of radix digits, p, in the floating-point significand. */
152 sprintf (name, "__%s_MANT_DIG__", name_prefix);
153 builtin_define_with_int_value (name, fmt->p);
155 /* The number of decimal digits, q, such that any floating-point number
156 with q decimal digits can be rounded into a floating-point number with
157 p radix b digits and back again without change to the q decimal digits,
159 p log10 b if b is a power of 10
160 floor((p - 1) log10 b) otherwise
162 dig = (fmt->p - 1) * log10_b;
163 sprintf (name, "__%s_DIG__", name_prefix);
164 builtin_define_with_int_value (name, dig);
166 /* The minimum negative int x such that b**(x-1) is a normalized float. */
167 sprintf (name, "__%s_MIN_EXP__", name_prefix);
168 sprintf (buf, "(%d)", fmt->emin);
169 builtin_define_with_value (name, buf, 0);
171 /* The minimum negative int x such that 10**x is a normalized float,
173 ceil (log10 (b ** (emin - 1)))
174 = ceil (log10 (b) * (emin - 1))
176 Recall that emin is negative, so the integer truncation calculates
177 the ceiling, not the floor, in this case. */
178 min_10_exp = (fmt->emin - 1) * log10_b;
179 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
180 sprintf (buf, "(%d)", min_10_exp);
181 builtin_define_with_value (name, buf, 0);
183 /* The maximum int x such that b**(x-1) is a representable float. */
184 sprintf (name, "__%s_MAX_EXP__", name_prefix);
185 builtin_define_with_int_value (name, fmt->emax);
187 /* The maximum int x such that 10**x is in the range of representable
188 finite floating-point numbers,
190 floor (log10((1 - b**-p) * b**emax))
191 = floor (log10(1 - b**-p) + log10(b**emax))
192 = floor (log10(1 - b**-p) + log10(b)*emax)
194 The safest thing to do here is to just compute this number. But since
195 we don't link cc1 with libm, we cannot. We could implement log10 here
196 a series expansion, but that seems too much effort because:
198 Note that the first term, for all extant p, is a number exceedingly close
199 to zero, but slightly negative. Note that the second term is an integer
200 scaling an irrational number, and that because of the floor we are only
201 interested in its integral portion.
203 In order for the first term to have any effect on the integral portion
204 of the second term, the second term has to be exceedingly close to an
205 integer itself (e.g. 123.000000000001 or something). Getting a result
206 that close to an integer requires that the irrational multiplicand have
207 a long series of zeros in its expansion, which doesn't occur in the
208 first 20 digits or so of log10(b).
210 Hand-waving aside, crunching all of the sets of constants above by hand
211 does not yield a case for which the first term is significant, which
212 in the end is all that matters. */
213 max_10_exp = fmt->emax * log10_b;
214 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
215 builtin_define_with_int_value (name, max_10_exp);
217 /* The number of decimal digits, n, such that any floating-point number
218 can be rounded to n decimal digits and back again without change to
219 the value.
221 p * log10(b) if b is a power of 10
222 ceil(1 + p * log10(b)) otherwise
224 The only macro we care about is this number for the widest supported
225 floating type, but we want this value for rendering constants below. */
227 double d_decimal_dig
228 = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
229 decimal_dig = d_decimal_dig;
230 if (decimal_dig < d_decimal_dig)
231 decimal_dig++;
233 /* Similar, for this type rather than long double. */
235 double type_d_decimal_dig = 1 + fmt->p * log10_b;
236 type_decimal_dig = type_d_decimal_dig;
237 if (type_decimal_dig < type_d_decimal_dig)
238 type_decimal_dig++;
240 if (type == long_double_type_node)
241 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
242 else
244 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
245 builtin_define_with_int_value (name, type_decimal_dig);
248 /* Since, for the supported formats, B is always a power of 2, we
249 construct the following numbers directly as a hexadecimal
250 constants. */
251 get_max_float (fmt, buf, sizeof (buf));
253 sprintf (name, "__%s_MAX__", name_prefix);
254 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
256 /* The minimum normalized positive floating-point number,
257 b**(emin-1). */
258 sprintf (name, "__%s_MIN__", name_prefix);
259 sprintf (buf, "0x1p%d", fmt->emin - 1);
260 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
262 /* The difference between 1 and the least value greater than 1 that is
263 representable in the given floating point type, b**(1-p). */
264 sprintf (name, "__%s_EPSILON__", name_prefix);
265 if (fmt->pnan < fmt->p)
266 /* This is an IBM extended double format, so 1.0 + any double is
267 representable precisely. */
268 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
269 else
270 sprintf (buf, "0x1p%d", 1 - fmt->p);
271 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
273 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
274 positive floating-point number, b**(emin-p). Zero for formats that
275 don't support denormals. */
276 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
277 if (fmt->has_denorm)
279 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
280 builtin_define_with_hex_fp_value (name, type, decimal_dig,
281 buf, fp_suffix, fp_cast);
283 else
285 sprintf (buf, "0.0%s", fp_suffix);
286 builtin_define_with_value (name, buf, 0);
289 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
290 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
292 /* For C++ std::numeric_limits<T>::has_infinity. */
293 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
294 builtin_define_with_int_value (name,
295 MODE_HAS_INFINITIES (TYPE_MODE (type)));
296 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
297 predicate to distinguish a target that has both quiet and
298 signalling NaNs from a target that has only quiet NaNs or only
299 signalling NaNs, so we assume that a target that has any kind of
300 NaN has quiet NaNs. */
301 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
302 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
304 /* Note whether we have fast FMA. */
305 if (mode_has_fma (TYPE_MODE (type)))
307 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
308 builtin_define_with_int_value (name, 1);
312 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
313 static void
314 builtin_define_decimal_float_constants (const char *name_prefix,
315 const char *suffix,
316 tree type)
318 const struct real_format *fmt;
319 char name[64], buf[128], *p;
320 int digits;
322 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
324 /* The number of radix digits, p, in the significand. */
325 sprintf (name, "__%s_MANT_DIG__", name_prefix);
326 builtin_define_with_int_value (name, fmt->p);
328 /* The minimum negative int x such that b**(x-1) is a normalized float. */
329 sprintf (name, "__%s_MIN_EXP__", name_prefix);
330 sprintf (buf, "(%d)", fmt->emin);
331 builtin_define_with_value (name, buf, 0);
333 /* The maximum int x such that b**(x-1) is a representable float. */
334 sprintf (name, "__%s_MAX_EXP__", name_prefix);
335 builtin_define_with_int_value (name, fmt->emax);
337 /* Compute the minimum representable value. */
338 sprintf (name, "__%s_MIN__", name_prefix);
339 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
340 builtin_define_with_value (name, buf, 0);
342 /* Compute the maximum representable value. */
343 sprintf (name, "__%s_MAX__", name_prefix);
344 p = buf;
345 for (digits = fmt->p; digits; digits--)
347 *p++ = '9';
348 if (digits == fmt->p)
349 *p++ = '.';
351 *p = 0;
352 /* fmt->p plus 1, to account for the decimal point and fmt->emax
353 minus 1 because the digits are nines, not 1.0. */
354 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
355 builtin_define_with_value (name, buf, 0);
357 /* Compute epsilon (the difference between 1 and least value greater
358 than 1 representable). */
359 sprintf (name, "__%s_EPSILON__", name_prefix);
360 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
361 builtin_define_with_value (name, buf, 0);
363 /* Minimum subnormal positive decimal value. */
364 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
365 p = buf;
366 for (digits = fmt->p; digits > 1; digits--)
368 *p++ = '0';
369 if (digits == fmt->p)
370 *p++ = '.';
372 *p = 0;
373 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
374 builtin_define_with_value (name, buf, 0);
377 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
379 static void
380 builtin_define_fixed_point_constants (const char *name_prefix,
381 const char *suffix,
382 tree type)
384 char name[64], buf[256], *new_buf;
385 int i, mod;
387 sprintf (name, "__%s_FBIT__", name_prefix);
388 builtin_define_with_int_value (name, TYPE_FBIT (type));
390 sprintf (name, "__%s_IBIT__", name_prefix);
391 builtin_define_with_int_value (name, TYPE_IBIT (type));
393 /* If there is no suffix, defines are for fixed-point modes.
394 We just return. */
395 if (strcmp (suffix, "") == 0)
396 return;
398 if (TYPE_UNSIGNED (type))
400 sprintf (name, "__%s_MIN__", name_prefix);
401 sprintf (buf, "0.0%s", suffix);
402 builtin_define_with_value (name, buf, 0);
404 else
406 sprintf (name, "__%s_MIN__", name_prefix);
407 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
408 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
409 TYPE_IBIT (type) - 1, suffix);
410 else
411 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
412 builtin_define_with_value (name, buf, 0);
415 sprintf (name, "__%s_MAX__", name_prefix);
416 sprintf (buf, "0X");
417 new_buf = buf + 2;
418 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
419 if (mod)
420 sprintf (new_buf++, "%x", (1 << mod) - 1);
421 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
422 sprintf (new_buf++, "F");
423 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
424 builtin_define_with_value (name, buf, 0);
426 sprintf (name, "__%s_EPSILON__", name_prefix);
427 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
428 builtin_define_with_value (name, buf, 0);
431 /* Define macros used by <stdint.h>. */
432 static void
433 builtin_define_stdint_macros (void)
435 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
436 builtin_define_constants ("__INTMAX_C", intmax_type_node);
437 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
438 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
439 if (sig_atomic_type_node)
440 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
441 sig_atomic_type_node);
442 if (int8_type_node)
443 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
444 if (int16_type_node)
445 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
446 if (int32_type_node)
447 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
448 if (int64_type_node)
449 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
450 if (uint8_type_node)
451 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
452 if (c_uint16_type_node)
453 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
454 if (c_uint32_type_node)
455 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
456 if (c_uint64_type_node)
457 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
458 if (int_least8_type_node)
460 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
461 builtin_define_constants ("__INT8_C", int_least8_type_node);
463 if (int_least16_type_node)
465 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
466 builtin_define_constants ("__INT16_C", int_least16_type_node);
468 if (int_least32_type_node)
470 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
471 builtin_define_constants ("__INT32_C", int_least32_type_node);
473 if (int_least64_type_node)
475 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
476 builtin_define_constants ("__INT64_C", int_least64_type_node);
478 if (uint_least8_type_node)
480 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
481 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
483 if (uint_least16_type_node)
485 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
486 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
488 if (uint_least32_type_node)
490 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
491 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
493 if (uint_least64_type_node)
495 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
496 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
498 if (int_fast8_type_node)
499 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
500 if (int_fast16_type_node)
501 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
502 if (int_fast32_type_node)
503 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
504 if (int_fast64_type_node)
505 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
506 if (uint_fast8_type_node)
507 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
508 if (uint_fast16_type_node)
509 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
510 if (uint_fast32_type_node)
511 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
512 if (uint_fast64_type_node)
513 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
514 if (intptr_type_node)
515 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
516 if (uintptr_type_node)
517 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
520 /* Adjust the optimization macros when a #pragma GCC optimization is done to
521 reflect the current level. */
522 void
523 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
524 tree cur_tree)
526 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
527 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
528 bool prev_fast_math;
529 bool cur_fast_math;
531 /* -undef turns off target-specific built-ins. */
532 if (flag_undef)
533 return;
535 /* Other target-independent built-ins determined by command-line
536 options. */
537 if (!prev->x_optimize_size && cur->x_optimize_size)
538 cpp_define (pfile, "__OPTIMIZE_SIZE__");
539 else if (prev->x_optimize_size && !cur->x_optimize_size)
540 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
542 if (!prev->x_optimize && cur->x_optimize)
543 cpp_define (pfile, "__OPTIMIZE__");
544 else if (prev->x_optimize && !cur->x_optimize)
545 cpp_undef (pfile, "__OPTIMIZE__");
547 prev_fast_math = fast_math_flags_struct_set_p (prev);
548 cur_fast_math = fast_math_flags_struct_set_p (cur);
549 if (!prev_fast_math && cur_fast_math)
550 cpp_define (pfile, "__FAST_MATH__");
551 else if (prev_fast_math && !cur_fast_math)
552 cpp_undef (pfile, "__FAST_MATH__");
554 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
555 cpp_define (pfile, "__SUPPORT_SNAN__");
556 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
557 cpp_undef (pfile, "__SUPPORT_SNAN__");
559 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
561 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
562 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
564 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
566 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
567 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
572 /* This function will emit cpp macros to indicate the presence of various lock
573 free atomic operations. */
575 static void
576 cpp_atomic_builtins (cpp_reader *pfile)
578 /* Set a flag for each size of object that compare and swap exists for up to
579 a 16 byte object. */
580 #define SWAP_LIMIT 17
581 bool have_swap[SWAP_LIMIT];
582 unsigned int psize;
584 /* Clear the map of sizes compare_and swap exists for. */
585 memset (have_swap, 0, sizeof (have_swap));
587 /* Tell source code if the compiler makes sync_compare_and_swap
588 builtins available. */
589 #ifndef HAVE_sync_compare_and_swapqi
590 #define HAVE_sync_compare_and_swapqi 0
591 #endif
592 #ifndef HAVE_atomic_compare_and_swapqi
593 #define HAVE_atomic_compare_and_swapqi 0
594 #endif
596 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
598 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
599 have_swap[1] = true;
602 #ifndef HAVE_sync_compare_and_swaphi
603 #define HAVE_sync_compare_and_swaphi 0
604 #endif
605 #ifndef HAVE_atomic_compare_and_swaphi
606 #define HAVE_atomic_compare_and_swaphi 0
607 #endif
608 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
610 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
611 have_swap[2] = true;
614 #ifndef HAVE_sync_compare_and_swapsi
615 #define HAVE_sync_compare_and_swapsi 0
616 #endif
617 #ifndef HAVE_atomic_compare_and_swapsi
618 #define HAVE_atomic_compare_and_swapsi 0
619 #endif
620 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
622 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
623 have_swap[4] = true;
626 #ifndef HAVE_sync_compare_and_swapdi
627 #define HAVE_sync_compare_and_swapdi 0
628 #endif
629 #ifndef HAVE_atomic_compare_and_swapdi
630 #define HAVE_atomic_compare_and_swapdi 0
631 #endif
632 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
634 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
635 have_swap[8] = true;
638 #ifndef HAVE_sync_compare_and_swapti
639 #define HAVE_sync_compare_and_swapti 0
640 #endif
641 #ifndef HAVE_atomic_compare_and_swapti
642 #define HAVE_atomic_compare_and_swapti 0
643 #endif
644 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
646 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
647 have_swap[16] = true;
650 /* Tell the source code about various types. These map to the C++11 and C11
651 macros where 2 indicates lock-free always, and 1 indicates sometimes
652 lock free. */
653 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
654 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
655 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
656 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
657 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
658 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
659 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
660 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
661 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
662 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
663 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
664 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
665 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
666 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
667 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
668 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
669 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
670 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
671 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
672 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
674 /* If we're dealing with a "set" value that doesn't exactly correspond
675 to a boolean truth value, let the library work around that. */
676 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
677 targetm.atomic_test_and_set_trueval);
679 /* ptr_type_node can't be used here since ptr_mode is only set when
680 toplev calls backend_init which is not done with -E or pch. */
681 psize = POINTER_SIZE / BITS_PER_UNIT;
682 if (psize >= SWAP_LIMIT)
683 psize = 0;
684 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
685 (have_swap[psize]? 2 : 1));
688 /* Return the value for __GCC_IEC_559. */
689 static int
690 cpp_iec_559_value (void)
692 /* The default is support for IEEE 754-2008. */
693 int ret = 2;
695 /* float and double must be binary32 and binary64. If they are but
696 with reversed NaN convention, at most IEEE 754-1985 is
697 supported. */
698 const struct real_format *ffmt
699 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
700 const struct real_format *dfmt
701 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
702 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
703 ret = 1;
704 if (ffmt->b != 2
705 || ffmt->p != 24
706 || ffmt->pnan != 24
707 || ffmt->emin != -125
708 || ffmt->emax != 128
709 || ffmt->signbit_rw != 31
710 || ffmt->round_towards_zero
711 || !ffmt->has_sign_dependent_rounding
712 || !ffmt->has_nans
713 || !ffmt->has_inf
714 || !ffmt->has_denorm
715 || !ffmt->has_signed_zero
716 || dfmt->b != 2
717 || dfmt->p != 53
718 || dfmt->pnan != 53
719 || dfmt->emin != -1021
720 || dfmt->emax != 1024
721 || dfmt->signbit_rw != 63
722 || dfmt->round_towards_zero
723 || !dfmt->has_sign_dependent_rounding
724 || !dfmt->has_nans
725 || !dfmt->has_inf
726 || !dfmt->has_denorm
727 || !dfmt->has_signed_zero)
728 ret = 0;
730 /* In strict C standards conformance mode, consider unpredictable
731 excess precision to mean lack of IEEE 754 support. The same
732 applies to unpredictable contraction. For C++, and outside
733 strict conformance mode, do not consider these options to mean
734 lack of IEEE 754 support. */
735 if (flag_iso
736 && !c_dialect_cxx ()
737 && TARGET_FLT_EVAL_METHOD != 0
738 && flag_excess_precision_cmdline != EXCESS_PRECISION_STANDARD)
739 ret = 0;
740 if (flag_iso
741 && !c_dialect_cxx ()
742 && flag_fp_contract_mode == FP_CONTRACT_FAST)
743 ret = 0;
745 /* Various options are contrary to IEEE 754 semantics. */
746 if (flag_unsafe_math_optimizations
747 || flag_associative_math
748 || flag_reciprocal_math
749 || flag_finite_math_only
750 || !flag_signed_zeros
751 || flag_single_precision_constant)
752 ret = 0;
754 /* If the target does not support IEEE 754 exceptions and rounding
755 modes, consider IEEE 754 support to be absent. */
756 if (!targetm.float_exceptions_rounding_supported_p ())
757 ret = 0;
759 return ret;
762 /* Return the value for __GCC_IEC_559_COMPLEX. */
763 static int
764 cpp_iec_559_complex_value (void)
766 /* The value is no bigger than that of __GCC_IEC_559. */
767 int ret = cpp_iec_559_value ();
769 /* Some options are contrary to the required default state of the
770 CX_LIMITED_RANGE pragma. */
771 if (flag_complex_method != 2)
772 ret = 0;
774 return ret;
777 /* Hook that registers front end and target-specific built-ins. */
778 void
779 c_cpp_builtins (cpp_reader *pfile)
781 /* -undef turns off target-specific built-ins. */
782 if (flag_undef)
783 return;
785 define_language_independent_builtin_macros (pfile);
787 if (c_dialect_cxx ())
789 int major;
790 parse_basever (&major, NULL, NULL);
791 cpp_define_formatted (pfile, "__GNUG__=%d", major);
794 /* For stddef.h. They require macros defined in c-common.c. */
795 c_stddef_cpp_builtins ();
797 if (c_dialect_cxx ())
799 if (flag_weak && SUPPORTS_ONE_ONLY)
800 cpp_define (pfile, "__GXX_WEAK__=1");
801 else
802 cpp_define (pfile, "__GXX_WEAK__=0");
803 if (warn_deprecated)
804 cpp_define (pfile, "__DEPRECATED");
805 if (flag_rtti)
806 cpp_define (pfile, "__GXX_RTTI");
807 if (cxx_dialect >= cxx11)
808 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
810 /* Note that we define this for C as well, so that we know if
811 __attribute__((cleanup)) will interface with EH. */
812 if (flag_exceptions)
813 cpp_define (pfile, "__EXCEPTIONS");
815 /* Represents the C++ ABI version, always defined so it can be used while
816 preprocessing C and assembler. */
817 if (flag_abi_version == 0)
818 /* Use a very large value so that:
820 #if __GXX_ABI_VERSION >= <value for version X>
822 will work whether the user explicitly says "-fabi-version=x" or
823 "-fabi-version=0". Do not use INT_MAX because that will be
824 different from system to system. */
825 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
826 else if (flag_abi_version == 1)
827 /* Due to a historical accident, this version had the value
828 "102". */
829 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
830 else
831 /* Newer versions have values 1002, 1003, .... */
832 builtin_define_with_int_value ("__GXX_ABI_VERSION",
833 1000 + flag_abi_version);
835 /* libgcc needs to know this. */
836 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
837 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
839 /* limits.h and stdint.h need to know these. */
840 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
841 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
842 builtin_define_type_max ("__INT_MAX__", integer_type_node);
843 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
844 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
845 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
846 underlying_wchar_type_node);
847 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
848 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
849 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
851 /* stdint.h and the testsuite need to know these. */
852 builtin_define_stdint_macros ();
854 /* Provide information for library headers to determine whether to
855 define macros such as __STDC_IEC_559__ and
856 __STDC_IEC_559_COMPLEX__. */
857 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
858 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
859 cpp_iec_559_complex_value ());
861 /* float.h needs to know this. */
862 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
863 TARGET_FLT_EVAL_METHOD);
865 /* And decfloat.h needs this. */
866 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
867 TARGET_DEC_EVAL_METHOD);
869 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
870 /* Cast the double precision constants. This is needed when single
871 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
872 is used. The correct result is computed by the compiler when using
873 macros that include a cast. We use a different cast for C++ to avoid
874 problems with -Wold-style-cast. */
875 builtin_define_float_constants ("DBL", "L",
876 (c_dialect_cxx ()
877 ? "double(%s)"
878 : "((double)%s)"),
879 "", double_type_node);
880 builtin_define_float_constants ("LDBL", "L", "%s", "L",
881 long_double_type_node);
883 /* For decfloat.h. */
884 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
885 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
886 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
888 /* For fixed-point fibt, ibit, max, min, and epsilon. */
889 if (targetm.fixed_point_supported_p ())
891 builtin_define_fixed_point_constants ("SFRACT", "HR",
892 short_fract_type_node);
893 builtin_define_fixed_point_constants ("USFRACT", "UHR",
894 unsigned_short_fract_type_node);
895 builtin_define_fixed_point_constants ("FRACT", "R",
896 fract_type_node);
897 builtin_define_fixed_point_constants ("UFRACT", "UR",
898 unsigned_fract_type_node);
899 builtin_define_fixed_point_constants ("LFRACT", "LR",
900 long_fract_type_node);
901 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
902 unsigned_long_fract_type_node);
903 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
904 long_long_fract_type_node);
905 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
906 unsigned_long_long_fract_type_node);
907 builtin_define_fixed_point_constants ("SACCUM", "HK",
908 short_accum_type_node);
909 builtin_define_fixed_point_constants ("USACCUM", "UHK",
910 unsigned_short_accum_type_node);
911 builtin_define_fixed_point_constants ("ACCUM", "K",
912 accum_type_node);
913 builtin_define_fixed_point_constants ("UACCUM", "UK",
914 unsigned_accum_type_node);
915 builtin_define_fixed_point_constants ("LACCUM", "LK",
916 long_accum_type_node);
917 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
918 unsigned_long_accum_type_node);
919 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
920 long_long_accum_type_node);
921 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
922 unsigned_long_long_accum_type_node);
924 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
925 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
926 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
927 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
928 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
929 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
930 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
931 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
932 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
933 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
934 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
935 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
936 builtin_define_fixed_point_constants ("DA", "", da_type_node);
937 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
938 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
939 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
940 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
941 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
944 /* For libgcc-internal use only. */
945 if (flag_building_libgcc)
947 /* For libgcc crtstuff.c and libgcc2.c. */
948 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
949 EH_TABLES_CAN_BE_READ_ONLY);
950 #ifdef EH_FRAME_SECTION_NAME
951 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
952 EH_FRAME_SECTION_NAME, 1);
953 #endif
954 #ifdef JCR_SECTION_NAME
955 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
956 JCR_SECTION_NAME, 1);
957 #endif
958 #ifdef CTORS_SECTION_ASM_OP
959 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
960 CTORS_SECTION_ASM_OP, 1);
961 #endif
962 #ifdef DTORS_SECTION_ASM_OP
963 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
964 DTORS_SECTION_ASM_OP, 1);
965 #endif
966 #ifdef TEXT_SECTION_ASM_OP
967 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
968 TEXT_SECTION_ASM_OP, 1);
969 #endif
970 #ifdef INIT_SECTION_ASM_OP
971 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
972 INIT_SECTION_ASM_OP, 1);
973 #endif
974 #ifdef INIT_ARRAY_SECTION_ASM_OP
975 /* Despite the name of this target macro, the expansion is not
976 actually used, and may be empty rather than a string
977 constant. */
978 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
979 #endif
981 /* For libgcc enable-execute-stack.c. */
982 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
983 TRAMPOLINE_SIZE);
985 /* For libgcc generic-morestack.c and unwinder code. */
986 #ifdef STACK_GROWS_DOWNWARD
987 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
988 #endif
990 /* For libgcc unwinder code. */
991 #ifdef DONT_USE_BUILTIN_SETJMP
992 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
993 #endif
994 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
995 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
996 DWARF_ALT_FRAME_RETURN_COLUMN);
997 #endif
998 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
999 DWARF_FRAME_REGISTERS);
1000 #ifdef EH_RETURN_STACKADJ_RTX
1001 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1002 #endif
1003 #ifdef JMP_BUF_SIZE
1004 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1005 JMP_BUF_SIZE);
1006 #endif
1007 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1008 STACK_POINTER_REGNUM);
1010 /* For libgcov. */
1011 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1012 TARGET_VTABLE_USES_DESCRIPTORS);
1015 /* For use in assembly language. */
1016 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1017 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1019 /* Misc. */
1020 if (flag_gnu89_inline)
1021 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1022 else
1023 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1025 if (flag_no_inline)
1026 cpp_define (pfile, "__NO_INLINE__");
1028 if (flag_iso)
1029 cpp_define (pfile, "__STRICT_ANSI__");
1031 if (!flag_signed_char)
1032 cpp_define (pfile, "__CHAR_UNSIGNED__");
1034 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1035 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1037 cpp_atomic_builtins (pfile);
1039 #ifdef DWARF2_UNWIND_INFO
1040 if (dwarf2out_do_cfi_asm ())
1041 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1042 #endif
1044 /* Make the choice of ObjC runtime visible to source code. */
1045 if (c_dialect_objc () && flag_next_runtime)
1046 cpp_define (pfile, "__NEXT_RUNTIME__");
1048 /* Show the availability of some target pragmas. */
1049 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1051 /* Make the choice of the stack protector runtime visible to source code.
1052 The macro names and values here were chosen for compatibility with an
1053 earlier implementation, i.e. ProPolice. */
1054 if (flag_stack_protect == 3)
1055 cpp_define (pfile, "__SSP_STRONG__=3");
1056 if (flag_stack_protect == 2)
1057 cpp_define (pfile, "__SSP_ALL__=2");
1058 else if (flag_stack_protect == 1)
1059 cpp_define (pfile, "__SSP__=1");
1061 if (flag_openmp)
1062 cpp_define (pfile, "_OPENMP=201307");
1064 if (int128_integer_type_node != NULL_TREE)
1065 builtin_define_type_sizeof ("__SIZEOF_INT128__",
1066 int128_integer_type_node);
1067 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1068 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1069 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1070 unsigned_ptrdiff_type_node);
1072 /* A straightforward target hook doesn't work, because of problems
1073 linking that hook's body when part of non-C front ends. */
1074 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1075 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1076 # define builtin_define(TXT) cpp_define (pfile, TXT)
1077 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1078 TARGET_CPU_CPP_BUILTINS ();
1079 TARGET_OS_CPP_BUILTINS ();
1080 TARGET_OBJFMT_CPP_BUILTINS ();
1082 /* Support the __declspec keyword by turning them into attributes.
1083 Note that the current way we do this may result in a collision
1084 with predefined attributes later on. This can be solved by using
1085 one attribute, say __declspec__, and passing args to it. The
1086 problem with that approach is that args are not accumulated: each
1087 new appearance would clobber any existing args. */
1088 if (TARGET_DECLSPEC)
1089 builtin_define ("__declspec(x)=__attribute__((x))");
1091 /* If decimal floating point is supported, tell the user if the
1092 alternate format (BID) is used instead of the standard (DPD)
1093 format. */
1094 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1095 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1098 /* Pass an object-like macro. If it doesn't lie in the user's
1099 namespace, defines it unconditionally. Otherwise define a version
1100 with two leading underscores, and another version with two leading
1101 and trailing underscores, and define the original only if an ISO
1102 standard was not nominated.
1104 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1105 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1106 "_mips". */
1107 void
1108 builtin_define_std (const char *macro)
1110 size_t len = strlen (macro);
1111 char *buff = (char *) alloca (len + 5);
1112 char *p = buff + 2;
1113 char *q = p + len;
1115 /* prepend __ (or maybe just _) if in user's namespace. */
1116 memcpy (p, macro, len + 1);
1117 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1119 if (*p != '_')
1120 *--p = '_';
1121 if (p[1] != '_')
1122 *--p = '_';
1124 cpp_define (parse_in, p);
1126 /* If it was in user's namespace... */
1127 if (p != buff + 2)
1129 /* Define the macro with leading and following __. */
1130 if (q[-1] != '_')
1131 *q++ = '_';
1132 if (q[-2] != '_')
1133 *q++ = '_';
1134 *q = '\0';
1135 cpp_define (parse_in, p);
1137 /* Finally, define the original macro if permitted. */
1138 if (!flag_iso)
1139 cpp_define (parse_in, macro);
1143 /* Pass an object-like macro and a value to define it to. The third
1144 parameter says whether or not to turn the value into a string
1145 constant. */
1146 void
1147 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1149 char *buf;
1150 size_t mlen = strlen (macro);
1151 size_t elen = strlen (expansion);
1152 size_t extra = 2; /* space for an = and a NUL */
1154 if (is_str)
1156 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1157 const char *p;
1158 char *q;
1159 extra += 2; /* space for two quote marks */
1160 for (p = expansion, q = quoted_expansion; *p; p++)
1162 switch (*p)
1164 case '\n':
1165 *q++ = '\\';
1166 *q++ = 'n';
1167 break;
1169 case '\t':
1170 *q++ = '\\';
1171 *q++ = 't';
1172 break;
1174 case '\\':
1175 *q++ = '\\';
1176 *q++ = '\\';
1177 break;
1179 case '"':
1180 *q++ = '\\';
1181 *q++ = '"';
1182 break;
1184 default:
1185 if (ISPRINT ((unsigned char) *p))
1186 *q++ = *p;
1187 else
1189 sprintf (q, "\\%03o", (unsigned char) *p);
1190 q += 4;
1194 *q = '\0';
1195 expansion = quoted_expansion;
1196 elen = q - expansion;
1199 buf = (char *) alloca (mlen + elen + extra);
1200 if (is_str)
1201 sprintf (buf, "%s=\"%s\"", macro, expansion);
1202 else
1203 sprintf (buf, "%s=%s", macro, expansion);
1205 cpp_define (parse_in, buf);
1209 /* Pass an object-like macro and an integer value to define it to. */
1210 static void
1211 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1213 char *buf;
1214 size_t mlen = strlen (macro);
1215 size_t vlen = 18;
1216 size_t extra = 2; /* space for = and NUL. */
1218 buf = (char *) alloca (mlen + vlen + extra);
1219 memcpy (buf, macro, mlen);
1220 buf[mlen] = '=';
1221 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1223 cpp_define (parse_in, buf);
1226 /* builtin_define_with_hex_fp_value is very expensive, so the following
1227 array and function allows it to be done lazily when __DBL_MAX__
1228 etc. is first used. */
1230 struct GTY(()) lazy_hex_fp_value_struct
1232 const char *hex_str;
1233 cpp_macro *macro;
1234 enum machine_mode mode;
1235 int digits;
1236 const char *fp_suffix;
1238 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
1239 static GTY(()) int lazy_hex_fp_value_count;
1241 static bool
1242 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1243 cpp_hashnode *node)
1245 REAL_VALUE_TYPE real;
1246 char dec_str[64], buf1[256];
1247 unsigned int idx;
1248 if (node->value.builtin < BT_FIRST_USER
1249 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1250 return false;
1252 idx = node->value.builtin - BT_FIRST_USER;
1253 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1254 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1255 lazy_hex_fp_values[idx].digits, 0,
1256 lazy_hex_fp_values[idx].mode);
1258 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1259 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1260 node->value.macro = lazy_hex_fp_values[idx].macro;
1261 for (idx = 0; idx < node->value.macro->count; idx++)
1262 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1263 break;
1264 gcc_assert (idx < node->value.macro->count);
1265 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1266 node->value.macro->exp.tokens[idx].val.str.text
1267 = (const unsigned char *) ggc_strdup (buf1);
1268 return true;
1271 /* Pass an object-like macro a hexadecimal floating-point value. */
1272 static void
1273 builtin_define_with_hex_fp_value (const char *macro,
1274 tree type, int digits,
1275 const char *hex_str,
1276 const char *fp_suffix,
1277 const char *fp_cast)
1279 REAL_VALUE_TYPE real;
1280 char dec_str[64], buf1[256], buf2[256];
1282 /* This is very expensive, so if possible expand them lazily. */
1283 if (lazy_hex_fp_value_count < 12
1284 && flag_dump_macros == 0
1285 && !cpp_get_options (parse_in)->traditional)
1287 struct cpp_hashnode *node;
1288 if (lazy_hex_fp_value_count == 0)
1289 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1290 sprintf (buf2, fp_cast, "1.1");
1291 sprintf (buf1, "%s=%s", macro, buf2);
1292 cpp_define (parse_in, buf1);
1293 node = C_CPP_HASHNODE (get_identifier (macro));
1294 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1295 = ggc_strdup (hex_str);
1296 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1297 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1298 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1299 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1300 node->flags |= NODE_BUILTIN;
1301 node->value.builtin
1302 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1303 lazy_hex_fp_value_count++;
1304 return;
1307 /* Hex values are really cool and convenient, except that they're
1308 not supported in strict ISO C90 mode. First, the "p-" sequence
1309 is not valid as part of a preprocessor number. Second, we get a
1310 pedwarn from the preprocessor, which has no context, so we can't
1311 suppress the warning with __extension__.
1313 So instead what we do is construct the number in hex (because
1314 it's easy to get the exact correct value), parse it as a real,
1315 then print it back out as decimal. */
1317 real_from_string (&real, hex_str);
1318 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1319 TYPE_MODE (type));
1321 /* Assemble the macro in the following fashion
1322 macro = fp_cast [dec_str fp_suffix] */
1323 sprintf (buf1, "%s%s", dec_str, fp_suffix);
1324 sprintf (buf2, fp_cast, buf1);
1325 sprintf (buf1, "%s=%s", macro, buf2);
1327 cpp_define (parse_in, buf1);
1330 /* Return a string constant for the suffix for a value of type TYPE
1331 promoted according to the integer promotions. The type must be one
1332 of the standard integer type nodes. */
1334 static const char *
1335 type_suffix (tree type)
1337 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1338 int unsigned_suffix;
1339 int is_long;
1341 if (type == long_long_integer_type_node
1342 || type == long_long_unsigned_type_node)
1343 is_long = 2;
1344 else if (type == long_integer_type_node
1345 || type == long_unsigned_type_node)
1346 is_long = 1;
1347 else if (type == integer_type_node
1348 || type == unsigned_type_node
1349 || type == short_integer_type_node
1350 || type == short_unsigned_type_node
1351 || type == signed_char_type_node
1352 || type == unsigned_char_type_node
1353 /* ??? "char" is not a signed or unsigned integer type and
1354 so is not permitted for the standard typedefs, but some
1355 systems use it anyway. */
1356 || type == char_type_node)
1357 is_long = 0;
1358 else
1359 gcc_unreachable ();
1361 unsigned_suffix = TYPE_UNSIGNED (type);
1362 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1363 unsigned_suffix = 0;
1364 return suffixes[is_long * 2 + unsigned_suffix];
1367 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1368 static void
1369 builtin_define_constants (const char *macro, tree type)
1371 const char *suffix;
1372 char *buf;
1374 suffix = type_suffix (type);
1376 if (suffix[0] == 0)
1378 buf = (char *) alloca (strlen (macro) + 6);
1379 sprintf (buf, "%s(c)=c", macro);
1381 else
1383 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1384 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1387 cpp_define (parse_in, buf);
1390 /* Define MAX for TYPE based on the precision of the type. */
1392 static void
1393 builtin_define_type_max (const char *macro, tree type)
1395 builtin_define_type_minmax (NULL, macro, type);
1398 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1399 representation of that value. For example, a COUNT of 10 would
1400 return "0x3ff". */
1402 static void
1403 print_bits_of_hex (char *buf, int bufsz, int count)
1405 gcc_assert (bufsz > 3);
1406 *buf++ = '0';
1407 *buf++ = 'x';
1408 bufsz -= 2;
1410 gcc_assert (count > 0);
1412 switch (count % 4) {
1413 case 0:
1414 break;
1415 case 1:
1416 *buf++ = '1';
1417 bufsz --;
1418 count -= 1;
1419 break;
1420 case 2:
1421 *buf++ = '3';
1422 bufsz --;
1423 count -= 2;
1424 break;
1425 case 3:
1426 *buf++ = '7';
1427 bufsz --;
1428 count -= 3;
1429 break;
1431 while (count >= 4)
1433 gcc_assert (bufsz > 1);
1434 *buf++ = 'f';
1435 bufsz --;
1436 count -= 4;
1438 gcc_assert (bufsz > 0);
1439 *buf++ = 0;
1442 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1443 precision of the type. */
1445 static void
1446 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1447 tree type)
1449 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1450 char value[PBOH_SZ];
1452 const char *suffix;
1453 char *buf;
1454 int bits;
1456 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1458 print_bits_of_hex (value, PBOH_SZ, bits);
1460 suffix = type_suffix (type);
1462 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1463 + strlen (suffix) + 1);
1464 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1466 cpp_define (parse_in, buf);
1468 if (min_macro)
1470 if (TYPE_UNSIGNED (type))
1472 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1473 sprintf (buf, "%s=0%s", min_macro, suffix);
1475 else
1477 buf = (char *) alloca (strlen (min_macro) + 3
1478 + strlen (max_macro) + 6);
1479 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1481 cpp_define (parse_in, buf);
1485 #include "gt-c-family-c-cppbuiltin.h"