1/* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2017 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3. If not see
18<http://www.gnu.org/licenses/>. */
19
20#include "config.h"
21#include "system.h"
22#include "coretypes.h"
23#include "target.h"
24#include "c-common.h"
25#include "memmodel.h"
26#include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
27#include "stringpool.h"
28#include "stor-layout.h"
29#include "flags.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 "common/common-target.h"
34#include "cpp-id-data.h"
35#include "cppbuiltin.h"
36
37#ifndef TARGET_OS_CPP_BUILTINS
38# define TARGET_OS_CPP_BUILTINS()
39#endif
40
41#ifndef TARGET_OBJFMT_CPP_BUILTINS
42# define TARGET_OBJFMT_CPP_BUILTINS()
43#endif
44
45#ifndef REGISTER_PREFIX
46#define REGISTER_PREFIX ""
47#endif
48
49/* Non-static as some targets don't use it. */
50static void builtin_define_with_hex_fp_value (const char *, tree,
51 int, const char *,
52 const char *,
53 const char *);
54static void builtin_define_stdint_macros (void);
55static void builtin_define_constants (const char *, tree);
56static void builtin_define_type_max (const char *, tree);
57static void builtin_define_type_minmax (const char *, const char *, tree);
58static void builtin_define_type_width (const char *, tree, tree);
59static void builtin_define_float_constants (const char *,
60 const char *,
61 const char *,
62 const char *,
63 tree);
64
65/* Return true if MODE provides a fast multiply/add (FMA) builtin function.
66 Originally this function used the fma optab, but that doesn't work with
67 -save-temps, so just rely on the HAVE_fma macros for the standard floating
68 point types. */
69
70static bool
71mode_has_fma (machine_mode mode)
72{
73 switch (mode)
74 {
75#ifdef HAVE_fmasf4
76 case E_SFmode:
77 return !!HAVE_fmasf4;
78#endif
79
80#ifdef HAVE_fmadf4
81 case E_DFmode:
82 return !!HAVE_fmadf4;
83#endif
84
85#ifdef HAVE_fmakf4 /* PowerPC if long double != __float128. */
86 case E_KFmode:
87 return !!HAVE_fmakf4;
88#endif
89
90#ifdef HAVE_fmaxf4
91 case E_XFmode:
92 return !!HAVE_fmaxf4;
93#endif
94
95#ifdef HAVE_fmatf4
96 case E_TFmode:
97 return !!HAVE_fmatf4;
98#endif
99
100 default:
101 break;
102 }
103
104 return false;
105}
106
107/* Define NAME with value TYPE size_unit. */
108void
109builtin_define_type_sizeof (const char *name, tree type)
110{
111 builtin_define_with_int_value (name,
112 tree_to_uhwi (TYPE_SIZE_UNIT (type)));
113}
114
115/* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
116 and FP_CAST. */
117static void
118builtin_define_float_constants (const char *name_prefix,
119 const char *fp_suffix,
120 const char *fp_cast,
121 const char *fma_suffix,
122 tree type)
123{
124 /* Used to convert radix-based values to base 10 values in several cases.
125
126 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
127 least 6 significant digits for correct results. Using the fraction
128 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
129 intermediate; perhaps someone can find a better approximation, in the
130 mean time, I suspect using doubles won't harm the bootstrap here. */
131
132 const double log10_2 = .30102999566398119521;
133 double log10_b;
134 const struct real_format *fmt;
135 const struct real_format *widefmt;
136
137 char name[64], buf[128];
138 int dig, min_10_exp, max_10_exp;
139 int decimal_dig;
140 int type_decimal_dig;
141
142 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
143 gcc_assert (fmt->b != 10);
144 widefmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
145 gcc_assert (widefmt->b != 10);
146 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
147 {
148 tree wtype = FLOATN_NX_TYPE_NODE (i);
149 if (wtype != NULL_TREE)
150 {
151 const struct real_format *wfmt
152 = REAL_MODE_FORMAT (TYPE_MODE (wtype));
153 gcc_assert (wfmt->b != 10);
154 if (wfmt->p > widefmt->p)
155 widefmt = wfmt;
156 }
157 }
158
159 /* The radix of the exponent representation. */
160 if (type == float_type_node)
161 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
162 log10_b = log10_2;
163
164 /* The number of radix digits, p, in the floating-point significand. */
165 sprintf (name, "__%s_MANT_DIG__", name_prefix);
166 builtin_define_with_int_value (name, fmt->p);
167
168 /* The number of decimal digits, q, such that any floating-point number
169 with q decimal digits can be rounded into a floating-point number with
170 p radix b digits and back again without change to the q decimal digits,
171
172 p log10 b if b is a power of 10
173 floor((p - 1) log10 b) otherwise
174 */
175 dig = (fmt->p - 1) * log10_b;
176 sprintf (name, "__%s_DIG__", name_prefix);
177 builtin_define_with_int_value (name, dig);
178
179 /* The minimum negative int x such that b**(x-1) is a normalized float. */
180 sprintf (name, "__%s_MIN_EXP__", name_prefix);
181 sprintf (buf, "(%d)", fmt->emin);
182 builtin_define_with_value (name, buf, 0);
183
184 /* The minimum negative int x such that 10**x is a normalized float,
185
186 ceil (log10 (b ** (emin - 1)))
187 = ceil (log10 (b) * (emin - 1))
188
189 Recall that emin is negative, so the integer truncation calculates
190 the ceiling, not the floor, in this case. */
191 min_10_exp = (fmt->emin - 1) * log10_b;
192 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
193 sprintf (buf, "(%d)", min_10_exp);
194 builtin_define_with_value (name, buf, 0);
195
196 /* The maximum int x such that b**(x-1) is a representable float. */
197 sprintf (name, "__%s_MAX_EXP__", name_prefix);
198 builtin_define_with_int_value (name, fmt->emax);
199
200 /* The maximum int x such that 10**x is in the range of representable
201 finite floating-point numbers,
202
203 floor (log10((1 - b**-p) * b**emax))
204 = floor (log10(1 - b**-p) + log10(b**emax))
205 = floor (log10(1 - b**-p) + log10(b)*emax)
206
207 The safest thing to do here is to just compute this number. But since
208 we don't link cc1 with libm, we cannot. We could implement log10 here
209 a series expansion, but that seems too much effort because:
210
211 Note that the first term, for all extant p, is a number exceedingly close
212 to zero, but slightly negative. Note that the second term is an integer
213 scaling an irrational number, and that because of the floor we are only
214 interested in its integral portion.
215
216 In order for the first term to have any effect on the integral portion
217 of the second term, the second term has to be exceedingly close to an
218 integer itself (e.g. 123.000000000001 or something). Getting a result
219 that close to an integer requires that the irrational multiplicand have
220 a long series of zeros in its expansion, which doesn't occur in the
221 first 20 digits or so of log10(b).
222
223 Hand-waving aside, crunching all of the sets of constants above by hand
224 does not yield a case for which the first term is significant, which
225 in the end is all that matters. */
226 max_10_exp = fmt->emax * log10_b;
227 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
228 builtin_define_with_int_value (name, max_10_exp);
229
230 /* The number of decimal digits, n, such that any floating-point number
231 can be rounded to n decimal digits and back again without change to
232 the value.
233
234 p * log10(b) if b is a power of 10
235 ceil(1 + p * log10(b)) otherwise
236
237 The only macro we care about is this number for the widest supported
238 floating type, but we want this value for rendering constants below. */
239 {
240 double d_decimal_dig
241 = 1 + (fmt->p < widefmt->p ? widefmt->p : fmt->p) * log10_b;
242 decimal_dig = d_decimal_dig;
243 if (decimal_dig < d_decimal_dig)
244 decimal_dig++;
245 }
246 /* Similar, for this type rather than long double. */
247 {
248 double type_d_decimal_dig = 1 + fmt->p * log10_b;
249 type_decimal_dig = type_d_decimal_dig;
250 if (type_decimal_dig < type_d_decimal_dig)
251 type_decimal_dig++;
252 }
253 /* Define __DECIMAL_DIG__ to the value for long double to be
254 compatible with C99 and C11; see DR#501 and N2108. */
255 if (type == long_double_type_node)
256 builtin_define_with_int_value ("__DECIMAL_DIG__", type_decimal_dig);
257 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
258 builtin_define_with_int_value (name, type_decimal_dig);
259
260 /* Since, for the supported formats, B is always a power of 2, we
261 construct the following numbers directly as a hexadecimal
262 constants. */
263 get_max_float (fmt, buf, sizeof (buf));
264
265 sprintf (name, "__%s_MAX__", name_prefix);
266 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
267
268 /* The minimum normalized positive floating-point number,
269 b**(emin-1). */
270 sprintf (name, "__%s_MIN__", name_prefix);
271 sprintf (buf, "0x1p%d", fmt->emin - 1);
272 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
273
274 /* The difference between 1 and the least value greater than 1 that is
275 representable in the given floating point type, b**(1-p). */
276 sprintf (name, "__%s_EPSILON__", name_prefix);
277 if (fmt->pnan < fmt->p)
278 /* This is an IBM extended double format, so 1.0 + any double is
279 representable precisely. */
280 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
281 else
282 sprintf (buf, "0x1p%d", 1 - fmt->p);
283 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
284
285 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
286 The minimum denormalized positive floating-point number, b**(emin-p).
287 The minimum normalized positive floating-point number for formats
288 that don't support denormals. */
289 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
290 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
291 builtin_define_with_hex_fp_value (name, type, decimal_dig,
292 buf, fp_suffix, fp_cast);
293
294 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
295 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
296
297 /* For C++ std::numeric_limits<T>::has_infinity. */
298 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
299 builtin_define_with_int_value (name,
300 MODE_HAS_INFINITIES (TYPE_MODE (type)));
301 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
302 predicate to distinguish a target that has both quiet and
303 signalling NaNs from a target that has only quiet NaNs or only
304 signalling NaNs, so we assume that a target that has any kind of
305 NaN has quiet NaNs. */
306 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
307 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
308
309 /* Note whether we have fast FMA. */
310 if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
311 {
312 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
313 builtin_define_with_int_value (name, 1);
314 }
315}
316
317/* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
318static void
319builtin_define_decimal_float_constants (const char *name_prefix,
320 const char *suffix,
321 tree type)
322{
323 const struct real_format *fmt;
324 char name[64], buf[128], *p;
325 int digits;
326
327 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
328
329 /* The number of radix digits, p, in the significand. */
330 sprintf (name, "__%s_MANT_DIG__", name_prefix);
331 builtin_define_with_int_value (name, fmt->p);
332
333 /* The minimum negative int x such that b**(x-1) is a normalized float. */
334 sprintf (name, "__%s_MIN_EXP__", name_prefix);
335 sprintf (buf, "(%d)", fmt->emin);
336 builtin_define_with_value (name, buf, 0);
337
338 /* The maximum int x such that b**(x-1) is a representable float. */
339 sprintf (name, "__%s_MAX_EXP__", name_prefix);
340 builtin_define_with_int_value (name, fmt->emax);
341
342 /* Compute the minimum representable value. */
343 sprintf (name, "__%s_MIN__", name_prefix);
344 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
345 builtin_define_with_value (name, buf, 0);
346
347 /* Compute the maximum representable value. */
348 sprintf (name, "__%s_MAX__", name_prefix);
349 p = buf;
350 for (digits = fmt->p; digits; digits--)
351 {
352 *p++ = '9';
353 if (digits == fmt->p)
354 *p++ = '.';
355 }
356 *p = 0;
357 /* fmt->p plus 1, to account for the decimal point and fmt->emax
358 minus 1 because the digits are nines, not 1.0. */
359 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
360 builtin_define_with_value (name, buf, 0);
361
362 /* Compute epsilon (the difference between 1 and least value greater
363 than 1 representable). */
364 sprintf (name, "__%s_EPSILON__", name_prefix);
365 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
366 builtin_define_with_value (name, buf, 0);
367
368 /* Minimum subnormal positive decimal value. */
369 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
370 p = buf;
371 for (digits = fmt->p; digits > 1; digits--)
372 {
373 *p++ = '0';
374 if (digits == fmt->p)
375 *p++ = '.';
376 }
377 *p = 0;
378 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
379 builtin_define_with_value (name, buf, 0);
380}
381
382/* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
383
384static void
385builtin_define_fixed_point_constants (const char *name_prefix,
386 const char *suffix,
387 tree type)
388{
389 char name[64], buf[256], *new_buf;
390 int i, mod;
391
392 sprintf (name, "__%s_FBIT__", name_prefix);
393 builtin_define_with_int_value (name, TYPE_FBIT (type));
394
395 sprintf (name, "__%s_IBIT__", name_prefix);
396 builtin_define_with_int_value (name, TYPE_IBIT (type));
397
398 /* If there is no suffix, defines are for fixed-point modes.
399 We just return. */
400 if (strcmp (suffix, "") == 0)
401 return;
402
403 if (TYPE_UNSIGNED (type))
404 {
405 sprintf (name, "__%s_MIN__", name_prefix);
406 sprintf (buf, "0.0%s", suffix);
407 builtin_define_with_value (name, buf, 0);
408 }
409 else
410 {
411 sprintf (name, "__%s_MIN__", name_prefix);
412 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
413 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
414 TYPE_IBIT (type) - 1, suffix);
415 else
416 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
417 builtin_define_with_value (name, buf, 0);
418 }
419
420 sprintf (name, "__%s_MAX__", name_prefix);
421 sprintf (buf, "0X");
422 new_buf = buf + 2;
423 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
424 if (mod)
425 sprintf (new_buf++, "%x", (1 << mod) - 1);
426 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
427 sprintf (new_buf++, "F");
428 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
429 builtin_define_with_value (name, buf, 0);
430
431 sprintf (name, "__%s_EPSILON__", name_prefix);
432 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
433 builtin_define_with_value (name, buf, 0);
434}
435
436/* Define macros used by <stdint.h>. */
437static void
438builtin_define_stdint_macros (void)
439{
440 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
441 builtin_define_constants ("__INTMAX_C", intmax_type_node);
442 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
443 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
444 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node,
445 uintmax_type_node);
446 if (sig_atomic_type_node)
447 {
448 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
449 sig_atomic_type_node);
450 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node,
451 NULL_TREE);
452 }
453 if (int8_type_node)
454 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
455 if (int16_type_node)
456 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
457 if (int32_type_node)
458 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
459 if (int64_type_node)
460 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
461 if (uint8_type_node)
462 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
463 if (c_uint16_type_node)
464 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
465 if (c_uint32_type_node)
466 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
467 if (c_uint64_type_node)
468 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
469 if (int_least8_type_node)
470 {
471 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
472 builtin_define_constants ("__INT8_C", int_least8_type_node);
473 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node,
474 uint_least8_type_node);
475 }
476 if (int_least16_type_node)
477 {
478 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
479 builtin_define_constants ("__INT16_C", int_least16_type_node);
480 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
481 int_least16_type_node,
482 uint_least16_type_node);
483 }
484 if (int_least32_type_node)
485 {
486 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
487 builtin_define_constants ("__INT32_C", int_least32_type_node);
488 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
489 int_least32_type_node,
490 uint_least32_type_node);
491 }
492 if (int_least64_type_node)
493 {
494 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
495 builtin_define_constants ("__INT64_C", int_least64_type_node);
496 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
497 int_least64_type_node,
498 uint_least64_type_node);
499 }
500 if (uint_least8_type_node)
501 {
502 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
503 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
504 }
505 if (uint_least16_type_node)
506 {
507 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
508 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
509 }
510 if (uint_least32_type_node)
511 {
512 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
513 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
514 }
515 if (uint_least64_type_node)
516 {
517 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
518 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
519 }
520 if (int_fast8_type_node)
521 {
522 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
523 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node,
524 uint_fast8_type_node);
525 }
526 if (int_fast16_type_node)
527 {
528 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
529 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node,
530 uint_fast16_type_node);
531 }
532 if (int_fast32_type_node)
533 {
534 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
535 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node,
536 uint_fast32_type_node);
537 }
538 if (int_fast64_type_node)
539 {
540 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
541 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node,
542 uint_fast64_type_node);
543 }
544 if (uint_fast8_type_node)
545 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
546 if (uint_fast16_type_node)
547 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
548 if (uint_fast32_type_node)
549 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
550 if (uint_fast64_type_node)
551 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
552 if (intptr_type_node)
553 {
554 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
555 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node,
556 uintptr_type_node);
557 }
558 if (uintptr_type_node)
559 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
560}
561
562/* Adjust the optimization macros when a #pragma GCC optimization is done to
563 reflect the current level. */
564void
565c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
566 tree cur_tree)
567{
568 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
569 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
570 bool prev_fast_math;
571 bool cur_fast_math;
572
573 /* -undef turns off target-specific built-ins. */
574 if (flag_undef)
575 return;
576
577 /* Other target-independent built-ins determined by command-line
578 options. */
579 if (!prev->x_optimize_size && cur->x_optimize_size)
580 cpp_define (pfile, "__OPTIMIZE_SIZE__");
581 else if (prev->x_optimize_size && !cur->x_optimize_size)
582 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
583
584 if (!prev->x_optimize && cur->x_optimize)
585 cpp_define (pfile, "__OPTIMIZE__");
586 else if (prev->x_optimize && !cur->x_optimize)
587 cpp_undef (pfile, "__OPTIMIZE__");
588
589 prev_fast_math = fast_math_flags_struct_set_p (prev);
590 cur_fast_math = fast_math_flags_struct_set_p (cur);
591 if (!prev_fast_math && cur_fast_math)
592 cpp_define (pfile, "__FAST_MATH__");
593 else if (prev_fast_math && !cur_fast_math)
594 cpp_undef (pfile, "__FAST_MATH__");
595
596 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
597 cpp_define (pfile, "__SUPPORT_SNAN__");
598 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
599 cpp_undef (pfile, "__SUPPORT_SNAN__");
600
601 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
602 cpp_undef (pfile, "__NO_MATH_ERRNO__");
603 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
604 cpp_define (pfile, "__NO_MATH_ERRNO__");
605
606 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
607 {
608 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
609 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
610 }
611 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
612 {
613 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
614 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
615 }
616}
617
618
619/* This function will emit cpp macros to indicate the presence of various lock
620 free atomic operations. */
621
622static void
623cpp_atomic_builtins (cpp_reader *pfile)
624{
625 /* Set a flag for each size of object that compare and swap exists for up to
626 a 16 byte object. */
627#define SWAP_LIMIT 17
628 bool have_swap[SWAP_LIMIT];
629 unsigned int psize;
630
631 /* Clear the map of sizes compare_and swap exists for. */
632 memset (have_swap, 0, sizeof (have_swap));
633
634 /* Tell source code if the compiler makes sync_compare_and_swap
635 builtins available. */
636#ifndef HAVE_sync_compare_and_swapqi
637#define HAVE_sync_compare_and_swapqi 0
638#endif
639#ifndef HAVE_atomic_compare_and_swapqi
640#define HAVE_atomic_compare_and_swapqi 0
641#endif
642
643 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
644 {
645 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
646 have_swap[1] = true;
647 }
648
649#ifndef HAVE_sync_compare_and_swaphi
650#define HAVE_sync_compare_and_swaphi 0
651#endif
652#ifndef HAVE_atomic_compare_and_swaphi
653#define HAVE_atomic_compare_and_swaphi 0
654#endif
655 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
656 {
657 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
658 have_swap[2] = true;
659 }
660
661#ifndef HAVE_sync_compare_and_swapsi
662#define HAVE_sync_compare_and_swapsi 0
663#endif
664#ifndef HAVE_atomic_compare_and_swapsi
665#define HAVE_atomic_compare_and_swapsi 0
666#endif
667 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
668 {
669 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
670 have_swap[4] = true;
671 }
672
673#ifndef HAVE_sync_compare_and_swapdi
674#define HAVE_sync_compare_and_swapdi 0
675#endif
676#ifndef HAVE_atomic_compare_and_swapdi
677#define HAVE_atomic_compare_and_swapdi 0
678#endif
679 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
680 {
681 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
682 have_swap[8] = true;
683 }
684
685#ifndef HAVE_sync_compare_and_swapti
686#define HAVE_sync_compare_and_swapti 0
687#endif
688#ifndef HAVE_atomic_compare_and_swapti
689#define HAVE_atomic_compare_and_swapti 0
690#endif
691 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
692 {
693 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
694 have_swap[16] = true;
695 }
696
697 /* Tell the source code about various types. These map to the C++11 and C11
698 macros where 2 indicates lock-free always, and 1 indicates sometimes
699 lock free. */
700#define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
701#define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
702 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
703 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
704 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
705 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
706 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
707 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
708 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
709 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
710 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
711 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
712 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
713 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
714 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
715 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
716 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
717 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
718 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
719 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
720
721 /* If we're dealing with a "set" value that doesn't exactly correspond
722 to a boolean truth value, let the library work around that. */
723 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
724 targetm.atomic_test_and_set_trueval);
725
726 /* ptr_type_node can't be used here since ptr_mode is only set when
727 toplev calls backend_init which is not done with -E or pch. */
728 psize = POINTER_SIZE_UNITS;
729 if (psize >= SWAP_LIMIT)
730 psize = 0;
731 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
732 (have_swap[psize]? 2 : 1));
733}
734
735/* Return TRUE if the implicit excess precision in which the back-end will
736 compute floating-point calculations is not more than the explicit
737 excess precision that the front-end will apply under
738 -fexcess-precision=[standard|fast].
739
740 More intuitively, return TRUE if the excess precision proposed by the
741 front-end is the excess precision that will actually be used. */
742
743static bool
744c_cpp_flt_eval_method_iec_559 (void)
745{
746 enum excess_precision_type front_end_ept
747 = (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
748 ? EXCESS_PRECISION_TYPE_STANDARD
749 : EXCESS_PRECISION_TYPE_FAST);
750
751 enum flt_eval_method back_end
752 = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
753
754 enum flt_eval_method front_end
755 = targetm.c.excess_precision (front_end_ept);
756
757 return excess_precision_mode_join (front_end, back_end) == front_end;
758}
759
760/* Return the value for __GCC_IEC_559. */
761static int
762cpp_iec_559_value (void)
763{
764 /* The default is support for IEEE 754-2008. */
765 int ret = 2;
766
767 /* float and double must be binary32 and binary64. If they are but
768 with reversed NaN convention, at most IEEE 754-1985 is
769 supported. */
770 const struct real_format *ffmt
771 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
772 const struct real_format *dfmt
773 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
774 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
775 ret = 1;
776 if (ffmt->b != 2
777 || ffmt->p != 24
778 || ffmt->pnan != 24
779 || ffmt->emin != -125
780 || ffmt->emax != 128
781 || ffmt->signbit_rw != 31
782 || ffmt->round_towards_zero
783 || !ffmt->has_sign_dependent_rounding
784 || !ffmt->has_nans
785 || !ffmt->has_inf
786 || !ffmt->has_denorm
787 || !ffmt->has_signed_zero
788 || dfmt->b != 2
789 || dfmt->p != 53
790 || dfmt->pnan != 53
791 || dfmt->emin != -1021
792 || dfmt->emax != 1024
793 || dfmt->signbit_rw != 63
794 || dfmt->round_towards_zero
795 || !dfmt->has_sign_dependent_rounding
796 || !dfmt->has_nans
797 || !dfmt->has_inf
798 || !dfmt->has_denorm
799 || !dfmt->has_signed_zero)
800 ret = 0;
801
802 /* In strict C standards conformance mode, consider a back-end providing
803 more implicit excess precision than the explicit excess precision
804 the front-end options would require to mean a lack of IEEE 754
805 support. For C++, and outside strict conformance mode, do not consider
806 this to mean a lack of IEEE 754 support. */
807
808 if (flag_iso
809 && !c_dialect_cxx ()
810 && !c_cpp_flt_eval_method_iec_559 ())
811 ret = 0;
812
813 if (flag_iso
814 && !c_dialect_cxx ()
815 && flag_fp_contract_mode == FP_CONTRACT_FAST)
816 ret = 0;
817
818 /* Various options are contrary to IEEE 754 semantics. */
819 if (flag_unsafe_math_optimizations
820 || flag_associative_math
821 || flag_reciprocal_math
822 || flag_finite_math_only
823 || !flag_signed_zeros
824 || flag_single_precision_constant)
825 ret = 0;
826
827 /* If the target does not support IEEE 754 exceptions and rounding
828 modes, consider IEEE 754 support to be absent. */
829 if (!targetm.float_exceptions_rounding_supported_p ())
830 ret = 0;
831
832 return ret;
833}
834
835/* Return the value for __GCC_IEC_559_COMPLEX. */
836static int
837cpp_iec_559_complex_value (void)
838{
839 /* The value is no bigger than that of __GCC_IEC_559. */
840 int ret = cpp_iec_559_value ();
841
842 /* Some options are contrary to the required default state of the
843 CX_LIMITED_RANGE pragma. */
844 if (flag_complex_method != 2)
845 ret = 0;
846
847 return ret;
848}
849
850/* Hook that registers front end and target-specific built-ins. */
851void
852c_cpp_builtins (cpp_reader *pfile)
853{
854 int i;
855
856 /* -undef turns off target-specific built-ins. */
857 if (flag_undef)
858 return;
859
860 define_language_independent_builtin_macros (pfile);
861
862 if (c_dialect_cxx ())
863 {
864 int major;
865 parse_basever (&major, NULL, NULL);
866 cpp_define_formatted (pfile, "__GNUG__=%d", major);
867 }
868
869 /* For stddef.h. They require macros defined in c-common.c. */
870 c_stddef_cpp_builtins ();
871
872 /* Set include test macros for all C/C++ (not for just C++11 etc.)
873 The builtins __has_include__ and __has_include_next__ are defined
874 in libcpp. */
875 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
876 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
877
878 if (c_dialect_cxx ())
879 {
880 if (flag_weak && SUPPORTS_ONE_ONLY)
881 cpp_define (pfile, "__GXX_WEAK__=1");
882 else
883 cpp_define (pfile, "__GXX_WEAK__=0");
884
885 if (warn_deprecated)
886 cpp_define (pfile, "__DEPRECATED");
887
888 if (flag_rtti)
889 {
890 cpp_define (pfile, "__GXX_RTTI");
891 cpp_define (pfile, "__cpp_rtti=199711");
892 }
893
894 if (cxx_dialect >= cxx11)
895 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
896
897 /* Binary literals have been allowed in g++ before C++11
898 and were standardized for C++14. */
899 if (!pedantic || cxx_dialect > cxx11)
900 cpp_define (pfile, "__cpp_binary_literals=201304");
901
902 /* Similarly for hexadecimal floating point literals and C++17. */
903 if (!pedantic || cpp_get_options (parse_in)->extended_numbers)
904 cpp_define (pfile, "__cpp_hex_float=201603");
905
906 /* Arrays of runtime bound were removed from C++14, but we still
907 support GNU VLAs. Let's define this macro to a low number
908 (corresponding to the initial test release of GNU C++) if we won't
909 complain about use of VLAs. */
910 if (c_dialect_cxx ()
911 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
912 cpp_define (pfile, "__cpp_runtime_arrays=198712");
913
914 if (cxx_dialect >= cxx11)
915 {
916 /* Set feature test macros for C++11. */
917 if (cxx_dialect <= cxx14)
918 cpp_define (pfile, "__cpp_unicode_characters=200704");
919 cpp_define (pfile, "__cpp_raw_strings=200710");
920 cpp_define (pfile, "__cpp_unicode_literals=200710");
921 cpp_define (pfile, "__cpp_user_defined_literals=200809");
922 cpp_define (pfile, "__cpp_lambdas=200907");
923 if (cxx_dialect == cxx11)
924 cpp_define (pfile, "__cpp_constexpr=200704");
925 if (cxx_dialect <= cxx14)
926 cpp_define (pfile, "__cpp_range_based_for=200907");
927 if (cxx_dialect <= cxx14)
928 cpp_define (pfile, "__cpp_static_assert=200410");
929 cpp_define (pfile, "__cpp_decltype=200707");
930 cpp_define (pfile, "__cpp_attributes=200809");
931 cpp_define (pfile, "__cpp_rvalue_reference=200610");
932 cpp_define (pfile, "__cpp_rvalue_references=200610");
933 cpp_define (pfile, "__cpp_variadic_templates=200704");
934 cpp_define (pfile, "__cpp_initializer_lists=200806");
935 cpp_define (pfile, "__cpp_delegating_constructors=200604");
936 cpp_define (pfile, "__cpp_nsdmi=200809");
937 if (!flag_new_inheriting_ctors)
938 cpp_define (pfile, "__cpp_inheriting_constructors=200802");
939 else
940 cpp_define (pfile, "__cpp_inheriting_constructors=201511");
941 cpp_define (pfile, "__cpp_ref_qualifiers=200710");
942 cpp_define (pfile, "__cpp_alias_templates=200704");
943 }
944 if (cxx_dialect > cxx11)
945 {
946 /* Set feature test macros for C++14. */
947 cpp_define (pfile, "__cpp_return_type_deduction=201304");
948 cpp_define (pfile, "__cpp_init_captures=201304");
949 cpp_define (pfile, "__cpp_generic_lambdas=201304");
950 if (cxx_dialect <= cxx14)
951 cpp_define (pfile, "__cpp_constexpr=201304");
952 cpp_define (pfile, "__cpp_decltype_auto=201304");
953 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
954 cpp_define (pfile, "__cpp_variable_templates=201304");
955 cpp_define (pfile, "__cpp_digit_separators=201309");
956 }
957 if (cxx_dialect > cxx14)
958 {
959 /* Set feature test macros for C++1z. */
960 cpp_define (pfile, "__cpp_unicode_characters=201411");
961 cpp_define (pfile, "__cpp_static_assert=201411");
962 cpp_define (pfile, "__cpp_namespace_attributes=201411");
963 cpp_define (pfile, "__cpp_enumerator_attributes=201411");
964 cpp_define (pfile, "__cpp_nested_namespace_definitions=201411");
965 cpp_define (pfile, "__cpp_fold_expressions=201603");
966 cpp_define (pfile, "__cpp_nontype_template_args=201411");
967 cpp_define (pfile, "__cpp_range_based_for=201603");
968 cpp_define (pfile, "__cpp_constexpr=201603");
969 cpp_define (pfile, "__cpp_if_constexpr=201606");
970 cpp_define (pfile, "__cpp_capture_star_this=201603");
971 cpp_define (pfile, "__cpp_inline_variables=201606");
972 cpp_define (pfile, "__cpp_aggregate_bases=201603");
973 cpp_define (pfile, "__cpp_deduction_guides=201606");
974 cpp_define (pfile, "__cpp_noexcept_function_type=201510");
975 cpp_define (pfile, "__cpp_template_auto=201606");
976 cpp_define (pfile, "__cpp_structured_bindings=201606");
977 cpp_define (pfile, "__cpp_variadic_using=201611");
978 }
979 if (flag_concepts)
980 cpp_define (pfile, "__cpp_concepts=201507");
981 if (flag_tm)
982 /* Use a value smaller than the 201505 specified in
983 the TS, since we don't yet support atomic_cancel. */
984 cpp_define (pfile, "__cpp_transactional_memory=210500");
985 if (flag_sized_deallocation)
986 cpp_define (pfile, "__cpp_sized_deallocation=201309");
987 if (aligned_new_threshold)
988 {
989 cpp_define (pfile, "__cpp_aligned_new=201606");
990 cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
991 aligned_new_threshold);
992 }
993 if (flag_new_ttp)
994 cpp_define (pfile, "__cpp_template_template_args=201611");
995 if (flag_threadsafe_statics)
996 cpp_define (pfile, "__cpp_threadsafe_static_init=200806");
997 }
998 /* Note that we define this for C as well, so that we know if
999 __attribute__((cleanup)) will interface with EH. */
1000 if (flag_exceptions)
1001 {
1002 cpp_define (pfile, "__EXCEPTIONS");
1003 if (c_dialect_cxx ())
1004 cpp_define (pfile, "__cpp_exceptions=199711");
1005 }
1006
1007 /* Represents the C++ ABI version, always defined so it can be used while
1008 preprocessing C and assembler. */
1009 if (flag_abi_version == 0)
1010 /* We should have set this to something real in c_common_post_options. */
1011 gcc_unreachable ();
1012 else if (flag_abi_version == 1)
1013 /* Due to a historical accident, this version had the value
1014 "102". */
1015 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1016 else
1017 /* Newer versions have values 1002, 1003, .... */
1018 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1019 1000 + flag_abi_version);
1020
1021 /* libgcc needs to know this. */
1022 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1023 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
1024
1025 /* limits.h and stdint.h need to know these. */
1026 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
1027 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
1028 builtin_define_type_max ("__INT_MAX__", integer_type_node);
1029 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
1030 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
1031 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1032 underlying_wchar_type_node);
1033 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
1034 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
1035 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
1036
1037 /* These are needed for TS 18661-1. */
1038 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
1039 unsigned_char_type_node);
1040 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
1041 short_unsigned_type_node);
1042 builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
1043 unsigned_type_node);
1044 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
1045 long_unsigned_type_node);
1046 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1047 long_long_integer_type_node,
1048 long_long_unsigned_type_node);
1049 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
1050 NULL_TREE);
1051 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
1052 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
1053 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
1054
1055 if (c_dialect_cxx ())
1056 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1057 if (int_n_enabled_p[i])
1058 {
1059 char buf[35+20+20];
1060
1061 /* These are used to configure the C++ library. */
1062
1063 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
1064 {
1065 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
1066 cpp_define (parse_in, buf);
1067
1068 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
1069 cpp_define (parse_in, buf);
1070 }
1071 }
1072
1073 /* stdint.h and the testsuite need to know these. */
1074 builtin_define_stdint_macros ();
1075
1076 /* Provide information for library headers to determine whether to
1077 define macros such as __STDC_IEC_559__ and
1078 __STDC_IEC_559_COMPLEX__. */
1079 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1080 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1081 cpp_iec_559_complex_value ());
1082
1083 /* float.h needs these to correctly set FLT_EVAL_METHOD
1084
1085 We define two values:
1086
1087 __FLT_EVAL_METHOD__
1088 Which, depending on the value given for
1089 -fpermitted-flt-eval-methods, may be limited to only those values
1090 for FLT_EVAL_METHOD defined in C99/C11.
1091
1092 __FLT_EVAL_METHOD_TS_18661_3__
1093 Which always permits the values for FLT_EVAL_METHOD defined in
1094 ISO/IEC TS 18661-3. */
1095 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1096 c_flt_eval_method (true));
1097 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1098 c_flt_eval_method (false));
1099
1100 /* And decfloat.h needs this. */
1101 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1102 TARGET_DEC_EVAL_METHOD);
1103
1104 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
1105 /* Cast the double precision constants. This is needed when single
1106 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1107 is used. The correct result is computed by the compiler when using
1108 macros that include a cast. We use a different cast for C++ to avoid
1109 problems with -Wold-style-cast. */
1110 builtin_define_float_constants ("DBL", "L",
1111 (c_dialect_cxx ()
1112 ? "double(%s)"
1113 : "((double)%s)"),
1114 "", double_type_node);
1115 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1116 long_double_type_node);
1117
1118 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1119 {
1120 if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
1121 continue;
1122 char prefix[20], csuffix[20];
1123 sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
1124 floatn_nx_types[i].extended ? "X" : "");
1125 sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
1126 floatn_nx_types[i].extended ? "x" : "");
1127 builtin_define_float_constants (prefix, csuffix, "%s", csuffix,
1128 FLOATN_NX_TYPE_NODE (i));
1129 }
1130
1131 /* For decfloat.h. */
1132 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
1133 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
1134 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
1135
1136 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1137 if (targetm.fixed_point_supported_p ())
1138 {
1139 builtin_define_fixed_point_constants ("SFRACT", "HR",
1140 short_fract_type_node);
1141 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1142 unsigned_short_fract_type_node);
1143 builtin_define_fixed_point_constants ("FRACT", "R",
1144 fract_type_node);
1145 builtin_define_fixed_point_constants ("UFRACT", "UR",
1146 unsigned_fract_type_node);
1147 builtin_define_fixed_point_constants ("LFRACT", "LR",
1148 long_fract_type_node);
1149 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1150 unsigned_long_fract_type_node);
1151 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1152 long_long_fract_type_node);
1153 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1154 unsigned_long_long_fract_type_node);
1155 builtin_define_fixed_point_constants ("SACCUM", "HK",
1156 short_accum_type_node);
1157 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1158 unsigned_short_accum_type_node);
1159 builtin_define_fixed_point_constants ("ACCUM", "K",
1160 accum_type_node);
1161 builtin_define_fixed_point_constants ("UACCUM", "UK",
1162 unsigned_accum_type_node);
1163 builtin_define_fixed_point_constants ("LACCUM", "LK",
1164 long_accum_type_node);
1165 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1166 unsigned_long_accum_type_node);
1167 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1168 long_long_accum_type_node);
1169 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1170 unsigned_long_long_accum_type_node);
1171
1172 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
1173 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
1174 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
1175 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
1176 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
1177 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
1178 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
1179 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
1180 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
1181 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
1182 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
1183 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
1184 builtin_define_fixed_point_constants ("DA", "", da_type_node);
1185 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
1186 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
1187 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
1188 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
1189 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
1190 }
1191
1192 /* For libgcc-internal use only. */
1193 if (flag_building_libgcc)
1194 {
1195 /* Properties of floating-point modes for libgcc2.c. */
1196 opt_scalar_float_mode mode_iter;
1197 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
1198 {
1199 scalar_float_mode mode = mode_iter.require ();
1200 const char *name = GET_MODE_NAME (mode);
1201 char *macro_name
1202 = (char *) alloca (strlen (name)
1203 + sizeof ("__LIBGCC__MANT_DIG__"));
1204 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
1205 builtin_define_with_int_value (macro_name,
1206 REAL_MODE_FORMAT (mode)->p);
1207 if (!targetm.scalar_mode_supported_p (mode)
1208 || !targetm.libgcc_floating_mode_supported_p (mode))
1209 continue;
1210 macro_name = (char *) alloca (strlen (name)
1211 + sizeof ("__LIBGCC_HAS__MODE__"));
1212 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
1213 cpp_define (pfile, macro_name);
1214 macro_name = (char *) alloca (strlen (name)
1215 + sizeof ("__LIBGCC__FUNC_EXT__"));
1216 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
1217 char suffix[20] = "";
1218 if (mode == TYPE_MODE (double_type_node))
1219 ; /* Empty suffix correct. */
1220 else if (mode == TYPE_MODE (float_type_node))
1221 suffix[0] = 'f';
1222 else if (mode == TYPE_MODE (long_double_type_node))
1223 suffix[0] = 'l';
1224 else
1225 {
1226 bool found_suffix = false;
1227 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1228 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
1229 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
1230 {
1231 sprintf (suffix, "f%d%s", floatn_nx_types[i].n,
1232 floatn_nx_types[i].extended ? "x" : "");
1233 found_suffix = true;
1234 break;
1235 }
1236 gcc_assert (found_suffix);
1237 }
1238 builtin_define_with_value (macro_name, suffix, 0);
1239
1240 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1241 eliminating excess precision from results assigned to
1242 variables - meaning it should be about the implicit excess
1243 precision only. */
1244 bool excess_precision = false;
1245 machine_mode float16_type_mode = (float16_type_node
1246 ? TYPE_MODE (float16_type_node)
1247 : VOIDmode);
1248 switch (targetm.c.excess_precision
1249 (EXCESS_PRECISION_TYPE_IMPLICIT))
1250 {
1251 case FLT_EVAL_METHOD_UNPREDICTABLE:
1252 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
1253 excess_precision = (mode == float16_type_mode
1254 || mode == TYPE_MODE (float_type_node)
1255 || mode == TYPE_MODE (double_type_node));
1256 break;
1257
1258 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
1259 excess_precision = (mode == float16_type_mode
1260 || mode == TYPE_MODE (float_type_node));
1261 break;
1262 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
1263 excess_precision = mode == float16_type_mode;
1264 break;
1265 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
1266 excess_precision = false;
1267 break;
1268 default:
1269 gcc_unreachable ();
1270 }
1271 macro_name = (char *) alloca (strlen (name)
1272 + sizeof ("__LIBGCC__EXCESS_"
1273 "PRECISION__"));
1274 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
1275 builtin_define_with_int_value (macro_name, excess_precision);
1276 }
1277
1278 /* For libgcc crtstuff.c and libgcc2.c. */
1279 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1280 EH_TABLES_CAN_BE_READ_ONLY);
1281#ifdef EH_FRAME_SECTION_NAME
1282 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1283 EH_FRAME_SECTION_NAME, 1);
1284#endif
1285#ifdef CTORS_SECTION_ASM_OP
1286 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1287 CTORS_SECTION_ASM_OP, 1);
1288#endif
1289#ifdef DTORS_SECTION_ASM_OP
1290 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1291 DTORS_SECTION_ASM_OP, 1);
1292#endif
1293#ifdef TEXT_SECTION_ASM_OP
1294 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1295 TEXT_SECTION_ASM_OP, 1);
1296#endif
1297#ifdef INIT_SECTION_ASM_OP
1298 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1299 INIT_SECTION_ASM_OP, 1);
1300#endif
1301#ifdef INIT_ARRAY_SECTION_ASM_OP
1302 /* Despite the name of this target macro, the expansion is not
1303 actually used, and may be empty rather than a string
1304 constant. */
1305 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1306#endif
1307
1308 /* For libgcc enable-execute-stack.c. */
1309 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1310 TRAMPOLINE_SIZE);
1311
1312 /* For libgcc generic-morestack.c and unwinder code. */
1313 if (STACK_GROWS_DOWNWARD)
1314 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1315
1316 /* For libgcc unwinder code. */
1317#ifdef DONT_USE_BUILTIN_SETJMP
1318 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1319#endif
1320#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1321 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1322 DWARF_ALT_FRAME_RETURN_COLUMN);
1323#endif
1324 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1325 DWARF_FRAME_REGISTERS);
1326#ifdef EH_RETURN_STACKADJ_RTX
1327 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1328#endif
1329#ifdef JMP_BUF_SIZE
1330 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1331 JMP_BUF_SIZE);
1332#endif
1333 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1334 STACK_POINTER_REGNUM);
1335
1336 /* For libgcov. */
1337 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1338 TARGET_VTABLE_USES_DESCRIPTORS);
1339 }
1340
1341 /* For use in assembly language. */
1342 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1343 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1344
1345 /* Misc. */
1346 if (flag_gnu89_inline)
1347 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1348 else
1349 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1350
1351 if (flag_no_inline)
1352 cpp_define (pfile, "__NO_INLINE__");
1353
1354 if (flag_iso)
1355 cpp_define (pfile, "__STRICT_ANSI__");
1356
1357 if (!flag_signed_char)
1358 cpp_define (pfile, "__CHAR_UNSIGNED__");
1359
1360 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1361 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1362
1363 cpp_atomic_builtins (pfile);
1364
1365#ifdef DWARF2_UNWIND_INFO
1366 if (dwarf2out_do_cfi_asm ())
1367 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1368#endif
1369
1370 /* Make the choice of ObjC runtime visible to source code. */
1371 if (c_dialect_objc () && flag_next_runtime)
1372 cpp_define (pfile, "__NEXT_RUNTIME__");
1373
1374 /* Show the availability of some target pragmas. */
1375 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1376
1377 /* Make the choice of the stack protector runtime visible to source code.
1378 The macro names and values here were chosen for compatibility with an
1379 earlier implementation, i.e. ProPolice. */
1380 if (flag_stack_protect == 4)
1381 cpp_define (pfile, "__SSP_EXPLICIT__=4");
1382 if (flag_stack_protect == 3)
1383 cpp_define (pfile, "__SSP_STRONG__=3");
1384 if (flag_stack_protect == 2)
1385 cpp_define (pfile, "__SSP_ALL__=2");
1386 else if (flag_stack_protect == 1)
1387 cpp_define (pfile, "__SSP__=1");
1388
1389 if (flag_openacc)
1390 cpp_define (pfile, "_OPENACC=201306");
1391
1392 if (flag_openmp)
1393 cpp_define (pfile, "_OPENMP=201511");
1394
1395 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1396 if (int_n_enabled_p[i])
1397 {
1398 char buf[15+20];
1399 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1400 builtin_define_type_sizeof (buf,
1401 int_n_trees[i].signed_type);
1402 }
1403 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1404 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1405 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1406 unsigned_ptrdiff_type_node);
1407
1408 /* A straightforward target hook doesn't work, because of problems
1409 linking that hook's body when part of non-C front ends. */
1410# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1411# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1412# define builtin_define(TXT) cpp_define (pfile, TXT)
1413# define builtin_assert(TXT) cpp_assert (pfile, TXT)
1414 TARGET_CPU_CPP_BUILTINS ();
1415 TARGET_OS_CPP_BUILTINS ();
1416 TARGET_OBJFMT_CPP_BUILTINS ();
1417
1418 /* Support the __declspec keyword by turning them into attributes.
1419 Note that the current way we do this may result in a collision
1420 with predefined attributes later on. This can be solved by using
1421 one attribute, say __declspec__, and passing args to it. The
1422 problem with that approach is that args are not accumulated: each
1423 new appearance would clobber any existing args. */
1424 if (TARGET_DECLSPEC)
1425 builtin_define ("__declspec(x)=__attribute__((x))");
1426
1427 /* If decimal floating point is supported, tell the user if the
1428 alternate format (BID) is used instead of the standard (DPD)
1429 format. */
1430 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1431 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1432}
1433
1434/* Pass an object-like macro. If it doesn't lie in the user's
1435 namespace, defines it unconditionally. Otherwise define a version
1436 with two leading underscores, and another version with two leading
1437 and trailing underscores, and define the original only if an ISO
1438 standard was not nominated.
1439
1440 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1441 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1442 "_mips". */
1443void
1444builtin_define_std (const char *macro)
1445{
1446 size_t len = strlen (macro);
1447 char *buff = (char *) alloca (len + 5);
1448 char *p = buff + 2;
1449 char *q = p + len;
1450
1451 /* prepend __ (or maybe just _) if in user's namespace. */
1452 memcpy (p, macro, len + 1);
1453 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1454 {
1455 if (*p != '_')
1456 *--p = '_';
1457 if (p[1] != '_')
1458 *--p = '_';
1459 }
1460 cpp_define (parse_in, p);
1461
1462 /* If it was in user's namespace... */
1463 if (p != buff + 2)
1464 {
1465 /* Define the macro with leading and following __. */
1466 if (q[-1] != '_')
1467 *q++ = '_';
1468 if (q[-2] != '_')
1469 *q++ = '_';
1470 *q = '\0';
1471 cpp_define (parse_in, p);
1472
1473 /* Finally, define the original macro if permitted. */
1474 if (!flag_iso)
1475 cpp_define (parse_in, macro);
1476 }
1477}
1478
1479/* Pass an object-like macro and a value to define it to. The third
1480 parameter says whether or not to turn the value into a string
1481 constant. */
1482void
1483builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1484{
1485 char *buf;
1486 size_t mlen = strlen (macro);
1487 size_t elen = strlen (expansion);
1488 size_t extra = 2; /* space for an = and a NUL */
1489
1490 if (is_str)
1491 {
1492 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1493 const char *p;
1494 char *q;
1495 extra += 2; /* space for two quote marks */
1496 for (p = expansion, q = quoted_expansion; *p; p++)
1497 {
1498 switch (*p)
1499 {
1500 case '\n':
1501 *q++ = '\\';
1502 *q++ = 'n';
1503 break;
1504
1505 case '\t':
1506 *q++ = '\\';
1507 *q++ = 't';
1508 break;
1509
1510 case '\\':
1511 *q++ = '\\';
1512 *q++ = '\\';
1513 break;
1514
1515 case '"':
1516 *q++ = '\\';
1517 *q++ = '"';
1518 break;
1519
1520 default:
1521 if (ISPRINT ((unsigned char) *p))
1522 *q++ = *p;
1523 else
1524 {
1525 sprintf (q, "\\%03o", (unsigned char) *p);
1526 q += 4;
1527 }
1528 }
1529 }
1530 *q = '\0';
1531 expansion = quoted_expansion;
1532 elen = q - expansion;
1533 }
1534
1535 buf = (char *) alloca (mlen + elen + extra);
1536 if (is_str)
1537 sprintf (buf, "%s=\"%s\"", macro, expansion);
1538 else
1539 sprintf (buf, "%s=%s", macro, expansion);
1540
1541 cpp_define (parse_in, buf);
1542}
1543
1544
1545/* Pass an object-like macro and an integer value to define it to. */
1546void
1547builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1548{
1549 char *buf;
1550 size_t mlen = strlen (macro);
1551 size_t vlen = 18;
1552 size_t extra = 2; /* space for = and NUL. */
1553
1554 buf = (char *) alloca (mlen + vlen + extra);
1555 memcpy (buf, macro, mlen);
1556 buf[mlen] = '=';
1557 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1558
1559 cpp_define (parse_in, buf);
1560}
1561
1562/* builtin_define_with_hex_fp_value is very expensive, so the following
1563 array and function allows it to be done lazily when __DBL_MAX__
1564 etc. is first used. */
1565
1566struct GTY(()) lazy_hex_fp_value_struct
1567{
1568 const char *hex_str;
1569 cpp_macro *macro;
1570 machine_mode mode;
1571 int digits;
1572 const char *fp_suffix;
1573};
1574static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12];
1575static GTY(()) int lazy_hex_fp_value_count;
1576
1577static bool
1578lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1579 cpp_hashnode *node)
1580{
1581 REAL_VALUE_TYPE real;
1582 char dec_str[64], buf1[256];
1583 unsigned int idx;
1584 if (node->value.builtin < BT_FIRST_USER
1585 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1586 return false;
1587
1588 idx = node->value.builtin - BT_FIRST_USER;
1589 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1590 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1591 lazy_hex_fp_values[idx].digits, 0,
1592 lazy_hex_fp_values[idx].mode);
1593
1594 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1595 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1596 node->value.macro = lazy_hex_fp_values[idx].macro;
1597 for (idx = 0; idx < node->value.macro->count; idx++)
1598 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1599 break;
1600 gcc_assert (idx < node->value.macro->count);
1601 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1602 node->value.macro->exp.tokens[idx].val.str.text
1603 = (const unsigned char *) ggc_strdup (buf1);
1604 return true;
1605}
1606
1607/* Pass an object-like macro a hexadecimal floating-point value. */
1608static void
1609builtin_define_with_hex_fp_value (const char *macro,
1610 tree type, int digits,
1611 const char *hex_str,
1612 const char *fp_suffix,
1613 const char *fp_cast)
1614{
1615 REAL_VALUE_TYPE real;
1616 char dec_str[64], buf1[256], buf2[256];
1617
1618 /* This is very expensive, so if possible expand them lazily. */
1619 if (lazy_hex_fp_value_count < 12
1620 && flag_dump_macros == 0
1621 && !cpp_get_options (parse_in)->traditional)
1622 {
1623 struct cpp_hashnode *node;
1624 if (lazy_hex_fp_value_count == 0)
1625 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1626 sprintf (buf2, fp_cast, "1.1");
1627 sprintf (buf1, "%s=%s", macro, buf2);
1628 cpp_define (parse_in, buf1);
1629 node = C_CPP_HASHNODE (get_identifier (macro));
1630 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1631 = ggc_strdup (hex_str);
1632 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1633 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1634 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1635 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1636 node->flags |= NODE_BUILTIN;
1637 node->value.builtin
1638 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1639 lazy_hex_fp_value_count++;
1640 return;
1641 }
1642
1643 /* Hex values are really cool and convenient, except that they're
1644 not supported in strict ISO C90 mode. First, the "p-" sequence
1645 is not valid as part of a preprocessor number. Second, we get a
1646 pedwarn from the preprocessor, which has no context, so we can't
1647 suppress the warning with __extension__.
1648
1649 So instead what we do is construct the number in hex (because
1650 it's easy to get the exact correct value), parse it as a real,
1651 then print it back out as decimal. */
1652
1653 real_from_string (&real, hex_str);
1654 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1655 TYPE_MODE (type));
1656
1657 /* Assemble the macro in the following fashion
1658 macro = fp_cast [dec_str fp_suffix] */
1659 sprintf (buf1, "%s%s", dec_str, fp_suffix);
1660 sprintf (buf2, fp_cast, buf1);
1661 sprintf (buf1, "%s=%s", macro, buf2);
1662
1663 cpp_define (parse_in, buf1);
1664}
1665
1666/* Return a string constant for the suffix for a value of type TYPE
1667 promoted according to the integer promotions. The type must be one
1668 of the standard integer type nodes. */
1669
1670static const char *
1671type_suffix (tree type)
1672{
1673 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1674 int unsigned_suffix;
1675 int is_long;
1676 int tp = TYPE_PRECISION (type);
1677
1678 if (type == long_long_integer_type_node
1679 || type == long_long_unsigned_type_node
1680 || tp > TYPE_PRECISION (long_integer_type_node))
1681 is_long = 2;
1682 else if (type == long_integer_type_node
1683 || type == long_unsigned_type_node
1684 || tp > TYPE_PRECISION (integer_type_node))
1685 is_long = 1;
1686 else if (type == integer_type_node
1687 || type == unsigned_type_node
1688 || type == short_integer_type_node
1689 || type == short_unsigned_type_node
1690 || type == signed_char_type_node
1691 || type == unsigned_char_type_node
1692 /* ??? "char" is not a signed or unsigned integer type and
1693 so is not permitted for the standard typedefs, but some
1694 systems use it anyway. */
1695 || type == char_type_node)
1696 is_long = 0;
1697 else
1698 gcc_unreachable ();
1699
1700 unsigned_suffix = TYPE_UNSIGNED (type);
1701 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1702 unsigned_suffix = 0;
1703 return suffixes[is_long * 2 + unsigned_suffix];
1704}
1705
1706/* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1707static void
1708builtin_define_constants (const char *macro, tree type)
1709{
1710 const char *suffix;
1711 char *buf;
1712
1713 suffix = type_suffix (type);
1714
1715 if (suffix[0] == 0)
1716 {
1717 buf = (char *) alloca (strlen (macro) + 6);
1718 sprintf (buf, "%s(c)=c", macro);
1719 }
1720 else
1721 {
1722 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1723 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1724 }
1725
1726 cpp_define (parse_in, buf);
1727}
1728
1729/* Define MAX for TYPE based on the precision of the type. */
1730
1731static void
1732builtin_define_type_max (const char *macro, tree type)
1733{
1734 builtin_define_type_minmax (NULL, macro, type);
1735}
1736
1737/* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1738 representation of that value. For example, a COUNT of 10 would
1739 return "0x3ff". */
1740
1741static void
1742print_bits_of_hex (char *buf, int bufsz, int count)
1743{
1744 gcc_assert (bufsz > 3);
1745 *buf++ = '0';
1746 *buf++ = 'x';
1747 bufsz -= 2;
1748
1749 gcc_assert (count > 0);
1750
1751 switch (count % 4) {
1752 case 0:
1753 break;
1754 case 1:
1755 *buf++ = '1';
1756 bufsz --;
1757 count -= 1;
1758 break;
1759 case 2:
1760 *buf++ = '3';
1761 bufsz --;
1762 count -= 2;
1763 break;
1764 case 3:
1765 *buf++ = '7';
1766 bufsz --;
1767 count -= 3;
1768 break;
1769 }
1770 while (count >= 4)
1771 {
1772 gcc_assert (bufsz > 1);
1773 *buf++ = 'f';
1774 bufsz --;
1775 count -= 4;
1776 }
1777 gcc_assert (bufsz > 0);
1778 *buf++ = 0;
1779}
1780
1781/* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1782 precision of the type. */
1783
1784static void
1785builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1786 tree type)
1787{
1788#define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1789 char value[PBOH_SZ];
1790
1791 const char *suffix;
1792 char *buf;
1793 int bits;
1794
1795 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1796
1797 print_bits_of_hex (value, PBOH_SZ, bits);
1798
1799 suffix = type_suffix (type);
1800
1801 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1802 + strlen (suffix) + 1);
1803 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1804
1805 cpp_define (parse_in, buf);
1806
1807 if (min_macro)
1808 {
1809 if (TYPE_UNSIGNED (type))
1810 {
1811 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1812 sprintf (buf, "%s=0%s", min_macro, suffix);
1813 }
1814 else
1815 {
1816 buf = (char *) alloca (strlen (min_macro) + 3
1817 + strlen (max_macro) + 6);
1818 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1819 }
1820 cpp_define (parse_in, buf);
1821 }
1822}
1823
1824/* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1825 both types must have the same width. */
1826
1827static void
1828builtin_define_type_width (const char *width_macro, tree type, tree type2)
1829{
1830 if (type2 != NULL_TREE)
1831 gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
1832 builtin_define_with_int_value (width_macro, TYPE_PRECISION (type));
1833}
1834
1835#include "gt-c-family-c-cppbuiltin.h"
1836