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