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