annotate gcc/tree-core.h @ 158:494b0b89df80 default tip

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