1	/* Definitions for the ubiquitous 'tree' type for GNU compilers.
2	Copyright (C) 1989-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_TREE_H
21	#define GCC_TREE_H
22
23	#include "tree-core.h"
24	#include "options.h"
25	#include "vec.h"
26
27	/* Convert a target-independent built-in function code to a combined_fn. */
28
29	inline combined_fn
30	as_combined_fn (built_in_function fn)
31	{
32	return combined_fn (int (fn));
33	}
34
35	/* Convert an internal function code to a combined_fn. */
36
37	inline combined_fn
38	as_combined_fn (internal_fn fn)
39	{
40	return combined_fn (int (fn) + int (END_BUILTINS));
41	}
42
43	/* Return true if CODE is a target-independent built-in function. */
44
45	inline bool
46	builtin_fn_p (combined_fn code)
47	{
48	return int (code) < int (END_BUILTINS);
49	}
50
51	/* Return the target-independent built-in function represented by CODE.
52	Only valid if builtin_fn_p (CODE). */
53
54	inline built_in_function
55	as_builtin_fn (combined_fn code)
56	{
57	gcc_checking_assert (builtin_fn_p (code));
58	return built_in_function (int (code));
59	}
60
61	/* Return true if CODE is an internal function. */
62
63	inline bool
64	internal_fn_p (combined_fn code)
65	{
66	return int (code) >= int (END_BUILTINS);
67	}
68
69	/* Return the internal function represented by CODE. Only valid if
70	internal_fn_p (CODE). */
71
72	inline internal_fn
73	as_internal_fn (combined_fn code)
74	{
75	gcc_checking_assert (internal_fn_p (code));
76	return internal_fn (int (code) - int (END_BUILTINS));
77	}
78
79	/* Helper to transparently allow tree codes and builtin function codes
80	exist in one storage entity. */
81	class code_helper
82	{
83	public:
84	code_helper () {}
85	code_helper (tree_code code) : rep ((int) code) {}
86	code_helper (combined_fn fn) : rep (-(int) fn) {}
87	code_helper (internal_fn fn) : rep (-(int) as_combined_fn (fn)) {}
88	explicit operator tree_code () const { return (tree_code) rep; }
89	explicit operator combined_fn () const { return (combined_fn) -rep; }
90	explicit operator internal_fn () const;
91	explicit operator built_in_function () const;
92	bool is_tree_code () const { return rep > 0; }
93	bool is_fn_code () const { return rep < 0; }
94	bool is_internal_fn () const;
95	bool is_builtin_fn () const;
96	int get_rep () const { return rep; }
97	tree_code safe_as_tree_code () const;
98	combined_fn safe_as_fn_code () const;
99	bool operator== (const code_helper &other) { return rep == other.rep; }
100	bool operator!= (const code_helper &other) { return rep != other.rep; }
101	bool operator== (tree_code c) { return rep == code_helper (c).rep; }
102	bool operator!= (tree_code c) { return rep != code_helper (c).rep; }
103
104	private:
105	int rep;
106	};
107
108	/* Helper function that returns the tree_code representation of THIS
109	code_helper if it is a tree_code and MAX_TREE_CODES otherwise. This is
110	useful when passing a code_helper to a tree_code only check. */
111
112	inline tree_code
113	code_helper::safe_as_tree_code () const
114	{
115	return is_tree_code () ? (tree_code) *this : MAX_TREE_CODES;
116	}
117
118	/* Helper function that returns the combined_fn representation of THIS
119	code_helper if it is a fn_code and CFN_LAST otherwise. This is useful when
120	passing a code_helper to a combined_fn only check. */
121
122	inline combined_fn
123	code_helper::safe_as_fn_code () const {
124	return is_fn_code () ? (combined_fn) *this : CFN_LAST;
125	}
126
127	inline code_helper::operator internal_fn () const
128	{
129	return as_internal_fn (code: combined_fn (*this));
130	}
131
132	inline code_helper::operator built_in_function () const
133	{
134	return as_builtin_fn (code: combined_fn (*this));
135	}
136
137	inline bool
138	code_helper::is_internal_fn () const
139	{
140	return is_fn_code () && internal_fn_p (code: combined_fn (*this));
141	}
142
143	inline bool
144	code_helper::is_builtin_fn () const
145	{
146	return is_fn_code () && builtin_fn_p (code: combined_fn (*this));
147	}
148
149	/* Macros for initializing `tree_contains_struct'. */
150	#define MARK_TS_BASE(C) \
151	(tree_contains_struct[C][TS_BASE] = true)
152
153	#define MARK_TS_TYPED(C) \
154	(MARK_TS_BASE (C), \
155	tree_contains_struct[C][TS_TYPED] = true)
156
157	#define MARK_TS_COMMON(C) \
158	(MARK_TS_TYPED (C), \
159	tree_contains_struct[C][TS_COMMON] = true)
160
161	#define MARK_TS_TYPE_COMMON(C) \
162	(MARK_TS_COMMON (C), \
163	tree_contains_struct[C][TS_TYPE_COMMON] = true)
164
165	#define MARK_TS_TYPE_WITH_LANG_SPECIFIC(C) \
166	(MARK_TS_TYPE_COMMON (C), \
167	tree_contains_struct[C][TS_TYPE_WITH_LANG_SPECIFIC] = true)
168
169	#define MARK_TS_TYPE_NON_COMMON(C) \
170	(MARK_TS_TYPE_WITH_LANG_SPECIFIC (C), \
171	tree_contains_struct[C][TS_TYPE_NON_COMMON] = true) \
172
173	#define MARK_TS_DECL_MINIMAL(C) \
174	(MARK_TS_COMMON (C), \
175	tree_contains_struct[C][TS_DECL_MINIMAL] = true)
176
177	#define MARK_TS_DECL_COMMON(C) \
178	(MARK_TS_DECL_MINIMAL (C), \
179	tree_contains_struct[C][TS_DECL_COMMON] = true)
180
181	#define MARK_TS_DECL_WRTL(C) \
182	(MARK_TS_DECL_COMMON (C), \
183	tree_contains_struct[C][TS_DECL_WRTL] = true)
184
185	#define MARK_TS_DECL_WITH_VIS(C) \
186	(MARK_TS_DECL_WRTL (C), \
187	tree_contains_struct[C][TS_DECL_WITH_VIS] = true)
188
189	#define MARK_TS_DECL_NON_COMMON(C) \
190	(MARK_TS_DECL_WITH_VIS (C), \
191	tree_contains_struct[C][TS_DECL_NON_COMMON] = true)
192
193	#define MARK_TS_EXP(C) \
194	(MARK_TS_TYPED (C), \
195	tree_contains_struct[C][TS_EXP] = true)
196
197	/* Returns the string representing CLASS. */
198
199	#define TREE_CODE_CLASS_STRING(CLASS)\
200	tree_code_class_strings[(int) (CLASS)]
201
202	#if __cpp_inline_variables < 201606L
203	#define TREE_CODE_CLASS(CODE) \
204	tree_code_type_tmpl <0>::tree_code_type[(int) (CODE)]
205	#else
206	#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
207	#endif
208
209	/* Nonzero if NODE represents an exceptional code. */
210
211	#define EXCEPTIONAL_CLASS_P(NODE)\
212	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_exceptional)
213
214	/* Nonzero if NODE represents a constant. */
215
216	#define CONSTANT_CLASS_P(NODE)\
217	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_constant)
218
219	/* Nonzero if NODE represents a constant, or is a location wrapper
220	around such a node. */
221
222	#define CONSTANT_CLASS_OR_WRAPPER_P(NODE)\
223	(CONSTANT_CLASS_P (tree_strip_any_location_wrapper (NODE)))
224
225	/* Nonzero if NODE represents a type. */
226
227	#define TYPE_P(NODE)\
228	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_type)
229
230	/* Nonzero if NODE represents a declaration. */
231
232	#define DECL_P(NODE)\
233	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_declaration)
234
235	/* True if NODE designates a variable declaration. */
236	#define VAR_P(NODE) \
237	(TREE_CODE (NODE) == VAR_DECL)
238
239	/* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL. */
240
241	#define VAR_OR_FUNCTION_DECL_P(DECL)\
242	(TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
243
244	/* Nonzero if NODE represents a INDIRECT_REF. Keep these checks in
245	ascending code order. */
246
247	#define INDIRECT_REF_P(NODE)\
248	(TREE_CODE (NODE) == INDIRECT_REF)
249
250	/* Nonzero if NODE represents a reference. */
251
252	#define REFERENCE_CLASS_P(NODE)\
253	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_reference)
254
255	/* Nonzero if NODE represents a comparison. */
256
257	#define COMPARISON_CLASS_P(NODE)\
258	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_comparison)
259
260	/* Nonzero if NODE represents a unary arithmetic expression. */
261
262	#define UNARY_CLASS_P(NODE)\
263	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_unary)
264
265	/* Nonzero if NODE represents a binary arithmetic expression. */
266
267	#define BINARY_CLASS_P(NODE)\
268	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_binary)
269
270	/* Nonzero if NODE represents a statement expression. */
271
272	#define STATEMENT_CLASS_P(NODE)\
273	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_statement)
274
275	/* Nonzero if NODE represents a function call-like expression with a
276	variable-length operand vector. */
277
278	#define VL_EXP_CLASS_P(NODE)\
279	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_vl_exp)
280
281	/* Nonzero if NODE represents any other expression. */
282
283	#define EXPRESSION_CLASS_P(NODE)\
284	(TREE_CODE_CLASS (TREE_CODE (NODE)) == tcc_expression)
285
286	/* Returns nonzero iff NODE represents a type or declaration. */
287
288	#define IS_TYPE_OR_DECL_P(NODE)\
289	(TYPE_P (NODE) || DECL_P (NODE))
290
291	/* Returns nonzero iff CLASS is the tree-code class of an
292	expression. */
293
294	#define IS_EXPR_CODE_CLASS(CLASS)\
295	((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
296
297	/* Returns nonzero iff NODE is an expression of some kind. */
298
299	#define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
300
301	#if __cpp_inline_variables < 201606L
302	#define TREE_CODE_LENGTH(CODE) \
303	tree_code_length_tmpl <0>::tree_code_length[(int) (CODE)]
304	#else
305	#define TREE_CODE_LENGTH(CODE) tree_code_length[(int) (CODE)]
306	#endif
307
308
309	/* Helper macros for math builtins. */
310
311	#define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
312	#define CASE_FLT_FN_FLOATN_NX(FN) \
313	case FN##F16: case FN##F32: case FN##F64: case FN##F128: \
314	case FN##F32X: case FN##F64X: case FN##F128X
315	#define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
316	#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX
317
318	#define NULL_TREE (tree) NULL
319
320	/* Define accessors for the fields that all tree nodes have
321	(though some fields are not used for all kinds of nodes). */
322
323	/* The tree-code says what kind of node it is.
324	Codes are defined in tree.def. */
325	#define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
326	#define TREE_SET_CODE(NODE, VALUE) ((NODE)->base.code = (VALUE))
327
328	/* When checking is enabled, errors will be generated if a tree node
329	is accessed incorrectly. The macros die with a fatal error. */
330	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
331
332	#define TREE_CHECK(T, CODE) \
333	(tree_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
334
335	#define TREE_NOT_CHECK(T, CODE) \
336	(tree_not_check ((T), __FILE__, __LINE__, __FUNCTION__, (CODE)))
337
338	#define TREE_CHECK2(T, CODE1, CODE2) \
339	(tree_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
340
341	#define TREE_NOT_CHECK2(T, CODE1, CODE2) \
342	(tree_not_check2 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2)))
343
344	#define TREE_CHECK3(T, CODE1, CODE2, CODE3) \
345	(tree_check3 ((T), __FILE__, __LINE__, __FUNCTION__, (CODE1), (CODE2), (CODE3)))
346
347	#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) \
348	(tree_not_check3 ((T), __FILE__, __LINE__, __FUNCTION__, \
349	(CODE1), (CODE2), (CODE3)))
350
351	#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
352	(tree_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
353	(CODE1), (CODE2), (CODE3), (CODE4)))
354
355	#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) \
356	(tree_not_check4 ((T), __FILE__, __LINE__, __FUNCTION__, \
357	(CODE1), (CODE2), (CODE3), (CODE4)))
358
359	#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
360	(tree_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
361	(CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
362
363	#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) \
364	(tree_not_check5 ((T), __FILE__, __LINE__, __FUNCTION__, \
365	(CODE1), (CODE2), (CODE3), (CODE4), (CODE5)))
366
367	#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) \
368	(tree_check6 ((T), __FILE__, __LINE__, __FUNCTION__, \
369	(CODE1), (CODE2), (CODE3), (CODE4), (CODE5), (CODE6)))
370
371	#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) \
372	(tree_not_check6 ((T), __FILE__, __LINE__, __FUNCTION__, \
373	(CODE1), (CODE2), (CODE3), (CODE4), (CODE5), (CODE6)))
374
375	#define CONTAINS_STRUCT_CHECK(T, STRUCT) \
376	(contains_struct_check ((T), (STRUCT), __FILE__, __LINE__, __FUNCTION__))
377
378	#define TREE_CLASS_CHECK(T, CLASS) \
379	(tree_class_check ((T), (CLASS), __FILE__, __LINE__, __FUNCTION__))
380
381	#define TREE_RANGE_CHECK(T, CODE1, CODE2) \
382	(tree_range_check ((T), (CODE1), (CODE2), __FILE__, __LINE__, __FUNCTION__))
383
384	#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) \
385	(omp_clause_subcode_check ((T), (CODE), __FILE__, __LINE__, __FUNCTION__))
386
387	#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) \
388	(omp_clause_range_check ((T), (CODE1), (CODE2), \
389	__FILE__, __LINE__, __FUNCTION__))
390
391	/* These checks have to be special cased. */
392	#define EXPR_CHECK(T) \
393	(expr_check ((T), __FILE__, __LINE__, __FUNCTION__))
394
395	/* These checks have to be special cased. */
396	#define NON_TYPE_CHECK(T) \
397	(non_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
398
399	/* These checks have to be special cased. */
400	#define ANY_INTEGRAL_TYPE_CHECK(T) \
401	(any_integral_type_check ((T), __FILE__, __LINE__, __FUNCTION__))
402
403	#define TREE_INT_CST_ELT_CHECK(T, I) \
404	(*tree_int_cst_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))
405
406	#define TREE_VEC_ELT_CHECK(T, I) \
407	(*(const_cast<tree *> ( \
408	tree_vec_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
409
410	#define OMP_CLAUSE_ELT_CHECK(T, I) \
411	(*(omp_clause_elt_check ((T), (I), __FILE__, __LINE__, __FUNCTION__)))
412
413	/* Special checks for TREE_OPERANDs. */
414	#define TREE_OPERAND_CHECK(T, I) \
415	(*(const_cast<tree *> ( \
416	tree_operand_check ((T), (I), __FILE__, __LINE__, __FUNCTION__))))
417
418	#define TREE_OPERAND_CHECK_CODE(T, CODE, I) \
419	(*(tree_operand_check_code ((T), (CODE), (I), \
420	__FILE__, __LINE__, __FUNCTION__)))
421
422	/* Nodes are chained together for many purposes.
423	Types are chained together to record them for being output to the debugger
424	(see the function `chain_type').
425	Decls in the same scope are chained together to record the contents
426	of the scope.
427	Statement nodes for successive statements used to be chained together.
428	Often lists of things are represented by TREE_LIST nodes that
429	are chained together. */
430
431	#define TREE_CHAIN(NODE) \
432	(CONTAINS_STRUCT_CHECK (NODE, TS_COMMON)->common.chain)
433
434	/* In all nodes that are expressions, this is the data type of the expression.
435	In POINTER_TYPE nodes, this is the type that the pointer points to.
436	In ARRAY_TYPE nodes, this is the type of the elements.
437	In VECTOR_TYPE nodes, this is the type of the elements. */
438	#define TREE_TYPE(NODE) \
439	(CONTAINS_STRUCT_CHECK (NODE, TS_TYPED)->typed.type)
440
441	extern void tree_contains_struct_check_failed (const_tree,
442	const enum tree_node_structure_enum,
443	const char *, int, const char *)
444	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
445
446	extern void tree_check_failed (const_tree, const char *, int, const char *,
447	...) ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
448	extern void tree_not_check_failed (const_tree, const char *, int, const char *,
449	...) ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
450	extern void tree_class_check_failed (const_tree, const enum tree_code_class,
451	const char *, int, const char *)
452	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
453	extern void tree_range_check_failed (const_tree, const char *, int,
454	const char *, enum tree_code,
455	enum tree_code)
456	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
457	extern void tree_not_class_check_failed (const_tree,
458	const enum tree_code_class,
459	const char *, int, const char *)
460	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
461	extern void tree_int_cst_elt_check_failed (int, int, const char *,
462	int, const char *)
463	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
464	extern void tree_vec_elt_check_failed (int, int, const char *,
465	int, const char *)
466	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
467	extern void phi_node_elt_check_failed (int, int, const char *,
468	int, const char *)
469	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
470	extern void tree_operand_check_failed (int, const_tree,
471	const char *, int, const char *)
472	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
473	extern void omp_clause_check_failed (const_tree, const char *, int,
474	const char *, enum omp_clause_code)
475	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
476	extern void omp_clause_operand_check_failed (int, const_tree, const char *,
477	int, const char *)
478	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
479	extern void omp_clause_range_check_failed (const_tree, const char *, int,
480	const char *, enum omp_clause_code,
481	enum omp_clause_code)
482	ATTRIBUTE_NORETURN ATTRIBUTE_COLD;
483
484	#else /* not ENABLE_TREE_CHECKING, or not gcc */
485
486	#define CONTAINS_STRUCT_CHECK(T, ENUM) (T)
487	#define TREE_CHECK(T, CODE) (T)
488	#define TREE_NOT_CHECK(T, CODE) (T)
489	#define TREE_CHECK2(T, CODE1, CODE2) (T)
490	#define TREE_NOT_CHECK2(T, CODE1, CODE2) (T)
491	#define TREE_CHECK3(T, CODE1, CODE2, CODE3) (T)
492	#define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T)
493	#define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
494	#define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
495	#define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
496	#define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
497	#define TREE_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) (T)
498	#define TREE_NOT_CHECK6(T, CODE1, CODE2, CODE3, CODE4, CODE5, CODE6) (T)
499	#define TREE_CLASS_CHECK(T, CODE) (T)
500	#define TREE_RANGE_CHECK(T, CODE1, CODE2) (T)
501	#define EXPR_CHECK(T) (T)
502	#define NON_TYPE_CHECK(T) (T)
503	#define TREE_INT_CST_ELT_CHECK(T, I) ((T)->int_cst.val[I])
504	#define TREE_VEC_ELT_CHECK(T, I) ((T)->vec.a[I])
505	#define TREE_OPERAND_CHECK(T, I) ((T)->exp.operands[I])
506	#define TREE_OPERAND_CHECK_CODE(T, CODE, I) ((T)->exp.operands[I])
507	#define OMP_CLAUSE_ELT_CHECK(T, i) ((T)->omp_clause.ops[i])
508	#define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T)
509	#define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) (T)
510	#define ANY_INTEGRAL_TYPE_CHECK(T) (T)
511
512	#define TREE_CHAIN(NODE) ((NODE)->common.chain)
513	#define TREE_TYPE(NODE) ((NODE)->typed.type)
514
515	#endif
516
517	#define TREE_BLOCK(NODE) (tree_block (NODE))
518	#define TREE_SET_BLOCK(T, B) (tree_set_block ((T), (B)))
519
520	#include "tree-check.h"
521
522	#define TYPE_CHECK(T) TREE_CLASS_CHECK (T, tcc_type)
523	#define DECL_MINIMAL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
524	#define DECL_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
525	#define DECL_WRTL_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
526	#define DECL_WITH_VIS_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
527	#define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
528	#define CST_CHECK(T) TREE_CLASS_CHECK (T, tcc_constant)
529	#define STMT_CHECK(T) TREE_CLASS_CHECK (T, tcc_statement)
530	#define VL_EXP_CHECK(T) TREE_CLASS_CHECK (T, tcc_vl_exp)
531	#define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
532	#define PTR_OR_REF_CHECK(T) TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
533
534	#define RECORD_OR_UNION_CHECK(T) \
535	TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
536	#define NOT_RECORD_OR_UNION_CHECK(T) \
537	TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
538	#define ARRAY_OR_INTEGER_TYPE_CHECK(T) \
539	TREE_CHECK2 (T, ARRAY_TYPE, INTEGER_TYPE)
540
541	#define NUMERICAL_TYPE_CHECK(T) \
542	TREE_CHECK6 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \
543	FIXED_POINT_TYPE, BITINT_TYPE)
544
545	/* Here is how primitive or already-canonicalized types' hash codes
546	are made. */
547	#define TYPE_HASH(TYPE) (TYPE_UID (TYPE))
548
549	/* A simple hash function for an arbitrary tree node. This must not be
550	used in hash tables which are saved to a PCH. */
551	#define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
552
553	/* Tests if CODE is a conversion expr (NOP_EXPR or CONVERT_EXPR). */
554	#define CONVERT_EXPR_CODE_P(CODE) \
555	((CODE) == NOP_EXPR || (CODE) == CONVERT_EXPR)
556
557	/* Similarly, but accept an expression instead of a tree code. */
558	#define CONVERT_EXPR_P(EXP) CONVERT_EXPR_CODE_P (TREE_CODE (EXP))
559
560	/* Generate case for NOP_EXPR, CONVERT_EXPR. */
561
562	#define CASE_CONVERT \
563	case NOP_EXPR: \
564	case CONVERT_EXPR
565
566	/* Given an expression as a tree, strip any conversion that generates
567	no instruction. Accepts both tree and const_tree arguments since
568	we are not modifying the tree itself. */
569
570	#define STRIP_NOPS(EXP) \
571	(EXP) = tree_strip_nop_conversions (const_cast<tree> (EXP))
572
573	/* Like STRIP_NOPS, but don't let the signedness change either. */
574
575	#define STRIP_SIGN_NOPS(EXP) \
576	(EXP) = tree_strip_sign_nop_conversions (const_cast<tree> (EXP))
577
578	/* Like STRIP_NOPS, but don't alter the TREE_TYPE either. */
579
580	#define STRIP_TYPE_NOPS(EXP) \
581	while ((CONVERT_EXPR_P (EXP) \
582	|| TREE_CODE (EXP) == NON_LVALUE_EXPR) \
583	&& TREE_OPERAND (EXP, 0) != error_mark_node \
584	&& (TREE_TYPE (EXP) \
585	== TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
586	(EXP) = TREE_OPERAND (EXP, 0)
587
588	/* Remove unnecessary type conversions according to
589	tree_ssa_useless_type_conversion. */
590
591	#define STRIP_USELESS_TYPE_CONVERSION(EXP) \
592	(EXP) = tree_ssa_strip_useless_type_conversions (EXP)
593
594	/* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely
595	in use to provide a location_t. */
596
597	#define STRIP_ANY_LOCATION_WRAPPER(EXP) \
598	(EXP) = tree_strip_any_location_wrapper (const_cast<tree> (EXP))
599
600	/* Nonzero if TYPE represents a vector type. */
601
602	#define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE)
603
604	/* Nonzero if TYPE represents a vector of booleans. */
605
606	#define VECTOR_BOOLEAN_TYPE_P(TYPE) \
607	(TREE_CODE (TYPE) == VECTOR_TYPE \
608	&& TREE_CODE (TREE_TYPE (TYPE)) == BOOLEAN_TYPE)
609
610	/* Nonzero if TYPE represents an integral type. Note that we do not
611	include COMPLEX types here. Keep these checks in ascending code
612	order. */
613
614	#define INTEGRAL_TYPE_P(TYPE) \
615	(TREE_CODE (TYPE) == ENUMERAL_TYPE \
616	|| TREE_CODE (TYPE) == BOOLEAN_TYPE \
617	|| TREE_CODE (TYPE) == INTEGER_TYPE \
618	|| TREE_CODE (TYPE) == BITINT_TYPE)
619
620	/* Nonzero if TYPE represents an integral type, including complex
621	and vector integer types. */
622
623	#define ANY_INTEGRAL_TYPE_P(TYPE) \
624	(INTEGRAL_TYPE_P (TYPE) \
625	|| ((TREE_CODE (TYPE) == COMPLEX_TYPE \
626	|| VECTOR_TYPE_P (TYPE)) \
627	&& INTEGRAL_TYPE_P (TREE_TYPE (TYPE))))
628
629	/* Nonzero if TYPE is bit-precise integer type. */
630
631	#define BITINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == BITINT_TYPE)
632
633	/* Nonzero if TYPE represents a non-saturating fixed-point type. */
634
635	#define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \
636	(TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE))
637
638	/* Nonzero if TYPE represents a saturating fixed-point type. */
639
640	#define SAT_FIXED_POINT_TYPE_P(TYPE) \
641	(TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE))
642
643	/* Nonzero if TYPE represents a fixed-point type. */
644
645	#define FIXED_POINT_TYPE_P(TYPE) (TREE_CODE (TYPE) == FIXED_POINT_TYPE)
646
647	/* Nonzero if TYPE represents a scalar floating-point type. */
648
649	#define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE)
650
651	/* Nonzero if TYPE represents a complex floating-point type. */
652
653	#define COMPLEX_FLOAT_TYPE_P(TYPE) \
654	(TREE_CODE (TYPE) == COMPLEX_TYPE \
655	&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
656
657	/* Nonzero if TYPE represents a vector integer type. */
658
659	#define VECTOR_INTEGER_TYPE_P(TYPE) \
660	(VECTOR_TYPE_P (TYPE) \
661	&& TREE_CODE (TREE_TYPE (TYPE)) == INTEGER_TYPE)
662
663
664	/* Nonzero if TYPE represents a vector floating-point type. */
665
666	#define VECTOR_FLOAT_TYPE_P(TYPE) \
667	(VECTOR_TYPE_P (TYPE) \
668	&& TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
669
670	/* Nonzero if TYPE represents a floating-point type, including complex
671	and vector floating-point types. The vector and complex check does
672	not use the previous two macros to enable early folding. */
673
674	#define FLOAT_TYPE_P(TYPE) \
675	(SCALAR_FLOAT_TYPE_P (TYPE) \
676	|| ((TREE_CODE (TYPE) == COMPLEX_TYPE \
677	|| VECTOR_TYPE_P (TYPE)) \
678	&& SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))
679
680	/* Nonzero if TYPE represents a decimal floating-point type. */
681	#define DECIMAL_FLOAT_TYPE_P(TYPE) \
682	(SCALAR_FLOAT_TYPE_P (TYPE) \
683	&& DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))
684
685	/* Nonzero if TYPE is a record or union type. */
686	#define RECORD_OR_UNION_TYPE_P(TYPE) \
687	(TREE_CODE (TYPE) == RECORD_TYPE \
688	|| TREE_CODE (TYPE) == UNION_TYPE \
689	|| TREE_CODE (TYPE) == QUAL_UNION_TYPE)
690
691	/* Nonzero if TYPE represents an aggregate (multi-component) type.
692	Keep these checks in ascending code order. */
693
694	#define AGGREGATE_TYPE_P(TYPE) \
695	(TREE_CODE (TYPE) == ARRAY_TYPE || RECORD_OR_UNION_TYPE_P (TYPE))
696
697	/* Nonzero if TYPE represents a pointer or reference type.
698	(It should be renamed to INDIRECT_TYPE_P.) Keep these checks in
699	ascending code order. */
700
701	#define POINTER_TYPE_P(TYPE) \
702	(TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
703
704	/* Nonzero if TYPE represents a pointer to function. */
705	#define FUNCTION_POINTER_TYPE_P(TYPE) \
706	(POINTER_TYPE_P (TYPE) && TREE_CODE (TREE_TYPE (TYPE)) == FUNCTION_TYPE)
707
708	/* Nonzero if this type is a complete type. */
709	#define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
710
711	/* Nonzero if this type is the (possibly qualified) void type. */
712	#define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)
713
714	/* Nonzero if this type is complete or is cv void. */
715	#define COMPLETE_OR_VOID_TYPE_P(NODE) \
716	(COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
717
718	/* Nonzero if this type is complete or is an array with unspecified bound. */
719	#define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
720	(COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
721
722	#define FUNC_OR_METHOD_TYPE_P(NODE) \
723	(TREE_CODE (NODE) == FUNCTION_TYPE || TREE_CODE (NODE) == METHOD_TYPE)
724
725	#define OPAQUE_TYPE_P(NODE) \
726	(TREE_CODE (NODE) == OPAQUE_TYPE)
727
728	/* Define many boolean fields that all tree nodes have. */
729
730	/* In VAR_DECL, PARM_DECL and RESULT_DECL nodes, nonzero means address
731	of this is needed. So it cannot be in a register.
732	In a FUNCTION_DECL it has no meaning.
733	In LABEL_DECL nodes, it means a goto for this label has been seen
734	from a place outside all binding contours that restore stack levels.
735	In an artificial SSA_NAME that points to a stack partition with at least
736	two variables, it means that at least one variable has TREE_ADDRESSABLE.
737	In ..._TYPE nodes, it means that objects of this type must be fully
738	addressable. This means that pieces of this object cannot go into
739	register parameters, for example. If this a function type, this
740	means that the value must be returned in memory.
741	In CONSTRUCTOR nodes, it means object constructed must be in memory.
742	In IDENTIFIER_NODEs, this means that some extern decl for this name
743	had its address taken. That matters for inline functions.
744	In a STMT_EXPR, it means we want the result of the enclosed expression. */
745	#define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag)
746
747	/* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
748	exit of a function. Calls for which this is true are candidates for tail
749	call optimizations. */
750	#define CALL_EXPR_TAILCALL(NODE) \
751	(CALL_EXPR_CHECK (NODE)->base.addressable_flag)
752
753	/* Set on a CALL_EXPR if the call has been marked as requiring tail call
754	optimization for correctness. */
755	#define CALL_EXPR_MUST_TAIL_CALL(NODE) \
756	(CALL_EXPR_CHECK (NODE)->base.static_flag)
757
758	/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
759	CASE_LOW operand has been processed. */
760	#define CASE_LOW_SEEN(NODE) \
761	(CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
762
763	#define PREDICT_EXPR_OUTCOME(NODE) \
764	((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))
765	#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \
766	(PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)
767	#define PREDICT_EXPR_PREDICTOR(NODE) \
768	((enum br_predictor)tree_to_shwi (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0)))
769
770	/* In a VAR_DECL, nonzero means allocate static storage.
771	In a FUNCTION_DECL, nonzero if function has been defined.
772	In a CONSTRUCTOR, nonzero means allocate static storage. */
773	#define TREE_STATIC(NODE) ((NODE)->base.static_flag)
774
775	/* In an ADDR_EXPR, nonzero means do not use a trampoline. */
776	#define TREE_NO_TRAMPOLINE(NODE) (ADDR_EXPR_CHECK (NODE)->base.static_flag)
777
778	/* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
779	should only be executed if an exception is thrown, not on normal exit
780	of its scope. */
781	#define CLEANUP_EH_ONLY(NODE) ((NODE)->base.static_flag)
782
783	/* In a TRY_CATCH_EXPR, means that the handler should be considered a
784	separate cleanup in honor_protect_cleanup_actions. */
785	#define TRY_CATCH_IS_CLEANUP(NODE) \
786	(TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag)
787
788	/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
789	CASE_HIGH operand has been processed. */
790	#define CASE_HIGH_SEEN(NODE) \
791	(CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag)
792
793	/* Used to mark scoped enums. */
794	#define ENUM_IS_SCOPED(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.static_flag)
795
796	/* Determines whether an ENUMERAL_TYPE has defined the list of constants. */
797	#define ENUM_IS_OPAQUE(NODE) (ENUMERAL_TYPE_CHECK (NODE)->base.private_flag)
798
799	/* Determines whether a VIEW_CONVERT_EXPR node is used to create const
800	qualified variant of its first operand (used by C++ contracts). */
801	#define CONST_WRAPPER_P(NODE) \
802	(TREE_CHECK (NODE, VIEW_CONVERT_EXPR)->base.private_flag)
803
804	/* In an expr node (usually a conversion) this means the node was made
805	implicitly and should not lead to any sort of warning. In a decl node,
806	warnings concerning the decl should be suppressed. This is used at
807	least for used-before-set warnings, and it set after one warning is
808	emitted. */
809	#define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_flag)
810
811	/* Nonzero if we should warn about the change in empty class parameter
812	passing ABI in this TU. */
813	#define TRANSLATION_UNIT_WARN_EMPTY_P(NODE) \
814	(TRANSLATION_UNIT_DECL_CHECK (NODE)->decl_common.decl_flag_0)
815
816	/* Nonzero if this type is "empty" according to the particular psABI. */
817	#define TYPE_EMPTY_P(NODE) (TYPE_CHECK (NODE)->type_common.empty_flag)
818
819	/* Used to indicate that this TYPE represents a compiler-generated entity. */
820	#define TYPE_ARTIFICIAL(NODE) (TYPE_CHECK (NODE)->base.nowarning_flag)
821
822	/* True if the type is indivisible at the source level, i.e. if its
823	component parts cannot be accessed directly. This is used to suppress
824	normal GNU extensions for target-specific vector types. */
825	#define TYPE_INDIVISIBLE_P(NODE) (TYPE_CHECK (NODE)->type_common.indivisible_p)
826
827	/* True if this is a stdarg function with no named arguments (C23
828	(...) prototype, where arguments can be accessed with va_start and
829	va_arg), as opposed to an unprototyped function. */
830	#define TYPE_NO_NAMED_ARGS_STDARG_P(NODE) \
831	(FUNC_OR_METHOD_CHECK (NODE)->type_common.no_named_args_stdarg_p)
832
833	/* True if this RECORD_TYPE or UNION_TYPE includes a flexible array member
834	as the last field recursively. */
835	#define TYPE_INCLUDES_FLEXARRAY(NODE) \
836	(RECORD_OR_UNION_CHECK (NODE)->type_common.no_named_args_stdarg_p)
837
838	/* In an IDENTIFIER_NODE, this means that assemble_name was called with
839	this string as an argument. */
840	#define TREE_SYMBOL_REFERENCED(NODE) \
841	(IDENTIFIER_NODE_CHECK (NODE)->base.static_flag)
842
843	/* Nonzero in a pointer or reference type means the data pointed to
844	by this type can alias anything. */
845	#define TYPE_REF_CAN_ALIAS_ALL(NODE) \
846	(PTR_OR_REF_CHECK (NODE)->base.static_flag)
847
848	/* In an INTEGER_CST, REAL_CST, or COMPLEX_CST, this means
849	there was an overflow in folding. */
850
851	#define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag)
852
853	/* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P. */
854
855	#define TREE_OVERFLOW_P(EXPR) \
856	(CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))
857
858	/* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
859	nonzero means name is to be accessible from outside this translation unit.
860	In an IDENTIFIER_NODE, nonzero means an external declaration
861	accessible from outside this translation unit was previously seen
862	for this name in an inner scope. */
863	#define TREE_PUBLIC(NODE) ((NODE)->base.public_flag)
864
865	/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
866	of cached values, or is something else. */
867	#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK (NODE)->base.public_flag)
868
869	/* In a SAVE_EXPR, indicates that the original expression has already
870	been substituted with a VAR_DECL that contains the value. */
871	#define SAVE_EXPR_RESOLVED_P(NODE) \
872	(SAVE_EXPR_CHECK (NODE)->base.public_flag)
873
874	/* Set on a CALL_EXPR if this stdarg call should be passed the argument
875	pack. */
876	#define CALL_EXPR_VA_ARG_PACK(NODE) \
877	(CALL_EXPR_CHECK (NODE)->base.public_flag)
878
879	/* In any expression, decl, or constant, nonzero means it has side effects or
880	reevaluation of the whole expression could produce a different value.
881	This is set if any subexpression is a function call, a side effect or a
882	reference to a volatile variable. In a ..._DECL, this is set only if the
883	declaration said `volatile'. This will never be set for a constant. */
884	#define TREE_SIDE_EFFECTS(NODE) \
885	(NON_TYPE_CHECK (NODE)->base.side_effects_flag)
886
887	/* In a LABEL_DECL, nonzero means this label had its address taken
888	and therefore can never be deleted and is a jump target for
889	computed gotos. */
890	#define FORCED_LABEL(NODE) (LABEL_DECL_CHECK (NODE)->base.side_effects_flag)
891
892	/* Whether a case or a user-defined label is allowed to fall through to.
893	This is used to implement -Wimplicit-fallthrough. */
894	#define FALLTHROUGH_LABEL_P(NODE) \
895	(LABEL_DECL_CHECK (NODE)->base.private_flag)
896
897	/* Set on the artificial label created for break; stmt from a switch.
898	This is used to implement -Wimplicit-fallthrough. */
899	#define SWITCH_BREAK_LABEL_P(NODE) \
900	(LABEL_DECL_CHECK (NODE)->base.protected_flag)
901
902	/* Set on label that is known not to be jumped to, it can be only
903	reached by falling through from previous statements.
904	This is used to implement -Wimplicit-fallthrough. */
905	#define UNUSED_LABEL_P(NODE) \
906	(LABEL_DECL_CHECK (NODE)->base.default_def_flag)
907
908	/* Label used to goto around artificial .DEFERRED_INIT code for
909	C++ -ftrivial-auto-var-init= purposes with a goto around it.
910	VACUOUS_INIT_LABEL_P flag is used on the lab LABEL_DECL in:
911	goto lab;
912	lab1:
913	v1 = .DEFERRED_INIT (...);
914	v2 = .DEFERRED_INIT (...);
915	lab2:
916	v3 = .DEFERRED_INIT (...);
917	lab: */
918	#define VACUOUS_INIT_LABEL_P(NODE) \
919	(LABEL_DECL_CHECK (NODE)->base.nothrow_flag)
920
921	/* Nonzero means this expression is volatile in the C sense:
922	its address should be of type `volatile WHATEVER *'.
923	In other words, the declared item is volatile qualified.
924	This is used in _DECL nodes and _REF nodes.
925	On a FUNCTION_DECL node, this means the function does not
926	return normally. This is the same effect as setting
927	the attribute noreturn on the function in C.
928
929	In a ..._TYPE node, means this type is volatile-qualified.
930	But use TYPE_VOLATILE instead of this macro when the node is a type,
931	because eventually we may make that a different bit.
932
933	If this bit is set in an expression, so is TREE_SIDE_EFFECTS. */
934	#define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag)
935
936	/* Nonzero means this node will not trap. In an INDIRECT_REF, means
937	accessing the memory pointed to won't generate a trap. However,
938	this only applies to an object when used appropriately: it doesn't
939	mean that writing a READONLY mem won't trap.
940
941	In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
942	(or slice of the array) always belongs to the range of the array.
943	I.e. that the access will not trap, provided that the access to
944	the base to the array will not trap. */
945	#define TREE_THIS_NOTRAP(NODE) \
946	(TREE_CHECK5 (NODE, INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, \
947	ARRAY_RANGE_REF)->base.nothrow_flag)
948
949	/* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
950	nonzero means it may not be the lhs of an assignment.
951	Nonzero in a FUNCTION_DECL means this function should be treated
952	as "const" function (can only read its arguments). */
953	#define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag)
954
955	/* Value of expression is constant. Always on in all ..._CST nodes. May
956	also appear in an expression or decl where the value is constant. */
957	#define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->base.constant_flag)
958
959	/* Nonzero if NODE, a type, has had its sizes gimplified. */
960	#define TYPE_SIZES_GIMPLIFIED(NODE) \
961	(TYPE_CHECK (NODE)->base.constant_flag)
962
963	/* In a decl (most significantly a FIELD_DECL), means an unsigned field. */
964	#define DECL_UNSIGNED(NODE) \
965	(DECL_COMMON_CHECK (NODE)->base.u.bits.unsigned_flag)
966
967	/* In integral and pointer types, means an unsigned type. */
968	#define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.u.bits.unsigned_flag)
969
970	/* Same as TYPE_UNSIGNED but converted to SIGNOP. */
971	#define TYPE_SIGN(NODE) ((signop) TYPE_UNSIGNED (NODE))
972
973	/* True if overflow wraps around for the given integral or pointer type. That
974	is, TYPE_MAX + 1 == TYPE_MIN. */
975	#define TYPE_OVERFLOW_WRAPS(TYPE) \
976	(POINTER_TYPE_P (TYPE) \
977	? flag_wrapv_pointer \
978	: (ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag \
979	|| flag_wrapv))
980
981	/* True if overflow is undefined for the given integral or pointer type.
982	We may optimize on the assumption that values in the type never overflow. */
983	#define TYPE_OVERFLOW_UNDEFINED(TYPE) \
984	(POINTER_TYPE_P (TYPE) \
985	? !flag_wrapv_pointer \
986	: (!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag \
987	&& !flag_wrapv && !flag_trapv))
988
989	/* True if overflow for the given integral type should issue a
990	trap. */
991	#define TYPE_OVERFLOW_TRAPS(TYPE) \
992	(!ANY_INTEGRAL_TYPE_CHECK(TYPE)->base.u.bits.unsigned_flag && flag_trapv)
993
994	/* True if an overflow is to be preserved for sanitization. */
995	#define TYPE_OVERFLOW_SANITIZED(TYPE) \
996	(INTEGRAL_TYPE_P (TYPE) \
997	&& !TYPE_OVERFLOW_WRAPS (TYPE) \
998	&& (flag_sanitize & SANITIZE_SI_OVERFLOW))
999
1000	/* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
1001	Nonzero in a FUNCTION_DECL means that the function has been compiled.
1002	This is interesting in an inline function, since it might not need
1003	to be compiled separately.
1004	Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ENUMERAL_TYPE
1005	or TYPE_DECL if the debugging info for the type has been written.
1006	In a BLOCK node, nonzero if reorder_blocks has already seen this block.
1007	In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
1008	PHI node. */
1009	#define TREE_ASM_WRITTEN(NODE) ((NODE)->base.asm_written_flag)
1010
1011	/* Nonzero in a _DECL if the name is used in its scope.
1012	Nonzero in an expr node means inhibit warning if value is unused.
1013	In IDENTIFIER_NODEs, this means that some extern decl for this name
1014	was used.
1015	In a BLOCK, this means that the block contains variables that are used. */
1016	#define TREE_USED(NODE) ((NODE)->base.used_flag)
1017
1018	/* In a FUNCTION_DECL, nonzero means a call to the function cannot
1019	throw an exception. In a CALL_EXPR, nonzero means the call cannot
1020	throw. We can't easily check the node type here as the C++
1021	frontend also uses this flag (for AGGR_INIT_EXPR). */
1022	#define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_flag)
1023
1024	/* In a CALL_EXPR, means that it's safe to use the target of the call
1025	expansion as the return slot for a call that returns in memory. */
1026	#define CALL_EXPR_RETURN_SLOT_OPT(NODE) \
1027	(CALL_EXPR_CHECK (NODE)->base.private_flag)
1028
1029	/* In a RESULT_DECL, PARM_DECL and VAR_DECL, means that it is
1030	passed by invisible reference (and the TREE_TYPE is a pointer to the true
1031	type). */
1032	#define DECL_BY_REFERENCE(NODE) \
1033	(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, \
1034	RESULT_DECL)->decl_common.decl_by_reference_flag)
1035
1036	/* In VAR_DECL and PARM_DECL, set when the decl has been used except for
1037	being set. */
1038	#define DECL_READ_P(NODE) \
1039	(TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_read_flag)
1040
1041	/* In VAR_DECL or RESULT_DECL, set when significant code movement precludes
1042	attempting to share the stack slot with some other variable. */
1043	#define DECL_NONSHAREABLE(NODE) \
1044	(TREE_CHECK2 (NODE, VAR_DECL, \
1045	RESULT_DECL)->decl_common.decl_nonshareable_flag)
1046
1047	/* In a PARM_DECL, set for Fortran hidden string length arguments that some
1048	buggy callers don't pass to the callee. */
1049	#define DECL_HIDDEN_STRING_LENGTH(NODE) \
1050	(TREE_CHECK (NODE, PARM_DECL)->decl_common.decl_nonshareable_flag)
1051
1052	/* In a CALL_EXPR, means that the call is the jump from a thunk to the
1053	thunked-to function. Be careful to avoid using this macro when one of the
1054	next two applies instead. */
1055	#define CALL_FROM_THUNK_P(NODE) (CALL_EXPR_CHECK (NODE)->base.protected_flag)
1056
1057	/* In a CALL_EXPR, if the function being called is BUILT_IN_ALLOCA, means that
1058	it has been built for the declaration of a variable-sized object and, if the
1059	function being called is BUILT_IN_MEMCPY, means that it has been built for
1060	the assignment of a variable-sized object. */
1061	#define CALL_ALLOCA_FOR_VAR_P(NODE) \
1062	(CALL_EXPR_CHECK (NODE)->base.protected_flag)
1063
1064	/* In a CALL_EXPR, if the function being called is DECL_IS_OPERATOR_NEW_P or
1065	DECL_IS_OPERATOR_DELETE_P, true for allocator calls from C++ new or delete
1066	expressions. Not set for C++20 destroying delete operators. */
1067	#define CALL_FROM_NEW_OR_DELETE_P(NODE) \
1068	(CALL_EXPR_CHECK (NODE)->base.protected_flag)
1069
1070	/* Used in classes in C++. */
1071	#define TREE_PRIVATE(NODE) ((NODE)->base.private_flag)
1072	/* Used in classes in C++. */
1073	#define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag)
1074
1075	/* True if reference type NODE is a C++ rvalue reference. */
1076	#define TYPE_REF_IS_RVALUE(NODE) \
1077	(REFERENCE_TYPE_CHECK (NODE)->base.private_flag)
1078
1079	/* Nonzero in a _DECL if the use of the name is defined as a
1080	deprecated feature by __attribute__((deprecated)). */
1081	#define TREE_DEPRECATED(NODE) \
1082	((NODE)->base.deprecated_flag)
1083
1084	/* Nonzero in a _DECL if the use of the name is defined as an
1085	unavailable feature by __attribute__((unavailable)). */
1086	#define TREE_UNAVAILABLE(NODE) \
1087	((NODE)->base.u.bits.unavailable_flag)
1088
1089	/* Nonzero indicates an IDENTIFIER_NODE that names an anonymous
1090	aggregate, (as created by anon_aggr_name_format). */
1091	#define IDENTIFIER_ANON_P(NODE) \
1092	(IDENTIFIER_NODE_CHECK (NODE)->base.private_flag)
1093
1094	/* Nonzero indicates an IDENTIFIER_NODE that names an internal label.
1095	The prefix used to generate the label can be found on the TREE_CHAIN. */
1096	#define IDENTIFIER_INTERNAL_P(NODE) \
1097	(IDENTIFIER_NODE_CHECK (NODE)->base.volatile_flag)
1098
1099	/* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
1100	uses are to be substituted for uses of the TREE_CHAINed identifier. */
1101	#define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \
1102	(IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)
1103
1104	/* In an aggregate type, indicates that the scalar fields of the type are
1105	stored in reverse order from the target order. This effectively
1106	toggles BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN within the type. */
1107	#define TYPE_REVERSE_STORAGE_ORDER(NODE) \
1108	(TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
1109
1110	/* In a non-aggregate type, indicates a saturating type. */
1111	#define TYPE_SATURATING(NODE) \
1112	(TREE_NOT_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE)->base.u.bits.saturating_flag)
1113
1114	/* In a BIT_FIELD_REF and MEM_REF, indicates that the reference is to a group
1115	of bits stored in reverse order from the target order. This effectively
1116	toggles both BYTES_BIG_ENDIAN and WORDS_BIG_ENDIAN for the reference.
1117
1118	The overall strategy is to preserve the invariant that every scalar in
1119	memory is associated with a single storage order, i.e. all accesses to
1120	this scalar are done with the same storage order. This invariant makes
1121	it possible to factor out the storage order in most transformations, as
1122	only the address and/or the value (in target order) matter for them.
1123	But, of course, the storage order must be preserved when the accesses
1124	themselves are rewritten or transformed. */
1125	#define REF_REVERSE_STORAGE_ORDER(NODE) \
1126	(TREE_CHECK2 (NODE, BIT_FIELD_REF, MEM_REF)->base.default_def_flag)
1127
1128	/* In an ADDR_EXPR, indicates that this is a pointer to nested function
1129	represented by a descriptor instead of a trampoline. */
1130	#define FUNC_ADDR_BY_DESCRIPTOR(NODE) \
1131	(TREE_CHECK (NODE, ADDR_EXPR)->base.default_def_flag)
1132
1133	/* In a CALL_EXPR, indicates that this is an indirect call for which
1134	pointers to nested function are descriptors instead of trampolines. */
1135	#define CALL_EXPR_BY_DESCRIPTOR(NODE) \
1136	(TREE_CHECK (NODE, CALL_EXPR)->base.default_def_flag)
1137
1138	/* These flags are available for each language front end to use internally. */
1139	#define TREE_LANG_FLAG_0(NODE) \
1140	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)
1141	#define TREE_LANG_FLAG_1(NODE) \
1142	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)
1143	#define TREE_LANG_FLAG_2(NODE) \
1144	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)
1145	#define TREE_LANG_FLAG_3(NODE) \
1146	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)
1147	#define TREE_LANG_FLAG_4(NODE) \
1148	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)
1149	#define TREE_LANG_FLAG_5(NODE) \
1150	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)
1151	#define TREE_LANG_FLAG_6(NODE) \
1152	(TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)
1153
1154	/* Define additional fields and accessors for nodes representing constants. */
1155
1156	#define TREE_INT_CST_NUNITS(NODE) \
1157	(INTEGER_CST_CHECK (NODE)->base.u.int_length.unextended)
1158	#define TREE_INT_CST_EXT_NUNITS(NODE) \
1159	(INTEGER_CST_CHECK (NODE)->base.u.int_length.extended)
1160	#define TREE_INT_CST_ELT(NODE, I) TREE_INT_CST_ELT_CHECK (NODE, I)
1161	#define TREE_INT_CST_LOW(NODE) \
1162	((unsigned HOST_WIDE_INT) TREE_INT_CST_ELT (NODE, 0))
1163
1164	/* Return true if NODE is a POLY_INT_CST. This is only ever true on
1165	targets with variable-sized modes. */
1166	#define POLY_INT_CST_P(NODE) \
1167	(NUM_POLY_INT_COEFFS > 1 && TREE_CODE (NODE) == POLY_INT_CST)
1168
1169	/* In a POLY_INT_CST node. */
1170	#define POLY_INT_CST_COEFF(NODE, I) \
1171	(POLY_INT_CST_CHECK (NODE)->poly_int_cst.coeffs[I])
1172
1173	#define TREE_REAL_CST_PTR(NODE) (&REAL_CST_CHECK (NODE)->real_cst.value)
1174	#define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
1175
1176	#define TREE_FIXED_CST_PTR(NODE) \
1177	(FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)
1178	#define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE))
1179
1180	/* In a STRING_CST */
1181	/* In C terms, this is sizeof, not strlen. */
1182	#define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
1183	#define TREE_STRING_POINTER(NODE) \
1184	((const char *)(STRING_CST_CHECK (NODE)->string.str))
1185
1186	/* In a RAW_DATA_CST */
1187	#define RAW_DATA_LENGTH(NODE) \
1188	(RAW_DATA_CST_CHECK (NODE)->raw_data_cst.length)
1189	#define RAW_DATA_POINTER(NODE) \
1190	(RAW_DATA_CST_CHECK (NODE)->raw_data_cst.str)
1191	#define RAW_DATA_OWNER(NODE) \
1192	(RAW_DATA_CST_CHECK (NODE)->raw_data_cst.owner)
1193	#define RAW_DATA_UCHAR_ELT(NODE, I) \
1194	(((const unsigned char *) RAW_DATA_POINTER (NODE))[I])
1195	#define RAW_DATA_SCHAR_ELT(NODE, I) \
1196	(((const signed char *) RAW_DATA_POINTER (NODE))[I])
1197
1198	/* In a COMPLEX_CST node. */
1199	#define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
1200	#define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
1201
1202	/* In a VECTOR_CST node. See generic.texi for details. */
1203	#define VECTOR_CST_NELTS(NODE) (TYPE_VECTOR_SUBPARTS (TREE_TYPE (NODE)))
1204	#define VECTOR_CST_ELT(NODE,IDX) vector_cst_elt (NODE, IDX)
1205
1206	#define VECTOR_CST_LOG2_NPATTERNS(NODE) \
1207	(VECTOR_CST_CHECK (NODE)->base.u.vector_cst.log2_npatterns)
1208	#define VECTOR_CST_NPATTERNS(NODE) \
1209	(1U << VECTOR_CST_LOG2_NPATTERNS (NODE))
1210	#define VECTOR_CST_NELTS_PER_PATTERN(NODE) \
1211	(VECTOR_CST_CHECK (NODE)->base.u.vector_cst.nelts_per_pattern)
1212	#define VECTOR_CST_DUPLICATE_P(NODE) \
1213	(VECTOR_CST_NELTS_PER_PATTERN (NODE) == 1)
1214	#define VECTOR_CST_STEPPED_P(NODE) \
1215	(VECTOR_CST_NELTS_PER_PATTERN (NODE) == 3)
1216	#define VECTOR_CST_ENCODED_ELTS(NODE) \
1217	(VECTOR_CST_CHECK (NODE)->vector.elts)
1218	#define VECTOR_CST_ENCODED_ELT(NODE, ELT) \
1219	(VECTOR_CST_CHECK (NODE)->vector.elts[ELT])
1220
1221	/* Define fields and accessors for some special-purpose tree nodes. */
1222
1223	/* Unlike STRING_CST, in C terms this is strlen, not sizeof. */
1224	#define IDENTIFIER_LENGTH(NODE) \
1225	(IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
1226	#define IDENTIFIER_POINTER(NODE) \
1227	((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
1228	#define IDENTIFIER_HASH_VALUE(NODE) \
1229	(IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
1230
1231	/* Translate a hash table identifier pointer to a tree_identifier
1232	pointer, and vice versa. */
1233
1234	#define HT_IDENT_TO_GCC_IDENT(NODE) \
1235	((tree) ((char *) (NODE) - sizeof (struct tree_common)))
1236	#define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
1237
1238	/* In a TREE_LIST node. */
1239	#define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
1240	#define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
1241
1242	/* In TREE_VALUE of an attribute this means the attribute is never equal to
1243	different attribute with the same name and value and that the attribute
1244	is order sensitive, the order of attributes with this flag on their
1245	TREE_VALUE should be preserved. */
1246	#define ATTR_UNIQUE_VALUE_P(NODE) (TREE_LIST_CHECK (NODE)->base.protected_flag)
1247
1248	/* In a TREE_VEC node. */
1249	#define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->base.u.length)
1250	#define TREE_VEC_BEGIN(NODE) (&TREE_VEC_CHECK (NODE)->vec.a[0])
1251	#define TREE_VEC_END(NODE) \
1252	((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->base.u.length]))
1253
1254	#define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
1255
1256	/* In a CONSTRUCTOR node. */
1257	#define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
1258	#define CONSTRUCTOR_ELT(NODE,IDX) \
1259	(&(*CONSTRUCTOR_ELTS (NODE))[IDX])
1260	#define CONSTRUCTOR_NELTS(NODE) \
1261	(vec_safe_length (CONSTRUCTOR_ELTS (NODE)))
1262	#define CONSTRUCTOR_NO_CLEARING(NODE) \
1263	(CONSTRUCTOR_CHECK (NODE)->base.public_flag)
1264	/* True if even padding bits should be zeroed during initialization. */
1265	#define CONSTRUCTOR_ZERO_PADDING_BITS(NODE) \
1266	(CONSTRUCTOR_CHECK (NODE)->base.default_def_flag)
1267
1268	/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
1269	value of each element (stored within VAL). IX must be a scratch variable
1270	of unsigned integer type. */
1271	#define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
1272	for (IX = 0; (IX >= vec_safe_length (V)) \
1273	? false \
1274	: ((VAL = (*(V))[IX].value), \
1275	true); \
1276	(IX)++)
1277
1278	/* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
1279	the value of each element (stored within VAL) and its index (stored
1280	within INDEX). IX must be a scratch variable of unsigned integer type. */
1281	#define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
1282	for (IX = 0; (IX >= vec_safe_length (V)) \
1283	? false \
1284	: (((void) (VAL = (*V)[IX].value)), \
1285	(INDEX = (*V)[IX].index), \
1286	true); \
1287	(IX)++)
1288
1289	/* Append a new constructor element to V, with the specified INDEX and VAL. */
1290	#define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
1291	do { \
1292	constructor_elt _ce___ = {INDEX, VALUE}; \
1293	vec_safe_push ((V), _ce___); \
1294	} while (0)
1295
1296	/* True if NODE, a FIELD_DECL, is to be processed as a bitfield for
1297	constructor output purposes. */
1298	#define CONSTRUCTOR_BITFIELD_P(NODE) \
1299	(DECL_BIT_FIELD (FIELD_DECL_CHECK (NODE)) \
1300	&& (DECL_MODE (NODE) != BLKmode \
1301	|| TREE_CODE (TREE_TYPE (NODE)) == BITINT_TYPE))
1302
1303	/* True if NODE is a clobber right hand side, an expression of indeterminate
1304	value that clobbers the LHS in a copy instruction. We use a volatile
1305	empty CONSTRUCTOR for this, as it matches most of the necessary semantic.
1306	In particular the volatile flag causes us to not prematurely remove
1307	such clobber instructions. */
1308	#define TREE_CLOBBER_P(NODE) \
1309	(TREE_CODE (NODE) == CONSTRUCTOR && TREE_THIS_VOLATILE (NODE))
1310
1311	/* Return the clobber_kind of a CLOBBER CONSTRUCTOR. */
1312	#define CLOBBER_KIND(NODE) \
1313	(CONSTRUCTOR_CHECK (NODE)->base.u.bits.address_space)
1314
1315	/* Define fields and accessors for some nodes that represent expressions. */
1316
1317	/* Nonzero if NODE is an empty statement (NOP_EXPR <0>). */
1318	#define IS_EMPTY_STMT(NODE) (TREE_CODE (NODE) == NOP_EXPR \
1319	&& VOID_TYPE_P (TREE_TYPE (NODE)) \
1320	&& integer_zerop (TREE_OPERAND (NODE, 0)))
1321
1322	/* In ordinary expression nodes. */
1323	#define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE)
1324	#define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
1325
1326	/* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
1327	length. Its value includes the length operand itself; that is,
1328	the minimum valid length is 1.
1329	Note that we have to bypass the use of TREE_OPERAND to access
1330	that field to avoid infinite recursion in expanding the macros. */
1331	#define VL_EXP_OPERAND_LENGTH(NODE) \
1332	((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0]))
1333
1334	/* Nonzero if gimple_debug_nonbind_marker_p() may possibly hold. */
1335	#define MAY_HAVE_DEBUG_MARKER_STMTS debug_nonbind_markers_p
1336	/* Nonzero if gimple_debug_bind_p() (and thus
1337	gimple_debug_source_bind_p()) may possibly hold. */
1338	#define MAY_HAVE_DEBUG_BIND_STMTS flag_var_tracking_assignments
1339	/* Nonzero if is_gimple_debug() may possibly hold. */
1340	#define MAY_HAVE_DEBUG_STMTS \
1341	(MAY_HAVE_DEBUG_MARKER_STMTS || MAY_HAVE_DEBUG_BIND_STMTS)
1342
1343	/* In a LOOP_EXPR node. */
1344	#define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
1345
1346	/* The source location of this expression. Non-tree_exp nodes such as
1347	decls and constants can be shared among multiple locations, so
1348	return nothing. */
1349	#define EXPR_LOCATION(NODE) \
1350	(CAN_HAVE_LOCATION_P ((NODE)) ? (NODE)->exp.locus : UNKNOWN_LOCATION)
1351	#define SET_EXPR_LOCATION(NODE, LOCUS) EXPR_CHECK ((NODE))->exp.locus = (LOCUS)
1352	#define EXPR_HAS_LOCATION(NODE) (LOCATION_LOCUS (EXPR_LOCATION (NODE)) \
1353	!= UNKNOWN_LOCATION)
1354	/* The location to be used in a diagnostic about this expression. Do not
1355	use this macro if the location will be assigned to other expressions. */
1356	#define EXPR_LOC_OR_LOC(NODE, LOCUS) (EXPR_HAS_LOCATION (NODE) \
1357	? (NODE)->exp.locus : (LOCUS))
1358	#define EXPR_FILENAME(NODE) LOCATION_FILE (EXPR_CHECK ((NODE))->exp.locus)
1359	#define EXPR_LINENO(NODE) LOCATION_LINE (EXPR_CHECK (NODE)->exp.locus)
1360
1361	#define CAN_HAVE_RANGE_P(NODE) (CAN_HAVE_LOCATION_P (NODE))
1362	#define EXPR_LOCATION_RANGE(NODE) (get_expr_source_range (EXPR_CHECK ((NODE))))
1363
1364	#define EXPR_HAS_RANGE(NODE) \
1365	(CAN_HAVE_RANGE_P (NODE) \
1366	? EXPR_LOCATION_RANGE (NODE).m_start != UNKNOWN_LOCATION \
1367	: false)
1368
1369	/* True if a tree is an expression or statement that can have a
1370	location. */
1371	#define CAN_HAVE_LOCATION_P(NODE) ((NODE) && EXPR_P (NODE))
1372
1373	inline source_range
1374	get_expr_source_range (tree expr)
1375	{
1376	location_t loc = EXPR_LOCATION (expr);
1377	return get_range_from_loc (set: line_table, loc);
1378	}
1379
1380	extern void protected_set_expr_location (tree, location_t);
1381	extern void protected_set_expr_location_if_unset (tree, location_t);
1382	ATTRIBUTE_WARN_UNUSED_RESULT
1383	extern tree protected_set_expr_location_unshare (tree, location_t);
1384
1385	WARN_UNUSED_RESULT extern tree maybe_wrap_with_location (tree, location_t);
1386
1387	extern int suppress_location_wrappers;
1388
1389	/* A class for suppressing the creation of location wrappers.
1390	Location wrappers will not be created during the lifetime
1391	of an instance of this class. */
1392
1393	class auto_suppress_location_wrappers
1394	{
1395	public:
1396	auto_suppress_location_wrappers () { ++suppress_location_wrappers; }
1397	~auto_suppress_location_wrappers () { --suppress_location_wrappers; }
1398	};
1399
1400	/* In a TARGET_EXPR node. */
1401	#define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
1402	#define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
1403	#define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
1404	/* Don't elide the initialization of TARGET_EXPR_SLOT for this TARGET_EXPR
1405	on rhs of MODIFY_EXPR. */
1406	#define TARGET_EXPR_NO_ELIDE(NODE) (TARGET_EXPR_CHECK (NODE)->base.private_flag)
1407
1408	/* DECL_EXPR accessor. This gives access to the DECL associated with
1409	the given declaration statement. */
1410	#define DECL_EXPR_DECL(NODE) TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
1411
1412	#define EXIT_EXPR_COND(NODE) TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
1413
1414	/* COMPOUND_LITERAL_EXPR accessors. */
1415	#define COMPOUND_LITERAL_EXPR_DECL_EXPR(NODE) \
1416	TREE_OPERAND (COMPOUND_LITERAL_EXPR_CHECK (NODE), 0)
1417	#define COMPOUND_LITERAL_EXPR_DECL(NODE) \
1418	DECL_EXPR_DECL (COMPOUND_LITERAL_EXPR_DECL_EXPR (NODE))
1419
1420	/* SWITCH_EXPR accessors. These give access to the condition and body. */
1421	#define SWITCH_COND(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
1422	#define SWITCH_BODY(NODE) TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
1423	/* True if there are case labels for all possible values of SWITCH_COND, either
1424	because there is a default: case label or because the case label ranges cover
1425	all values. */
1426	#define SWITCH_ALL_CASES_P(NODE) (SWITCH_EXPR_CHECK (NODE)->base.private_flag)
1427
1428	/* CASE_LABEL_EXPR accessors. These give access to the high and low values
1429	of a case label, respectively. */
1430	#define CASE_LOW(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
1431	#define CASE_HIGH(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
1432	#define CASE_LABEL(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
1433	#define CASE_CHAIN(NODE) TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 3)
1434
1435	/* The operands of a TARGET_MEM_REF. Operands 0 and 1 have to match
1436	corresponding MEM_REF operands. */
1437	#define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
1438	#define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
1439	#define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
1440	#define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
1441	#define TMR_INDEX2(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
1442
1443	#define MR_DEPENDENCE_CLIQUE(NODE) \
1444	(TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.clique)
1445	#define MR_DEPENDENCE_BASE(NODE) \
1446	(TREE_CHECK2 (NODE, MEM_REF, TARGET_MEM_REF)->base.u.dependence_info.base)
1447
1448	/* The operands of a BIND_EXPR. */
1449	#define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
1450	#define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
1451	#define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
1452
1453	/* GOTO_EXPR accessor. This gives access to the label associated with
1454	a goto statement. */
1455	#define GOTO_DESTINATION(NODE) TREE_OPERAND (GOTO_EXPR_CHECK (NODE), 0)
1456
1457	/* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
1458	instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
1459	ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
1460	statement. */
1461	#define ASM_STRING(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
1462	#define ASM_OUTPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
1463	#define ASM_INPUTS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
1464	#define ASM_CLOBBERS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
1465	#define ASM_LABELS(NODE) TREE_OPERAND (ASM_EXPR_CHECK (NODE), 4)
1466	/* Nonzero if the asm is a basic asm, zero if it is an extended asm.
1467	Basic asms use a plain ASM_INPUT insn pattern whereas extended asms
1468	use an ASM_OPERANDS insn pattern. */
1469	#define ASM_BASIC_P(NODE) (ASM_EXPR_CHECK (NODE)->base.static_flag)
1470	#define ASM_VOLATILE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.public_flag)
1471	/* Nonzero if we want to consider this asm as minimum length and cost
1472	for inlining decisions. */
1473	#define ASM_INLINE_P(NODE) (ASM_EXPR_CHECK (NODE)->base.protected_flag)
1474
1475	/* COND_EXPR accessors. */
1476	#define COND_EXPR_COND(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
1477	#define COND_EXPR_THEN(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
1478	#define COND_EXPR_ELSE(NODE) (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
1479
1480	/* Accessors for the chains of recurrences. */
1481	#define CHREC_LEFT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)
1482	#define CHREC_RIGHT(NODE) TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)
1483	#define CHREC_VARIABLE(NODE) POLYNOMIAL_CHREC_CHECK (NODE)->base.u.chrec_var
1484	/* Nonzero if this chrec doesn't overflow (i.e., nonwrapping). */
1485	#define CHREC_NOWRAP(NODE) POLYNOMIAL_CHREC_CHECK (NODE)->base.nothrow_flag
1486
1487	/* LABEL_EXPR accessor. This gives access to the label associated with
1488	the given label expression. */
1489	#define LABEL_EXPR_LABEL(NODE) TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
1490
1491	/* CATCH_EXPR accessors. */
1492	#define CATCH_TYPES(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
1493	#define CATCH_BODY(NODE) TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
1494
1495	/* EH_FILTER_EXPR accessors. */
1496	#define EH_FILTER_TYPES(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
1497	#define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
1498
1499	/* OBJ_TYPE_REF accessors. */
1500	#define OBJ_TYPE_REF_EXPR(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
1501	#define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
1502	#define OBJ_TYPE_REF_TOKEN(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
1503
1504	/* CALL_EXPR accessors. */
1505	#define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)
1506	#define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)
1507	#define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)
1508	#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH (NODE) - 3)
1509	#define CALL_EXPR_IFN(NODE) (CALL_EXPR_CHECK (NODE)->base.u.ifn)
1510
1511	/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
1512	We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
1513	the argument count is zero when checking is enabled. Instead, do
1514	the pointer arithmetic to advance past the 3 fixed operands in a
1515	CALL_EXPR. That produces a valid pointer to just past the end of the
1516	operand array, even if it's not valid to dereference it. */
1517	#define CALL_EXPR_ARGP(NODE) \
1518	(&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3)
1519
1520	/* TM directives and accessors. */
1521	#define TRANSACTION_EXPR_BODY(NODE) \
1522	TREE_OPERAND (TRANSACTION_EXPR_CHECK (NODE), 0)
1523	#define TRANSACTION_EXPR_OUTER(NODE) \
1524	(TRANSACTION_EXPR_CHECK (NODE)->base.static_flag)
1525	#define TRANSACTION_EXPR_RELAXED(NODE) \
1526	(TRANSACTION_EXPR_CHECK (NODE)->base.public_flag)
1527
1528	/* OpenMP and OpenACC directive and clause accessors. */
1529
1530	/* Generic accessors for OMP nodes that keep the body as operand 0, and clauses
1531	as operand 1. */
1532	#define OMP_BODY(NODE) \
1533	TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_MASTER), 0)
1534	#define OMP_CLAUSES(NODE) \
1535	TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_PARALLEL, OMP_SCAN), 1)
1536
1537	/* Generic accessors for OMP nodes that keep clauses as operand 0. */
1538	#define OMP_STANDALONE_CLAUSES(NODE) \
1539	TREE_OPERAND (TREE_RANGE_CHECK (NODE, OACC_CACHE, OMP_TARGET_EXIT_DATA), 0)
1540
1541	#define OACC_DATA_BODY(NODE) \
1542	TREE_OPERAND (OACC_DATA_CHECK (NODE), 0)
1543	#define OACC_DATA_CLAUSES(NODE) \
1544	TREE_OPERAND (OACC_DATA_CHECK (NODE), 1)
1545
1546	#define OACC_HOST_DATA_BODY(NODE) \
1547	TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 0)
1548	#define OACC_HOST_DATA_CLAUSES(NODE) \
1549	TREE_OPERAND (OACC_HOST_DATA_CHECK (NODE), 1)
1550
1551	#define OACC_CACHE_CLAUSES(NODE) \
1552	TREE_OPERAND (OACC_CACHE_CHECK (NODE), 0)
1553
1554	#define OACC_DECLARE_CLAUSES(NODE) \
1555	TREE_OPERAND (OACC_DECLARE_CHECK (NODE), 0)
1556
1557	#define OACC_ENTER_DATA_CLAUSES(NODE) \
1558	TREE_OPERAND (OACC_ENTER_DATA_CHECK (NODE), 0)
1559
1560	#define OACC_EXIT_DATA_CLAUSES(NODE) \
1561	TREE_OPERAND (OACC_EXIT_DATA_CHECK (NODE), 0)
1562
1563	#define OACC_UPDATE_CLAUSES(NODE) \
1564	TREE_OPERAND (OACC_UPDATE_CHECK (NODE), 0)
1565
1566	#define OMP_PARALLEL_BODY(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
1567	#define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
1568
1569	#define OMP_TASK_BODY(NODE) TREE_OPERAND (OMP_TASK_CHECK (NODE), 0)
1570	#define OMP_TASK_CLAUSES(NODE) TREE_OPERAND (OMP_TASK_CHECK (NODE), 1)
1571
1572	#define OMP_TASKREG_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_TASK)
1573	#define OMP_TASKREG_BODY(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 0)
1574	#define OMP_TASKREG_CLAUSES(NODE) TREE_OPERAND (OMP_TASKREG_CHECK (NODE), 1)
1575
1576	#define OMP_LOOPING_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_FOR, OACC_LOOP)
1577	#define OMP_FOR_BODY(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 0)
1578	#define OMP_FOR_CLAUSES(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 1)
1579	#define OMP_FOR_INIT(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 2)
1580	#define OMP_FOR_COND(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 3)
1581	#define OMP_FOR_INCR(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 4)
1582	#define OMP_FOR_PRE_BODY(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 5)
1583	#define OMP_FOR_ORIG_DECLS(NODE) TREE_OPERAND (OMP_LOOPING_CHECK (NODE), 6)
1584
1585	#define OMP_INTEROP_CLAUSES(NODE)\
1586	TREE_OPERAND (OMP_INTEROP_CHECK (NODE), 0)
1587
1588	#define OMP_LOOPXFORM_CHECK(NODE) TREE_RANGE_CHECK (NODE, OMP_TILE, OMP_UNROLL)
1589	#define OMP_LOOPXFORM_LOWERED(NODE) \
1590	(OMP_LOOPXFORM_CHECK (NODE)->base.public_flag)
1591
1592	#define OMP_SECTIONS_BODY(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
1593	#define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
1594
1595	#define OMP_SECTION_BODY(NODE) TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)
1596
1597	#define OMP_STRUCTURED_BLOCK_BODY(NODE) \
1598	TREE_OPERAND (OMP_STRUCTURED_BLOCK_CHECK (NODE), 0)
1599
1600	#define OMP_SINGLE_BODY(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
1601	#define OMP_SINGLE_CLAUSES(NODE) TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
1602
1603	#define OMP_SCOPE_BODY(NODE) TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 0)
1604	#define OMP_SCOPE_CLAUSES(NODE) TREE_OPERAND (OMP_SCOPE_CHECK (NODE), 1)
1605
1606	#define OMP_MASTER_BODY(NODE) TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
1607
1608	#define OMP_MASKED_BODY(NODE) TREE_OPERAND (OMP_MASKED_CHECK (NODE), 0)
1609	#define OMP_MASKED_CLAUSES(NODE) TREE_OPERAND (OMP_MASKED_CHECK (NODE), 1)
1610
1611	#define OMP_TASKGROUP_BODY(NODE) TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 0)
1612	#define OMP_TASKGROUP_CLAUSES(NODE) \
1613	TREE_OPERAND (OMP_TASKGROUP_CHECK (NODE), 1)
1614
1615	#define OMP_ORDERED_BODY(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
1616	#define OMP_ORDERED_CLAUSES(NODE) TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 1)
1617
1618	#define OMP_CRITICAL_BODY(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
1619	#define OMP_CRITICAL_CLAUSES(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
1620	#define OMP_CRITICAL_NAME(NODE) TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 2)
1621
1622	#define OMP_TEAMS_BODY(NODE) TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 0)
1623	#define OMP_TEAMS_CLAUSES(NODE) TREE_OPERAND (OMP_TEAMS_CHECK (NODE), 1)
1624
1625	#define OMP_TARGET_DATA_BODY(NODE) \
1626	TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 0)
1627	#define OMP_TARGET_DATA_CLAUSES(NODE)\
1628	TREE_OPERAND (OMP_TARGET_DATA_CHECK (NODE), 1)
1629
1630	#define OMP_TARGET_BODY(NODE) TREE_OPERAND (OMP_TARGET_CHECK (NODE), 0)
1631	#define OMP_TARGET_CLAUSES(NODE) TREE_OPERAND (OMP_TARGET_CHECK (NODE), 1)
1632
1633	#define OMP_TARGET_UPDATE_CLAUSES(NODE)\
1634	TREE_OPERAND (OMP_TARGET_UPDATE_CHECK (NODE), 0)
1635
1636	#define OMP_TARGET_ENTER_DATA_CLAUSES(NODE)\
1637	TREE_OPERAND (OMP_TARGET_ENTER_DATA_CHECK (NODE), 0)
1638
1639	#define OMP_TARGET_EXIT_DATA_CLAUSES(NODE)\
1640	TREE_OPERAND (OMP_TARGET_EXIT_DATA_CHECK (NODE), 0)
1641
1642	#define OMP_METADIRECTIVE_VARIANTS(NODE) \
1643	TREE_OPERAND (OMP_METADIRECTIVE_CHECK (NODE), 0)
1644
1645	#define OMP_METADIRECTIVE_VARIANT_SELECTOR(v) \
1646	TREE_PURPOSE (v)
1647	#define OMP_METADIRECTIVE_VARIANT_DIRECTIVE(v) \
1648	TREE_PURPOSE (TREE_VALUE (v))
1649	#define OMP_METADIRECTIVE_VARIANT_BODY(v) \
1650	TREE_VALUE (TREE_VALUE (v))
1651
1652	#define OMP_DECLARE_MAPPER_ID(NODE) \
1653	TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 0)
1654	#define OMP_DECLARE_MAPPER_DECL(NODE) \
1655	TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 1)
1656	#define OMP_DECLARE_MAPPER_CLAUSES(NODE) \
1657	TREE_OPERAND (OMP_DECLARE_MAPPER_CHECK (NODE), 2)
1658
1659	#define OMP_SCAN_BODY(NODE) TREE_OPERAND (OMP_SCAN_CHECK (NODE), 0)
1660	#define OMP_SCAN_CLAUSES(NODE) TREE_OPERAND (OMP_SCAN_CHECK (NODE), 1)
1661
1662	#define OMP_DISPATCH_BODY(NODE) TREE_OPERAND (OMP_DISPATCH_CHECK (NODE), 0)
1663	#define OMP_DISPATCH_CLAUSES(NODE) TREE_OPERAND (OMP_DISPATCH_CHECK (NODE), 1)
1664
1665	#define OMP_CLAUSE_SIZE(NODE) \
1666	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1667	OMP_CLAUSE_FROM, \
1668	OMP_CLAUSE__CACHE_), 1)
1669
1670	#define OMP_CLAUSE_CHAIN(NODE) TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
1671	#define OMP_CLAUSE_DECL(NODE) \
1672	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1673	OMP_CLAUSE_PRIVATE, \
1674	OMP_CLAUSE__SCANTEMP_), 0)
1675	#define OMP_CLAUSE_HAS_LOCATION(NODE) \
1676	(LOCATION_LOCUS ((OMP_CLAUSE_CHECK (NODE))->omp_clause.locus) \
1677	!= UNKNOWN_LOCATION)
1678	#define OMP_CLAUSE_LOCATION(NODE) (OMP_CLAUSE_CHECK (NODE))->omp_clause.locus
1679
1680	#define OMP_CLAUSE_HAS_ITERATORS(NODE) \
1681	((OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_FROM \
1682	|| OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_TO \
1683	|| OMP_CLAUSE_CODE (NODE) == OMP_CLAUSE_MAP) \
1684	&& OMP_CLAUSE_ITERATORS (NODE))
1685	#define OMP_CLAUSE_ITERATORS(NODE) \
1686	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1687	OMP_CLAUSE_FROM, \
1688	OMP_CLAUSE_MAP), 2)
1689
1690	/* True on OMP_FOR and other OpenMP/OpenACC looping constructs if the loop nest
1691	is non-rectangular. */
1692	#define OMP_FOR_NON_RECTANGULAR(NODE) \
1693	(OMP_LOOPING_CHECK (NODE)->base.private_flag)
1694
1695	/* True on an OMP_SECTION statement that was the last lexical member.
1696	This status is meaningful in the implementation of lastprivate. */
1697	#define OMP_SECTION_LAST(NODE) \
1698	(OMP_SECTION_CHECK (NODE)->base.private_flag)
1699
1700	/* True on an OMP_PARALLEL statement if it represents an explicit
1701	combined parallel work-sharing constructs. */
1702	#define OMP_PARALLEL_COMBINED(NODE) \
1703	(OMP_PARALLEL_CHECK (NODE)->base.private_flag)
1704
1705	/* True on an OMP_TEAMS statement if it represents an explicit
1706	combined teams distribute constructs. */
1707	#define OMP_TEAMS_COMBINED(NODE) \
1708	(OMP_TEAMS_CHECK (NODE)->base.private_flag)
1709
1710	/* True on an OMP_TARGET statement if it represents explicit
1711	combined target teams, target parallel or target simd constructs. */
1712	#define OMP_TARGET_COMBINED(NODE) \
1713	(OMP_TARGET_CHECK (NODE)->base.private_flag)
1714
1715	/* True on an OMP_MASTER statement if it represents an explicit
1716	combined master constructs. */
1717	#define OMP_MASTER_COMBINED(NODE) \
1718	(OMP_MASTER_CHECK (NODE)->base.private_flag)
1719
1720	/* True on an OMP_MASKED statement if it represents an explicit
1721	combined masked constructs. */
1722	#define OMP_MASKED_COMBINED(NODE) \
1723	(OMP_MASKED_CHECK (NODE)->base.private_flag)
1724
1725	/* Memory order for OMP_ATOMIC*. */
1726	#define OMP_ATOMIC_MEMORY_ORDER(NODE) \
1727	(TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \
1728	OMP_ATOMIC_CAPTURE_NEW)->base.u.omp_atomic_memory_order)
1729
1730	/* Weak clause on OMP_ATOMIC*. */
1731	#define OMP_ATOMIC_WEAK(NODE) \
1732	(TREE_RANGE_CHECK (NODE, OMP_ATOMIC, \
1733	OMP_ATOMIC_CAPTURE_NEW)->base.public_flag)
1734
1735	/* True on a PRIVATE clause if its decl is kept around for debugging
1736	information only and its DECL_VALUE_EXPR is supposed to point
1737	to what it has been remapped to. */
1738	#define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \
1739	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE)->base.public_flag)
1740
1741	/* True on a PRIVATE clause if ctor needs access to outer region's
1742	variable. */
1743	#define OMP_CLAUSE_PRIVATE_OUTER_REF(NODE) \
1744	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
1745
1746	/* True if a PRIVATE clause is for a C++ class IV on taskloop construct
1747	(thus should be private on the outer taskloop and firstprivate on
1748	task). */
1749	#define OMP_CLAUSE_PRIVATE_TASKLOOP_IV(NODE) \
1750	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
1751
1752	/* True on a FIRSTPRIVATE clause if it has been added implicitly. */
1753	#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT(NODE) \
1754	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE)->base.public_flag)
1755
1756	/* True on a FIRSTPRIVATE clause if only the reference and not what it refers
1757	to should be firstprivatized. */
1758	#define OMP_CLAUSE_FIRSTPRIVATE_NO_REFERENCE(NODE) \
1759	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
1760
1761	/* True on a FIRSTPRIVATE clause with OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT also
1762	set if target construct is the only one that accepts the clause. */
1763	#define OMP_CLAUSE_FIRSTPRIVATE_IMPLICIT_TARGET(NODE) \
1764	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FIRSTPRIVATE))
1765
1766	/* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
1767	decl is present in the chain. */
1768	#define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \
1769	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE)->base.public_flag)
1770	#define OMP_CLAUSE_LASTPRIVATE_STMT(NODE) \
1771	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
1772	OMP_CLAUSE_LASTPRIVATE),\
1773	1)
1774	#define OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ(NODE) \
1775	(OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
1776
1777	/* True if a LASTPRIVATE clause is for a C++ class IV on taskloop or
1778	loop construct (thus should be lastprivate on the outer taskloop and
1779	firstprivate on task for the taskloop construct and carefully handled
1780	for loop construct). */
1781	#define OMP_CLAUSE_LASTPRIVATE_LOOP_IV(NODE) \
1782	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
1783
1784	/* True if a LASTPRIVATE clause has CONDITIONAL: modifier. */
1785	#define OMP_CLAUSE_LASTPRIVATE_CONDITIONAL(NODE) \
1786	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
1787
1788	/* True on a SHARED clause if a FIRSTPRIVATE clause for the same
1789	decl is present in the chain (this can happen only for taskloop
1790	with FIRSTPRIVATE/LASTPRIVATE on it originally. */
1791	#define OMP_CLAUSE_SHARED_FIRSTPRIVATE(NODE) \
1792	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED)->base.public_flag)
1793
1794	/* True on a SHARED clause if a scalar is not modified in the body and
1795	thus could be optimized as firstprivate. */
1796	#define OMP_CLAUSE_SHARED_READONLY(NODE) \
1797	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SHARED))
1798
1799	#define OMP_CLAUSE_IF_MODIFIER(NODE) \
1800	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF)->omp_clause.subcode.if_modifier)
1801
1802	#define OMP_CLAUSE_FINAL_EXPR(NODE) \
1803	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FINAL), 0)
1804	#define OMP_CLAUSE_IF_EXPR(NODE) \
1805	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
1806	#define OMP_CLAUSE_SELF_EXPR(NODE) \
1807	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SELF), 0)
1808	#define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \
1809	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
1810	#define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \
1811	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)
1812	#define OMP_CLAUSE_NUM_TASKS_EXPR(NODE) \
1813	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS), 0)
1814	#define OMP_CLAUSE_HINT_EXPR(NODE) \
1815	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_HINT), 0)
1816	#define OMP_CLAUSE_FILTER_EXPR(NODE) \
1817	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_FILTER), 0)
1818	#define OMP_CLAUSE_PARTIAL_EXPR(NODE) \
1819	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PARTIAL), 0)
1820	#define OMP_CLAUSE_SIZES_LIST(NODE) \
1821	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIZES), 0)
1822	#define OMP_CLAUSE_NOVARIANTS_EXPR(NODE) \
1823	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NOVARIANTS), 0)
1824	#define OMP_CLAUSE_NOCONTEXT_EXPR(NODE) \
1825	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NOCONTEXT), 0)
1826
1827	#define OMP_CLAUSE_GRAINSIZE_EXPR(NODE) \
1828	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE),0)
1829
1830	#define OMP_CLAUSE_PRIORITY_EXPR(NODE) \
1831	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIORITY),0)
1832
1833	#define OMP_CLAUSE_GRAINSIZE_STRICT(NODE) \
1834	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GRAINSIZE))
1835	#define OMP_CLAUSE_NUM_TASKS_STRICT(NODE) \
1836	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TASKS))
1837
1838	/* OpenACC clause expressions */
1839	#define OMP_CLAUSE_EXPR(NODE, CLAUSE) \
1840	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, CLAUSE), 0)
1841	#define OMP_CLAUSE_GANG_EXPR(NODE) \
1842	OMP_CLAUSE_OPERAND ( \
1843	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 0)
1844	#define OMP_CLAUSE_GANG_STATIC_EXPR(NODE) \
1845	OMP_CLAUSE_OPERAND ( \
1846	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_GANG), 1)
1847	#define OMP_CLAUSE_ASYNC_EXPR(NODE) \
1848	OMP_CLAUSE_OPERAND ( \
1849	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ASYNC), 0)
1850	#define OMP_CLAUSE_WAIT_EXPR(NODE) \
1851	OMP_CLAUSE_OPERAND ( \
1852	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WAIT), 0)
1853	#define OMP_CLAUSE_VECTOR_EXPR(NODE) \
1854	OMP_CLAUSE_OPERAND ( \
1855	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR), 0)
1856	#define OMP_CLAUSE_WORKER_EXPR(NODE) \
1857	OMP_CLAUSE_OPERAND ( \
1858	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_WORKER), 0)
1859	#define OMP_CLAUSE_NUM_GANGS_EXPR(NODE) \
1860	OMP_CLAUSE_OPERAND ( \
1861	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_GANGS), 0)
1862	#define OMP_CLAUSE_NUM_WORKERS_EXPR(NODE) \
1863	OMP_CLAUSE_OPERAND ( \
1864	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_WORKERS), 0)
1865	#define OMP_CLAUSE_VECTOR_LENGTH_EXPR(NODE) \
1866	OMP_CLAUSE_OPERAND ( \
1867	OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_VECTOR_LENGTH), 0)
1868
1869	#define OMP_CLAUSE_DEPEND_KIND(NODE) \
1870	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEPEND)->omp_clause.subcode.depend_kind)
1871
1872	#define OMP_CLAUSE_DOACROSS_KIND(NODE) \
1873	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS)->omp_clause.subcode.doacross_kind)
1874
1875	#define OMP_CLAUSE_DOACROSS_SINK_NEGATIVE(NODE) \
1876	TREE_PUBLIC (TREE_LIST_CHECK (NODE))
1877
1878	/* True if DOACROSS clause is spelled as DEPEND. */
1879	#define OMP_CLAUSE_DOACROSS_DEPEND(NODE) \
1880	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DOACROSS))
1881
1882	#define OMP_CLAUSE_MAP_KIND(NODE) \
1883	((enum gomp_map_kind) OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind)
1884	#define OMP_CLAUSE_SET_MAP_KIND(NODE, MAP_KIND) \
1885	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->omp_clause.subcode.map_kind \
1886	= (unsigned int) (MAP_KIND))
1887
1888	#define OMP_CLAUSE_MOTION_PRESENT(NODE) \
1889	(OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_FROM, OMP_CLAUSE_TO)->base.deprecated_flag)
1890
1891	#define OMP_CLAUSE_INIT_TARGET(NODE) \
1892	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INIT)->base.public_flag)
1893	#define OMP_CLAUSE_INIT_TARGETSYNC(NODE) \
1894	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INIT)->base.deprecated_flag)
1895	#define OMP_CLAUSE_INIT_PREFER_TYPE(NODE) \
1896	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE), \
1897	OMP_CLAUSE_INIT, \
1898	OMP_CLAUSE_INIT), 1)
1899
1900	/* Nonzero if this map clause is for array (rather than pointer) based array
1901	section with zero bias. Both the non-decl OMP_CLAUSE_MAP and corresponding
1902	OMP_CLAUSE_MAP with GOMP_MAP_POINTER are marked with this flag. */
1903	#define OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION(NODE) \
1904	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.public_flag)
1905	/* Nonzero if this is a mapped array section, that might need special
1906	treatment if OMP_CLAUSE_SIZE is zero. */
1907	#define OMP_CLAUSE_MAP_MAYBE_ZERO_LENGTH_ARRAY_SECTION(NODE) \
1908	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1909	/* Nonzero if this map clause is for an OpenACC compute construct's reduction
1910	variable or OpenMP map clause mentioned also in in_reduction clause on the
1911	same construct. */
1912	#define OMP_CLAUSE_MAP_IN_REDUCTION(NODE) \
1913	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1914	/* Nonzero on map clauses added implicitly for reduction clauses on combined
1915	or composite constructs. They shall be removed if there is an explicit
1916	map clause. */
1917	#define OMP_CLAUSE_MAP_IMPLICIT(NODE) \
1918	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.default_def_flag)
1919	/* Nonzero if this map clause is to be indicated to the runtime as 'implicit',
1920	due to being created through implicit data-mapping rules in the middle-end.
1921	NOTE: this is different than OMP_CLAUSE_MAP_IMPLICIT. */
1922	#define OMP_CLAUSE_MAP_RUNTIME_IMPLICIT_P(NODE) \
1923	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.deprecated_flag)
1924	/* Nonzero for an attach/detach node whose decl was explicitly mapped on the
1925	same directive. */
1926	#define OMP_CLAUSE_ATTACHMENT_MAPPING_ERASED(NODE) \
1927	TREE_STATIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1928	/* Nonzero if this is a release/delete node which refers to a (Fortran) array
1929	descriptor. */
1930	#define OMP_CLAUSE_RELEASE_DESCRIPTOR(NODE) \
1931	TREE_NOTHROW (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1932
1933	/* Flag that 'OMP_CLAUSE_DECL (NODE)' is to be made addressable during OMP
1934	lowering. */
1935	#define OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE(NODE) \
1936	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP)->base.addressable_flag)
1937
1938	/* Nonzero if OpenACC 'readonly' modifier set, used for 'copyin'. */
1939	#define OMP_CLAUSE_MAP_READONLY(NODE) \
1940	TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_MAP))
1941
1942	/* Same as above, for use in OpenACC cache directives. */
1943	#define OMP_CLAUSE__CACHE__READONLY(NODE) \
1944	TREE_READONLY (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CACHE_))
1945
1946	/* True on an OMP_CLAUSE_USE_DEVICE_PTR with an OpenACC 'if_present'
1947	clause. */
1948	#define OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT(NODE) \
1949	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USE_DEVICE_PTR)->base.public_flag)
1950
1951	#define OMP_CLAUSE_PROC_BIND_KIND(NODE) \
1952	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PROC_BIND)->omp_clause.subcode.proc_bind_kind)
1953
1954	#define OMP_CLAUSE_DEVICE_TYPE_KIND(NODE) \
1955	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE_TYPE)->omp_clause.subcode.device_type_kind)
1956
1957	#define OMP_CLAUSE_INDIRECT_EXPR(NODE) \
1958	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_INDIRECT), 0)
1959
1960
1961	/* True if there is a device clause with a device-modifier 'ancestor'. */
1962	#define OMP_CLAUSE_DEVICE_ANCESTOR(NODE) \
1963	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE)->base.public_flag)
1964
1965	#define OMP_CLAUSE_COLLAPSE_EXPR(NODE) \
1966	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 0)
1967	#define OMP_CLAUSE_COLLAPSE_ITERVAR(NODE) \
1968	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 1)
1969	#define OMP_CLAUSE_COLLAPSE_COUNT(NODE) \
1970	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_COLLAPSE), 2)
1971
1972	#define OMP_CLAUSE_ORDERED_EXPR(NODE) \
1973	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED), 0)
1974
1975	/* True on an OMP_CLAUSE_ORDERED if stand-alone ordered construct is nested
1976	inside of work-sharing loop the clause is on. */
1977	#define OMP_CLAUSE_ORDERED_DOACROSS(NODE) \
1978	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDERED)->base.public_flag)
1979
1980	/* True for unconstrained modifier on order(concurrent) clause. */
1981	#define OMP_CLAUSE_ORDER_UNCONSTRAINED(NODE) \
1982	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER)->base.public_flag)
1983	/* True for reproducible modifier on order(concurrent) clause. */
1984	#define OMP_CLAUSE_ORDER_REPRODUCIBLE(NODE) \
1985	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ORDER))
1986
1987	#define OMP_CLAUSE_REDUCTION_CODE(NODE) \
1988	(OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1989	OMP_CLAUSE_IN_REDUCTION)->omp_clause.subcode.reduction_code)
1990	#define OMP_CLAUSE_REDUCTION_INIT(NODE) \
1991	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1992	OMP_CLAUSE_IN_REDUCTION), 1)
1993	#define OMP_CLAUSE_REDUCTION_MERGE(NODE) \
1994	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
1995	OMP_CLAUSE_IN_REDUCTION), 2)
1996	#define OMP_CLAUSE_REDUCTION_GIMPLE_INIT(NODE) \
1997	(OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
1998	#define OMP_CLAUSE_REDUCTION_GIMPLE_MERGE(NODE) \
1999	(OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_merge
2000	#define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
2001	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
2002	OMP_CLAUSE_IN_REDUCTION), 3)
2003	#define OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER(NODE) \
2004	OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
2005	OMP_CLAUSE_IN_REDUCTION), 4)
2006
2007	/* True if a REDUCTION clause may reference the original list item (omp_orig)
2008	in its OMP_CLAUSE_REDUCTION_{,GIMPLE_}INIT. */
2009	#define OMP_CLAUSE_REDUCTION_OMP_ORIG_REF(NODE) \
2010	(OMP_CLAUSE_RANGE_CHECK (NODE, OMP_CLAUSE_REDUCTION, \
2011	OMP_CLAUSE_IN_REDUCTION)->base.public_flag)
2012
2013	/* True if a REDUCTION clause has task reduction-modifier. */
2014	#define OMP_CLAUSE_REDUCTION_TASK(NODE) \
2015	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
2016
2017	/* True if a REDUCTION clause has inscan reduction-modifier. */
2018	#define OMP_CLAUSE_REDUCTION_INSCAN(NODE) \
2019	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION))
2020
2021	/* True if a LINEAR clause doesn't need copy in. True for iterator vars which
2022	are always initialized inside of the loop construct, false otherwise. */
2023	#define OMP_CLAUSE_LINEAR_NO_COPYIN(NODE) \
2024	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.public_flag)
2025
2026	/* True if a LINEAR clause doesn't need copy out. True for iterator vars which
2027	are declared inside of the simd construct. */
2028	#define OMP_CLAUSE_LINEAR_NO_COPYOUT(NODE) \
2029	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
2030
2031	/* True if a LINEAR clause has a stride that is variable. */
2032	#define OMP_CLAUSE_LINEAR_VARIABLE_STRIDE(NODE) \
2033	TREE_PROTECTED (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR))
2034
2035	/* True for a LINEAR clause with old style modifier syntax
2036	linear(modifier(list)) or linear(modifier(list):step). */
2037	#define OMP_CLAUSE_LINEAR_OLD_LINEAR_MODIFIER(NODE) \
2038	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.addressable_flag)
2039
2040	/* True if a LINEAR clause is for an array or allocatable variable that
2041	needs special handling by the frontend. */
2042	#define OMP_CLAUSE_LINEAR_ARRAY(NODE) \
2043	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->base.deprecated_flag)
2044
2045	#define OMP_CLAUSE_LINEAR_STEP(NODE) \
2046	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 1)
2047
2048	#define OMP_CLAUSE_LINEAR_STMT(NODE) \
2049	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR), 2)
2050
2051	#define OMP_CLAUSE_LINEAR_GIMPLE_SEQ(NODE) \
2052	(OMP_CLAUSE_CHECK (NODE))->omp_clause.gimple_reduction_init
2053
2054	#define OMP_CLAUSE_LINEAR_KIND(NODE) \
2055	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LINEAR)->omp_clause.subcode.linear_kind)
2056
2057	#define OMP_CLAUSE_ALIGNED_ALIGNMENT(NODE) \
2058	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALIGNED), 1)
2059
2060	#define OMP_CLAUSE_ALLOCATE_ALLOCATOR(NODE) \
2061	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 1)
2062
2063	#define OMP_CLAUSE_ALLOCATE_ALIGN(NODE) \
2064	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE), 2)
2065
2066	/* True if an ALLOCATE clause was present on a combined or composite
2067	construct and the code for splitting the clauses has already performed
2068	checking if the listed variable has explicit privatization on the
2069	construct. */
2070	#define OMP_CLAUSE_ALLOCATE_COMBINED(NODE) \
2071	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ALLOCATE)->base.public_flag)
2072
2073	#define OMP_CLAUSE_USES_ALLOCATORS_ALLOCATOR(NODE) \
2074	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USES_ALLOCATORS), 0)
2075
2076	#define OMP_CLAUSE_USES_ALLOCATORS_MEMSPACE(NODE) \
2077	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USES_ALLOCATORS), 1)
2078
2079	#define OMP_CLAUSE_USES_ALLOCATORS_TRAITS(NODE) \
2080	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_USES_ALLOCATORS), 2)
2081
2082	#define OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR(NODE) \
2083	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 0)
2084
2085	#define OMP_CLAUSE_NUM_TEAMS_LOWER_EXPR(NODE) \
2086	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_TEAMS), 1)
2087
2088	#define OMP_CLAUSE_THREAD_LIMIT_EXPR(NODE) \
2089	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2090	OMP_CLAUSE_THREAD_LIMIT), 0)
2091
2092	#define OMP_CLAUSE_DEVICE_ID(NODE) \
2093	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEVICE), 0)
2094
2095	#define OMP_CLAUSE_DIST_SCHEDULE_CHUNK_EXPR(NODE) \
2096	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2097	OMP_CLAUSE_DIST_SCHEDULE), 0)
2098
2099	#define OMP_CLAUSE_SAFELEN_EXPR(NODE) \
2100	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SAFELEN), 0)
2101
2102	#define OMP_CLAUSE_SIMDLEN_EXPR(NODE) \
2103	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SIMDLEN), 0)
2104
2105	#define OMP_CLAUSE__SIMDUID__DECL(NODE) \
2106	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SIMDUID_), 0)
2107
2108	#define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
2109	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
2110
2111	/* True if a SCHEDULE clause has the simd modifier on it. */
2112	#define OMP_CLAUSE_SCHEDULE_SIMD(NODE) \
2113	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->base.public_flag)
2114
2115	#define OMP_CLAUSE_DEFAULT_KIND(NODE) \
2116	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
2117
2118	#define OMP_CLAUSE_DEFAULTMAP_KIND(NODE) \
2119	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULTMAP)->omp_clause.subcode.defaultmap_kind)
2120	#define OMP_CLAUSE_DEFAULTMAP_CATEGORY(NODE) \
2121	((enum omp_clause_defaultmap_kind) \
2122	(OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK))
2123	#define OMP_CLAUSE_DEFAULTMAP_BEHAVIOR(NODE) \
2124	((enum omp_clause_defaultmap_kind) \
2125	(OMP_CLAUSE_DEFAULTMAP_KIND (NODE) & OMP_CLAUSE_DEFAULTMAP_MASK))
2126	#define OMP_CLAUSE_DEFAULTMAP_SET_KIND(NODE, BEHAVIOR, CATEGORY) \
2127	(OMP_CLAUSE_DEFAULTMAP_KIND (NODE) \
2128	= (enum omp_clause_defaultmap_kind) (CATEGORY | BEHAVIOR))
2129
2130	#define OMP_CLAUSE_BIND_KIND(NODE) \
2131	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_BIND)->omp_clause.subcode.bind_kind)
2132
2133	#define OMP_CLAUSE_DYN_GROUPPRIVATE_EXPR(NODE) \
2134	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DYN_GROUPPRIVATE), 0)
2135	#define OMP_CLAUSE_DYN_GROUPPRIVATE_KIND(NODE) \
2136	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DYN_GROUPPRIVATE)->omp_clause.subcode.fallback_kind)
2137
2138	/* True if ENTER clause is spelled as TO. */
2139	#define OMP_CLAUSE_ENTER_TO(NODE) \
2140	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_ENTER)->base.public_flag)
2141
2142	#define OMP_CLAUSE_TILE_LIST(NODE) \
2143	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 0)
2144	#define OMP_CLAUSE_TILE_ITERVAR(NODE) \
2145	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 1)
2146	#define OMP_CLAUSE_TILE_COUNT(NODE) \
2147	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_TILE), 2)
2148
2149	/* _CONDTEMP_ holding temporary with iteration count. */
2150	#define OMP_CLAUSE__CONDTEMP__ITER(NODE) \
2151	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__CONDTEMP_)->base.public_flag)
2152
2153	/* _SCANTEMP_ holding temporary with pointer to thread's local array;
2154	allocation. */
2155	#define OMP_CLAUSE__SCANTEMP__ALLOC(NODE) \
2156	(OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_)->base.public_flag)
2157
2158	/* _SCANTEMP_ holding temporary with a control variable for deallocation;
2159	one boolean_type_node for test whether alloca was used, another one
2160	to pass to __builtin_stack_restore or free. */
2161	#define OMP_CLAUSE__SCANTEMP__CONTROL(NODE) \
2162	TREE_PRIVATE (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE__SCANTEMP_))
2163
2164	/* OpenMP OMP_NEXT_VARIANT accessors. */
2165	#define OMP_NEXT_VARIANT_INDEX(NODE) \
2166	TREE_OPERAND (OMP_NEXT_VARIANT_CHECK (NODE), 0)
2167	#define OMP_NEXT_VARIANT_STATE(NODE) \
2168	TREE_OPERAND (OMP_NEXT_VARIANT_CHECK (NODE), 1)
2169
2170	/* OpenMP OMP_TARGET_DEVICE_MATCHES accessors. */
2171	#define OMP_TARGET_DEVICE_MATCHES_SELECTOR(NODE) \
2172	TREE_OPERAND (OMP_TARGET_DEVICE_MATCHES_CHECK (NODE), 0)
2173	#define OMP_TARGET_DEVICE_MATCHES_PROPERTIES(NODE) \
2174	TREE_OPERAND (OMP_TARGET_DEVICE_MATCHES_CHECK (NODE), 1)
2175
2176	#define OMP_CLAUSE__MAPPER_BINDING__ID(NODE) \
2177	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2178	OMP_CLAUSE__MAPPER_BINDING_), 0)
2179
2180	#define OMP_CLAUSE__MAPPER_BINDING__DECL(NODE) \
2181	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2182	OMP_CLAUSE__MAPPER_BINDING_), 1)
2183
2184	#define OMP_CLAUSE__MAPPER_BINDING__MAPPER(NODE) \
2185	OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, \
2186	OMP_CLAUSE__MAPPER_BINDING_), 2)
2187
2188	/* SSA_NAME accessors. */
2189
2190	/* Whether SSA_NAME NODE is a virtual operand. This simply caches the
2191	information in the underlying SSA_NAME_VAR for efficiency. */
2192	#define SSA_NAME_IS_VIRTUAL_OPERAND(NODE) \
2193	SSA_NAME_CHECK (NODE)->base.public_flag
2194
2195	/* Returns the IDENTIFIER_NODE giving the SSA name a name or NULL_TREE
2196	if there is no name associated with it. */
2197	#define SSA_NAME_IDENTIFIER(NODE) \
2198	(SSA_NAME_CHECK (NODE)->ssa_name.var != NULL_TREE \
2199	? (TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE \
2200	? (NODE)->ssa_name.var \
2201	: DECL_NAME ((NODE)->ssa_name.var)) \
2202	: NULL_TREE)
2203
2204	/* Returns the variable being referenced. This can be NULL_TREE for
2205	temporaries not associated with any user variable.
2206	Once released, this is the only field that can be relied upon. */
2207	#define SSA_NAME_VAR(NODE) \
2208	(SSA_NAME_CHECK (NODE)->ssa_name.var == NULL_TREE \
2209	|| TREE_CODE ((NODE)->ssa_name.var) == IDENTIFIER_NODE \
2210	? NULL_TREE : (NODE)->ssa_name.var)
2211
2212	#define SET_SSA_NAME_VAR_OR_IDENTIFIER(NODE,VAR) \
2213	do \
2214	{ \
2215	tree var_ = (VAR); \
2216	SSA_NAME_CHECK (NODE)->ssa_name.var = var_; \
2217	SSA_NAME_IS_VIRTUAL_OPERAND (NODE) \
2218	= (var_ \
2219	&& TREE_CODE (var_) == VAR_DECL \
2220	&& VAR_DECL_IS_VIRTUAL_OPERAND (var_)); \
2221	} \
2222	while (0)
2223
2224	/* Returns the statement which defines this SSA name. */
2225	#define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->ssa_name.def_stmt
2226
2227	/* Returns the SSA version number of this SSA name. Note that in
2228	tree SSA, version numbers are not per variable and may be recycled. */
2229	#define SSA_NAME_VERSION(NODE) SSA_NAME_CHECK (NODE)->base.u.version
2230
2231	/* Nonzero if this SSA name occurs in an abnormal PHI. SSA_NAMES are
2232	never output, so we can safely use the ASM_WRITTEN_FLAG for this
2233	status bit. */
2234	#define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
2235	SSA_NAME_CHECK (NODE)->base.asm_written_flag
2236
2237	/* Nonzero if this SSA_NAME expression is currently on the free list of
2238	SSA_NAMES. Using NOTHROW_FLAG seems reasonably safe since throwing
2239	has no meaning for an SSA_NAME. */
2240	#define SSA_NAME_IN_FREE_LIST(NODE) \
2241	SSA_NAME_CHECK (NODE)->base.nothrow_flag
2242
2243	/* Nonzero if this SSA_NAME is the default definition for the
2244	underlying symbol. A default SSA name is created for symbol S if
2245	the very first reference to S in the function is a read operation.
2246	Default definitions are always created by an empty statement and
2247	belong to no basic block. */
2248	#define SSA_NAME_IS_DEFAULT_DEF(NODE) \
2249	SSA_NAME_CHECK (NODE)->base.default_def_flag
2250
2251	/* Nonzero if this SSA_NAME is known to point to memory that may not
2252	be written to. This is set for default defs of function parameters
2253	that have a corresponding r or R specification in the functions
2254	fn spec attribute. This is used by alias analysis. */
2255	#define SSA_NAME_POINTS_TO_READONLY_MEMORY(NODE) \
2256	SSA_NAME_CHECK (NODE)->base.deprecated_flag
2257
2258	/* Attributes for SSA_NAMEs for pointer-type variables. */
2259	#define SSA_NAME_PTR_INFO(N) \
2260	SSA_NAME_CHECK (N)->ssa_name.info.ptr_info
2261
2262	/* Value range info attributes for SSA_NAMEs of non pointer-type variables. */
2263	#define SSA_NAME_RANGE_INFO(N) \
2264	SSA_NAME_CHECK (N)->ssa_name.info.range_info
2265
2266	/* Return the immediate_use information for an SSA_NAME. */
2267	#define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
2268
2269	#define OMP_CLAUSE_CODE(NODE) \
2270	(OMP_CLAUSE_CHECK (NODE))->omp_clause.code
2271
2272	#define OMP_CLAUSE_SET_CODE(NODE, CODE) \
2273	((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))
2274
2275	#define OMP_CLAUSE_OPERAND(NODE, I) \
2276	OMP_CLAUSE_ELT_CHECK (NODE, I)
2277
2278	/* True if the clause decl NODE contains an OpenMP iterator. */
2279	#define OMP_ITERATOR_DECL_P(NODE) \
2280	(TREE_CODE (NODE) == TREE_LIST \
2281	&& TREE_PURPOSE (NODE) \
2282	&& TREE_CODE (TREE_PURPOSE (NODE)) == TREE_VEC)
2283
2284	/* In a BLOCK (scope) node:
2285	Variables declared in the scope NODE. */
2286	#define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
2287	#define BLOCK_NONLOCALIZED_VARS(NODE) \
2288	(BLOCK_CHECK (NODE)->block.nonlocalized_vars)
2289	#define BLOCK_NUM_NONLOCALIZED_VARS(NODE) \
2290	vec_safe_length (BLOCK_NONLOCALIZED_VARS (NODE))
2291	#define BLOCK_NONLOCALIZED_VAR(NODE,N) (*BLOCK_NONLOCALIZED_VARS (NODE))[N]
2292	/* A chain of BLOCKs (scopes) nested within the scope NODE. */
2293	#define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
2294	/* The scope enclosing the scope NODE, or FUNCTION_DECL for the "outermost"
2295	function scope. Inlined functions are chained by this so that given
2296	expression E and its TREE_BLOCK(E) B, BLOCK_SUPERCONTEXT(B) is the scope
2297	in which E has been made or into which E has been inlined. */
2298	#define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
2299	/* Points to the next scope at the same level of nesting as scope NODE. */
2300	#define BLOCK_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.chain)
2301	/* A BLOCK, or FUNCTION_DECL of the function from which a block has been
2302	inlined. In a scope immediately enclosing an inlined leaf expression,
2303	points to the outermost scope into which it has been inlined (thus
2304	bypassing all intermediate BLOCK_SUPERCONTEXTs). */
2305	#define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
2306	#define BLOCK_ORIGIN(NODE) \
2307	(BLOCK_ABSTRACT_ORIGIN(NODE) ? BLOCK_ABSTRACT_ORIGIN(NODE) : (NODE))
2308	#define BLOCK_DIE(NODE) (BLOCK_CHECK (NODE)->block.die)
2309
2310	/* True if BLOCK has the same ranges as its BLOCK_SUPERCONTEXT. */
2311	#define BLOCK_SAME_RANGE(NODE) (BLOCK_CHECK (NODE)->base.u.bits.nameless_flag)
2312
2313	/* True if BLOCK appears in cold section. */
2314	#define BLOCK_IN_COLD_SECTION_P(NODE) \
2315	(BLOCK_CHECK (NODE)->base.u.bits.atomic_flag)
2316
2317	/* An index number for this block. These values are not guaranteed to
2318	be unique across functions -- whether or not they are depends on
2319	the debugging output format in use. */
2320	#define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
2321
2322	/* If block reordering splits a lexical block into discontiguous
2323	address ranges, we'll make a copy of the original block.
2324
2325	Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
2326	In that case, we have one source block that has been replicated
2327	(through inlining or unrolling) into many logical blocks, and that
2328	these logical blocks have different physical variables in them.
2329
2330	In this case, we have one logical block split into several
2331	non-contiguous address ranges. Most debug formats can't actually
2332	represent this idea directly, so we fake it by creating multiple
2333	logical blocks with the same variables in them. However, for those
2334	that do support non-contiguous regions, these allow the original
2335	logical block to be reconstructed, along with the set of address
2336	ranges.
2337
2338	One of the logical block fragments is arbitrarily chosen to be
2339	the ORIGIN. The other fragments will point to the origin via
2340	BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
2341	be null. The list of fragments will be chained through
2342	BLOCK_FRAGMENT_CHAIN from the origin. */
2343
2344	#define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
2345	#define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
2346
2347	/* For an inlined function, this gives the location where it was called
2348	from. This is only set in the top level block, which corresponds to the
2349	inlined function scope. This is used in the debug output routines. */
2350
2351	#define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
2352
2353	/* This gives the location of the end of the block, useful to attach
2354	code implicitly generated for outgoing paths. */
2355
2356	#define BLOCK_SOURCE_END_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.end_locus)
2357
2358	/* Define fields and accessors for nodes representing data types. */
2359
2360	/* See tree.def for documentation of the use of these fields.
2361	Look at the documentation of the various ..._TYPE tree codes.
2362
2363	Note that the type.values, type.minval, and type.maxval fields are
2364	overloaded and used for different macros in different kinds of types.
2365	Each macro must check to ensure the tree node is of the proper kind of
2366	type. Note also that some of the front-ends also overload these fields,
2367	so they must be checked as well. */
2368
2369	#define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type_common.uid)
2370	/* Type size in bits as a tree expression. Need not be constant and may
2371	be greater than TYPE_SIZE for a C++ FIELD_DECL representing a base
2372	class subobject with its own virtual base classes (which are laid out
2373	separately). */
2374	#define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type_common.size)
2375	/* Likewise, type size in bytes. */
2376	#define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type_common.size_unit)
2377	#define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type_common.pointer_to)
2378	#define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type_common.reference_to)
2379	#define TYPE_PRECISION(NODE) \
2380	(TREE_NOT_CHECK (TYPE_CHECK (NODE), VECTOR_TYPE)->type_common.precision)
2381	#define TYPE_PRECISION_RAW(NODE) (TYPE_CHECK (NODE)->type_common.precision)
2382	#define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type_common.name)
2383	#define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.next_variant)
2384	#define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type_common.main_variant)
2385	#define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type_common.context)
2386
2387	#define TYPE_MODE_RAW(NODE) (TYPE_CHECK (NODE)->type_common.mode)
2388	#define TYPE_MODE(NODE) \
2389	(VECTOR_TYPE_P (TYPE_CHECK (NODE)) \
2390	? vector_type_mode (NODE) : (NODE)->type_common.mode)
2391	#define SCALAR_TYPE_MODE(NODE) \
2392	(as_a <scalar_mode> (TYPE_CHECK (NODE)->type_common.mode))
2393	#define SCALAR_INT_TYPE_MODE(NODE) \
2394	(as_a <scalar_int_mode> (TYPE_CHECK (NODE)->type_common.mode))
2395	#define SCALAR_FLOAT_TYPE_MODE(NODE) \
2396	(as_a <scalar_float_mode> (TYPE_CHECK (NODE)->type_common.mode))
2397	#define SET_TYPE_MODE(NODE, MODE) \
2398	(TYPE_CHECK (NODE)->type_common.mode = (MODE))
2399
2400	extern unsigned int element_precision (const_tree);
2401	extern machine_mode element_mode (const_tree);
2402	extern machine_mode vector_type_mode (const_tree);
2403	extern unsigned int vector_element_bits (const_tree);
2404	extern tree vector_element_bits_tree (const_tree);
2405
2406	/* The "canonical" type for this type node, which is used by frontends to
2407	compare the type for equality with another type. If two types are
2408	equal (based on the semantics of the language), then they will have
2409	equivalent TYPE_CANONICAL entries.
2410
2411	As a special case, if TYPE_CANONICAL is NULL_TREE, and thus
2412	TYPE_STRUCTURAL_EQUALITY_P is true, then it cannot
2413	be used for comparison against other types. Instead, the type is
2414	said to require structural equality checks, described in
2415	TYPE_STRUCTURAL_EQUALITY_P.
2416
2417	For unqualified aggregate and function types the middle-end relies on
2418	TYPE_CANONICAL to tell whether two variables can be assigned
2419	to each other without a conversion. The middle-end also makes sure
2420	to assign the same alias-sets to the type partition with equal
2421	TYPE_CANONICAL of their unqualified variants. */
2422	#define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type_common.canonical)
2423	/* Indicates that the type node requires structural equality
2424	checks. The compiler will need to look at the composition of the
2425	type to determine whether it is equal to another type, rather than
2426	just comparing canonical type pointers. For instance, we would need
2427	to look at the return and parameter types of a FUNCTION_TYPE
2428	node. */
2429	#define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE)
2430	/* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the
2431	type node requires structural equality. */
2432	#define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE)
2433
2434	#define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE)))
2435	#define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE)))
2436
2437	/* The (language-specific) typed-based alias set for this type.
2438	Objects whose TYPE_ALIAS_SETs are different cannot alias each
2439	other. If the TYPE_ALIAS_SET is -1, no alias set has yet been
2440	assigned to this type. If the TYPE_ALIAS_SET is 0, objects of this
2441	type can alias objects of any type. */
2442	#define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type_common.alias_set)
2443
2444	/* Nonzero iff the typed-based alias set for this type has been
2445	calculated. */
2446	#define TYPE_ALIAS_SET_KNOWN_P(NODE) \
2447	(TYPE_CHECK (NODE)->type_common.alias_set != -1)
2448
2449	/* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
2450	to this type. */
2451	#define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type_common.attributes)
2452
2453	/* Raw access to the alignment field. */
2454	#define TYPE_ALIGN_RAW(NODE) \
2455	(TYPE_CHECK (NODE)->type_common.align)
2456
2457	/* The alignment necessary for objects of this type.
2458	The value is an int, measured in bits and must be a power of two.
2459	We support also an "alignment" of zero. */
2460	#define TYPE_ALIGN(NODE) \
2461	(TYPE_ALIGN_RAW (NODE) \
2462	? ((unsigned)1) << (TYPE_ALIGN_RAW(NODE) - 1) : 0)
2463
2464	/* Specify that TYPE_ALIGN(NODE) is X. */
2465	#define SET_TYPE_ALIGN(NODE, X) \
2466	(TYPE_CHECK (NODE)->type_common.align = ffs_hwi (X))
2467
2468	/* 1 if the alignment for this type was requested by "aligned" attribute,
2469	0 if it is the default for this type. */
2470	#define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->base.u.bits.user_align)
2471
2472	/* The alignment for NODE, in bytes. */
2473	#define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
2474
2475	/* The minimum alignment necessary for objects of this type without
2476	warning. The value is an int, measured in bits. */
2477	#define TYPE_WARN_IF_NOT_ALIGN_RAW(NODE) \
2478	(TYPE_CHECK (NODE)->type_common.warn_if_not_align)
2479	#define TYPE_WARN_IF_NOT_ALIGN(NODE) \
2480	(TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) \
2481	? ((unsigned)1) << (TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0)
2482
2483	/* Specify that TYPE_WARN_IF_NOT_ALIGN(NODE) is X. */
2484	#define SET_TYPE_WARN_IF_NOT_ALIGN(NODE, X) \
2485	(TYPE_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X))
2486
2487	/* If your language allows you to declare types, and you want debug info
2488	for them, then you need to generate corresponding TYPE_DECL nodes.
2489	These "stub" TYPE_DECL nodes have no name, and simply point at the
2490	type node. You then set the TYPE_STUB_DECL field of the type node
2491	to point back at the TYPE_DECL node. This allows the debug routines
2492	to know that the two nodes represent the same type, so that we only
2493	get one debug info record for them. */
2494	#define TYPE_STUB_DECL(NODE) (TREE_CHAIN (TYPE_CHECK (NODE)))
2495
2496	/* In a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ARRAY_TYPE, it means
2497	the type has BLKmode only because it lacks the alignment required for
2498	its size. */
2499	#define TYPE_NO_FORCE_BLK(NODE) \
2500	(TYPE_CHECK (NODE)->type_common.no_force_blk_flag)
2501
2502	/* Nonzero in a type considered volatile as a whole. */
2503	#define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->base.volatile_flag)
2504
2505	/* Nonzero in a type considered atomic as a whole. */
2506	#define TYPE_ATOMIC(NODE) (TYPE_CHECK (NODE)->base.u.bits.atomic_flag)
2507
2508	/* Means this type is const-qualified. */
2509	#define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->base.readonly_flag)
2510
2511	/* If nonzero, this type is `restrict'-qualified, in the C sense of
2512	the term. */
2513	#define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type_common.restrict_flag)
2514
2515	/* If nonzero, type's name shouldn't be emitted into debug info. */
2516	#define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)
2517
2518	/* The address space the type is in. */
2519	#define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space)
2520
2521	/* Encode/decode the named memory support as part of the qualifier. If more
2522	than 8 qualifiers are added, these macros need to be adjusted. */
2523	#define ENCODE_QUAL_ADDR_SPACE(NUM) ((NUM & 0xFF) << 8)
2524	#define DECODE_QUAL_ADDR_SPACE(X) (((X) >> 8) & 0xFF)
2525
2526	/* Return all qualifiers except for the address space qualifiers. */
2527	#define CLEAR_QUAL_ADDR_SPACE(X) ((X) & ~0xFF00)
2528
2529	/* Only keep the address space out of the qualifiers and discard the other
2530	qualifiers. */
2531	#define KEEP_QUAL_ADDR_SPACE(X) ((X) & 0xFF00)
2532
2533	/* The set of type qualifiers for this type. */
2534	#define TYPE_QUALS(NODE) \
2535	((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2536	| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
2537	| (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC) \
2538	| (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT) \
2539	| (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))))
2540
2541	/* The same as TYPE_QUALS without the address space qualifications. */
2542	#define TYPE_QUALS_NO_ADDR_SPACE(NODE) \
2543	((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2544	| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
2545	| (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC) \
2546	| (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))
2547
2548	/* The same as TYPE_QUALS without the address space and atomic
2549	qualifications. */
2550	#define TYPE_QUALS_NO_ADDR_SPACE_NO_ATOMIC(NODE) \
2551	((int) ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST) \
2552	| (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE) \
2553	| (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)))
2554
2555	/* These flags are available for each language front end to use internally. */
2556	#define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_0)
2557	#define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_1)
2558	#define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_2)
2559	#define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_3)
2560	#define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_4)
2561	#define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_5)
2562	#define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_6)
2563	#define TYPE_LANG_FLAG_7(NODE) (TYPE_CHECK (NODE)->type_common.lang_flag_7)
2564
2565	/* Used to keep track of visited nodes in tree traversals. This is set to
2566	0 by copy_node and make_node. */
2567	#define TREE_VISITED(NODE) ((NODE)->base.visited)
2568
2569	/* If set in an ARRAY_TYPE, indicates a string type (for languages
2570	that distinguish string from array of char).
2571	If set in a INTEGER_TYPE, indicates a character type. */
2572	#define TYPE_STRING_FLAG(NODE) \
2573	(ARRAY_OR_INTEGER_TYPE_CHECK (NODE)->type_common.string_flag)
2574
2575	/* If set for RECORD_TYPE or UNION_TYPE it indicates that the type conforms
2576	to the C++ one definition rule. This is used for LTO canonical type
2577	computation. */
2578	#define TYPE_CXX_ODR_P(NODE) \
2579	(RECORD_OR_UNION_CHECK (NODE)->type_common.string_flag)
2580
2581	/* Nonzero in a VECTOR_TYPE if the frontends should not emit warnings
2582	about missing conversions to other vector types of the same size. */
2583	#define TYPE_VECTOR_OPAQUE(NODE) \
2584	(VECTOR_TYPE_CHECK (NODE)->base.default_def_flag)
2585
2586	/* Indicates that objects of this type must be initialized by calling a
2587	function when they are created. */
2588	#define TYPE_NEEDS_CONSTRUCTING(NODE) \
2589	(TYPE_CHECK (NODE)->type_common.needs_constructing_flag)
2590
2591	/* Indicates that a UNION_TYPE object should be passed the same way that
2592	the first union alternative would be passed, or that a RECORD_TYPE
2593	object should be passed the same way that the first (and only) member
2594	would be passed. */
2595	#define TYPE_TRANSPARENT_AGGR(NODE) \
2596	(RECORD_OR_UNION_CHECK (NODE)->type_common.transparent_aggr_flag)
2597
2598	/* For an ARRAY_TYPE, indicates that it is not permitted to take the
2599	address of a component of the type. This is the counterpart of
2600	DECL_NONADDRESSABLE_P for arrays, see the definition of this flag. */
2601	#define TYPE_NONALIASED_COMPONENT(NODE) \
2602	(ARRAY_TYPE_CHECK (NODE)->type_common.transparent_aggr_flag)
2603
2604	/* For an ARRAY_TYPE, a RECORD_TYPE, a UNION_TYPE or a QUAL_UNION_TYPE
2605	whether the array is typeless storage or the type contains a member
2606	with this flag set. Such types are exempt from type-based alias
2607	analysis. For ARRAY_TYPEs with AGGREGATE_TYPE_P element types
2608	the flag should be inherited from the element type, can change
2609	when type is finalized and because of that should not be used in
2610	type hashing. For ARRAY_TYPEs with non-AGGREGATE_TYPE_P element types
2611	the flag should not be changed after the array is created and should
2612	be used in type hashing. */
2613	#define TYPE_TYPELESS_STORAGE(NODE) \
2614	(TREE_CHECK4 (NODE, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, \
2615	ARRAY_TYPE)->type_common.typeless_storage)
2616
2617	/* Indicated that objects of this type should be laid out in as
2618	compact a way as possible. */
2619	#define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->base.u.bits.packed_flag)
2620
2621	/* Used by type_contains_placeholder_p to avoid recomputation.
2622	Values are: 0 (unknown), 1 (false), 2 (true). Never access
2623	this field directly. */
2624	#define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
2625	(TYPE_CHECK (NODE)->type_common.contains_placeholder_bits)
2626
2627	/* Nonzero if RECORD_TYPE represents a final derivation of class. */
2628	#define TYPE_FINAL_P(NODE) \
2629	(RECORD_OR_UNION_CHECK (NODE)->base.default_def_flag)
2630
2631	/* The debug output functions use the symtab union field to store
2632	information specific to the debugging format. The different debug
2633	output hooks store different types in the union field. These three
2634	macros are used to access different fields in the union. The debug
2635	hooks are responsible for consistently using only a specific
2636	macro. */
2637
2638	/* Symtab field as an integer. Used by stabs generator in dbxout.cc to
2639	hold the type's number in the generated stabs. */
2640	#define TYPE_SYMTAB_ADDRESS(NODE) \
2641	(TYPE_CHECK (NODE)->type_common.symtab.address)
2642
2643	/* Symtab field as a pointer to a DWARF DIE. Used by DWARF generator
2644	in dwarf2out.cc to point to the DIE generated for the type. */
2645	#define TYPE_SYMTAB_DIE(NODE) \
2646	(TYPE_CHECK (NODE)->type_common.symtab.die)
2647
2648	/* The garbage collector needs to know the interpretation of the
2649	symtab field. These constants represent the different types in the
2650	union. */
2651
2652	#define TYPE_SYMTAB_IS_ADDRESS (0)
2653	#define TYPE_SYMTAB_IS_DIE (1)
2654
2655	#define TYPE_LANG_SPECIFIC(NODE) \
2656	(TYPE_CHECK (NODE)->type_with_lang_specific.lang_specific)
2657
2658	#define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type_non_common.values)
2659	#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
2660	#define TYPE_FIELDS(NODE) \
2661	(RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)
2662	#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
2663	#define TYPE_ARG_TYPES(NODE) \
2664	(FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)
2665	#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
2666
2667	#define TYPE_MIN_VALUE(NODE) \
2668	(NUMERICAL_TYPE_CHECK (NODE)->type_non_common.minval)
2669	#define TYPE_NEXT_PTR_TO(NODE) \
2670	(POINTER_TYPE_CHECK (NODE)->type_non_common.minval)
2671	#define TYPE_NEXT_REF_TO(NODE) \
2672	(REFERENCE_TYPE_CHECK (NODE)->type_non_common.minval)
2673	#define TYPE_VFIELD(NODE) \
2674	(RECORD_OR_UNION_CHECK (NODE)->type_non_common.minval)
2675	#define TYPE_MIN_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.minval)
2676
2677	#define TYPE_MAX_VALUE(NODE) \
2678	(NUMERICAL_TYPE_CHECK (NODE)->type_non_common.maxval)
2679	#define TYPE_METHOD_BASETYPE(NODE) \
2680	(FUNC_OR_METHOD_CHECK (NODE)->type_non_common.maxval)
2681	#define TYPE_OFFSET_BASETYPE(NODE) \
2682	(OFFSET_TYPE_CHECK (NODE)->type_non_common.maxval)
2683	/* If non-NULL, this is an upper bound of the size (in bytes) of an
2684	object of the given ARRAY_TYPE_NON_COMMON. This allows temporaries to be
2685	allocated. */
2686	#define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
2687	(ARRAY_TYPE_CHECK (ARRAY_TYPE)->type_non_common.maxval)
2688	#define TYPE_MAX_VALUE_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.maxval)
2689	/* For record and union types, information about this type, as a base type
2690	for itself. */
2691	#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
2692
2693	/* For types, used in a language-dependent way. */
2694	#define TYPE_LANG_SLOT_1(NODE) \
2695	(TYPE_CHECK (NODE)->type_non_common.lang_1)
2696
2697	/* Define accessor macros for information about type inheritance
2698	and basetypes.
2699
2700	A "basetype" means a particular usage of a data type for inheritance
2701	in another type. Each such basetype usage has its own "binfo"
2702	object to describe it. The binfo object is a TREE_VEC node.
2703
2704	Inheritance is represented by the binfo nodes allocated for a
2705	given type. For example, given types C and D, such that D is
2706	inherited by C, 3 binfo nodes will be allocated: one for describing
2707	the binfo properties of C, similarly one for D, and one for
2708	describing the binfo properties of D as a base type for C.
2709	Thus, given a pointer to class C, one can get a pointer to the binfo
2710	of D acting as a basetype for C by looking at C's binfo's basetypes. */
2711
2712	/* BINFO specific flags. */
2713
2714	/* Nonzero means that the derivation chain is via a `virtual' declaration. */
2715	#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag)
2716
2717	/* Flags for language dependent use. */
2718	#define BINFO_FLAG_0(NODE) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))
2719	#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE))
2720	#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE))
2721	#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE))
2722	#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE))
2723	#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE))
2724	#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE))
2725
2726	/* The actual data type node being inherited in this basetype. */
2727	#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK (NODE))
2728
2729	/* The offset where this basetype appears in its containing type.
2730	BINFO_OFFSET slot holds the offset (in bytes)
2731	from the base of the complete object to the base of the part of the
2732	object that is allocated on behalf of this `type'.
2733	This is always 0 except when there is multiple inheritance. */
2734
2735	#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK (NODE)->binfo.offset)
2736	#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
2737
2738	/* The virtual function table belonging to this basetype. Virtual
2739	function tables provide a mechanism for run-time method dispatching.
2740	The entries of a virtual function table are language-dependent. */
2741
2742	#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtable)
2743
2744	/* The virtual functions in the virtual function table. This is
2745	a TREE_LIST that is used as an initial approximation for building
2746	a virtual function table for this basetype. */
2747	#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK (NODE)->binfo.virtuals)
2748
2749	/* A vector of binfos for the direct basetypes inherited by this
2750	basetype.
2751
2752	If this basetype describes type D as inherited in C, and if the
2753	basetypes of D are E and F, then this vector contains binfos for
2754	inheritance of E and F by C. */
2755	#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos)
2756
2757	/* The number of basetypes for NODE. */
2758	#define BINFO_N_BASE_BINFOS(NODE) (BINFO_BASE_BINFOS (NODE)->length ())
2759
2760	/* Accessor macro to get to the Nth base binfo of this binfo. */
2761	#define BINFO_BASE_BINFO(NODE,N) \
2762	((*BINFO_BASE_BINFOS (NODE))[(N)])
2763	#define BINFO_BASE_ITERATE(NODE,N,B) \
2764	(BINFO_BASE_BINFOS (NODE)->iterate ((N), &(B)))
2765	#define BINFO_BASE_APPEND(NODE,T) \
2766	(BINFO_BASE_BINFOS (NODE)->quick_push ((T)))
2767
2768	/* For a BINFO record describing a virtual base class, i.e., one where
2769	TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
2770	base. The actual contents are language-dependent. In the C++
2771	front-end this field is an INTEGER_CST giving an offset into the
2772	vtable where the offset to the virtual base can be found. */
2773	#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vptr_field)
2774
2775	/* Indicates the accesses this binfo has to its bases. The values are
2776	access_public_node, access_protected_node or access_private_node.
2777	If this vector is not present, public access is implied. If present,
2778	the vector should have BINFO_N_BASE_BINFOS or larger length. Elements
2779	beyond BINFO_N_BASE_BINFOS are base attributes instead of the
2780	access_p*_node values for base with index IDX at IDX + BINFO_N_BASE_BINFOS
2781	index. If that is beyond the length of the vector, no attributes for
2782	that base is implied. */
2783	#define BINFO_BASE_ACCESSES(NODE) \
2784	(TREE_BINFO_CHECK (NODE)->binfo.base_accesses)
2785
2786	#define BINFO_BASE_ACCESS(NODE,N) \
2787	(*BINFO_BASE_ACCESSES (NODE))[(N)]
2788	#define BINFO_BASE_ACCESS_APPEND(NODE,T) \
2789	BINFO_BASE_ACCESSES (NODE)->quick_push ((T))
2790
2791	/* The index in the VTT where this subobject's sub-VTT can be found.
2792	NULL_TREE if there is no sub-VTT. */
2793	#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt)
2794
2795	/* The index in the VTT where the vptr for this subobject can be
2796	found. NULL_TREE if there is no secondary vptr in the VTT. */
2797	#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr)
2798
2799	/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
2800	inheriting this base for non-virtual bases. For virtual bases it
2801	points either to the binfo for which this is a primary binfo, or to
2802	the binfo of the most derived type. */
2803	#define BINFO_INHERITANCE_CHAIN(NODE) \
2804	(TREE_BINFO_CHECK (NODE)->binfo.inheritance)
2805
2806
2807	/* Define fields and accessors for nodes representing declared names. */
2808
2809	/* Nonzero if DECL represents an SSA name or a variable that can possibly
2810	have an associated SSA name. */
2811	#define SSA_VAR_P(DECL) \
2812	(TREE_CODE (DECL) == VAR_DECL \
2813	|| TREE_CODE (DECL) == PARM_DECL \
2814	|| TREE_CODE (DECL) == RESULT_DECL \
2815	|| TREE_CODE (DECL) == SSA_NAME)
2816
2817
2818	#define DECL_CHAIN(NODE) (TREE_CHAIN (DECL_MINIMAL_CHECK (NODE)))
2819
2820	/* This is the name of the object as written by the user.
2821	It is an IDENTIFIER_NODE. */
2822	#define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
2823
2824	/* The IDENTIFIER_NODE associated with the TYPE_NAME field. */
2825	#define TYPE_IDENTIFIER(NODE) \
2826	(TYPE_NAME (NODE) && DECL_P (TYPE_NAME (NODE)) \
2827	? DECL_NAME (TYPE_NAME (NODE)) : TYPE_NAME (NODE))
2828
2829	/* Every ..._DECL node gets a unique number. */
2830	#define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
2831
2832	/* DEBUG_EXPR_DECLs get negative UID numbers, to catch erroneous
2833	uses. */
2834	#define DEBUG_TEMP_UID(NODE) (-DECL_UID (TREE_CHECK ((NODE), DEBUG_EXPR_DECL)))
2835
2836	/* Every ..._DECL node gets a unique number that stays the same even
2837	when the decl is copied by the inliner once it is set. */
2838	#define DECL_PT_UID(NODE) \
2839	(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid == -1u \
2840	? (NODE)->decl_minimal.uid : (NODE)->decl_common.pt_uid)
2841	/* Initialize the ..._DECL node pt-uid to the decls uid. */
2842	#define SET_DECL_PT_UID(NODE, UID) \
2843	(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid = (UID))
2844	/* Whether the ..._DECL node pt-uid has been initialized and thus needs to
2845	be preserved when copyin the decl. */
2846	#define DECL_PT_UID_SET_P(NODE) \
2847	(DECL_COMMON_CHECK (NODE)->decl_common.pt_uid != -1u)
2848
2849	/* These two fields describe where in the source code the declaration
2850	was. If the declaration appears in several places (as for a C
2851	function that is declared first and then defined later), this
2852	information should refer to the definition. */
2853	#define DECL_SOURCE_LOCATION(NODE) \
2854	(DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
2855	#define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
2856	#define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
2857	#define DECL_SOURCE_COLUMN(NODE) LOCATION_COLUMN (DECL_SOURCE_LOCATION (NODE))
2858	/* This decl was created by a front-end or back-end rather than by
2859	user code, and has not been explicitly declared by the user -- when
2860	that happens the source location is updated to the user's
2861	source. This includes decls with no location (!). */
2862	#define DECL_IS_UNDECLARED_BUILTIN(DECL) \
2863	(DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
2864
2865	/* For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
2866	QUAL_UNION_TYPE node that the field is a member of. For VAR_DECL,
2867	PARM_DECL, FUNCTION_DECL, LABEL_DECL, RESULT_DECL, and CONST_DECL
2868	nodes, this points to either the FUNCTION_DECL for the containing
2869	function, the RECORD_TYPE or UNION_TYPE for the containing type, or
2870	NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
2871	scope". In particular, for VAR_DECLs which are virtual table pointers
2872	(they have DECL_VIRTUAL set), we use DECL_CONTEXT to determine the type
2873	they belong to. */
2874	#define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
2875	#define DECL_FIELD_CONTEXT(NODE) \
2876	(FIELD_DECL_CHECK (NODE)->decl_minimal.context)
2877
2878	/* If nonzero, decl's name shouldn't be emitted into debug info. */
2879	#define DECL_NAMELESS(NODE) (DECL_MINIMAL_CHECK (NODE)->base.u.bits.nameless_flag)
2880
2881	/* For any sort of a ..._DECL node, this points to the original (abstract)
2882	decl node which this decl is an inlined/cloned instance of, or else it
2883	is NULL indicating that this decl is not an instance of some other decl.
2884
2885	The C front-end also uses this in a nested declaration of an inline
2886	function, to point back to the definition. */
2887	#define DECL_ABSTRACT_ORIGIN(NODE) \
2888	(DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
2889
2890	/* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
2891	origin. This is useful when setting the DECL_ABSTRACT_ORIGIN. */
2892	#define DECL_ORIGIN(NODE) \
2893	(DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
2894
2895	/* Nonzero for any sort of ..._DECL node means this decl node represents an
2896	inline instance of some original (abstract) decl from an inline function;
2897	suppress any warnings about shadowing some other variable. FUNCTION_DECL
2898	nodes can also have their abstract origin set to themselves. */
2899	#define DECL_FROM_INLINE(NODE) \
2900	(DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
2901	&& DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
2902
2903	/* In a DECL this is the field where attributes are stored. */
2904	#define DECL_ATTRIBUTES(NODE) \
2905	(DECL_COMMON_CHECK (NODE)->decl_common.attributes)
2906
2907	/* For a FUNCTION_DECL, holds the tree of BINDINGs.
2908	For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
2909	For a VAR_DECL, holds the initial value.
2910	For a PARM_DECL, used for DECL_ARG_TYPE--default
2911	values for parameters are encoded in the type of the function,
2912	not in the PARM_DECL slot.
2913	For a FIELD_DECL, this is used for enumeration values and the C
2914	frontend uses it for temporarily storing bitwidth of bitfields.
2915
2916	??? Need to figure out some way to check this isn't a PARM_DECL. */
2917	#define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial)
2918
2919	/* Holds the size of the datum, in bits, as a tree expression.
2920	Need not be constant and may be null. May be less than TYPE_SIZE
2921	for a C++ FIELD_DECL representing a base class subobject with its
2922	own virtual base classes (which are laid out separately). */
2923	#define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size)
2924	/* Likewise for the size in bytes. */
2925	#define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
2926	#define DECL_ALIGN_RAW(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align)
2927	/* Returns the alignment required for the datum, in bits. It must
2928	be a power of two, but an "alignment" of zero is supported
2929	(e.g. as "uninitialized" sentinel). */
2930	#define DECL_ALIGN(NODE) \
2931	(DECL_ALIGN_RAW (NODE) \
2932	? ((unsigned)1) << (DECL_ALIGN_RAW (NODE) - 1) : 0)
2933	/* Specify that DECL_ALIGN(NODE) is X. */
2934	#define SET_DECL_ALIGN(NODE, X) \
2935	(DECL_ALIGN_RAW (NODE) = ffs_hwi (X))
2936
2937	/* The minimum alignment necessary for the datum, in bits, without
2938	warning. */
2939	#define DECL_WARN_IF_NOT_ALIGN_RAW(NODE) \
2940	(DECL_COMMON_CHECK (NODE)->decl_common.warn_if_not_align)
2941	#define DECL_WARN_IF_NOT_ALIGN(NODE) \
2942	(DECL_WARN_IF_NOT_ALIGN_RAW (NODE) \
2943	? ((unsigned)1) << (DECL_WARN_IF_NOT_ALIGN_RAW (NODE) - 1) : 0)
2944
2945	/* Specify that DECL_WARN_IF_NOT_ALIGN(NODE) is X. */
2946	#define SET_DECL_WARN_IF_NOT_ALIGN(NODE, X) \
2947	(DECL_WARN_IF_NOT_ALIGN_RAW (NODE) = ffs_hwi (X))
2948
2949	/* The alignment of NODE, in bytes. */
2950	#define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
2951	/* Set if the alignment of this DECL has been set by the user, for
2952	example with an 'aligned' attribute. */
2953	#define DECL_USER_ALIGN(NODE) \
2954	(DECL_COMMON_CHECK (NODE)->base.u.bits.user_align)
2955	/* Holds the machine mode corresponding to the declaration of a variable or
2956	field. Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
2957	FIELD_DECL. */
2958	#define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)
2959	#define SET_DECL_MODE(NODE, MODE) \
2960	(DECL_COMMON_CHECK (NODE)->decl_common.mode = (MODE))
2961
2962	/* For FUNCTION_DECL, if it is built-in, this identifies which built-in
2963	operation it is. This is only intended for low-level accesses;
2964	normally DECL_FUNCTION_CODE, DECL_FE_FUNCTION_CODE or DECL_MD_FUNCTION
2965	should be used instead. */
2966	#define DECL_UNCHECKED_FUNCTION_CODE(NODE) \
2967	(FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
2968
2969	/* Test if FCODE is a function code for an alloca operation. */
2970	#define ALLOCA_FUNCTION_CODE_P(FCODE) \
2971	((FCODE) == BUILT_IN_ALLOCA \
2972	|| (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN \
2973	|| (FCODE) == BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX)
2974
2975	/* Generate case for an alloca operation. */
2976	#define CASE_BUILT_IN_ALLOCA \
2977	case BUILT_IN_ALLOCA: \
2978	case BUILT_IN_ALLOCA_WITH_ALIGN: \
2979	case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX
2980
2981	#define DECL_FUNCTION_PERSONALITY(NODE) \
2982	(FUNCTION_DECL_CHECK (NODE)->function_decl.personality)
2983
2984	/* Nonzero for a given ..._DECL node means that the name of this node should
2985	be ignored for symbolic debug purposes. For a TYPE_DECL, this means that
2986	the associated type should be ignored. For a FUNCTION_DECL, the body of
2987	the function should also be ignored. */
2988	#define DECL_IGNORED_P(NODE) \
2989	(DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
2990
2991	/* Nonzero for a given ..._DECL node means that this node represents an
2992	"abstract instance" of the given declaration (e.g. in the original
2993	declaration of an inline function). When generating symbolic debugging
2994	information, we mustn't try to generate any address information for nodes
2995	marked as "abstract instances" because we don't actually generate
2996	any code or allocate any data space for such instances. */
2997	#define DECL_ABSTRACT_P(NODE) \
2998	(DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
2999
3000	/* Language-specific decl information. */
3001	#define DECL_LANG_SPECIFIC(NODE) \
3002	(DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
3003
3004	/* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
3005	do not allocate storage, and refer to a definition elsewhere. Note that
3006	this does not necessarily imply the entity represented by NODE
3007	has no program source-level definition in this translation unit. For
3008	example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
3009	DECL_EXTERNAL may be true simultaneously; that can be the case for
3010	a C99 "extern inline" function. */
3011	#define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_1)
3012
3013	/* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
3014	For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
3015
3016	For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
3017
3018	Also set in some languages for variables, etc., outside the normal
3019	lexical scope, such as class instance variables. */
3020	#define DECL_NONLOCAL(NODE) \
3021	(DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
3022
3023	/* Used in VAR_DECLs to indicate that the variable is a vtable.
3024	Used in FIELD_DECLs for vtable pointers.
3025	Used in FUNCTION_DECLs to indicate that the function is virtual. */
3026	#define DECL_VIRTUAL_P(NODE) \
3027	(DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
3028
3029	/* Used to indicate that this DECL represents a compiler-generated entity. */
3030	#define DECL_ARTIFICIAL(NODE) \
3031	(DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
3032
3033	/* Additional flags for language-specific uses. */
3034	#define DECL_LANG_FLAG_0(NODE) \
3035	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
3036	#define DECL_LANG_FLAG_1(NODE) \
3037	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
3038	#define DECL_LANG_FLAG_2(NODE) \
3039	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
3040	#define DECL_LANG_FLAG_3(NODE) \
3041	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
3042	#define DECL_LANG_FLAG_4(NODE) \
3043	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
3044	#define DECL_LANG_FLAG_5(NODE) \
3045	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
3046	#define DECL_LANG_FLAG_6(NODE) \
3047	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
3048	#define DECL_LANG_FLAG_7(NODE) \
3049	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
3050	#define DECL_LANG_FLAG_8(NODE) \
3051	(DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_8)
3052
3053	/* Nonzero for a scope which is equal to file scope. */
3054	#define SCOPE_FILE_SCOPE_P(EXP) \
3055	(! (EXP) || TREE_CODE (EXP) == TRANSLATION_UNIT_DECL)
3056	/* Nonzero for a decl which is at file scope. */
3057	#define DECL_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (DECL_CONTEXT (EXP))
3058	/* Nonzero for a type which is at file scope. */
3059	#define TYPE_FILE_SCOPE_P(EXP) SCOPE_FILE_SCOPE_P (TYPE_CONTEXT (EXP))
3060
3061	/* Nonzero for a decl that is decorated using attribute used.
3062	This indicates to compiler tools that this decl needs to be preserved. */
3063	#define DECL_PRESERVE_P(DECL) \
3064	DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
3065
3066	/* Nonzero for a decl that is decorated with the "noinit" attribute.
3067	decls with this attribute are placed into the ".noinit" section, so they are
3068	not initialized by the target's startup code. */
3069	#define DECL_NOINIT_P(DECL) \
3070	(DECL_P (DECL) \
3071	&& (lookup_attribute ("noinit", DECL_ATTRIBUTES (DECL)) != NULL_TREE))
3072
3073	/* Nonzero for a decl that is decorated with the "persistent" attribute.
3074	decls with this attribute are placed into the ".persistent" section, so they
3075	are not initialized by the target's startup code. */
3076	#define DECL_PERSISTENT_P(DECL) \
3077	(DECL_P (DECL) \
3078	&& (lookup_attribute ("persistent", DECL_ATTRIBUTES (DECL)) != NULL_TREE))
3079
3080	/* For function local variables indicates that the variable
3081	should not be treated as a GIMPLE register. In particular
3082	this means that partial definitions can appear and the
3083	variable cannot be written into SSA form and instead uses
3084	virtual operands to represent the use-def dataflow. */
3085	#define DECL_NOT_GIMPLE_REG_P(DECL) \
3086	DECL_COMMON_CHECK (DECL)->decl_common.not_gimple_reg_flag
3087
3088	extern tree decl_value_expr_lookup (tree);
3089	extern void decl_value_expr_insert (tree, tree);
3090
3091	/* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
3092	if transformations have made this more complicated than evaluating the
3093	decl itself. */
3094	#define DECL_HAS_VALUE_EXPR_P(NODE) \
3095	(TREE_CHECK3 (NODE, VAR_DECL, PARM_DECL, RESULT_DECL) \
3096	->decl_common.decl_flag_2)
3097	#define DECL_VALUE_EXPR(NODE) \
3098	(decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
3099	#define SET_DECL_VALUE_EXPR(NODE, VAL) \
3100	(decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
3101
3102	/* Holds the RTL expression for the value of a variable or function.
3103	This value can be evaluated lazily for functions, variables with
3104	static storage duration, and labels. */
3105	#define DECL_RTL(NODE) \
3106	(DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl \
3107	? (NODE)->decl_with_rtl.rtl \
3108	: (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))
3109
3110	/* Set the DECL_RTL for NODE to RTL. */
3111	#define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
3112
3113	/* Returns nonzero if NODE is a tree node that can contain RTL. */
3114	#define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
3115
3116	/* Returns nonzero if the DECL_RTL for NODE has already been set. */
3117	#define DECL_RTL_SET_P(NODE) \
3118	(HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
3119
3120	/* Copy the RTL from SRC_DECL to DST_DECL. If the RTL was not set for
3121	SRC_DECL, it will not be set for DST_DECL; this is a lazy copy. */
3122	#define COPY_DECL_RTL(SRC_DECL, DST_DECL) \
3123	(DECL_WRTL_CHECK (DST_DECL)->decl_with_rtl.rtl \
3124	= DECL_WRTL_CHECK (SRC_DECL)->decl_with_rtl.rtl)
3125
3126	/* The DECL_RTL for NODE, if it is set, or NULL, if it is not set. */
3127	#define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
3128
3129	#if (GCC_VERSION >= 2007)
3130	#define DECL_RTL_KNOWN_SET(decl) __extension__ \
3131	({ tree const __d = (decl); \
3132	gcc_checking_assert (DECL_RTL_SET_P (__d)); \
3133	/* Dereference it so the compiler knows it can't be NULL even \
3134	without assertion checking. */ \
3135	&*DECL_RTL_IF_SET (__d); })
3136	#else
3137	#define DECL_RTL_KNOWN_SET(decl) (&*DECL_RTL_IF_SET (decl))
3138	#endif
3139
3140	/* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'. */
3141	#define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
3142
3143	/* In a FIELD_DECL, this is the field position, counting in bytes, of the
3144	DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
3145	of the structure. */
3146	#define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)
3147
3148	/* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
3149	field from DECL_FIELD_OFFSET. This field may be nonzero even for fields
3150	that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
3151	natural alignment of the field's type). */
3152	#define DECL_FIELD_BIT_OFFSET(NODE) \
3153	(FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
3154
3155	/* In a FIELD_DECL, this indicates whether the field was a bit-field and
3156	if so, the type that was originally specified for it.
3157	TREE_TYPE may have been modified (in finish_struct). */
3158	#define DECL_BIT_FIELD_TYPE(NODE) \
3159	(FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
3160
3161	/* In a FIELD_DECL of a RECORD_TYPE, this is a pointer to the storage
3162	representative FIELD_DECL. */
3163	#define DECL_BIT_FIELD_REPRESENTATIVE(NODE) \
3164	(FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
3165
3166	/* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
3167	if nonzero, indicates that the field occupies the type. */
3168	#define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
3169
3170	/* For FIELD_DECLs, off_align holds the number of low-order bits of
3171	DECL_FIELD_OFFSET which are known to be always zero.
3172	DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
3173	has. */
3174	#define DECL_OFFSET_ALIGN(NODE) \
3175	(HOST_WIDE_INT_1U << FIELD_DECL_CHECK (NODE)->decl_common.off_align)
3176
3177	/* Specify that DECL_OFFSET_ALIGN(NODE) is X. */
3178	#define SET_DECL_OFFSET_ALIGN(NODE, X) \
3179	(FIELD_DECL_CHECK (NODE)->decl_common.off_align = ffs_hwi (X) - 1)
3180
3181	/* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
3182	which this FIELD_DECL is defined. This information is needed when
3183	writing debugging information about vfield and vbase decls for C++. */
3184	#define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
3185
3186	/* In a FIELD_DECL, indicates this field should be bit-packed. */
3187	#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->base.u.bits.packed_flag)
3188
3189	/* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
3190	specially. */
3191	#define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
3192
3193	/* In a FIELD_DECL, indicates this field should be ignored for ABI decisions
3194	like passing/returning containing struct by value.
3195	Set for C++17 empty base artificial FIELD_DECLs as well as
3196	empty [[no_unique_address]] non-static data members. */
3197	#define DECL_FIELD_ABI_IGNORED(NODE) \
3198	(!DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)
3199	#define SET_DECL_FIELD_ABI_IGNORED(NODE, VAL) \
3200	do { \
3201	gcc_checking_assert (!DECL_BIT_FIELD (NODE)); \
3202	FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL); \
3203	} while (0)
3204
3205	/* In a FIELD_DECL, indicates C++ zero-width bitfield that used to be
3206	removed from the IL since PR42217 until PR101539 and by that changed
3207	the ABI on several targets. This flag is provided so that the backends
3208	can decide on the ABI with zero-width bitfields and emit -Wpsabi
3209	warnings. */
3210	#define DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE) \
3211	(DECL_BIT_FIELD (NODE) && (NODE)->decl_common.decl_flag_0)
3212	#define SET_DECL_FIELD_CXX_ZERO_WIDTH_BIT_FIELD(NODE, VAL) \
3213	do { \
3214	gcc_checking_assert (DECL_BIT_FIELD (NODE)); \
3215	FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_0 = (VAL); \
3216	} while (0)
3217
3218	/* Used in a FIELD_DECL to indicate that we cannot form the address of
3219	this component. This makes it possible for Type-Based Alias Analysis
3220	to disambiguate accesses to this field with indirect accesses using
3221	the field's type:
3222
3223	struct S { int i; } s;
3224	int *p;
3225
3226	If the flag is set on 'i', TBAA computes that s.i and *p never conflict.
3227
3228	From the implementation's viewpoint, the alias set of the type of the
3229	field 'i' (int) will not be recorded as a subset of that of the type of
3230	's' (struct S) in record_component_aliases. The counterpart is that
3231	accesses to s.i must not be given the alias set of the type of 'i'
3232	(int) but instead directly that of the type of 's' (struct S). */
3233	#define DECL_NONADDRESSABLE_P(NODE) \
3234	(FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
3235
3236	/* Used in a FIELD_DECL to indicate that this field is padding. */
3237	#define DECL_PADDING_P(NODE) \
3238	(FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
3239
3240	/* Used in a FIELD_DECL to indicate whether this field is not a flexible
3241	array member. This is only valid for the last array type field of a
3242	structure. */
3243	#define DECL_NOT_FLEXARRAY(NODE) \
3244	(FIELD_DECL_CHECK (NODE)->decl_common.decl_not_flexarray)
3245
3246	/* A numeric unique identifier for a LABEL_DECL. The UID allocation is
3247	dense, unique within any one function, and may be used to index arrays.
3248	If the value is -1, then no UID has been assigned. */
3249	#define LABEL_DECL_UID(NODE) \
3250	(LABEL_DECL_CHECK (NODE)->label_decl.label_decl_uid)
3251
3252	/* In a LABEL_DECL, the EH region number for which the label is the
3253	post_landing_pad. */
3254	#define EH_LANDING_PAD_NR(NODE) \
3255	(LABEL_DECL_CHECK (NODE)->label_decl.eh_landing_pad_nr)
3256
3257	/* For a PARM_DECL, records the data type used to pass the argument,
3258	which may be different from the type seen in the program. */
3259	#define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
3260
3261	/* For PARM_DECL, holds an RTL for the stack slot or register
3262	where the data was actually passed. */
3263	#define DECL_INCOMING_RTL(NODE) \
3264	(PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
3265
3266	/* Nonzero for a given ..._DECL node means that no warnings should be
3267	generated just because this node is unused. */
3268	#define DECL_IN_SYSTEM_HEADER(NODE) \
3269	(in_system_header_at (DECL_SOURCE_LOCATION (NODE)))
3270
3271	/* Used to indicate that the linkage status of this DECL is not yet known,
3272	so it should not be output now. */
3273	#define DECL_DEFER_OUTPUT(NODE) \
3274	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
3275
3276	/* In a VAR_DECL that's static,
3277	nonzero if the space is in the text section. */
3278	#define DECL_IN_TEXT_SECTION(NODE) \
3279	(VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
3280
3281	/* In a VAR_DECL that's static,
3282	nonzero if it belongs to the global constant pool. */
3283	#define DECL_IN_CONSTANT_POOL(NODE) \
3284	(VAR_DECL_CHECK (NODE)->decl_with_vis.in_constant_pool)
3285
3286	/* Nonzero for a given ..._DECL node means that this node should be
3287	put in .common, if possible. If a DECL_INITIAL is given, and it
3288	is not error_mark_node, then the decl cannot be put in .common. */
3289	#define DECL_COMMON(NODE) \
3290	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
3291
3292	/* In a VAR_DECL, nonzero if the decl is a register variable with
3293	an explicit asm specification. */
3294	#define DECL_HARD_REGISTER(NODE) \
3295	(VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
3296
3297	/* Used to indicate that this DECL has weak linkage. */
3298	#define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
3299
3300	/* Used to indicate that the DECL is a dllimport. */
3301	#define DECL_DLLIMPORT_P(NODE) \
3302	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
3303
3304	/* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
3305	not be put out unless it is needed in this translation unit.
3306	Entities like this are shared across translation units (like weak
3307	entities), but are guaranteed to be generated by any translation
3308	unit that needs them, and therefore need not be put out anywhere
3309	where they are not needed. DECL_COMDAT is just a hint to the
3310	back-end; it is up to front-ends which set this flag to ensure
3311	that there will never be any harm, other than bloat, in putting out
3312	something which is DECL_COMDAT. */
3313	#define DECL_COMDAT(NODE) \
3314	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
3315
3316	#define DECL_COMDAT_GROUP(NODE) \
3317	decl_comdat_group (NODE)
3318
3319	/* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
3320	multiple translation units should be merged. */
3321	#define DECL_ONE_ONLY(NODE) (DECL_COMDAT_GROUP (NODE) != NULL_TREE \
3322	&& (TREE_PUBLIC (NODE) || DECL_EXTERNAL (NODE)))
3323
3324	/* The name of the object as the assembler will see it (but before any
3325	translations made by ASM_OUTPUT_LABELREF). Often this is the same
3326	as DECL_NAME. It is an IDENTIFIER_NODE.
3327
3328	ASSEMBLER_NAME of TYPE_DECLS may store global name of type used for
3329	One Definition Rule based type merging at LTO. It is computed only for
3330	LTO compilation and C++. */
3331	#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
3332
3333	/* Raw accessor for DECL_ASSEMBLE_NAME. */
3334	#define DECL_ASSEMBLER_NAME_RAW(NODE) \
3335	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name)
3336
3337	/* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
3338	This is true of all DECL nodes except FIELD_DECL. */
3339	#define HAS_DECL_ASSEMBLER_NAME_P(NODE) \
3340	(CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
3341
3342	/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
3343	the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
3344	yet. */
3345	#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
3346	(DECL_ASSEMBLER_NAME_RAW (NODE) != NULL_TREE)
3347
3348	/* Set the DECL_ASSEMBLER_NAME for NODE to NAME. */
3349	#define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
3350	overwrite_decl_assembler_name (NODE, NAME)
3351
3352	/* Copy the DECL_ASSEMBLER_NAME from SRC_DECL to DST_DECL. Note that
3353	if SRC_DECL's DECL_ASSEMBLER_NAME has not yet been set, using this
3354	macro will not cause the DECL_ASSEMBLER_NAME to be set, but will
3355	clear DECL_ASSEMBLER_NAME of DST_DECL, if it was already set. In
3356	other words, the semantics of using this macro, are different than
3357	saying:
3358
3359	SET_DECL_ASSEMBLER_NAME(DST_DECL, DECL_ASSEMBLER_NAME (SRC_DECL))
3360
3361	which will try to set the DECL_ASSEMBLER_NAME for SRC_DECL. */
3362
3363	#define COPY_DECL_ASSEMBLER_NAME(SRC_DECL, DST_DECL) \
3364	SET_DECL_ASSEMBLER_NAME (DST_DECL, DECL_ASSEMBLER_NAME_RAW (SRC_DECL))
3365
3366	/* Records the section name in a section attribute. Used to pass
3367	the name from decl_attributes to make_function_rtl and make_decl_rtl. */
3368	#define DECL_SECTION_NAME(NODE) decl_section_name (NODE)
3369
3370	/* Nonzero in a decl means that the gimplifier has seen (or placed)
3371	this variable in a BIND_EXPR. */
3372	#define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
3373	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
3374
3375	/* Value of the decls's visibility attribute */
3376	#define DECL_VISIBILITY(NODE) \
3377	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
3378
3379	/* Nonzero means that the decl (or an enclosing scope) had its
3380	visibility specified rather than being inferred. */
3381	#define DECL_VISIBILITY_SPECIFIED(NODE) \
3382	(DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
3383
3384	/* In a VAR_DECL, the model to use if the data should be allocated from
3385	thread-local storage. */
3386	#define DECL_TLS_MODEL(NODE) decl_tls_model (NODE)
3387
3388	/* In a VAR_DECL, nonzero if the data should be allocated from
3389	thread-local storage. */
3390	#define DECL_THREAD_LOCAL_P(NODE) \
3391	((TREE_STATIC (NODE) || DECL_EXTERNAL (NODE)) && decl_tls_model (NODE) >= TLS_MODEL_REAL)
3392
3393	/* In a non-local VAR_DECL with static storage duration, true if the
3394	variable has an initialization priority. If false, the variable
3395	will be initialized at the DEFAULT_INIT_PRIORITY. */
3396	#define DECL_HAS_INIT_PRIORITY_P(NODE) \
3397	(VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
3398
3399	extern tree decl_debug_expr_lookup (tree);
3400	extern void decl_debug_expr_insert (tree, tree);
3401
3402	/* For VAR_DECL, this is set to an expression that it was split from. */
3403	#define DECL_HAS_DEBUG_EXPR_P(NODE) \
3404	(VAR_DECL_CHECK (NODE)->decl_common.debug_expr_is_from)
3405	#define DECL_DEBUG_EXPR(NODE) \
3406	(decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))
3407
3408	#define SET_DECL_DEBUG_EXPR(NODE, VAL) \
3409	(decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
3410
3411	extern priority_type decl_init_priority_lookup (tree);
3412	extern priority_type decl_fini_priority_lookup (tree);
3413	extern void decl_init_priority_insert (tree, priority_type);
3414	extern void decl_fini_priority_insert (tree, priority_type);
3415
3416	/* For a VAR_DECL or FUNCTION_DECL the initialization priority of
3417	NODE. */
3418	#define DECL_INIT_PRIORITY(NODE) \
3419	(decl_init_priority_lookup (NODE))
3420	/* Set the initialization priority for NODE to VAL. */
3421	#define SET_DECL_INIT_PRIORITY(NODE, VAL) \
3422	(decl_init_priority_insert (NODE, VAL))
3423
3424	/* For a FUNCTION_DECL the finalization priority of NODE. */
3425	#define DECL_FINI_PRIORITY(NODE) \
3426	(decl_fini_priority_lookup (NODE))
3427	/* Set the finalization priority for NODE to VAL. */
3428	#define SET_DECL_FINI_PRIORITY(NODE, VAL) \
3429	(decl_fini_priority_insert (NODE, VAL))
3430
3431	/* The initialization priority for entities for which no explicit
3432	initialization priority has been specified. */
3433	#define DEFAULT_INIT_PRIORITY 65535
3434
3435	/* The maximum allowed initialization priority. */
3436	#define MAX_INIT_PRIORITY 65535
3437
3438	/* The largest priority value reserved for use by system runtime
3439	libraries. */
3440	#define MAX_RESERVED_INIT_PRIORITY 100
3441
3442	/* In a VAR_DECL, nonzero if this is a global variable for VOPs. */
3443	#define VAR_DECL_IS_VIRTUAL_OPERAND(NODE) \
3444	(VAR_DECL_CHECK (NODE)->base.u.bits.saturating_flag)
3445
3446	/* In a VAR_DECL, nonzero if this is a non-local frame structure. */
3447	#define DECL_NONLOCAL_FRAME(NODE) \
3448	(VAR_DECL_CHECK (NODE)->base.default_def_flag)
3449
3450	/* In a VAR_DECL, nonzero if this variable is not aliased by any pointer. */
3451	#define DECL_NONALIASED(NODE) \
3452	(VAR_DECL_CHECK (NODE)->base.nothrow_flag)
3453
3454	/* In a VAR_DECL, nonzero if this variable is not required to have a distinct
3455	address from other variables with the same constant value. In other words,
3456	consider -fmerge-all-constants to be on for this VAR_DECL. */
3457	#define DECL_MERGEABLE(NODE) \
3458	(VAR_DECL_CHECK (NODE)->decl_common.decl_flag_3)
3459
3460	/* This field is used to reference anything in decl.result and is meant only
3461	for use by the garbage collector. */
3462	#define DECL_RESULT_FLD(NODE) \
3463	(DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
3464
3465	/* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
3466	Before the struct containing the FUNCTION_DECL is laid out,
3467	DECL_VINDEX may point to a FUNCTION_DECL in a base class which
3468	is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
3469	function. When the class is laid out, this pointer is changed
3470	to an INTEGER_CST node which is suitable for use as an index
3471	into the virtual function table. */
3472	#define DECL_VINDEX(NODE) \
3473	(FUNCTION_DECL_CHECK (NODE)->function_decl.vindex)
3474
3475	/* In FUNCTION_DECL, holds the decl for the return value. */
3476	#define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
3477
3478	/* In a FUNCTION_DECL, nonzero if the function cannot be inlined. */
3479	#define DECL_UNINLINABLE(NODE) \
3480	(FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
3481
3482	/* In a FUNCTION_DECL, the saved representation of the body of the
3483	entire function. */
3484	#define DECL_SAVED_TREE(NODE) \
3485	(FUNCTION_DECL_CHECK (NODE)->function_decl.saved_tree)
3486
3487	/* Nonzero in a FUNCTION_DECL means this function should be treated
3488	as if it were a malloc, meaning it returns a pointer that is
3489	not an alias. */
3490	#define DECL_IS_MALLOC(NODE) \
3491	(FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
3492
3493	/* Macro for direct set and get of function_decl.decl_type. */
3494	#define FUNCTION_DECL_DECL_TYPE(NODE) \
3495	(NODE->function_decl.decl_type)
3496
3497	/* Set decl_type of a DECL. Set it to T when SET is true, or reset
3498	it to NONE. */
3499
3500	inline void
3501	set_function_decl_type (tree decl, function_decl_type t, bool set)
3502	{
3503	if (set)
3504	{
3505	gcc_assert (FUNCTION_DECL_DECL_TYPE (decl) == function_decl_type::NONE
3506	|| FUNCTION_DECL_DECL_TYPE (decl) == t);
3507	FUNCTION_DECL_DECL_TYPE (decl) = t;
3508	}
3509	else if (FUNCTION_DECL_DECL_TYPE (decl) == t)
3510	FUNCTION_DECL_DECL_TYPE (decl) = function_decl_type::NONE;
3511	}
3512
3513	/* Nonzero in a FUNCTION_DECL means this function is a replaceable
3514	function (like replaceable operators new or delete). */
3515	#define DECL_IS_REPLACEABLE_OPERATOR(NODE)\
3516	(FUNCTION_DECL_CHECK (NODE)->function_decl.replaceable_operator)
3517
3518	/* Nonzero in a FUNCTION_DECL means this function should be treated as
3519	C++ operator new, meaning that it returns a pointer for which we
3520	should not use type based aliasing. */
3521	#define DECL_IS_OPERATOR_NEW_P(NODE) \
3522	(FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \
3523	== function_decl_type::OPERATOR_NEW)
3524
3525	#define DECL_IS_REPLACEABLE_OPERATOR_NEW_P(NODE) \
3526	(DECL_IS_OPERATOR_NEW_P (NODE) && DECL_IS_REPLACEABLE_OPERATOR (NODE))
3527
3528	#define DECL_SET_IS_OPERATOR_NEW(NODE, VAL) \
3529	set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \
3530	function_decl_type::OPERATOR_NEW, VAL)
3531
3532	/* Nonzero in a FUNCTION_DECL means this function should be treated as
3533	C++ operator delete. */
3534	#define DECL_IS_OPERATOR_DELETE_P(NODE) \
3535	(FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \
3536	== function_decl_type::OPERATOR_DELETE)
3537
3538	#define DECL_SET_IS_OPERATOR_DELETE(NODE, VAL) \
3539	set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \
3540	function_decl_type::OPERATOR_DELETE, VAL)
3541
3542	/* Nonzero in a FUNCTION_DECL means this function may return more
3543	than once. */
3544	#define DECL_IS_RETURNS_TWICE(NODE) \
3545	(FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)
3546
3547	/* Nonzero in a FUNCTION_DECL means this function should be treated
3548	as "pure" function (like const function, but may read global memory).
3549	Note that being pure or const for a function is orthogonal to being
3550	nothrow, i.e. it is valid to have DECL_PURE_P set and TREE_NOTHROW
3551	cleared. */
3552	#define DECL_PURE_P(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)
3553
3554	/* Nonzero only if one of TREE_READONLY or DECL_PURE_P is nonzero AND
3555	the const or pure function may not terminate. When this is nonzero
3556	for a const or pure function, it can be dealt with by cse passes
3557	but cannot be removed by dce passes since you are not allowed to
3558	change an infinite looping program into one that terminates without
3559	error. */
3560	#define DECL_LOOPING_CONST_OR_PURE_P(NODE) \
3561	(FUNCTION_DECL_CHECK (NODE)->function_decl.looping_const_or_pure_flag)
3562
3563	/* Nonzero in a FUNCTION_DECL means this function should be treated
3564	as "novops" function (function that does not read global memory,
3565	but may have arbitrary side effects). */
3566	#define DECL_IS_NOVOPS(NODE) \
3567	(FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
3568
3569	/* Used in FUNCTION_DECLs to indicate that they should be run automatically
3570	at the beginning or end of execution. */
3571	#define DECL_STATIC_CONSTRUCTOR(NODE) \
3572	(FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
3573
3574	#define DECL_STATIC_DESTRUCTOR(NODE) \
3575	(FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)
3576
3577	/* Used in FUNCTION_DECLs to indicate that function entry and exit should
3578	be instrumented with calls to support routines. */
3579	#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
3580	(FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)
3581
3582	/* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
3583	disabled in this function. */
3584	#define DECL_NO_LIMIT_STACK(NODE) \
3585	(FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
3586
3587	/* In a FUNCTION_DECL indicates that a static chain is needed. */
3588	#define DECL_STATIC_CHAIN(NODE) \
3589	(FUNCTION_DECL_CHECK (NODE)->decl_with_vis.regdecl_flag)
3590
3591	/* Nonzero for a decl that cgraph has decided should be inlined into
3592	at least one call site. It is not meaningful to look at this
3593	directly; always use cgraph_function_possibly_inlined_p. */
3594	#define DECL_POSSIBLY_INLINED(DECL) \
3595	FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined
3596
3597	/* Nonzero in a FUNCTION_DECL means that this function was declared inline,
3598	such as via the `inline' keyword in C/C++. This flag controls the linkage
3599	semantics of 'inline' */
3600	#define DECL_DECLARED_INLINE_P(NODE) \
3601	(FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
3602
3603	/* Nonzero in a FUNCTION_DECL means this function should not get
3604	-Winline warnings. */
3605	#define DECL_NO_INLINE_WARNING_P(NODE) \
3606	(FUNCTION_DECL_CHECK (NODE)->function_decl.no_inline_warning_flag)
3607
3608	/* Nonzero if a FUNCTION_CODE is a TM load/store. */
3609	#define BUILTIN_TM_LOAD_STORE_P(FN) \
3610	((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
3611
3612	/* Nonzero if a FUNCTION_CODE is a TM load. */
3613	#define BUILTIN_TM_LOAD_P(FN) \
3614	((FN) >= BUILT_IN_TM_LOAD_1 && (FN) <= BUILT_IN_TM_LOAD_RFW_LDOUBLE)
3615
3616	/* Nonzero if a FUNCTION_CODE is a TM store. */
3617	#define BUILTIN_TM_STORE_P(FN) \
3618	((FN) >= BUILT_IN_TM_STORE_1 && (FN) <= BUILT_IN_TM_STORE_WAW_LDOUBLE)
3619
3620	#define CASE_BUILT_IN_TM_LOAD(FN) \
3621	case BUILT_IN_TM_LOAD_##FN: \
3622	case BUILT_IN_TM_LOAD_RAR_##FN: \
3623	case BUILT_IN_TM_LOAD_RAW_##FN: \
3624	case BUILT_IN_TM_LOAD_RFW_##FN
3625
3626	#define CASE_BUILT_IN_TM_STORE(FN) \
3627	case BUILT_IN_TM_STORE_##FN: \
3628	case BUILT_IN_TM_STORE_WAR_##FN: \
3629	case BUILT_IN_TM_STORE_WAW_##FN
3630
3631	/* Nonzero in a FUNCTION_DECL that should be always inlined by the inliner
3632	disregarding size and cost heuristics. This is equivalent to using
3633	the always_inline attribute without the required diagnostics if the
3634	function cannot be inlined. */
3635	#define DECL_DISREGARD_INLINE_LIMITS(NODE) \
3636	(FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)
3637
3638	extern vec<tree, va_gc> **decl_debug_args_lookup (tree);
3639	extern vec<tree, va_gc> **decl_debug_args_insert (tree);
3640
3641	/* Nonzero if a FUNCTION_DECL has DEBUG arguments attached to it. */
3642	#define DECL_HAS_DEBUG_ARGS_P(NODE) \
3643	(FUNCTION_DECL_CHECK (NODE)->function_decl.has_debug_args_flag)
3644
3645	/* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
3646	that describes the status of this function. */
3647	#define DECL_STRUCT_FUNCTION(NODE) \
3648	(FUNCTION_DECL_CHECK (NODE)->function_decl.f)
3649
3650	/* For a builtin function, identify which part of the compiler defined it. */
3651	#define DECL_BUILT_IN_CLASS(NODE) \
3652	((built_in_class) FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
3653
3654	/* In FUNCTION_DECL, a chain of ..._DECL nodes. */
3655	#define DECL_ARGUMENTS(NODE) \
3656	(FUNCTION_DECL_CHECK (NODE)->function_decl.arguments)
3657
3658	/* In FUNCTION_DECL, the function specific target options to use when compiling
3659	this function. */
3660	#define DECL_FUNCTION_SPECIFIC_TARGET(NODE) \
3661	(FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_target)
3662
3663	/* In FUNCTION_DECL, the function specific optimization options to use when
3664	compiling this function. */
3665	#define DECL_FUNCTION_SPECIFIC_OPTIMIZATION(NODE) \
3666	(FUNCTION_DECL_CHECK (NODE)->function_decl.function_specific_optimization)
3667
3668	/* In FUNCTION_DECL, this is set if this function has other versions generated
3669	to support different architecture feature sets, e.g. using "target" or
3670	"target_version" attributes. */
3671	#define DECL_FUNCTION_VERSIONED(NODE)\
3672	(FUNCTION_DECL_CHECK (NODE)->function_decl.versioned_function)
3673
3674	/* In FUNCTION_DECL, this is set if this function is a C++ constructor.
3675	Devirtualization machinery uses this knowledge for determing type of the
3676	object constructed. Also we assume that constructor address is not
3677	important. */
3678	#define DECL_CXX_CONSTRUCTOR_P(NODE)\
3679	(FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_constructor)
3680
3681	/* In FUNCTION_DECL, this is set if this function is a C++ destructor.
3682	Devirtualization machinery uses this to track types in destruction. */
3683	#define DECL_CXX_DESTRUCTOR_P(NODE)\
3684	(FUNCTION_DECL_CHECK (NODE)->decl_with_vis.cxx_destructor)
3685
3686	/* In FUNCTION_DECL, this is set if this function is a lambda function. */
3687	#define DECL_LAMBDA_FUNCTION_P(NODE) \
3688	(FUNCTION_DECL_DECL_TYPE (FUNCTION_DECL_CHECK (NODE)) \
3689	== function_decl_type::LAMBDA_FUNCTION)
3690
3691	#define DECL_SET_LAMBDA_FUNCTION(NODE, VAL) \
3692	set_function_decl_type (FUNCTION_DECL_CHECK (NODE), \
3693	function_decl_type::LAMBDA_FUNCTION, VAL)
3694
3695	/* In FUNCTION_DECL that represent an virtual method this is set when
3696	the method is final. */
3697	#define DECL_FINAL_P(NODE)\
3698	(FUNCTION_DECL_CHECK (NODE)->decl_with_vis.final)
3699
3700	/* The source language of the translation-unit. */
3701	#define TRANSLATION_UNIT_LANGUAGE(NODE) \
3702	(TRANSLATION_UNIT_DECL_CHECK (NODE)->translation_unit_decl.language)
3703
3704	/* TRANSLATION_UNIT_DECL inherits from DECL_MINIMAL. */
3705
3706	/* For a TYPE_DECL, holds the "original" type. (TREE_TYPE has the copy.) */
3707	#define DECL_ORIGINAL_TYPE(NODE) \
3708	(TYPE_DECL_CHECK (NODE)->decl_non_common.result)
3709
3710	/* In a TYPE_DECL nonzero means the detail info about this type is not dumped
3711	into stabs. Instead it will generate cross reference ('x') of names.
3712	This uses the same flag as DECL_EXTERNAL. */
3713	#define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
3714	(TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_1)
3715
3716	/* Getter of the imported declaration associated to the
3717	IMPORTED_DECL node. */
3718	#define IMPORTED_DECL_ASSOCIATED_DECL(NODE) \
3719	(DECL_INITIAL (IMPORTED_DECL_CHECK (NODE)))
3720
3721	/* Getter of the symbol declaration associated with the
3722	NAMELIST_DECL node. */
3723	#define NAMELIST_DECL_ASSOCIATED_DECL(NODE) \
3724	(DECL_INITIAL (NODE))
3725
3726	/* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
3727	To reduce overhead, the nodes containing the statements are not trees.
3728	This avoids the overhead of tree_common on all linked list elements.
3729
3730	Use the interface in tree-iterator.h to access this node. */
3731
3732	#define STATEMENT_LIST_HEAD(NODE) \
3733	(STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
3734	#define STATEMENT_LIST_TAIL(NODE) \
3735	(STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
3736
3737	#define TREE_OPTIMIZATION(NODE) \
3738	(OPTIMIZATION_NODE_CHECK (NODE)->optimization.opts)
3739
3740	#define TREE_OPTIMIZATION_OPTABS(NODE) \
3741	(OPTIMIZATION_NODE_CHECK (NODE)->optimization.optabs)
3742
3743	#define TREE_OPTIMIZATION_BASE_OPTABS(NODE) \
3744	(OPTIMIZATION_NODE_CHECK (NODE)->optimization.base_optabs)
3745
3746	/* Return a tree node that encapsulates the optimization options in OPTS
3747	and OPTS_SET. */
3748	extern tree build_optimization_node (struct gcc_options *opts,
3749	struct gcc_options *opts_set);
3750
3751	#define TREE_TARGET_OPTION(NODE) \
3752	(TARGET_OPTION_NODE_CHECK (NODE)->target_option.opts)
3753
3754	#define TREE_TARGET_GLOBALS(NODE) \
3755	(TARGET_OPTION_NODE_CHECK (NODE)->target_option.globals)
3756
3757	/* Return a tree node that encapsulates the target options in OPTS and
3758	OPTS_SET. */
3759	extern tree build_target_option_node (struct gcc_options *opts,
3760	struct gcc_options *opts_set);
3761
3762	extern void prepare_target_option_nodes_for_pch (void);
3763
3764	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
3765
3766	inline tree
3767	tree_check (tree __t, const char *__f, int __l, const char *__g, tree_code __c)
3768	{
3769	if (TREE_CODE (__t) != __c)
3770	tree_check_failed (__t, __f, __l, __g, __c, 0);
3771	return __t;
3772	}
3773
3774	inline tree
3775	tree_not_check (tree __t, const char *__f, int __l, const char *__g,
3776	enum tree_code __c)
3777	{
3778	if (TREE_CODE (__t) == __c)
3779	tree_not_check_failed (__t, __f, __l, __g, __c, 0);
3780	return __t;
3781	}
3782
3783	inline tree
3784	tree_check2 (tree __t, const char *__f, int __l, const char *__g,
3785	enum tree_code __c1, enum tree_code __c2)
3786	{
3787	if (TREE_CODE (__t) != __c1
3788	&& TREE_CODE (__t) != __c2)
3789	tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
3790	return __t;
3791	}
3792
3793	inline tree
3794	tree_not_check2 (tree __t, const char *__f, int __l, const char *__g,
3795	enum tree_code __c1, enum tree_code __c2)
3796	{
3797	if (TREE_CODE (__t) == __c1
3798	|| TREE_CODE (__t) == __c2)
3799	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
3800	return __t;
3801	}
3802
3803	inline tree
3804	tree_check3 (tree __t, const char *__f, int __l, const char *__g,
3805	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
3806	{
3807	if (TREE_CODE (__t) != __c1
3808	&& TREE_CODE (__t) != __c2
3809	&& TREE_CODE (__t) != __c3)
3810	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
3811	return __t;
3812	}
3813
3814	inline tree
3815	tree_not_check3 (tree __t, const char *__f, int __l, const char *__g,
3816	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
3817	{
3818	if (TREE_CODE (__t) == __c1
3819	|| TREE_CODE (__t) == __c2
3820	|| TREE_CODE (__t) == __c3)
3821	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
3822	return __t;
3823	}
3824
3825	inline tree
3826	tree_check4 (tree __t, const char *__f, int __l, const char *__g,
3827	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3828	enum tree_code __c4)
3829	{
3830	if (TREE_CODE (__t) != __c1
3831	&& TREE_CODE (__t) != __c2
3832	&& TREE_CODE (__t) != __c3
3833	&& TREE_CODE (__t) != __c4)
3834	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
3835	return __t;
3836	}
3837
3838	inline tree
3839	tree_not_check4 (tree __t, const char *__f, int __l, const char *__g,
3840	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3841	enum tree_code __c4)
3842	{
3843	if (TREE_CODE (__t) == __c1
3844	|| TREE_CODE (__t) == __c2
3845	|| TREE_CODE (__t) == __c3
3846	|| TREE_CODE (__t) == __c4)
3847	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
3848	return __t;
3849	}
3850
3851	inline tree
3852	tree_check5 (tree __t, const char *__f, int __l, const char *__g,
3853	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3854	enum tree_code __c4, enum tree_code __c5)
3855	{
3856	if (TREE_CODE (__t) != __c1
3857	&& TREE_CODE (__t) != __c2
3858	&& TREE_CODE (__t) != __c3
3859	&& TREE_CODE (__t) != __c4
3860	&& TREE_CODE (__t) != __c5)
3861	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
3862	return __t;
3863	}
3864
3865	inline tree
3866	tree_not_check5 (tree __t, const char *__f, int __l, const char *__g,
3867	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3868	enum tree_code __c4, enum tree_code __c5)
3869	{
3870	if (TREE_CODE (__t) == __c1
3871	|| TREE_CODE (__t) == __c2
3872	|| TREE_CODE (__t) == __c3
3873	|| TREE_CODE (__t) == __c4
3874	|| TREE_CODE (__t) == __c5)
3875	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
3876	return __t;
3877	}
3878
3879	inline tree
3880	tree_check6 (tree __t, const char *__f, int __l, const char *__g,
3881	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3882	enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
3883	{
3884	if (TREE_CODE (__t) != __c1
3885	&& TREE_CODE (__t) != __c2
3886	&& TREE_CODE (__t) != __c3
3887	&& TREE_CODE (__t) != __c4
3888	&& TREE_CODE (__t) != __c5
3889	&& TREE_CODE (__t) != __c6)
3890	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, __c6,
3891	0);
3892	return __t;
3893	}
3894
3895	inline tree
3896	tree_not_check6 (tree __t, const char *__f, int __l, const char *__g,
3897	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
3898	enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
3899	{
3900	if (TREE_CODE (__t) == __c1
3901	|| TREE_CODE (__t) == __c2
3902	|| TREE_CODE (__t) == __c3
3903	|| TREE_CODE (__t) == __c4
3904	|| TREE_CODE (__t) == __c5
3905	|| TREE_CODE (__t) == __c6)
3906	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
3907	__c6, 0);
3908	return __t;
3909	}
3910
3911	inline tree
3912	contains_struct_check (tree __t, const enum tree_node_structure_enum __s,
3913	const char *__f, int __l, const char *__g)
3914	{
3915	if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
3916	tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
3917	return __t;
3918	}
3919
3920	inline tree
3921	tree_class_check (tree __t, const enum tree_code_class __class,
3922	const char *__f, int __l, const char *__g)
3923	{
3924	if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
3925	tree_class_check_failed (__t, __class, __f, __l, __g);
3926	return __t;
3927	}
3928
3929	inline tree
3930	tree_range_check (tree __t,
3931	enum tree_code __code1, enum tree_code __code2,
3932	const char *__f, int __l, const char *__g)
3933	{
3934	if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
3935	tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
3936	return __t;
3937	}
3938
3939	inline tree
3940	omp_clause_subcode_check (tree __t, enum omp_clause_code __code,
3941	const char *__f, int __l, const char *__g)
3942	{
3943	if (TREE_CODE (__t) != OMP_CLAUSE)
3944	tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
3945	if (__t->omp_clause.code != __code)
3946	omp_clause_check_failed (__t, __f, __l, __g, __code);
3947	return __t;
3948	}
3949
3950	inline tree
3951	omp_clause_range_check (tree __t,
3952	enum omp_clause_code __code1,
3953	enum omp_clause_code __code2,
3954	const char *__f, int __l, const char *__g)
3955	{
3956	if (TREE_CODE (__t) != OMP_CLAUSE)
3957	tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
3958	if ((int) __t->omp_clause.code < (int) __code1
3959	|| (int) __t->omp_clause.code > (int) __code2)
3960	omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
3961	return __t;
3962	}
3963
3964	/* These checks have to be special cased. */
3965
3966	inline tree
3967	expr_check (tree __t, const char *__f, int __l, const char *__g)
3968	{
3969	char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
3970	if (!IS_EXPR_CODE_CLASS (__c))
3971	tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
3972	return __t;
3973	}
3974
3975	/* These checks have to be special cased. */
3976
3977	inline tree
3978	non_type_check (tree __t, const char *__f, int __l, const char *__g)
3979	{
3980	if (TYPE_P (__t))
3981	tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
3982	return __t;
3983	}
3984
3985	inline const HOST_WIDE_INT *
3986	tree_int_cst_elt_check (const_tree __t, int __i,
3987	const char *__f, int __l, const char *__g)
3988	{
3989	if (TREE_CODE (__t) != INTEGER_CST)
3990	tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
3991	if (__i < 0 || __i >= __t->base.u.int_length.extended)
3992	tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
3993	__f, __l, __g);
3994	return &const_cast<tree> (__t)->int_cst.val[__i];
3995	}
3996
3997	inline HOST_WIDE_INT *
3998	tree_int_cst_elt_check (tree __t, int __i,
3999	const char *__f, int __l, const char *__g)
4000	{
4001	if (TREE_CODE (__t) != INTEGER_CST)
4002	tree_check_failed (__t, __f, __l, __g, INTEGER_CST, 0);
4003	if (__i < 0 || __i >= __t->base.u.int_length.extended)
4004	tree_int_cst_elt_check_failed (__i, __t->base.u.int_length.extended,
4005	__f, __l, __g);
4006	return &const_cast<tree> (__t)->int_cst.val[__i];
4007	}
4008
4009	/* Workaround -Wstrict-overflow false positive during profiledbootstrap. */
4010
4011	# if GCC_VERSION >= 4006
4012	#pragma GCC diagnostic push
4013	#pragma GCC diagnostic ignored "-Wstrict-overflow"
4014	#endif
4015
4016	inline tree *
4017	tree_vec_elt_check (tree __t, int __i,
4018	const char *__f, int __l, const char *__g)
4019	{
4020	if (TREE_CODE (__t) != TREE_VEC)
4021	tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
4022	if (__i < 0 || __i >= __t->base.u.length)
4023	tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
4024	return &const_cast<tree> (__t)->vec.a[__i];
4025	}
4026
4027	# if GCC_VERSION >= 4006
4028	#pragma GCC diagnostic pop
4029	#endif
4030
4031	inline tree *
4032	omp_clause_elt_check (tree __t, int __i,
4033	const char *__f, int __l, const char *__g)
4034	{
4035	if (TREE_CODE (__t) != OMP_CLAUSE)
4036	tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4037	if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
4038	omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
4039	return &__t->omp_clause.ops[__i];
4040	}
4041
4042	/* These checks have to be special cased. */
4043
4044	inline tree
4045	any_integral_type_check (tree __t, const char *__f, int __l, const char *__g)
4046	{
4047	if (!ANY_INTEGRAL_TYPE_P (__t))
4048	tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
4049	INTEGER_TYPE, BITINT_TYPE, 0);
4050	return __t;
4051	}
4052
4053	inline const_tree
4054	tree_check (const_tree __t, const char *__f, int __l, const char *__g,
4055	tree_code __c)
4056	{
4057	if (TREE_CODE (__t) != __c)
4058	tree_check_failed (__t, __f, __l, __g, __c, 0);
4059	return __t;
4060	}
4061
4062	inline const_tree
4063	tree_not_check (const_tree __t, const char *__f, int __l, const char *__g,
4064	enum tree_code __c)
4065	{
4066	if (TREE_CODE (__t) == __c)
4067	tree_not_check_failed (__t, __f, __l, __g, __c, 0);
4068	return __t;
4069	}
4070
4071	inline const_tree
4072	tree_check2 (const_tree __t, const char *__f, int __l, const char *__g,
4073	enum tree_code __c1, enum tree_code __c2)
4074	{
4075	if (TREE_CODE (__t) != __c1
4076	&& TREE_CODE (__t) != __c2)
4077	tree_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
4078	return __t;
4079	}
4080
4081	inline const_tree
4082	tree_not_check2 (const_tree __t, const char *__f, int __l, const char *__g,
4083	enum tree_code __c1, enum tree_code __c2)
4084	{
4085	if (TREE_CODE (__t) == __c1
4086	|| TREE_CODE (__t) == __c2)
4087	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, 0);
4088	return __t;
4089	}
4090
4091	inline const_tree
4092	tree_check3 (const_tree __t, const char *__f, int __l, const char *__g,
4093	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
4094	{
4095	if (TREE_CODE (__t) != __c1
4096	&& TREE_CODE (__t) != __c2
4097	&& TREE_CODE (__t) != __c3)
4098	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
4099	return __t;
4100	}
4101
4102	inline const_tree
4103	tree_not_check3 (const_tree __t, const char *__f, int __l, const char *__g,
4104	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3)
4105	{
4106	if (TREE_CODE (__t) == __c1
4107	|| TREE_CODE (__t) == __c2
4108	|| TREE_CODE (__t) == __c3)
4109	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, 0);
4110	return __t;
4111	}
4112
4113	inline const_tree
4114	tree_check4 (const_tree __t, const char *__f, int __l, const char *__g,
4115	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4116	enum tree_code __c4)
4117	{
4118	if (TREE_CODE (__t) != __c1
4119	&& TREE_CODE (__t) != __c2
4120	&& TREE_CODE (__t) != __c3
4121	&& TREE_CODE (__t) != __c4)
4122	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
4123	return __t;
4124	}
4125
4126	inline const_tree
4127	tree_not_check4 (const_tree __t, const char *__f, int __l, const char *__g,
4128	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4129	enum tree_code __c4)
4130	{
4131	if (TREE_CODE (__t) == __c1
4132	|| TREE_CODE (__t) == __c2
4133	|| TREE_CODE (__t) == __c3
4134	|| TREE_CODE (__t) == __c4)
4135	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, 0);
4136	return __t;
4137	}
4138
4139	inline const_tree
4140	tree_check5 (const_tree __t, const char *__f, int __l, const char *__g,
4141	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4142	enum tree_code __c4, enum tree_code __c5)
4143	{
4144	if (TREE_CODE (__t) != __c1
4145	&& TREE_CODE (__t) != __c2
4146	&& TREE_CODE (__t) != __c3
4147	&& TREE_CODE (__t) != __c4
4148	&& TREE_CODE (__t) != __c5)
4149	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
4150	return __t;
4151	}
4152
4153	inline const_tree
4154	tree_not_check5 (const_tree __t, const char *__f, int __l, const char *__g,
4155	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4156	enum tree_code __c4, enum tree_code __c5)
4157	{
4158	if (TREE_CODE (__t) == __c1
4159	|| TREE_CODE (__t) == __c2
4160	|| TREE_CODE (__t) == __c3
4161	|| TREE_CODE (__t) == __c4
4162	|| TREE_CODE (__t) == __c5)
4163	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, 0);
4164	return __t;
4165	}
4166
4167	inline const_tree
4168	tree_check6 (const_tree __t, const char *__f, int __l, const char *__g,
4169	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4170	enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
4171	{
4172	if (TREE_CODE (__t) != __c1
4173	&& TREE_CODE (__t) != __c2
4174	&& TREE_CODE (__t) != __c3
4175	&& TREE_CODE (__t) != __c4
4176	&& TREE_CODE (__t) != __c5
4177	&& TREE_CODE (__t) != __c6)
4178	tree_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5, __c6,
4179	0);
4180	return __t;
4181	}
4182
4183	inline const_tree
4184	tree_not_check6 (const_tree __t, const char *__f, int __l, const char *__g,
4185	enum tree_code __c1, enum tree_code __c2, enum tree_code __c3,
4186	enum tree_code __c4, enum tree_code __c5, enum tree_code __c6)
4187	{
4188	if (TREE_CODE (__t) == __c1
4189	|| TREE_CODE (__t) == __c2
4190	|| TREE_CODE (__t) == __c3
4191	|| TREE_CODE (__t) == __c4
4192	|| TREE_CODE (__t) == __c5
4193	|| TREE_CODE (__t) == __c6)
4194	tree_not_check_failed (__t, __f, __l, __g, __c1, __c2, __c3, __c4, __c5,
4195	__c6, 0);
4196	return __t;
4197	}
4198
4199	inline const_tree
4200	contains_struct_check (const_tree __t, const enum tree_node_structure_enum __s,
4201	const char *__f, int __l, const char *__g)
4202	{
4203	if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
4204	tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
4205	return __t;
4206	}
4207
4208	inline const_tree
4209	tree_class_check (const_tree __t, const enum tree_code_class __class,
4210	const char *__f, int __l, const char *__g)
4211	{
4212	if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
4213	tree_class_check_failed (__t, __class, __f, __l, __g);
4214	return __t;
4215	}
4216
4217	inline const_tree
4218	tree_range_check (const_tree __t,
4219	enum tree_code __code1, enum tree_code __code2,
4220	const char *__f, int __l, const char *__g)
4221	{
4222	if (TREE_CODE (__t) < __code1 || TREE_CODE (__t) > __code2)
4223	tree_range_check_failed (__t, __f, __l, __g, __code1, __code2);
4224	return __t;
4225	}
4226
4227	inline const_tree
4228	omp_clause_subcode_check (const_tree __t, enum omp_clause_code __code,
4229	const char *__f, int __l, const char *__g)
4230	{
4231	if (TREE_CODE (__t) != OMP_CLAUSE)
4232	tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4233	if (__t->omp_clause.code != __code)
4234	omp_clause_check_failed (__t, __f, __l, __g, __code);
4235	return __t;
4236	}
4237
4238	inline const_tree
4239	omp_clause_range_check (const_tree __t,
4240	enum omp_clause_code __code1,
4241	enum omp_clause_code __code2,
4242	const char *__f, int __l, const char *__g)
4243	{
4244	if (TREE_CODE (__t) != OMP_CLAUSE)
4245	tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4246	if ((int) __t->omp_clause.code < (int) __code1
4247	|| (int) __t->omp_clause.code > (int) __code2)
4248	omp_clause_range_check_failed (__t, __f, __l, __g, __code1, __code2);
4249	return __t;
4250	}
4251
4252	inline const_tree
4253	expr_check (const_tree __t, const char *__f, int __l, const char *__g)
4254	{
4255	char const __c = TREE_CODE_CLASS (TREE_CODE (__t));
4256	if (!IS_EXPR_CODE_CLASS (__c))
4257	tree_class_check_failed (__t, tcc_expression, __f, __l, __g);
4258	return __t;
4259	}
4260
4261	inline const_tree
4262	non_type_check (const_tree __t, const char *__f, int __l, const char *__g)
4263	{
4264	if (TYPE_P (__t))
4265	tree_not_class_check_failed (__t, tcc_type, __f, __l, __g);
4266	return __t;
4267	}
4268
4269	# if GCC_VERSION >= 4006
4270	#pragma GCC diagnostic push
4271	#pragma GCC diagnostic ignored "-Wstrict-overflow"
4272	#endif
4273
4274	inline const_tree *
4275	tree_vec_elt_check (const_tree __t, int __i,
4276	const char *__f, int __l, const char *__g)
4277	{
4278	if (TREE_CODE (__t) != TREE_VEC)
4279	tree_check_failed (__t, __f, __l, __g, TREE_VEC, 0);
4280	if (__i < 0 || __i >= __t->base.u.length)
4281	tree_vec_elt_check_failed (__i, __t->base.u.length, __f, __l, __g);
4282	return const_cast<const_tree *> (&__t->vec.a[__i]);
4283	//return &__t->vec.a[__i];
4284	}
4285
4286	# if GCC_VERSION >= 4006
4287	#pragma GCC diagnostic pop
4288	#endif
4289
4290	inline const_tree *
4291	omp_clause_elt_check (const_tree __t, int __i,
4292	const char *__f, int __l, const char *__g)
4293	{
4294	if (TREE_CODE (__t) != OMP_CLAUSE)
4295	tree_check_failed (__t, __f, __l, __g, OMP_CLAUSE, 0);
4296	if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])
4297	omp_clause_operand_check_failed (__i, __t, __f, __l, __g);
4298	return const_cast<const_tree *> (&__t->omp_clause.ops[__i]);
4299	}
4300
4301	inline const_tree
4302	any_integral_type_check (const_tree __t, const char *__f, int __l,
4303	const char *__g)
4304	{
4305	if (!ANY_INTEGRAL_TYPE_P (__t))
4306	tree_check_failed (__t, __f, __l, __g, BOOLEAN_TYPE, ENUMERAL_TYPE,
4307	INTEGER_TYPE, BITINT_TYPE, 0);
4308	return __t;
4309	}
4310
4311	#endif
4312
4313	/* Compute the number of operands in an expression node NODE. For
4314	tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
4315	otherwise it is looked up from the node's code. */
4316	inline int
4317	tree_operand_length (const_tree node)
4318	{
4319	if (VL_EXP_CLASS_P (node))
4320	return VL_EXP_OPERAND_LENGTH (node);
4321	else
4322	return TREE_CODE_LENGTH (TREE_CODE (node));
4323	}
4324
4325	#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4326
4327	/* Special checks for TREE_OPERANDs. */
4328	inline tree *
4329	tree_operand_check (tree __t, int __i,
4330	const char *__f, int __l, const char *__g)
4331	{
4332	const_tree __u = EXPR_CHECK (__t);
4333	if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
4334	tree_operand_check_failed (__i, __u, __f, __l, __g);
4335	return &const_cast<tree> (__u)->exp.operands[__i];
4336	}
4337
4338	inline tree *
4339	tree_operand_check_code (tree __t, enum tree_code __code, int __i,
4340	const char *__f, int __l, const char *__g)
4341	{
4342	if (TREE_CODE (__t) != __code)
4343	tree_check_failed (__t, __f, __l, __g, __code, 0);
4344	if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
4345	tree_operand_check_failed (__i, __t, __f, __l, __g);
4346	return &__t->exp.operands[__i];
4347	}
4348
4349	inline const_tree *
4350	tree_operand_check (const_tree __t, int __i,
4351	const char *__f, int __l, const char *__g)
4352	{
4353	const_tree __u = EXPR_CHECK (__t);
4354	if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__u))
4355	tree_operand_check_failed (__i, __u, __f, __l, __g);
4356	return const_cast<const_tree *> (&__u->exp.operands[__i]);
4357	}
4358
4359	inline const_tree *
4360	tree_operand_check_code (const_tree __t, enum tree_code __code, int __i,
4361	const char *__f, int __l, const char *__g)
4362	{
4363	if (TREE_CODE (__t) != __code)
4364	tree_check_failed (__t, __f, __l, __g, __code, 0);
4365	if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))
4366	tree_operand_check_failed (__i, __t, __f, __l, __g);
4367	return const_cast<const_tree *> (&__t->exp.operands[__i]);
4368	}
4369
4370	#endif
4371
4372	/* True iff an identifier matches a C string. */
4373
4374	inline bool
4375	id_equal (const_tree id, const char *str)
4376	{
4377	return !strcmp (IDENTIFIER_POINTER (id), s2: str);
4378	}
4379
4380	inline bool
4381	id_equal (const char *str, const_tree id)
4382	{
4383	return id_equal (id, str);
4384	}
4385
4386	/* Return the number of elements in the VECTOR_TYPE given by NODE. */
4387
4388	inline poly_uint64
4389	TYPE_VECTOR_SUBPARTS (const_tree node)
4390	{
4391	STATIC_ASSERT (NUM_POLY_INT_COEFFS <= 2);
4392	unsigned int precision = VECTOR_TYPE_CHECK (node)->type_common.precision;
4393	if (NUM_POLY_INT_COEFFS == 2)
4394	{
4395	/* See the corresponding code in SET_TYPE_VECTOR_SUBPARTS for a
4396	description of the encoding. */
4397	poly_uint64 res = 0;
4398	res.coeffs[0] = HOST_WIDE_INT_1U << (precision & 0xff);
4399	if (precision & 0x100)
4400	res.coeffs[1] = HOST_WIDE_INT_1U << (precision & 0xff);
4401	return res;
4402	}
4403	else
4404	return HOST_WIDE_INT_1U << precision;
4405	}
4406
4407	/* Set the number of elements in VECTOR_TYPE NODE to SUBPARTS, which must
4408	satisfy valid_vector_subparts_p. */
4409
4410	inline void
4411	SET_TYPE_VECTOR_SUBPARTS (tree node, poly_uint64 subparts)
4412	{
4413	STATIC_ASSERT (NUM_POLY_INT_COEFFS <= 2);
4414	unsigned HOST_WIDE_INT coeff0 = subparts.coeffs[0];
4415	int index = exact_log2 (x: coeff0);
4416	gcc_assert (index >= 0);
4417	if (NUM_POLY_INT_COEFFS == 2)
4418	{
4419	/* We have two coefficients that are each in the range 1 << [0, 63],
4420	so supporting all combinations would require 6 bits per coefficient
4421	and 12 bits in total. Since the precision field is only 10 bits
4422	in size, we need to be more restrictive than that.
4423
4424	At present, coeff[1] is always either 0 (meaning that the number
4425	of units is constant) or equal to coeff[0] (meaning that the number
4426	of units is N + X * N for some target-dependent zero-based runtime
4427	parameter X). We can therefore encode coeff[1] in a single bit.
4428
4429	The most compact encoding would be to use mask 0x3f for coeff[0]
4430	and 0x40 for coeff[1], leaving 0x380 unused. It's possible to
4431	get slightly more efficient code on some hosts if we instead
4432	treat the shift amount as an independent byte, so here we use
4433	0xff for coeff[0] and 0x100 for coeff[1]. */
4434	unsigned HOST_WIDE_INT coeff1 = subparts.coeffs[1];
4435	gcc_assert (coeff1 == 0 || coeff1 == coeff0);
4436	VECTOR_TYPE_CHECK (node)->type_common.precision
4437	= index + (coeff1 != 0 ? 0x100 : 0);
4438	}
4439	else
4440	VECTOR_TYPE_CHECK (node)->type_common.precision = index;
4441	}
4442
4443	/* Return true if we can construct vector types with the given number
4444	of subparts. */
4445
4446	inline bool
4447	valid_vector_subparts_p (poly_uint64 subparts)
4448	{
4449	unsigned HOST_WIDE_INT coeff0 = subparts.coeffs[0];
4450	if (!pow2p_hwi (x: coeff0))
4451	return false;
4452	if (NUM_POLY_INT_COEFFS == 2)
4453	{
4454	unsigned HOST_WIDE_INT coeff1 = subparts.coeffs[1];
4455	if (coeff1 != 0 && coeff1 != coeff0)
4456	return false;
4457	}
4458	return true;
4459	}
4460
4461	/* Return the built-in function that DECL represents, given that it is known
4462	to be a FUNCTION_DECL with built-in class BUILT_IN_NORMAL. */
4463	inline built_in_function
4464	DECL_FUNCTION_CODE (const_tree decl)
4465	{
4466	const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4467	gcc_checking_assert (fndecl.built_in_class == BUILT_IN_NORMAL);
4468	return (built_in_function) fndecl.function_code;
4469	}
4470
4471	/* Return the target-specific built-in function that DECL represents,
4472	given that it is known to be a FUNCTION_DECL with built-in class
4473	BUILT_IN_MD. */
4474	inline int
4475	DECL_MD_FUNCTION_CODE (const_tree decl)
4476	{
4477	const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4478	gcc_checking_assert (fndecl.built_in_class == BUILT_IN_MD);
4479	return fndecl.function_code;
4480	}
4481
4482	/* Return the frontend-specific built-in function that DECL represents,
4483	given that it is known to be a FUNCTION_DECL with built-in class
4484	BUILT_IN_FRONTEND. */
4485	inline int
4486	DECL_FE_FUNCTION_CODE (const_tree decl)
4487	{
4488	const tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4489	gcc_checking_assert (fndecl.built_in_class == BUILT_IN_FRONTEND);
4490	return fndecl.function_code;
4491	}
4492
4493	/* Record that FUNCTION_DECL DECL represents built-in function FCODE of
4494	class FCLASS. */
4495	inline void
4496	set_decl_built_in_function (tree decl, built_in_class fclass,
4497	unsigned int fcode)
4498	{
4499	tree_function_decl &fndecl = FUNCTION_DECL_CHECK (decl)->function_decl;
4500	fndecl.built_in_class = fclass;
4501	fndecl.function_code = fcode;
4502	}
4503
4504	/* Record that FUNCTION_DECL NEWDECL represents the same built-in function
4505	as OLDDECL (or none, if OLDDECL doesn't represent a built-in function). */
4506	inline void
4507	copy_decl_built_in_function (tree newdecl, const_tree olddecl)
4508	{
4509	tree_function_decl &newfndecl = FUNCTION_DECL_CHECK (newdecl)->function_decl;
4510	const tree_function_decl &oldfndecl
4511	= FUNCTION_DECL_CHECK (olddecl)->function_decl;
4512	newfndecl.built_in_class = oldfndecl.built_in_class;
4513	newfndecl.function_code = oldfndecl.function_code;
4514	}
4515
4516	/* In NON_LVALUE_EXPR and VIEW_CONVERT_EXPR, set when this node is merely a
4517	wrapper added to express a location_t on behalf of the node's child
4518	(e.g. by maybe_wrap_with_location). */
4519
4520	#define EXPR_LOCATION_WRAPPER_P(NODE) \
4521	(TREE_CHECK2(NODE, NON_LVALUE_EXPR, VIEW_CONVERT_EXPR)->base.public_flag)
4522
4523	/* Test if EXP is merely a wrapper node, added to express a location_t
4524	on behalf of the node's child (e.g. by maybe_wrap_with_location). */
4525
4526	inline bool
4527	location_wrapper_p (const_tree exp)
4528	{
4529	/* A wrapper node has code NON_LVALUE_EXPR or VIEW_CONVERT_EXPR, and
4530	the flag EXPR_LOCATION_WRAPPER_P is set.
4531	It normally has the same type as its operand, but it can have a
4532	different one if the type of the operand has changed (e.g. when
4533	merging duplicate decls).
4534
4535	NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
4536	VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST. */
4537	if ((TREE_CODE (exp) == NON_LVALUE_EXPR
4538	|| TREE_CODE (exp) == VIEW_CONVERT_EXPR)
4539	&& EXPR_LOCATION_WRAPPER_P (exp))
4540	return true;
4541	return false;
4542	}
4543
4544	/* Implementation of STRIP_ANY_LOCATION_WRAPPER. */
4545
4546	inline tree
4547	tree_strip_any_location_wrapper (tree exp)
4548	{
4549	if (location_wrapper_p (exp))
4550	return TREE_OPERAND (exp, 0);
4551	else
4552	return exp;
4553	}
4554
4555	#define error_mark_node global_trees[TI_ERROR_MARK]
4556
4557	#define intQI_type_node global_trees[TI_INTQI_TYPE]
4558	#define intHI_type_node global_trees[TI_INTHI_TYPE]
4559	#define intSI_type_node global_trees[TI_INTSI_TYPE]
4560	#define intDI_type_node global_trees[TI_INTDI_TYPE]
4561	#define intTI_type_node global_trees[TI_INTTI_TYPE]
4562
4563	#define unsigned_intQI_type_node global_trees[TI_UINTQI_TYPE]
4564	#define unsigned_intHI_type_node global_trees[TI_UINTHI_TYPE]
4565	#define unsigned_intSI_type_node global_trees[TI_UINTSI_TYPE]
4566	#define unsigned_intDI_type_node global_trees[TI_UINTDI_TYPE]
4567	#define unsigned_intTI_type_node global_trees[TI_UINTTI_TYPE]
4568
4569	#define atomicQI_type_node global_trees[TI_ATOMICQI_TYPE]
4570	#define atomicHI_type_node global_trees[TI_ATOMICHI_TYPE]
4571	#define atomicSI_type_node global_trees[TI_ATOMICSI_TYPE]
4572	#define atomicDI_type_node global_trees[TI_ATOMICDI_TYPE]
4573	#define atomicTI_type_node global_trees[TI_ATOMICTI_TYPE]
4574
4575	#define uint16_type_node global_trees[TI_UINT16_TYPE]
4576	#define uint32_type_node global_trees[TI_UINT32_TYPE]
4577	#define uint64_type_node global_trees[TI_UINT64_TYPE]
4578	#define uint128_type_node global_trees[TI_UINT128_TYPE]
4579
4580	#define void_node global_trees[TI_VOID]
4581
4582	#define integer_zero_node global_trees[TI_INTEGER_ZERO]
4583	#define integer_one_node global_trees[TI_INTEGER_ONE]
4584	#define integer_minus_one_node global_trees[TI_INTEGER_MINUS_ONE]
4585	#define size_zero_node global_trees[TI_SIZE_ZERO]
4586	#define size_one_node global_trees[TI_SIZE_ONE]
4587	#define bitsize_zero_node global_trees[TI_BITSIZE_ZERO]
4588	#define bitsize_one_node global_trees[TI_BITSIZE_ONE]
4589	#define bitsize_unit_node global_trees[TI_BITSIZE_UNIT]
4590
4591	/* Base access nodes. */
4592	#define access_public_node global_trees[TI_PUBLIC]
4593	#define access_protected_node global_trees[TI_PROTECTED]
4594	#define access_private_node global_trees[TI_PRIVATE]
4595
4596	#define null_pointer_node global_trees[TI_NULL_POINTER]
4597
4598	#define float_type_node global_trees[TI_FLOAT_TYPE]
4599	#define double_type_node global_trees[TI_DOUBLE_TYPE]
4600	#define long_double_type_node global_trees[TI_LONG_DOUBLE_TYPE]
4601	#define bfloat16_type_node global_trees[TI_BFLOAT16_TYPE]
4602
4603	/* Nodes for particular _FloatN and _FloatNx types in sequence. */
4604	#define FLOATN_TYPE_NODE(IDX) global_trees[TI_FLOATN_TYPE_FIRST + (IDX)]
4605	#define FLOATN_NX_TYPE_NODE(IDX) global_trees[TI_FLOATN_NX_TYPE_FIRST + (IDX)]
4606	#define FLOATNX_TYPE_NODE(IDX) global_trees[TI_FLOATNX_TYPE_FIRST + (IDX)]
4607
4608	/* Names for individual types (code should normally iterate over all
4609	such types; these are only for back-end use, or in contexts such as
4610	*.def where iteration is not possible). */
4611	#define float16_type_node global_trees[TI_FLOAT16_TYPE]
4612	#define float32_type_node global_trees[TI_FLOAT32_TYPE]
4613	#define float64_type_node global_trees[TI_FLOAT64_TYPE]
4614	#define float128_type_node global_trees[TI_FLOAT128_TYPE]
4615	#define float32x_type_node global_trees[TI_FLOAT32X_TYPE]
4616	#define float64x_type_node global_trees[TI_FLOAT64X_TYPE]
4617	#define float128x_type_node global_trees[TI_FLOAT128X_TYPE]
4618
4619	/* Type used by certain backends for __float128, which in C++ should be
4620	distinct type from _Float128 for backwards compatibility reasons. */
4621	#define float128t_type_node global_trees[TI_FLOAT128T_TYPE]
4622
4623	#define float_ptr_type_node global_trees[TI_FLOAT_PTR_TYPE]
4624	#define double_ptr_type_node global_trees[TI_DOUBLE_PTR_TYPE]
4625	#define long_double_ptr_type_node global_trees[TI_LONG_DOUBLE_PTR_TYPE]
4626	#define integer_ptr_type_node global_trees[TI_INTEGER_PTR_TYPE]
4627
4628	#define complex_integer_type_node global_trees[TI_COMPLEX_INTEGER_TYPE]
4629	#define complex_float_type_node global_trees[TI_COMPLEX_FLOAT_TYPE]
4630	#define complex_double_type_node global_trees[TI_COMPLEX_DOUBLE_TYPE]
4631	#define complex_long_double_type_node global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
4632
4633	#define COMPLEX_FLOATN_NX_TYPE_NODE(IDX) global_trees[TI_COMPLEX_FLOATN_NX_TYPE_FIRST + (IDX)]
4634
4635	#define void_type_node global_trees[TI_VOID_TYPE]
4636	/* The C type `void *'. */
4637	#define ptr_type_node global_trees[TI_PTR_TYPE]
4638	/* The C type `const void *'. */
4639	#define const_ptr_type_node global_trees[TI_CONST_PTR_TYPE]
4640	/* The C type `size_t'. */
4641	#define size_type_node global_trees[TI_SIZE_TYPE]
4642	#define pid_type_node global_trees[TI_PID_TYPE]
4643	#define ptrdiff_type_node global_trees[TI_PTRDIFF_TYPE]
4644	#define va_list_type_node global_trees[TI_VA_LIST_TYPE]
4645	#define va_list_gpr_counter_field global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
4646	#define va_list_fpr_counter_field global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
4647	/* The C type `FILE *'. */
4648	#define fileptr_type_node global_trees[TI_FILEPTR_TYPE]
4649	/* The C type `const struct tm *'. */
4650	#define const_tm_ptr_type_node global_trees[TI_CONST_TM_PTR_TYPE]
4651	/* The C type `fenv_t *'. */
4652	#define fenv_t_ptr_type_node global_trees[TI_FENV_T_PTR_TYPE]
4653	#define const_fenv_t_ptr_type_node global_trees[TI_CONST_FENV_T_PTR_TYPE]
4654	/* The C type `fexcept_t *'. */
4655	#define fexcept_t_ptr_type_node global_trees[TI_FEXCEPT_T_PTR_TYPE]
4656	#define const_fexcept_t_ptr_type_node global_trees[TI_CONST_FEXCEPT_T_PTR_TYPE]
4657	#define pointer_sized_int_node global_trees[TI_POINTER_SIZED_TYPE]
4658
4659	#define boolean_type_node global_trees[TI_BOOLEAN_TYPE]
4660	#define boolean_false_node global_trees[TI_BOOLEAN_FALSE]
4661	#define boolean_true_node global_trees[TI_BOOLEAN_TRUE]
4662
4663	/* The decimal floating point types. */
4664	#define dfloat32_type_node global_trees[TI_DFLOAT32_TYPE]
4665	#define dfloat64_type_node global_trees[TI_DFLOAT64_TYPE]
4666	#define dfloat128_type_node global_trees[TI_DFLOAT128_TYPE]
4667	#define dfloat64x_type_node global_trees[TI_DFLOAT64X_TYPE]
4668
4669	/* The fixed-point types. */
4670	#define sat_short_fract_type_node global_trees[TI_SAT_SFRACT_TYPE]
4671	#define sat_fract_type_node global_trees[TI_SAT_FRACT_TYPE]
4672	#define sat_long_fract_type_node global_trees[TI_SAT_LFRACT_TYPE]
4673	#define sat_long_long_fract_type_node global_trees[TI_SAT_LLFRACT_TYPE]
4674	#define sat_unsigned_short_fract_type_node \
4675	global_trees[TI_SAT_USFRACT_TYPE]
4676	#define sat_unsigned_fract_type_node global_trees[TI_SAT_UFRACT_TYPE]
4677	#define sat_unsigned_long_fract_type_node \
4678	global_trees[TI_SAT_ULFRACT_TYPE]
4679	#define sat_unsigned_long_long_fract_type_node \
4680	global_trees[TI_SAT_ULLFRACT_TYPE]
4681	#define short_fract_type_node global_trees[TI_SFRACT_TYPE]
4682	#define fract_type_node global_trees[TI_FRACT_TYPE]
4683	#define long_fract_type_node global_trees[TI_LFRACT_TYPE]
4684	#define long_long_fract_type_node global_trees[TI_LLFRACT_TYPE]
4685	#define unsigned_short_fract_type_node global_trees[TI_USFRACT_TYPE]
4686	#define unsigned_fract_type_node global_trees[TI_UFRACT_TYPE]
4687	#define unsigned_long_fract_type_node global_trees[TI_ULFRACT_TYPE]
4688	#define unsigned_long_long_fract_type_node \
4689	global_trees[TI_ULLFRACT_TYPE]
4690	#define sat_short_accum_type_node global_trees[TI_SAT_SACCUM_TYPE]
4691	#define sat_accum_type_node global_trees[TI_SAT_ACCUM_TYPE]
4692	#define sat_long_accum_type_node global_trees[TI_SAT_LACCUM_TYPE]
4693	#define sat_long_long_accum_type_node global_trees[TI_SAT_LLACCUM_TYPE]
4694	#define sat_unsigned_short_accum_type_node \
4695	global_trees[TI_SAT_USACCUM_TYPE]
4696	#define sat_unsigned_accum_type_node global_trees[TI_SAT_UACCUM_TYPE]
4697	#define sat_unsigned_long_accum_type_node \
4698	global_trees[TI_SAT_ULACCUM_TYPE]
4699	#define sat_unsigned_long_long_accum_type_node \
4700	global_trees[TI_SAT_ULLACCUM_TYPE]
4701	#define short_accum_type_node global_trees[TI_SACCUM_TYPE]
4702	#define accum_type_node global_trees[TI_ACCUM_TYPE]
4703	#define long_accum_type_node global_trees[TI_LACCUM_TYPE]
4704	#define long_long_accum_type_node global_trees[TI_LLACCUM_TYPE]
4705	#define unsigned_short_accum_type_node global_trees[TI_USACCUM_TYPE]
4706	#define unsigned_accum_type_node global_trees[TI_UACCUM_TYPE]
4707	#define unsigned_long_accum_type_node global_trees[TI_ULACCUM_TYPE]
4708	#define unsigned_long_long_accum_type_node \
4709	global_trees[TI_ULLACCUM_TYPE]
4710	#define qq_type_node global_trees[TI_QQ_TYPE]
4711	#define hq_type_node global_trees[TI_HQ_TYPE]
4712	#define sq_type_node global_trees[TI_SQ_TYPE]
4713	#define dq_type_node global_trees[TI_DQ_TYPE]
4714	#define tq_type_node global_trees[TI_TQ_TYPE]
4715	#define uqq_type_node global_trees[TI_UQQ_TYPE]
4716	#define uhq_type_node global_trees[TI_UHQ_TYPE]
4717	#define usq_type_node global_trees[TI_USQ_TYPE]
4718	#define udq_type_node global_trees[TI_UDQ_TYPE]
4719	#define utq_type_node global_trees[TI_UTQ_TYPE]
4720	#define sat_qq_type_node global_trees[TI_SAT_QQ_TYPE]
4721	#define sat_hq_type_node global_trees[TI_SAT_HQ_TYPE]
4722	#define sat_sq_type_node global_trees[TI_SAT_SQ_TYPE]
4723	#define sat_dq_type_node global_trees[TI_SAT_DQ_TYPE]
4724	#define sat_tq_type_node global_trees[TI_SAT_TQ_TYPE]
4725	#define sat_uqq_type_node global_trees[TI_SAT_UQQ_TYPE]
4726	#define sat_uhq_type_node global_trees[TI_SAT_UHQ_TYPE]
4727	#define sat_usq_type_node global_trees[TI_SAT_USQ_TYPE]
4728	#define sat_udq_type_node global_trees[TI_SAT_UDQ_TYPE]
4729	#define sat_utq_type_node global_trees[TI_SAT_UTQ_TYPE]
4730	#define ha_type_node global_trees[TI_HA_TYPE]
4731	#define sa_type_node global_trees[TI_SA_TYPE]
4732	#define da_type_node global_trees[TI_DA_TYPE]
4733	#define ta_type_node global_trees[TI_TA_TYPE]
4734	#define uha_type_node global_trees[TI_UHA_TYPE]
4735	#define usa_type_node global_trees[TI_USA_TYPE]
4736	#define uda_type_node global_trees[TI_UDA_TYPE]
4737	#define uta_type_node global_trees[TI_UTA_TYPE]
4738	#define sat_ha_type_node global_trees[TI_SAT_HA_TYPE]
4739	#define sat_sa_type_node global_trees[TI_SAT_SA_TYPE]
4740	#define sat_da_type_node global_trees[TI_SAT_DA_TYPE]
4741	#define sat_ta_type_node global_trees[TI_SAT_TA_TYPE]
4742	#define sat_uha_type_node global_trees[TI_SAT_UHA_TYPE]
4743	#define sat_usa_type_node global_trees[TI_SAT_USA_TYPE]
4744	#define sat_uda_type_node global_trees[TI_SAT_UDA_TYPE]
4745	#define sat_uta_type_node global_trees[TI_SAT_UTA_TYPE]
4746
4747	/* The node that should be placed at the end of a parameter list to
4748	indicate that the function does not take a variable number of
4749	arguments. The TREE_VALUE will be void_type_node and there will be
4750	no TREE_CHAIN. Language-independent code should not assume
4751	anything else about this node. */
4752	#define void_list_node global_trees[TI_VOID_LIST_NODE]
4753
4754	#define main_identifier_node global_trees[TI_MAIN_IDENTIFIER]
4755	#define MAIN_NAME_P(NODE) \
4756	(IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
4757
4758	/* Optimization options (OPTIMIZATION_NODE) to use for default and current
4759	functions. */
4760	#define optimization_default_node global_trees[TI_OPTIMIZATION_DEFAULT]
4761	#define optimization_current_node global_trees[TI_OPTIMIZATION_CURRENT]
4762
4763	/* Default/current target options (TARGET_OPTION_NODE). */
4764	#define target_option_default_node global_trees[TI_TARGET_OPTION_DEFAULT]
4765	#define target_option_current_node global_trees[TI_TARGET_OPTION_CURRENT]
4766
4767	/* Default tree list option(), optimize() pragmas to be linked into the
4768	attribute list. */
4769	#define current_target_pragma global_trees[TI_CURRENT_TARGET_PRAGMA]
4770	#define current_optimize_pragma global_trees[TI_CURRENT_OPTIMIZE_PRAGMA]
4771
4772	/* SCEV analyzer global shared trees. */
4773	#define chrec_not_analyzed_yet NULL_TREE
4774	#define chrec_dont_know global_trees[TI_CHREC_DONT_KNOW]
4775	#define chrec_known global_trees[TI_CHREC_KNOWN]
4776
4777	#define char_type_node integer_types[itk_char]
4778	#define signed_char_type_node integer_types[itk_signed_char]
4779	#define unsigned_char_type_node integer_types[itk_unsigned_char]
4780	#define short_integer_type_node integer_types[itk_short]
4781	#define short_unsigned_type_node integer_types[itk_unsigned_short]
4782	#define integer_type_node integer_types[itk_int]
4783	#define unsigned_type_node integer_types[itk_unsigned_int]
4784	#define long_integer_type_node integer_types[itk_long]
4785	#define long_unsigned_type_node integer_types[itk_unsigned_long]
4786	#define long_long_integer_type_node integer_types[itk_long_long]
4787	#define long_long_unsigned_type_node integer_types[itk_unsigned_long_long]
4788
4789	/* True if T is an erroneous expression. */
4790
4791	inline bool
4792	error_operand_p (const_tree t)
4793	{
4794	return (t == error_mark_node
4795	|| (t && TREE_TYPE (t) == error_mark_node));
4796	}
4797
4798	/* Return the number of elements encoded directly in a VECTOR_CST. */
4799
4800	inline unsigned int
4801	vector_cst_encoded_nelts (const_tree t)
4802	{
4803	return VECTOR_CST_NPATTERNS (t) * VECTOR_CST_NELTS_PER_PATTERN (t);
4804	}
4805
4806	extern tree generate_internal_label (const char *);
4807	extern const char *prefix_for_internal_label (tree label);
4808	extern tree decl_assembler_name (tree);
4809	extern void overwrite_decl_assembler_name (tree decl, tree name);
4810	extern tree decl_comdat_group (const_tree);
4811	extern tree decl_comdat_group_id (const_tree);
4812	extern const char *decl_section_name (const_tree);
4813	extern void set_decl_section_name (tree, const char *);
4814	extern void set_decl_section_name (tree, const_tree);
4815	extern enum tls_model decl_tls_model (const_tree);
4816	extern void set_decl_tls_model (tree, enum tls_model);
4817
4818	/* Compute the number of bytes occupied by 'node'. This routine only
4819	looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH. */
4820
4821	extern size_t tree_size (const_tree);
4822
4823	/* Compute the number of bytes occupied by a tree with code CODE.
4824	This function cannot be used for TREE_VEC or INTEGER_CST nodes,
4825	which are of variable length. */
4826	extern size_t tree_code_size (enum tree_code);
4827
4828	/* Allocate and return a new UID from the DECL_UID namespace. */
4829	extern int allocate_decl_uid (void);
4830
4831	/* Lowest level primitive for allocating a node.
4832	The TREE_CODE is the only argument. Contents are initialized
4833	to zero except for a few of the common fields. */
4834
4835	extern tree make_node (enum tree_code CXX_MEM_STAT_INFO);
4836
4837	/* Free tree node. */
4838
4839	extern void free_node (tree);
4840
4841	/* Make a copy of a node, with all the same contents. */
4842
4843	extern tree copy_node (tree CXX_MEM_STAT_INFO);
4844
4845	/* Make a copy of a chain of TREE_LIST nodes. */
4846
4847	extern tree copy_list (tree);
4848
4849	/* Make a CASE_LABEL_EXPR. */
4850
4851	extern tree build_case_label (tree, tree, tree);
4852
4853	/* Make a BINFO. */
4854	extern tree make_tree_binfo (unsigned CXX_MEM_STAT_INFO);
4855
4856	/* Make an INTEGER_CST. */
4857
4858	extern tree make_int_cst (int, int CXX_MEM_STAT_INFO);
4859
4860	/* Make a TREE_VEC. */
4861
4862	extern tree make_tree_vec (int CXX_MEM_STAT_INFO);
4863
4864	/* Grow a TREE_VEC. */
4865
4866	extern tree grow_tree_vec (tree v, int CXX_MEM_STAT_INFO);
4867
4868	/* Treat a TREE_VEC as a range of trees, e.g.
4869	for (tree e : tree_vec_range (v)) { ... } */
4870
4871	class tree_vec_range
4872	{
4873	tree v;
4874	public:
4875	tree_vec_range(tree v) : v(v) { }
4876	tree *begin() { return TREE_VEC_BEGIN (v); }
4877	tree *end() { return TREE_VEC_END (v); }
4878	};
4879
4880	/* Construct various types of nodes. */
4881
4882	extern tree build_nt (enum tree_code, ...);
4883	extern tree build_nt_call_vec (tree, vec<tree, va_gc> *);
4884
4885	extern tree build0 (enum tree_code, tree CXX_MEM_STAT_INFO);
4886	extern tree build1 (enum tree_code, tree, tree CXX_MEM_STAT_INFO);
4887	extern tree build2 (enum tree_code, tree, tree, tree CXX_MEM_STAT_INFO);
4888	extern tree build3 (enum tree_code, tree, tree, tree, tree CXX_MEM_STAT_INFO);
4889	extern tree build4 (enum tree_code, tree, tree, tree, tree,
4890	tree CXX_MEM_STAT_INFO);
4891	extern tree build5 (enum tree_code, tree, tree, tree, tree, tree,
4892	tree CXX_MEM_STAT_INFO);
4893
4894	/* _loc versions of build[1-5]. */
4895
4896	inline tree
4897	build1_loc (location_t loc, enum tree_code code, tree type,
4898	tree arg1 CXX_MEM_STAT_INFO)
4899	{
4900	tree t = build1 (code, type, arg1 PASS_MEM_STAT);
4901	if (CAN_HAVE_LOCATION_P (t))
4902	SET_EXPR_LOCATION (t, loc);
4903	return t;
4904	}
4905
4906	inline tree
4907	build2_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4908	tree arg1 CXX_MEM_STAT_INFO)
4909	{
4910	tree t = build2 (code, type, arg0, arg1 PASS_MEM_STAT);
4911	if (CAN_HAVE_LOCATION_P (t))
4912	SET_EXPR_LOCATION (t, loc);
4913	return t;
4914	}
4915
4916	inline tree
4917	build3_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4918	tree arg1, tree arg2 CXX_MEM_STAT_INFO)
4919	{
4920	tree t = build3 (code, type, arg0, arg1, arg2 PASS_MEM_STAT);
4921	if (CAN_HAVE_LOCATION_P (t))
4922	SET_EXPR_LOCATION (t, loc);
4923	return t;
4924	}
4925
4926	inline tree
4927	build4_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4928	tree arg1, tree arg2, tree arg3 CXX_MEM_STAT_INFO)
4929	{
4930	tree t = build4 (code, type, arg0, arg1, arg2, arg3 PASS_MEM_STAT);
4931	if (CAN_HAVE_LOCATION_P (t))
4932	SET_EXPR_LOCATION (t, loc);
4933	return t;
4934	}
4935
4936	inline tree
4937	build5_loc (location_t loc, enum tree_code code, tree type, tree arg0,
4938	tree arg1, tree arg2, tree arg3, tree arg4 CXX_MEM_STAT_INFO)
4939	{
4940	tree t = build5 (code, type, arg0, arg1, arg2, arg3,
4941	arg4 PASS_MEM_STAT);
4942	if (CAN_HAVE_LOCATION_P (t))
4943	SET_EXPR_LOCATION (t, loc);
4944	return t;
4945	}
4946
4947	/* Constructs double_int from tree CST. */
4948
4949	extern tree double_int_to_tree (tree, double_int);
4950
4951	extern tree wide_int_to_tree (tree type, const poly_wide_int_ref &cst);
4952	extern tree force_fit_type (tree, const poly_wide_int_ref &, int, bool);
4953
4954	/* Create an INT_CST node with a CST value zero extended. */
4955
4956	/* static inline */
4957	extern tree build_int_cst (tree, poly_int64);
4958	extern tree build_int_cstu (tree type, poly_uint64);
4959	extern tree build_int_cst_type (tree, poly_int64);
4960	extern tree make_vector (unsigned, unsigned CXX_MEM_STAT_INFO);
4961	extern tree build_vector_from_ctor (tree, const vec<constructor_elt, va_gc> *);
4962	extern tree build_vector_from_val (tree, tree);
4963	extern tree build_uniform_cst (tree, tree);
4964	extern tree build_vec_series (tree, tree, tree);
4965	extern tree build_index_vector (tree, poly_uint64, poly_uint64);
4966	extern tree build_vector_a_then_b (tree, unsigned int, tree, tree);
4967	extern void recompute_constructor_flags (tree);
4968	extern void verify_constructor_flags (tree);
4969	extern tree build_constructor (tree, vec<constructor_elt, va_gc> * CXX_MEM_STAT_INFO);
4970	extern tree build_constructor_single (tree, tree, tree);
4971	extern tree build_constructor_from_list (tree, tree);
4972	extern tree build_constructor_from_vec (tree, const vec<tree, va_gc> *);
4973	extern tree build_constructor_va (tree, int, ...);
4974	extern tree build_clobber (tree, enum clobber_kind = CLOBBER_UNDEF);
4975	extern tree build_real_from_int_cst (tree, const_tree);
4976	extern tree build_real_from_wide (tree, const wide_int_ref &, signop);
4977	extern tree build_complex (tree, tree, tree);
4978	extern tree build_complex_inf (tree, bool);
4979	extern tree build_each_one_cst (tree);
4980	extern tree build_one_cst (tree);
4981	extern tree build_minus_one_cst (tree);
4982	extern tree build_all_ones_cst (tree);
4983	extern tree build_zero_cst (tree);
4984	extern tree build_replicated_int_cst (tree, unsigned, HOST_WIDE_INT);
4985	extern tree sign_mask_for (tree);
4986	extern tree build_string (unsigned, const char * = NULL);
4987	extern tree build_poly_int_cst (tree, const poly_wide_int_ref &);
4988	extern tree build_tree_list (tree, tree CXX_MEM_STAT_INFO);
4989	extern tree build_tree_list_vec (const vec<tree, va_gc> * CXX_MEM_STAT_INFO);
4990	extern tree build_decl (location_t, enum tree_code,
4991	tree, tree CXX_MEM_STAT_INFO);
4992	extern tree build_debug_expr_decl (tree type);
4993	extern tree build_fn_decl (const char *, tree);
4994	extern tree build_translation_unit_decl (tree);
4995	extern tree build_block (tree, tree, tree, tree);
4996	extern tree build_empty_stmt (location_t);
4997	extern tree build_omp_clause (location_t, enum omp_clause_code);
4998
4999	extern tree build_vl_exp (enum tree_code, int CXX_MEM_STAT_INFO);
5000
5001	extern tree build_call_valist (tree, tree, int, va_list);
5002	extern tree build_call (tree, tree, std::initializer_list<tree>);
5003
5004
5005	/* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
5006	FN and a null static chain slot. NARGS is the number of call arguments
5007	which are specified as "..." arguments. */
5008
5009	template <typename ...T>
5010	inline tree build_call_nary (tree return_type, tree fn, int nargs, T... args)
5011	{
5012	std::initializer_list<tree> args_ = {args...};
5013	gcc_checking_assert (sizeof...(args) == nargs);
5014	return build_call (return_type, fn, args_);
5015	}
5016	#define build_call_array(T1,T2,N,T3)\
5017	build_call_array_loc (UNKNOWN_LOCATION, T1, T2, N, T3)
5018	extern tree build_call_array_loc (location_t, tree, tree, int, const tree *);
5019	extern tree build_call_vec (tree, tree, const vec<tree, va_gc> *);
5020	extern tree build_call_expr_loc_array (location_t, tree, int, tree *);
5021	extern tree build_call_expr_loc_vec (location_t, tree, vec<tree, va_gc> *);
5022	extern tree build_call_expr_loc (location_t, tree, int, ...);
5023	extern tree build_call_expr (tree, int, ...);
5024	extern tree build_call_expr_internal_loc (location_t, enum internal_fn,
5025	tree, int, ...);
5026	extern tree build_call_expr_internal_loc_array (location_t, enum internal_fn,
5027	tree, int, const tree *);
5028	extern tree maybe_build_call_expr_loc (location_t, combined_fn, tree,
5029	int, ...);
5030	extern tree build_alloca_call_expr (tree, unsigned int, HOST_WIDE_INT);
5031	extern tree build_string_literal (unsigned, const char * = NULL,
5032	tree = char_type_node,
5033	unsigned HOST_WIDE_INT = HOST_WIDE_INT_M1U);
5034	inline tree build_string_literal (const char *p)
5035	{ return build_string_literal (strlen (s: p) + 1, p); }
5036	inline tree build_string_literal (tree t)
5037	{
5038	return build_string_literal (IDENTIFIER_LENGTH (t) + 1,
5039	IDENTIFIER_POINTER (t));
5040	}
5041
5042	/* Construct various nodes representing data types. */
5043
5044	extern tree signed_or_unsigned_type_for (int, tree);
5045	extern tree signed_type_for (tree);
5046	extern tree unsigned_type_for (tree);
5047	extern bool is_truth_type_for (tree, tree);
5048	extern bool tree_zero_one_valued_p (tree);
5049	extern tree truth_type_for (tree);
5050	extern tree build_pointer_type_for_mode (tree, machine_mode, bool);
5051	extern tree build_pointer_type (tree);
5052	extern tree build_reference_type_for_mode (tree, machine_mode, bool);
5053	extern tree build_reference_type (tree);
5054	extern tree build_vector_type_for_mode (tree, machine_mode);
5055	extern tree build_vector_type (tree, poly_int64);
5056	extern tree build_truth_vector_type_for_mode (poly_uint64, machine_mode);
5057	extern tree build_opaque_vector_type (tree, poly_int64);
5058	extern tree build_index_type (tree);
5059	extern tree build_array_type_1 (tree, tree, bool, bool, bool);
5060	extern tree build_array_type (tree, tree, bool = false);
5061	extern tree build_nonshared_array_type (tree, tree);
5062	extern tree build_array_type_nelts (tree, poly_uint64);
5063	extern tree build_function_type (tree, tree, bool = false);
5064	extern tree build_function_type_list (tree, ...);
5065	extern tree build_varargs_function_type_list (tree, ...);
5066	extern tree build_function_type_array (tree, int, tree *);
5067	extern tree build_varargs_function_type_array (tree, int, tree *);
5068	#define build_function_type_vec(RET, V) \
5069	build_function_type_array (RET, vec_safe_length (V), vec_safe_address (V))
5070	#define build_varargs_function_type_vec(RET, V) \
5071	build_varargs_function_type_array (RET, vec_safe_length (V), \
5072	vec_safe_address (V))
5073	extern tree build_method_type_directly (tree, tree, tree);
5074	extern tree build_method_type (tree, tree);
5075	extern tree build_offset_type (tree, tree);
5076	extern tree build_complex_type (tree, bool named = false);
5077	extern tree array_type_nelts_minus_one (const_tree);
5078	extern tree array_type_nelts_top (tree);
5079
5080	extern tree value_member (tree, tree);
5081	extern tree purpose_member (const_tree, tree);
5082	extern bool vec_member (const_tree, vec<tree, va_gc> *);
5083	extern tree chain_index (int, tree);
5084
5085	/* Arguments may be null. */
5086	extern bool tree_int_cst_equal (const_tree, const_tree);
5087
5088	/* The following predicates are safe to call with a null argument. */
5089	extern bool tree_fits_shwi_p (const_tree) ATTRIBUTE_PURE;
5090	extern bool tree_fits_poly_int64_p (const_tree) ATTRIBUTE_PURE;
5091	extern bool tree_fits_uhwi_p (const_tree) ATTRIBUTE_PURE;
5092	extern bool tree_fits_poly_uint64_p (const_tree) ATTRIBUTE_PURE;
5093	extern bool tree_fits_sanitize_code_type_p (const_tree) ATTRIBUTE_PURE;
5094
5095
5096	extern HOST_WIDE_INT tree_to_shwi (const_tree)
5097	ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5098	extern poly_int64 tree_to_poly_int64 (const_tree)
5099	ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5100	extern unsigned HOST_WIDE_INT tree_to_uhwi (const_tree)
5101	ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5102	extern poly_uint64 tree_to_poly_uint64 (const_tree)
5103	ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5104	extern sanitize_code_type tree_to_sanitize_code_type (const_tree)
5105	ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
5106	#if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003)
5107	extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT
5108	tree_to_shwi (const_tree t)
5109	{
5110	gcc_assert (tree_fits_shwi_p (t));
5111	return TREE_INT_CST_LOW (t);
5112	}
5113
5114	extern inline __attribute__ ((__gnu_inline__)) unsigned HOST_WIDE_INT
5115	tree_to_uhwi (const_tree t)
5116	{
5117	gcc_assert (tree_fits_uhwi_p (t));
5118	return TREE_INT_CST_LOW (t);
5119	}
5120	#if NUM_POLY_INT_COEFFS == 1
5121	extern inline __attribute__ ((__gnu_inline__)) poly_int64
5122	tree_to_poly_int64 (const_tree t)
5123	{
5124	gcc_assert (tree_fits_poly_int64_p (t));
5125	return TREE_INT_CST_LOW (t);
5126	}
5127
5128	extern inline __attribute__ ((__gnu_inline__)) poly_uint64
5129	tree_to_poly_uint64 (const_tree t)
5130	{
5131	gcc_assert (tree_fits_poly_uint64_p (t));
5132	return TREE_INT_CST_LOW (t);
5133	}
5134	#endif
5135	#endif
5136	extern int tree_int_cst_sgn (const_tree);
5137	extern int tree_int_cst_sign_bit (const_tree);
5138	extern unsigned int tree_int_cst_min_precision (tree, signop);
5139	extern tree excess_precision_type (tree);
5140
5141	/* Recursively examines the array elements of TYPE, until a non-array
5142	element type is found. */
5143
5144	inline tree
5145	strip_array_types (tree type)
5146	{
5147	while (TREE_CODE (type) == ARRAY_TYPE)
5148	type = TREE_TYPE (type);
5149
5150	return type;
5151	}
5152
5153	/* Recursively traverse down pointer type layers to pointee type. */
5154
5155	inline const_tree
5156	strip_pointer_types (const_tree type)
5157	{
5158	while (POINTER_TYPE_P (type))
5159	type = TREE_TYPE (type);
5160
5161	return type;
5162	}
5163
5164	/* Desription of the reason why the argument of valid_constant_size_p
5165	is not a valid size. */
5166	enum cst_size_error {
5167	cst_size_ok,
5168	cst_size_not_constant,
5169	cst_size_negative,
5170	cst_size_too_big,
5171	cst_size_overflow
5172	};
5173
5174	extern bool valid_constant_size_p (const_tree, cst_size_error * = NULL);
5175	extern tree max_object_size ();
5176
5177	/* Return true if T holds a value that can be represented as a poly_int64
5178	without loss of precision. Store the value in *VALUE if so. */
5179
5180	inline bool
5181	poly_int_tree_p (const_tree t, poly_int64 *value)
5182	{
5183	if (tree_fits_poly_int64_p (t))
5184	{
5185	*value = tree_to_poly_int64 (t);
5186	return true;
5187	}
5188	return false;
5189	}
5190
5191	/* Return true if T holds a value that can be represented as a poly_uint64
5192	without loss of precision. Store the value in *VALUE if so. */
5193
5194	inline bool
5195	poly_int_tree_p (const_tree t, poly_uint64 *value)
5196	{
5197	if (tree_fits_poly_uint64_p (t))
5198	{
5199	*value = tree_to_poly_uint64 (t);
5200	return true;
5201	}
5202	return false;
5203	}
5204
5205	/* From expmed.cc. Since rtl.h is included after tree.h, we can't
5206	put the prototype here. Rtl.h does declare the prototype if
5207	tree.h had been included. */
5208
5209	extern tree make_tree (tree, rtx);
5210
5211	/* Returns true iff CAND and BASE have equivalent language-specific
5212	qualifiers. */
5213
5214	extern bool check_lang_type (const_tree cand, const_tree base);
5215
5216	/* Returns true iff unqualified CAND and BASE are equivalent. */
5217
5218	extern bool check_base_type (const_tree cand, const_tree base);
5219
5220	/* Check whether CAND is suitable to be returned from get_qualified_type
5221	(BASE, TYPE_QUALS). */
5222
5223	extern bool check_qualified_type (const_tree, const_tree, int);
5224
5225	/* Return a version of the TYPE, qualified as indicated by the
5226	TYPE_QUALS, if one exists. If no qualified version exists yet,
5227	return NULL_TREE. */
5228
5229	extern tree get_qualified_type (tree, int);
5230
5231	/* Like get_qualified_type, but creates the type if it does not
5232	exist. This function never returns NULL_TREE. */
5233
5234	extern tree build_qualified_type (tree, int CXX_MEM_STAT_INFO);
5235
5236	/* Create a variant of type T with alignment ALIGN. */
5237
5238	extern tree build_aligned_type (tree, unsigned int);
5239
5240	/* Like build_qualified_type, but only deals with the `const' and
5241	`volatile' qualifiers. This interface is retained for backwards
5242	compatibility with the various front-ends; new code should use
5243	build_qualified_type instead. */
5244
5245	#define build_type_variant(TYPE, CONST_P, VOLATILE_P) \
5246	build_qualified_type ((TYPE), \
5247	((CONST_P) ? TYPE_QUAL_CONST : 0) \
5248	| ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
5249
5250	/* Make a copy of a type node. */
5251
5252	extern tree build_distinct_type_copy (tree CXX_MEM_STAT_INFO);
5253	extern tree build_variant_type_copy (tree CXX_MEM_STAT_INFO);
5254
5255	/* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
5256	return a canonicalized ..._TYPE node, so that duplicates are not made.
5257	How the hash code is computed is up to the caller, as long as any two
5258	callers that could hash identical-looking type nodes agree. */
5259
5260	extern hashval_t type_hash_canon_hash (tree);
5261	extern tree type_hash_canon (unsigned int, tree);
5262
5263	extern tree convert (tree, tree);
5264	extern tree size_in_bytes_loc (location_t, const_tree);
5265	inline tree
5266	size_in_bytes (const_tree t)
5267	{
5268	return size_in_bytes_loc (input_location, t);
5269	}
5270
5271	extern HOST_WIDE_INT int_size_in_bytes (const_tree);
5272	extern HOST_WIDE_INT max_int_size_in_bytes (const_tree);
5273	extern tree bit_position (const_tree);
5274	extern tree byte_position (const_tree);
5275	extern HOST_WIDE_INT int_byte_position (const_tree);
5276
5277	/* Type for sizes of data-type. */
5278
5279	#define sizetype sizetype_tab[(int) stk_sizetype]
5280	#define bitsizetype sizetype_tab[(int) stk_bitsizetype]
5281	#define ssizetype sizetype_tab[(int) stk_ssizetype]
5282	#define sbitsizetype sizetype_tab[(int) stk_sbitsizetype]
5283	#define size_int(L) size_int_kind (L, stk_sizetype)
5284	#define ssize_int(L) size_int_kind (L, stk_ssizetype)
5285	#define bitsize_int(L) size_int_kind (L, stk_bitsizetype)
5286	#define sbitsize_int(L) size_int_kind (L, stk_sbitsizetype)
5287
5288	/* Log2 of BITS_PER_UNIT. */
5289
5290	#if BITS_PER_UNIT == 8
5291	#define LOG2_BITS_PER_UNIT 3
5292	#elif BITS_PER_UNIT == 16
5293	#define LOG2_BITS_PER_UNIT 4
5294	#else
5295	#error Unknown BITS_PER_UNIT
5296	#endif
5297
5298	/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
5299	by making the last node in X point to Y.
5300	Returns X, except if X is 0 returns Y. */
5301
5302	extern tree chainon (tree, tree);
5303
5304	/* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN. */
5305
5306	extern tree tree_cons (tree, tree, tree CXX_MEM_STAT_INFO);
5307
5308	/* Return the last tree node in a chain. */
5309
5310	extern tree tree_last (tree);
5311
5312	/* Reverse the order of elements in a chain, and return the new head. */
5313
5314	extern tree nreverse (tree);
5315
5316	/* Returns the length of a chain of nodes
5317	(number of chain pointers to follow before reaching a null pointer). */
5318
5319	extern int list_length (const_tree);
5320
5321	/* Returns the first/last FIELD_DECL in a RECORD_TYPE. */
5322
5323	extern tree first_field (const_tree) ATTRIBUTE_NONNULL (1);
5324	extern tree last_field (const_tree) ATTRIBUTE_NONNULL (1);
5325
5326	/* Given an initializer INIT, return TRUE if INIT is zero or some
5327	aggregate of zeros. Otherwise return FALSE. If NONZERO is not
5328	null, set *NONZERO if and only if INIT is known not to be all
5329	zeros. The combination of return value of false and *NONZERO
5330	false implies that INIT may but need not be all zeros. Other
5331	combinations indicate definitive answers. */
5332
5333	extern bool initializer_zerop (const_tree, bool * = NULL);
5334	extern bool initializer_each_zero_or_onep (const_tree);
5335
5336	extern tree vector_cst_elt (const_tree, unsigned int);
5337
5338	/* Given a vector VEC, return its first element if all elements are
5339	the same. Otherwise return NULL_TREE. */
5340
5341	extern tree uniform_vector_p (const_tree);
5342
5343	/* Same as above, but if VEC is an SSA_NAME, inspect its definition. */
5344
5345	extern tree ssa_uniform_vector_p (tree);
5346
5347	/* If the argument is INTEGER_CST, return it. If the argument is vector
5348	with all elements the same INTEGER_CST, return that INTEGER_CST. Otherwise
5349	return NULL_TREE. */
5350
5351	extern tree uniform_integer_cst_p (tree);
5352
5353	extern int single_nonzero_element (const_tree);
5354
5355	/* Given a CONSTRUCTOR CTOR, return the element values as a vector. */
5356
5357	extern vec<tree, va_gc> *ctor_to_vec (tree);
5358
5359	/* zerop (tree x) is nonzero if X is a constant of value 0. */
5360
5361	extern bool zerop (const_tree);
5362
5363	/* integer_zerop (tree x) is nonzero if X is an integer constant of value 0. */
5364
5365	extern bool integer_zerop (const_tree);
5366
5367	/* integer_onep (tree x) is nonzero if X is an integer constant of value 1. */
5368
5369	extern bool integer_onep (const_tree);
5370
5371	/* integer_onep (tree x) is nonzero if X is an integer constant of value 1, or
5372	a vector or complex where each part is 1. */
5373
5374	extern bool integer_each_onep (const_tree);
5375
5376	/* integer_all_onesp (tree x) is nonzero if X is an integer constant
5377	all of whose significant bits are 1. */
5378
5379	extern bool integer_all_onesp (const_tree);
5380
5381	/* integer_minus_onep (tree x) is nonzero if X is an integer constant of
5382	value -1. */
5383
5384	extern bool integer_minus_onep (const_tree);
5385
5386	/* integer_pow2p (tree x) is nonzero is X is an integer constant with
5387	exactly one bit 1. */
5388
5389	extern bool integer_pow2p (const_tree);
5390
5391	/* Checks to see if T is a constant or a constant vector and if each element E
5392	adheres to ~E + 1 == pow2 then return ~E otherwise NULL_TREE. */
5393
5394	extern tree bitmask_inv_cst_vector_p (tree);
5395
5396	/* integer_nonzerop (tree x) is nonzero if X is an integer constant
5397	with a nonzero value. */
5398
5399	extern bool integer_nonzerop (const_tree);
5400
5401	/* integer_truep (tree x) is nonzero if X is an integer constant of value 1 or
5402	a vector where each element is an integer constant of value -1. */
5403
5404	extern bool integer_truep (const_tree);
5405
5406	extern bool cst_and_fits_in_hwi (const_tree);
5407	extern tree num_ending_zeros (const_tree);
5408
5409	/* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of
5410	value 0. */
5411
5412	extern bool fixed_zerop (const_tree);
5413
5414	/* staticp (tree x) is nonzero if X is a reference to data allocated
5415	at a fixed address in memory. Returns the outermost data. */
5416
5417	extern tree staticp (tree);
5418
5419	/* save_expr (EXP) returns an expression equivalent to EXP
5420	but it can be used multiple times within context CTX
5421	and only evaluate EXP once. */
5422
5423	extern tree save_expr (tree);
5424
5425	/* Return true if T is an object with invariant address. */
5426
5427	extern bool address_invariant_p (tree);
5428
5429	/* Return true if T is function-invariant. */
5430
5431	extern bool tree_invariant_p (tree);
5432
5433	/* Look inside EXPR into any simple arithmetic operations. Return the
5434	outermost non-arithmetic or non-invariant node. */
5435
5436	extern tree skip_simple_arithmetic (tree);
5437
5438	/* Look inside EXPR into simple arithmetic operations involving constants.
5439	Return the outermost non-arithmetic or non-constant node. */
5440
5441	extern tree skip_simple_constant_arithmetic (tree);
5442
5443	/* Return which tree structure is used by T. */
5444
5445	enum tree_node_structure_enum tree_node_structure (const_tree);
5446
5447	/* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
5448	size or offset that depends on a field within a record. */
5449
5450	extern bool contains_placeholder_p (const_tree);
5451
5452	/* This macro calls the above function but short-circuits the common
5453	case of a constant to save time. Also check for null. */
5454
5455	#define CONTAINS_PLACEHOLDER_P(EXP) \
5456	((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
5457
5458	/* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
5459	directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
5460	field positions. */
5461
5462	extern bool type_contains_placeholder_p (tree);
5463
5464	/* Given a tree EXP, find all occurrences of references to fields
5465	in a PLACEHOLDER_EXPR and place them in vector REFS without
5466	duplicates. Also record VAR_DECLs and CONST_DECLs. Note that
5467	we assume here that EXP contains only arithmetic expressions
5468	or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
5469	argument list. */
5470
5471	extern void find_placeholder_in_expr (tree, vec<tree> *);
5472
5473	/* This macro calls the above function but short-circuits the common
5474	case of a constant to save time and also checks for NULL. */
5475
5476	#define FIND_PLACEHOLDER_IN_EXPR(EXP, V) \
5477	do { \
5478	if((EXP) && !TREE_CONSTANT (EXP)) \
5479	find_placeholder_in_expr (EXP, V); \
5480	} while (0)
5481
5482	/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
5483	return a tree with all occurrences of references to F in a
5484	PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
5485	CONST_DECLs. Note that we assume here that EXP contains only
5486	arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
5487	occurring only in their argument list. */
5488
5489	extern tree substitute_in_expr (tree, tree, tree);
5490
5491	/* This macro calls the above function but short-circuits the common
5492	case of a constant to save time and also checks for NULL. */
5493
5494	#define SUBSTITUTE_IN_EXPR(EXP, F, R) \
5495	((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
5496
5497	/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
5498	for it within OBJ, a tree that is an object or a chain of references. */
5499
5500	extern tree substitute_placeholder_in_expr (tree, tree);
5501
5502	/* This macro calls the above function but short-circuits the common
5503	case of a constant to save time and also checks for NULL. */
5504
5505	#define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
5506	((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) \
5507	: substitute_placeholder_in_expr (EXP, OBJ))
5508
5509
5510	/* stabilize_reference (EXP) returns a reference equivalent to EXP
5511	but it can be used multiple times
5512	and only evaluate the subexpressions once. */
5513
5514	extern tree stabilize_reference (tree);
5515
5516	/* Return EXP, stripped of any conversions to wider types
5517	in such a way that the result of converting to type FOR_TYPE
5518	is the same as if EXP were converted to FOR_TYPE.
5519	If FOR_TYPE is 0, it signifies EXP's type. */
5520
5521	extern tree get_unwidened (tree, tree);
5522
5523	/* Return OP or a simpler expression for a narrower value
5524	which can be sign-extended or zero-extended to give back OP.
5525	Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
5526	or 0 if the value should be sign-extended. */
5527
5528	extern tree get_narrower (tree, int *);
5529
5530	/* Return true if T is an expression that get_inner_reference handles. */
5531
5532	inline bool
5533	handled_component_p (const_tree t)
5534	{
5535	switch (TREE_CODE (t))
5536	{
5537	case COMPONENT_REF:
5538	case BIT_FIELD_REF:
5539	case ARRAY_REF:
5540	case ARRAY_RANGE_REF:
5541	case REALPART_EXPR:
5542	case IMAGPART_EXPR:
5543	case VIEW_CONVERT_EXPR:
5544	return true;
5545
5546	default:
5547	return false;
5548	}
5549	}
5550
5551	/* Return true T is a component with reverse storage order. */
5552
5553	inline bool
5554	reverse_storage_order_for_component_p (tree t)
5555	{
5556	/* The storage order only applies to scalar components. */
5557	if (AGGREGATE_TYPE_P (TREE_TYPE (t))
5558	|| POINTER_TYPE_P (TREE_TYPE (t))
5559	|| VECTOR_TYPE_P (TREE_TYPE (t)))
5560	return false;
5561
5562	if (TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR)
5563	t = TREE_OPERAND (t, 0);
5564
5565	switch (TREE_CODE (t))
5566	{
5567	case ARRAY_REF:
5568	case COMPONENT_REF:
5569	/* ??? Fortran can take COMPONENT_REF of a VOID_TYPE. */
5570	/* ??? UBSan can take COMPONENT_REF of a REFERENCE_TYPE. */
5571	return AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0)))
5572	&& TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (TREE_OPERAND (t, 0)));
5573
5574	case BIT_FIELD_REF:
5575	case MEM_REF:
5576	return REF_REVERSE_STORAGE_ORDER (t);
5577
5578	case ARRAY_RANGE_REF:
5579	case VIEW_CONVERT_EXPR:
5580	default:
5581	return false;
5582	}
5583	}
5584
5585	/* Return true if T is a storage order barrier, i.e. a VIEW_CONVERT_EXPR
5586	that can modify the storage order of objects. Note that, even if the
5587	TYPE_REVERSE_STORAGE_ORDER flag is set on both the inner type and the
5588	outer type, a VIEW_CONVERT_EXPR can modify the storage order because
5589	it can change the partition of the aggregate object into scalars. */
5590
5591	inline bool
5592	storage_order_barrier_p (const_tree t)
5593	{
5594	if (TREE_CODE (t) != VIEW_CONVERT_EXPR)
5595	return false;
5596
5597	if (AGGREGATE_TYPE_P (TREE_TYPE (t))
5598	&& TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (t)))
5599	return true;
5600
5601	tree op = TREE_OPERAND (t, 0);
5602
5603	if (AGGREGATE_TYPE_P (TREE_TYPE (op))
5604	&& TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (op)))
5605	return true;
5606
5607	return reverse_storage_order_for_component_p (t: op);
5608	}
5609
5610	/* Given a DECL or TYPE, return the scope in which it was declared, or
5611	NUL_TREE if there is no containing scope. */
5612
5613	extern tree get_containing_scope (const_tree);
5614
5615	/* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
5616
5617	extern const_tree get_ultimate_context (const_tree);
5618
5619	/* Return the FUNCTION_DECL which provides this _DECL with its context,
5620	or zero if none. */
5621	extern tree decl_function_context (const_tree);
5622
5623	/* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
5624	this _DECL with its context, or zero if none. */
5625	extern tree decl_type_context (const_tree);
5626
5627	/* Return true if EXPR is the real constant zero. */
5628	extern bool real_zerop (const_tree);
5629
5630	/* Initialize the iterator I with arguments from function FNDECL */
5631
5632	inline void
5633	function_args_iter_init (function_args_iterator *i, const_tree fntype)
5634	{
5635	i->next = TYPE_ARG_TYPES (fntype);
5636	}
5637
5638	/* Return a pointer that holds the next argument if there are more arguments to
5639	handle, otherwise return NULL. */
5640
5641	inline tree *
5642	function_args_iter_cond_ptr (function_args_iterator *i)
5643	{
5644	return (i->next) ? &TREE_VALUE (i->next) : NULL;
5645	}
5646
5647	/* Return the next argument if there are more arguments to handle, otherwise
5648	return NULL. */
5649
5650	inline tree
5651	function_args_iter_cond (function_args_iterator *i)
5652	{
5653	return (i->next) ? TREE_VALUE (i->next) : NULL_TREE;
5654	}
5655
5656	/* Advance to the next argument. */
5657	inline void
5658	function_args_iter_next (function_args_iterator *i)
5659	{
5660	gcc_assert (i->next != NULL_TREE);
5661	i->next = TREE_CHAIN (i->next);
5662	}
5663
5664	/* Returns true if a BLOCK has a source location.
5665	BLOCK_SOURCE_LOCATION is set only to inlined function entry points,
5666	so the function returns true for all but the innermost and outermost
5667	blocks into which an expression has been inlined. */
5668
5669	inline bool
5670	inlined_function_outer_scope_p (const_tree block)
5671	{
5672	return LOCATION_LOCUS (BLOCK_SOURCE_LOCATION (block)) != UNKNOWN_LOCATION;
5673	}
5674
5675	/* Loop over all function arguments of FNTYPE. In each iteration, PTR is set
5676	to point to the next tree element. ITER is an instance of
5677	function_args_iterator used to iterate the arguments. */
5678	#define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER) \
5679	for (function_args_iter_init (&(ITER), (FNTYPE)); \
5680	(PTR = function_args_iter_cond_ptr (&(ITER))) != NULL; \
5681	function_args_iter_next (&(ITER)))
5682
5683	/* Loop over all function arguments of FNTYPE. In each iteration, TREE is set
5684	to the next tree element. ITER is an instance of function_args_iterator
5685	used to iterate the arguments. */
5686	#define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER) \
5687	for (function_args_iter_init (&(ITER), (FNTYPE)); \
5688	(TREE = function_args_iter_cond (&(ITER))) != NULL_TREE; \
5689	function_args_iter_next (&(ITER)))
5690
5691	/* In tree.cc */
5692	extern unsigned crc32_unsigned_n (unsigned, unsigned, unsigned);
5693	extern unsigned crc32_string (unsigned, const char *);
5694	inline unsigned
5695	crc32_unsigned (unsigned chksum, unsigned value)
5696	{
5697	return crc32_unsigned_n (chksum, value, 4);
5698	}
5699	inline unsigned
5700	crc32_byte (unsigned chksum, char byte)
5701	{
5702	return crc32_unsigned_n (chksum, byte, 1);
5703	}
5704	extern void clean_symbol_name (char *);
5705	extern tree get_file_function_name (const char *);
5706	extern tree get_callee_fndecl (const_tree);
5707	extern combined_fn get_call_combined_fn (const_tree);
5708	extern int type_num_arguments (const_tree);
5709	extern tree type_argument_type (const_tree, unsigned) ATTRIBUTE_NONNULL (1);
5710	extern bool associative_tree_code (enum tree_code);
5711	extern bool commutative_tree_code (enum tree_code);
5712	extern bool commutative_ternary_tree_code (enum tree_code);
5713	extern bool operation_can_overflow (enum tree_code);
5714	extern bool operation_no_trapping_overflow (tree, enum tree_code);
5715	extern tree upper_bound_in_type (tree, tree);
5716	extern tree lower_bound_in_type (tree, tree);
5717	extern bool operand_equal_for_phi_arg_p (const_tree, const_tree);
5718	extern tree create_artificial_label (location_t);
5719	extern const char *get_name (tree);
5720	extern bool stdarg_p (const_tree);
5721	extern bool prototype_p (const_tree);
5722	extern bool auto_var_p (const_tree);
5723	extern bool auto_var_in_fn_p (const_tree, const_tree);
5724	extern tree build_low_bits_mask (tree, unsigned);
5725	extern bool tree_nop_conversion_p (const_tree, const_tree);
5726	extern tree tree_strip_nop_conversions (tree);
5727	extern tree tree_strip_sign_nop_conversions (tree);
5728	extern const_tree strip_invariant_refs (const_tree);
5729	extern tree strip_zero_offset_components (tree);
5730	extern tree lhd_gcc_personality (void);
5731	extern void assign_assembler_name_if_needed (tree);
5732	extern bool warn_deprecated_use (tree, tree);
5733	extern void error_unavailable_use (tree, tree);
5734	extern tree cache_integer_cst (tree, bool might_duplicate = false);
5735	extern const char *combined_fn_name (combined_fn);
5736
5737	/* Returns true if X is a typedef decl. */
5738
5739	inline bool
5740	is_typedef_decl (const_tree x)
5741	{
5742	return (x && TREE_CODE (x) == TYPE_DECL
5743	&& DECL_ORIGINAL_TYPE (x) != NULL_TREE);
5744	}
5745
5746	/* Returns true iff TYPE is a type variant created for a typedef. */
5747
5748	inline bool
5749	typedef_variant_p (const_tree type)
5750	{
5751	return is_typedef_decl (TYPE_NAME (type));
5752	}
5753
5754	/* Compare and hash for any structure which begins with a canonical
5755	pointer. Assumes all pointers are interchangeable, which is sort
5756	of already assumed by gcc elsewhere IIRC. */
5757
5758	inline int
5759	struct_ptr_eq (const void *a, const void *b)
5760	{
5761	const void * const * x = (const void * const *) a;
5762	const void * const * y = (const void * const *) b;
5763	return *x == *y;
5764	}
5765
5766	inline hashval_t
5767	struct_ptr_hash (const void *a)
5768	{
5769	const void * const * x = (const void * const *) a;
5770	return (intptr_t)*x >> 4;
5771	}
5772
5773	/* Return true if CODE can be treated as a truncating division.
5774
5775	EXACT_DIV_EXPR can be treated as a truncating division in which the
5776	remainder is known to be zero. However, if trunc_div_p gates the
5777	generation of new IL, the conservative choice for that new IL is
5778	TRUNC_DIV_EXPR rather than CODE. Using CODE (EXACT_DIV_EXPR) would
5779	only be correct if the transformation preserves exactness. */
5780	inline bool
5781	trunc_or_exact_div_p (tree_code code)
5782	{
5783	return code == TRUNC_DIV_EXPR || code == EXACT_DIV_EXPR;
5784	}
5785
5786	/* Return nonzero if CODE is a tree code that represents a truth value. */
5787	inline bool
5788	truth_value_p (enum tree_code code)
5789	{
5790	return (TREE_CODE_CLASS (code) == tcc_comparison
5791	|| code == TRUTH_AND_EXPR || code == TRUTH_ANDIF_EXPR
5792	|| code == TRUTH_OR_EXPR || code == TRUTH_ORIF_EXPR
5793	|| code == TRUTH_XOR_EXPR || code == TRUTH_NOT_EXPR);
5794	}
5795
5796	/* Return whether TYPE is a type suitable for an offset for
5797	a POINTER_PLUS_EXPR. */
5798	inline bool
5799	ptrofftype_p (tree type)
5800	{
5801	return (INTEGRAL_TYPE_P (type)
5802	&& TYPE_PRECISION (type) == TYPE_PRECISION (sizetype)
5803	&& TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
5804	}
5805
5806	/* Return true if the argument is a complete type or an array
5807	of unknown bound (whose type is incomplete but) whose elements
5808	have complete type. */
5809	inline bool
5810	complete_or_array_type_p (const_tree type)
5811	{
5812	return COMPLETE_TYPE_P (type)
5813	|| (TREE_CODE (type) == ARRAY_TYPE
5814	&& COMPLETE_TYPE_P (TREE_TYPE (type)));
5815	}
5816
5817	/* Return true if the value of T could be represented as a poly_widest_int. */
5818
5819	inline bool
5820	poly_int_tree_p (const_tree t)
5821	{
5822	return (TREE_CODE (t) == INTEGER_CST || POLY_INT_CST_P (t));
5823	}
5824
5825	/* Return the bit size of BIT_FIELD_REF T, in cases where it is known
5826	to be a poly_uint64. (This is always true at the gimple level.) */
5827
5828	inline poly_uint64
5829	bit_field_size (const_tree t)
5830	{
5831	return tree_to_poly_uint64 (TREE_OPERAND (t, 1));
5832	}
5833
5834	/* Return the starting bit offset of BIT_FIELD_REF T, in cases where it is
5835	known to be a poly_uint64. (This is always true at the gimple level.) */
5836
5837	inline poly_uint64
5838	bit_field_offset (const_tree t)
5839	{
5840	return tree_to_poly_uint64 (TREE_OPERAND (t, 2));
5841	}
5842
5843	extern tree strip_float_extensions (tree);
5844	extern bool really_constant_p (const_tree);
5845	extern bool ptrdiff_tree_p (const_tree, poly_int64 *);
5846	extern bool decl_address_invariant_p (const_tree);
5847	extern bool decl_address_ip_invariant_p (const_tree);
5848	extern bool int_fits_type_p (const_tree, const_tree)
5849	ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2) ATTRIBUTE_PURE;
5850	#ifndef GENERATOR_FILE
5851	extern void get_type_static_bounds (const_tree, mpz_t, mpz_t);
5852	#endif
5853	extern bool variably_modified_type_p (tree, tree);
5854	extern int tree_log2 (const_tree);
5855	extern int tree_floor_log2 (const_tree);
5856	extern unsigned int tree_ctz (const_tree);
5857	extern int simple_cst_equal (const_tree, const_tree);
5858
5859	namespace inchash
5860	{
5861
5862	extern void add_expr (const_tree, hash &, unsigned int = 0);
5863
5864	}
5865
5866	/* Compat version until all callers are converted. Return hash for
5867	TREE with SEED. */
5868	inline hashval_t iterative_hash_expr(const_tree tree, hashval_t seed)
5869	{
5870	inchash::hash hstate (seed);
5871	inchash::add_expr (tree, hstate);
5872	return hstate.end ();
5873	}
5874
5875	extern int compare_tree_int (const_tree, unsigned HOST_WIDE_INT);
5876	extern bool type_list_equal (const_tree, const_tree);
5877	extern bool chain_member (const_tree, const_tree);
5878	extern void dump_tree_statistics (void);
5879	extern void recompute_tree_invariant_for_addr_expr (tree);
5880	extern bool needs_to_live_in_memory (const_tree);
5881	extern tree reconstruct_complex_type (tree, tree);
5882	extern bool real_onep (const_tree);
5883	extern bool real_minus_onep (const_tree);
5884	extern bool real_maybe_zerop (const_tree);
5885	extern void init_ttree (void);
5886	extern void build_common_tree_nodes (bool);
5887	extern void build_common_builtin_nodes (void);
5888	extern void tree_cc_finalize (void);
5889	extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int);
5890	extern tree build_nonstandard_boolean_type (unsigned HOST_WIDE_INT);
5891	extern tree build_bitint_type (unsigned HOST_WIDE_INT, int);
5892	extern tree build_range_type (tree, tree, tree);
5893	extern tree build_nonshared_range_type (tree, tree, tree);
5894	extern bool subrange_type_for_debug_p (const_tree, tree *, tree *);
5895	extern HOST_WIDE_INT int_cst_value (const_tree);
5896	extern tree tree_block (tree);
5897	extern void tree_set_block (tree, tree);
5898	extern location_t *block_nonartificial_location (tree);
5899	extern location_t tree_nonartificial_location (tree);
5900	extern location_t tree_inlined_location (tree, bool = true);
5901	extern tree block_ultimate_origin (const_tree);
5902	extern tree get_binfo_at_offset (tree, poly_int64, tree);
5903	extern bool virtual_method_call_p (const_tree, bool = false);
5904	extern tree obj_type_ref_class (const_tree ref, bool = false);
5905	extern bool types_same_for_odr (const_tree type1, const_tree type2);
5906	extern bool contains_bitfld_component_ref_p (const_tree);
5907	extern bool block_may_fallthru (const_tree);
5908	extern void using_eh_for_cleanups (void);
5909	extern bool using_eh_for_cleanups_p (void);
5910	extern const char *get_tree_code_name (enum tree_code);
5911	extern void set_call_expr_flags (tree, int);
5912	extern tree walk_tree_1 (tree*, walk_tree_fn, void*, hash_set<tree>*,
5913	walk_tree_lh);
5914	extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*,
5915	walk_tree_lh);
5916	#define walk_tree(a,b,c,d) \
5917	walk_tree_1 (a, b, c, d, NULL)
5918	#define walk_tree_without_duplicates(a,b,c) \
5919	walk_tree_without_duplicates_1 (a, b, c, NULL)
5920
5921	extern tree drop_tree_overflow (tree);
5922
5923	/* Given a memory reference expression T, return its base address.
5924	The base address of a memory reference expression is the main
5925	object being referenced. */
5926	extern tree get_base_address (tree t);
5927
5928	/* Return a tree of sizetype representing the size, in bytes, of the element
5929	of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
5930	extern tree array_ref_element_size (tree);
5931
5932	/* Return a typenode for the "standard" C type with a given name. */
5933	extern tree get_typenode_from_name (const char *);
5934
5935	/* Return a tree representing the upper bound of the array mentioned in
5936	EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
5937	extern tree array_ref_up_bound (tree);
5938
5939	/* Return a tree representing the lower bound of the array mentioned in
5940	EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */
5941	extern tree array_ref_low_bound (tree);
5942
5943	/* Returns true if REF is an array reference, a component reference,
5944	or a memory reference to an array whose actual size might be larger
5945	than its upper bound implies. */
5946	extern bool array_ref_flexible_size_p (tree, bool * = NULL);
5947
5948	/* Return a tree representing the offset, in bytes, of the field referenced
5949	by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */
5950	extern tree component_ref_field_offset (tree);
5951
5952	/* Describes a "special" array member for a COMPONENT_REF. */
5953	enum struct special_array_member
5954	{
5955	none, /* Not a special array member. */
5956	int_0, /* Interior array member with zero elements. */
5957	trail_0, /* Trailing array member with zero elements. */
5958	trail_1, /* Trailing array member with one element. */
5959	trail_n, /* Trailing array member with two or more elements. */
5960	int_n /* Interior array member with one or more elements. */
5961	};
5962
5963	/* Determines the special array member type for a COMPONENT_REF. */
5964	extern special_array_member component_ref_sam_type (tree);
5965
5966	/* Return the size of the member referenced by the COMPONENT_REF, using
5967	its initializer expression if necessary in order to determine the size
5968	of an initialized flexible array member. The size might be zero for
5969	an object with an uninitialized flexible array member or null if it
5970	cannot be determined. */
5971	extern tree component_ref_size (tree, special_array_member * = NULL);
5972
5973	/* Return true if the given node is a call to a .ACCESS_WITH_SIZE
5974	function. */
5975	extern bool is_access_with_size_p (const_tree);
5976
5977	/* Get the corresponding reference from the call to a .ACCESS_WITH_SIZE,
5978	* i.e. the first argument of this call. Return NULL_TREE otherwise. */
5979	extern tree get_ref_from_access_with_size (tree);
5980
5981	extern int tree_map_base_eq (const void *, const void *);
5982	extern unsigned int tree_map_base_hash (const void *);
5983	extern bool tree_map_base_marked_p (const void *);
5984	extern void DEBUG_FUNCTION verify_type (const_tree t);
5985	extern bool gimple_canonical_types_compatible_p (const_tree, const_tree,
5986	bool trust_type_canonical = true);
5987	extern bool type_with_interoperable_signedness (const_tree);
5988	extern bitmap get_nonnull_args (const_tree);
5989	extern int get_range_pos_neg (tree, gimple * = NULL);
5990
5991	/* Return true for a valid pair of new and delete operators. */
5992	extern bool valid_new_delete_pair_p (tree, tree, bool * = NULL);
5993
5994	/* Return simplified tree code of type that is used for canonical type
5995	merging. */
5996	inline enum tree_code
5997	tree_code_for_canonical_type_merging (enum tree_code code)
5998	{
5999	/* By C standard, each enumerated type shall be compatible with char,
6000	a signed integer, or an unsigned integer. The choice of type is
6001	implementation defined (in our case it depends on -fshort-enum).
6002
6003	For this reason we make no distinction between ENUMERAL_TYPE and INTEGER
6004	type and compare only by their signedness and precision. */
6005	if (code == ENUMERAL_TYPE)
6006	return INTEGER_TYPE;
6007	/* To allow inter-operability between languages having references and
6008	C, we consider reference types and pointers alike. Note that this is
6009	not strictly necessary for C-Fortran 2008 interoperability because
6010	Fortran define C_PTR type that needs to be compatible with C pointers
6011	and we handle this one as ptr_type_node. */
6012	if (code == REFERENCE_TYPE)
6013	return POINTER_TYPE;
6014	return code;
6015	}
6016
6017	/* Return true if get_alias_set care about TYPE_CANONICAL of given type.
6018	We don't define the types for pointers, arrays and vectors. The reason is
6019	that pointers are handled specially: ptr_type_node accesses conflict with
6020	accesses to all other pointers. This is done by alias.cc.
6021	Because alias sets of arrays and vectors are the same as types of their
6022	elements, we can't compute canonical type either. Otherwise we could go
6023	form void *[10] to int *[10] (because they are equivalent for canonical type
6024	machinery) and get wrong TBAA. */
6025
6026	inline bool
6027	canonical_type_used_p (const_tree t)
6028	{
6029	return !(POINTER_TYPE_P (t)
6030	|| TREE_CODE (t) == ARRAY_TYPE
6031	|| TREE_CODE (t) == VECTOR_TYPE);
6032	}
6033
6034	/* Kinds of access to pass-by-reference arguments to functions. */
6035	enum access_mode
6036	{
6037	access_none = 0,
6038	access_read_only = 1,
6039	access_write_only = 2,
6040	access_read_write = access_read_only | access_write_only,
6041	access_deferred = 4
6042	};
6043
6044	#define tree_map_eq tree_map_base_eq
6045	extern unsigned int tree_map_hash (const void *);
6046	#define tree_map_marked_p tree_map_base_marked_p
6047
6048	#define tree_decl_map_eq tree_map_base_eq
6049	extern unsigned int tree_decl_map_hash (const void *);
6050	#define tree_decl_map_marked_p tree_map_base_marked_p
6051
6052	struct tree_decl_map_cache_hasher : ggc_cache_ptr_hash<tree_decl_map>
6053	{
6054	static hashval_t hash (tree_decl_map *m) { return tree_decl_map_hash (m); }
6055	static bool
6056	equal (tree_decl_map *a, tree_decl_map *b)
6057	{
6058	return tree_decl_map_eq (a, b);
6059	}
6060
6061	static int
6062	keep_cache_entry (tree_decl_map *&m)
6063	{
6064	return ggc_marked_p (m->base.from);
6065	}
6066	};
6067
6068	#define tree_int_map_eq tree_map_base_eq
6069	#define tree_int_map_hash tree_map_base_hash
6070	#define tree_int_map_marked_p tree_map_base_marked_p
6071
6072	#define tree_vec_map_eq tree_map_base_eq
6073	#define tree_vec_map_hash tree_decl_map_hash
6074	#define tree_vec_map_marked_p tree_map_base_marked_p
6075
6076	struct tree_vec_map_cache_hasher : ggc_cache_ptr_hash<tree_vec_map>
6077	{
6078	static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); }
6079
6080	static bool
6081	equal (tree_vec_map *a, tree_vec_map *b)
6082	{
6083	return a->base.from == b->base.from;
6084	}
6085
6086	static int
6087	keep_cache_entry (tree_vec_map *&m)
6088	{
6089	return ggc_marked_p (m->base.from);
6090	}
6091	};
6092
6093	/* Hasher for tree decls. Pointer equality is enough here, but the DECL_UID
6094	is a better hash than the pointer value and gives a predictable traversal
6095	order. Additionally it can be used across PCH save/restore. */
6096	struct tree_decl_hash : ggc_ptr_hash <tree_node>
6097	{
6098	static inline hashval_t hash (tree);
6099	};
6100
6101	inline hashval_t
6102	tree_decl_hash::hash (tree t)
6103	{
6104	return DECL_UID (t);
6105	}
6106
6107	/* Similarly for types. Uses TYPE_UID as hash function. */
6108	struct tree_type_hash : ggc_ptr_hash <tree_node>
6109	{
6110	static inline hashval_t hash (tree);
6111	};
6112
6113	inline hashval_t
6114	tree_type_hash::hash (tree t)
6115	{
6116	return TYPE_UID (t);
6117	}
6118
6119	/* Hash for SSA_NAMEs in the same function. Pointer equality is enough
6120	here, but the SSA_NAME_VERSION is a better hash than the pointer
6121	value and gives a predictable traversal order. */
6122	struct tree_ssa_name_hash : ggc_ptr_hash <tree_node>
6123	{
6124	static inline hashval_t hash (tree);
6125	};
6126
6127	inline hashval_t
6128	tree_ssa_name_hash::hash (tree t)
6129	{
6130	return SSA_NAME_VERSION (t);
6131	}
6132
6133	/* Hasher for general trees, based on their TREE_HASH. */
6134	struct tree_hash : ggc_ptr_hash <tree_node>
6135	{
6136	static hashval_t hash (tree);
6137	};
6138
6139	inline hashval_t
6140	tree_hash::hash (tree t)
6141	{
6142	return TREE_HASH (t);
6143	}
6144
6145	/* A hash_map of two trees for use with GTY((cache)). Garbage collection for
6146	such a map will not mark keys, and will mark values if the key is already
6147	marked. */
6148	struct tree_cache_traits
6149	: simple_cache_map_traits<default_hash_traits<tree>, tree> { };
6150	typedef hash_map<tree,tree,tree_cache_traits> tree_cache_map;
6151
6152	/* Similarly, but use DECL_UID as hash function rather than pointer hashing.
6153	This is for hash_maps from decls to trees that need to work across PCH. */
6154	struct decl_tree_cache_traits
6155	: simple_cache_map_traits<tree_decl_hash, tree> { };
6156	typedef hash_map<tree,tree,decl_tree_cache_traits> decl_tree_cache_map;
6157
6158	/* Similarly, but use TYPE_UID as hash function rather than pointer hashing.
6159	This is for hash_maps from types to trees that need to work across PCH. */
6160	struct type_tree_cache_traits
6161	: simple_cache_map_traits<tree_type_hash, tree> { };
6162	typedef hash_map<tree,tree,type_tree_cache_traits> type_tree_cache_map;
6163
6164	/* Similarly to decl_tree_cache_map, but without caching. */
6165	struct decl_tree_traits
6166	: simple_hashmap_traits<tree_decl_hash, tree> { };
6167	typedef hash_map<tree,tree,decl_tree_traits> decl_tree_map;
6168
6169	/* Initialize the abstract argument list iterator object ITER with the
6170	arguments from CALL_EXPR node EXP. */
6171	inline void
6172	init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter)
6173	{
6174	iter->t = exp;
6175	iter->n = call_expr_nargs (exp);
6176	iter->i = 0;
6177	}
6178
6179	inline void
6180	init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter)
6181	{
6182	iter->t = exp;
6183	iter->n = call_expr_nargs (exp);
6184	iter->i = 0;
6185	}
6186
6187	/* Return the next argument from abstract argument list iterator object ITER,
6188	and advance its state. Return NULL_TREE if there are no more arguments. */
6189	inline tree
6190	next_call_expr_arg (call_expr_arg_iterator *iter)
6191	{
6192	tree result;
6193	if (iter->i >= iter->n)
6194	return NULL_TREE;
6195	result = CALL_EXPR_ARG (iter->t, iter->i);
6196	iter->i++;
6197	return result;
6198	}
6199
6200	inline const_tree
6201	next_const_call_expr_arg (const_call_expr_arg_iterator *iter)
6202	{
6203	const_tree result;
6204	if (iter->i >= iter->n)
6205	return NULL_TREE;
6206	result = CALL_EXPR_ARG (iter->t, iter->i);
6207	iter->i++;
6208	return result;
6209	}
6210
6211	/* Initialize the abstract argument list iterator object ITER, then advance
6212	past and return the first argument. Useful in for expressions, e.g.
6213	for (arg = first_call_expr_arg (exp, &iter); arg;
6214	arg = next_call_expr_arg (&iter)) */
6215	inline tree
6216	first_call_expr_arg (tree exp, call_expr_arg_iterator *iter)
6217	{
6218	init_call_expr_arg_iterator (exp, iter);
6219	return next_call_expr_arg (iter);
6220	}
6221
6222	inline const_tree
6223	first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter)
6224	{
6225	init_const_call_expr_arg_iterator (exp, iter);
6226	return next_const_call_expr_arg (iter);
6227	}
6228
6229	/* Test whether there are more arguments in abstract argument list iterator
6230	ITER, without changing its state. */
6231	inline bool
6232	more_call_expr_args_p (const call_expr_arg_iterator *iter)
6233	{
6234	return (iter->i < iter->n);
6235	}
6236
6237	/* Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER
6238	(of type call_expr_arg_iterator) to hold the iteration state. */
6239	#define FOR_EACH_CALL_EXPR_ARG(arg, iter, call) \
6240	for ((arg) = first_call_expr_arg ((call), &(iter)); (arg); \
6241	(arg) = next_call_expr_arg (&(iter)))
6242
6243	#define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call) \
6244	for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg); \
6245	(arg) = next_const_call_expr_arg (&(iter)))
6246
6247	/* Return true if tree node T is a language-specific node. */
6248	inline bool
6249	is_lang_specific (const_tree t)
6250	{
6251	return TREE_CODE (t) == LANG_TYPE || TREE_CODE (t) >= NUM_TREE_CODES;
6252	}
6253
6254	/* Valid builtin number. */
6255	#define BUILTIN_VALID_P(FNCODE) \
6256	(IN_RANGE ((int)FNCODE, ((int)BUILT_IN_NONE) + 1, ((int) END_BUILTINS) - 1))
6257
6258	/* Obtain a pointer to the identifier string holding the asm name for
6259	BUILTIN, a BUILT_IN code. This is handy if the target
6260	mangles/overrides the function name that implements the
6261	builtin. */
6262	#define BUILTIN_ASM_NAME_PTR(BUILTIN) \
6263	(IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (builtin_decl_explicit (BUILTIN))))
6264
6265	/* Return the tree node for an explicit standard builtin function or NULL. */
6266	inline tree
6267	builtin_decl_explicit (enum built_in_function fncode)
6268	{
6269	gcc_checking_assert (BUILTIN_VALID_P (fncode));
6270
6271	return builtin_info[(size_t)fncode].decl;
6272	}
6273
6274	/* Return the tree node for an implicit builtin function or NULL. */
6275	inline tree
6276	builtin_decl_implicit (enum built_in_function fncode)
6277	{
6278	size_t uns_fncode = (size_t)fncode;
6279	gcc_checking_assert (BUILTIN_VALID_P (fncode));
6280
6281	if (!builtin_info[uns_fncode].implicit_p)
6282	return NULL_TREE;
6283
6284	return builtin_info[uns_fncode].decl;
6285	}
6286
6287	/* For BUILTIN_UNREACHABLE, use one of these or
6288	gimple_build_builtin_unreachable instead of one of the above. */
6289	extern tree builtin_decl_unreachable ();
6290	extern tree build_builtin_unreachable (location_t);
6291
6292	/* Set explicit builtin function nodes and whether it is an implicit
6293	function. */
6294
6295	inline void
6296	set_builtin_decl (enum built_in_function fncode, tree decl, bool implicit_p)
6297	{
6298	size_t ufncode = (size_t)fncode;
6299
6300	gcc_checking_assert (BUILTIN_VALID_P (fncode)
6301	&& (decl != NULL_TREE || !implicit_p));
6302
6303	builtin_info[ufncode].decl = decl;
6304	builtin_info[ufncode].implicit_p = implicit_p;
6305	builtin_info[ufncode].declared_p = false;
6306	}
6307
6308	/* Set the implicit flag for a builtin function. */
6309
6310	inline void
6311	set_builtin_decl_implicit_p (enum built_in_function fncode, bool implicit_p)
6312	{
6313	size_t uns_fncode = (size_t)fncode;
6314
6315	gcc_checking_assert (BUILTIN_VALID_P (fncode)
6316	&& builtin_info[uns_fncode].decl != NULL_TREE);
6317
6318	builtin_info[uns_fncode].implicit_p = implicit_p;
6319	}
6320
6321	/* Set the declared flag for a builtin function. */
6322
6323	inline void
6324	set_builtin_decl_declared_p (enum built_in_function fncode, bool declared_p)
6325	{
6326	size_t uns_fncode = (size_t)fncode;
6327
6328	gcc_checking_assert (BUILTIN_VALID_P (fncode)
6329	&& builtin_info[uns_fncode].decl != NULL_TREE);
6330
6331	builtin_info[uns_fncode].declared_p = declared_p;
6332	}
6333
6334	/* Return whether the standard builtin function can be used as an explicit
6335	function. */
6336
6337	inline bool
6338	builtin_decl_explicit_p (enum built_in_function fncode)
6339	{
6340	gcc_checking_assert (BUILTIN_VALID_P (fncode));
6341	return (builtin_info[(size_t)fncode].decl != NULL_TREE);
6342	}
6343
6344	/* Return whether the standard builtin function can be used implicitly. */
6345
6346	inline bool
6347	builtin_decl_implicit_p (enum built_in_function fncode)
6348	{
6349	size_t uns_fncode = (size_t)fncode;
6350
6351	gcc_checking_assert (BUILTIN_VALID_P (fncode));
6352	return (builtin_info[uns_fncode].decl != NULL_TREE
6353	&& builtin_info[uns_fncode].implicit_p);
6354	}
6355
6356	/* Return whether the standard builtin function was declared. */
6357
6358	inline bool
6359	builtin_decl_declared_p (enum built_in_function fncode)
6360	{
6361	size_t uns_fncode = (size_t)fncode;
6362
6363	gcc_checking_assert (BUILTIN_VALID_P (fncode));
6364	return (builtin_info[uns_fncode].decl != NULL_TREE
6365	&& builtin_info[uns_fncode].declared_p);
6366	}
6367
6368	/* Determine if the function identified by FNDECL is one that
6369	makes sense to match by name, for those places where we detect
6370	"magic" functions by name.
6371
6372	Return true if FNDECL has a name and is an extern fndecl at file scope.
6373	FNDECL must be a non-NULL decl.
6374
6375	Avoid using this, as it's generally better to use attributes rather
6376	than to check for functions by name. */
6377
6378	inline bool
6379	maybe_special_function_p (const_tree fndecl)
6380	{
6381	tree name_decl = DECL_NAME (fndecl);
6382	if (name_decl
6383	/* Exclude functions not at the file scope, or not `extern',
6384	since they are not the magic functions we would otherwise
6385	think they are. */
6386	&& (DECL_CONTEXT (fndecl) == NULL_TREE
6387	|| TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
6388	&& TREE_PUBLIC (fndecl))
6389	return true;
6390	return false;
6391	}
6392
6393	/* Return true if T (assumed to be a DECL) is a global variable.
6394	A variable is considered global if its storage is not automatic. */
6395
6396	inline bool
6397	is_global_var (const_tree t)
6398	{
6399	return (TREE_STATIC (t) || DECL_EXTERNAL (t));
6400	}
6401
6402	/* Return true if VAR may be aliased. A variable is considered as
6403	maybe aliased if it has its address taken by the local TU
6404	or possibly by another TU and might be modified through a pointer. */
6405
6406	inline bool
6407	may_be_aliased (const_tree var)
6408	{
6409	return (TREE_CODE (var) != CONST_DECL
6410	&& (TREE_PUBLIC (var)
6411	|| DECL_EXTERNAL (var)
6412	|| TREE_ADDRESSABLE (var))
6413	&& !((TREE_STATIC (var) || TREE_PUBLIC (var) || DECL_EXTERNAL (var))
6414	&& (TREE_READONLY (var)
6415	|| (TREE_CODE (var) == VAR_DECL
6416	&& DECL_NONALIASED (var)))));
6417	}
6418
6419	/* Return pointer to optimization flags of FNDECL. */
6420	inline struct cl_optimization *
6421	opts_for_fn (const_tree fndecl)
6422	{
6423	tree fn_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
6424	if (fn_opts == NULL_TREE)
6425	fn_opts = optimization_default_node;
6426	return TREE_OPTIMIZATION (fn_opts);
6427	}
6428
6429	/* Return pointer to target flags of FNDECL. */
6430	inline cl_target_option *
6431	target_opts_for_fn (const_tree fndecl)
6432	{
6433	tree fn_opts = DECL_FUNCTION_SPECIFIC_TARGET (fndecl);
6434	if (fn_opts == NULL_TREE)
6435	fn_opts = target_option_default_node;
6436	return fn_opts == NULL_TREE ? NULL : TREE_TARGET_OPTION (fn_opts);
6437	}
6438
6439	/* opt flag for function FNDECL, e.g. opts_for_fn (fndecl, optimize) is
6440	the optimization level of function fndecl. */
6441	#define opt_for_fn(fndecl, opt) (opts_for_fn (fndecl)->x_##opt)
6442
6443	/* For anonymous aggregate types, we need some sort of name to
6444	hold on to. In practice, this should not appear, but it should
6445	not be harmful if it does. Identifiers returned will be
6446	IDENTIFIER_ANON_P. */
6447	extern tree make_anon_name ();
6448
6449	/* The tree and const_tree overload templates. */
6450	namespace wi
6451	{
6452	class unextended_tree
6453	{
6454	private:
6455	const_tree m_t;
6456
6457	public:
6458	unextended_tree () {}
6459	unextended_tree (const_tree t) : m_t (t) {}
6460
6461	unsigned int get_precision () const;
6462	const HOST_WIDE_INT *get_val () const;
6463	unsigned int get_len () const;
6464	const_tree get_tree () const { return m_t; }
6465	};
6466
6467	template <>
6468	struct int_traits <unextended_tree>
6469	{
6470	static const enum precision_type precision_type = VAR_PRECISION;
6471	static const bool host_dependent_precision = false;
6472	static const bool is_sign_extended = false;
6473	static const bool needs_write_val_arg = false;
6474	};
6475
6476	template <int N>
6477	class extended_tree
6478	{
6479	private:
6480	const_tree m_t;
6481
6482	public:
6483	extended_tree () {}
6484	extended_tree (const_tree);
6485
6486	unsigned int get_precision () const;
6487	const HOST_WIDE_INT *get_val () const;
6488	unsigned int get_len () const;
6489	const_tree get_tree () const { return m_t; }
6490	};
6491
6492	template <int N>
6493	struct int_traits <extended_tree <N> >
6494	{
6495	static const enum precision_type precision_type
6496	= N == ADDR_MAX_PRECISION ? INL_CONST_PRECISION : CONST_PRECISION;
6497	static const bool host_dependent_precision = false;
6498	static const bool is_sign_extended = true;
6499	static const bool needs_write_val_arg = false;
6500	static const unsigned int precision = N;
6501	};
6502
6503	typedef extended_tree <WIDEST_INT_MAX_PRECISION> widest_extended_tree;
6504	typedef extended_tree <ADDR_MAX_PRECISION> offset_extended_tree;
6505
6506	typedef const generic_wide_int <widest_extended_tree> tree_to_widest_ref;
6507	typedef const generic_wide_int <offset_extended_tree> tree_to_offset_ref;
6508	typedef const generic_wide_int<wide_int_ref_storage<false, false> >
6509	tree_to_wide_ref;
6510
6511	tree_to_widest_ref to_widest (const_tree);
6512	tree_to_offset_ref to_offset (const_tree);
6513	tree_to_wide_ref to_wide (const_tree);
6514	wide_int to_wide (const_tree, unsigned int);
6515
6516	typedef const poly_int <NUM_POLY_INT_COEFFS,
6517	generic_wide_int <widest_extended_tree> >
6518	tree_to_poly_widest_ref;
6519	typedef const poly_int <NUM_POLY_INT_COEFFS,
6520	generic_wide_int <offset_extended_tree> >
6521	tree_to_poly_offset_ref;
6522	typedef const poly_int <NUM_POLY_INT_COEFFS,
6523	generic_wide_int <unextended_tree> >
6524	tree_to_poly_wide_ref;
6525
6526	tree_to_poly_widest_ref to_poly_widest (const_tree);
6527	tree_to_poly_offset_ref to_poly_offset (const_tree);
6528	tree_to_poly_wide_ref to_poly_wide (const_tree);
6529
6530	template <int N>
6531	struct ints_for <generic_wide_int <extended_tree <N> >, INL_CONST_PRECISION>
6532	{
6533	typedef generic_wide_int <extended_tree <N> > extended;
6534	static extended zero (const extended &);
6535	};
6536
6537	template <int N>
6538	struct ints_for <generic_wide_int <extended_tree <N> >, CONST_PRECISION>
6539	{
6540	typedef generic_wide_int <extended_tree <N> > extended;
6541	static extended zero (const extended &);
6542	};
6543
6544	template <>
6545	struct ints_for <generic_wide_int <unextended_tree>, VAR_PRECISION>
6546	{
6547	typedef generic_wide_int <unextended_tree> unextended;
6548	static unextended zero (const unextended &);
6549	};
6550	}
6551
6552	/* Used to convert a tree to a widest2_int like this:
6553	widest2_int foo = widest2_int_cst (some_tree). */
6554	typedef generic_wide_int <wi::extended_tree <WIDEST_INT_MAX_PRECISION * 2> >
6555	widest2_int_cst;
6556
6557	/* Refer to INTEGER_CST T as though it were a widest_int.
6558
6559	This function gives T's actual numerical value, influenced by the
6560	signedness of its type. For example, a signed byte with just the
6561	top bit set would be -128 while an unsigned byte with the same
6562	bit pattern would be 128.
6563
6564	This is the right choice when operating on groups of INTEGER_CSTs
6565	that might have different signedness or precision. It is also the
6566	right choice in code that specifically needs an approximation of
6567	infinite-precision arithmetic instead of normal modulo arithmetic.
6568
6569	The approximation of infinite precision is good enough for realistic
6570	numbers of additions and subtractions of INTEGER_CSTs (where
6571	"realistic" includes any number less than 1 << 31) but it cannot
6572	represent the result of multiplying the two largest supported
6573	INTEGER_CSTs. The overflow-checking form of wi::mul provides a way
6574	of multiplying two arbitrary INTEGER_CSTs and checking that the
6575	result is representable as a widest_int.
6576
6577	Note that any overflow checking done on these values is relative to
6578	the range of widest_int rather than the range of a TREE_TYPE.
6579
6580	Calling this function should have no overhead in release builds,
6581	so it is OK to call it several times for the same tree. If it is
6582	useful for readability reasons to reduce the number of calls,
6583	it is more efficient to use:
6584
6585	wi::tree_to_widest_ref wt = wi::to_widest (t);
6586
6587	instead of:
6588
6589	widest_int wt = wi::to_widest (t). */
6590
6591	inline wi::tree_to_widest_ref
6592	wi::to_widest (const_tree t)
6593	{
6594	return t;
6595	}
6596
6597	/* Refer to INTEGER_CST T as though it were an offset_int.
6598
6599	This function is an optimisation of wi::to_widest for cases
6600	in which T is known to be a bit or byte count in the range
6601	(-(2 ^ (N + BITS_PER_UNIT)), 2 ^ (N + BITS_PER_UNIT)), where N is
6602	the target's address size in bits.
6603
6604	This is the right choice when operating on bit or byte counts as
6605	untyped numbers rather than M-bit values. The wi::to_widest comments
6606	about addition, subtraction and multiplication apply here: sequences
6607	of 1 << 31 additions and subtractions do not induce overflow, but
6608	multiplying the largest sizes might. Again,
6609
6610	wi::tree_to_offset_ref wt = wi::to_offset (t);
6611
6612	is more efficient than:
6613
6614	offset_int wt = wi::to_offset (t). */
6615
6616	inline wi::tree_to_offset_ref
6617	wi::to_offset (const_tree t)
6618	{
6619	return t;
6620	}
6621
6622	/* Refer to INTEGER_CST T as though it were a wide_int.
6623
6624	In contrast to the approximation of infinite-precision numbers given
6625	by wi::to_widest and wi::to_offset, this function treats T as a
6626	signless collection of N bits, where N is the precision of T's type.
6627	As with machine registers, signedness is determined by the operation
6628	rather than the operands; for example, there is a distinction between
6629	signed and unsigned division.
6630
6631	This is the right choice when operating on values with the same type
6632	using normal modulo arithmetic. The overflow-checking forms of things
6633	like wi::add check whether the result can be represented in T's type.
6634
6635	Calling this function should have no overhead in release builds,
6636	so it is OK to call it several times for the same tree. If it is
6637	useful for readability reasons to reduce the number of calls,
6638	it is more efficient to use:
6639
6640	wi::tree_to_wide_ref wt = wi::to_wide (t);
6641
6642	instead of:
6643
6644	wide_int wt = wi::to_wide (t). */
6645
6646	inline wi::tree_to_wide_ref
6647	wi::to_wide (const_tree t)
6648	{
6649	return wi::storage_ref (&TREE_INT_CST_ELT (t, 0), TREE_INT_CST_NUNITS (t),
6650	TYPE_PRECISION (TREE_TYPE (t)));
6651	}
6652
6653	/* Convert INTEGER_CST T to a wide_int of precision PREC, extending or
6654	truncating as necessary. When extending, use sign extension if T's
6655	type is signed and zero extension if T's type is unsigned. */
6656
6657	inline wide_int
6658	wi::to_wide (const_tree t, unsigned int prec)
6659	{
6660	return wide_int::from (x: wi::to_wide (t), precision: prec, TYPE_SIGN (TREE_TYPE (t)));
6661	}
6662
6663	template <int N>
6664	inline wi::extended_tree <N>::extended_tree (const_tree t)
6665	: m_t (t)
6666	{
6667	gcc_checking_assert (TYPE_PRECISION (TREE_TYPE (t)) <= N);
6668	}
6669
6670	template <int N>
6671	inline unsigned int
6672	wi::extended_tree <N>::get_precision () const
6673	{
6674	return N;
6675	}
6676
6677	template <int N>
6678	inline const HOST_WIDE_INT *
6679	wi::extended_tree <N>::get_val () const
6680	{
6681	return &TREE_INT_CST_ELT (m_t, 0);
6682	}
6683
6684	template <int N>
6685	inline unsigned int
6686	wi::extended_tree <N>::get_len () const
6687	{
6688	if (N == ADDR_MAX_PRECISION)
6689	{
6690	/* to_offset can only be applied to trees that are offset_int-sized
6691	or smaller. EXT_LEN is correct if it fits, otherwise the constant
6692	must be exactly the precision of offset_int and so LEN is correct. */
6693	unsigned int ext_len = TREE_INT_CST_EXT_NUNITS (m_t);
6694	if (ext_len <= OFFSET_INT_ELTS)
6695	return ext_len;
6696	return TREE_INT_CST_NUNITS (m_t);
6697	}
6698	else if (N >= WIDEST_INT_MAX_PRECISION)
6699	return TREE_INT_CST_EXT_NUNITS (m_t);
6700	else
6701	/* This class is designed to be used for specific output precisions
6702	and needs to be as fast as possible, so there is no fallback for
6703	other casees. */
6704	gcc_unreachable ();
6705	}
6706
6707	inline unsigned int
6708	wi::unextended_tree::get_precision () const
6709	{
6710	return TYPE_PRECISION (TREE_TYPE (m_t));
6711	}
6712
6713	inline const HOST_WIDE_INT *
6714	wi::unextended_tree::get_val () const
6715	{
6716	return &TREE_INT_CST_ELT (m_t, 0);
6717	}
6718
6719	inline unsigned int
6720	wi::unextended_tree::get_len () const
6721	{
6722	return TREE_INT_CST_NUNITS (m_t);
6723	}
6724
6725	/* Return the value of a POLY_INT_CST in its native precision. */
6726
6727	inline wi::tree_to_poly_wide_ref
6728	poly_int_cst_value (const_tree x)
6729	{
6730	poly_int <NUM_POLY_INT_COEFFS, generic_wide_int <wi::unextended_tree> > res;
6731	for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
6732	res.coeffs[i] = POLY_INT_CST_COEFF (x, i);
6733	return res;
6734	}
6735
6736	/* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
6737	poly_widest_int. See wi::to_widest for more details. */
6738
6739	inline wi::tree_to_poly_widest_ref
6740	wi::to_poly_widest (const_tree t)
6741	{
6742	if (POLY_INT_CST_P (t))
6743	{
6744	poly_int <NUM_POLY_INT_COEFFS,
6745	generic_wide_int <widest_extended_tree> > res;
6746	for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
6747	res.coeffs[i] = POLY_INT_CST_COEFF (t, i);
6748	return res;
6749	}
6750	return t;
6751	}
6752
6753	/* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
6754	poly_offset_int. See wi::to_offset for more details. */
6755
6756	inline wi::tree_to_poly_offset_ref
6757	wi::to_poly_offset (const_tree t)
6758	{
6759	if (POLY_INT_CST_P (t))
6760	{
6761	poly_int <NUM_POLY_INT_COEFFS,
6762	generic_wide_int <offset_extended_tree> > res;
6763	for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
6764	res.coeffs[i] = POLY_INT_CST_COEFF (t, i);
6765	return res;
6766	}
6767	return t;
6768	}
6769
6770	/* Access INTEGER_CST or POLY_INT_CST tree T as if it were a
6771	poly_wide_int. See wi::to_wide for more details. */
6772
6773	inline wi::tree_to_poly_wide_ref
6774	wi::to_poly_wide (const_tree t)
6775	{
6776	if (POLY_INT_CST_P (t))
6777	return poly_int_cst_value (x: t);
6778	return t;
6779	}
6780
6781	template <int N>
6782	inline generic_wide_int <wi::extended_tree <N> >
6783	wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
6784	wi::INL_CONST_PRECISION>::zero (const extended &x)
6785	{
6786	return build_zero_cst (TREE_TYPE (x.get_tree ()));
6787	}
6788
6789	template <int N>
6790	inline generic_wide_int <wi::extended_tree <N> >
6791	wi::ints_for <generic_wide_int <wi::extended_tree <N> >,
6792	wi::CONST_PRECISION>::zero (const extended &x)
6793	{
6794	return build_zero_cst (TREE_TYPE (x.get_tree ()));
6795	}
6796
6797	inline generic_wide_int <wi::unextended_tree>
6798	wi::ints_for <generic_wide_int <wi::unextended_tree>,
6799	wi::VAR_PRECISION>::zero (const unextended &x)
6800	{
6801	return build_zero_cst (TREE_TYPE (x.get_tree ()));
6802	}
6803
6804	namespace wi
6805	{
6806	template <typename T>
6807	bool fits_to_boolean_p (const T &x, const_tree);
6808
6809	template <typename T>
6810	bool fits_to_tree_p (const T &x, const_tree);
6811
6812	wide_int min_value (const_tree);
6813	wide_int max_value (const_tree);
6814	#ifndef GENERATOR_FILE
6815	wide_int from_mpz (const_tree, mpz_t, bool);
6816	#endif
6817	}
6818
6819	template <typename T>
6820	bool
6821	wi::fits_to_boolean_p (const T &x, const_tree type)
6822	{
6823	typedef typename poly_int_traits<T>::int_type int_type;
6824	return (known_eq (x, int_type (0))
6825	|| known_eq (x, int_type (TYPE_UNSIGNED (type) ? 1 : -1)));
6826	}
6827
6828	template <typename T>
6829	bool
6830	wi::fits_to_tree_p (const T &x, const_tree type)
6831	{
6832	/* Non-standard boolean types can have arbitrary precision but various
6833	transformations assume that they can only take values 0 and +/-1. */
6834	if (TREE_CODE (type) == BOOLEAN_TYPE)
6835	return fits_to_boolean_p (x, type);
6836
6837	if (TYPE_UNSIGNED (type))
6838	return known_eq (x, zext (x, TYPE_PRECISION (type)));
6839	else
6840	return known_eq (x, sext (x, TYPE_PRECISION (type)));
6841	}
6842
6843	/* Produce the smallest number that is represented in TYPE. The precision
6844	and sign are taken from TYPE. */
6845	inline wide_int
6846	wi::min_value (const_tree type)
6847	{
6848	return min_value (TYPE_PRECISION (type), TYPE_SIGN (type));
6849	}
6850
6851	/* Produce the largest number that is represented in TYPE. The precision
6852	and sign are taken from TYPE. */
6853	inline wide_int
6854	wi::max_value (const_tree type)
6855	{
6856	return max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
6857	}
6858
6859	/* Return true if INTEGER_CST T1 is less than INTEGER_CST T2,
6860	extending both according to their respective TYPE_SIGNs. */
6861
6862	inline bool
6863	tree_int_cst_lt (const_tree t1, const_tree t2)
6864	{
6865	return wi::to_widest (t: t1) < wi::to_widest (t: t2);
6866	}
6867
6868	/* Return true if INTEGER_CST T1 is less than or equal to INTEGER_CST T2,
6869	extending both according to their respective TYPE_SIGNs. */
6870
6871	inline bool
6872	tree_int_cst_le (const_tree t1, const_tree t2)
6873	{
6874	return wi::to_widest (t: t1) <= wi::to_widest (t: t2);
6875	}
6876
6877	/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. T1 and T2
6878	are both INTEGER_CSTs and their values are extended according to their
6879	respective TYPE_SIGNs. */
6880
6881	inline int
6882	tree_int_cst_compare (const_tree t1, const_tree t2)
6883	{
6884	return wi::cmps (x: wi::to_widest (t: t1), y: wi::to_widest (t: t2));
6885	}
6886
6887	/* FIXME - These declarations belong in builtins.h, expr.h and emit-rtl.h,
6888	but none of these files are allowed to be included from front ends.
6889	They should be split in two. One suitable for the FEs, the other suitable
6890	for the BE. */
6891
6892	/* Assign the RTX to declaration. */
6893	extern void set_decl_rtl (tree, rtx);
6894	extern bool complete_ctor_at_level_p (const_tree, HOST_WIDE_INT, const_tree);
6895
6896	/* Given an expression EXP that is a handled_component_p,
6897	look for the ultimate containing object, which is returned and specify
6898	the access position and size. */
6899	extern tree get_inner_reference (tree, poly_int64 *, poly_int64 *,
6900	tree *, machine_mode *, int *, int *, int *);
6901
6902	extern tree build_personality_function (const char *);
6903
6904	struct GTY(()) int_n_trees_t {
6905	/* These parts are initialized at runtime */
6906	tree signed_type;
6907	tree unsigned_type;
6908	};
6909
6910	/* This is also in machmode.h */
6911	extern bool int_n_enabled_p[NUM_INT_N_ENTS];
6912	extern GTY(()) struct int_n_trees_t int_n_trees[NUM_INT_N_ENTS];
6913
6914	/* Like bit_position, but return as an integer. It must be representable in
6915	that way (since it could be a signed value, we don't have the
6916	option of returning -1 like int_size_in_byte can. */
6917
6918	inline HOST_WIDE_INT
6919	int_bit_position (const_tree field)
6920	{
6921	return ((wi::to_offset (DECL_FIELD_OFFSET (field)) << LOG2_BITS_PER_UNIT)
6922	+ wi::to_offset (DECL_FIELD_BIT_OFFSET (field))).to_shwi ();
6923	}
6924
6925	/* Return true if it makes sense to consider alias set for a type T. */
6926
6927	inline bool
6928	type_with_alias_set_p (const_tree t)
6929	{
6930	/* Function and method types are never accessed as memory locations. */
6931	if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)
6932	return false;
6933
6934	if (COMPLETE_TYPE_P (t))
6935	return true;
6936
6937	/* Incomplete types cannot be accessed in general except for arrays
6938	where we can fetch its element despite we have no array bounds. */
6939	if (TREE_CODE (t) == ARRAY_TYPE && COMPLETE_TYPE_P (TREE_TYPE (t)))
6940	return true;
6941
6942	return false;
6943	}
6944
6945	extern location_t set_block (location_t loc, tree block);
6946
6947	extern void gt_ggc_mx (tree &);
6948	extern void gt_pch_nx (tree &);
6949	extern void gt_pch_nx (tree &, gt_pointer_operator, void *);
6950	extern void gt_ggc_mx (tree_raw_data *);
6951	extern void gt_pch_nx (tree_raw_data *);
6952	extern void gt_pch_nx (tree_raw_data *, gt_pointer_operator, void *);
6953
6954	extern bool nonnull_arg_p (const_tree);
6955	extern bool is_empty_type (const_tree);
6956	extern bool default_is_empty_record (const_tree);
6957	extern bool flexible_array_type_p (const_tree);
6958	extern HOST_WIDE_INT arg_int_size_in_bytes (const_tree);
6959	extern tree arg_size_in_bytes (const_tree);
6960	extern bool expr_type_first_operand_type_p (tree_code);
6961
6962	extern location_t
6963	set_source_range (tree expr, location_t start, location_t finish);
6964
6965	extern location_t
6966	set_source_range (tree expr, source_range src_range);
6967
6968	/* Return true if it makes sense to promote/demote from_type to to_type. */
6969	inline bool
6970	desired_pro_or_demotion_p (const_tree to_type, const_tree from_type)
6971	{
6972	unsigned int to_type_precision = TYPE_PRECISION (to_type);
6973
6974	/* OK to promote if to_type is no bigger than word_mode. */
6975	if (to_type_precision <= GET_MODE_PRECISION (mode: word_mode))
6976	return true;
6977
6978	/* Otherwise, allow only if narrowing or same precision conversions. */
6979	return to_type_precision <= TYPE_PRECISION (from_type);
6980	}
6981
6982	/* Pointer type used to declare builtins before we have seen its real
6983	declaration. */
6984	class builtin_structptr_type
6985	{
6986	public:
6987	tree& node;
6988	tree& base;
6989	const char *str;
6990	};
6991	extern const builtin_structptr_type builtin_structptr_types[6];
6992
6993	/* Return true if type T has the same precision as its underlying mode. */
6994
6995	inline bool
6996	type_has_mode_precision_p (const_tree t)
6997	{
6998	return known_eq (TYPE_PRECISION (t), GET_MODE_PRECISION (TYPE_MODE (t)));
6999	}
7000
7001	/* Helper functions for fndecl_built_in_p. */
7002
7003	inline bool
7004	built_in_function_equal_p (built_in_function name0, built_in_function name1)
7005	{
7006	return name0 == name1;
7007	}
7008
7009	/* Recursive case for two or more names. */
7010
7011	template <typename... F>
7012	inline bool
7013	built_in_function_equal_p (built_in_function name0, built_in_function name1,
7014	built_in_function name2, F... names)
7015	{
7016	return name0 == name1 || built_in_function_equal_p (name0, name2, names...);
7017	}
7018
7019	/* Return true if a FUNCTION_DECL NODE is a GCC built-in function.
7020
7021	Note that it is different from the DECL_IS_UNDECLARED_BUILTIN
7022	accessor, as this is impervious to user declaration. */
7023
7024	inline bool
7025	fndecl_built_in_p (const_tree node)
7026	{
7027	return DECL_BUILT_IN_CLASS (node) != NOT_BUILT_IN;
7028	}
7029
7030	/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
7031	of class KLASS. */
7032
7033	inline bool
7034	fndecl_built_in_p (const_tree node, built_in_class klass)
7035	{
7036	return fndecl_built_in_p (node) && DECL_BUILT_IN_CLASS (node) == klass;
7037	}
7038
7039	/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
7040	of class KLASS with name equal to NAME. */
7041
7042	inline bool
7043	fndecl_built_in_p (const_tree node, unsigned int name, built_in_class klass)
7044	{
7045	return (fndecl_built_in_p (node, klass)
7046	&& DECL_UNCHECKED_FUNCTION_CODE (node) == name);
7047	}
7048
7049	/* Return true if a FUNCTION_DECL NODE is a GCC built-in function
7050	of BUILT_IN_NORMAL class with name equal to NAME1 (or other mentioned
7051	NAMES). */
7052
7053	template <typename... F>
7054	inline bool
7055	fndecl_built_in_p (const_tree node, built_in_function name1, F... names)
7056	{
7057	return (fndecl_built_in_p (node, klass: BUILT_IN_NORMAL)
7058	&& built_in_function_equal_p (DECL_FUNCTION_CODE (decl: node),
7059	name1, names...));
7060	}
7061
7062	/* Returns true if the function decl NODE is an alloca. */
7063	inline bool
7064	fndecl_builtin_alloc_p (const_tree node)
7065	{
7066	if (!fndecl_built_in_p (node, klass: BUILT_IN_NORMAL))
7067	return false;
7068	return ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (node));
7069	}
7070
7071	/* A struct for encapsulating location information about an operator
7072	and the operation built from it.
7073
7074	m_operator_loc is the location of the operator
7075	m_combined_loc is the location of the compound expression.
7076
7077	For example, given "a && b" the, operator location is:
7078	a && b
7079	^~
7080	and the combined location is:
7081	a && b
7082	~~^~~~
7083	Capturing this information allows for class binary_op_rich_location
7084	to provide detailed information about e.g. type mismatches in binary
7085	operations where enough location information is available:
7086
7087	arg_0 op arg_1
7088	~~~~~ ^~ ~~~~~
7089	| |
7090	| arg1 type
7091	arg0 type
7092
7093	falling back to just showing the combined location:
7094
7095	arg_0 op arg_1
7096	~~~~~~^~~~~~~~
7097
7098	where it is not. */
7099
7100	class op_location_t
7101	{
7102	public:
7103	location_t m_operator_loc;
7104	location_t m_combined_loc;
7105
7106	/* 1-argument ctor, for constructing from a combined location. */
7107	op_location_t (location_t combined_loc)
7108	: m_operator_loc (UNKNOWN_LOCATION), m_combined_loc (combined_loc)
7109	{}
7110
7111	/* 2-argument ctor, for distinguishing between the operator's location
7112	and the combined location. */
7113	op_location_t (location_t operator_loc, location_t combined_loc)
7114	: m_operator_loc (operator_loc), m_combined_loc (combined_loc)
7115	{}
7116
7117	/* Implicitly convert back to a location_t, using the combined location. */
7118	operator location_t () const { return m_combined_loc; }
7119	};
7120
7121	/* Code that doesn't refer to any warning. Has no effect on suppression
7122	functions. */
7123	constexpr opt_code no_warning = opt_code ();
7124	/* Wildcard code that refers to all warnings. */
7125	constexpr opt_code all_warnings = N_OPTS;
7126
7127	/* Return the disposition for a warning (or all warnings by default)
7128	at a location. */
7129	extern bool warning_suppressed_at (location_t, opt_code = all_warnings);
7130	/* Set the disposition for a warning (or all warnings by default)
7131	at a location to disabled by default. */
7132	extern bool suppress_warning_at (location_t, opt_code = all_warnings,
7133	bool = true);
7134	/* Overwrite warning disposition bitmap for a location with given spec. */
7135	extern void put_warning_spec_at (location_t loc, unsigned);
7136	/* Copy warning disposition from one location to another. */
7137	extern void copy_warning (location_t, location_t);
7138
7139	/* Return the disposition for a warning (or all warnings by default)
7140	for an expression. */
7141	extern bool warning_suppressed_p (const_tree, opt_code = all_warnings);
7142	/* Set the disposition for a warning (or all warnings by default)
7143	at a location to disabled by default. */
7144	extern void suppress_warning (tree, opt_code = all_warnings, bool = true)
7145	ATTRIBUTE_NONNULL (1);
7146	/* Copy warning disposition from one expression to another. */
7147	extern void copy_warning (tree, const_tree);
7148
7149	/* Whether the tree might have a warning spec. */
7150	extern bool has_warning_spec (const_tree);
7151	/* Retrieve warning spec bitmap for tree streaming. */
7152	extern unsigned get_warning_spec (const_tree);
7153	/* Overwrite warning spec bitmap for a tree with given spec. */
7154	extern void put_warning_spec (tree, unsigned);
7155
7156	/* Return the zero-based number corresponding to the argument being
7157	deallocated if FNDECL is a deallocation function or an out-of-bounds
7158	value if it isn't. */
7159	extern unsigned fndecl_dealloc_argno (tree);
7160
7161	/* If an expression refers to a character array or pointer declared
7162	attribute nonstring, return a decl for that array or pointer and
7163	if nonnull, set the second argument to the referenced enclosing
7164	object or pointer. Otherwise return null. */
7165	extern tree get_attr_nonstring_decl (tree, tree * = NULL);
7166
7167	/* Returns the version string for a decl with target_version attribute.
7168	Returns an invalid string_slice if no attribute is present. */
7169	extern string_slice get_target_version (const tree);
7170	/* Returns a vector of the version strings from a target_clones attribute on
7171	a decl. Can also record the number of default versions found.
7172	Use bool to control whether or not the results should
7173	be filtered with TARGET_CHECK_TARGET_CLONE_VERSION. */
7174	extern auto_vec<string_slice> get_clone_versions
7175	(const tree,int * = NULL, bool = true);
7176	/* Returns a vector of the version strings from a target_clones attribute
7177	directly. Additionally takes a bool to control whether or not the results
7178	should be filtered with TARGET_CHECK_TARGET_CLONE_VERSION. */
7179	extern auto_vec<string_slice> get_clone_attr_versions
7180	(const tree, int *, bool = true);
7181
7182	/* Checks if two decls define any overlapping versions. */
7183	extern bool disjoint_version_decls (tree, tree);
7184	/* Checks if two overlapping decls are not mergeable. */
7185	extern bool diagnose_versioned_decls (tree, tree);
7186
7187	#endif /* GCC_TREE_H */
7188