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