gcc/tree-core.h

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