tree-core.h source code [gcc/tree-core.h]

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

source code of gcc/tree-core.h