gcc/tree-core.h

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