gcc/tree-core.h

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