gcc/tree-core.h

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