LCOV - code coverage report
Current view: top level - gcc - tree-core.h Coverage Total Hit
Test: gcc.info Lines: 100.0 % 14 14
Test Date: 2026-11-14 16:39:50 Functions: - 0 0
Legend: Lines:     hit not hit

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

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.