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