2014-07-29 Ed Smith-Rowland <3dw4rd@verizon.net>
[official-gcc.git] / gcc / c-family / c-cppbuiltin.c
blobd07c9809eab3c27b058a1309b006dd1b02d3d888
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)
946 /* For libgcc enable-execute-stack.c. */
947 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
948 TRAMPOLINE_SIZE);
950 /* For use in assembly language. */
951 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
952 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
954 /* Misc. */
955 if (flag_gnu89_inline)
956 cpp_define (pfile, "__GNUC_GNU_INLINE__");
957 else
958 cpp_define (pfile, "__GNUC_STDC_INLINE__");
960 if (flag_no_inline)
961 cpp_define (pfile, "__NO_INLINE__");
963 if (flag_iso)
964 cpp_define (pfile, "__STRICT_ANSI__");
966 if (!flag_signed_char)
967 cpp_define (pfile, "__CHAR_UNSIGNED__");
969 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
970 cpp_define (pfile, "__WCHAR_UNSIGNED__");
972 cpp_atomic_builtins (pfile);
974 #ifdef DWARF2_UNWIND_INFO
975 if (dwarf2out_do_cfi_asm ())
976 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
977 #endif
979 /* Make the choice of ObjC runtime visible to source code. */
980 if (c_dialect_objc () && flag_next_runtime)
981 cpp_define (pfile, "__NEXT_RUNTIME__");
983 /* Show the availability of some target pragmas. */
984 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
986 /* Make the choice of the stack protector runtime visible to source code.
987 The macro names and values here were chosen for compatibility with an
988 earlier implementation, i.e. ProPolice. */
989 if (flag_stack_protect == 3)
990 cpp_define (pfile, "__SSP_STRONG__=3");
991 if (flag_stack_protect == 2)
992 cpp_define (pfile, "__SSP_ALL__=2");
993 else if (flag_stack_protect == 1)
994 cpp_define (pfile, "__SSP__=1");
996 if (flag_openmp)
997 cpp_define (pfile, "_OPENMP=201307");
999 if (int128_integer_type_node != NULL_TREE)
1000 builtin_define_type_sizeof ("__SIZEOF_INT128__",
1001 int128_integer_type_node);
1002 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1003 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1004 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1005 unsigned_ptrdiff_type_node);
1007 /* A straightforward target hook doesn't work, because of problems
1008 linking that hook's body when part of non-C front ends. */
1009 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1010 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1011 # define builtin_define(TXT) cpp_define (pfile, TXT)
1012 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1013 TARGET_CPU_CPP_BUILTINS ();
1014 TARGET_OS_CPP_BUILTINS ();
1015 TARGET_OBJFMT_CPP_BUILTINS ();
1017 /* Support the __declspec keyword by turning them into attributes.
1018 Note that the current way we do this may result in a collision
1019 with predefined attributes later on. This can be solved by using
1020 one attribute, say __declspec__, and passing args to it. The
1021 problem with that approach is that args are not accumulated: each
1022 new appearance would clobber any existing args. */
1023 if (TARGET_DECLSPEC)
1024 builtin_define ("__declspec(x)=__attribute__((x))");
1026 /* If decimal floating point is supported, tell the user if the
1027 alternate format (BID) is used instead of the standard (DPD)
1028 format. */
1029 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1030 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1033 /* Pass an object-like macro. If it doesn't lie in the user's
1034 namespace, defines it unconditionally. Otherwise define a version
1035 with two leading underscores, and another version with two leading
1036 and trailing underscores, and define the original only if an ISO
1037 standard was not nominated.
1039 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1040 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1041 "_mips". */
1042 void
1043 builtin_define_std (const char *macro)
1045 size_t len = strlen (macro);
1046 char *buff = (char *) alloca (len + 5);
1047 char *p = buff + 2;
1048 char *q = p + len;
1050 /* prepend __ (or maybe just _) if in user's namespace. */
1051 memcpy (p, macro, len + 1);
1052 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1054 if (*p != '_')
1055 *--p = '_';
1056 if (p[1] != '_')
1057 *--p = '_';
1059 cpp_define (parse_in, p);
1061 /* If it was in user's namespace... */
1062 if (p != buff + 2)
1064 /* Define the macro with leading and following __. */
1065 if (q[-1] != '_')
1066 *q++ = '_';
1067 if (q[-2] != '_')
1068 *q++ = '_';
1069 *q = '\0';
1070 cpp_define (parse_in, p);
1072 /* Finally, define the original macro if permitted. */
1073 if (!flag_iso)
1074 cpp_define (parse_in, macro);
1078 /* Pass an object-like macro and a value to define it to. The third
1079 parameter says whether or not to turn the value into a string
1080 constant. */
1081 void
1082 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1084 char *buf;
1085 size_t mlen = strlen (macro);
1086 size_t elen = strlen (expansion);
1087 size_t extra = 2; /* space for an = and a NUL */
1089 if (is_str)
1090 extra += 2; /* space for two quote marks */
1092 buf = (char *) alloca (mlen + elen + extra);
1093 if (is_str)
1094 sprintf (buf, "%s=\"%s\"", macro, expansion);
1095 else
1096 sprintf (buf, "%s=%s", macro, expansion);
1098 cpp_define (parse_in, buf);
1102 /* Pass an object-like macro and an integer value to define it to. */
1103 static void
1104 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1106 char *buf;
1107 size_t mlen = strlen (macro);
1108 size_t vlen = 18;
1109 size_t extra = 2; /* space for = and NUL. */
1111 buf = (char *) alloca (mlen + vlen + extra);
1112 memcpy (buf, macro, mlen);
1113 buf[mlen] = '=';
1114 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1116 cpp_define (parse_in, buf);
1119 /* builtin_define_with_hex_fp_value is very expensive, so the following
1120 array and function allows it to be done lazily when __DBL_MAX__
1121 etc. is first used. */
1123 struct GTY(()) lazy_hex_fp_value_struct
1125 const char *hex_str;
1126 cpp_macro *macro;
1127 enum machine_mode mode;
1128 int digits;
1129 const char *fp_suffix;
1131 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
1132 static GTY(()) int lazy_hex_fp_value_count;
1134 static bool
1135 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1136 cpp_hashnode *node)
1138 REAL_VALUE_TYPE real;
1139 char dec_str[64], buf1[256];
1140 unsigned int idx;
1141 if (node->value.builtin < BT_FIRST_USER
1142 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1143 return false;
1145 idx = node->value.builtin - BT_FIRST_USER;
1146 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1147 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1148 lazy_hex_fp_values[idx].digits, 0,
1149 lazy_hex_fp_values[idx].mode);
1151 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1152 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1153 node->value.macro = lazy_hex_fp_values[idx].macro;
1154 for (idx = 0; idx < node->value.macro->count; idx++)
1155 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1156 break;
1157 gcc_assert (idx < node->value.macro->count);
1158 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1159 node->value.macro->exp.tokens[idx].val.str.text
1160 = (const unsigned char *) ggc_strdup (buf1);
1161 return true;
1164 /* Pass an object-like macro a hexadecimal floating-point value. */
1165 static void
1166 builtin_define_with_hex_fp_value (const char *macro,
1167 tree type, int digits,
1168 const char *hex_str,
1169 const char *fp_suffix,
1170 const char *fp_cast)
1172 REAL_VALUE_TYPE real;
1173 char dec_str[64], buf1[256], buf2[256];
1175 /* This is very expensive, so if possible expand them lazily. */
1176 if (lazy_hex_fp_value_count < 12
1177 && flag_dump_macros == 0
1178 && !cpp_get_options (parse_in)->traditional)
1180 struct cpp_hashnode *node;
1181 if (lazy_hex_fp_value_count == 0)
1182 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1183 sprintf (buf2, fp_cast, "1.1");
1184 sprintf (buf1, "%s=%s", macro, buf2);
1185 cpp_define (parse_in, buf1);
1186 node = C_CPP_HASHNODE (get_identifier (macro));
1187 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1188 = ggc_strdup (hex_str);
1189 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1190 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1191 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1192 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1193 node->flags |= NODE_BUILTIN;
1194 node->value.builtin
1195 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1196 lazy_hex_fp_value_count++;
1197 return;
1200 /* Hex values are really cool and convenient, except that they're
1201 not supported in strict ISO C90 mode. First, the "p-" sequence
1202 is not valid as part of a preprocessor number. Second, we get a
1203 pedwarn from the preprocessor, which has no context, so we can't
1204 suppress the warning with __extension__.
1206 So instead what we do is construct the number in hex (because
1207 it's easy to get the exact correct value), parse it as a real,
1208 then print it back out as decimal. */
1210 real_from_string (&real, hex_str);
1211 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1212 TYPE_MODE (type));
1214 /* Assemble the macro in the following fashion
1215 macro = fp_cast [dec_str fp_suffix] */
1216 sprintf (buf1, "%s%s", dec_str, fp_suffix);
1217 sprintf (buf2, fp_cast, buf1);
1218 sprintf (buf1, "%s=%s", macro, buf2);
1220 cpp_define (parse_in, buf1);
1223 /* Return a string constant for the suffix for a value of type TYPE
1224 promoted according to the integer promotions. The type must be one
1225 of the standard integer type nodes. */
1227 static const char *
1228 type_suffix (tree type)
1230 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1231 int unsigned_suffix;
1232 int is_long;
1234 if (type == long_long_integer_type_node
1235 || type == long_long_unsigned_type_node)
1236 is_long = 2;
1237 else if (type == long_integer_type_node
1238 || type == long_unsigned_type_node)
1239 is_long = 1;
1240 else if (type == integer_type_node
1241 || type == unsigned_type_node
1242 || type == short_integer_type_node
1243 || type == short_unsigned_type_node
1244 || type == signed_char_type_node
1245 || type == unsigned_char_type_node
1246 /* ??? "char" is not a signed or unsigned integer type and
1247 so is not permitted for the standard typedefs, but some
1248 systems use it anyway. */
1249 || type == char_type_node)
1250 is_long = 0;
1251 else
1252 gcc_unreachable ();
1254 unsigned_suffix = TYPE_UNSIGNED (type);
1255 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1256 unsigned_suffix = 0;
1257 return suffixes[is_long * 2 + unsigned_suffix];
1260 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1261 static void
1262 builtin_define_constants (const char *macro, tree type)
1264 const char *suffix;
1265 char *buf;
1267 suffix = type_suffix (type);
1269 if (suffix[0] == 0)
1271 buf = (char *) alloca (strlen (macro) + 6);
1272 sprintf (buf, "%s(c)=c", macro);
1274 else
1276 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1277 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1280 cpp_define (parse_in, buf);
1283 /* Define MAX for TYPE based on the precision of the type. */
1285 static void
1286 builtin_define_type_max (const char *macro, tree type)
1288 builtin_define_type_minmax (NULL, macro, type);
1291 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1292 representation of that value. For example, a COUNT of 10 would
1293 return "0x3ff". */
1295 static void
1296 print_bits_of_hex (char *buf, int bufsz, int count)
1298 gcc_assert (bufsz > 3);
1299 *buf++ = '0';
1300 *buf++ = 'x';
1301 bufsz -= 2;
1303 gcc_assert (count > 0);
1305 switch (count % 4) {
1306 case 0:
1307 break;
1308 case 1:
1309 *buf++ = '1';
1310 bufsz --;
1311 count -= 1;
1312 break;
1313 case 2:
1314 *buf++ = '3';
1315 bufsz --;
1316 count -= 2;
1317 break;
1318 case 3:
1319 *buf++ = '7';
1320 bufsz --;
1321 count -= 3;
1322 break;
1324 while (count >= 4)
1326 gcc_assert (bufsz > 1);
1327 *buf++ = 'f';
1328 bufsz --;
1329 count -= 4;
1331 gcc_assert (bufsz > 0);
1332 *buf++ = 0;
1335 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1336 precision of the type. */
1338 static void
1339 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1340 tree type)
1342 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1343 char value[PBOH_SZ];
1345 const char *suffix;
1346 char *buf;
1347 int bits;
1349 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1351 print_bits_of_hex (value, PBOH_SZ, bits);
1353 suffix = type_suffix (type);
1355 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1356 + strlen (suffix) + 1);
1357 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1359 cpp_define (parse_in, buf);
1361 if (min_macro)
1363 if (TYPE_UNSIGNED (type))
1365 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1366 sprintf (buf, "%s=0%s", min_macro, suffix);
1368 else
1370 buf = (char *) alloca (strlen (min_macro) + 3
1371 + strlen (max_macro) + 6);
1372 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1374 cpp_define (parse_in, buf);
1378 #include "gt-c-family-c-cppbuiltin.h"