1	/* Core data structures for the 'tree' type.
2	Copyright (C) 1989-2024 Free Software Foundation, Inc.
3
4	This file is part of GCC.
5
6	GCC is free software; you can redistribute it and/or modify it under
7	the terms of the GNU General Public License as published by the Free
8	Software Foundation; either version 3, or (at your option) any later
9	version.
10
11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14	for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with GCC; see the file COPYING3. If not see
18	<http://www.gnu.org/licenses/>. */
19
20	#ifndef GCC_TREE_CORE_H
21	#define GCC_TREE_CORE_H
22
23	#include "symtab.h"
24
25	/* This file contains all the data structures that define the 'tree' type.
26	There are no accessor macros nor functions in this file. Only the
27	basic data structures, extern declarations and type definitions. */
28
29	/*---------------------------------------------------------------------------
30	Forward type declarations. Mostly to avoid including unnecessary headers
31	---------------------------------------------------------------------------*/
32	struct function;
33	struct real_value;
34	struct fixed_value;
35	struct ptr_info_def;
36	struct die_struct;
37
38
39	/*---------------------------------------------------------------------------
40	#defined constants
41	---------------------------------------------------------------------------*/
42	/* Nonzero if this is a call to a function whose return value depends
43	solely on its arguments, has no side effects, and does not read
44	global memory. This corresponds to TREE_READONLY for function
45	decls. */
46	#define ECF_CONST (1 << 0)
47
48	/* Nonzero if this is a call to "pure" function (like const function,
49	but may read memory. This corresponds to DECL_PURE_P for function
50	decls. */
51	#define ECF_PURE (1 << 1)
52
53	/* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no
54	infinite loop. This corresponds to DECL_LOOPING_CONST_OR_PURE_P
55	for function decls.*/
56	#define ECF_LOOPING_CONST_OR_PURE (1 << 2)
57
58	/* Nonzero if this call will never return. */
59	#define ECF_NORETURN (1 << 3)
60
61	/* Nonzero if this is a call to malloc or a related function. */
62	#define ECF_MALLOC (1 << 4)
63
64	/* Nonzero if it is plausible that this is a call to alloca. */
65	#define ECF_MAY_BE_ALLOCA (1 << 5)
66
67	/* Nonzero if this is a call to a function that won't throw an exception. */
68	#define ECF_NOTHROW (1 << 6)
69
70	/* Nonzero if this is a call to setjmp or a related function. */
71	#define ECF_RETURNS_TWICE (1 << 7)
72
73	/* Nonzero if this call replaces the current stack frame. */
74	#define ECF_SIBCALL (1 << 8)
75
76	/* Function does not read or write memory (but may have side effects, so
77	it does not necessarily fit ECF_CONST). */
78	#define ECF_NOVOPS (1 << 9)
79
80	/* The function does not lead to calls within current function unit. */
81	#define ECF_LEAF (1 << 10)
82
83	/* Nonzero if this call returns its first argument. */
84	#define ECF_RET1 (1 << 11)
85
86	/* Nonzero if this call does not affect transactions. */
87	#define ECF_TM_PURE (1 << 12)
88
89	/* Nonzero if this call is into the transaction runtime library. */
90	#define ECF_TM_BUILTIN (1 << 13)
91
92	/* Nonzero if this is an indirect call by descriptor. */
93	#define ECF_BY_DESCRIPTOR (1 << 14)
94
95	/* Nonzero if this is a cold function. */
96	#define ECF_COLD (1 << 15)
97
98	/* Nonzero if this is a function expected to end with an exception. */
99	#define ECF_XTHROW (1 << 16)
100
101	/* Call argument flags. */
102
103	/* Nonzero if the argument is not used by the function. */
104	#define EAF_UNUSED (1 << 1)
105
106	/* Following flags come in pairs. First one is about direct dereferences
107	from the parameter, while the second is about memory reachable by
108	recursive dereferences. */
109
110	/* Nonzero if memory reached by the argument is not clobbered. */
111	#define EAF_NO_DIRECT_CLOBBER (1 << 2)
112	#define EAF_NO_INDIRECT_CLOBBER (1 << 3)
113
114	/* Nonzero if the argument does not escape. */
115	#define EAF_NO_DIRECT_ESCAPE (1 << 4)
116	#define EAF_NO_INDIRECT_ESCAPE (1 << 5)
117
118	/* Nonzero if the argument does not escape to return value. */
119	#define EAF_NOT_RETURNED_DIRECTLY (1 << 6)
120	#define EAF_NOT_RETURNED_INDIRECTLY (1 << 7)
121
122	/* Nonzero if the argument is not read. */
123	#define EAF_NO_DIRECT_READ (1 << 8)
124	#define EAF_NO_INDIRECT_READ (1 << 9)
125
126	/* Call return flags. */
127	/* Mask for the argument number that is returned. Lower two bits of
128	the return flags, encodes argument slots zero to three. */
129	#define ERF_RETURN_ARG_MASK (3)
130
131	/* Nonzero if the return value is equal to the argument number
132	flags & ERF_RETURN_ARG_MASK. */
133	#define ERF_RETURNS_ARG (1 << 2)
134
135	/* Nonzero if the return value does not alias with anything. Functions
136	with the malloc attribute have this set on their return value. */
137	#define ERF_NOALIAS (1 << 3)
138
139
140	/*---------------------------------------------------------------------------
141	Enumerations
142	---------------------------------------------------------------------------*/
143	/* Codes of tree nodes. */
144	#define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM,
145	#define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE,
146
147	enum tree_code {
148	#include "all-tree.def"
149	MAX_TREE_CODES
150	};
151
152	#undef DEFTREECODE
153	#undef END_OF_BASE_TREE_CODES
154
155	/* Number of language-independent tree codes. */
156	#define NUM_TREE_CODES \
157	((int) LAST_AND_UNUSED_TREE_CODE)
158
159	#define CODE_CONTAINS_STRUCT(CODE, STRUCT) \
160	(tree_contains_struct[(CODE)][(STRUCT)])
161
162
163	/* Classify which part of the compiler has defined a given builtin function.
164	Note that we assume below that this is no more than two bits. */
165	enum built_in_class {
166	NOT_BUILT_IN = 0,
167	BUILT_IN_FRONTEND,
168	BUILT_IN_MD,
169	BUILT_IN_NORMAL
170	};
171
172	/* Last marker used for LTO stremaing of built_in_class. We cannot add it
173	to the enum since we need the enumb to fit in 2 bits. */
174	#define BUILT_IN_LAST (BUILT_IN_NORMAL + 1)
175
176	/* Codes that identify the various built in functions
177	so that expand_call can identify them quickly. */
178	#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
179	enum built_in_function {
180	#include "builtins.def"
181	/* Complex division routines in libgcc. These are done via builtins
182	because emit_library_call_value can't handle complex values. */
183	BUILT_IN_COMPLEX_MUL_MIN,
184	BUILT_IN_COMPLEX_MUL_MAX
185	= BUILT_IN_COMPLEX_MUL_MIN
186	+ MAX_MODE_COMPLEX_FLOAT
187	- MIN_MODE_COMPLEX_FLOAT,
188
189	BUILT_IN_COMPLEX_DIV_MIN,
190	BUILT_IN_COMPLEX_DIV_MAX
191	= BUILT_IN_COMPLEX_DIV_MIN
192	+ MAX_MODE_COMPLEX_FLOAT
193	- MIN_MODE_COMPLEX_FLOAT,
194
195	/* Upper bound on non-language-specific builtins. */
196	END_BUILTINS
197	};
198
199	/* Internal functions. */
200	enum internal_fn {
201	#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) IFN_##CODE,
202	#include "internal-fn.def"
203	IFN_LAST
204	};
205
206	/* An enum that combines target-independent built-in functions with
207	internal functions, so that they can be treated in a similar way.
208	The numbers for built-in functions are the same as for the
209	built_in_function enum. The numbers for internal functions
210	start at END_BUITLINS. */
211	enum combined_fn {
212	#define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) \
213	CFN_##ENUM = int (ENUM),
214	#include "builtins.def"
215
216
217	#define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) \
218	CFN_##CODE = int (END_BUILTINS) + int (IFN_##CODE),
219	#include "internal-fn.def"
220
221	CFN_LAST
222	};
223
224	/* Tree code classes. Each tree_code has an associated code class
225	represented by a TREE_CODE_CLASS. */
226	enum tree_code_class {
227	tcc_exceptional, /* An exceptional code (fits no category). */
228	tcc_constant, /* A constant. */
229	/* Order of tcc_type and tcc_declaration is important. */
230	tcc_type, /* A type object code. */
231	tcc_declaration, /* A declaration (also serving as variable refs). */
232	tcc_reference, /* A reference to storage. */
233	tcc_comparison, /* A comparison expression. */
234	tcc_unary, /* A unary arithmetic expression. */
235	tcc_binary, /* A binary arithmetic expression. */
236	tcc_statement, /* A statement expression, which have side effects
237	but usually no interesting value. */
238	tcc_vl_exp, /* A function call or other expression with a
239	variable-length operand vector. */
240	tcc_expression /* Any other expression. */
241	};
242
243	/* OMP_CLAUSE codes. Do not reorder, as this is used to index into
244	the tables omp_clause_num_ops and omp_clause_code_name. */
245	enum omp_clause_code {
246	/* Clause zero is special-cased inside the parser
247	(c_parser_omp_variable_list). */
248	OMP_CLAUSE_ERROR = 0,
249
250	/* OpenACC/OpenMP clause: private (variable_list). */
251	OMP_CLAUSE_PRIVATE,
252
253	/* OpenMP clause: shared (variable_list). */
254	OMP_CLAUSE_SHARED,
255
256	/* OpenACC/OpenMP clause: firstprivate (variable_list). */
257	OMP_CLAUSE_FIRSTPRIVATE,
258
259	/* OpenMP clause: lastprivate (variable_list). */
260	OMP_CLAUSE_LASTPRIVATE,
261
262	/* OpenACC/OpenMP clause: reduction (operator:variable_list).
263	OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
264	Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
265	Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
266	into the shared one.
267	Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
268	placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}.
269	Operand 4: OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER: Another dummy
270	VAR_DECL placeholder, used like the above for C/C++ array
271	reductions. */
272	OMP_CLAUSE_REDUCTION,
273
274	/* OpenMP clause: task_reduction (operator:variable_list). */
275	OMP_CLAUSE_TASK_REDUCTION,
276
277	/* OpenMP clause: in_reduction (operator:variable_list). */
278	OMP_CLAUSE_IN_REDUCTION,
279
280	/* OpenMP clause: copyin (variable_list). */
281	OMP_CLAUSE_COPYIN,
282
283	/* OpenMP clause: copyprivate (variable_list). */
284	OMP_CLAUSE_COPYPRIVATE,
285
286	/* OpenMP clause: linear (variable-list[:linear-step]). */
287	OMP_CLAUSE_LINEAR,
288
289	/* OpenMP clause: affinity([depend-modifier :] variable-list). */
290	OMP_CLAUSE_AFFINITY,
291
292	/* OpenMP clause: aligned (variable-list[:alignment]). */
293	OMP_CLAUSE_ALIGNED,
294
295	/* OpenMP clause: allocate ([allocator:]variable-list). */
296	OMP_CLAUSE_ALLOCATE,
297
298	/* OpenMP clause: depend ({in,out,inout}:variable-list). */
299	OMP_CLAUSE_DEPEND,
300
301	/* OpenMP clause: nontemporal (variable-list). */
302	OMP_CLAUSE_NONTEMPORAL,
303
304	/* OpenMP clause: uniform (argument-list). */
305	OMP_CLAUSE_UNIFORM,
306
307	/* OpenMP clause: enter (extended-list).
308	to is a deprecated alias when it appears in declare target. */
309	OMP_CLAUSE_ENTER,
310
311	/* OpenMP clause: link (variable-list). */
312	OMP_CLAUSE_LINK,
313
314	/* OpenMP clause: detach (event-handle). */
315	OMP_CLAUSE_DETACH,
316
317	/* OpenACC clause: use_device (variable-list).
318	OpenMP clause: use_device_ptr (ptr-list). */
319	OMP_CLAUSE_USE_DEVICE_PTR,
320
321	/* OpenMP clause: use_device_addr (variable-list). */
322	OMP_CLAUSE_USE_DEVICE_ADDR,
323
324	/* OpenMP clause: is_device_ptr (variable-list). */
325	OMP_CLAUSE_IS_DEVICE_PTR,
326
327	/* OpenMP clause: inclusive (variable-list). */
328	OMP_CLAUSE_INCLUSIVE,
329
330	/* OpenMP clause: exclusive (variable-list). */
331	OMP_CLAUSE_EXCLUSIVE,
332
333	/* OpenMP clause: from (variable-list). */
334	OMP_CLAUSE_FROM,
335
336	/* OpenMP clause: to (variable-list). */
337	OMP_CLAUSE_TO,
338
339	/* OpenACC clauses: {copy, copyin, copyout, create, delete, deviceptr,
340	device, host (self), present, present_or_copy (pcopy), present_or_copyin
341	(pcopyin), present_or_copyout (pcopyout), present_or_create (pcreate)}
342	(variable-list).
343
344	OpenMP clause: map ({alloc:,to:,from:,tofrom:,}variable-list). */
345	OMP_CLAUSE_MAP,
346
347	/* OpenMP clause: has_device_addr (variable-list). */
348	OMP_CLAUSE_HAS_DEVICE_ADDR,
349
350	/* OpenMP clause: doacross ({source,sink}:vec). */
351	OMP_CLAUSE_DOACROSS,
352
353	/* Internal structure to hold OpenACC cache directive's variable-list.
354	#pragma acc cache (variable-list). */
355	OMP_CLAUSE__CACHE_,
356
357	/* OpenACC clause: gang [(gang-argument-list)].
358	Where
359	gang-argument-list: [gang-argument-list, ] gang-argument
360	gang-argument: [num:] integer-expression
361	| static: size-expression
362	size-expression: * | integer-expression. */
363	OMP_CLAUSE_GANG,
364
365	/* OpenACC clause: async [(integer-expression)]. */
366	OMP_CLAUSE_ASYNC,
367
368	/* OpenACC clause: wait [(integer-expression-list)]. */
369	OMP_CLAUSE_WAIT,
370
371	/* OpenACC clause: auto. */
372	OMP_CLAUSE_AUTO,
373
374	/* OpenACC clause: seq. */
375	OMP_CLAUSE_SEQ,
376
377	/* Internal clause: temporary for combined loops expansion. */
378	OMP_CLAUSE__LOOPTEMP_,
379
380	/* Internal clause: temporary for task reductions. */
381	OMP_CLAUSE__REDUCTEMP_,
382
383	/* Internal clause: temporary for lastprivate(conditional:). */
384	OMP_CLAUSE__CONDTEMP_,
385
386	/* Internal clause: temporary for inscan reductions. */
387	OMP_CLAUSE__SCANTEMP_,
388
389	/* OpenACC/OpenMP clause: if (scalar-expression). */
390	OMP_CLAUSE_IF,
391
392	/* OpenACC clause: self. */
393	OMP_CLAUSE_SELF,
394
395	/* OpenMP clause: num_threads (integer-expression). */
396	OMP_CLAUSE_NUM_THREADS,
397
398	/* OpenMP clause: schedule. */
399	OMP_CLAUSE_SCHEDULE,
400
401	/* OpenMP clause: nowait. */
402	OMP_CLAUSE_NOWAIT,
403
404	/* OpenMP clause: ordered [(constant-integer-expression)]. */
405	OMP_CLAUSE_ORDERED,
406
407	/* OpenACC/OpenMP clause: default. */
408	OMP_CLAUSE_DEFAULT,
409
410	/* OpenACC/OpenMP clause: collapse (constant-integer-expression). */
411	OMP_CLAUSE_COLLAPSE,
412
413	/* OpenMP clause: untied. */
414	OMP_CLAUSE_UNTIED,
415
416	/* OpenMP clause: final (scalar-expression). */
417	OMP_CLAUSE_FINAL,
418
419	/* OpenMP clause: mergeable. */
420	OMP_CLAUSE_MERGEABLE,
421
422	/* OpenMP clause: device (integer-expression). */
423	OMP_CLAUSE_DEVICE,
424
425	/* OpenMP clause: dist_schedule (static[:chunk-size]). */
426	OMP_CLAUSE_DIST_SCHEDULE,
427
428	/* OpenMP clause: inbranch. */
429	OMP_CLAUSE_INBRANCH,
430
431	/* OpenMP clause: notinbranch. */
432	OMP_CLAUSE_NOTINBRANCH,
433
434	/* OpenMP clause: num_teams(integer-expression). */
435	OMP_CLAUSE_NUM_TEAMS,
436
437	/* OpenMP clause: thread_limit(integer-expression). */
438	OMP_CLAUSE_THREAD_LIMIT,
439
440	/* OpenMP clause: proc_bind ({master,close,spread}). */
441	OMP_CLAUSE_PROC_BIND,
442
443	/* OpenMP clause: safelen (constant-integer-expression). */
444	OMP_CLAUSE_SAFELEN,
445
446	/* OpenMP clause: simdlen (constant-integer-expression). */
447	OMP_CLAUSE_SIMDLEN,
448
449	/* OpenMP clause: device_type ({host,nohost,any}). */
450	OMP_CLAUSE_DEVICE_TYPE,
451
452	/* OpenMP clause: for. */
453	OMP_CLAUSE_FOR,
454
455	/* OpenMP clause: parallel. */
456	OMP_CLAUSE_PARALLEL,
457
458	/* OpenMP clause: sections. */
459	OMP_CLAUSE_SECTIONS,
460
461	/* OpenMP clause: taskgroup. */
462	OMP_CLAUSE_TASKGROUP,
463
464	/* OpenMP clause: priority (integer-expression). */
465	OMP_CLAUSE_PRIORITY,
466
467	/* OpenMP clause: grainsize (integer-expression). */
468	OMP_CLAUSE_GRAINSIZE,
469
470	/* OpenMP clause: num_tasks (integer-expression). */
471	OMP_CLAUSE_NUM_TASKS,
472
473	/* OpenMP clause: nogroup. */
474	OMP_CLAUSE_NOGROUP,
475
476	/* OpenMP clause: threads. */
477	OMP_CLAUSE_THREADS,
478
479	/* OpenMP clause: simd. */
480	OMP_CLAUSE_SIMD,
481
482	/* OpenMP clause: hint (integer-expression). */
483	OMP_CLAUSE_HINT,
484
485	/* OpenMP clause: defaultmap (tofrom: scalar). */
486	OMP_CLAUSE_DEFAULTMAP,
487
488	/* OpenMP clause: order (concurrent). */
489	OMP_CLAUSE_ORDER,
490
491	/* OpenMP clause: bind (binding). */
492	OMP_CLAUSE_BIND,
493
494	/* OpenMP clause: filter (integer-expression). */
495	OMP_CLAUSE_FILTER,
496
497	/* OpenMP clause: indirect [(constant-integer-expression)]. */
498	OMP_CLAUSE_INDIRECT,
499
500	/* Internally used only clause, holding SIMD uid. */
501	OMP_CLAUSE__SIMDUID_,
502
503	/* Internally used only clause, flag whether this is SIMT simd
504	loop or not. */
505	OMP_CLAUSE__SIMT_,
506
507	/* OpenACC clause: independent. */
508	OMP_CLAUSE_INDEPENDENT,
509
510	/* OpenACC clause: worker [( [num:] integer-expression)]. */
511	OMP_CLAUSE_WORKER,
512
513	/* OpenACC clause: vector [( [length:] integer-expression)]. */
514	OMP_CLAUSE_VECTOR,
515
516	/* OpenACC clause: num_gangs (integer-expression). */
517	OMP_CLAUSE_NUM_GANGS,
518
519	/* OpenACC clause: num_workers (integer-expression). */
520	OMP_CLAUSE_NUM_WORKERS,
521
522	/* OpenACC clause: vector_length (integer-expression). */
523	OMP_CLAUSE_VECTOR_LENGTH,
524
525	/* OpenACC clause: tile ( size-expr-list ). */
526	OMP_CLAUSE_TILE,
527
528	/* OpenACC clause: if_present. */
529	OMP_CLAUSE_IF_PRESENT,
530
531	/* OpenACC clause: finalize. */
532	OMP_CLAUSE_FINALIZE,
533
534	/* OpenACC clause: nohost. */
535	OMP_CLAUSE_NOHOST,
536	};
537
538	#undef DEFTREESTRUCT
539	#define DEFTREESTRUCT(ENUM, NAME) ENUM,
540	enum tree_node_structure_enum {
541	#include "treestruct.def"
542	LAST_TS_ENUM
543	};
544	#undef DEFTREESTRUCT
545
546	enum omp_clause_schedule_kind {
547	OMP_CLAUSE_SCHEDULE_STATIC,
548	OMP_CLAUSE_SCHEDULE_DYNAMIC,
549	OMP_CLAUSE_SCHEDULE_GUIDED,
550	OMP_CLAUSE_SCHEDULE_AUTO,
551	OMP_CLAUSE_SCHEDULE_RUNTIME,
552	OMP_CLAUSE_SCHEDULE_MASK = (1 << 3) - 1,
553	OMP_CLAUSE_SCHEDULE_MONOTONIC = (1 << 3),
554	OMP_CLAUSE_SCHEDULE_NONMONOTONIC = (1 << 4),
555	OMP_CLAUSE_SCHEDULE_LAST = 2 * OMP_CLAUSE_SCHEDULE_NONMONOTONIC - 1
556	};
557
558	enum omp_clause_default_kind {
559	OMP_CLAUSE_DEFAULT_UNSPECIFIED,
560	OMP_CLAUSE_DEFAULT_SHARED,
561	OMP_CLAUSE_DEFAULT_NONE,
562	OMP_CLAUSE_DEFAULT_PRIVATE,
563	OMP_CLAUSE_DEFAULT_FIRSTPRIVATE,
564	OMP_CLAUSE_DEFAULT_PRESENT,
565	OMP_CLAUSE_DEFAULT_LAST
566	};
567
568	enum omp_clause_defaultmap_kind {
569	OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED,
570	OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALL,
571	OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR,
572	OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE,
573	OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE,
574	OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER,
575	OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK = 7,
576	OMP_CLAUSE_DEFAULTMAP_ALLOC = 1 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
577	OMP_CLAUSE_DEFAULTMAP_TO = 2 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
578	OMP_CLAUSE_DEFAULTMAP_FROM = 3 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
579	OMP_CLAUSE_DEFAULTMAP_TOFROM = 4 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
580	OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE
581	= 5 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
582	OMP_CLAUSE_DEFAULTMAP_NONE = 6 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
583	OMP_CLAUSE_DEFAULTMAP_DEFAULT
584	= 7 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
585	OMP_CLAUSE_DEFAULTMAP_PRESENT = 8 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1),
586	OMP_CLAUSE_DEFAULTMAP_MASK = 15 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1)
587	};
588
589	enum omp_clause_bind_kind {
590	OMP_CLAUSE_BIND_TEAMS,
591	OMP_CLAUSE_BIND_PARALLEL,
592	OMP_CLAUSE_BIND_THREAD
593	};
594
595	/* memory-order-clause on OpenMP atomic/flush constructs or
596	argument of atomic_default_mem_order clause. */
597	enum omp_memory_order {
598	OMP_MEMORY_ORDER_UNSPECIFIED,
599	OMP_MEMORY_ORDER_RELAXED,
600	OMP_MEMORY_ORDER_ACQUIRE,
601	OMP_MEMORY_ORDER_RELEASE,
602	OMP_MEMORY_ORDER_ACQ_REL,
603	OMP_MEMORY_ORDER_SEQ_CST,
604	OMP_MEMORY_ORDER_MASK = 7,
605	OMP_FAIL_MEMORY_ORDER_UNSPECIFIED = OMP_MEMORY_ORDER_UNSPECIFIED * 8,
606	OMP_FAIL_MEMORY_ORDER_RELAXED = OMP_MEMORY_ORDER_RELAXED * 8,
607	OMP_FAIL_MEMORY_ORDER_ACQUIRE = OMP_MEMORY_ORDER_ACQUIRE * 8,
608	OMP_FAIL_MEMORY_ORDER_RELEASE = OMP_MEMORY_ORDER_RELEASE * 8,
609	OMP_FAIL_MEMORY_ORDER_ACQ_REL = OMP_MEMORY_ORDER_ACQ_REL * 8,
610	OMP_FAIL_MEMORY_ORDER_SEQ_CST = OMP_MEMORY_ORDER_SEQ_CST * 8,
611	OMP_FAIL_MEMORY_ORDER_MASK = OMP_MEMORY_ORDER_MASK * 8
612	};
613	#define OMP_FAIL_MEMORY_ORDER_SHIFT 3
614
615	/* There is a TYPE_QUAL value for each type qualifier. They can be
616	combined by bitwise-or to form the complete set of qualifiers for a
617	type. */
618	enum cv_qualifier {
619	TYPE_UNQUALIFIED = 0x0,
620	TYPE_QUAL_CONST = 0x1,
621	TYPE_QUAL_VOLATILE = 0x2,
622	TYPE_QUAL_RESTRICT = 0x4,
623	TYPE_QUAL_ATOMIC = 0x8
624	};
625
626	/* Standard named or nameless data types of the C compiler. */
627	enum tree_index {
628	TI_ERROR_MARK,
629	TI_INTQI_TYPE,
630	TI_INTHI_TYPE,
631	TI_INTSI_TYPE,
632	TI_INTDI_TYPE,
633	TI_INTTI_TYPE,
634
635	TI_UINTQI_TYPE,
636	TI_UINTHI_TYPE,
637	TI_UINTSI_TYPE,
638	TI_UINTDI_TYPE,
639	TI_UINTTI_TYPE,
640
641	TI_ATOMICQI_TYPE,
642	TI_ATOMICHI_TYPE,
643	TI_ATOMICSI_TYPE,
644	TI_ATOMICDI_TYPE,
645	TI_ATOMICTI_TYPE,
646
647	TI_UINT16_TYPE,
648	TI_UINT32_TYPE,
649	TI_UINT64_TYPE,
650	TI_UINT128_TYPE,
651
652	TI_VOID,
653
654	TI_INTEGER_ZERO,
655	TI_INTEGER_ONE,
656	TI_INTEGER_THREE,
657	TI_INTEGER_MINUS_ONE,
658	TI_NULL_POINTER,
659
660	TI_SIZE_ZERO,
661	TI_SIZE_ONE,
662
663	TI_BITSIZE_ZERO,
664	TI_BITSIZE_ONE,
665	TI_BITSIZE_UNIT,
666
667	TI_PUBLIC,
668	TI_PROTECTED,
669	TI_PRIVATE,
670
671	TI_BOOLEAN_FALSE,
672	TI_BOOLEAN_TRUE,
673
674	TI_FLOAT_TYPE,
675	TI_DOUBLE_TYPE,
676	TI_LONG_DOUBLE_TYPE,
677
678	/* __bf16 type if supported (used in C++ as std::bfloat16_t). */
679	TI_BFLOAT16_TYPE,
680
681	/* The _FloatN and _FloatNx types must be consecutive, and in the
682	same sequence as the corresponding complex types, which must also
683	be consecutive; _FloatN must come before _FloatNx; the order must
684	also be the same as in the floatn_nx_types array and the RID_*
685	values in c-common.h. This is so that iterations over these
686	types work as intended. */
687	TI_FLOAT16_TYPE,
688	TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE,
689	TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE,
690	TI_FLOAT32_TYPE,
691	TI_FLOAT64_TYPE,
692	TI_FLOAT128_TYPE,
693	TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE,
694	#define NUM_FLOATN_TYPES (TI_FLOATN_TYPE_LAST - TI_FLOATN_TYPE_FIRST + 1)
695	TI_FLOAT32X_TYPE,
696	TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE,
697	TI_FLOAT64X_TYPE,
698	TI_FLOAT128X_TYPE,
699	TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE,
700	TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE,
701	#define NUM_FLOATNX_TYPES (TI_FLOATNX_TYPE_LAST - TI_FLOATNX_TYPE_FIRST + 1)
702	#define NUM_FLOATN_NX_TYPES (TI_FLOATN_NX_TYPE_LAST \
703	- TI_FLOATN_NX_TYPE_FIRST \
704	+ 1)
705
706	/* Type used by certain backends for __float128, which in C++ should be
707	distinct type from _Float128 for backwards compatibility reasons. */
708	TI_FLOAT128T_TYPE,
709
710	/* Put the complex types after their component types, so that in (sequential)
711	tree streaming we can assert that their component types have already been
712	handled (see tree-streamer.cc:record_common_node). */
713	TI_COMPLEX_INTEGER_TYPE,
714	TI_COMPLEX_FLOAT_TYPE,
715	TI_COMPLEX_DOUBLE_TYPE,
716	TI_COMPLEX_LONG_DOUBLE_TYPE,
717
718	TI_COMPLEX_FLOAT16_TYPE,
719	TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE,
720	TI_COMPLEX_FLOAT32_TYPE,
721	TI_COMPLEX_FLOAT64_TYPE,
722	TI_COMPLEX_FLOAT128_TYPE,
723	TI_COMPLEX_FLOAT32X_TYPE,
724	TI_COMPLEX_FLOAT64X_TYPE,
725	TI_COMPLEX_FLOAT128X_TYPE,
726
727	TI_FLOAT_PTR_TYPE,
728	TI_DOUBLE_PTR_TYPE,
729	TI_LONG_DOUBLE_PTR_TYPE,
730	TI_INTEGER_PTR_TYPE,
731
732	TI_VOID_TYPE,
733	TI_PTR_TYPE,
734	TI_CONST_PTR_TYPE,
735	TI_SIZE_TYPE,
736	TI_PID_TYPE,
737	TI_PTRDIFF_TYPE,
738	TI_VA_LIST_TYPE,
739	TI_VA_LIST_GPR_COUNTER_FIELD,
740	TI_VA_LIST_FPR_COUNTER_FIELD,
741	TI_BOOLEAN_TYPE,
742	TI_FILEPTR_TYPE,
743	TI_CONST_TM_PTR_TYPE,
744	TI_FENV_T_PTR_TYPE,
745	TI_CONST_FENV_T_PTR_TYPE,
746	TI_FEXCEPT_T_PTR_TYPE,
747	TI_CONST_FEXCEPT_T_PTR_TYPE,
748	TI_POINTER_SIZED_TYPE,
749
750	TI_DFLOAT32_TYPE,
751	TI_DFLOAT64_TYPE,
752	TI_DFLOAT128_TYPE,
753
754	TI_VOID_LIST_NODE,
755
756	TI_MAIN_IDENTIFIER,
757
758	TI_SAT_SFRACT_TYPE,
759	TI_SAT_FRACT_TYPE,
760	TI_SAT_LFRACT_TYPE,
761	TI_SAT_LLFRACT_TYPE,
762	TI_SAT_USFRACT_TYPE,
763	TI_SAT_UFRACT_TYPE,
764	TI_SAT_ULFRACT_TYPE,
765	TI_SAT_ULLFRACT_TYPE,
766	TI_SFRACT_TYPE,
767	TI_FRACT_TYPE,
768	TI_LFRACT_TYPE,
769	TI_LLFRACT_TYPE,
770	TI_USFRACT_TYPE,
771	TI_UFRACT_TYPE,
772	TI_ULFRACT_TYPE,
773	TI_ULLFRACT_TYPE,
774	TI_SAT_SACCUM_TYPE,
775	TI_SAT_ACCUM_TYPE,
776	TI_SAT_LACCUM_TYPE,
777	TI_SAT_LLACCUM_TYPE,
778	TI_SAT_USACCUM_TYPE,
779	TI_SAT_UACCUM_TYPE,
780	TI_SAT_ULACCUM_TYPE,
781	TI_SAT_ULLACCUM_TYPE,
782	TI_SACCUM_TYPE,
783	TI_ACCUM_TYPE,
784	TI_LACCUM_TYPE,
785	TI_LLACCUM_TYPE,
786	TI_USACCUM_TYPE,
787	TI_UACCUM_TYPE,
788	TI_ULACCUM_TYPE,
789	TI_ULLACCUM_TYPE,
790	TI_QQ_TYPE,
791	TI_HQ_TYPE,
792	TI_SQ_TYPE,
793	TI_DQ_TYPE,
794	TI_TQ_TYPE,
795	TI_UQQ_TYPE,
796	TI_UHQ_TYPE,
797	TI_USQ_TYPE,
798	TI_UDQ_TYPE,
799	TI_UTQ_TYPE,
800	TI_SAT_QQ_TYPE,
801	TI_SAT_HQ_TYPE,
802	TI_SAT_SQ_TYPE,
803	TI_SAT_DQ_TYPE,
804	TI_SAT_TQ_TYPE,
805	TI_SAT_UQQ_TYPE,
806	TI_SAT_UHQ_TYPE,
807	TI_SAT_USQ_TYPE,
808	TI_SAT_UDQ_TYPE,
809	TI_SAT_UTQ_TYPE,
810	TI_HA_TYPE,
811	TI_SA_TYPE,
812	TI_DA_TYPE,
813	TI_TA_TYPE,
814	TI_UHA_TYPE,
815	TI_USA_TYPE,
816	TI_UDA_TYPE,
817	TI_UTA_TYPE,
818	TI_SAT_HA_TYPE,
819	TI_SAT_SA_TYPE,
820	TI_SAT_DA_TYPE,
821	TI_SAT_TA_TYPE,
822	TI_SAT_UHA_TYPE,
823	TI_SAT_USA_TYPE,
824	TI_SAT_UDA_TYPE,
825	TI_SAT_UTA_TYPE,
826
827	TI_MODULE_HWM,
828	/* Nodes below here change during compilation, and should therefore
829	not be in the C++ module's global tree table. */
830
831	TI_OPTIMIZATION_DEFAULT,
832	TI_OPTIMIZATION_CURRENT,
833	TI_TARGET_OPTION_DEFAULT,
834	TI_TARGET_OPTION_CURRENT,
835	TI_CURRENT_TARGET_PRAGMA,
836	TI_CURRENT_OPTIMIZE_PRAGMA,
837
838	TI_CHREC_DONT_KNOW,
839	TI_CHREC_KNOWN,
840
841	TI_MAX
842	};
843
844	/* An enumeration of the standard C integer types. These must be
845	ordered so that shorter types appear before longer ones, and so
846	that signed types appear before unsigned ones, for the correct
847	functioning of interpret_integer() in c-lex.cc. */
848	enum integer_type_kind {
849	itk_char,
850	itk_signed_char,
851	itk_unsigned_char,
852	itk_short,
853	itk_unsigned_short,
854	itk_int,
855	itk_unsigned_int,
856	itk_long,
857	itk_unsigned_long,
858	itk_long_long,
859	itk_unsigned_long_long,
860
861	itk_intN_0,
862	itk_unsigned_intN_0,
863	itk_intN_1,
864	itk_unsigned_intN_1,
865	itk_intN_2,
866	itk_unsigned_intN_2,
867	itk_intN_3,
868	itk_unsigned_intN_3,
869
870	itk_none
871	};
872
873	/* A pointer-to-function member type looks like:
874
875	struct {
876	__P __pfn;
877	ptrdiff_t __delta;
878	};
879
880	If __pfn is NULL, it is a NULL pointer-to-member-function.
881
882	(Because the vtable is always the first thing in the object, we
883	don't need its offset.) If the function is virtual, then PFN is
884	one plus twice the index into the vtable; otherwise, it is just a
885	pointer to the function.
886
887	Unfortunately, using the lowest bit of PFN doesn't work in
888	architectures that don't impose alignment requirements on function
889	addresses, or that use the lowest bit to tell one ISA from another,
890	for example. For such architectures, we use the lowest bit of
891	DELTA instead of the lowest bit of the PFN, and DELTA will be
892	multiplied by 2. */
893	enum ptrmemfunc_vbit_where_t {
894	ptrmemfunc_vbit_in_pfn,
895	ptrmemfunc_vbit_in_delta
896	};
897
898	/* Flags that may be passed in the third argument of decl_attributes, and
899	to handler functions for attributes. */
900	enum attribute_flags {
901	/* The type passed in is the type of a DECL, and any attributes that
902	should be passed in again to be applied to the DECL rather than the
903	type should be returned. */
904	ATTR_FLAG_DECL_NEXT = 1,
905	/* The type passed in is a function return type, and any attributes that
906	should be passed in again to be applied to the function type rather
907	than the return type should be returned. */
908	ATTR_FLAG_FUNCTION_NEXT = 2,
909	/* The type passed in is an array element type, and any attributes that
910	should be passed in again to be applied to the array type rather
911	than the element type should be returned. */
912	ATTR_FLAG_ARRAY_NEXT = 4,
913	/* The type passed in is a structure, union or enumeration type being
914	created, and should be modified in place. */
915	ATTR_FLAG_TYPE_IN_PLACE = 8,
916	/* The attributes are being applied by default to a library function whose
917	name indicates known behavior, and should be silently ignored if they
918	are not in fact compatible with the function type. */
919	ATTR_FLAG_BUILT_IN = 16,
920	/* A given attribute has been parsed as a C++-11 attribute. */
921	ATTR_FLAG_CXX11 = 32,
922	/* The attribute handler is being invoked with an internal argument
923	that may not otherwise be valid when specified in source code. */
924	ATTR_FLAG_INTERNAL = 64
925	};
926
927	/* Types used to represent sizes. */
928	enum size_type_kind {
929	stk_sizetype, /* Normal representation of sizes in bytes. */
930	stk_ssizetype, /* Signed representation of sizes in bytes. */
931	stk_bitsizetype, /* Normal representation of sizes in bits. */
932	stk_sbitsizetype, /* Signed representation of sizes in bits. */
933	stk_type_kind_last
934	};
935
936	/* Flags controlling operand_equal_p() behavior. */
937	enum operand_equal_flag {
938	OEP_ONLY_CONST = 1,
939	OEP_PURE_SAME = 2,
940	OEP_MATCH_SIDE_EFFECTS = 4,
941	OEP_ADDRESS_OF = 8,
942	/* Internal within operand_equal_p: */
943	OEP_NO_HASH_CHECK = 16,
944	/* Internal within inchash::add_expr: */
945	OEP_HASH_CHECK = 32,
946	/* Makes operand_equal_p handle more expressions: */
947	OEP_LEXICOGRAPHIC = 64,
948	OEP_BITWISE = 128,
949	/* For OEP_ADDRESS_OF of COMPONENT_REFs, only consider same fields as
950	equivalent rather than also different fields with the same offset. */
951	OEP_ADDRESS_OF_SAME_FIELD = 256,
952	/* In conjunction with OEP_LEXICOGRAPHIC considers names of declarations
953	of the same kind. Used to compare VLA bounds involving parameters
954	across redeclarations of the same function. */
955	OEP_DECL_NAME = 512
956	};
957
958	/* Enum and arrays used for tree allocation stats.
959	Keep in sync with tree.cc:tree_node_kind_names. */
960	enum tree_node_kind {
961	d_kind,
962	t_kind,
963	b_kind,
964	s_kind,
965	r_kind,
966	e_kind,
967	c_kind,
968	id_kind,
969	vec_kind,
970	binfo_kind,
971	ssa_name_kind,
972	constr_kind,
973	x_kind,
974	lang_decl,
975	lang_type,
976	omp_clause_kind,
977	all_kinds
978	};
979
980	enum annot_expr_kind {
981	annot_expr_ivdep_kind,
982	annot_expr_unroll_kind,
983	annot_expr_no_vector_kind,
984	annot_expr_vector_kind,
985	annot_expr_parallel_kind,
986	annot_expr_maybe_infinite_kind,
987	annot_expr_kind_last
988	};
989
990	/* The kind of a TREE_CLOBBER_P CONSTRUCTOR node. Other than _UNDEF, these are
991	in roughly sequential order. */
992	enum clobber_kind {
993	/* Unspecified, this clobber acts as a store of an undefined value. */
994	CLOBBER_UNDEF,
995	/* Beginning of storage duration, e.g. malloc. */
996	CLOBBER_STORAGE_BEGIN,
997	/* Beginning of object data, e.g. start of C++ constructor. This differs
998	from C++ 'lifetime', which starts when initialization is complete; a
999	clobber there would discard the initialization. */
1000	CLOBBER_OBJECT_BEGIN,
1001	/* End of object data, e.g. end of C++ destructor. */
1002	CLOBBER_OBJECT_END,
1003	/* End of storage duration, e.g. free. */
1004	CLOBBER_STORAGE_END,
1005	CLOBBER_LAST
1006	};
1007
1008	/*---------------------------------------------------------------------------
1009	Type definitions
1010	---------------------------------------------------------------------------*/
1011	/* When processing aliases at the symbol table level, we need the
1012	declaration of target. For this reason we need to queue aliases and
1013	process them after all declarations has been produced. */
1014	struct GTY(()) alias_pair {
1015	tree decl;
1016	tree target;
1017	};
1018
1019	/* An initialization priority. */
1020	typedef unsigned short priority_type;
1021
1022	/* The type of a callback function for walking over tree structure. */
1023	typedef tree (*walk_tree_fn) (tree *, int *, void *);
1024
1025	/* The type of a callback function that represents a custom walk_tree. */
1026	typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
1027	void *, hash_set<tree> *);
1028
1029
1030	/*---------------------------------------------------------------------------
1031	Main data structures
1032	---------------------------------------------------------------------------*/
1033	/* A tree node can represent a data type, a variable, an expression
1034	or a statement. Each node has a TREE_CODE which says what kind of
1035	thing it represents. Some common codes are:
1036	INTEGER_TYPE -- represents a type of integers.
1037	ARRAY_TYPE -- represents a type of pointer.
1038	VAR_DECL -- represents a declared variable.
1039	INTEGER_CST -- represents a constant integer value.
1040	PLUS_EXPR -- represents a sum (an expression).
1041
1042	As for the contents of a tree node: there are some fields
1043	that all nodes share. Each TREE_CODE has various special-purpose
1044	fields as well. The fields of a node are never accessed directly,
1045	always through accessor macros. */
1046
1047	/* Every kind of tree node starts with this structure,
1048	so all nodes have these fields.
1049
1050	See the accessor macros, defined below, for documentation of the
1051	fields, and the table below which connects the fields and the
1052	accessor macros. */
1053
1054	struct GTY(()) tree_base {
1055	ENUM_BITFIELD(tree_code) code : 16;
1056
1057	unsigned side_effects_flag : 1;
1058	unsigned constant_flag : 1;
1059	unsigned addressable_flag : 1;
1060	unsigned volatile_flag : 1;
1061	unsigned readonly_flag : 1;
1062	unsigned asm_written_flag: 1;
1063	unsigned nowarning_flag : 1;
1064	unsigned visited : 1;
1065
1066	unsigned used_flag : 1;
1067	unsigned nothrow_flag : 1;
1068	unsigned static_flag : 1;
1069	unsigned public_flag : 1;
1070	unsigned private_flag : 1;
1071	unsigned protected_flag : 1;
1072	unsigned deprecated_flag : 1;
1073	unsigned default_def_flag : 1;
1074
1075	union {
1076	/* The bits in the following structure should only be used with
1077	accessor macros that constrain inputs with tree checking. */
1078	struct {
1079	unsigned lang_flag_0 : 1;
1080	unsigned lang_flag_1 : 1;
1081	unsigned lang_flag_2 : 1;
1082	unsigned lang_flag_3 : 1;
1083	unsigned lang_flag_4 : 1;
1084	unsigned lang_flag_5 : 1;
1085	unsigned lang_flag_6 : 1;
1086	unsigned saturating_flag : 1;
1087
1088	unsigned unsigned_flag : 1;
1089	unsigned packed_flag : 1;
1090	unsigned user_align : 1;
1091	unsigned nameless_flag : 1;
1092	unsigned atomic_flag : 1;
1093	unsigned unavailable_flag : 1;
1094	unsigned spare0 : 2;
1095
1096	unsigned spare1 : 8;
1097
1098	/* For _TYPE nodes, this is TYPE_ADDR_SPACE; the reason it is
1099	present in tree_base instead of tree_type is to save space. The size
1100	of the field must be large enough to hold addr_space_t values.
1101	For CONSTRUCTOR nodes this holds the clobber_kind enum.
1102	The C++ front-end uses this in IDENTIFIER_NODE and NAMESPACE_DECL. */
1103	unsigned address_space : 8;
1104	} bits;
1105
1106	/* The following fields are present in tree_base to save space. The
1107	nodes using them do not require any of the flags above and so can
1108	make better use of the 4-byte sized word. */
1109
1110	/* The number of HOST_WIDE_INTs in an INTEGER_CST. */
1111	struct {
1112	/* The number of HOST_WIDE_INTs if the INTEGER_CST is accessed in
1113	its native precision. */
1114	unsigned short unextended;
1115
1116	/* The number of HOST_WIDE_INTs if the INTEGER_CST is extended to
1117	wider precisions based on its TYPE_SIGN. */
1118	unsigned short extended;
1119	} int_length;
1120
1121	/* VEC length. This field is only used with TREE_VEC. */
1122	int length;
1123
1124	/* This field is only used with VECTOR_CST. */
1125	struct {
1126	/* The value of VECTOR_CST_LOG2_NPATTERNS. */
1127	unsigned int log2_npatterns : 8;
1128
1129	/* The value of VECTOR_CST_NELTS_PER_PATTERN. */
1130	unsigned int nelts_per_pattern : 8;
1131
1132	/* For future expansion. */
1133	unsigned int unused : 16;
1134	} vector_cst;
1135
1136	/* SSA version number. This field is only used with SSA_NAME. */
1137	unsigned int version;
1138
1139	/* CHREC_VARIABLE. This field is only used with POLYNOMIAL_CHREC. */
1140	unsigned int chrec_var;
1141
1142	/* Internal function code. */
1143	enum internal_fn ifn;
1144
1145	/* OMP_ATOMIC* memory order. */
1146	enum omp_memory_order omp_atomic_memory_order;
1147
1148	/* The following two fields are used for MEM_REF and TARGET_MEM_REF
1149	expression trees and specify known data non-dependences. For
1150	two memory references in a function they are known to not
1151	alias if dependence_info.clique are equal and dependence_info.base
1152	are distinct. Clique number zero means there is no information,
1153	clique number one is populated from function global information
1154	and thus needs no remapping on transforms like loop unrolling. */
1155	struct {
1156	unsigned short clique;
1157	unsigned short base;
1158	} dependence_info;
1159	} GTY((skip(""))) u;
1160	};
1161
1162	/* The following table lists the uses of each of the above flags and
1163	for which types of nodes they are defined.
1164
1165	addressable_flag:
1166
1167	TREE_ADDRESSABLE in
1168	VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL
1169	SSA_NAME
1170	all types
1171	CONSTRUCTOR, IDENTIFIER_NODE
1172	STMT_EXPR
1173
1174	CALL_EXPR_TAILCALL in
1175	CALL_EXPR
1176
1177	CASE_LOW_SEEN in
1178	CASE_LABEL_EXPR
1179
1180	PREDICT_EXPR_OUTCOME in
1181	PREDICT_EXPR
1182
1183	OMP_CLAUSE_MAP_DECL_MAKE_ADDRESSABLE in
1184	OMP_CLAUSE
1185
1186	static_flag:
1187
1188	TREE_STATIC in
1189	VAR_DECL, FUNCTION_DECL
1190	CONSTRUCTOR
1191
1192	TREE_NO_TRAMPOLINE in
1193	ADDR_EXPR
1194
1195	BINFO_VIRTUAL_P in
1196	TREE_BINFO
1197
1198	TREE_SYMBOL_REFERENCED in
1199	IDENTIFIER_NODE
1200
1201	CLEANUP_EH_ONLY in
1202	TARGET_EXPR, WITH_CLEANUP_EXPR
1203
1204	TRY_CATCH_IS_CLEANUP in
1205	TRY_CATCH_EXPR
1206
1207	ASM_INPUT_P in
1208	ASM_EXPR
1209
1210	TYPE_REF_CAN_ALIAS_ALL in
1211	POINTER_TYPE, REFERENCE_TYPE
1212
1213	CASE_HIGH_SEEN in
1214	CASE_LABEL_EXPR
1215
1216	ENUM_IS_SCOPED in
1217	ENUMERAL_TYPE
1218
1219	TRANSACTION_EXPR_OUTER in
1220	TRANSACTION_EXPR
1221
1222	MUST_TAIL_CALL in
1223	CALL_EXPR
1224
1225	public_flag:
1226
1227	TREE_OVERFLOW in
1228	INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
1229
1230	TREE_PUBLIC in
1231	VAR_DECL, FUNCTION_DECL
1232	IDENTIFIER_NODE
1233
1234	CONSTRUCTOR_NO_CLEARING in
1235	CONSTRUCTOR
1236
1237	ASM_VOLATILE_P in
1238	ASM_EXPR
1239
1240	CALL_EXPR_VA_ARG_PACK in
1241	CALL_EXPR
1242
1243	TYPE_CACHED_VALUES_P in
1244	all types
1245
1246	SAVE_EXPR_RESOLVED_P in
1247	SAVE_EXPR
1248
1249	OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
1250	OMP_CLAUSE_LASTPRIVATE
1251
1252	OMP_CLAUSE_PRIVATE_DEBUG in
1253	OMP_CLAUSE_PRIVATE
1254
1255	OMP_CLAUSE_LINEAR_NO_COPYIN in
1256	OMP_CLAUSE_LINEAR
1257
1258	OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION in
1259	OMP_CLAUSE_MAP
1260
1261	OMP_CLAUSE_REDUCTION_OMP_ORIG_REF in
1262	OMP_CLAUSE_{,TASK_,IN_}REDUCTION
1263
1264	OMP_CLAUSE_USE_DEVICE_PTR_IF_PRESENT in
1265	OMP_CLAUSE_USE_DEVICE_PTR
1266
1267	TRANSACTION_EXPR_RELAXED in
1268	TRANSACTION_EXPR
1269
1270	FALLTHROUGH_LABEL_P in
1271	LABEL_DECL
1272
1273	SSA_NAME_IS_VIRTUAL_OPERAND in
1274	SSA_NAME
1275
1276	EXPR_LOCATION_WRAPPER_P in
1277	NON_LVALUE_EXPR, VIEW_CONVERT_EXPR
1278
1279	private_flag:
1280
1281	TREE_PRIVATE in
1282	all decls
1283
1284	CALL_EXPR_RETURN_SLOT_OPT in
1285	CALL_EXPR
1286
1287	OMP_SECTION_LAST in
1288	OMP_SECTION
1289
1290	OMP_PARALLEL_COMBINED in
1291	OMP_PARALLEL
1292
1293	OMP_CLAUSE_PRIVATE_OUTER_REF in
1294	OMP_CLAUSE_PRIVATE
1295
1296	OMP_CLAUSE_LINEAR_NO_COPYOUT in
1297	OMP_CLAUSE_LINEAR
1298
1299	TYPE_REF_IS_RVALUE in
1300	REFERENCE_TYPE
1301
1302	ENUM_IS_OPAQUE in
1303	ENUMERAL_TYPE
1304
1305	protected_flag:
1306
1307	TREE_PROTECTED in
1308	BLOCK
1309	all decls
1310
1311	CALL_FROM_THUNK_P and
1312	CALL_ALLOCA_FOR_VAR_P and
1313	CALL_FROM_NEW_OR_DELETE_P in
1314	CALL_EXPR
1315
1316	OMP_CLAUSE_LINEAR_VARIABLE_STRIDE in
1317	OMP_CLAUSE_LINEAR
1318
1319	ASM_INLINE_P in
1320	ASM_EXPR
1321
1322	side_effects_flag:
1323
1324	TREE_SIDE_EFFECTS in
1325	all expressions
1326	all decls
1327	all constants
1328
1329	FORCED_LABEL in
1330	LABEL_DECL
1331
1332	volatile_flag:
1333
1334	TREE_THIS_VOLATILE in
1335	all expressions
1336	all decls
1337
1338	TYPE_VOLATILE in
1339	all types
1340
1341	readonly_flag:
1342
1343	TREE_READONLY in
1344	all expressions
1345	all decls
1346
1347	TYPE_READONLY in
1348	all types
1349
1350	OMP_CLAUSE_MAP_READONLY in
1351	OMP_CLAUSE_MAP
1352
1353	OMP_CLAUSE__CACHE__READONLY in
1354	OMP_CLAUSE__CACHE_
1355
1356	constant_flag:
1357
1358	TREE_CONSTANT in
1359	all expressions
1360	all decls
1361	all constants
1362
1363	TYPE_SIZES_GIMPLIFIED in
1364	all types
1365
1366	unsigned_flag:
1367
1368	TYPE_UNSIGNED in
1369	all types
1370
1371	DECL_UNSIGNED in
1372	all decls
1373
1374	asm_written_flag:
1375
1376	TREE_ASM_WRITTEN in
1377	VAR_DECL, FUNCTION_DECL, TYPE_DECL
1378	RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
1379	BLOCK, STRING_CST
1380
1381	SSA_NAME_OCCURS_IN_ABNORMAL_PHI in
1382	SSA_NAME
1383
1384	used_flag:
1385
1386	TREE_USED in
1387	all expressions
1388	all decls
1389	IDENTIFIER_NODE
1390
1391	nothrow_flag:
1392
1393	TREE_NOTHROW in
1394	CALL_EXPR
1395	FUNCTION_DECL
1396
1397	TREE_THIS_NOTRAP in
1398	INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF
1399
1400	SSA_NAME_IN_FREE_LIST in
1401	SSA_NAME
1402
1403	DECL_NONALIASED in
1404	VAR_DECL
1405
1406	CHREC_NOWRAP in
1407	POLYNOMIAL_CHREC
1408
1409	deprecated_flag:
1410
1411	TREE_DEPRECATED in
1412	all decls
1413	all types
1414
1415	IDENTIFIER_TRANSPARENT_ALIAS in
1416	IDENTIFIER_NODE
1417
1418	SSA_NAME_POINTS_TO_READONLY_MEMORY in
1419	SSA_NAME
1420
1421	unavailable_flag:
1422
1423	TREE_UNAVAILABLE in
1424	all decls
1425	all types
1426
1427	visited:
1428
1429	TREE_VISITED in
1430	all trees (used liberally by many passes)
1431
1432	saturating_flag:
1433
1434	TYPE_REVERSE_STORAGE_ORDER in
1435	RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE
1436
1437	TYPE_SATURATING in
1438	other types
1439
1440	VAR_DECL_IS_VIRTUAL_OPERAND in
1441	VAR_DECL
1442
1443	nowarning_flag:
1444
1445	TREE_NO_WARNING in
1446	all expressions
1447	all decls
1448
1449	TYPE_ARTIFICIAL in
1450	all types
1451
1452	default_def_flag:
1453
1454	TYPE_FINAL_P in
1455	RECORD_TYPE, UNION_TYPE and QUAL_UNION_TYPE
1456
1457	TYPE_VECTOR_OPAQUE in
1458	VECTOR_TYPE
1459
1460	SSA_NAME_IS_DEFAULT_DEF in
1461	SSA_NAME
1462
1463	DECL_NONLOCAL_FRAME in
1464	VAR_DECL
1465
1466	REF_REVERSE_STORAGE_ORDER in
1467	BIT_FIELD_REF, MEM_REF
1468
1469	FUNC_ADDR_BY_DESCRIPTOR in
1470	ADDR_EXPR
1471
1472	CALL_EXPR_BY_DESCRIPTOR in
1473	CALL_EXPR
1474
1475	*/
1476
1477	struct GTY(()) tree_typed {
1478	struct tree_base base;
1479	tree type;
1480	};
1481
1482	struct GTY(()) tree_common {
1483	struct tree_typed typed;
1484	tree chain;
1485	};
1486
1487	struct GTY(()) tree_int_cst {
1488	struct tree_typed typed;
1489	HOST_WIDE_INT val[1];
1490	};
1491
1492
1493	struct GTY(()) tree_real_cst {
1494	struct tree_typed typed;
1495	struct real_value value;
1496	};
1497
1498	struct GTY(()) tree_fixed_cst {
1499	struct tree_typed typed;
1500	struct fixed_value * fixed_cst_ptr;
1501	};
1502
1503	struct GTY(()) tree_string {
1504	struct tree_typed typed;
1505	int length;
1506	char str[1];
1507	};
1508
1509	struct GTY(()) tree_complex {
1510	struct tree_typed typed;
1511	tree real;
1512	tree imag;
1513	};
1514
1515	struct GTY(()) tree_vector {
1516	struct tree_typed typed;
1517	tree GTY ((length ("vector_cst_encoded_nelts ((tree) &%h)"))) elts[1];
1518	};
1519
1520	struct GTY(()) tree_poly_int_cst {
1521	struct tree_typed typed;
1522	tree coeffs[NUM_POLY_INT_COEFFS];
1523	};
1524
1525	struct GTY(()) tree_identifier {
1526	struct tree_common common;
1527	struct ht_identifier id;
1528	};
1529
1530	struct GTY(()) tree_list {
1531	struct tree_common common;
1532	tree purpose;
1533	tree value;
1534	};
1535
1536	struct GTY(()) tree_vec {
1537	struct tree_common common;
1538	tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
1539	};
1540
1541	/* A single element of a CONSTRUCTOR. VALUE holds the actual value of the
1542	element. INDEX can optionally design the position of VALUE: in arrays,
1543	it is the index where VALUE has to be placed; in structures, it is the
1544	FIELD_DECL of the member. */
1545	struct GTY(()) constructor_elt {
1546	tree index;
1547	tree value;
1548	};
1549
1550	struct GTY(()) tree_constructor {
1551	struct tree_typed typed;
1552	vec<constructor_elt, va_gc> *elts;
1553	};
1554
1555	enum omp_clause_depend_kind
1556	{
1557	OMP_CLAUSE_DEPEND_IN,
1558	OMP_CLAUSE_DEPEND_OUT,
1559	OMP_CLAUSE_DEPEND_INOUT,
1560	OMP_CLAUSE_DEPEND_MUTEXINOUTSET,
1561	OMP_CLAUSE_DEPEND_INOUTSET,
1562	OMP_CLAUSE_DEPEND_DEPOBJ,
1563	OMP_CLAUSE_DEPEND_INVALID,
1564	OMP_CLAUSE_DEPEND_LAST
1565	};
1566
1567	enum omp_clause_doacross_kind
1568	{
1569	OMP_CLAUSE_DOACROSS_SOURCE,
1570	OMP_CLAUSE_DOACROSS_SINK,
1571	OMP_CLAUSE_DOACROSS_LAST
1572	};
1573
1574	enum omp_clause_proc_bind_kind
1575	{
1576	/* Numbers should match omp_proc_bind_t enum in omp.h. */
1577	OMP_CLAUSE_PROC_BIND_FALSE = 0,
1578	OMP_CLAUSE_PROC_BIND_TRUE = 1,
1579	OMP_CLAUSE_PROC_BIND_PRIMARY = 2,
1580	OMP_CLAUSE_PROC_BIND_MASTER = 2,
1581	OMP_CLAUSE_PROC_BIND_CLOSE = 3,
1582	OMP_CLAUSE_PROC_BIND_SPREAD = 4,
1583	OMP_CLAUSE_PROC_BIND_LAST
1584	};
1585
1586	enum omp_clause_device_type_kind
1587	{
1588	OMP_CLAUSE_DEVICE_TYPE_HOST = 1,
1589	OMP_CLAUSE_DEVICE_TYPE_NOHOST = 2,
1590	OMP_CLAUSE_DEVICE_TYPE_ANY = 3
1591	};
1592
1593	enum omp_clause_linear_kind
1594	{
1595	OMP_CLAUSE_LINEAR_DEFAULT,
1596	OMP_CLAUSE_LINEAR_REF,
1597	OMP_CLAUSE_LINEAR_VAL,
1598	OMP_CLAUSE_LINEAR_UVAL
1599	};
1600
1601	struct GTY(()) tree_exp {
1602	struct tree_typed typed;
1603	location_t locus;
1604	/* Discriminator for basic conditions in a Boolean expressions. Trees that
1605	are operands of the same Boolean expression should have the same uid. */
1606	unsigned condition_uid;
1607	tree GTY ((length ("TREE_OPERAND_LENGTH ((tree)&%h)"))) operands[1];
1608	};
1609
1610	/* Immediate use linking structure. This structure is used for maintaining
1611	a doubly linked list of uses of an SSA_NAME. */
1612	struct GTY(()) ssa_use_operand_t {
1613	struct ssa_use_operand_t* GTY((skip(""))) prev;
1614	struct ssa_use_operand_t* GTY((skip(""))) next;
1615	/* Immediate uses for a given SSA name are maintained as a cyclic
1616	list. To recognize the root of this list, the location field
1617	needs to point to the original SSA name. Since statements and
1618	SSA names are of different data types, we need this union. See
1619	the explanation in struct imm_use_iterator. */
1620	union { gimple *stmt; tree ssa_name; } GTY((skip(""))) loc;
1621	tree *GTY((skip(""))) use;
1622	};
1623
1624	struct GTY(()) tree_ssa_name {
1625	struct tree_typed typed;
1626
1627	/* _DECL wrapped by this SSA name. */
1628	tree var;
1629
1630	/* Statement that defines this SSA name. */
1631	gimple *def_stmt;
1632
1633	/* Value range information. */
1634	union ssa_name_info_type {
1635	/* Range and aliasing info for pointers. */
1636	struct GTY ((tag ("0"))) ptr_info_def *ptr_info;
1637	/* Range info for everything else. */
1638	struct GTY ((tag ("1"))) vrange_storage * range_info;
1639	} GTY ((desc ("%1.typed.type ?" \
1640	"!POINTER_TYPE_P (TREE_TYPE ((tree)&%1)) : 2"))) info;
1641	/* Immediate uses list for this SSA_NAME. */
1642	struct ssa_use_operand_t imm_uses;
1643	};
1644
1645	struct GTY(()) phi_arg_d {
1646	/* imm_use MUST be the first element in struct because we do some
1647	pointer arithmetic with it. See phi_arg_index_from_use. */
1648	struct ssa_use_operand_t imm_use;
1649	tree def;
1650	location_t locus;
1651	};
1652
1653	struct GTY(()) tree_omp_clause {
1654	struct tree_common common;
1655	location_t locus;
1656	enum omp_clause_code code;
1657	union omp_clause_subcode {
1658	enum omp_clause_default_kind default_kind;
1659	enum omp_clause_schedule_kind schedule_kind;
1660	enum omp_clause_depend_kind depend_kind;
1661	enum omp_clause_doacross_kind doacross_kind;
1662	/* See include/gomp-constants.h for enum gomp_map_kind's values. */
1663	unsigned int map_kind;
1664	enum omp_clause_proc_bind_kind proc_bind_kind;
1665	enum tree_code reduction_code;
1666	enum omp_clause_linear_kind linear_kind;
1667	enum tree_code if_modifier;
1668	enum omp_clause_defaultmap_kind defaultmap_kind;
1669	enum omp_clause_bind_kind bind_kind;
1670	enum omp_clause_device_type_kind device_type_kind;
1671	} GTY ((skip)) subcode;
1672
1673	/* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's
1674	usage. */
1675	gimple_seq gimple_reduction_init;
1676	gimple_seq gimple_reduction_merge;
1677
1678	tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]")))
1679	ops[1];
1680	};
1681
1682	struct GTY(()) tree_block {
1683	struct tree_base base;
1684	tree chain;
1685
1686	unsigned block_num;
1687
1688	location_t locus;
1689	location_t end_locus;
1690
1691	tree vars;
1692	vec<tree, va_gc> *nonlocalized_vars;
1693
1694	tree subblocks;
1695	tree supercontext;
1696	tree abstract_origin;
1697	tree fragment_origin;
1698	tree fragment_chain;
1699
1700	/* Pointer to the DWARF lexical block. */
1701	struct die_struct *die;
1702	};
1703
1704	struct GTY(()) tree_type_common {
1705	struct tree_common common;
1706	tree size;
1707	tree size_unit;
1708	tree attributes;
1709	unsigned int uid;
1710
1711	ENUM_BITFIELD(machine_mode) mode : MACHINE_MODE_BITSIZE;
1712
1713	unsigned int precision : 16;
1714	unsigned lang_flag_0 : 1;
1715	unsigned lang_flag_1 : 1;
1716	unsigned lang_flag_2 : 1;
1717	unsigned lang_flag_3 : 1;
1718	unsigned lang_flag_4 : 1;
1719	unsigned lang_flag_5 : 1;
1720	unsigned lang_flag_6 : 1;
1721	unsigned lang_flag_7 : 1;
1722
1723	/* TYPE_ALIGN in log2; this has to be large enough to hold values
1724	of the maximum of BIGGEST_ALIGNMENT and MAX_OFILE_ALIGNMENT,
1725	the latter being usually the larger. For ELF it is 8<<28,
1726	so we need to store the value 32 (not 31, as we need the zero
1727	as well), hence six bits. */
1728	unsigned align : 6;
1729	/* TYPE_STRING_FLAG for INTEGER_TYPE and ARRAY_TYPE.
1730	TYPE_CXX_ODR_P for RECORD_TYPE and UNION_TYPE. */
1731	unsigned string_flag : 1;
1732	unsigned no_force_blk_flag : 1;
1733
1734	unsigned warn_if_not_align : 6;
1735	unsigned needs_constructing_flag : 1;
1736	unsigned transparent_aggr_flag : 1;
1737
1738	unsigned contains_placeholder_bits : 2;
1739	unsigned restrict_flag : 1;
1740	unsigned typeless_storage : 1;
1741	unsigned empty_flag : 1;
1742	unsigned indivisible_p : 1;
1743	/* TYPE_NO_NAMED_ARGS_STDARG_P for a stdarg function.
1744	Or TYPE_INCLUDES_FLEXARRAY for RECORD_TYPE and UNION_TYPE. */
1745	unsigned no_named_args_stdarg_p : 1;
1746	unsigned spare : 1;
1747
1748	alias_set_type alias_set;
1749	tree pointer_to;
1750	tree reference_to;
1751	union tree_type_symtab {
1752	int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address;
1753	struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die;
1754	} GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab;
1755	tree canonical;
1756	tree next_variant;
1757	tree main_variant;
1758	tree context;
1759	tree name;
1760	};
1761
1762	struct GTY(()) tree_type_with_lang_specific {
1763	struct tree_type_common common;
1764	/* Points to a structure whose details depend on the language in use. */
1765	struct lang_type *lang_specific;
1766	};
1767
1768	struct GTY(()) tree_type_non_common {
1769	struct tree_type_with_lang_specific with_lang_specific;
1770	tree values;
1771	tree minval;
1772	tree maxval;
1773	tree lang_1;
1774	};
1775
1776	struct GTY (()) tree_binfo {
1777	struct tree_common common;
1778
1779	tree offset;
1780	tree vtable;
1781	tree virtuals;
1782	tree vptr_field;
1783	vec<tree, va_gc> *base_accesses;
1784	tree inheritance;
1785
1786	tree vtt_subvtt;
1787	tree vtt_vptr;
1788
1789	vec<tree, va_gc> base_binfos;
1790	};
1791
1792	struct GTY(()) tree_decl_minimal {
1793	struct tree_common common;
1794	location_t locus;
1795	unsigned int uid;
1796	tree name;
1797	tree context;
1798	};
1799
1800	struct GTY(()) tree_decl_common {
1801	struct tree_decl_minimal common;
1802	tree size;
1803
1804	ENUM_BITFIELD(machine_mode) mode : MACHINE_MODE_BITSIZE;
1805
1806	unsigned nonlocal_flag : 1;
1807	unsigned virtual_flag : 1;
1808	unsigned ignored_flag : 1;
1809	unsigned abstract_flag : 1;
1810	unsigned artificial_flag : 1;
1811	unsigned preserve_flag: 1;
1812	unsigned debug_expr_is_from : 1;
1813
1814	unsigned lang_flag_0 : 1;
1815	unsigned lang_flag_1 : 1;
1816	unsigned lang_flag_2 : 1;
1817	unsigned lang_flag_3 : 1;
1818	unsigned lang_flag_4 : 1;
1819	unsigned lang_flag_5 : 1;
1820	unsigned lang_flag_6 : 1;
1821	unsigned lang_flag_7 : 1;
1822	unsigned lang_flag_8 : 1;
1823
1824	/* In VAR_DECL and PARM_DECL, this is DECL_REGISTER
1825	In TRANSLATION_UNIT_DECL, this is TRANSLATION_UNIT_WARN_EMPTY_P.
1826	In FIELD_DECL, this is DECL_FIELD_ABI_IGNORED. */
1827	unsigned decl_flag_0 : 1;
1828	/* In FIELD_DECL, this is DECL_BIT_FIELD
1829	In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL.
1830	In TYPE_DECL, this is TYPE_DECL_SUPPRESS_DEBUG. */
1831	unsigned decl_flag_1 : 1;
1832	/* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
1833	In VAR_DECL, PARM_DECL and RESULT_DECL, this is
1834	DECL_HAS_VALUE_EXPR_P. */
1835	unsigned decl_flag_2 : 1;
1836	/* In FIELD_DECL, this is DECL_PADDING_P.
1837	In VAR_DECL, this is DECL_MERGEABLE. */
1838	unsigned decl_flag_3 : 1;
1839	/* Logically, these two would go in a theoretical base shared by var and
1840	parm decl. */
1841	unsigned not_gimple_reg_flag : 1;
1842	/* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE. */
1843	unsigned decl_by_reference_flag : 1;
1844	/* In a VAR_DECL and PARM_DECL, this is DECL_READ_P. */
1845	unsigned decl_read_flag : 1;
1846	/* In a VAR_DECL or RESULT_DECL, this is DECL_NONSHAREABLE. */
1847	/* In a PARM_DECL, this is DECL_HIDDEN_STRING_LENGTH. */
1848	unsigned decl_nonshareable_flag : 1;
1849
1850	/* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */
1851	unsigned int off_align : 6;
1852
1853	/* DECL_ALIGN. It should have the same size as TYPE_ALIGN. */
1854	unsigned int align : 6;
1855
1856	/* DECL_WARN_IF_NOT_ALIGN. It should have the same size as
1857	TYPE_WARN_IF_NOT_ALIGN. */
1858	unsigned int warn_if_not_align : 6;
1859
1860	/* In FIELD_DECL, this is DECL_NOT_FLEXARRAY. */
1861	unsigned int decl_not_flexarray : 1;
1862
1863	/* 5 bits unused. */
1864
1865	/* UID for points-to sets, stable over copying from inlining. */
1866	unsigned int pt_uid;
1867
1868	tree size_unit;
1869	tree initial;
1870	tree attributes;
1871	tree abstract_origin;
1872
1873	/* Points to a structure whose details depend on the language in use. */
1874	struct lang_decl *lang_specific;
1875	};
1876
1877	struct GTY(()) tree_decl_with_rtl {
1878	struct tree_decl_common common;
1879	rtx rtl;
1880	};
1881
1882	struct GTY(()) tree_field_decl {
1883	struct tree_decl_common common;
1884
1885	tree offset;
1886	tree bit_field_type;
1887	tree qualifier;
1888	tree bit_offset;
1889	tree fcontext;
1890	};
1891
1892	struct GTY(()) tree_label_decl {
1893	struct tree_decl_with_rtl common;
1894	int label_decl_uid;
1895	int eh_landing_pad_nr;
1896	};
1897
1898	struct GTY(()) tree_result_decl {
1899	struct tree_decl_with_rtl common;
1900	};
1901
1902	struct GTY(()) tree_const_decl {
1903	struct tree_decl_common common;
1904	};
1905
1906	struct GTY(()) tree_parm_decl {
1907	struct tree_decl_with_rtl common;
1908	rtx incoming_rtl;
1909	};
1910
1911	struct GTY(()) tree_decl_with_vis {
1912	struct tree_decl_with_rtl common;
1913	tree assembler_name;
1914	struct symtab_node *symtab_node;
1915
1916	/* Belong to VAR_DECL exclusively. */
1917	unsigned defer_output : 1;
1918	unsigned hard_register : 1;
1919	unsigned common_flag : 1;
1920	unsigned in_text_section : 1;
1921	unsigned in_constant_pool : 1;
1922	unsigned dllimport_flag : 1;
1923	/* Don't belong to VAR_DECL exclusively. */
1924	unsigned weak_flag : 1;
1925
1926	unsigned seen_in_bind_expr : 1;
1927	unsigned comdat_flag : 1;
1928	/* Used for FUNCTION_DECL, VAR_DECL and in C++ for TYPE_DECL. */
1929	ENUM_BITFIELD(symbol_visibility) visibility : 2;
1930	unsigned visibility_specified : 1;
1931
1932	/* Belong to FUNCTION_DECL exclusively. */
1933	unsigned init_priority_p : 1;
1934	/* Used by C++ only. Might become a generic decl flag. */
1935	unsigned shadowed_for_var_p : 1;
1936	/* Belong to FUNCTION_DECL exclusively. */
1937	unsigned cxx_constructor : 1;
1938	/* Belong to FUNCTION_DECL exclusively. */
1939	unsigned cxx_destructor : 1;
1940	/* Belong to FUNCTION_DECL exclusively. */
1941	unsigned final : 1;
1942	/* Belong to FUNCTION_DECL exclusively. */
1943	unsigned regdecl_flag : 1;
1944	/* 14 unused bits. */
1945	/* 32 more unused on 64 bit HW. */
1946	};
1947
1948	struct GTY(()) tree_var_decl {
1949	struct tree_decl_with_vis common;
1950	};
1951
1952	struct GTY(()) tree_decl_non_common {
1953	struct tree_decl_with_vis common;
1954	/* Almost all FE's use this. */
1955	tree result;
1956	};
1957
1958	/* Classify a special function declaration type. */
1959
1960	enum function_decl_type
1961	{
1962	NONE,
1963	OPERATOR_NEW,
1964	OPERATOR_DELETE,
1965	LAMBDA_FUNCTION
1966
1967	/* 0 values left */
1968	};
1969
1970	/* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the
1971	arguments/result/saved_tree fields by front ends. It was either inherit
1972	FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
1973	which seemed a bit strange. */
1974
1975	struct GTY(()) tree_function_decl {
1976	struct tree_decl_non_common common;
1977
1978	struct function *f;
1979
1980	/* Arguments of the function. */
1981	tree arguments;
1982	/* The personality function. Used for stack unwinding. */
1983	tree personality;
1984
1985	/* Function specific options that are used by this function. */
1986	tree function_specific_target; /* target options */
1987	tree function_specific_optimization; /* optimization options */
1988
1989	/* Generic function body. */
1990	tree saved_tree;
1991	/* Index within a virtual table. */
1992	tree vindex;
1993
1994	/* In a FUNCTION_DECL this is DECL_UNCHECKED_FUNCTION_CODE. */
1995	unsigned int function_code;
1996
1997	ENUM_BITFIELD(built_in_class) built_in_class : 2;
1998	unsigned static_ctor_flag : 1;
1999	unsigned static_dtor_flag : 1;
2000	unsigned uninlinable : 1;
2001	unsigned possibly_inlined : 1;
2002	unsigned novops_flag : 1;
2003	unsigned returns_twice_flag : 1;
2004
2005	unsigned malloc_flag : 1;
2006	unsigned declared_inline_flag : 1;
2007	unsigned no_inline_warning_flag : 1;
2008	unsigned no_instrument_function_entry_exit : 1;
2009	unsigned no_limit_stack : 1;
2010	unsigned disregard_inline_limits : 1;
2011	unsigned pure_flag : 1;
2012	unsigned looping_const_or_pure_flag : 1;
2013
2014	/* Align the bitfield to boundary of a byte. */
2015	ENUM_BITFIELD(function_decl_type) decl_type: 2;
2016	unsigned has_debug_args_flag : 1;
2017	unsigned versioned_function : 1;
2018	unsigned replaceable_operator : 1;
2019
2020	/* 11 bits left for future expansion. */
2021	/* 32 bits on 64-bit HW. */
2022	};
2023
2024	struct GTY(()) tree_translation_unit_decl {
2025	struct tree_decl_common common;
2026	/* Source language of this translation unit. Used for DWARF output. */
2027	const char *language;
2028	/* TODO: Non-optimization used to build this translation unit. */
2029	/* TODO: Root of a partial DWARF tree for global types and decls. */
2030	};
2031
2032	struct GTY(()) tree_type_decl {
2033	struct tree_decl_non_common common;
2034
2035	};
2036
2037	struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node
2038	{
2039	struct tree_statement_list_node *prev;
2040	struct tree_statement_list_node *next;
2041	tree stmt;
2042	};
2043
2044	struct GTY(()) tree_statement_list
2045	{
2046	struct tree_typed typed;
2047	struct tree_statement_list_node *head;
2048	struct tree_statement_list_node *tail;
2049	};
2050
2051
2052	/* Optimization options used by a function. */
2053
2054	struct GTY(()) tree_optimization_option {
2055	struct tree_base base;
2056
2057	/* The optimization options used by the user. */
2058	struct cl_optimization *opts;
2059
2060	/* Target optabs for this set of optimization options. This is of
2061	type `struct target_optabs *'. */
2062	void *GTY ((atomic)) optabs;
2063
2064	/* The value of this_target_optabs against which the optabs above were
2065	generated. */
2066	struct target_optabs *GTY ((skip)) base_optabs;
2067	};
2068
2069	/* Forward declaration, defined in target-globals.h. */
2070
2071	class GTY(()) target_globals;
2072
2073	/* Target options used by a function. */
2074
2075	struct GTY(()) tree_target_option {
2076	struct tree_base base;
2077
2078	/* Target globals for the corresponding target option. */
2079	class target_globals *globals;
2080
2081	/* The optimization options used by the user. */
2082	struct cl_target_option *opts;
2083	};
2084
2085	/* Define the overall contents of a tree node.
2086	It may be any of the structures declared above
2087	for various types of node. */
2088	union GTY ((ptr_alias (union lang_tree_node),
2089	desc ("tree_node_structure (&%h)"), variable_size)) tree_node {
2090	struct tree_base GTY ((tag ("TS_BASE"))) base;
2091	struct tree_typed GTY ((tag ("TS_TYPED"))) typed;
2092	struct tree_common GTY ((tag ("TS_COMMON"))) common;
2093	struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
2094	struct tree_poly_int_cst GTY ((tag ("TS_POLY_INT_CST"))) poly_int_cst;
2095	struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
2096	struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst;
2097	struct tree_vector GTY ((tag ("TS_VECTOR"))) vector;
2098	struct tree_string GTY ((tag ("TS_STRING"))) string;
2099	struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
2100	struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
2101	struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal;
2102	struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common;
2103	struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl;
2104	struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON")))
2105	decl_non_common;
2106	struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl;
2107	struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis;
2108	struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl;
2109	struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
2110	struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl;
2111	struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl;
2112	struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl;
2113	struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl;
2114	struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl;
2115	struct tree_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL")))
2116	translation_unit_decl;
2117	struct tree_type_common GTY ((tag ("TS_TYPE_COMMON"))) type_common;
2118	struct tree_type_with_lang_specific GTY ((tag ("TS_TYPE_WITH_LANG_SPECIFIC")))
2119	type_with_lang_specific;
2120	struct tree_type_non_common GTY ((tag ("TS_TYPE_NON_COMMON")))
2121	type_non_common;
2122	struct tree_list GTY ((tag ("TS_LIST"))) list;
2123	struct tree_vec GTY ((tag ("TS_VEC"))) vec;
2124	struct tree_exp GTY ((tag ("TS_EXP"))) exp;
2125	struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
2126	struct tree_block GTY ((tag ("TS_BLOCK"))) block;
2127	struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
2128	struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
2129	struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
2130	struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
2131	struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization;
2132	struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option;
2133	};
2134
2135	/* Structure describing an attribute and a function to handle it. */
2136	struct attribute_spec {
2137	/* The name of the attribute (without any leading or trailing __),
2138	or NULL to mark the end of a table of attributes. */
2139	const char *name;
2140	/* The minimum length of the list of arguments of the attribute. */
2141	int min_length;
2142	/* The maximum length of the list of arguments of the attribute
2143	(-1 for no maximum). It can also be -2 for fake attributes
2144	created for the sake of -Wno-attributes; in that case, we
2145	should skip the balanced token sequence when parsing the attribute. */
2146	int max_length;
2147	/* Whether this attribute requires a DECL. If it does, it will be passed
2148	from types of DECLs, function return types and array element types to
2149	the DECLs, function types and array types respectively; but when
2150	applied to a type in any other circumstances, it will be ignored with
2151	a warning. (If greater control is desired for a given attribute,
2152	this should be false, and the flags argument to the handler may be
2153	used to gain greater control in that case.) */
2154	bool decl_required;
2155	/* Whether this attribute requires a type. If it does, it will be passed
2156	from a DECL to the type of that DECL. */
2157	bool type_required;
2158	/* Whether this attribute requires a function (or method) type. If it does,
2159	it will be passed from a function pointer type to the target type,
2160	and from a function return type (which is not itself a function
2161	pointer type) to the function type. */
2162	bool function_type_required;
2163	/* Specifies if attribute affects type's identity. */
2164	bool affects_type_identity;
2165	/* Function to handle this attribute. NODE points to a tree[3] array,
2166	where node[0] is the node to which the attribute is to be applied;
2167	node[1] is the last pushed/merged declaration if one exists, and node[2]
2168	may be the declaration for node[0]. If a DECL, it should be modified in
2169	place; if a TYPE, a copy should be created. NAME is the canonicalized
2170	name of the attribute i.e. without any leading or trailing underscores.
2171	ARGS is the TREE_LIST of the arguments (which may be NULL). FLAGS gives
2172	further information about the context of the attribute. Afterwards, the
2173	attributes will be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as
2174	appropriate, unless *NO_ADD_ATTRS is set to true (which should be done on
2175	error, as well as in any other cases when the attributes should not be
2176	added to the DECL or TYPE). Depending on FLAGS, any attributes to be
2177	applied to another type or DECL later may be returned;
2178	otherwise the return value should be NULL_TREE. This pointer may be
2179	NULL if no special handling is required beyond the checks implied
2180	by the rest of this structure. */
2181	tree (*handler) (tree *node, tree name, tree args,
2182	int flags, bool *no_add_attrs);
2183
2184	/* Specifies the name of an attribute that's mutually exclusive with
2185	this one, and whether the relationship applies to the function,
2186	variable, or type form of the attribute. */
2187	struct exclusions {
2188	const char *name;
2189	bool function;
2190	bool variable;
2191	bool type;
2192	};
2193
2194	/* An array of attribute exclusions describing names of other attributes
2195	that this attribute is mutually exclusive with. */
2196	const exclusions *exclude;
2197	};
2198
2199	/* These functions allow a front-end to perform a manual layout of a
2200	RECORD_TYPE. (For instance, if the placement of subsequent fields
2201	depends on the placement of fields so far.) Begin by calling
2202	start_record_layout. Then, call place_field for each of the
2203	fields. Then, call finish_record_layout. See layout_type for the
2204	default way in which these functions are used. */
2205	typedef struct record_layout_info_s {
2206	/* The RECORD_TYPE that we are laying out. */
2207	tree t;
2208	/* The offset into the record so far, in bytes, not including bits in
2209	BITPOS. */
2210	tree offset;
2211	/* The last known alignment of SIZE. */
2212	unsigned int offset_align;
2213	/* The bit position within the last OFFSET_ALIGN bits, in bits. */
2214	tree bitpos;
2215	/* The alignment of the record so far, in bits. */
2216	unsigned int record_align;
2217	/* The alignment of the record so far, ignoring #pragma pack and
2218	__attribute__ ((packed)), in bits. */
2219	unsigned int unpacked_align;
2220	/* The previous field laid out. */
2221	tree prev_field;
2222	/* The static variables (i.e., class variables, as opposed to
2223	instance variables) encountered in T. */
2224	vec<tree, va_gc> *pending_statics;
2225	/* Bits remaining in the current alignment group */
2226	int remaining_in_alignment;
2227	/* True if we've seen a packed field that didn't have normal
2228	alignment anyway. */
2229	int packed_maybe_necessary;
2230	} *record_layout_info;
2231
2232	/* Iterator for going through the function arguments. */
2233	struct function_args_iterator {
2234	tree next; /* TREE_LIST pointing to the next argument */
2235	};
2236
2237	/* Structures to map from a tree to another tree. */
2238	struct GTY(()) tree_map_base {
2239	tree from;
2240	};
2241
2242	/* Map from a tree to another tree. */
2243
2244	struct GTY((for_user)) tree_map {
2245	struct tree_map_base base;
2246	unsigned int hash;
2247	tree to;
2248	};
2249
2250	/* Map from a decl tree to another tree. */
2251	struct GTY((for_user)) tree_decl_map {
2252	struct tree_map_base base;
2253	tree to;
2254	};
2255
2256	/* Map from a tree to an int. */
2257	struct GTY((for_user)) tree_int_map {
2258	struct tree_map_base base;
2259	unsigned int to;
2260	};
2261
2262	/* Map from a decl tree to a tree vector. */
2263	struct GTY((for_user)) tree_vec_map {
2264	struct tree_map_base base;
2265	vec<tree, va_gc> *to;
2266	};
2267
2268	/* Abstract iterators for CALL_EXPRs. These static inline definitions
2269	have to go towards the end of tree.h so that union tree_node is fully
2270	defined by this point. */
2271
2272	/* Structure containing iterator state. */
2273	struct call_expr_arg_iterator {
2274	tree t; /* the call_expr */
2275	int n; /* argument count */
2276	int i; /* next argument index */
2277	};
2278
2279	struct const_call_expr_arg_iterator {
2280	const_tree t; /* the call_expr */
2281	int n; /* argument count */
2282	int i; /* next argument index */
2283	};
2284
2285	/* The builtin_info structure holds the FUNCTION_DECL of the standard builtin
2286	function, and flags. */
2287	struct GTY(()) builtin_info_type {
2288	tree decl;
2289	/* Whether the user can use <xxx> instead of explicitly using calls
2290	to __builtin_<xxx>. */
2291	unsigned implicit_p : 1;
2292	/* Whether the user has provided a declaration of <xxx>. */
2293	unsigned declared_p : 1;
2294	};
2295
2296	/* Information about a _FloatN or _FloatNx type that may be
2297	supported. */
2298	struct floatn_type_info {
2299	/* The number N in the type name. */
2300	int n;
2301	/* Whether it is an extended type _FloatNx (true) or an interchange
2302	type (false). */
2303	bool extended;
2304	};
2305
2306
2307	/*---------------------------------------------------------------------------
2308	Global variables
2309	---------------------------------------------------------------------------*/
2310	/* Matrix describing the structures contained in a given tree code. */
2311	extern bool tree_contains_struct[MAX_TREE_CODES][64];
2312
2313	/* Class of tree given its code. */
2314	#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
2315	#define END_OF_BASE_TREE_CODES tcc_exceptional,
2316
2317	#if __cpp_inline_variables < 201606L
2318	template <int N>
2319	struct tree_code_type_tmpl {
2320	static constexpr enum tree_code_class tree_code_type[] = {
2321	#include "all-tree.def"
2322	};
2323	};
2324
2325	template <int N>
2326	constexpr enum tree_code_class tree_code_type_tmpl<N>::tree_code_type[];
2327	#else
2328	constexpr inline enum tree_code_class tree_code_type[] = {
2329	#include "all-tree.def"
2330	};
2331	#endif
2332
2333	#undef DEFTREECODE
2334	#undef END_OF_BASE_TREE_CODES
2335
2336	/* Each tree code class has an associated string representation.
2337	These must correspond to the tree_code_class entries. */
2338	extern const char *const tree_code_class_strings[];
2339
2340	/* Number of argument-words in each kind of tree-node. */
2341
2342	#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
2343	#define END_OF_BASE_TREE_CODES 0,
2344
2345	#if __cpp_inline_variables < 201606L
2346	template <int N>
2347	struct tree_code_length_tmpl {
2348	static constexpr unsigned char tree_code_length[] = {
2349	#include "all-tree.def"
2350	};
2351	};
2352
2353	template <int N>
2354	constexpr unsigned char tree_code_length_tmpl<N>::tree_code_length[];
2355	#else
2356	constexpr inline unsigned char tree_code_length[] = {
2357	#include "all-tree.def"
2358	};
2359	#endif
2360
2361	#undef DEFTREECODE
2362	#undef END_OF_BASE_TREE_CODES
2363
2364	/* Vector of all alias pairs for global symbols. */
2365	extern GTY(()) vec<alias_pair, va_gc> *alias_pairs;
2366
2367	/* Names of all the built_in classes. */
2368	extern const char *const built_in_class_names[BUILT_IN_LAST];
2369
2370	/* Names of all the built_in functions. */
2371	extern const char * built_in_names[(int) END_BUILTINS];
2372
2373	/* Number of operands and names for each OMP_CLAUSE node. */
2374	extern unsigned const char omp_clause_num_ops[];
2375	extern const char * const omp_clause_code_name[];
2376	extern const char *user_omp_clause_code_name (tree, bool);
2377
2378	/* A vector of all translation-units. */
2379	extern GTY (()) vec<tree, va_gc> *all_translation_units;
2380
2381	/* Vector of standard trees used by the C compiler. */
2382	extern GTY(()) tree global_trees[TI_MAX];
2383
2384	/* The standard C integer types. Use integer_type_kind to index into
2385	this array. */
2386	extern GTY(()) tree integer_types[itk_none];
2387
2388	/* Types used to represent sizes. */
2389	extern GTY(()) tree sizetype_tab[(int) stk_type_kind_last];
2390
2391	/* Arrays for keeping track of tree node statistics. */
2392	extern uint64_t tree_node_counts[];
2393	extern uint64_t tree_node_sizes[];
2394
2395	/* True if we are in gimple form and the actions of the folders need to
2396	be restricted. False if we are not in gimple form and folding is not
2397	restricted to creating gimple expressions. */
2398	extern bool in_gimple_form;
2399
2400	/* Functional interface to the builtin functions. */
2401	extern GTY(()) builtin_info_type builtin_info[(int)END_BUILTINS];
2402
2403	/* If nonzero, an upper limit on alignment of structure fields, in bits, */
2404	extern unsigned int maximum_field_alignment;
2405
2406	/* Points to the FUNCTION_DECL of the function whose body we are reading. */
2407	extern GTY(()) tree current_function_decl;
2408
2409	/* Nonzero means a FUNC_BEGIN label was emitted. */
2410	extern GTY(()) const char * current_function_func_begin_label;
2411
2412	/* Information about the _FloatN and _FloatNx types. */
2413	extern const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES];
2414
2415	#endif // GCC_TREE_CORE_H
2416