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

Provided by KDAB

Privacy Policy
Improve your Profiling and Debugging skills
Find out more

source code of gcc/tree-core.h