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