gcc/tree-core.h

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