1	/* Define builtin-in macros for the C family front ends.
2	Copyright (C) 2002-2023 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	cpp_define (pfile, "__cpp_static_assert=201411L");
1027	cpp_define (pfile, "__cpp_namespace_attributes=201411L");
1028	cpp_define (pfile, "__cpp_enumerator_attributes=201411L");
1029	cpp_define (pfile, "__cpp_nested_namespace_definitions=201411L");
1030	cpp_define (pfile, "__cpp_fold_expressions=201603L");
1031	if (cxx_dialect <= cxx17)
1032	cpp_define (pfile, "__cpp_nontype_template_args=201411L");
1033	cpp_define (pfile, "__cpp_range_based_for=201603L");
1034	if (cxx_dialect <= cxx17)
1035	cpp_define (pfile, "__cpp_constexpr=201603L");
1036	cpp_define (pfile, "__cpp_if_constexpr=201606L");
1037	cpp_define (pfile, "__cpp_capture_star_this=201603L");
1038	cpp_define (pfile, "__cpp_inline_variables=201606L");
1039	cpp_define (pfile, "__cpp_aggregate_bases=201603L");
1040	if (cxx_dialect <= cxx17)
1041	cpp_define (pfile, "__cpp_deduction_guides=201703L");
1042	cpp_define (pfile, "__cpp_noexcept_function_type=201510L");
1043	/* Old macro, superseded by
1044	__cpp_nontype_template_parameter_auto. */
1045	cpp_define (pfile, "__cpp_template_auto=201606L");
1046	cpp_define (pfile, "__cpp_structured_bindings=201606L");
1047	cpp_define (pfile, "__cpp_variadic_using=201611L");
1048	cpp_define (pfile, "__cpp_guaranteed_copy_elision=201606L");
1049	cpp_define (pfile, "__cpp_nontype_template_parameter_auto=201606L");
1050	}
1051	if (cxx_dialect > cxx17)
1052	{
1053	/* Set feature test macros for C++20. */
1054	cpp_define (pfile, "__cpp_init_captures=201803L");
1055	cpp_define (pfile, "__cpp_generic_lambdas=201707L");
1056	cpp_define (pfile, "__cpp_designated_initializers=201707L");
1057	if (cxx_dialect <= cxx20)
1058	cpp_define (pfile, "__cpp_constexpr=202002L");
1059	cpp_define (pfile, "__cpp_constexpr_in_decltype=201711L");
1060	cpp_define (pfile, "__cpp_conditional_explicit=201806L");
1061	cpp_define (pfile, "__cpp_consteval=201811L");
1062	cpp_define (pfile, "__cpp_constinit=201907L");
1063	cpp_define (pfile, "__cpp_deduction_guides=201907L");
1064	cpp_define (pfile, "__cpp_nontype_template_args=201911L");
1065	cpp_define (pfile, "__cpp_nontype_template_parameter_class=201806L");
1066	cpp_define (pfile, "__cpp_impl_destroying_delete=201806L");
1067	cpp_define (pfile, "__cpp_constexpr_dynamic_alloc=201907L");
1068	cpp_define (pfile, "__cpp_impl_three_way_comparison=201907L");
1069	cpp_define (pfile, "__cpp_aggregate_paren_init=201902L");
1070	cpp_define (pfile, "__cpp_using_enum=201907L");
1071	}
1072	if (cxx_dialect > cxx20)
1073	{
1074	/* Set feature test macros for C++23. */
1075	cpp_define (pfile, "__cpp_size_t_suffix=202011L");
1076	cpp_define (pfile, "__cpp_if_consteval=202106L");
1077	cpp_define (pfile, "__cpp_auto_cast=202110L");
1078	if (cxx_dialect <= cxx23)
1079	cpp_define (pfile, "__cpp_constexpr=202211L");
1080	cpp_define (pfile, "__cpp_multidimensional_subscript=202211L");
1081	cpp_define (pfile, "__cpp_named_character_escapes=202207L");
1082	cpp_define (pfile, "__cpp_static_call_operator=202207L");
1083	cpp_define (pfile, "__cpp_implicit_move=202207L");
1084	}
1085	if (cxx_dialect > cxx23)
1086	{
1087	/* Set feature test macros for C++26. */
1088	cpp_define (pfile, "__cpp_constexpr=202306L");
1089	}
1090	if (flag_concepts)
1091	{
1092	if (cxx_dialect >= cxx20 || !flag_concepts_ts)
1093	cpp_define (pfile, "__cpp_concepts=202002L");
1094	else
1095	cpp_define (pfile, "__cpp_concepts=201507L");
1096	}
1097	if (flag_contracts)
1098	{
1099	cpp_define (pfile, "__cpp_contracts=201906L");
1100	cpp_define (pfile, "__cpp_contracts_literal_semantics=201906L");
1101	cpp_define (pfile, "__cpp_contracts_roles=201906L");
1102	}
1103	if (flag_modules)
1104	/* The std-defined value is 201907L, but I don't think we can
1105	claim victory yet. 201810 is the p1103 date. */
1106	cpp_define (pfile, "__cpp_modules=201810L");
1107	if (flag_coroutines)
1108	cpp_define (pfile, "__cpp_impl_coroutine=201902L"); /* n4861, DIS */
1109	if (flag_tm)
1110	/* Use a value smaller than the 201505 specified in
1111	the TS, since we don't yet support atomic_cancel. */
1112	cpp_define (pfile, "__cpp_transactional_memory=201500L");
1113	if (flag_sized_deallocation)
1114	cpp_define (pfile, "__cpp_sized_deallocation=201309L");
1115	if (aligned_new_threshold)
1116	{
1117	cpp_define (pfile, "__cpp_aligned_new=201606L");
1118	cpp_define_formatted (pfile, fmt: "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
1119	aligned_new_threshold);
1120	}
1121	if (flag_new_ttp)
1122	cpp_define (pfile, "__cpp_template_template_args=201611L");
1123	if (flag_threadsafe_statics)
1124	cpp_define (pfile, "__cpp_threadsafe_static_init=200806L");
1125	if (flag_char8_t)
1126	cpp_define (pfile, "__cpp_char8_t=202207L");
1127	#ifndef THREAD_MODEL_SPEC
1128	/* Targets that define THREAD_MODEL_SPEC need to define
1129	__STDCPP_THREADS__ in their config/XXX/XXX-c.c themselves. */
1130	if (cxx_dialect >= cxx11 && strcmp (s1: thread_model, s2: "single") != 0)
1131	cpp_define (pfile, "__STDCPP_THREADS__=1");
1132	#endif
1133	if (flag_implicit_constexpr)
1134	cpp_define (pfile, "__cpp_implicit_constexpr=20211111L");
1135	}
1136	/* Note that we define this for C as well, so that we know if
1137	__attribute__((cleanup)) will interface with EH. */
1138	if (flag_exceptions)
1139	{
1140	cpp_define (pfile, "__EXCEPTIONS");
1141	if (c_dialect_cxx ())
1142	cpp_define (pfile, "__cpp_exceptions=199711L");
1143	}
1144
1145	/* Represents the C++ ABI version, always defined so it can be used while
1146	preprocessing C and assembler. */
1147	if (flag_abi_version == 0)
1148	/* We should have set this to something real in c_common_post_options. */
1149	gcc_unreachable ();
1150	else if (flag_abi_version == 1)
1151	/* Due to a historical accident, this version had the value
1152	"102". */
1153	builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1154	else
1155	/* Newer versions have values 1002, 1003, .... */
1156	builtin_define_with_int_value ("__GXX_ABI_VERSION",
1157	1000 + flag_abi_version);
1158
1159	/* libgcc needs to know this. */
1160	if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1161	cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
1162
1163	/* limits.h and stdint.h need to know these. */
1164	builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
1165	builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
1166	builtin_define_type_max ("__INT_MAX__", integer_type_node);
1167	builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
1168	builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
1169	builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1170	underlying_wchar_type_node);
1171	builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
1172	builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
1173	builtin_define_type_max ("__SIZE_MAX__", size_type_node);
1174
1175	/* These are needed for TS 18661-1. */
1176	builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
1177	unsigned_char_type_node);
1178	builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
1179	short_unsigned_type_node);
1180	builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
1181	unsigned_type_node);
1182	builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
1183	long_unsigned_type_node);
1184	builtin_define_type_width ("__LONG_LONG_WIDTH__",
1185	long_long_integer_type_node,
1186	long_long_unsigned_type_node);
1187	builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
1188	NULL_TREE);
1189	builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
1190	builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
1191	builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
1192
1193	if (!c_dialect_cxx ())
1194	{
1195	struct bitint_info info;
1196	/* For now, restrict __BITINT_MAXWIDTH__ to what can be represented in
1197	wide_int and widest_int. */
1198	if (targetm.c.bitint_type_info (WIDE_INT_MAX_PRECISION - 1, &info))
1199	{
1200	cpp_define_formatted (pfile, fmt: "__BITINT_MAXWIDTH__=%d",
1201	(int) WIDE_INT_MAX_PRECISION - 1);
1202	if (flag_building_libgcc)
1203	{
1204	scalar_int_mode limb_mode
1205	= as_a <scalar_int_mode> (m: info.limb_mode);
1206	cpp_define_formatted (pfile, fmt: "__LIBGCC_BITINT_LIMB_WIDTH__=%d",
1207	(int) GET_MODE_PRECISION (mode: limb_mode));
1208	cpp_define_formatted (pfile, fmt: "__LIBGCC_BITINT_ORDER__=%s",
1209	info.big_endian
1210	? "__ORDER_BIG_ENDIAN__"
1211	: "__ORDER_LITTLE_ENDIAN__");
1212	}
1213	}
1214	}
1215
1216	if (c_dialect_cxx ())
1217	for (i = 0; i < NUM_INT_N_ENTS; i ++)
1218	if (int_n_enabled_p[i])
1219	{
1220	char buf[35+20+20];
1221
1222	/* These are used to configure the C++ library. */
1223
1224	if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
1225	{
1226	sprintf (s: buf, format: "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
1227	cpp_define (parse_in, buf);
1228
1229	sprintf (s: buf, format: "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
1230	cpp_define (parse_in, buf);
1231	}
1232	}
1233
1234	/* stdint.h and the testsuite need to know these. */
1235	builtin_define_stdint_macros ();
1236
1237	/* Provide information for library headers to determine whether to
1238	define macros such as __STDC_IEC_559__ and
1239	__STDC_IEC_559_COMPLEX__. */
1240	builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1241	builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1242	cpp_iec_559_complex_value ());
1243
1244	/* float.h needs these to correctly set FLT_EVAL_METHOD
1245
1246	We define two values:
1247
1248	__FLT_EVAL_METHOD__
1249	Which, depending on the value given for
1250	-fpermitted-flt-eval-methods, may be limited to only those values
1251	for FLT_EVAL_METHOD defined in C99/C11.
1252
1253	__FLT_EVAL_METHOD_TS_18661_3__
1254	Which always permits the values for FLT_EVAL_METHOD defined in
1255	ISO/IEC TS 18661-3. */
1256	builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1257	c_flt_eval_method (ts18661_p: true));
1258	builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1259	c_flt_eval_method (ts18661_p: false));
1260
1261	/* And decfloat.h needs this. */
1262	builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1263	TARGET_DEC_EVAL_METHOD);
1264
1265	builtin_define_float_constants (name_prefix: "FLT", fp_suffix: "F", fp_cast: "%s", fma_suffix: "F", float_type_node);
1266	/* Cast the double precision constants. This is needed when single
1267	precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1268	is used. The correct result is computed by the compiler when using
1269	macros that include a cast. We use a different cast for C++ to avoid
1270	problems with -Wold-style-cast. */
1271	builtin_define_float_constants (name_prefix: "DBL", fp_suffix: "L",
1272	fp_cast: (c_dialect_cxx ()
1273	? "double(%s)"
1274	: "((double)%s)"),
1275	fma_suffix: "", double_type_node);
1276	builtin_define_float_constants (name_prefix: "LDBL", fp_suffix: "L", fp_cast: "%s", fma_suffix: "L",
1277	long_double_type_node);
1278
1279	for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1280	{
1281	if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
1282	continue;
1283	if (c_dialect_cxx ()
1284	&& cxx_dialect > cxx20
1285	&& !floatn_nx_types[i].extended)
1286	{
1287	char name[sizeof ("__STDCPP_FLOAT128_T__=1")];
1288	sprintf (s: name, format: "__STDCPP_FLOAT%d_T__=1", floatn_nx_types[i].n);
1289	cpp_define (pfile, name);
1290	}
1291	char prefix[20], csuffix[20];
1292	sprintf (s: prefix, format: "FLT%d%s", floatn_nx_types[i].n,
1293	floatn_nx_types[i].extended ? "X" : "");
1294	sprintf (s: csuffix, format: "F%d%s", floatn_nx_types[i].n,
1295	floatn_nx_types[i].extended ? "x" : "");
1296	builtin_define_float_constants (name_prefix: prefix, ggc_strdup (csuffix), fp_cast: "%s",
1297	fma_suffix: csuffix, FLOATN_NX_TYPE_NODE (i));
1298	}
1299	if (bfloat16_type_node)
1300	{
1301	if (c_dialect_cxx () && cxx_dialect > cxx20)
1302	cpp_define (pfile, "__STDCPP_BFLOAT16_T__=1");
1303	builtin_define_float_constants (name_prefix: "BFLT16", fp_suffix: "BF16", fp_cast: "%s",
1304	fma_suffix: "BF16", bfloat16_type_node);
1305	}
1306
1307	/* For float.h. */
1308	if (targetm.decimal_float_supported_p ())
1309	{
1310	builtin_define_decimal_float_constants (name_prefix: "DEC32", suffix: "DF",
1311	dfloat32_type_node);
1312	builtin_define_decimal_float_constants (name_prefix: "DEC64", suffix: "DD",
1313	dfloat64_type_node);
1314	builtin_define_decimal_float_constants (name_prefix: "DEC128", suffix: "DL",
1315	dfloat128_type_node);
1316	}
1317
1318	/* For fixed-point fibt, ibit, max, min, and epsilon. */
1319	if (targetm.fixed_point_supported_p ())
1320	{
1321	builtin_define_fixed_point_constants (name_prefix: "SFRACT", suffix: "HR",
1322	short_fract_type_node);
1323	builtin_define_fixed_point_constants (name_prefix: "USFRACT", suffix: "UHR",
1324	unsigned_short_fract_type_node);
1325	builtin_define_fixed_point_constants (name_prefix: "FRACT", suffix: "R",
1326	fract_type_node);
1327	builtin_define_fixed_point_constants (name_prefix: "UFRACT", suffix: "UR",
1328	unsigned_fract_type_node);
1329	builtin_define_fixed_point_constants (name_prefix: "LFRACT", suffix: "LR",
1330	long_fract_type_node);
1331	builtin_define_fixed_point_constants (name_prefix: "ULFRACT", suffix: "ULR",
1332	unsigned_long_fract_type_node);
1333	builtin_define_fixed_point_constants (name_prefix: "LLFRACT", suffix: "LLR",
1334	long_long_fract_type_node);
1335	builtin_define_fixed_point_constants (name_prefix: "ULLFRACT", suffix: "ULLR",
1336	unsigned_long_long_fract_type_node);
1337	builtin_define_fixed_point_constants (name_prefix: "SACCUM", suffix: "HK",
1338	short_accum_type_node);
1339	builtin_define_fixed_point_constants (name_prefix: "USACCUM", suffix: "UHK",
1340	unsigned_short_accum_type_node);
1341	builtin_define_fixed_point_constants (name_prefix: "ACCUM", suffix: "K",
1342	accum_type_node);
1343	builtin_define_fixed_point_constants (name_prefix: "UACCUM", suffix: "UK",
1344	unsigned_accum_type_node);
1345	builtin_define_fixed_point_constants (name_prefix: "LACCUM", suffix: "LK",
1346	long_accum_type_node);
1347	builtin_define_fixed_point_constants (name_prefix: "ULACCUM", suffix: "ULK",
1348	unsigned_long_accum_type_node);
1349	builtin_define_fixed_point_constants (name_prefix: "LLACCUM", suffix: "LLK",
1350	long_long_accum_type_node);
1351	builtin_define_fixed_point_constants (name_prefix: "ULLACCUM", suffix: "ULLK",
1352	unsigned_long_long_accum_type_node);
1353
1354	builtin_define_fixed_point_constants (name_prefix: "QQ", suffix: "", qq_type_node);
1355	builtin_define_fixed_point_constants (name_prefix: "HQ", suffix: "", hq_type_node);
1356	builtin_define_fixed_point_constants (name_prefix: "SQ", suffix: "", sq_type_node);
1357	builtin_define_fixed_point_constants (name_prefix: "DQ", suffix: "", dq_type_node);
1358	builtin_define_fixed_point_constants (name_prefix: "TQ", suffix: "", tq_type_node);
1359	builtin_define_fixed_point_constants (name_prefix: "UQQ", suffix: "", uqq_type_node);
1360	builtin_define_fixed_point_constants (name_prefix: "UHQ", suffix: "", uhq_type_node);
1361	builtin_define_fixed_point_constants (name_prefix: "USQ", suffix: "", usq_type_node);
1362	builtin_define_fixed_point_constants (name_prefix: "UDQ", suffix: "", udq_type_node);
1363	builtin_define_fixed_point_constants (name_prefix: "UTQ", suffix: "", utq_type_node);
1364	builtin_define_fixed_point_constants (name_prefix: "HA", suffix: "", ha_type_node);
1365	builtin_define_fixed_point_constants (name_prefix: "SA", suffix: "", sa_type_node);
1366	builtin_define_fixed_point_constants (name_prefix: "DA", suffix: "", da_type_node);
1367	builtin_define_fixed_point_constants (name_prefix: "TA", suffix: "", ta_type_node);
1368	builtin_define_fixed_point_constants (name_prefix: "UHA", suffix: "", uha_type_node);
1369	builtin_define_fixed_point_constants (name_prefix: "USA", suffix: "", usa_type_node);
1370	builtin_define_fixed_point_constants (name_prefix: "UDA", suffix: "", uda_type_node);
1371	builtin_define_fixed_point_constants (name_prefix: "UTA", suffix: "", uta_type_node);
1372	}
1373
1374	/* For libgcc-internal use only. */
1375	if (flag_building_libgcc)
1376	{
1377	/* Properties of floating-point modes for libgcc2.c. */
1378	opt_scalar_float_mode mode_iter;
1379	FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
1380	{
1381	scalar_float_mode mode = mode_iter.require ();
1382	const char *name = GET_MODE_NAME (mode);
1383	const size_t name_len = strlen (s: name);
1384	char float_h_prefix[16] = "";
1385	char *macro_name
1386	= XALLOCAVEC (char, name_len + sizeof ("__LIBGCC__MANT_DIG__"));
1387	sprintf (s: macro_name, format: "__LIBGCC_%s_MANT_DIG__", name);
1388	builtin_define_with_int_value (macro_name,
1389	REAL_MODE_FORMAT (mode)->p);
1390	if (!targetm.scalar_mode_supported_p (mode)
1391	|| !targetm.libgcc_floating_mode_supported_p (mode))
1392	continue;
1393	macro_name = XALLOCAVEC (char, name_len
1394	+ sizeof ("__LIBGCC_HAS__MODE__"));
1395	sprintf (s: macro_name, format: "__LIBGCC_HAS_%s_MODE__", name);
1396	cpp_define (pfile, macro_name);
1397	macro_name = XALLOCAVEC (char, name_len
1398	+ sizeof ("__LIBGCC__FUNC_EXT__"));
1399	sprintf (s: macro_name, format: "__LIBGCC_%s_FUNC_EXT__", name);
1400	char suffix[20] = "";
1401	if (mode == TYPE_MODE (double_type_node))
1402	{
1403	/* Empty suffix correct. */
1404	memcpy (dest: float_h_prefix, src: "DBL", n: 4);
1405	}
1406	else if (mode == TYPE_MODE (float_type_node))
1407	{
1408	suffix[0] = 'f';
1409	memcpy (dest: float_h_prefix, src: "FLT", n: 4);
1410	}
1411	else if (mode == TYPE_MODE (long_double_type_node))
1412	{
1413	suffix[0] = 'l';
1414	memcpy (dest: float_h_prefix, src: "LDBL", n: 5);
1415	}
1416	else if (bfloat16_type_node
1417	&& mode == TYPE_MODE (bfloat16_type_node))
1418	{
1419	memcpy (dest: suffix, src: "bf16", n: 5);
1420	memcpy (dest: float_h_prefix, src: "BFLT16", n: 7);
1421	}
1422	else
1423	{
1424	bool found_suffix = false;
1425	for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1426	if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
1427	&& mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
1428	{
1429	sprintf (s: suffix, format: "f%d%s", floatn_nx_types[i].n,
1430	floatn_nx_types[i].extended ? "x" : "");
1431	found_suffix = true;
1432	sprintf (s: float_h_prefix, format: "FLT%d%s", floatn_nx_types[i].n,
1433	floatn_nx_types[i].extended ? "X" : "");
1434	break;
1435	}
1436	gcc_assert (found_suffix);
1437	}
1438	builtin_define_with_value (macro_name, suffix, 0);
1439
1440	/* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1441	eliminating excess precision from results assigned to
1442	variables - meaning it should be about the implicit excess
1443	precision only. */
1444	bool excess_precision = false;
1445	machine_mode float16_type_mode = (float16_type_node
1446	? TYPE_MODE (float16_type_node)
1447	: VOIDmode);
1448	machine_mode bfloat16_type_mode = (bfloat16_type_node
1449	? TYPE_MODE (bfloat16_type_node)
1450	: VOIDmode);
1451	switch (targetm.c.excess_precision
1452	(EXCESS_PRECISION_TYPE_IMPLICIT))
1453	{
1454	case FLT_EVAL_METHOD_UNPREDICTABLE:
1455	case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
1456	excess_precision = (mode == float16_type_mode
1457	|| mode == bfloat16_type_mode
1458	|| mode == TYPE_MODE (float_type_node)
1459	|| mode == TYPE_MODE (double_type_node));
1460	break;
1461
1462	case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
1463	excess_precision = (mode == float16_type_mode
1464	|| mode == bfloat16_type_mode
1465	|| mode == TYPE_MODE (float_type_node));
1466	break;
1467	case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
1468	excess_precision = (mode == float16_type_mode
1469	|| mode == bfloat16_type_mode);
1470	break;
1471	case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
1472	excess_precision = false;
1473	break;
1474	default:
1475	gcc_unreachable ();
1476	}
1477	macro_name = XALLOCAVEC (char, name_len
1478	+ sizeof ("__LIBGCC__EXCESS_PRECISION__"));
1479	sprintf (s: macro_name, format: "__LIBGCC_%s_EXCESS_PRECISION__", name);
1480	builtin_define_with_int_value (macro_name, excess_precision);
1481
1482	char val_name[64];
1483
1484	macro_name = XALLOCAVEC (char, name_len
1485	+ sizeof ("__LIBGCC__EPSILON__"));
1486	sprintf (s: macro_name, format: "__LIBGCC_%s_EPSILON__", name);
1487	sprintf (s: val_name, format: "__%s_EPSILON__", float_h_prefix);
1488	builtin_define_with_value (macro_name, val_name, 0);
1489
1490	macro_name = XALLOCAVEC (char, name_len + sizeof ("__LIBGCC__MAX__"));
1491	sprintf (s: macro_name, format: "__LIBGCC_%s_MAX__", name);
1492	sprintf (s: val_name, format: "__%s_MAX__", float_h_prefix);
1493	builtin_define_with_value (macro_name, val_name, 0);
1494
1495	macro_name = XALLOCAVEC (char, name_len + sizeof ("__LIBGCC__MIN__"));
1496	sprintf (s: macro_name, format: "__LIBGCC_%s_MIN__", name);
1497	sprintf (s: val_name, format: "__%s_MIN__", float_h_prefix);
1498	builtin_define_with_value (macro_name, val_name, 0);
1499
1500	#ifdef HAVE_adddf3
1501	builtin_define_with_int_value ("__LIBGCC_HAVE_HWDBL__",
1502	HAVE_adddf3);
1503	#endif
1504	}
1505
1506	/* For libgcc crtstuff.c and libgcc2.c. */
1507	builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1508	EH_TABLES_CAN_BE_READ_ONLY);
1509	#ifdef EH_FRAME_SECTION_NAME
1510	builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1511	EH_FRAME_SECTION_NAME, 1);
1512	#endif
1513	#ifdef CTORS_SECTION_ASM_OP
1514	builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1515	CTORS_SECTION_ASM_OP, 1);
1516	#endif
1517	#ifdef DTORS_SECTION_ASM_OP
1518	builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1519	DTORS_SECTION_ASM_OP, 1);
1520	#endif
1521	#ifdef TEXT_SECTION_ASM_OP
1522	builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1523	TEXT_SECTION_ASM_OP, 1);
1524	#endif
1525	#ifdef INIT_SECTION_ASM_OP
1526	builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1527	INIT_SECTION_ASM_OP, 1);
1528	#endif
1529	#ifdef INIT_ARRAY_SECTION_ASM_OP
1530	/* Despite the name of this target macro, the expansion is not
1531	actually used, and may be empty rather than a string
1532	constant. */
1533	cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1534	#endif
1535
1536	/* For libgcc enable-execute-stack.c. */
1537	builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1538	TRAMPOLINE_SIZE);
1539
1540	/* For libgcc generic-morestack.c and unwinder code. */
1541	if (STACK_GROWS_DOWNWARD)
1542	cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1543
1544	/* For libgcc unwinder code. */
1545	#ifdef DONT_USE_BUILTIN_SETJMP
1546	cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1547	#endif
1548	#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1549	builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1550	DWARF_ALT_FRAME_RETURN_COLUMN);
1551	#endif
1552	builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1553	DWARF_FRAME_REGISTERS);
1554	builtin_define_with_int_value ("__LIBGCC_DWARF_CIE_DATA_ALIGNMENT__",
1555	DWARF_CIE_DATA_ALIGNMENT);
1556
1557	#ifdef EH_RETURN_STACKADJ_RTX
1558	cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1559	#endif
1560	#ifdef JMP_BUF_SIZE
1561	builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1562	JMP_BUF_SIZE);
1563	#endif
1564	builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1565	STACK_POINTER_REGNUM);
1566
1567	/* For libgcov. */
1568	builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1569	TARGET_VTABLE_USES_DESCRIPTORS);
1570	builtin_define_with_int_value ("__LIBGCC_GCOV_TYPE_SIZE",
1571	targetm.gcov_type_size());
1572	}
1573
1574	/* For use in assembly language. */
1575	builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1576	builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1577
1578	/* Misc. */
1579	if (flag_gnu89_inline)
1580	cpp_define (pfile, "__GNUC_GNU_INLINE__");
1581	else
1582	cpp_define (pfile, "__GNUC_STDC_INLINE__");
1583
1584	if (flag_no_inline)
1585	cpp_define (pfile, "__NO_INLINE__");
1586
1587	if (flag_iso)
1588	cpp_define (pfile, "__STRICT_ANSI__");
1589
1590	if (!flag_signed_char)
1591	cpp_define (pfile, "__CHAR_UNSIGNED__");
1592
1593	if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1594	cpp_define (pfile, "__WCHAR_UNSIGNED__");
1595
1596	cpp_atomic_builtins (pfile);
1597
1598	/* Show support for __builtin_speculation_safe_value () if the target
1599	has been updated to fully support it. */
1600	if (targetm.have_speculation_safe_value (false))
1601	cpp_define (pfile, "__HAVE_SPECULATION_SAFE_VALUE");
1602
1603	#ifdef DWARF2_UNWIND_INFO
1604	if (dwarf2out_do_cfi_asm ())
1605	cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1606	#endif
1607
1608	/* Make the choice of ObjC runtime visible to source code. */
1609	if (c_dialect_objc () && flag_next_runtime)
1610	cpp_define (pfile, "__NEXT_RUNTIME__");
1611
1612	/* Show the availability of some target pragmas. */
1613	cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1614
1615	/* Make the choice of the stack protector runtime visible to source code.
1616	The macro names and values here were chosen for compatibility with an
1617	earlier implementation, i.e. ProPolice. */
1618	if (flag_stack_protect == SPCT_FLAG_EXPLICIT)
1619	cpp_define (pfile, "__SSP_EXPLICIT__=4");
1620	if (flag_stack_protect == SPCT_FLAG_STRONG)
1621	cpp_define (pfile, "__SSP_STRONG__=3");
1622	if (flag_stack_protect == SPCT_FLAG_ALL)
1623	cpp_define (pfile, "__SSP_ALL__=2");
1624	else if (flag_stack_protect == SPCT_FLAG_DEFAULT)
1625	cpp_define (pfile, "__SSP__=1");
1626
1627	if (flag_openacc)
1628	cpp_define (pfile, "_OPENACC=201711");
1629
1630	if (flag_openmp)
1631	cpp_define (pfile, "_OPENMP=201511");
1632
1633	for (i = 0; i < NUM_INT_N_ENTS; i ++)
1634	if (int_n_enabled_p[i])
1635	{
1636	char buf[15+20];
1637	sprintf(s: buf, format: "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1638	builtin_define_type_sizeof (name: buf,
1639	type: int_n_trees[i].signed_type);
1640	}
1641	builtin_define_type_sizeof (name: "__SIZEOF_WCHAR_T__", wchar_type_node);
1642	builtin_define_type_sizeof (name: "__SIZEOF_WINT_T__", wint_type_node);
1643	builtin_define_type_sizeof (name: "__SIZEOF_PTRDIFF_T__",
1644	unsigned_ptrdiff_type_node);
1645
1646	/* A straightforward target hook doesn't work, because of problems
1647	linking that hook's body when part of non-C front ends. */
1648	# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1649	# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1650	# define builtin_define(TXT) cpp_define (pfile, TXT)
1651	# define builtin_assert(TXT) cpp_assert (pfile, TXT)
1652	TARGET_CPU_CPP_BUILTINS ();
1653	TARGET_OS_CPP_BUILTINS ();
1654	TARGET_OBJFMT_CPP_BUILTINS ();
1655
1656	/* Support the __declspec keyword by turning them into attributes.
1657	Note that the current way we do this may result in a collision
1658	with predefined attributes later on. This can be solved by using
1659	one attribute, say __declspec__, and passing args to it. The
1660	problem with that approach is that args are not accumulated: each
1661	new appearance would clobber any existing args. */
1662	if (TARGET_DECLSPEC)
1663	builtin_define ("__declspec(x)=__attribute__((x))");
1664
1665	/* If decimal floating point is supported, tell the user if the
1666	alternate format (BID) is used instead of the standard (DPD)
1667	format. */
1668	if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1669	cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1670	}
1671
1672	/* Pass an object-like macro. If it doesn't lie in the user's
1673	namespace, defines it unconditionally. Otherwise define a version
1674	with two leading underscores, and another version with two leading
1675	and trailing underscores, and define the original only if an ISO
1676	standard was not nominated.
1677
1678	e.g. passing "unix" defines "__unix", "__unix__" and possibly
1679	"unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1680	"_mips". */
1681	void
1682	builtin_define_std (const char *macro)
1683	{
1684	size_t len = strlen (s: macro);
1685	char *buff = (char *) alloca (len + 5);
1686	char *p = buff + 2;
1687	char *q = p + len;
1688
1689	/* prepend __ (or maybe just _) if in user's namespace. */
1690	memcpy (dest: p, src: macro, n: len + 1);
1691	if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1692	{
1693	if (*p != '_')
1694	*--p = '_';
1695	if (p[1] != '_')
1696	*--p = '_';
1697	}
1698	cpp_define (parse_in, p);
1699
1700	/* If it was in user's namespace... */
1701	if (p != buff + 2)
1702	{
1703	/* Define the macro with leading and following __. */
1704	if (q[-1] != '_')
1705	*q++ = '_';
1706	if (q[-2] != '_')
1707	*q++ = '_';
1708	*q = '\0';
1709	cpp_define (parse_in, p);
1710
1711	/* Finally, define the original macro if permitted. */
1712	if (!flag_iso)
1713	cpp_define (parse_in, macro);
1714	}
1715	}
1716
1717	/* Pass an object-like macro and a value to define it to. The third
1718	parameter says whether or not to turn the value into a string
1719	constant. */
1720	void
1721	builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1722	{
1723	char *buf;
1724	size_t mlen = strlen (s: macro);
1725	size_t elen = strlen (s: expansion);
1726	size_t extra = 2; /* space for an = and a NUL */
1727
1728	if (is_str)
1729	{
1730	char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1731	const char *p;
1732	char *q;
1733	extra += 2; /* space for two quote marks */
1734	for (p = expansion, q = quoted_expansion; *p; p++)
1735	{
1736	switch (*p)
1737	{
1738	case '\n':
1739	*q++ = '\\';
1740	*q++ = 'n';
1741	break;
1742
1743	case '\t':
1744	*q++ = '\\';
1745	*q++ = 't';
1746	break;
1747
1748	case '\\':
1749	*q++ = '\\';
1750	*q++ = '\\';
1751	break;
1752
1753	case '"':
1754	*q++ = '\\';
1755	*q++ = '"';
1756	break;
1757
1758	default:
1759	if (ISPRINT ((unsigned char) *p))
1760	*q++ = *p;
1761	else
1762	{
1763	sprintf (s: q, format: "\\%03o", (unsigned char) *p);
1764	q += 4;
1765	}
1766	}
1767	}
1768	*q = '\0';
1769	expansion = quoted_expansion;
1770	elen = q - expansion;
1771	}
1772
1773	buf = (char *) alloca (mlen + elen + extra);
1774	if (is_str)
1775	sprintf (s: buf, format: "%s=\"%s\"", macro, expansion);
1776	else
1777	sprintf (s: buf, format: "%s=%s", macro, expansion);
1778
1779	cpp_define (parse_in, buf);
1780	}
1781
1782
1783	/* Pass an object-like macro and an integer value to define it to. */
1784	void
1785	builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1786	{
1787	char *buf;
1788	size_t mlen = strlen (s: macro);
1789	size_t vlen = 18;
1790	size_t extra = 2; /* space for = and NUL. */
1791
1792	buf = (char *) alloca (mlen + vlen + extra);
1793	memcpy (dest: buf, src: macro, n: mlen);
1794	buf[mlen] = '=';
1795	sprintf (s: buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1796
1797	cpp_define (parse_in, buf);
1798	}
1799
1800	/* builtin_define_with_hex_fp_value is very expensive, so the following
1801	array and function allows it to be done lazily when __DBL_MAX__
1802	etc. is first used. */
1803
1804	struct GTY(()) lazy_hex_fp_value_struct
1805	{
1806	const char *hex_str;
1807	machine_mode mode;
1808	int digits;
1809	const char *fp_suffix;
1810	};
1811	/* Number of the expensive to compute macros we should evaluate lazily.
1812	Each builtin_define_float_constants invocation calls
1813	builtin_define_with_hex_fp_value 5 times and builtin_define_float_constants
1814	is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1815	FLTNN*. */
1816	#define LAZY_HEX_FP_VALUES_CNT (5 * (3 + NUM_FLOATN_NX_TYPES))
1817	static GTY(()) struct lazy_hex_fp_value_struct
1818	lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT];
1819	static GTY(()) unsigned lazy_hex_fp_value_count;
1820
1821	static void
1822	lazy_hex_fp_value (cpp_reader *, cpp_macro *macro, unsigned num)
1823	{
1824	REAL_VALUE_TYPE real;
1825	char dec_str[64], buf1[256];
1826
1827	gcc_checking_assert (num < lazy_hex_fp_value_count);
1828
1829	real_from_string (&real, lazy_hex_fp_values[num].hex_str);
1830	real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1831	lazy_hex_fp_values[num].digits, 0,
1832	lazy_hex_fp_values[num].mode);
1833
1834	size_t len
1835	= sprintf (s: buf1, format: "%s%s", dec_str, lazy_hex_fp_values[num].fp_suffix);
1836	gcc_assert (len < sizeof (buf1));
1837	for (unsigned idx = 0; idx < macro->count; idx++)
1838	if (macro->exp.tokens[idx].type == CPP_NUMBER)
1839	{
1840	macro->exp.tokens[idx].val.str.len = len;
1841	macro->exp.tokens[idx].val.str.text
1842	= (const unsigned char *) ggc_strdup (buf1);
1843	return;
1844	}
1845
1846	/* We must have replaced a token. */
1847	gcc_unreachable ();
1848	}
1849
1850	/* Pass an object-like macro a hexadecimal floating-point value. */
1851	static void
1852	builtin_define_with_hex_fp_value (const char *macro,
1853	tree type, int digits,
1854	const char *hex_str,
1855	const char *fp_suffix,
1856	const char *fp_cast)
1857	{
1858	REAL_VALUE_TYPE real;
1859	char dec_str[64], buf[256], buf1[128], buf2[64];
1860
1861	/* This is very expensive, so if possible expand them lazily. */
1862	if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT
1863	&& flag_dump_macros == 0
1864	&& flag_dump_go_spec == NULL
1865	&& !cpp_get_options (parse_in)->traditional)
1866	{
1867	if (lazy_hex_fp_value_count == 0)
1868	cpp_get_callbacks (parse_in)->user_lazy_macro = lazy_hex_fp_value;
1869	sprintf (s: buf2, format: fp_cast, "1.1");
1870	sprintf (s: buf1, format: "%s=%s", macro, buf2);
1871	cpp_define (parse_in, buf1);
1872	struct cpp_hashnode *node = C_CPP_HASHNODE (get_identifier (macro));
1873	lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1874	= ggc_strdup (hex_str);
1875	lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1876	lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1877	lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1878	cpp_define_lazily (parse_in, node, N: lazy_hex_fp_value_count++);
1879	return;
1880	}
1881
1882	/* Hex values are really cool and convenient, except that they're
1883	not supported in strict ISO C90 mode. First, the "p-" sequence
1884	is not valid as part of a preprocessor number. Second, we get a
1885	pedwarn from the preprocessor, which has no context, so we can't
1886	suppress the warning with __extension__.
1887
1888	So instead what we do is construct the number in hex (because
1889	it's easy to get the exact correct value), parse it as a real,
1890	then print it back out as decimal. */
1891
1892	real_from_string (&real, hex_str);
1893	real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1894	TYPE_MODE (type));
1895
1896	/* Assemble the macro in the following fashion
1897	macro = fp_cast [dec_str fp_suffix] */
1898	sprintf (s: buf2, format: "%s%s", dec_str, fp_suffix);
1899	sprintf (s: buf1, format: fp_cast, buf2);
1900	sprintf (s: buf, format: "%s=%s", macro, buf1);
1901
1902	cpp_define (parse_in, buf);
1903	}
1904
1905	/* Return a string constant for the suffix for a value of type TYPE
1906	promoted according to the integer promotions. The type must be one
1907	of the standard integer type nodes. */
1908
1909	static const char *
1910	type_suffix (tree type)
1911	{
1912	static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1913	int unsigned_suffix;
1914	int is_long;
1915	int tp = TYPE_PRECISION (type);
1916
1917	if (type == long_long_integer_type_node
1918	|| type == long_long_unsigned_type_node
1919	|| tp > TYPE_PRECISION (long_integer_type_node))
1920	is_long = 2;
1921	else if (type == long_integer_type_node
1922	|| type == long_unsigned_type_node
1923	|| tp > TYPE_PRECISION (integer_type_node))
1924	is_long = 1;
1925	else if (type == integer_type_node
1926	|| type == unsigned_type_node
1927	|| type == short_integer_type_node
1928	|| type == short_unsigned_type_node
1929	|| type == signed_char_type_node
1930	|| type == unsigned_char_type_node
1931	/* ??? "char" is not a signed or unsigned integer type and
1932	so is not permitted for the standard typedefs, but some
1933	systems use it anyway. */
1934	|| type == char_type_node)
1935	is_long = 0;
1936	else if (type == wchar_type_node)
1937	return type_suffix (underlying_wchar_type_node);
1938	else
1939	gcc_unreachable ();
1940
1941	unsigned_suffix = TYPE_UNSIGNED (type);
1942	if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1943	unsigned_suffix = 0;
1944	return suffixes[is_long * 2 + unsigned_suffix];
1945	}
1946
1947	/* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1948	static void
1949	builtin_define_constants (const char *macro, tree type)
1950	{
1951	const char *suffix;
1952	char *buf;
1953
1954	suffix = type_suffix (type);
1955
1956	if (suffix[0] == 0)
1957	{
1958	buf = (char *) alloca (strlen (macro) + 6);
1959	sprintf (s: buf, format: "%s(c)=c", macro);
1960	}
1961	else
1962	{
1963	buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1964	sprintf (s: buf, format: "%s(c)=c ## %s", macro, suffix);
1965	}
1966
1967	cpp_define (parse_in, buf);
1968	}
1969
1970	/* Define MAX for TYPE based on the precision of the type. */
1971
1972	static void
1973	builtin_define_type_max (const char *macro, tree type)
1974	{
1975	builtin_define_type_minmax (NULL, macro, type);
1976	}
1977
1978	/* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1979	representation of that value. For example, a COUNT of 10 would
1980	return "0x3ff". */
1981
1982	static void
1983	print_bits_of_hex (char *buf, int bufsz, int count)
1984	{
1985	gcc_assert (bufsz > 3);
1986	*buf++ = '0';
1987	*buf++ = 'x';
1988	bufsz -= 2;
1989
1990	gcc_assert (count > 0);
1991
1992	switch (count % 4) {
1993	case 0:
1994	break;
1995	case 1:
1996	*buf++ = '1';
1997	bufsz --;
1998	count -= 1;
1999	break;
2000	case 2:
2001	*buf++ = '3';
2002	bufsz --;
2003	count -= 2;
2004	break;
2005	case 3:
2006	*buf++ = '7';
2007	bufsz --;
2008	count -= 3;
2009	break;
2010	}
2011	while (count >= 4)
2012	{
2013	gcc_assert (bufsz > 1);
2014	*buf++ = 'f';
2015	bufsz --;
2016	count -= 4;
2017	}
2018	gcc_assert (bufsz > 0);
2019	*buf++ = 0;
2020	}
2021
2022	/* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
2023	precision of the type. */
2024
2025	static void
2026	builtin_define_type_minmax (const char *min_macro, const char *max_macro,
2027	tree type)
2028	{
2029	#define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
2030	char value[PBOH_SZ];
2031
2032	const char *suffix;
2033	char *buf;
2034	int bits;
2035
2036	bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
2037
2038	print_bits_of_hex (buf: value, PBOH_SZ, count: bits);
2039
2040	suffix = type_suffix (type);
2041
2042	buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
2043	+ strlen (suffix) + 1);
2044	sprintf (s: buf, format: "%s=%s%s", max_macro, value, suffix);
2045
2046	cpp_define (parse_in, buf);
2047
2048	if (min_macro)
2049	{
2050	if (TYPE_UNSIGNED (type))
2051	{
2052	buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
2053	sprintf (s: buf, format: "%s=0%s", min_macro, suffix);
2054	}
2055	else
2056	{
2057	buf = (char *) alloca (strlen (min_macro) + 3
2058	+ strlen (max_macro) + 6);
2059	sprintf (s: buf, format: "%s=(-%s - 1)", min_macro, max_macro);
2060	}
2061	cpp_define (parse_in, buf);
2062	}
2063	}
2064
2065	/* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
2066	both types must have the same width. */
2067
2068	static void
2069	builtin_define_type_width (const char *width_macro, tree type, tree type2)
2070	{
2071	if (type2 != NULL_TREE)
2072	gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
2073	builtin_define_with_int_value (macro: width_macro, TYPE_PRECISION (type));
2074	}
2075
2076	#include "gt-c-family-c-cppbuiltin.h"
2077