1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2022 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
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.
10
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.
15
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/>. */
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 "cppbuiltin.h"
35 #include "configargs.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. */
50 static void builtin_define_with_hex_fp_value (const char *, tree,
51 int, const char *,
52 const char *,
53 const char *);
54 static void builtin_define_stdint_macros (void);
55 static void builtin_define_constants (const char *, tree);
56 static void builtin_define_type_max (const char *, tree);
57 static void builtin_define_type_minmax (const char *, const char *, tree);
58 static void builtin_define_type_width (const char *, tree, tree);
59 static 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
70 static bool
mode_has_fma(machine_mode mode)71 mode_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. */
108 void
builtin_define_type_sizeof(const char * name,tree type)109 builtin_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. */
117 static void
builtin_define_float_constants(const char * name_prefix,const char * fp_suffix,const char * fp_cast,const char * fma_suffix,tree type)118 builtin_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), false);
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 get_max_float (fmt, buf, sizeof (buf), true);
269
270 sprintf (name, "__%s_NORM_MAX__", name_prefix);
271 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
272
273 /* The minimum normalized positive floating-point number,
274 b**(emin-1). */
275 sprintf (name, "__%s_MIN__", name_prefix);
276 sprintf (buf, "0x1p%d", fmt->emin - 1);
277 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
278
279 /* The difference between 1 and the least value greater than 1 that is
280 representable in the given floating point type, b**(1-p). */
281 sprintf (name, "__%s_EPSILON__", name_prefix);
282 if (fmt->pnan < fmt->p)
283 /* This is an IBM extended double format, so 1.0 + any double is
284 representable precisely. */
285 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
286 else
287 sprintf (buf, "0x1p%d", 1 - fmt->p);
288 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
289
290 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
291 The minimum denormalized positive floating-point number, b**(emin-p).
292 The minimum normalized positive floating-point number for formats
293 that don't support denormals. */
294 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
295 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
296 builtin_define_with_hex_fp_value (name, type, decimal_dig,
297 buf, fp_suffix, fp_cast);
298
299 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
300 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
301
302 /* For C++ std::numeric_limits<T>::has_infinity. */
303 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
304 builtin_define_with_int_value (name,
305 MODE_HAS_INFINITIES (TYPE_MODE (type)));
306 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
307 predicate to distinguish a target that has both quiet and
308 signalling NaNs from a target that has only quiet NaNs or only
309 signalling NaNs, so we assume that a target that has any kind of
310 NaN has quiet NaNs. */
311 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
312 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
313
314 /* Note whether we have fast FMA. */
315 if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
316 {
317 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
318 builtin_define_with_int_value (name, 1);
319 }
320
321 /* For C2x *_IS_IEC_60559. 0 means the type does not match an IEC
322 60559 format, 1 that it matches a format but not operations and 2
323 that it matches a format and operations (but may not conform to
324 Annex F; we take this as meaning exceptions and rounding modes
325 need not be supported). */
326 sprintf (name, "__%s_IS_IEC_60559__", name_prefix);
327 builtin_define_with_int_value (name,
328 (fmt->ieee_bits == 0
329 ? 0 : (fmt->round_towards_zero ? 1 : 2)));
330 }
331
332 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
333 static void
builtin_define_decimal_float_constants(const char * name_prefix,const char * suffix,tree type)334 builtin_define_decimal_float_constants (const char *name_prefix,
335 const char *suffix,
336 tree type)
337 {
338 const struct real_format *fmt;
339 char name[64], buf[128], *p;
340 int digits;
341
342 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
343
344 /* The number of radix digits, p, in the significand. */
345 sprintf (name, "__%s_MANT_DIG__", name_prefix);
346 builtin_define_with_int_value (name, fmt->p);
347
348 /* The minimum negative int x such that b**(x-1) is a normalized float. */
349 sprintf (name, "__%s_MIN_EXP__", name_prefix);
350 sprintf (buf, "(%d)", fmt->emin);
351 builtin_define_with_value (name, buf, 0);
352
353 /* The maximum int x such that b**(x-1) is a representable float. */
354 sprintf (name, "__%s_MAX_EXP__", name_prefix);
355 builtin_define_with_int_value (name, fmt->emax);
356
357 /* Compute the minimum representable value. */
358 sprintf (name, "__%s_MIN__", name_prefix);
359 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
360 builtin_define_with_value (name, buf, 0);
361
362 /* Compute the maximum representable value. */
363 sprintf (name, "__%s_MAX__", name_prefix);
364 p = buf;
365 for (digits = fmt->p; digits; digits--)
366 {
367 *p++ = '9';
368 if (digits == fmt->p)
369 *p++ = '.';
370 }
371 *p = 0;
372 /* fmt->p plus 1, to account for the decimal point and fmt->emax
373 minus 1 because the digits are nines, not 1.0. */
374 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
375 builtin_define_with_value (name, buf, 0);
376
377 /* Compute epsilon (the difference between 1 and least value greater
378 than 1 representable). */
379 sprintf (name, "__%s_EPSILON__", name_prefix);
380 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
381 builtin_define_with_value (name, buf, 0);
382
383 /* Minimum subnormal positive decimal value. */
384 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
385 p = buf;
386 for (digits = fmt->p; digits > 1; digits--)
387 {
388 *p++ = '0';
389 if (digits == fmt->p)
390 *p++ = '.';
391 }
392 *p = 0;
393 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
394 builtin_define_with_value (name, buf, 0);
395 }
396
397 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
398
399 static void
builtin_define_fixed_point_constants(const char * name_prefix,const char * suffix,tree type)400 builtin_define_fixed_point_constants (const char *name_prefix,
401 const char *suffix,
402 tree type)
403 {
404 char name[64], buf[256], *new_buf;
405 int i, mod;
406
407 sprintf (name, "__%s_FBIT__", name_prefix);
408 builtin_define_with_int_value (name, TYPE_FBIT (type));
409
410 sprintf (name, "__%s_IBIT__", name_prefix);
411 builtin_define_with_int_value (name, TYPE_IBIT (type));
412
413 /* If there is no suffix, defines are for fixed-point modes.
414 We just return. */
415 if (strcmp (suffix, "") == 0)
416 return;
417
418 if (TYPE_UNSIGNED (type))
419 {
420 sprintf (name, "__%s_MIN__", name_prefix);
421 sprintf (buf, "0.0%s", suffix);
422 builtin_define_with_value (name, buf, 0);
423 }
424 else
425 {
426 sprintf (name, "__%s_MIN__", name_prefix);
427 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
428 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
429 TYPE_IBIT (type) - 1, suffix);
430 else
431 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
432 builtin_define_with_value (name, buf, 0);
433 }
434
435 sprintf (name, "__%s_MAX__", name_prefix);
436 sprintf (buf, "0X");
437 new_buf = buf + 2;
438 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
439 if (mod)
440 sprintf (new_buf++, "%x", (1 << mod) - 1);
441 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
442 sprintf (new_buf++, "F");
443 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
444 builtin_define_with_value (name, buf, 0);
445
446 sprintf (name, "__%s_EPSILON__", name_prefix);
447 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
448 builtin_define_with_value (name, buf, 0);
449 }
450
451 /* Define macros used by <stdint.h>. */
452 static void
builtin_define_stdint_macros(void)453 builtin_define_stdint_macros (void)
454 {
455 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
456 builtin_define_constants ("__INTMAX_C", intmax_type_node);
457 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
458 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
459 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node,
460 uintmax_type_node);
461 if (sig_atomic_type_node)
462 {
463 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
464 sig_atomic_type_node);
465 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node,
466 NULL_TREE);
467 }
468 if (int8_type_node)
469 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
470 if (int16_type_node)
471 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
472 if (int32_type_node)
473 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
474 if (int64_type_node)
475 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
476 if (uint8_type_node)
477 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
478 if (c_uint16_type_node)
479 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
480 if (c_uint32_type_node)
481 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
482 if (c_uint64_type_node)
483 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
484 if (int_least8_type_node)
485 {
486 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
487 builtin_define_constants ("__INT8_C", int_least8_type_node);
488 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node,
489 uint_least8_type_node);
490 }
491 if (int_least16_type_node)
492 {
493 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
494 builtin_define_constants ("__INT16_C", int_least16_type_node);
495 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
496 int_least16_type_node,
497 uint_least16_type_node);
498 }
499 if (int_least32_type_node)
500 {
501 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
502 builtin_define_constants ("__INT32_C", int_least32_type_node);
503 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
504 int_least32_type_node,
505 uint_least32_type_node);
506 }
507 if (int_least64_type_node)
508 {
509 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
510 builtin_define_constants ("__INT64_C", int_least64_type_node);
511 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
512 int_least64_type_node,
513 uint_least64_type_node);
514 }
515 if (uint_least8_type_node)
516 {
517 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
518 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
519 }
520 if (uint_least16_type_node)
521 {
522 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
523 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
524 }
525 if (uint_least32_type_node)
526 {
527 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
528 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
529 }
530 if (uint_least64_type_node)
531 {
532 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
533 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
534 }
535 /*
536 * NetBSD/sparc64 long ago defined signed and unsigned fast{8,16,32} to be
537 * different to the common sparc64 definitions, and they are not the same
538 * size for the same bitsize. GCC 7 introduced checks that they are the
539 * same size below that trigger here.
540 *
541 * NETBSD_TOOLS/NETBSD_NATIVE is wrong for this, but it will do for now.
542 */
543 #if defined(NETBSD_TOOLS) || defined(NETBSD_NATIVE)
544 #define builtin_define_type_width_nb(a,b,c) builtin_define_type_width(a,b,NULL_TREE)
545 #else
546 #define builtin_define_type_width_nb(a,b,c) builtin_define_type_width(a,b,c)
547 #endif
548 if (int_fast8_type_node)
549 {
550 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
551 builtin_define_type_width_nb ("__INT_FAST8_WIDTH__", int_fast8_type_node,
552 uint_fast8_type_node);
553 }
554 if (int_fast16_type_node)
555 {
556 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
557 builtin_define_type_width_nb ("__INT_FAST16_WIDTH__", int_fast16_type_node,
558 uint_fast16_type_node);
559 }
560 if (int_fast32_type_node)
561 {
562 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
563 builtin_define_type_width_nb ("__INT_FAST32_WIDTH__", int_fast32_type_node,
564 uint_fast32_type_node);
565 }
566 if (int_fast64_type_node)
567 {
568 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
569 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node,
570 uint_fast64_type_node);
571 }
572 #undef builtin_define_type_width_nb
573 if (uint_fast8_type_node)
574 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
575 if (uint_fast16_type_node)
576 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
577 if (uint_fast32_type_node)
578 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
579 if (uint_fast64_type_node)
580 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
581 if (intptr_type_node)
582 {
583 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
584 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node,
585 uintptr_type_node);
586 }
587 if (uintptr_type_node)
588 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
589 }
590
591 /* Adjust the optimization macros when a #pragma GCC optimization is done to
592 reflect the current level. */
593 void
c_cpp_builtins_optimize_pragma(cpp_reader * pfile,tree prev_tree,tree cur_tree)594 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
595 tree cur_tree)
596 {
597 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
598 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
599 bool prev_fast_math;
600 bool cur_fast_math;
601
602 /* -undef turns off target-specific built-ins. */
603 if (flag_undef)
604 return;
605
606 /* Make sure all of the builtins about to be declared have
607 BUILTINS_LOCATION has their location_t. */
608 cpp_force_token_locations (parse_in, BUILTINS_LOCATION);
609
610 /* Other target-independent built-ins determined by command-line
611 options. */
612 if (!prev->x_optimize_size && cur->x_optimize_size)
613 cpp_define_unused (pfile, "__OPTIMIZE_SIZE__");
614 else if (prev->x_optimize_size && !cur->x_optimize_size)
615 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
616
617 if (!prev->x_optimize && cur->x_optimize)
618 cpp_define_unused (pfile, "__OPTIMIZE__");
619 else if (prev->x_optimize && !cur->x_optimize)
620 cpp_undef (pfile, "__OPTIMIZE__");
621
622 prev_fast_math = fast_math_flags_struct_set_p (prev);
623 cur_fast_math = fast_math_flags_struct_set_p (cur);
624 if (!prev_fast_math && cur_fast_math)
625 cpp_define_unused (pfile, "__FAST_MATH__");
626 else if (prev_fast_math && !cur_fast_math)
627 cpp_undef (pfile, "__FAST_MATH__");
628
629 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
630 cpp_define_unused (pfile, "__SUPPORT_SNAN__");
631 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
632 cpp_undef (pfile, "__SUPPORT_SNAN__");
633
634 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
635 cpp_undef (pfile, "__NO_MATH_ERRNO__");
636 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
637 cpp_define_unused (pfile, "__NO_MATH_ERRNO__");
638
639 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
640 {
641 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
642 cpp_define_unused (pfile, "__FINITE_MATH_ONLY__=1");
643 }
644 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
645 {
646 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
647 cpp_define_unused (pfile, "__FINITE_MATH_ONLY__=0");
648 }
649
650 if (!prev->x_flag_reciprocal_math && cur->x_flag_reciprocal_math)
651 cpp_define_unused (pfile, "__RECIPROCAL_MATH__");
652 else if (prev->x_flag_reciprocal_math && !cur->x_flag_reciprocal_math)
653 cpp_undef (pfile, "__RECIPROCAL_MATH__");
654
655 if (!prev->x_flag_signed_zeros && cur->x_flag_signed_zeros)
656 cpp_undef (pfile, "__NO_SIGNED_ZEROS__");
657 else if (prev->x_flag_signed_zeros && !cur->x_flag_signed_zeros)
658 cpp_define_unused (pfile, "__NO_SIGNED_ZEROS__");
659
660 if (!prev->x_flag_trapping_math && cur->x_flag_trapping_math)
661 cpp_undef (pfile, "__NO_TRAPPING_MATH__");
662 else if (prev->x_flag_trapping_math && !cur->x_flag_trapping_math)
663 cpp_define_unused (pfile, "__NO_TRAPPING_MATH__");
664
665 if (!prev->x_flag_associative_math && cur->x_flag_associative_math)
666 cpp_define_unused (pfile, "__ASSOCIATIVE_MATH__");
667 else if (prev->x_flag_associative_math && !cur->x_flag_associative_math)
668 cpp_undef (pfile, "__ASSOCIATIVE_MATH__");
669
670 if (!prev->x_flag_rounding_math && cur->x_flag_rounding_math)
671 cpp_define_unused (pfile, "__ROUNDING_MATH__");
672 else if (prev->x_flag_rounding_math && !cur->x_flag_rounding_math)
673 cpp_undef (pfile, "__ROUNDING_MATH__");
674
675 cpp_stop_forcing_token_locations (parse_in);
676 }
677
678
679 /* This function will emit cpp macros to indicate the presence of various lock
680 free atomic operations. */
681
682 static void
cpp_atomic_builtins(cpp_reader * pfile)683 cpp_atomic_builtins (cpp_reader *pfile)
684 {
685 /* Set a flag for each size of object that compare and swap exists for up to
686 a 16 byte object. */
687 #define SWAP_LIMIT 17
688 bool have_swap[SWAP_LIMIT];
689 unsigned int psize;
690
691 /* Clear the map of sizes compare_and swap exists for. */
692 memset (have_swap, 0, sizeof (have_swap));
693
694 /* Tell source code if the compiler makes sync_compare_and_swap
695 builtins available. */
696 #ifndef HAVE_sync_compare_and_swapqi
697 #define HAVE_sync_compare_and_swapqi 0
698 #endif
699 #ifndef HAVE_atomic_compare_and_swapqi
700 #define HAVE_atomic_compare_and_swapqi 0
701 #endif
702
703 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
704 {
705 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
706 have_swap[1] = true;
707 }
708
709 #ifndef HAVE_sync_compare_and_swaphi
710 #define HAVE_sync_compare_and_swaphi 0
711 #endif
712 #ifndef HAVE_atomic_compare_and_swaphi
713 #define HAVE_atomic_compare_and_swaphi 0
714 #endif
715 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
716 {
717 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
718 have_swap[2] = true;
719 }
720
721 #ifndef HAVE_sync_compare_and_swapsi
722 #define HAVE_sync_compare_and_swapsi 0
723 #endif
724 #ifndef HAVE_atomic_compare_and_swapsi
725 #define HAVE_atomic_compare_and_swapsi 0
726 #endif
727 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
728 {
729 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
730 have_swap[4] = true;
731 }
732
733 #ifndef HAVE_sync_compare_and_swapdi
734 #define HAVE_sync_compare_and_swapdi 0
735 #endif
736 #ifndef HAVE_atomic_compare_and_swapdi
737 #define HAVE_atomic_compare_and_swapdi 0
738 #endif
739 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
740 {
741 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
742 have_swap[8] = true;
743 }
744
745 #ifndef HAVE_sync_compare_and_swapti
746 #define HAVE_sync_compare_and_swapti 0
747 #endif
748 #ifndef HAVE_atomic_compare_and_swapti
749 #define HAVE_atomic_compare_and_swapti 0
750 #endif
751 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
752 {
753 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
754 have_swap[16] = true;
755 }
756
757 /* Tell the source code about various types. These map to the C++11 and C11
758 macros where 2 indicates lock-free always, and 1 indicates sometimes
759 lock free. */
760 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
761 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
762 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
763 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
764 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
765 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
766 if (flag_char8_t)
767 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR8_T_LOCK_FREE",
768 (have_swap[SWAP_INDEX (char8_type_node)]? 2 : 1));
769 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
770 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
771 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
772 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
773 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
774 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
775 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
776 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
777 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
778 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
779 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
780 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
781 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
782 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
783
784 /* If we're dealing with a "set" value that doesn't exactly correspond
785 to a boolean truth value, let the library work around that. */
786 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
787 targetm.atomic_test_and_set_trueval);
788
789 /* Macros for C++17 hardware interference size constants. Either both or
790 neither should be set. */
791 gcc_assert (!param_destruct_interfere_size
792 == !param_construct_interfere_size);
793 if (param_destruct_interfere_size)
794 {
795 /* FIXME The way of communicating these values to the library should be
796 part of the C++ ABI, whether macro or builtin. */
797 builtin_define_with_int_value ("__GCC_DESTRUCTIVE_SIZE",
798 param_destruct_interfere_size);
799 builtin_define_with_int_value ("__GCC_CONSTRUCTIVE_SIZE",
800 param_construct_interfere_size);
801 }
802
803 /* ptr_type_node can't be used here since ptr_mode is only set when
804 toplev calls backend_init which is not done with -E or pch. */
805 psize = POINTER_SIZE_UNITS;
806 if (psize >= SWAP_LIMIT)
807 psize = 0;
808 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
809 (have_swap[psize]? 2 : 1));
810 }
811
812 /* Return TRUE if the implicit excess precision in which the back-end will
813 compute floating-point calculations is not more than the explicit
814 excess precision that the front-end will apply under
815 -fexcess-precision=[standard|fast|16].
816
817 More intuitively, return TRUE if the excess precision proposed by the
818 front-end is the excess precision that will actually be used. */
819
820 static bool
c_cpp_flt_eval_method_iec_559(void)821 c_cpp_flt_eval_method_iec_559 (void)
822 {
823 enum excess_precision_type front_end_ept
824 = (flag_excess_precision == EXCESS_PRECISION_STANDARD
825 ? EXCESS_PRECISION_TYPE_STANDARD
826 : (flag_excess_precision == EXCESS_PRECISION_FLOAT16
827 ? EXCESS_PRECISION_TYPE_FLOAT16
828 : EXCESS_PRECISION_TYPE_FAST));
829
830 enum flt_eval_method back_end
831 = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
832
833 enum flt_eval_method front_end
834 = targetm.c.excess_precision (front_end_ept);
835
836 return excess_precision_mode_join (front_end, back_end) == front_end;
837 }
838
839 /* Return the value for __GCC_IEC_559. */
840 static int
cpp_iec_559_value(void)841 cpp_iec_559_value (void)
842 {
843 /* The default is support for IEEE 754-2008. */
844 int ret = 2;
845
846 /* float and double must be binary32 and binary64. If they are but
847 with reversed NaN convention, at most IEEE 754-1985 is
848 supported. */
849 const struct real_format *ffmt
850 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
851 const struct real_format *dfmt
852 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
853 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
854 ret = 1;
855 if (ffmt->b != 2
856 || ffmt->p != 24
857 || ffmt->pnan != 24
858 || ffmt->emin != -125
859 || ffmt->emax != 128
860 || ffmt->signbit_rw != 31
861 || ffmt->round_towards_zero
862 || !ffmt->has_sign_dependent_rounding
863 || !ffmt->has_nans
864 || !ffmt->has_inf
865 || !ffmt->has_denorm
866 || !ffmt->has_signed_zero
867 || dfmt->b != 2
868 || dfmt->p != 53
869 || dfmt->pnan != 53
870 || dfmt->emin != -1021
871 || dfmt->emax != 1024
872 || dfmt->signbit_rw != 63
873 || dfmt->round_towards_zero
874 || !dfmt->has_sign_dependent_rounding
875 || !dfmt->has_nans
876 || !dfmt->has_inf
877 || !dfmt->has_denorm
878 || !dfmt->has_signed_zero)
879 ret = 0;
880
881 /* In strict C standards conformance mode, consider a back-end providing
882 more implicit excess precision than the explicit excess precision
883 the front-end options would require to mean a lack of IEEE 754
884 support. For C++, and outside strict conformance mode, do not consider
885 this to mean a lack of IEEE 754 support. */
886
887 if (flag_iso
888 && !c_dialect_cxx ()
889 && !c_cpp_flt_eval_method_iec_559 ())
890 ret = 0;
891
892 if (flag_iso
893 && !c_dialect_cxx ()
894 && flag_fp_contract_mode == FP_CONTRACT_FAST)
895 ret = 0;
896
897 /* Various options are contrary to IEEE 754 semantics. */
898 if (flag_unsafe_math_optimizations
899 || flag_associative_math
900 || flag_reciprocal_math
901 || flag_finite_math_only
902 || !flag_signed_zeros
903 || flag_single_precision_constant)
904 ret = 0;
905
906 /* If the target does not support IEEE 754 exceptions and rounding
907 modes, consider IEEE 754 support to be absent. */
908 if (!targetm.float_exceptions_rounding_supported_p ())
909 ret = 0;
910
911 return ret;
912 }
913
914 /* Return the value for __GCC_IEC_559_COMPLEX. */
915 static int
cpp_iec_559_complex_value(void)916 cpp_iec_559_complex_value (void)
917 {
918 /* The value is no bigger than that of __GCC_IEC_559. */
919 int ret = cpp_iec_559_value ();
920
921 /* Some options are contrary to the required default state of the
922 CX_LIMITED_RANGE pragma. */
923 if (flag_complex_method != 2)
924 ret = 0;
925
926 return ret;
927 }
928
929 /* Hook that registers front end and target-specific built-ins. */
930 void
c_cpp_builtins(cpp_reader * pfile)931 c_cpp_builtins (cpp_reader *pfile)
932 {
933 int i;
934
935 /* -undef turns off target-specific built-ins. */
936 if (flag_undef)
937 return;
938
939 define_language_independent_builtin_macros (pfile);
940
941 /* encoding definitions used by users and libraries */
942 builtin_define_with_value ("__GNUC_EXECUTION_CHARSET_NAME",
943 cpp_get_narrow_charset_name (pfile), 1);
944 builtin_define_with_value ("__GNUC_WIDE_EXECUTION_CHARSET_NAME",
945 cpp_get_wide_charset_name (pfile), 1);
946
947
948 if (c_dialect_cxx ())
949 {
950 int major;
951 parse_basever (&major, NULL, NULL);
952 cpp_define_formatted (pfile, "__GNUG__=%d", major);
953 }
954
955 /* For stddef.h. They require macros defined in c-common.cc. */
956 c_stddef_cpp_builtins ();
957
958 if (c_dialect_cxx ())
959 {
960 if (flag_weak && SUPPORTS_ONE_ONLY)
961 cpp_define (pfile, "__GXX_WEAK__=1");
962 else
963 cpp_define (pfile, "__GXX_WEAK__=0");
964
965 if (warn_deprecated)
966 cpp_define (pfile, "__DEPRECATED");
967
968 if (flag_rtti)
969 {
970 cpp_define (pfile, "__GXX_RTTI");
971 cpp_define (pfile, "__cpp_rtti=199711L");
972 }
973
974 if (cxx_dialect >= cxx11)
975 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
976
977 /* Binary literals have been allowed in g++ before C++11
978 and were standardized for C++14. */
979 if (!pedantic || cxx_dialect > cxx11)
980 cpp_define (pfile, "__cpp_binary_literals=201304L");
981
982 /* Similarly for hexadecimal floating point literals and C++17. */
983 if (!pedantic || cpp_get_options (parse_in)->extended_numbers)
984 cpp_define (pfile, "__cpp_hex_float=201603L");
985
986 /* Arrays of runtime bound were removed from C++14, but we still
987 support GNU VLAs. Let's define this macro to a low number
988 (corresponding to the initial test release of GNU C++) if we won't
989 complain about use of VLAs. */
990 if (c_dialect_cxx ()
991 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
992 cpp_define (pfile, "__cpp_runtime_arrays=198712L");
993
994 if (cxx_dialect >= cxx11)
995 {
996 /* Set feature test macros for C++11. */
997 if (cxx_dialect <= cxx14)
998 cpp_define (pfile, "__cpp_unicode_characters=200704L");
999 cpp_define (pfile, "__cpp_raw_strings=200710L");
1000 cpp_define (pfile, "__cpp_unicode_literals=200710L");
1001 cpp_define (pfile, "__cpp_user_defined_literals=200809L");
1002 cpp_define (pfile, "__cpp_lambdas=200907L");
1003 if (cxx_dialect == cxx11)
1004 cpp_define (pfile, "__cpp_constexpr=200704L");
1005 if (cxx_dialect <= cxx14)
1006 cpp_define (pfile, "__cpp_range_based_for=200907L");
1007 if (cxx_dialect <= cxx14)
1008 cpp_define (pfile, "__cpp_static_assert=200410L");
1009 cpp_define (pfile, "__cpp_decltype=200707L");
1010 cpp_define (pfile, "__cpp_attributes=200809L");
1011 cpp_define (pfile, "__cpp_rvalue_reference=200610L");
1012 cpp_define (pfile, "__cpp_rvalue_references=200610L");
1013 cpp_define (pfile, "__cpp_variadic_templates=200704L");
1014 cpp_define (pfile, "__cpp_initializer_lists=200806L");
1015 cpp_define (pfile, "__cpp_delegating_constructors=200604L");
1016 cpp_define (pfile, "__cpp_nsdmi=200809L");
1017 if (!flag_new_inheriting_ctors)
1018 cpp_define (pfile, "__cpp_inheriting_constructors=200802L");
1019 else
1020 cpp_define (pfile, "__cpp_inheriting_constructors=201511L");
1021 cpp_define (pfile, "__cpp_ref_qualifiers=200710L");
1022 cpp_define (pfile, "__cpp_alias_templates=200704L");
1023 }
1024 if (cxx_dialect > cxx11)
1025 {
1026 /* Set feature test macros for C++14. */
1027 cpp_define (pfile, "__cpp_return_type_deduction=201304L");
1028 if (cxx_dialect <= cxx17)
1029 {
1030 cpp_define (pfile, "__cpp_init_captures=201304L");
1031 cpp_define (pfile, "__cpp_generic_lambdas=201304L");
1032 }
1033 if (cxx_dialect <= cxx14)
1034 cpp_define (pfile, "__cpp_constexpr=201304L");
1035 cpp_define (pfile, "__cpp_decltype_auto=201304L");
1036 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304L");
1037 cpp_define (pfile, "__cpp_variable_templates=201304L");
1038 cpp_define (pfile, "__cpp_digit_separators=201309L");
1039 }
1040 if (cxx_dialect > cxx14)
1041 {
1042 /* Set feature test macros for C++17. */
1043 cpp_define (pfile, "__cpp_unicode_characters=201411L");
1044 cpp_define (pfile, "__cpp_static_assert=201411L");
1045 cpp_define (pfile, "__cpp_namespace_attributes=201411L");
1046 cpp_define (pfile, "__cpp_enumerator_attributes=201411L");
1047 cpp_define (pfile, "__cpp_nested_namespace_definitions=201411L");
1048 cpp_define (pfile, "__cpp_fold_expressions=201603L");
1049 if (cxx_dialect <= cxx17)
1050 cpp_define (pfile, "__cpp_nontype_template_args=201411L");
1051 cpp_define (pfile, "__cpp_range_based_for=201603L");
1052 if (cxx_dialect <= cxx17)
1053 cpp_define (pfile, "__cpp_constexpr=201603L");
1054 cpp_define (pfile, "__cpp_if_constexpr=201606L");
1055 cpp_define (pfile, "__cpp_capture_star_this=201603L");
1056 cpp_define (pfile, "__cpp_inline_variables=201606L");
1057 cpp_define (pfile, "__cpp_aggregate_bases=201603L");
1058 if (cxx_dialect <= cxx17)
1059 cpp_define (pfile, "__cpp_deduction_guides=201703L");
1060 cpp_define (pfile, "__cpp_noexcept_function_type=201510L");
1061 /* Old macro, superseded by
1062 __cpp_nontype_template_parameter_auto. */
1063 cpp_define (pfile, "__cpp_template_auto=201606L");
1064 cpp_define (pfile, "__cpp_structured_bindings=201606L");
1065 cpp_define (pfile, "__cpp_variadic_using=201611L");
1066 cpp_define (pfile, "__cpp_guaranteed_copy_elision=201606L");
1067 cpp_define (pfile, "__cpp_nontype_template_parameter_auto=201606L");
1068 }
1069 if (cxx_dialect > cxx17)
1070 {
1071 /* Set feature test macros for C++20. */
1072 cpp_define (pfile, "__cpp_init_captures=201803L");
1073 cpp_define (pfile, "__cpp_generic_lambdas=201707L");
1074 cpp_define (pfile, "__cpp_designated_initializers=201707L");
1075 if (cxx_dialect <= cxx20)
1076 cpp_define (pfile, "__cpp_constexpr=202002L");
1077 cpp_define (pfile, "__cpp_constexpr_in_decltype=201711L");
1078 cpp_define (pfile, "__cpp_conditional_explicit=201806L");
1079 cpp_define (pfile, "__cpp_consteval=201811L");
1080 cpp_define (pfile, "__cpp_constinit=201907L");
1081 cpp_define (pfile, "__cpp_deduction_guides=201907L");
1082 cpp_define (pfile, "__cpp_nontype_template_args=201911L");
1083 cpp_define (pfile, "__cpp_nontype_template_parameter_class=201806L");
1084 cpp_define (pfile, "__cpp_impl_destroying_delete=201806L");
1085 cpp_define (pfile, "__cpp_constexpr_dynamic_alloc=201907L");
1086 cpp_define (pfile, "__cpp_impl_three_way_comparison=201907L");
1087 cpp_define (pfile, "__cpp_aggregate_paren_init=201902L");
1088 cpp_define (pfile, "__cpp_using_enum=201907L");
1089 }
1090 if (cxx_dialect > cxx20)
1091 {
1092 /* Set feature test macros for C++23. */
1093 cpp_define (pfile, "__cpp_size_t_suffix=202011L");
1094 cpp_define (pfile, "__cpp_if_consteval=202106L");
1095 cpp_define (pfile, "__cpp_constexpr=202110L");
1096 cpp_define (pfile, "__cpp_multidimensional_subscript=202110L");
1097 cpp_define (pfile, "__cpp_auto_cast=202110L");
1098 }
1099 if (flag_concepts)
1100 {
1101 if (cxx_dialect >= cxx20)
1102 cpp_define (pfile, "__cpp_concepts=202002L");
1103 else
1104 cpp_define (pfile, "__cpp_concepts=201507L");
1105 }
1106 if (flag_modules)
1107 /* The std-defined value is 201907L, but I don't think we can
1108 claim victory yet. 201810 is the p1103 date. */
1109 cpp_define (pfile, "__cpp_modules=201810L");
1110 if (flag_coroutines)
1111 cpp_define (pfile, "__cpp_impl_coroutine=201902L"); /* n4861, DIS */
1112 if (flag_tm)
1113 /* Use a value smaller than the 201505 specified in
1114 the TS, since we don't yet support atomic_cancel. */
1115 cpp_define (pfile, "__cpp_transactional_memory=201500L");
1116 if (flag_sized_deallocation)
1117 cpp_define (pfile, "__cpp_sized_deallocation=201309L");
1118 if (aligned_new_threshold)
1119 {
1120 cpp_define (pfile, "__cpp_aligned_new=201606L");
1121 cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
1122 aligned_new_threshold);
1123 }
1124 if (flag_new_ttp)
1125 cpp_define (pfile, "__cpp_template_template_args=201611L");
1126 if (flag_threadsafe_statics)
1127 cpp_define (pfile, "__cpp_threadsafe_static_init=200806L");
1128 if (flag_char8_t)
1129 cpp_define (pfile, "__cpp_char8_t=201811L");
1130 #ifndef THREAD_MODEL_SPEC
1131 /* Targets that define THREAD_MODEL_SPEC need to define
1132 __STDCPP_THREADS__ in their config/XXX/XXX-c.c themselves. */
1133 if (cxx_dialect >= cxx11 && strcmp (thread_model, "single") != 0)
1134 cpp_define (pfile, "__STDCPP_THREADS__=1");
1135 #endif
1136 if (flag_implicit_constexpr)
1137 cpp_define (pfile, "__cpp_implicit_constexpr=20211111L");
1138 }
1139 /* Note that we define this for C as well, so that we know if
1140 __attribute__((cleanup)) will interface with EH. */
1141 if (flag_exceptions)
1142 {
1143 cpp_define (pfile, "__EXCEPTIONS");
1144 if (c_dialect_cxx ())
1145 cpp_define (pfile, "__cpp_exceptions=199711L");
1146 }
1147
1148 /* Represents the C++ ABI version, always defined so it can be used while
1149 preprocessing C and assembler. */
1150 if (flag_abi_version == 0)
1151 /* We should have set this to something real in c_common_post_options. */
1152 gcc_unreachable ();
1153 else if (flag_abi_version == 1)
1154 /* Due to a historical accident, this version had the value
1155 "102". */
1156 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1157 else
1158 /* Newer versions have values 1002, 1003, .... */
1159 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1160 1000 + flag_abi_version);
1161
1162 /* libgcc needs to know this. */
1163 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1164 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
1165
1166 /* limits.h and stdint.h need to know these. */
1167 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
1168 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
1169 builtin_define_type_max ("__INT_MAX__", integer_type_node);
1170 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
1171 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
1172 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1173 underlying_wchar_type_node);
1174 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
1175 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
1176 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
1177
1178 /* These are needed for TS 18661-1. */
1179 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
1180 unsigned_char_type_node);
1181 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
1182 short_unsigned_type_node);
1183 builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
1184 unsigned_type_node);
1185 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
1186 long_unsigned_type_node);
1187 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1188 long_long_integer_type_node,
1189 long_long_unsigned_type_node);
1190 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
1191 NULL_TREE);
1192 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
1193 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
1194 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
1195
1196 if (c_dialect_cxx ())
1197 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1198 if (int_n_enabled_p[i])
1199 {
1200 char buf[35+20+20];
1201
1202 /* These are used to configure the C++ library. */
1203
1204 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
1205 {
1206 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
1207 cpp_define (parse_in, buf);
1208
1209 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
1210 cpp_define (parse_in, buf);
1211 }
1212 }
1213
1214 /* stdint.h and the testsuite need to know these. */
1215 builtin_define_stdint_macros ();
1216
1217 /* Provide information for library headers to determine whether to
1218 define macros such as __STDC_IEC_559__ and
1219 __STDC_IEC_559_COMPLEX__. */
1220 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1221 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1222 cpp_iec_559_complex_value ());
1223
1224 /* float.h needs these to correctly set FLT_EVAL_METHOD
1225
1226 We define two values:
1227
1228 __FLT_EVAL_METHOD__
1229 Which, depending on the value given for
1230 -fpermitted-flt-eval-methods, may be limited to only those values
1231 for FLT_EVAL_METHOD defined in C99/C11.
1232
1233 __FLT_EVAL_METHOD_TS_18661_3__
1234 Which always permits the values for FLT_EVAL_METHOD defined in
1235 ISO/IEC TS 18661-3. */
1236 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1237 c_flt_eval_method (true));
1238 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1239 c_flt_eval_method (false));
1240
1241 /* And decfloat.h needs this. */
1242 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1243 TARGET_DEC_EVAL_METHOD);
1244
1245 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
1246 /* Cast the double precision constants. This is needed when single
1247 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1248 is used. The correct result is computed by the compiler when using
1249 macros that include a cast. We use a different cast for C++ to avoid
1250 problems with -Wold-style-cast. */
1251 builtin_define_float_constants ("DBL", "L",
1252 (c_dialect_cxx ()
1253 ? "double(%s)"
1254 : "((double)%s)"),
1255 "", double_type_node);
1256 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1257 long_double_type_node);
1258
1259 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1260 {
1261 if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
1262 continue;
1263 char prefix[20], csuffix[20];
1264 sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
1265 floatn_nx_types[i].extended ? "X" : "");
1266 sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
1267 floatn_nx_types[i].extended ? "x" : "");
1268 builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s",
1269 csuffix, FLOATN_NX_TYPE_NODE (i));
1270 }
1271
1272 /* For float.h. */
1273 if (targetm.decimal_float_supported_p ())
1274 {
1275 builtin_define_decimal_float_constants ("DEC32", "DF",
1276 dfloat32_type_node);
1277 builtin_define_decimal_float_constants ("DEC64", "DD",
1278 dfloat64_type_node);
1279 builtin_define_decimal_float_constants ("DEC128", "DL",
1280 dfloat128_type_node);
1281 }
1282
1283 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1284 if (targetm.fixed_point_supported_p ())
1285 {
1286 builtin_define_fixed_point_constants ("SFRACT", "HR",
1287 short_fract_type_node);
1288 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1289 unsigned_short_fract_type_node);
1290 builtin_define_fixed_point_constants ("FRACT", "R",
1291 fract_type_node);
1292 builtin_define_fixed_point_constants ("UFRACT", "UR",
1293 unsigned_fract_type_node);
1294 builtin_define_fixed_point_constants ("LFRACT", "LR",
1295 long_fract_type_node);
1296 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1297 unsigned_long_fract_type_node);
1298 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1299 long_long_fract_type_node);
1300 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1301 unsigned_long_long_fract_type_node);
1302 builtin_define_fixed_point_constants ("SACCUM", "HK",
1303 short_accum_type_node);
1304 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1305 unsigned_short_accum_type_node);
1306 builtin_define_fixed_point_constants ("ACCUM", "K",
1307 accum_type_node);
1308 builtin_define_fixed_point_constants ("UACCUM", "UK",
1309 unsigned_accum_type_node);
1310 builtin_define_fixed_point_constants ("LACCUM", "LK",
1311 long_accum_type_node);
1312 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1313 unsigned_long_accum_type_node);
1314 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1315 long_long_accum_type_node);
1316 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1317 unsigned_long_long_accum_type_node);
1318
1319 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
1320 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
1321 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
1322 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
1323 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
1324 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
1325 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
1326 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
1327 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
1328 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
1329 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
1330 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
1331 builtin_define_fixed_point_constants ("DA", "", da_type_node);
1332 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
1333 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
1334 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
1335 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
1336 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
1337 }
1338
1339 /* For libgcc-internal use only. */
1340 if (flag_building_libgcc)
1341 {
1342 /* Properties of floating-point modes for libgcc2.c. */
1343 opt_scalar_float_mode mode_iter;
1344 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
1345 {
1346 scalar_float_mode mode = mode_iter.require ();
1347 const char *name = GET_MODE_NAME (mode);
1348 const size_t name_len = strlen (name);
1349 char float_h_prefix[16] = "";
1350 char *macro_name
1351 = XALLOCAVEC (char, name_len + sizeof ("__LIBGCC__MANT_DIG__"));
1352 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
1353 builtin_define_with_int_value (macro_name,
1354 REAL_MODE_FORMAT (mode)->p);
1355 if (!targetm.scalar_mode_supported_p (mode)
1356 || !targetm.libgcc_floating_mode_supported_p (mode))
1357 continue;
1358 macro_name = XALLOCAVEC (char, name_len
1359 + sizeof ("__LIBGCC_HAS__MODE__"));
1360 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
1361 cpp_define (pfile, macro_name);
1362 macro_name = XALLOCAVEC (char, name_len
1363 + sizeof ("__LIBGCC__FUNC_EXT__"));
1364 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
1365 char suffix[20] = "";
1366 if (mode == TYPE_MODE (double_type_node))
1367 {
1368 /* Empty suffix correct. */
1369 memcpy (float_h_prefix, "DBL", 4);
1370 }
1371 else if (mode == TYPE_MODE (float_type_node))
1372 {
1373 suffix[0] = 'f';
1374 memcpy (float_h_prefix, "FLT", 4);
1375 }
1376 else if (mode == TYPE_MODE (long_double_type_node))
1377 {
1378 suffix[0] = 'l';
1379 memcpy (float_h_prefix, "LDBL", 5);
1380 }
1381 else
1382 {
1383 bool found_suffix = false;
1384 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1385 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
1386 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
1387 {
1388 sprintf (suffix, "f%d%s", floatn_nx_types[i].n,
1389 floatn_nx_types[i].extended ? "x" : "");
1390 found_suffix = true;
1391 sprintf (float_h_prefix, "FLT%d%s", floatn_nx_types[i].n,
1392 floatn_nx_types[i].extended ? "X" : "");
1393 break;
1394 }
1395 gcc_assert (found_suffix);
1396 }
1397 builtin_define_with_value (macro_name, suffix, 0);
1398
1399 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1400 eliminating excess precision from results assigned to
1401 variables - meaning it should be about the implicit excess
1402 precision only. */
1403 bool excess_precision = false;
1404 machine_mode float16_type_mode = (float16_type_node
1405 ? TYPE_MODE (float16_type_node)
1406 : VOIDmode);
1407 switch (targetm.c.excess_precision
1408 (EXCESS_PRECISION_TYPE_IMPLICIT))
1409 {
1410 case FLT_EVAL_METHOD_UNPREDICTABLE:
1411 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
1412 excess_precision = (mode == float16_type_mode
1413 || mode == TYPE_MODE (float_type_node)
1414 || mode == TYPE_MODE (double_type_node));
1415 break;
1416
1417 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
1418 excess_precision = (mode == float16_type_mode
1419 || mode == TYPE_MODE (float_type_node));
1420 break;
1421 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
1422 excess_precision = mode == float16_type_mode;
1423 break;
1424 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
1425 excess_precision = false;
1426 break;
1427 default:
1428 gcc_unreachable ();
1429 }
1430 macro_name = XALLOCAVEC (char, name_len
1431 + sizeof ("__LIBGCC__EXCESS_PRECISION__"));
1432 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
1433 builtin_define_with_int_value (macro_name, excess_precision);
1434
1435 char val_name[64];
1436
1437 macro_name = XALLOCAVEC (char, name_len
1438 + sizeof ("__LIBGCC__EPSILON__"));
1439 sprintf (macro_name, "__LIBGCC_%s_EPSILON__", name);
1440 sprintf (val_name, "__%s_EPSILON__", float_h_prefix);
1441 builtin_define_with_value (macro_name, val_name, 0);
1442
1443 macro_name = XALLOCAVEC (char, name_len + sizeof ("__LIBGCC__MAX__"));
1444 sprintf (macro_name, "__LIBGCC_%s_MAX__", name);
1445 sprintf (val_name, "__%s_MAX__", float_h_prefix);
1446 builtin_define_with_value (macro_name, val_name, 0);
1447
1448 macro_name = XALLOCAVEC (char, name_len + sizeof ("__LIBGCC__MIN__"));
1449 sprintf (macro_name, "__LIBGCC_%s_MIN__", name);
1450 sprintf (val_name, "__%s_MIN__", float_h_prefix);
1451 builtin_define_with_value (macro_name, val_name, 0);
1452
1453 #ifdef HAVE_adddf3
1454 builtin_define_with_int_value ("__LIBGCC_HAVE_HWDBL__",
1455 HAVE_adddf3);
1456 #endif
1457 }
1458
1459 /* For libgcc crtstuff.c and libgcc2.c. */
1460 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1461 EH_TABLES_CAN_BE_READ_ONLY);
1462 #ifdef EH_FRAME_SECTION_NAME
1463 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1464 EH_FRAME_SECTION_NAME, 1);
1465 #endif
1466 #ifdef CTORS_SECTION_ASM_OP
1467 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1468 CTORS_SECTION_ASM_OP, 1);
1469 #endif
1470 #ifdef DTORS_SECTION_ASM_OP
1471 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1472 DTORS_SECTION_ASM_OP, 1);
1473 #endif
1474 #ifdef TEXT_SECTION_ASM_OP
1475 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1476 TEXT_SECTION_ASM_OP, 1);
1477 #endif
1478 #ifdef INIT_SECTION_ASM_OP
1479 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1480 INIT_SECTION_ASM_OP, 1);
1481 #endif
1482 #ifdef INIT_ARRAY_SECTION_ASM_OP
1483 /* Despite the name of this target macro, the expansion is not
1484 actually used, and may be empty rather than a string
1485 constant. */
1486 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1487 #endif
1488
1489 /* For libgcc enable-execute-stack.c. */
1490 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1491 TRAMPOLINE_SIZE);
1492
1493 /* For libgcc generic-morestack.c and unwinder code. */
1494 if (STACK_GROWS_DOWNWARD)
1495 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1496
1497 /* For libgcc unwinder code. */
1498 #ifdef DONT_USE_BUILTIN_SETJMP
1499 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1500 #endif
1501 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1502 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1503 DWARF_ALT_FRAME_RETURN_COLUMN);
1504 #endif
1505 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1506 DWARF_FRAME_REGISTERS);
1507 #ifdef EH_RETURN_STACKADJ_RTX
1508 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1509 #endif
1510 #ifdef JMP_BUF_SIZE
1511 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1512 JMP_BUF_SIZE);
1513 #endif
1514 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1515 STACK_POINTER_REGNUM);
1516
1517 /* For libgcov. */
1518 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1519 TARGET_VTABLE_USES_DESCRIPTORS);
1520 builtin_define_with_int_value ("__LIBGCC_GCOV_TYPE_SIZE",
1521 targetm.gcov_type_size());
1522 }
1523
1524 /* For use in assembly language. */
1525 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1526 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1527
1528 /* Misc. */
1529 if (flag_gnu89_inline)
1530 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1531 else
1532 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1533
1534 if (flag_no_inline)
1535 cpp_define (pfile, "__NO_INLINE__");
1536
1537 if (flag_iso)
1538 cpp_define (pfile, "__STRICT_ANSI__");
1539
1540 if (!flag_signed_char)
1541 cpp_define (pfile, "__CHAR_UNSIGNED__");
1542
1543 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1544 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1545
1546 cpp_atomic_builtins (pfile);
1547
1548 /* Show support for __builtin_speculation_safe_value () if the target
1549 has been updated to fully support it. */
1550 if (targetm.have_speculation_safe_value (false))
1551 cpp_define (pfile, "__HAVE_SPECULATION_SAFE_VALUE");
1552
1553 #ifdef DWARF2_UNWIND_INFO
1554 if (dwarf2out_do_cfi_asm ())
1555 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1556 #endif
1557
1558 /* Make the choice of ObjC runtime visible to source code. */
1559 if (c_dialect_objc () && flag_next_runtime)
1560 cpp_define (pfile, "__NEXT_RUNTIME__");
1561
1562 /* Show the availability of some target pragmas. */
1563 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1564
1565 /* Make the choice of the stack protector runtime visible to source code.
1566 The macro names and values here were chosen for compatibility with an
1567 earlier implementation, i.e. ProPolice. */
1568 if (flag_stack_protect == SPCT_FLAG_EXPLICIT)
1569 cpp_define (pfile, "__SSP_EXPLICIT__=4");
1570 if (flag_stack_protect == SPCT_FLAG_STRONG)
1571 cpp_define (pfile, "__SSP_STRONG__=3");
1572 if (flag_stack_protect == SPCT_FLAG_ALL)
1573 cpp_define (pfile, "__SSP_ALL__=2");
1574 else if (flag_stack_protect == SPCT_FLAG_DEFAULT)
1575 cpp_define (pfile, "__SSP__=1");
1576
1577 if (flag_openacc)
1578 cpp_define (pfile, "_OPENACC=201711");
1579
1580 if (flag_openmp)
1581 cpp_define (pfile, "_OPENMP=201511");
1582
1583 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1584 if (int_n_enabled_p[i])
1585 {
1586 char buf[15+20];
1587 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1588 builtin_define_type_sizeof (buf,
1589 int_n_trees[i].signed_type);
1590 }
1591 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1592 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1593 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1594 unsigned_ptrdiff_type_node);
1595
1596 /* A straightforward target hook doesn't work, because of problems
1597 linking that hook's body when part of non-C front ends. */
1598 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1599 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1600 # define builtin_define(TXT) cpp_define (pfile, TXT)
1601 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1602 TARGET_CPU_CPP_BUILTINS ();
1603 TARGET_OS_CPP_BUILTINS ();
1604 TARGET_OBJFMT_CPP_BUILTINS ();
1605
1606 /* Support the __declspec keyword by turning them into attributes.
1607 Note that the current way we do this may result in a collision
1608 with predefined attributes later on. This can be solved by using
1609 one attribute, say __declspec__, and passing args to it. The
1610 problem with that approach is that args are not accumulated: each
1611 new appearance would clobber any existing args. */
1612 if (TARGET_DECLSPEC)
1613 builtin_define ("__declspec(x)=__attribute__((x))");
1614
1615 /* If decimal floating point is supported, tell the user if the
1616 alternate format (BID) is used instead of the standard (DPD)
1617 format. */
1618 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1619 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1620 }
1621
1622 /* Pass an object-like macro. If it doesn't lie in the user's
1623 namespace, defines it unconditionally. Otherwise define a version
1624 with two leading underscores, and another version with two leading
1625 and trailing underscores, and define the original only if an ISO
1626 standard was not nominated.
1627
1628 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1629 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1630 "_mips". */
1631 void
builtin_define_std(const char * macro)1632 builtin_define_std (const char *macro)
1633 {
1634 size_t len = strlen (macro);
1635 char *buff = (char *) alloca (len + 5);
1636 char *p = buff + 2;
1637 char *q = p + len;
1638
1639 /* prepend __ (or maybe just _) if in user's namespace. */
1640 memcpy (p, macro, len + 1);
1641 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1642 {
1643 if (*p != '_')
1644 *--p = '_';
1645 if (p[1] != '_')
1646 *--p = '_';
1647 }
1648 cpp_define (parse_in, p);
1649
1650 /* If it was in user's namespace... */
1651 if (p != buff + 2)
1652 {
1653 /* Define the macro with leading and following __. */
1654 if (q[-1] != '_')
1655 *q++ = '_';
1656 if (q[-2] != '_')
1657 *q++ = '_';
1658 *q = '\0';
1659 cpp_define (parse_in, p);
1660
1661 /* Finally, define the original macro if permitted. */
1662 if (!flag_iso)
1663 cpp_define (parse_in, macro);
1664 }
1665 }
1666
1667 /* Pass an object-like macro and a value to define it to. The third
1668 parameter says whether or not to turn the value into a string
1669 constant. */
1670 void
builtin_define_with_value(const char * macro,const char * expansion,int is_str)1671 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1672 {
1673 char *buf;
1674 size_t mlen = strlen (macro);
1675 size_t elen = strlen (expansion);
1676 size_t extra = 2; /* space for an = and a NUL */
1677
1678 if (is_str)
1679 {
1680 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1681 const char *p;
1682 char *q;
1683 extra += 2; /* space for two quote marks */
1684 for (p = expansion, q = quoted_expansion; *p; p++)
1685 {
1686 switch (*p)
1687 {
1688 case '\n':
1689 *q++ = '\\';
1690 *q++ = 'n';
1691 break;
1692
1693 case '\t':
1694 *q++ = '\\';
1695 *q++ = 't';
1696 break;
1697
1698 case '\\':
1699 *q++ = '\\';
1700 *q++ = '\\';
1701 break;
1702
1703 case '"':
1704 *q++ = '\\';
1705 *q++ = '"';
1706 break;
1707
1708 default:
1709 if (ISPRINT ((unsigned char) *p))
1710 *q++ = *p;
1711 else
1712 {
1713 sprintf (q, "\\%03o", (unsigned char) *p);
1714 q += 4;
1715 }
1716 }
1717 }
1718 *q = '\0';
1719 expansion = quoted_expansion;
1720 elen = q - expansion;
1721 }
1722
1723 buf = (char *) alloca (mlen + elen + extra);
1724 if (is_str)
1725 sprintf (buf, "%s=\"%s\"", macro, expansion);
1726 else
1727 sprintf (buf, "%s=%s", macro, expansion);
1728
1729 cpp_define (parse_in, buf);
1730 }
1731
1732
1733 /* Pass an object-like macro and an integer value to define it to. */
1734 void
builtin_define_with_int_value(const char * macro,HOST_WIDE_INT value)1735 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1736 {
1737 char *buf;
1738 size_t mlen = strlen (macro);
1739 size_t vlen = 18;
1740 size_t extra = 2; /* space for = and NUL. */
1741
1742 buf = (char *) alloca (mlen + vlen + extra);
1743 memcpy (buf, macro, mlen);
1744 buf[mlen] = '=';
1745 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1746
1747 cpp_define (parse_in, buf);
1748 }
1749
1750 /* builtin_define_with_hex_fp_value is very expensive, so the following
1751 array and function allows it to be done lazily when __DBL_MAX__
1752 etc. is first used. */
1753
1754 struct GTY(()) lazy_hex_fp_value_struct
1755 {
1756 const char *hex_str;
1757 machine_mode mode;
1758 int digits;
1759 const char *fp_suffix;
1760 };
1761 /* Number of the expensive to compute macros we should evaluate lazily.
1762 Each builtin_define_float_constants invocation calls
1763 builtin_define_with_hex_fp_value 5 times and builtin_define_float_constants
1764 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1765 FLTNN*. */
1766 #define LAZY_HEX_FP_VALUES_CNT (5 * (3 + NUM_FLOATN_NX_TYPES))
1767 static GTY(()) struct lazy_hex_fp_value_struct
1768 lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT];
1769 static GTY(()) unsigned lazy_hex_fp_value_count;
1770
1771 static void
lazy_hex_fp_value(cpp_reader *,cpp_macro * macro,unsigned num)1772 lazy_hex_fp_value (cpp_reader *, cpp_macro *macro, unsigned num)
1773 {
1774 REAL_VALUE_TYPE real;
1775 char dec_str[64], buf1[256];
1776
1777 gcc_checking_assert (num < lazy_hex_fp_value_count);
1778
1779 real_from_string (&real, lazy_hex_fp_values[num].hex_str);
1780 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1781 lazy_hex_fp_values[num].digits, 0,
1782 lazy_hex_fp_values[num].mode);
1783
1784 size_t len
1785 = sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[num].fp_suffix);
1786 gcc_assert (len < sizeof (buf1));
1787 for (unsigned idx = 0; idx < macro->count; idx++)
1788 if (macro->exp.tokens[idx].type == CPP_NUMBER)
1789 {
1790 macro->exp.tokens[idx].val.str.len = len;
1791 macro->exp.tokens[idx].val.str.text
1792 = (const unsigned char *) ggc_strdup (buf1);
1793 return;
1794 }
1795
1796 /* We must have replaced a token. */
1797 gcc_unreachable ();
1798 }
1799
1800 /* Pass an object-like macro a hexadecimal floating-point value. */
1801 static void
builtin_define_with_hex_fp_value(const char * macro,tree type,int digits,const char * hex_str,const char * fp_suffix,const char * fp_cast)1802 builtin_define_with_hex_fp_value (const char *macro,
1803 tree type, int digits,
1804 const char *hex_str,
1805 const char *fp_suffix,
1806 const char *fp_cast)
1807 {
1808 REAL_VALUE_TYPE real;
1809 char dec_str[64], buf[256], buf1[128], buf2[64];
1810
1811 /* This is very expensive, so if possible expand them lazily. */
1812 if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT
1813 && flag_dump_macros == 0
1814 && flag_dump_go_spec == NULL
1815 && !cpp_get_options (parse_in)->traditional)
1816 {
1817 if (lazy_hex_fp_value_count == 0)
1818 cpp_get_callbacks (parse_in)->user_lazy_macro = lazy_hex_fp_value;
1819 sprintf (buf2, fp_cast, "1.1");
1820 sprintf (buf1, "%s=%s", macro, buf2);
1821 cpp_define (parse_in, buf1);
1822 struct cpp_hashnode *node = C_CPP_HASHNODE (get_identifier (macro));
1823 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1824 = ggc_strdup (hex_str);
1825 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1826 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1827 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1828 cpp_define_lazily (parse_in, node, lazy_hex_fp_value_count++);
1829 return;
1830 }
1831
1832 /* Hex values are really cool and convenient, except that they're
1833 not supported in strict ISO C90 mode. First, the "p-" sequence
1834 is not valid as part of a preprocessor number. Second, we get a
1835 pedwarn from the preprocessor, which has no context, so we can't
1836 suppress the warning with __extension__.
1837
1838 So instead what we do is construct the number in hex (because
1839 it's easy to get the exact correct value), parse it as a real,
1840 then print it back out as decimal. */
1841
1842 real_from_string (&real, hex_str);
1843 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1844 TYPE_MODE (type));
1845
1846 /* Assemble the macro in the following fashion
1847 macro = fp_cast [dec_str fp_suffix] */
1848 sprintf (buf2, "%s%s", dec_str, fp_suffix);
1849 sprintf (buf1, fp_cast, buf2);
1850 sprintf (buf, "%s=%s", macro, buf1);
1851
1852 cpp_define (parse_in, buf);
1853 }
1854
1855 /* Return a string constant for the suffix for a value of type TYPE
1856 promoted according to the integer promotions. The type must be one
1857 of the standard integer type nodes. */
1858
1859 static const char *
type_suffix(tree type)1860 type_suffix (tree type)
1861 {
1862 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1863 int unsigned_suffix;
1864 int is_long;
1865 int tp = TYPE_PRECISION (type);
1866
1867 if (type == long_long_integer_type_node
1868 || type == long_long_unsigned_type_node
1869 || tp > TYPE_PRECISION (long_integer_type_node))
1870 is_long = 2;
1871 else if (type == long_integer_type_node
1872 || type == long_unsigned_type_node
1873 || tp > TYPE_PRECISION (integer_type_node))
1874 is_long = 1;
1875 else if (type == integer_type_node
1876 || type == unsigned_type_node
1877 || type == short_integer_type_node
1878 || type == short_unsigned_type_node
1879 || type == signed_char_type_node
1880 || type == unsigned_char_type_node
1881 /* ??? "char" is not a signed or unsigned integer type and
1882 so is not permitted for the standard typedefs, but some
1883 systems use it anyway. */
1884 || type == char_type_node)
1885 is_long = 0;
1886 else
1887 gcc_unreachable ();
1888
1889 unsigned_suffix = TYPE_UNSIGNED (type);
1890 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1891 unsigned_suffix = 0;
1892 return suffixes[is_long * 2 + unsigned_suffix];
1893 }
1894
1895 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1896 static void
builtin_define_constants(const char * macro,tree type)1897 builtin_define_constants (const char *macro, tree type)
1898 {
1899 const char *suffix;
1900 char *buf;
1901
1902 suffix = type_suffix (type);
1903
1904 if (suffix[0] == 0)
1905 {
1906 buf = (char *) alloca (strlen (macro) + 6);
1907 sprintf (buf, "%s(c)=c", macro);
1908 }
1909 else
1910 {
1911 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1912 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1913 }
1914
1915 cpp_define (parse_in, buf);
1916 }
1917
1918 /* Define MAX for TYPE based on the precision of the type. */
1919
1920 static void
builtin_define_type_max(const char * macro,tree type)1921 builtin_define_type_max (const char *macro, tree type)
1922 {
1923 builtin_define_type_minmax (NULL, macro, type);
1924 }
1925
1926 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1927 representation of that value. For example, a COUNT of 10 would
1928 return "0x3ff". */
1929
1930 static void
print_bits_of_hex(char * buf,int bufsz,int count)1931 print_bits_of_hex (char *buf, int bufsz, int count)
1932 {
1933 gcc_assert (bufsz > 3);
1934 *buf++ = '0';
1935 *buf++ = 'x';
1936 bufsz -= 2;
1937
1938 gcc_assert (count > 0);
1939
1940 switch (count % 4) {
1941 case 0:
1942 break;
1943 case 1:
1944 *buf++ = '1';
1945 bufsz --;
1946 count -= 1;
1947 break;
1948 case 2:
1949 *buf++ = '3';
1950 bufsz --;
1951 count -= 2;
1952 break;
1953 case 3:
1954 *buf++ = '7';
1955 bufsz --;
1956 count -= 3;
1957 break;
1958 }
1959 while (count >= 4)
1960 {
1961 gcc_assert (bufsz > 1);
1962 *buf++ = 'f';
1963 bufsz --;
1964 count -= 4;
1965 }
1966 gcc_assert (bufsz > 0);
1967 *buf++ = 0;
1968 }
1969
1970 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1971 precision of the type. */
1972
1973 static void
builtin_define_type_minmax(const char * min_macro,const char * max_macro,tree type)1974 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1975 tree type)
1976 {
1977 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1978 char value[PBOH_SZ];
1979
1980 const char *suffix;
1981 char *buf;
1982 int bits;
1983
1984 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1985
1986 print_bits_of_hex (value, PBOH_SZ, bits);
1987
1988 suffix = type_suffix (type);
1989
1990 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1991 + strlen (suffix) + 1);
1992 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1993
1994 cpp_define (parse_in, buf);
1995
1996 if (min_macro)
1997 {
1998 if (TYPE_UNSIGNED (type))
1999 {
2000 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
2001 sprintf (buf, "%s=0%s", min_macro, suffix);
2002 }
2003 else
2004 {
2005 buf = (char *) alloca (strlen (min_macro) + 3
2006 + strlen (max_macro) + 6);
2007 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
2008 }
2009 cpp_define (parse_in, buf);
2010 }
2011 }
2012
2013 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
2014 both types must have the same width. */
2015
2016 static void
builtin_define_type_width(const char * width_macro,tree type,tree type2)2017 builtin_define_type_width (const char *width_macro, tree type, tree type2)
2018 {
2019 if (type2 != NULL_TREE)
2020 gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
2021 builtin_define_with_int_value (width_macro, TYPE_PRECISION (type));
2022 }
2023
2024 #include "gt-c-family-c-cppbuiltin.h"
2025