gcc/tree-core.h

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