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