1	/* Definitions for c-common.cc.
2	Copyright (C) 1987-2026 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	#ifndef GCC_C_COMMON_H
21	#define GCC_C_COMMON_H
22
23	#include "splay-tree.h"
24	#include "cpplib.h"
25	#include "alias.h"
26	#include "tree.h"
27	#include "fold-const.h"
28	#include "wide-int-bitmask.h"
29
30	/* In order for the format checking to accept the C frontend
31	diagnostic framework extensions, you must include this file before
32	diagnostic-core.h, not after. The C front end formats are a subset of those
33	for C++, so they are the appropriate set to use in common code;
34	cp-tree.h overrides this for C++. */
35	#if defined(GCC_DIAGNOSTIC_CORE_H)
36	#error \
37	In order for the format checking to accept the C front end diagnostic \
38	framework extensions, you must include this file before diagnostic-core.h \
39	never after.
40	#endif
41	#ifndef GCC_DIAG_STYLE
42	#define GCC_DIAG_STYLE __gcc_cdiag__
43	#endif
44	#include "diagnostic-core.h"
45
46	/* Usage of TREE_LANG_FLAG_?:
47	0: IDENTIFIER_MARKED (used by search routines).
48	C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C)
49	1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
50	STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)
51	C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C)
52	2: unused
53	3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)
54	4: unused
55	*/
56
57	/* Reserved identifiers. This is the union of all the keywords for C,
58	C++, and Objective-C. All the type modifiers have to be in one
59	block at the beginning, because they are used as mask bits. There
60	are 28 type modifiers; if we add many more we will have to redesign
61	the mask mechanism. */
62
63	enum rid
64	{
65	/* Modifiers: */
66	/* C, in empirical order of frequency. */
67	RID_STATIC = 0,
68	RID_UNSIGNED, RID_LONG, RID_CONST, RID_EXTERN,
69	RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,
70	RID_VOLATILE, RID_SIGNED, RID_AUTO, RID_RESTRICT,
71	RID_NORETURN, RID_ATOMIC,
72
73	/* C extensions */
74	RID_COMPLEX, RID_THREAD, RID_SAT,
75
76	/* C++ */
77	RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
78
79	/* ObjC ("PQ" reserved words - they do not appear after a '@' and
80	are keywords only in specific contexts) */
81	RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,
82
83	/* ObjC ("PATTR" reserved words - they do not appear after a '@'
84	and are keywords only as property attributes) */
85	RID_GETTER, RID_SETTER,
86	RID_READONLY, RID_READWRITE,
87	RID_ASSIGN, RID_RETAIN, RID_COPY,
88	RID_PROPATOMIC, RID_NONATOMIC,
89
90	/* ObjC nullability support keywords that also can appear in the
91	property attribute context. These values should remain contiguous
92	with the other property attributes. */
93	RID_NULL_UNSPECIFIED, RID_NULLABLE, RID_NONNULL, RID_NULL_RESETTABLE,
94
95	/* C (reserved and imaginary types not implemented, so any use is a
96	syntax error) */
97	RID_IMAGINARY,
98
99	/* C */
100	RID_INT, RID_CHAR, RID_FLOAT, RID_DOUBLE, RID_VOID,
101	RID_ENUM, RID_STRUCT, RID_UNION, RID_IF, RID_ELSE,
102	RID_WHILE, RID_DO, RID_FOR, RID_SWITCH, RID_CASE,
103	RID_DEFAULT, RID_BREAK, RID_CONTINUE, RID_RETURN, RID_GOTO,
104	RID_SIZEOF, RID_BITINT,
105
106	/* C extensions */
107	RID_ASM, RID_TYPEOF, RID_TYPEOF_UNQUAL, RID_ALIGNOF, RID_ATTRIBUTE,
108	RID_COUNTOF, RID_MAXOF, RID_MINOF,
109	RID_C23_VA_START, RID_VA_ARG,
110	RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL, RID_CHOOSE_EXPR,
111	RID_TYPES_COMPATIBLE_P, RID_BUILTIN_COMPLEX, RID_BUILTIN_SHUFFLE,
112	RID_BUILTIN_SHUFFLEVECTOR, RID_BUILTIN_CONVERTVECTOR, RID_BUILTIN_TGMATH,
113	RID_BUILTIN_HAS_ATTRIBUTE, RID_BUILTIN_ASSOC_BARRIER, RID_BUILTIN_STDC,
114	RID_BUILTIN_COUNTED_BY_REF,
115	RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128, RID_DFLOAT64X,
116
117	/* TS 18661-3 keywords, in the same sequence as the TI_* values. */
118	RID_FLOAT16,
119	RID_FLOATN_NX_FIRST = RID_FLOAT16,
120	RID_FLOAT32,
121	RID_FLOAT64,
122	RID_FLOAT128,
123	RID_FLOAT32X,
124	RID_FLOAT64X,
125	RID_FLOAT128X,
126	#define CASE_RID_FLOATN_NX \
127	case RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128: \
128	case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X
129
130	RID_FRACT, RID_ACCUM, RID_AUTO_TYPE, RID_BUILTIN_CALL_WITH_STATIC_CHAIN,
131
132	/* "__GIMPLE", for the GIMPLE-parsing extension to the C frontend. */
133	RID_GIMPLE,
134
135	/* "__PHI", for parsing PHI function in GIMPLE FE. */
136	RID_PHI,
137
138	/* "__RTL", for the RTL-parsing extension to the C frontend. */
139	RID_RTL,
140
141	/* C11 */
142	RID_ALIGNAS, RID_GENERIC,
143
144	/* This means to warn that this is a C++ keyword, and then treat it
145	as a normal identifier. */
146	RID_CXX_COMPAT_WARN,
147
148	/* GNU transactional memory extension */
149	RID_TRANSACTION_ATOMIC, RID_TRANSACTION_RELAXED, RID_TRANSACTION_CANCEL,
150
151	/* Too many ways of getting the name of a function as a string */
152	RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,
153
154	/* C++ (some of these are keywords in Objective-C as well, but only
155	if they appear after a '@') */
156	RID_BOOL, RID_WCHAR, RID_CLASS,
157	RID_PUBLIC, RID_PRIVATE, RID_PROTECTED,
158	RID_TEMPLATE, RID_NULL, RID_CATCH,
159	RID_DELETE, RID_FALSE, RID_NAMESPACE,
160	RID_NEW, RID_OFFSETOF, RID_OPERATOR,
161	RID_THIS, RID_THROW, RID_TRUE,
162	RID_TRY, RID_TYPENAME, RID_TYPEID,
163	RID_USING, RID_CHAR16, RID_CHAR32,
164
165	/* casts */
166	RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,
167
168	/* C++ extensions */
169	RID_ADDRESSOF,
170	RID_BUILTIN_LAUNDER,
171	RID_BUILTIN_BIT_CAST,
172	RID_BUILTIN_OPERATOR_NEW, RID_BUILTIN_OPERATOR_DELETE,
173
174	/* C++11 */
175	RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
176
177	/* C++20 */
178	RID_CONSTINIT, RID_CONSTEVAL,
179
180	/* char8_t */
181	RID_CHAR8,
182
183	/* C++ concepts */
184	RID_CONCEPT, RID_REQUIRES,
185
186	/* C++ modules. */
187	RID__MODULE, RID__IMPORT, RID__EXPORT, /* Internal tokens. */
188
189	/* C++ coroutines */
190	RID_CO_AWAIT, RID_CO_YIELD, RID_CO_RETURN,
191
192	/* C++26 */
193	RID_CONTASSERT,
194
195	/* C++ transactional memory. */
196	RID_ATOMIC_NOEXCEPT, RID_ATOMIC_CANCEL, RID_SYNCHRONIZED,
197
198	/* Objective-C ("AT" reserved words - they are only keywords when
199	they follow '@') */
200	RID_AT_ENCODE, RID_AT_END,
201	RID_AT_CLASS, RID_AT_ALIAS, RID_AT_DEFS,
202	RID_AT_PRIVATE, RID_AT_PROTECTED, RID_AT_PUBLIC, RID_AT_PACKAGE,
203	RID_AT_PROTOCOL, RID_AT_SELECTOR,
204	RID_AT_THROW, RID_AT_TRY, RID_AT_CATCH,
205	RID_AT_FINALLY, RID_AT_SYNCHRONIZED,
206	RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY,
207	RID_AT_SYNTHESIZE, RID_AT_DYNAMIC,
208	RID_AT_INTERFACE,
209	RID_AT_IMPLEMENTATION,
210
211	/* OpenMP */
212	RID_OMP_ALL_MEMORY,
213
214	/* Named address support, mapping the keyword to a particular named address
215	number. Named address space 0 is reserved for the generic address. If
216	there are more than 254 named addresses, the addr_space_t type will need
217	to be grown from an unsigned char to unsigned short. */
218	RID_ADDR_SPACE_0, /* generic address */
219	RID_ADDR_SPACE_1,
220	RID_ADDR_SPACE_2,
221	RID_ADDR_SPACE_3,
222	RID_ADDR_SPACE_4,
223	RID_ADDR_SPACE_5,
224	RID_ADDR_SPACE_6,
225	RID_ADDR_SPACE_7,
226	RID_ADDR_SPACE_8,
227	RID_ADDR_SPACE_9,
228	RID_ADDR_SPACE_10,
229	RID_ADDR_SPACE_11,
230	RID_ADDR_SPACE_12,
231	RID_ADDR_SPACE_13,
232	RID_ADDR_SPACE_14,
233	RID_ADDR_SPACE_15,
234
235	RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0,
236	RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15,
237
238	/* __intN keywords. The _N_M here doesn't correspond to the intN
239	in the keyword; use the bitsize in int_n_t_data_t[M] for that.
240	For example, if int_n_t_data_t[0].bitsize is 13, then RID_INT_N_0
241	is for __int13. */
242
243	/* Note that the range to use is RID_FIRST_INT_N through
244	RID_FIRST_INT_N + NUM_INT_N_ENTS - 1 and c-parser.cc has a list of
245	all RID_INT_N_* in a case statement. */
246
247	RID_INT_N_0,
248	RID_INT_N_1,
249	RID_INT_N_2,
250	RID_INT_N_3,
251
252	RID_FIRST_INT_N = RID_INT_N_0,
253	RID_LAST_INT_N = RID_INT_N_3,
254
255	RID_MAX,
256
257	RID_FIRST_MODIFIER = RID_STATIC,
258	RID_LAST_MODIFIER = RID_ONEWAY,
259
260	RID_FIRST_CXX11 = RID_CONSTEXPR,
261	RID_LAST_CXX11 = RID_STATIC_ASSERT,
262	RID_FIRST_CXX20 = RID_CONSTINIT,
263	RID_LAST_CXX20 = RID_CO_RETURN,
264	RID_FIRST_CXX26 = RID_CONTASSERT,
265	RID_LAST_CXX26 = RID_CONTASSERT,
266	RID_FIRST_AT = RID_AT_ENCODE,
267	RID_LAST_AT = RID_AT_IMPLEMENTATION,
268	RID_FIRST_PQ = RID_IN,
269	RID_LAST_PQ = RID_ONEWAY,
270	RID_FIRST_PATTR = RID_GETTER,
271	RID_LAST_PATTR = RID_NULL_RESETTABLE
272	};
273
274	#define OBJC_IS_AT_KEYWORD(rid) \
275	((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
276	(unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
277
278	#define OBJC_IS_PQ_KEYWORD(rid) \
279	((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
280	(unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
281
282	/* Keywords permitted in an @property attribute context. */
283	#define OBJC_IS_PATTR_KEYWORD(rid) \
284	((((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \
285	(unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR)) \
286	|| rid == RID_CLASS)
287
288	/* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as
289	'class') which are shared in a subtle way between Objective-C and
290	C++. When the lexer is lexing in Objective-C/Objective-C++, if it
291	finds '@' followed by one of these identifiers (eg, '@class'), it
292	recognizes the whole as an Objective-C keyword. If the identifier
293	is found elsewhere, it follows the rules of the C/C++ language.
294	*/
295	#define OBJC_IS_CXX_KEYWORD(rid) \
296	(rid == RID_CLASS || rid == RID_SYNCHRONIZED \
297	|| rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE \
298	|| rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH)
299
300	/* The elements of `ridpointers' are identifier nodes for the reserved
301	type names and storage classes. It is indexed by a RID_... value. */
302	extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
303
304	/* Standard named or nameless data types of the C compiler. */
305
306	enum c_tree_index
307	{
308	CTI_CHAR8_TYPE,
309	CTI_CHAR16_TYPE,
310	CTI_CHAR32_TYPE,
311	CTI_WCHAR_TYPE,
312	CTI_UNDERLYING_WCHAR_TYPE,
313	CTI_WINT_TYPE,
314	CTI_SIGNED_SIZE_TYPE, /* For format checking only. */
315	CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only. */
316	CTI_INTMAX_TYPE,
317	CTI_UINTMAX_TYPE,
318	CTI_WIDEST_INT_LIT_TYPE,
319	CTI_WIDEST_UINT_LIT_TYPE,
320
321	/* Types for <stdint.h>, that may not be defined on all
322	targets. */
323	CTI_SIG_ATOMIC_TYPE,
324	CTI_INT8_TYPE,
325	CTI_INT16_TYPE,
326	CTI_INT32_TYPE,
327	CTI_INT64_TYPE,
328	CTI_UINT8_TYPE,
329	CTI_UINT16_TYPE,
330	CTI_UINT32_TYPE,
331	CTI_UINT64_TYPE,
332	CTI_INT_LEAST8_TYPE,
333	CTI_INT_LEAST16_TYPE,
334	CTI_INT_LEAST32_TYPE,
335	CTI_INT_LEAST64_TYPE,
336	CTI_UINT_LEAST8_TYPE,
337	CTI_UINT_LEAST16_TYPE,
338	CTI_UINT_LEAST32_TYPE,
339	CTI_UINT_LEAST64_TYPE,
340	CTI_INT_FAST8_TYPE,
341	CTI_INT_FAST16_TYPE,
342	CTI_INT_FAST32_TYPE,
343	CTI_INT_FAST64_TYPE,
344	CTI_UINT_FAST8_TYPE,
345	CTI_UINT_FAST16_TYPE,
346	CTI_UINT_FAST32_TYPE,
347	CTI_UINT_FAST64_TYPE,
348	CTI_INTPTR_TYPE,
349	CTI_UINTPTR_TYPE,
350
351	CTI_CHAR_ARRAY_TYPE,
352	CTI_CHAR8_ARRAY_TYPE,
353	CTI_CHAR16_ARRAY_TYPE,
354	CTI_CHAR32_ARRAY_TYPE,
355	CTI_WCHAR_ARRAY_TYPE,
356	CTI_STRING_TYPE,
357	CTI_CONST_STRING_TYPE,
358
359	/* Type for boolean expressions (bool in C++, int in C). */
360	CTI_TRUTHVALUE_TYPE,
361	CTI_TRUTHVALUE_TRUE,
362	CTI_TRUTHVALUE_FALSE,
363
364	CTI_DEFAULT_FUNCTION_TYPE,
365
366	CTI_NULL,
367	CTI_NULLPTR,
368	CTI_NULLPTR_TYPE,
369
370	/* These are not types, but we have to look them up all the time. */
371	CTI_FUNCTION_NAME_DECL,
372	CTI_PRETTY_FUNCTION_NAME_DECL,
373	CTI_C99_FUNCTION_NAME_DECL,
374
375	CTI_MODULE_HWM,
376	/* Below here entities change during compilation. */
377
378	CTI_SAVED_FUNCTION_NAME_DECLS,
379
380	CTI_MAX
381	};
382
383	#define C_CPP_HASHNODE(id) \
384	(&(((struct c_common_identifier *) (id))->node))
385	#define C_RID_CODE(id) \
386	((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))
387	#define C_SET_RID_CODE(id, code) \
388	(((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)
389
390	/* Identifier part common to the C front ends. Inherits from
391	tree_identifier, despite appearances. */
392	struct GTY(()) c_common_identifier {
393	struct tree_common common;
394	struct cpp_hashnode node;
395	};
396
397	/* An entry in the reserved keyword table. */
398
399	struct c_common_resword
400	{
401	const char *const word;
402	ENUM_BITFIELD(rid) const rid : 16;
403	const unsigned int disable : 32;
404	};
405
406	/* Mode used to build pointers (VOIDmode means ptr_mode). */
407
408	extern machine_mode c_default_pointer_mode;
409
410	/* Extra cpp_ttype values for C++. */
411
412	/* A token type for template-ids. If a template-id is processed while
413	parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
414	the value of the CPP_TEMPLATE_ID is whatever was returned by
415	cp_parser_template_id. */
416	#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
417
418	/* A token type for nested-name-specifiers. If a
419	nested-name-specifier is processed while parsing tentatively, it is
420	replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
421	CPP_NESTED_NAME_SPECIFIER is whatever was returned by
422	cp_parser_nested_name_specifier_opt. */
423	#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
424
425	/* A token type for pre-parsed C++0x decltype. */
426	#define CPP_DECLTYPE ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
427
428	/* A token type for pre-parsed primary-expression (lambda- or statement-). */
429	#define CPP_PREPARSED_EXPR ((enum cpp_ttype) (CPP_DECLTYPE + 1))
430
431	/* The number of token types, including C++-specific ones. */
432	#define N_CP_TTYPES ((int) (CPP_PREPARSED_EXPR + 1))
433
434	/* Disable mask. Keywords are disabled if (reswords[i].disable &
435	mask) is _true_. Thus for keywords which are present in all
436	languages the disable field is zero. */
437
438	#define D_CONLY 0x0001 /* C only (not in C++). */
439	#define D_CXXONLY 0x0002 /* C++ only (not in C). */
440	#define D_C99 0x0004 /* In C, C99 only. */
441	#define D_C23 0x0008 /* In C, C23 only. */
442	#define D_CXX11 0x0010 /* In C++, C++11 only. */
443	#define D_EXT 0x0020 /* GCC extension. */
444	#define D_EXT89 0x0040 /* GCC extension incorporated in C99. */
445	#define D_EXT11 0x0080 /* GCC extension incorporated in C23. */
446	#define D_ASM 0x0100 /* Disabled by -fno-asm. */
447	#define D_OBJC 0x0200 /* In Objective C and neither C nor C++. */
448	#define D_CXX_OBJC 0x0400 /* In Objective C, and C++, but not C. */
449	#define D_CXXWARN 0x0800 /* In C warn with -Wcxx-compat. */
450	#define D_CXX_CONCEPTS 0x1000 /* In C++, only with concepts. */
451	#define D_TRANSMEM 0x2000 /* C++ transactional memory TS. */
452	#define D_CXX_CHAR8_T 0x4000 /* In C++, only with -fchar8_t. */
453	#define D_CXX20 0x8000 /* In C++, C++20 only. */
454	#define D_CXX_COROUTINES 0x10000 /* In C++, only with coroutines. */
455	#define D_CXX_MODULES 0x20000 /* In C++, only with modules. */
456	#define D_CXX26 0x40000 /* In C++, C++26 only. */
457
458	#define D_CXX_CONCEPTS_FLAGS D_CXXONLY | D_CXX_CONCEPTS
459	#define D_CXX_CHAR8_T_FLAGS D_CXXONLY | D_CXX_CHAR8_T
460	#define D_CXX_MODULES_FLAGS (D_CXXONLY | D_CXX_MODULES)
461	#define D_CXX_COROUTINES_FLAGS (D_CXXONLY | D_CXX_COROUTINES)
462
463	/* The reserved keyword table. */
464	extern const struct c_common_resword c_common_reswords[];
465
466	/* The number of items in the reserved keyword table. */
467	extern const unsigned int num_c_common_reswords;
468
469	#define char8_type_node c_global_trees[CTI_CHAR8_TYPE]
470	#define char16_type_node c_global_trees[CTI_CHAR16_TYPE]
471	#define char32_type_node c_global_trees[CTI_CHAR32_TYPE]
472	#define wchar_type_node c_global_trees[CTI_WCHAR_TYPE]
473	#define underlying_wchar_type_node c_global_trees[CTI_UNDERLYING_WCHAR_TYPE]
474	#define wint_type_node c_global_trees[CTI_WINT_TYPE]
475	#define signed_size_type_node c_global_trees[CTI_SIGNED_SIZE_TYPE]
476	#define unsigned_ptrdiff_type_node c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]
477	#define intmax_type_node c_global_trees[CTI_INTMAX_TYPE]
478	#define uintmax_type_node c_global_trees[CTI_UINTMAX_TYPE]
479	#define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]
480	#define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]
481
482	#define sig_atomic_type_node c_global_trees[CTI_SIG_ATOMIC_TYPE]
483	#define int8_type_node c_global_trees[CTI_INT8_TYPE]
484	#define int16_type_node c_global_trees[CTI_INT16_TYPE]
485	#define int32_type_node c_global_trees[CTI_INT32_TYPE]
486	#define int64_type_node c_global_trees[CTI_INT64_TYPE]
487	#define uint8_type_node c_global_trees[CTI_UINT8_TYPE]
488	#define c_uint16_type_node c_global_trees[CTI_UINT16_TYPE]
489	#define c_uint32_type_node c_global_trees[CTI_UINT32_TYPE]
490	#define c_uint64_type_node c_global_trees[CTI_UINT64_TYPE]
491	#define int_least8_type_node c_global_trees[CTI_INT_LEAST8_TYPE]
492	#define int_least16_type_node c_global_trees[CTI_INT_LEAST16_TYPE]
493	#define int_least32_type_node c_global_trees[CTI_INT_LEAST32_TYPE]
494	#define int_least64_type_node c_global_trees[CTI_INT_LEAST64_TYPE]
495	#define uint_least8_type_node c_global_trees[CTI_UINT_LEAST8_TYPE]
496	#define uint_least16_type_node c_global_trees[CTI_UINT_LEAST16_TYPE]
497	#define uint_least32_type_node c_global_trees[CTI_UINT_LEAST32_TYPE]
498	#define uint_least64_type_node c_global_trees[CTI_UINT_LEAST64_TYPE]
499	#define int_fast8_type_node c_global_trees[CTI_INT_FAST8_TYPE]
500	#define int_fast16_type_node c_global_trees[CTI_INT_FAST16_TYPE]
501	#define int_fast32_type_node c_global_trees[CTI_INT_FAST32_TYPE]
502	#define int_fast64_type_node c_global_trees[CTI_INT_FAST64_TYPE]
503	#define uint_fast8_type_node c_global_trees[CTI_UINT_FAST8_TYPE]
504	#define uint_fast16_type_node c_global_trees[CTI_UINT_FAST16_TYPE]
505	#define uint_fast32_type_node c_global_trees[CTI_UINT_FAST32_TYPE]
506	#define uint_fast64_type_node c_global_trees[CTI_UINT_FAST64_TYPE]
507	#define intptr_type_node c_global_trees[CTI_INTPTR_TYPE]
508	#define uintptr_type_node c_global_trees[CTI_UINTPTR_TYPE]
509
510	#define truthvalue_type_node c_global_trees[CTI_TRUTHVALUE_TYPE]
511	#define truthvalue_true_node c_global_trees[CTI_TRUTHVALUE_TRUE]
512	#define truthvalue_false_node c_global_trees[CTI_TRUTHVALUE_FALSE]
513
514	#define char_array_type_node c_global_trees[CTI_CHAR_ARRAY_TYPE]
515	#define char8_array_type_node c_global_trees[CTI_CHAR8_ARRAY_TYPE]
516	#define char16_array_type_node c_global_trees[CTI_CHAR16_ARRAY_TYPE]
517	#define char32_array_type_node c_global_trees[CTI_CHAR32_ARRAY_TYPE]
518	#define wchar_array_type_node c_global_trees[CTI_WCHAR_ARRAY_TYPE]
519	#define string_type_node c_global_trees[CTI_STRING_TYPE]
520	#define const_string_type_node c_global_trees[CTI_CONST_STRING_TYPE]
521
522	#define default_function_type c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
523
524	#define function_name_decl_node c_global_trees[CTI_FUNCTION_NAME_DECL]
525	#define pretty_function_name_decl_node c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]
526	#define c99_function_name_decl_node c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
527	#define saved_function_name_decls c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
528
529	/* The node for C++ `__null'. */
530	#define null_node c_global_trees[CTI_NULL]
531	/* The nodes for `nullptr'. */
532	#define nullptr_node c_global_trees[CTI_NULLPTR]
533	#define nullptr_type_node c_global_trees[CTI_NULLPTR_TYPE]
534
535	extern GTY(()) tree c_global_trees[CTI_MAX];
536
537	/* Mark which labels are explicitly declared.
538	These may be shadowed, and may be referenced from nested functions. */
539	#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
540
541	enum c_language_kind
542	{
543	clk_c = 0, /* C without ObjC features. */
544	clk_objc = 1, /* clk_c with ObjC features. */
545	clk_cxx = 2, /* ANSI/ISO C++ */
546	clk_objcxx = 3 /* clk_cxx with ObjC features. */
547	};
548
549	/* To test for a specific language use c_language, defined by each
550	front end. For "ObjC features" or "not C++" use the macros. */
551	extern c_language_kind c_language;
552
553	#define c_dialect_cxx() ((c_language & clk_cxx) != 0)
554	#define c_dialect_objc() ((c_language & clk_objc) != 0)
555
556	/* The various name of operator that appears in error messages. */
557	enum ref_operator {
558	/* NULL */
559	RO_NULL,
560	/* array indexing */
561	RO_ARRAY_INDEXING,
562	/* unary * */
563	RO_UNARY_STAR,
564	/* -> */
565	RO_ARROW,
566	/* implicit conversion */
567	RO_IMPLICIT_CONVERSION,
568	/* ->* */
569	RO_ARROW_STAR
570	};
571
572	/* Information about a statement tree. */
573
574	struct GTY(()) stmt_tree_s {
575	/* A stack of statement lists being collected. */
576	vec<tree, va_gc> *x_cur_stmt_list;
577
578	/* In C++, Nonzero if we should treat statements as full
579	expressions. In particular, this variable is non-zero if at the
580	end of a statement we should destroy any temporaries created
581	during that statement. Similarly, if, at the end of a block, we
582	should destroy any local variables in this block. Normally, this
583	variable is nonzero, since those are the normal semantics of
584	C++.
585
586	This flag has no effect in C. */
587	int stmts_are_full_exprs_p;
588	};
589
590	typedef struct stmt_tree_s *stmt_tree;
591
592	/* Global state pertinent to the current function. Some C dialects
593	extend this structure with additional fields. */
594
595	struct GTY(()) c_language_function {
596	/* While we are parsing the function, this contains information
597	about the statement-tree that we are building. */
598	struct stmt_tree_s x_stmt_tree;
599
600	/* Vector of locally defined typedefs, for
601	-Wunused-local-typedefs. */
602	vec<tree, va_gc> *local_typedefs;
603	};
604
605	#define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
606
607	/* When building a statement-tree, this is the current statement list
608	being collected. */
609	#define cur_stmt_list (stmt_list_stack->last ())
610
611	#define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
612
613	/* Language-specific hooks. */
614
615	/* If non-NULL, this function is called after a precompile header file
616	is loaded. */
617	extern void (*lang_post_pch_load) (void);
618
619	extern void push_file_scope (void);
620	extern void pop_file_scope (void);
621	extern stmt_tree current_stmt_tree (void);
622	extern tree push_stmt_list (void);
623	extern tree pop_stmt_list (tree);
624	extern tree add_stmt (tree);
625	extern void push_cleanup (tree, tree, bool);
626
627	extern tree build_modify_expr (location_t, tree, tree, enum tree_code,
628	location_t, tree, tree);
629	extern tree build_indirect_ref (location_t, tree, ref_operator);
630
631	extern bool has_c_linkage (const_tree decl);
632	extern bool c_decl_implicit (const_tree);
633
634	/* Switches common to the C front ends. */
635
636	/* Nonzero means don't output line number information. */
637
638	extern char flag_no_line_commands;
639
640	/* Nonzero causes -E output not to be done, but directives such as
641	#define that have side effects are still obeyed. */
642
643	extern char flag_no_output;
644
645	/* Nonzero means dump macros in some fashion; contains the 'D', 'M',
646	'N' or 'U' of the command line switch. */
647
648	extern char flag_dump_macros;
649
650	/* Nonzero means pass #include lines through to the output. */
651
652	extern char flag_dump_includes;
653
654	/* Nonzero means process PCH files while preprocessing. */
655
656	extern bool flag_pch_preprocess;
657
658	/* The file name to which we should write a precompiled header, or
659	NULL if no header will be written in this compile. */
660
661	extern const char *pch_file;
662
663	/* Nonzero if an ISO standard was selected. It rejects macros in the
664	user's namespace. */
665
666	extern int flag_iso;
667
668	/* C/ObjC language option variables. */
669
670
671	/* Nonzero means allow type mismatches in conditional expressions;
672	just make their values `void'. */
673
674	extern int flag_cond_mismatch;
675
676	/* Nonzero means enable C89 Amendment 1 features. */
677
678	extern int flag_isoc94;
679
680	/* Nonzero means use the ISO C99 (or later) dialect of C. */
681
682	extern int flag_isoc99;
683
684	/* Nonzero means use the ISO C11 (or later) dialect of C. */
685
686	extern int flag_isoc11;
687
688	/* Nonzero means use the ISO C23 (or later) dialect of C. */
689
690	extern int flag_isoc23;
691
692	/* Nonzero means use the ISO C2Y (or later) dialect of C. */
693
694	extern int flag_isoc2y;
695
696	/* Nonzero means that we have builtin functions, and main is an int. */
697
698	extern int flag_hosted;
699
700	/* ObjC language option variables. */
701
702
703	/* Tells the compiler that this is a special run. Do not perform any
704	compiling, instead we are to test some platform dependent features
705	and output a C header file with appropriate definitions. */
706
707	extern int print_struct_values;
708
709	/* Tells the compiler what is the constant string class for ObjC. */
710
711	extern const char *constant_string_class_name;
712
713
714	/* C++ language option variables. */
715
716	/* The reference version of the ABI for -Wabi. */
717
718	extern int warn_abi_version;
719
720	/* Return TRUE if one of {flag_abi_version,flag_abi_compat_version} is
721	less than N and the other is at least N. */
722	#define abi_compat_version_crosses(N) \
723	(abi_version_at_least(N) \
724	!= (flag_abi_compat_version == 0 \
725	|| flag_abi_compat_version >= (N)))
726
727	/* Return TRUE if one of {flag_abi_version,warn_abi_version} is
728	less than N and the other is at least N, for use by -Wabi. */
729	#define abi_version_crosses(N) \
730	(abi_version_at_least(N) \
731	!= (warn_abi_version == 0 \
732	|| warn_abi_version >= (N)))
733
734	/* The supported C++ dialects. */
735
736	enum cxx_dialect {
737	cxx_unset,
738	/* C++98 with TC1 */
739	cxx98,
740	cxx03 = cxx98,
741	/* C++11 */
742	cxx0x,
743	cxx11 = cxx0x,
744	/* C++14 */
745	cxx14,
746	/* C++17 */
747	cxx17,
748	/* C++20 */
749	cxx20,
750	/* C++23 */
751	cxx23,
752	/* C++26 */
753	cxx26
754	};
755
756	/* The C++ dialect being used. C++20 is the default. */
757	extern enum cxx_dialect cxx_dialect;
758
759	/* Maximum template instantiation depth. This limit is rather
760	arbitrary, but it exists to limit the time it takes to notice
761	excessively recursive template instantiations. */
762
763	extern int max_tinst_depth;
764
765	/* Nonzero means that we should not issue warnings about problems that
766	occur when the code is executed, because the code being processed
767	is not expected to be executed. This is set during parsing. This
768	is used for cases like sizeof() and "0 ? a : b". This is a count,
769	not a bool, because unexecuted expressions can nest. */
770
771	extern int c_inhibit_evaluation_warnings;
772
773	/* Depending on which phase of processing we are in, we may need
774	to prefer input_location to libcpp's locations. (Specifically,
775	after the C++ lexer is done lexing tokens, but prior to calling
776	cpp_finish (), we need to do so. */
777
778	extern bool override_libcpp_locations;
779
780	/* C types are partitioned into three subsets: object, function, and
781	incomplete types. */
782	#define C_TYPE_OBJECT_P(type) \
783	(TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
784
785	#define C_TYPE_INCOMPLETE_P(type) \
786	(TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
787
788	#define C_TYPE_FUNCTION_P(type) \
789	(TREE_CODE (type) == FUNCTION_TYPE)
790
791	/* For convenience we define a single macro to identify the class of
792	object or incomplete types. */
793	#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
794	(!C_TYPE_FUNCTION_P (type))
795
796	/* Return true if TYPE is a vector type that should be subject to the GNU
797	vector extensions (as opposed to a vector type that is used only for
798	the purposes of defining target-specific built-in functions). */
799
800	inline bool
801	gnu_vector_type_p (const_tree type)
802	{
803	return VECTOR_TYPE_P (type) && !TYPE_INDIVISIBLE_P (type);
804	}
805
806	struct visibility_flags
807	{
808	unsigned inpragma : 1; /* True when in #pragma GCC visibility. */
809	unsigned inlines_hidden : 1; /* True when -finlineshidden in effect. */
810	};
811
812	/* These enumerators are possible types of unsafe conversions. */
813	enum conversion_safety {
814	/* The conversion is safe. */
815	SAFE_CONVERSION = 0,
816	/* Another type of conversion with problems. */
817	UNSAFE_OTHER,
818	/* Conversion between signed and unsigned integers. */
819	UNSAFE_SIGN,
820	/* Conversions that reduce the precision of reals including conversions
821	from reals to integers. */
822	UNSAFE_REAL,
823	/* Conversions from complex to reals or integers, that discard imaginary
824	component. */
825	UNSAFE_IMAGINARY
826	};
827
828	/* Global visibility options. */
829	extern struct visibility_flags visibility_options;
830
831	/* Attribute table common to the C front ends. */
832	extern const struct scoped_attribute_specs c_common_gnu_attribute_table;
833	extern const struct scoped_attribute_specs c_common_clang_attribute_table;
834	extern const struct scoped_attribute_specs c_common_format_attribute_table;
835
836	/* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.
837	ID is the identifier to use, NAME is the string.
838	TYPE_DEP indicates whether it depends on type of the function or not
839	(i.e. __PRETTY_FUNCTION__). */
840
841	extern tree (*make_fname_decl) (location_t, tree, int);
842
843	/* In c-decl.cc and cp/tree.cc. FIXME. */
844	extern void c_register_addr_space (const char *str, addr_space_t as);
845
846	/* In c-common.cc. */
847	extern bool in_late_binary_op;
848	extern const char *c_addr_space_name (addr_space_t as);
849	extern tree identifier_global_value (tree);
850	extern tree identifier_global_tag (tree);
851	extern int names_builtin_p (const char *);
852	extern tree c_linkage_bindings (tree);
853	extern void record_builtin_type (enum rid, const char *, tree);
854	extern void start_fname_decls (void);
855	extern void finish_fname_decls (void);
856	extern const char *fname_as_string (int);
857	extern tree fname_decl (location_t, unsigned, tree);
858
859	extern int check_user_alignment (const_tree, bool, bool);
860	extern bool check_function_arguments (location_t loc, const_tree, const_tree,
861	int, tree *, vec<location_t> *,
862	bool (*comp_types) (tree, tree));
863	extern void check_function_arguments_recurse (void (*)
864	(void *, tree,
865	unsigned HOST_WIDE_INT),
866	void *, tree,
867	unsigned HOST_WIDE_INT,
868	opt_code);
869	extern bool check_builtin_function_arguments (location_t, vec<location_t>, tree,
870	tree, int, tree *, bool = true);
871	extern void check_function_format (const_tree, tree, int, tree *,
872	vec<location_t> *,
873	bool (*comp_types) (tree, tree));
874	extern bool attribute_fallthrough_p (tree);
875	extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
876	extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
877	extern tree handle_unsequenced_attribute (tree *, tree, tree, int, bool *);
878	extern tree handle_reproducible_attribute (tree *, tree, tree, int, bool *);
879	extern bool c_common_handle_option (size_t, const char *, HOST_WIDE_INT, int,
880	location_t,
881	const struct cl_option_handlers *);
882	extern bool default_handle_c_option (size_t, const char *, int);
883	extern tree c_common_type_for_mode (machine_mode, int);
884	extern tree c_common_type_for_size (unsigned int, int);
885	extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
886	int, int);
887	extern tree c_common_unsigned_type (tree);
888	extern tree c_common_signed_type (tree);
889	extern tree c_common_signed_or_unsigned_type (int, tree);
890	extern void c_common_init_ts (void);
891	extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
892	extern enum conversion_safety unsafe_conversion_p (tree, tree, tree, bool);
893	extern bool decl_with_nonnull_addr_p (const_tree);
894	extern tree c_fully_fold (tree, bool, bool *, bool = false);
895	extern tree c_wrap_maybe_const (tree, bool);
896	extern tree c_common_truthvalue_conversion (location_t, tree);
897	extern void c_apply_type_quals_to_decl (int, tree);
898	extern tree c_sizeof_or_alignof_type (location_t, tree, bool, bool, int);
899	extern tree c_alignof_expr (location_t, tree);
900	extern tree c_countof_type (location_t, tree);
901	extern tree c_maxof_type (location_t, tree);
902	extern tree c_minof_type (location_t, tree);
903	/* Print an error message for invalid operands to arith operation CODE.
904	NOP_EXPR is used as a special case (see truthvalue_conversion). */
905	extern void binary_op_error (rich_location *, enum tree_code, tree, tree);
906	extern tree fix_string_type (tree);
907	extern tree convert_and_check (location_t, tree, tree, bool = false);
908	extern bool c_determine_visibility (tree);
909	extern bool vector_types_compatible_elements_p (tree, tree);
910	extern void mark_valid_location_for_stdc_pragma (bool);
911	extern bool valid_location_for_stdc_pragma_p (void);
912	extern void set_float_const_decimal64 (void);
913	extern void clear_float_const_decimal64 (void);
914	extern bool float_const_decimal64_p (void);
915
916	extern bool keyword_begins_type_specifier (enum rid);
917	extern bool keyword_is_storage_class_specifier (enum rid);
918	extern bool keyword_is_type_qualifier (enum rid);
919	extern bool keyword_is_decl_specifier (enum rid);
920	extern unsigned max_align_t_align (void);
921	extern bool cxx_fundamental_alignment_p (unsigned);
922	extern bool pointer_to_zero_sized_aggr_p (tree);
923	extern bool bool_promoted_to_int_p (tree);
924	extern tree fold_for_warn (tree);
925	extern tree c_common_get_narrower (tree, int *);
926	extern bool get_attribute_operand (tree, unsigned HOST_WIDE_INT *);
927	extern void c_common_finalize_early_debug (void);
928	extern bool c_flexible_array_member_type_p (const_tree);
929	extern unsigned int c_strict_flex_array_level_of (tree);
930	extern bool c_option_is_from_cpp_diagnostics (int);
931	extern tree c_hardbool_type_attr_1 (tree, tree *, tree *);
932
933	/* Used by convert_and_check; in front ends. */
934	extern tree convert_init (tree, tree);
935
936	#define c_sizeof(LOC, T) c_sizeof_or_alignof_type (LOC, T, true, false, 1)
937	#define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, false, 1)
938
939	/* Subroutine of build_binary_op, used for certain operations. */
940	extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
941
942	/* Return true if division or modulo op0 / op1 or op0 % op1 may be shortened.
943	We can shorten only if we can guarantee that op0 is not signed integral
944	minimum or op1 is not -1, because e.g. (long long) INT_MIN / -1 is
945	well defined INT_MAX + 1LL if long long is wider than int, but INT_MIN / -1
946	is UB. */
947	inline bool
948	may_shorten_divmod (tree op0, tree op1)
949	{
950	tree type0 = TREE_TYPE (op0);
951	if (TYPE_UNSIGNED (type0))
952	return true;
953	/* A cast from narrower unsigned won't be signed integral minimum,
954	but cast from same or wider precision unsigned could be. */
955	if (TREE_CODE (op0) == NOP_EXPR
956	&& INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (op0, 0)))
957	&& TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0)))
958	&& (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
959	< TYPE_PRECISION (type0)))
960	return true;
961	if (TREE_CODE (op1) == INTEGER_CST && !integer_all_onesp (op1))
962	return true;
963	return false;
964	}
965
966	/* Subroutine of build_binary_op, used for comparison operations.
967	See if the operands have both been converted from subword integer types
968	and, if so, perhaps change them both back to their original type. */
969	extern tree shorten_compare (location_t, tree *, tree *, tree *,
970	enum tree_code *);
971
972	extern tree pointer_int_sum (location_t, enum tree_code, tree, tree,
973	bool = true);
974
975	/* Add qualifiers to a type, in the fashion for C. */
976	extern tree c_build_qualified_type (tree, int, tree = NULL_TREE, size_t = 0);
977
978	/* Build tree nodes and builtin functions common to both C and C++ language
979	frontends. */
980	extern void c_common_nodes_and_builtins (void);
981
982	extern void disable_builtin_function (const char *);
983
984	extern void set_compound_literal_name (tree decl);
985
986	extern tree build_va_arg (location_t, tree, tree);
987
988	extern const unsigned int c_family_lang_mask;
989	extern unsigned int c_common_option_lang_mask (void);
990	extern void c_common_diagnostics_set_defaults (diagnostics::context *);
991	extern bool c_common_complain_wrong_lang_p (const struct cl_option *);
992	extern void c_common_init_options_struct (struct gcc_options *);
993	extern void c_common_init_options (unsigned int, struct cl_decoded_option *);
994	extern bool c_common_post_options (const char **);
995	extern bool c_common_init (void);
996	extern void c_common_finish (void);
997	extern void c_common_parse_file (void);
998	extern alias_set_type c_common_get_alias_set (tree);
999	extern void c_register_builtin_type (tree, const char*);
1000	extern bool c_promoting_integer_type_p (const_tree);
1001	extern bool self_promoting_args_p (const_tree);
1002	extern tree strip_pointer_operator (tree);
1003	extern tree strip_pointer_or_array_types (tree);
1004	extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
1005
1006	/* This is the basic parsing function. */
1007	extern void c_parse_file (void);
1008
1009	extern void c_parse_final_cleanups (void);
1010
1011	/* This initializes for preprocess-only mode. */
1012	extern void c_init_preprocess (void);
1013
1014	/* These macros provide convenient access to the various _STMT nodes. */
1015
1016	/* Nonzero if a given STATEMENT_LIST represents the outermost binding
1017	if a statement expression. */
1018	#define STATEMENT_LIST_STMT_EXPR(NODE) \
1019	TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
1020
1021	/* Nonzero if a label has been added to the statement list. */
1022	#define STATEMENT_LIST_HAS_LABEL(NODE) \
1023	TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
1024
1025	/* C_MAYBE_CONST_EXPR accessors. */
1026	#define C_MAYBE_CONST_EXPR_PRE(NODE) \
1027	TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0)
1028	#define C_MAYBE_CONST_EXPR_EXPR(NODE) \
1029	TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1)
1030	#define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE) \
1031	TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE))
1032	#define C_MAYBE_CONST_EXPR_NON_CONST(NODE) \
1033	TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE))
1034	#define EXPR_INT_CONST_OPERANDS(EXPR) \
1035	(INTEGRAL_TYPE_P (TREE_TYPE (EXPR)) \
1036	&& (TREE_CODE (EXPR) == INTEGER_CST \
1037	|| (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR \
1038	&& C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR))))
1039
1040	/* In a FIELD_DECL, nonzero if the decl was originally a bitfield. */
1041	#define DECL_C_BIT_FIELD(NODE) \
1042	(DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
1043	#define SET_DECL_C_BIT_FIELD(NODE) \
1044	(DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
1045	#define CLEAR_DECL_C_BIT_FIELD(NODE) \
1046	(DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
1047
1048	/* True if the decl was an unnamed bitfield. */
1049	#define DECL_UNNAMED_BIT_FIELD(NODE) \
1050	(DECL_C_BIT_FIELD (NODE) && !DECL_NAME (NODE))
1051
1052	/* True iff TYPE is cv decltype(nullptr). */
1053	#define NULLPTR_TYPE_P(TYPE) (TREE_CODE (TYPE) == NULLPTR_TYPE)
1054
1055	/* Returns the underlying type of the given enumeration type. The
1056	underlying type is determined in different ways, depending on the
1057	properties of the enum:
1058
1059	- In C++0x or C23, the underlying type can be explicitly specified, e.g.,
1060
1061	enum E1 : char { ... } // underlying type is char
1062
1063	- In a C++0x scoped enumeration, the underlying type is int
1064	unless otherwises specified:
1065
1066	enum class E2 { ... } // underlying type is int
1067
1068	- Otherwise, the underlying type is determined based on the
1069	values of the enumerators. In this case, the
1070	ENUM_UNDERLYING_TYPE will not be set until after the definition
1071	of the enumeration is completed by finish_enum. */
1072	#define ENUM_UNDERLYING_TYPE(TYPE) \
1073	TREE_TYPE (ENUMERAL_TYPE_CHECK (TYPE))
1074
1075	/* Determines whether an ENUMERAL_TYPE has an explicit
1076	underlying type. */
1077	#define ENUM_FIXED_UNDERLYING_TYPE_P(NODE) (TYPE_LANG_FLAG_5 (NODE))
1078
1079	extern tree do_case (location_t, tree, tree, tree);
1080	extern tree build_stmt (location_t, enum tree_code, ...);
1081	extern tree build_real_imag_expr (location_t, enum tree_code, tree);
1082
1083	/* These functions must be defined by each front-end which implements
1084	a variant of the C language. They are used in c-common.cc. */
1085
1086	extern tree build_unary_op (location_t, enum tree_code, tree, bool);
1087	extern tree build_binary_op (location_t, enum tree_code, tree, tree, bool);
1088	extern tree perform_integral_promotions (tree);
1089
1090	/* These functions must be defined by each front-end which implements
1091	a variant of the C language. They are used by port files. */
1092
1093	extern tree default_conversion (tree);
1094
1095	/* Given two integer or real types, return the type for their sum.
1096	Given two compatible ANSI C types, returns the merged type. */
1097
1098	extern tree common_type (tree, tree);
1099
1100	extern tree decl_constant_value (tree);
1101
1102	/* Handle increment and decrement of boolean types. */
1103	extern tree boolean_increment (enum tree_code, tree);
1104
1105	extern int case_compare (splay_tree_key, splay_tree_key);
1106
1107	extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree,
1108	tree = NULL_TREE);
1109	extern bool c_switch_covers_all_cases_p (splay_tree, tree);
1110	extern bool c_block_may_fallthru (const_tree);
1111
1112	extern tree build_function_call (location_t, tree, tree);
1113
1114	extern tree build_function_call_vec (location_t, vec<location_t>, tree,
1115	vec<tree, va_gc> *, vec<tree, va_gc> *,
1116	tree = NULL_TREE);
1117
1118	extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *,
1119	bool = true);
1120
1121	extern tree finish_label_address_expr (tree, location_t);
1122
1123	/* Same function prototype, but the C and C++ front ends have
1124	different implementations. Used in c-common.cc. */
1125	extern tree lookup_label (tree);
1126	extern tree lookup_name (tree);
1127	extern bool lvalue_p (const_tree);
1128	extern int maybe_adjust_arg_pos_for_attribute (const_tree);
1129	extern bool instantiation_dependent_expression_p (tree);
1130
1131	extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
1132	extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
1133	extern tree c_build_vec_perm_expr (location_t, tree, tree, tree, bool = true);
1134	extern tree c_build_shufflevector (location_t, tree, tree,
1135	const vec<tree> &, bool = true);
1136	extern tree c_build_vec_convert (location_t, tree, location_t, tree, bool = true);
1137
1138	extern void init_c_lex (void);
1139
1140	extern void c_cpp_builtins (cpp_reader *);
1141	extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
1142	extern bool c_cpp_diagnostic (cpp_reader *, enum cpp_diagnostic_level,
1143	enum cpp_warning_reason, rich_location *,
1144	const char *, va_list *)
1145	ATTRIBUTE_GCC_DIAG(5,0);
1146	extern int c_common_has_attribute (cpp_reader *, bool);
1147	extern int c_common_has_builtin (cpp_reader *);
1148	extern int c_common_has_feature (cpp_reader *, bool);
1149
1150	/* Implemented by each front end in *-lang.cc. */
1151	extern void c_family_register_lang_features ();
1152
1153	/* Implemented in c-family/c-common.cc. */
1154	extern void c_common_register_feature (const char *, bool);
1155	extern bool has_feature_p (const char *, bool);
1156
1157	extern bool parse_optimize_options (tree, bool);
1158
1159	/* Positive if an implicit `extern "C"' scope has just been entered;
1160	negative if such a scope has just been exited. */
1161	extern GTY(()) int pending_lang_change;
1162
1163	/* Information recorded about each file examined during compilation. */
1164
1165	struct c_fileinfo
1166	{
1167	int time; /* Time spent in the file. */
1168
1169	/* Flags used only by C++.
1170	INTERFACE_ONLY nonzero means that we are in an "interface" section
1171	of the compiler. INTERFACE_UNKNOWN nonzero means we cannot trust
1172	the value of INTERFACE_ONLY. If INTERFACE_UNKNOWN is zero and
1173	INTERFACE_ONLY is zero, it means that we are responsible for
1174	exporting definitions that others might need. */
1175	short interface_only;
1176	short interface_unknown;
1177	};
1178
1179	struct c_fileinfo *get_fileinfo (const char *);
1180	extern void dump_time_statistics (void);
1181
1182	extern bool c_dump_tree (void *, tree);
1183
1184	extern void verify_sequence_points (tree);
1185
1186	extern tree fold_offsetof (tree, tree = size_type_node,
1187	tree_code ctx = ERROR_MARK);
1188
1189	extern int complete_array_type (tree *, tree, bool);
1190	extern void complete_flexible_array_elts (tree);
1191
1192	extern tree builtin_type_for_size (int, bool);
1193
1194	extern void c_common_mark_addressable_vec (tree);
1195
1196	extern void set_underlying_type (tree);
1197	extern bool user_facing_original_type_p (const_tree);
1198	extern void record_types_used_by_current_var_decl (tree);
1199	extern vec<tree, va_gc> *make_tree_vector (void);
1200	extern void release_tree_vector (vec<tree, va_gc> *);
1201	extern vec<tree, va_gc> *make_tree_vector_single (tree);
1202	extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
1203	extern vec<tree, va_gc> *append_ctor_to_tree_vector (vec<tree, va_gc> *,
1204	tree);
1205	extern vec<tree, va_gc> *make_tree_vector_from_ctor (tree);
1206	extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
1207
1208	/* Used for communication between c_common_type_for_mode and
1209	c_register_builtin_type. */
1210	extern GTY(()) tree registered_builtin_types;
1211
1212	/* Read SOURCE_DATE_EPOCH from environment to have a deterministic
1213	timestamp to replace embedded current dates to get reproducible
1214	results. Returns -1 if SOURCE_DATE_EPOCH is not defined. */
1215	extern time_t cb_get_source_date_epoch (cpp_reader *pfile);
1216
1217	/* The value (as a unix timestamp) corresponds to date
1218	"Dec 31 9999 23:59:59 UTC", which is the latest date that __DATE__ and
1219	__TIME__ can store. */
1220	#define MAX_SOURCE_DATE_EPOCH HOST_WIDE_INT_C (253402300799)
1221
1222	/* Callback for libcpp for offering spelling suggestions for misspelled
1223	directives. */
1224	extern const char *cb_get_suggestion (cpp_reader *, const char *,
1225	const char *const *);
1226
1227	extern GTY(()) string_concat_db *g_string_concat_db;
1228
1229	class substring_loc;
1230	extern const char *c_get_substring_location (const substring_loc &substr_loc,
1231	location_t *out_loc);
1232
1233	/* In c-gimplify.cc. */
1234	typedef hash_map<tree, tree_pair,
1235	simple_hashmap_traits<tree_decl_hash,
1236	tree_pair>> bc_hash_map_t;
1237	typedef struct bc_state
1238	{
1239	tree bc_label[2];
1240	bc_hash_map_t *bc_hash_map;
1241	} bc_state_t;
1242	extern void save_bc_state (bc_state_t *);
1243	extern void restore_bc_state (bc_state_t *);
1244	extern tree c_genericize_control_stmt (tree *, int *, void *,
1245	walk_tree_fn, walk_tree_lh);
1246	extern void c_genericize (tree);
1247	extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
1248	extern tree c_build_bind_expr (location_t, tree, tree);
1249
1250	/* In c-lex.cc. */
1251	extern enum cpp_ttype
1252	conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind);
1253
1254	/* In c-pch.cc */
1255	extern void pch_init (void);
1256	extern void pch_cpp_save_state (void);
1257	extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
1258	extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
1259	const char *orig);
1260	extern void c_common_write_pch (void);
1261	extern void c_common_no_more_pch (void);
1262	extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
1263
1264	/* In *-checksum.c */
1265	extern const unsigned char executable_checksum[16];
1266
1267	/* In c-cppbuiltin.cc */
1268	extern void builtin_define_std (const char *macro);
1269	extern void builtin_define_with_value (const char *, const char *, int);
1270	extern void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
1271	extern void builtin_define_type_sizeof (const char *, tree);
1272	extern void c_stddef_cpp_builtins (void);
1273	extern void fe_file_change (const line_map_ordinary *);
1274	extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char,
1275	rich_location *richloc);
1276	extern diagnostics::option_id get_option_for_builtin_define (const char *macro_name);
1277
1278	/* In c-ppoutput.cc */
1279	extern void init_pp_output (FILE *);
1280	extern void preprocess_file (cpp_reader *);
1281	extern void pp_file_change (const line_map_ordinary *);
1282	extern void pp_dir_change (cpp_reader *, const char *);
1283	extern bool check_missing_format_attribute (tree, tree);
1284	extern void c_pp_stream_token (cpp_reader *, const cpp_token *, location_t loc);
1285
1286	/* In c-omp.cc */
1287	typedef wide_int_bitmask omp_clause_mask;
1288
1289	#define OMP_CLAUSE_MASK_1 omp_clause_mask (1)
1290
1291	enum c_omp_clause_split
1292	{
1293	C_OMP_CLAUSE_SPLIT_TARGET = 0,
1294	C_OMP_CLAUSE_SPLIT_TEAMS,
1295	C_OMP_CLAUSE_SPLIT_DISTRIBUTE,
1296	C_OMP_CLAUSE_SPLIT_PARALLEL,
1297	C_OMP_CLAUSE_SPLIT_FOR,
1298	C_OMP_CLAUSE_SPLIT_SIMD,
1299	C_OMP_CLAUSE_SPLIT_COUNT,
1300	C_OMP_CLAUSE_SPLIT_SECTIONS = C_OMP_CLAUSE_SPLIT_FOR,
1301	C_OMP_CLAUSE_SPLIT_TASKLOOP = C_OMP_CLAUSE_SPLIT_FOR,
1302	C_OMP_CLAUSE_SPLIT_LOOP = C_OMP_CLAUSE_SPLIT_FOR,
1303	C_OMP_CLAUSE_SPLIT_MASKED = C_OMP_CLAUSE_SPLIT_DISTRIBUTE
1304	};
1305
1306	enum c_omp_region_type
1307	{
1308	C_ORT_OMP = 1 << 0,
1309	C_ORT_ACC = 1 << 1,
1310	C_ORT_DECLARE_SIMD = 1 << 2,
1311	C_ORT_TARGET = 1 << 3,
1312	C_ORT_EXIT_DATA = 1 << 4,
1313	C_ORT_INTEROP = 1 << 5,
1314	C_ORT_DECLARE_MAPPER = 1 << 6,
1315	C_ORT_OMP_DECLARE_SIMD = C_ORT_OMP | C_ORT_DECLARE_SIMD,
1316	C_ORT_OMP_TARGET = C_ORT_OMP | C_ORT_TARGET,
1317	C_ORT_OMP_EXIT_DATA = C_ORT_OMP | C_ORT_EXIT_DATA,
1318	C_ORT_OMP_INTEROP = C_ORT_OMP | C_ORT_INTEROP,
1319	C_ORT_OMP_DECLARE_MAPPER = C_ORT_OMP | C_ORT_DECLARE_MAPPER,
1320	C_ORT_ACC_TARGET = C_ORT_ACC | C_ORT_TARGET
1321	};
1322
1323	extern tree c_finish_omp_master (location_t, tree);
1324	extern tree c_finish_omp_masked (location_t, tree, tree);
1325	extern tree c_finish_omp_taskgroup (location_t, tree, tree);
1326	extern tree c_finish_omp_critical (location_t, tree, tree, tree);
1327	extern tree c_finish_omp_ordered (location_t, tree, tree);
1328	extern void c_finish_omp_barrier (location_t);
1329	extern tree c_finish_omp_atomic (location_t, enum tree_code, enum tree_code,
1330	tree, tree, tree, tree, tree, tree, bool,
1331	enum omp_memory_order, bool, bool = false);
1332	extern bool c_omp_interop_t_p (tree);
1333	extern bool c_omp_depend_t_p (tree);
1334	extern void c_finish_omp_depobj (location_t, tree, enum omp_clause_depend_kind,
1335	tree);
1336	extern void c_finish_omp_flush (location_t, int);
1337	extern void c_finish_omp_taskwait (location_t);
1338	extern void c_finish_omp_taskyield (location_t);
1339	extern tree c_finish_omp_for (location_t, enum tree_code, tree, tree, tree,
1340	tree, tree, tree, tree, bool);
1341	extern int c_omp_find_generated_loop (tree &, int, walk_tree_lh);
1342	extern bool c_omp_check_loop_iv (tree, tree, walk_tree_lh);
1343	extern bool c_omp_check_loop_iv_exprs (location_t, enum tree_code, tree, int,
1344	tree, tree, tree, walk_tree_lh);
1345	extern bool c_omp_check_loop_binding_exprs (tree, vec<tree> *);
1346	extern tree c_finish_oacc_wait (location_t, tree, tree);
1347	extern tree c_oacc_split_loop_clauses (tree, tree *, bool);
1348	extern void c_omp_split_clauses (location_t, enum tree_code, omp_clause_mask,
1349	tree, tree *);
1350	extern tree c_omp_declare_simd_clauses_to_numbers (tree, tree);
1351	extern void c_omp_declare_simd_clauses_to_decls (tree, tree);
1352	extern bool c_omp_predefined_variable (tree);
1353	extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
1354	extern enum omp_clause_defaultmap_kind c_omp_predetermined_mapping (tree);
1355	extern tree c_omp_check_context_selector (location_t, tree);
1356	extern void c_omp_mark_declare_variant (location_t, tree, tree);
1357	extern void c_omp_adjust_map_clauses (tree, bool);
1358	template<typename T> struct omp_mapper_list;
1359	extern void c_omp_find_nested_mappers (struct omp_mapper_list<tree> *, tree);
1360	extern tree c_omp_instantiate_mappers (tree);
1361
1362	namespace omp_addr_tokenizer { struct omp_addr_token; }
1363	typedef omp_addr_tokenizer::omp_addr_token omp_addr_token;
1364
1365	class c_omp_address_inspector
1366	{
1367	location_t loc;
1368	tree root_term;
1369	bool indirections;
1370	int map_supported;
1371
1372	protected:
1373	tree orig;
1374
1375	public:
1376	c_omp_address_inspector (location_t loc, tree t)
1377	: loc (loc), root_term (NULL_TREE), indirections (false),
1378	map_supported (-1), orig (t)
1379	{
1380	}
1381
1382	~c_omp_address_inspector ()
1383	{
1384	}
1385
1386	virtual bool processing_template_decl_p ()
1387	{
1388	return false;
1389	}
1390
1391	virtual void emit_unmappable_type_notes (tree)
1392	{
1393	}
1394
1395	virtual tree convert_from_reference (tree)
1396	{
1397	gcc_unreachable ();
1398	}
1399
1400	virtual tree build_array_ref (location_t loc, tree arr, tree idx)
1401	{
1402	tree eltype = TREE_TYPE (TREE_TYPE (arr));
1403	return build4_loc (loc, code: ARRAY_REF, type: eltype, arg0: arr, arg1: idx, NULL_TREE,
1404	NULL_TREE);
1405	}
1406
1407	virtual bool check_clause (tree);
1408	tree get_root_term (bool);
1409
1410	tree unconverted_ref_origin ();
1411	bool component_access_p ();
1412
1413	bool map_supported_p ();
1414
1415	tree get_origin (tree);
1416	tree maybe_unconvert_ref (tree);
1417
1418	bool maybe_zero_length_array_section (tree);
1419
1420	tree expand_array_base (tree, vec<omp_addr_token *> &, tree, unsigned *,
1421	c_omp_region_type);
1422	tree expand_component_selector (tree, vec<omp_addr_token *> &, tree,
1423	unsigned *, c_omp_region_type);
1424	tree expand_map_clause (tree, tree, vec<omp_addr_token *> &,
1425	c_omp_region_type);
1426	};
1427
1428	enum c_omp_directive_kind {
1429	C_OMP_DIR_STANDALONE,
1430	C_OMP_DIR_CONSTRUCT,
1431	C_OMP_DIR_DECLARATIVE,
1432	C_OMP_DIR_UTILITY,
1433	C_OMP_DIR_INFORMATIONAL,
1434	C_OMP_DIR_META
1435	};
1436
1437	struct c_omp_directive {
1438	const char *first, *second, *third;
1439	unsigned int id;
1440	enum c_omp_directive_kind kind;
1441	bool simd;
1442	};
1443
1444	extern const struct c_omp_directive c_omp_directives[];
1445	extern const struct c_omp_directive *c_omp_categorize_directive (const char *,
1446	const char *,
1447	const char *);
1448	extern tree c_omp_expand_variant_construct (vec<struct omp_variant> &);
1449
1450	/* Return next tree in the chain for chain_next walking of tree nodes. */
1451	inline tree
1452	c_tree_chain_next (tree t)
1453	{
1454	/* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
1455	kind of object, never a long chain of nodes. Prefer
1456	TYPE_NEXT_VARIANT for types. */
1457	if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
1458	return TYPE_NEXT_VARIANT (t);
1459	/* Otherwise, if there is TREE_CHAIN, return it. */
1460	if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
1461	return TREE_CHAIN (t);
1462	return NULL;
1463	}
1464
1465	/* Return the hardbool attribute associated with TYPE, if there is one, provided
1466	that TYPE looks like an enumeral type that might have been set up by
1467	handle_hardbool_attribute. Return NULL otherwise.
1468
1469	If FALSE_VALUE or TRUE_VALUE are non-NULL and TYPE is a hardened boolean
1470	type, store the corresponding representation values. */
1471	static inline tree
1472	c_hardbool_type_attr (tree type,
1473	tree *false_value = NULL, tree *true_value = NULL)
1474	{
1475	if (TREE_CODE (type) != ENUMERAL_TYPE
1476	|| TYPE_LANG_SPECIFIC (type))
1477	return NULL_TREE;
1478
1479	return c_hardbool_type_attr_1 (type, false_value, true_value);
1480	}
1481
1482	/* Mask used by tm_stmt_attr. */
1483	#define TM_STMT_ATTR_OUTER 2
1484	#define TM_STMT_ATTR_ATOMIC 4
1485	#define TM_STMT_ATTR_RELAXED 8
1486
1487	/* Mask used by tm_attr_to_mask and tm_mask_to_attr. Note that these
1488	are ordered specifically such that more restrictive attributes are
1489	at lower bit positions. This fact is known by the C++ tm attribute
1490	inheritance code such that least bit extraction (mask & -mask) results
1491	in the most restrictive attribute. */
1492	#define TM_ATTR_SAFE 1
1493	#define TM_ATTR_CALLABLE 2
1494	#define TM_ATTR_PURE 4
1495	#define TM_ATTR_IRREVOCABLE 8
1496	#define TM_ATTR_MAY_CANCEL_OUTER 16
1497
1498	/* A suffix-identifier value doublet that represents user-defined literals
1499	for C++-0x. */
1500	enum overflow_type {
1501	OT_UNDERFLOW = -1,
1502	OT_NONE,
1503	OT_OVERFLOW
1504	};
1505
1506	struct GTY(()) tree_userdef_literal {
1507	struct tree_base base;
1508	tree suffix_id;
1509	tree value;
1510	tree num_string;
1511	enum overflow_type overflow;
1512	};
1513
1514	#define USERDEF_LITERAL_SUFFIX_ID(NODE) \
1515	(((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->suffix_id)
1516
1517	#define USERDEF_LITERAL_VALUE(NODE) \
1518	(((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->value)
1519
1520	#define USERDEF_LITERAL_OVERFLOW(NODE) \
1521	(((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->overflow)
1522
1523	#define USERDEF_LITERAL_NUM_STRING(NODE) \
1524	(((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->num_string)
1525
1526	#define USERDEF_LITERAL_TYPE(NODE) \
1527	(TREE_TYPE (USERDEF_LITERAL_VALUE (NODE)))
1528
1529	extern tree build_userdef_literal (tree suffix_id, tree value,
1530	enum overflow_type overflow,
1531	tree num_string);
1532
1533
1534	/* WHILE_STMT accessors. These give access to the condition of the
1535	while statement, the body, and name of the while statement, and
1536	condition preparation statements and number of its nested cleanups,
1537	respectively. */
1538	#define WHILE_COND(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 0)
1539	#define WHILE_BODY(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 1)
1540	#define WHILE_NAME(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 2)
1541	#define WHILE_COND_PREP(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 3)
1542	#define WHILE_COND_CLEANUP(NODE) TREE_OPERAND (WHILE_STMT_CHECK (NODE), 4)
1543
1544	/* DO_STMT accessors. These give access to the condition of the do
1545	statement, the body and name of the do statement, respectively. */
1546	#define DO_COND(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 0)
1547	#define DO_BODY(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 1)
1548	#define DO_NAME(NODE) TREE_OPERAND (DO_STMT_CHECK (NODE), 2)
1549
1550	/* FOR_STMT accessors. These give access to the init statement,
1551	condition, update expression, body and name of the for statement,
1552	and condition preparation statements and number of its nested cleanups,
1553	respectively. */
1554	#define FOR_INIT_STMT(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 0)
1555	#define FOR_COND(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 1)
1556	#define FOR_EXPR(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 2)
1557	#define FOR_BODY(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 3)
1558	#define FOR_SCOPE(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 4)
1559	#define FOR_NAME(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 5)
1560	#define FOR_COND_PREP(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 6)
1561	#define FOR_COND_CLEANUP(NODE) TREE_OPERAND (FOR_STMT_CHECK (NODE), 7)
1562
1563	/* BREAK_STMT accessors. */
1564	#define BREAK_NAME(NODE) TREE_OPERAND (BREAK_STMT_CHECK (NODE), 0)
1565
1566	/* CONTINUE_STMT accessors. */
1567	#define CONTINUE_NAME(NODE) TREE_OPERAND (CONTINUE_STMT_CHECK (NODE), 0)
1568
1569	#define SWITCH_STMT_COND(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 0)
1570	#define SWITCH_STMT_BODY(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 1)
1571	#define SWITCH_STMT_TYPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 2)
1572	#define SWITCH_STMT_SCOPE(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 3)
1573	#define SWITCH_STMT_NAME(NODE) TREE_OPERAND (SWITCH_STMT_CHECK (NODE), 4)
1574	/* True if there are case labels for all possible values of switch cond, either
1575	because there is a default: case label or because the case label ranges cover
1576	all values. */
1577	#define SWITCH_STMT_ALL_CASES_P(NODE) \
1578	TREE_LANG_FLAG_0 (SWITCH_STMT_CHECK (NODE))
1579	/* True if the body of a switch stmt contains no BREAK_STMTs. */
1580	#define SWITCH_STMT_NO_BREAK_P(NODE) \
1581	TREE_LANG_FLAG_2 (SWITCH_STMT_CHECK (NODE))
1582
1583
1584	/* Nonzero if NODE is the target for genericization of 'break' stmts. */
1585	#define LABEL_DECL_BREAK(NODE) \
1586	DECL_LANG_FLAG_0 (LABEL_DECL_CHECK (NODE))
1587
1588	/* Nonzero if NODE is the target for genericization of 'continue' stmts. */
1589	#define LABEL_DECL_CONTINUE(NODE) \
1590	DECL_LANG_FLAG_1 (LABEL_DECL_CHECK (NODE))
1591
1592	extern bool convert_vector_to_array_for_subscript (location_t, tree *, tree);
1593
1594	/* Possibe cases of scalar_to_vector conversion. */
1595	enum stv_conv {
1596	stv_error, /* Error occurred. */
1597	stv_nothing, /* Nothing happened. */
1598	stv_firstarg, /* First argument must be expanded. */
1599	stv_secondarg /* Second argument must be expanded. */
1600	};
1601
1602	extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code,
1603	tree op0, tree op1, bool);
1604
1605	extern tree find_inv_trees (tree *, int *, void *);
1606	extern tree replace_inv_trees (tree *, int *, void *);
1607
1608	extern bool reject_gcc_builtin (const_tree, location_t = UNKNOWN_LOCATION);
1609	extern bool valid_array_size_p (location_t, const_tree, tree, bool = true);
1610	extern void invalid_array_size_error (location_t, cst_size_error,
1611	const_tree, const_tree);
1612
1613	/* In c-warn.cc. */
1614	extern void constant_expression_warning (tree);
1615	extern void constant_expression_error (tree);
1616	extern void overflow_warning (location_t, tree, tree = NULL_TREE);
1617	extern void warn_logical_operator (location_t, enum tree_code, tree,
1618	enum tree_code, tree, enum tree_code, tree);
1619	extern void warn_tautological_cmp (const op_location_t &, enum tree_code,
1620	tree, tree);
1621	extern void warn_logical_not_parentheses (location_t, enum tree_code, tree,
1622	tree);
1623	extern bool warn_if_unused_value (const_tree, location_t, bool = false);
1624	extern bool strict_aliasing_warning (location_t, tree, tree);
1625	extern void sizeof_pointer_memaccess_warning (location_t *, tree,
1626	vec<tree, va_gc> *, tree *,
1627	bool (*) (tree, tree));
1628	extern void check_main_parameter_types (tree decl);
1629	extern void warnings_for_convert_and_check (location_t, tree, tree, tree);
1630	extern void c_do_switch_warnings (splay_tree, location_t, tree, tree, bool);
1631	extern void warn_for_omitted_condop (location_t, tree);
1632	extern bool warn_for_restrict (unsigned, tree *, unsigned);
1633	extern void warn_for_address_of_packed_member (tree, tree);
1634	extern void warn_parms_array_mismatch (location_t, tree, tree);
1635	extern void maybe_warn_sizeof_array_div (location_t, tree, tree, tree, tree);
1636	extern void do_warn_array_compare (location_t, tree_code, tree, tree);
1637
1638	/* Places where an lvalue, or modifiable lvalue, may be required.
1639	Used to select diagnostic messages in lvalue_error and
1640	readonly_error. */
1641	enum lvalue_use {
1642	lv_assign,
1643	lv_increment,
1644	lv_decrement,
1645	lv_addressof,
1646	lv_asm
1647	};
1648
1649	extern void lvalue_error (location_t, enum lvalue_use);
1650	extern void invalid_indirection_error (location_t, tree, ref_operator);
1651	extern void readonly_error (location_t, tree, enum lvalue_use);
1652	extern void warn_array_subscript_with_type_char (location_t, tree);
1653	extern void warn_about_parentheses (location_t,
1654	enum tree_code,
1655	enum tree_code, tree,
1656	enum tree_code, tree);
1657	extern void warn_for_unused_label (tree label);
1658	extern void warn_for_div_by_zero (location_t, tree divisor);
1659	extern void warn_for_memset (location_t, tree, tree, int);
1660	extern void warn_for_calloc (location_t *, tree, vec<tree, va_gc> *,
1661	tree *, tree);
1662	extern void warn_for_alloc_size (location_t, tree, tree, tree);
1663	extern void warn_for_sign_compare (location_t,
1664	tree orig_op0, tree orig_op1,
1665	tree op0, tree op1,
1666	tree result_type,
1667	enum tree_code resultcode);
1668	extern void do_warn_double_promotion (tree, tree, tree, const char *,
1669	location_t);
1670	extern void do_warn_unused_parameter (tree);
1671	extern void record_locally_defined_typedef (tree);
1672	extern void maybe_record_typedef_use (tree);
1673	extern void maybe_warn_unused_local_typedefs (void);
1674	extern void maybe_warn_bool_compare (location_t, enum tree_code, tree, tree);
1675	extern bool maybe_warn_shift_overflow (location_t, tree, tree);
1676	extern void warn_duplicated_cond_add_or_warn (location_t, tree, vec<tree> **);
1677	extern bool diagnose_mismatched_attributes (tree, tree);
1678	extern tree do_warn_duplicated_branches_r (tree *, int *, void *);
1679	extern void warn_for_multistatement_macros (location_t, location_t,
1680	location_t, enum rid);
1681
1682	extern void check_for_xor_used_as_pow (location_t lhs_loc, tree lhs_val,
1683	location_t operator_loc,
1684	location_t rhs_loc, tree rhs_val);
1685
1686	/* In c-attribs.cc. */
1687	extern bool attribute_takes_identifier_p (const_tree);
1688	extern tree handle_deprecated_attribute (tree *, tree, tree, int, bool *);
1689	extern tree handle_unused_attribute (tree *, tree, tree, int, bool *);
1690	extern tree handle_fallthrough_attribute (tree *, tree, tree, int, bool *);
1691	extern int parse_tm_stmt_attr (tree, int);
1692	extern int tm_attr_to_mask (tree);
1693	extern tree tm_mask_to_attr (int);
1694	extern tree find_tm_attribute (tree);
1695	extern const struct attribute_spec::exclusions attr_aligned_exclusions[];
1696	extern const struct attribute_spec::exclusions attr_cold_hot_exclusions[];
1697	extern const struct attribute_spec::exclusions attr_noreturn_exclusions[];
1698	extern tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
1699	extern tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
1700	extern tree handle_musttail_attribute (tree *, tree, tree, int, bool *);
1701	extern bool has_attribute (location_t, tree, tree, tree (*)(tree));
1702	extern tree build_attr_access_from_parms (tree, bool);
1703	extern void set_musttail_on_return (tree, location_t, bool);
1704
1705	/* In c-format.cc. */
1706	extern bool valid_format_string_type_p (tree);
1707
1708	/* A bitmap of flags to positional_argument. */
1709	enum posargflags {
1710	/* Consider positional attribute argument value zero valid. */
1711	POSARG_ZERO = 1,
1712	/* Consider positional attribute argument value valid if it refers
1713	to the ellipsis (i.e., beyond the last typed argument). */
1714	POSARG_ELLIPSIS = 2
1715	};
1716
1717	extern tree positional_argument (const_tree, const_tree, tree &, tree_code,
1718	int = 0, int = posargflags ());
1719
1720	extern enum flt_eval_method
1721	excess_precision_mode_join (enum flt_eval_method, enum flt_eval_method);
1722
1723	extern int c_flt_eval_method (bool ts18661_p);
1724	extern void add_no_sanitize_value (tree node, sanitize_code_type flags);
1725
1726	extern void maybe_add_include_fixit (rich_location *, const char *, bool);
1727	extern void maybe_suggest_missing_token_insertion (rich_location *richloc,
1728	enum cpp_ttype token_type,
1729	location_t prev_token_loc);
1730	extern void maybe_emit_indirection_note (location_t loc,
1731	tree expr, tree expected_type);
1732	extern bool compatible_types_for_indirection_note_p (tree type1, tree type2);
1733
1734	extern tree braced_lists_to_strings (tree, tree);
1735
1736	#if CHECKING_P
1737	namespace selftest {
1738	/* Declarations for specific families of tests within c-family,
1739	by source file, in alphabetical order. */
1740	extern void c_format_cc_tests (void);
1741	extern void c_indentation_cc_tests (void);
1742	extern void c_opt_problem_cc_tests (void);
1743	extern void c_pretty_print_cc_tests (void);
1744	extern void c_spellcheck_cc_tests (void);
1745
1746	/* The entrypoint for running all of the above tests. */
1747	extern void c_family_tests (void);
1748	} // namespace selftest
1749	#endif /* #if CHECKING_P */
1750
1751	#endif /* ! GCC_C_COMMON_H */
1752