gcc/tree.h

   1 /* Front-end tree definitions for GNU compiler.
   2    Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #ifndef GCC_TREE_H
  23 #define GCC_TREE_H
  24
  25 #include "hashtab.h"
  26 #include "machmode.h"
  27 #include "input.h"
  28 #include "statistics.h"
  29 #include "vec.h"
  30 #include "double-int.h"
  31 #include "alias.h"
  32
  33 /* Codes of tree nodes */
  34
  35 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
  36
  37 enum tree_code {
  38 #include "tree.def"
  39
  40   LAST_AND_UNUSED_TREE_CODE     /* A convenient way to get a value for
  41                                    NUM_TREE_CODES.  */
  42 };
  43
  44 #undef DEFTREECODE
  45
  46 #define MAX_TREE_CODES 512
  47 extern unsigned char tree_contains_struct[MAX_TREE_CODES][64];
  48 #define CODE_CONTAINS_STRUCT(CODE, STRUCT) (tree_contains_struct[(CODE)][(STRUCT)])
  49
  50 /* Number of language-independent tree codes.  */
  51 #define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
  52
  53 /* Tree code classes.  */
  54
  55 /* Each tree_code has an associated code class represented by a
  56    TREE_CODE_CLASS.  */
  57
  58 enum tree_code_class {
  59   tcc_exceptional, /* An exceptional code (fits no category).  */
  60   tcc_constant,    /* A constant.  */
  61   /* Order of tcc_type and tcc_declaration is important.  */
  62   tcc_type,        /* A type object code.  */
  63   tcc_declaration, /* A declaration (also serving as variable refs).  */
  64   tcc_reference,   /* A reference to storage.  */
  65   tcc_comparison,  /* A comparison expression.  */
  66   tcc_unary,       /* A unary arithmetic expression.  */
  67   tcc_binary,      /* A binary arithmetic expression.  */
  68   tcc_statement,   /* A statement expression, which have side effects
  69                       but usually no interesting value.  */
  70   tcc_vl_exp,      /* A function call or other expression with a
  71                       variable-length operand vector.  */
  72   tcc_expression,  /* Any other expression.  */
  73   tcc_gimple_stmt  /* A GIMPLE statement.  */
  74 };
  75
  76 /* Each tree code class has an associated string representation.
  77    These must correspond to the tree_code_class entries.  */
  78
  79 extern const char *const tree_code_class_strings[];
  80
  81 /* Returns the string representing CLASS.  */
  82
  83 #define TREE_CODE_CLASS_STRING(CLASS)\
  84         tree_code_class_strings[(int) (CLASS)]
  85
  86 extern const enum tree_code_class tree_code_type[];
  87 #define TREE_CODE_CLASS(CODE)   tree_code_type[(int) (CODE)]
  88
  89 /* Nonzero if CODE represents an exceptional code.  */
  90
  91 #define EXCEPTIONAL_CLASS_P(CODE)\
  92         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_exceptional)
  93
  94 /* Nonzero if CODE represents a constant.  */
  95
  96 #define CONSTANT_CLASS_P(CODE)\
  97         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_constant)
  98
  99 /* Nonzero if CODE represents a type.  */
 100
 101 #define TYPE_P(CODE)\
 102         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_type)
 103
 104 /* Nonzero if CODE represents a declaration.  */
 105
 106 #define DECL_P(CODE)\
 107         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_declaration)
 108
 109 /* Nonzero if CODE represents a memory tag.  */
 110
 111 #define MTAG_P(CODE) \
 112   (TREE_CODE (CODE) == STRUCT_FIELD_TAG         \
 113    || TREE_CODE (CODE) == NAME_MEMORY_TAG       \
 114    || TREE_CODE (CODE) == SYMBOL_MEMORY_TAG     \
 115    || TREE_CODE (CODE) == MEMORY_PARTITION_TAG)
 116
 117
 118 /* Nonzero if DECL represents a VAR_DECL or FUNCTION_DECL.  */
 119
 120 #define VAR_OR_FUNCTION_DECL_P(DECL)\
 121   (TREE_CODE (DECL) == VAR_DECL || TREE_CODE (DECL) == FUNCTION_DECL)
 122
 123 /* Nonzero if CODE represents a INDIRECT_REF.  Keep these checks in
 124    ascending code order.  */
 125
 126 #define INDIRECT_REF_P(CODE)\
 127   (TREE_CODE (CODE) == INDIRECT_REF \
 128    || TREE_CODE (CODE) == ALIGN_INDIRECT_REF \
 129    || TREE_CODE (CODE) == MISALIGNED_INDIRECT_REF)
 130
 131 /* Nonzero if CODE represents a reference.  */
 132
 133 #define REFERENCE_CLASS_P(CODE)\
 134         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_reference)
 135
 136 /* Nonzero if CODE represents a comparison.  */
 137
 138 #define COMPARISON_CLASS_P(CODE)\
 139         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_comparison)
 140
 141 /* Nonzero if CODE represents a unary arithmetic expression.  */
 142
 143 #define UNARY_CLASS_P(CODE)\
 144         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_unary)
 145
 146 /* Nonzero if CODE represents a binary arithmetic expression.  */
 147
 148 #define BINARY_CLASS_P(CODE)\
 149         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_binary)
 150
 151 /* Nonzero if CODE represents a statement expression.  */
 152
 153 #define STATEMENT_CLASS_P(CODE)\
 154         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_statement)
 155
 156 /* Nonzero if CODE represents a function call-like expression with a
 157    variable-length operand vector.  */
 158
 159 #define VL_EXP_CLASS_P(CODE)\
 160         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_vl_exp)
 161
 162 /* Nonzero if CODE represents any other expression.  */
 163
 164 #define EXPRESSION_CLASS_P(CODE)\
 165         (TREE_CODE_CLASS (TREE_CODE (CODE)) == tcc_expression)
 166
 167 /* Returns nonzero iff CODE represents a type or declaration.  */
 168
 169 #define IS_TYPE_OR_DECL_P(CODE)\
 170         (TYPE_P (CODE) || DECL_P (CODE))
 171
 172 /* Returns nonzero iff CLASS is the tree-code class of an
 173    expression.  */
 174
 175 #define IS_EXPR_CODE_CLASS(CLASS)\
 176         ((CLASS) >= tcc_reference && (CLASS) <= tcc_expression)
 177
 178 /* Returns nonzer iff CLASS is a GIMPLE statement.  */
 179
 180 #define IS_GIMPLE_STMT_CODE_CLASS(CLASS) ((CLASS) == tcc_gimple_stmt)
 181
 182 /* Returns nonzero iff NODE is an expression of some kind.  */
 183
 184 #define EXPR_P(NODE) IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (TREE_CODE (NODE)))
 185
 186 /* Returns nonzero iff NODE is an OpenMP directive.  */
 187
 188 #define OMP_DIRECTIVE_P(NODE)                           \
 189     (TREE_CODE (NODE) == OMP_PARALLEL                   \
 190      || TREE_CODE (NODE) == OMP_FOR                     \
 191      || TREE_CODE (NODE) == OMP_SECTIONS                \
 192      || TREE_CODE (NODE) == OMP_SECTIONS_SWITCH         \
 193      || TREE_CODE (NODE) == OMP_SINGLE                  \
 194      || TREE_CODE (NODE) == OMP_SECTION                 \
 195      || TREE_CODE (NODE) == OMP_MASTER                  \
 196      || TREE_CODE (NODE) == OMP_ORDERED                 \
 197      || TREE_CODE (NODE) == OMP_CRITICAL                \
 198      || TREE_CODE (NODE) == OMP_RETURN                  \
 199      || TREE_CODE (NODE) == OMP_ATOMIC_LOAD                            \
 200      || TREE_CODE (NODE) == OMP_ATOMIC_STORE                           \
 201      || TREE_CODE (NODE) == OMP_CONTINUE)
 202
 203 /* Number of argument-words in each kind of tree-node.  */
 204
 205 extern const unsigned char tree_code_length[];
 206 #define TREE_CODE_LENGTH(CODE)  tree_code_length[(int) (CODE)]
 207
 208 /* Names of tree components.  */
 209
 210 extern const char *const tree_code_name[];
 211
 212 /* A vectors of trees.  */
 213 DEF_VEC_P(tree);
 214 DEF_VEC_ALLOC_P(tree,gc);
 215 DEF_VEC_ALLOC_P(tree,heap);
 216
 217 \f
 218 /* Classify which part of the compiler has defined a given builtin function.
 219    Note that we assume below that this is no more than two bits.  */
 220 enum built_in_class
 221 {
 222   NOT_BUILT_IN = 0,
 223   BUILT_IN_FRONTEND,
 224   BUILT_IN_MD,
 225   BUILT_IN_NORMAL
 226 };
 227
 228 /* Names for the above.  */
 229 extern const char *const built_in_class_names[4];
 230
 231 /* Codes that identify the various built in functions
 232    so that expand_call can identify them quickly.  */
 233
 234 #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM,
 235 enum built_in_function
 236 {
 237 #include "builtins.def"
 238
 239   /* Complex division routines in libgcc.  These are done via builtins
 240      because emit_library_call_value can't handle complex values.  */
 241   BUILT_IN_COMPLEX_MUL_MIN,
 242   BUILT_IN_COMPLEX_MUL_MAX
 243     = BUILT_IN_COMPLEX_MUL_MIN
 244       + MAX_MODE_COMPLEX_FLOAT
 245       - MIN_MODE_COMPLEX_FLOAT,
 246
 247   BUILT_IN_COMPLEX_DIV_MIN,
 248   BUILT_IN_COMPLEX_DIV_MAX
 249     = BUILT_IN_COMPLEX_DIV_MIN
 250       + MAX_MODE_COMPLEX_FLOAT
 251       - MIN_MODE_COMPLEX_FLOAT,
 252
 253   /* Upper bound on non-language-specific builtins.  */
 254   END_BUILTINS
 255 };
 256 #undef DEF_BUILTIN
 257
 258 /* Names for the above.  */
 259 extern const char * built_in_names[(int) END_BUILTINS];
 260
 261 /* Helper macros for math builtins.  */
 262
 263 #define BUILTIN_EXP10_P(FN) \
 264  ((FN) == BUILT_IN_EXP10 || (FN) == BUILT_IN_EXP10F || (FN) == BUILT_IN_EXP10L \
 265   || (FN) == BUILT_IN_POW10 || (FN) == BUILT_IN_POW10F || (FN) == BUILT_IN_POW10L)
 266
 267 #define BUILTIN_EXPONENT_P(FN) (BUILTIN_EXP10_P (FN) \
 268   || (FN) == BUILT_IN_EXP || (FN) == BUILT_IN_EXPF || (FN) == BUILT_IN_EXPL \
 269   || (FN) == BUILT_IN_EXP2 || (FN) == BUILT_IN_EXP2F || (FN) == BUILT_IN_EXP2L)
 270
 271 #define BUILTIN_SQRT_P(FN) \
 272  ((FN) == BUILT_IN_SQRT || (FN) == BUILT_IN_SQRTF || (FN) == BUILT_IN_SQRTL)
 273
 274 #define BUILTIN_CBRT_P(FN) \
 275  ((FN) == BUILT_IN_CBRT || (FN) == BUILT_IN_CBRTF || (FN) == BUILT_IN_CBRTL)
 276
 277 #define BUILTIN_ROOT_P(FN) (BUILTIN_SQRT_P (FN) || BUILTIN_CBRT_P (FN))
 278
 279 #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L
 280 #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R
 281 #define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL
 282
 283 /* An array of _DECL trees for the above.  */
 284 extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
 285 extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
 286 \f
 287 /* In an OMP_CLAUSE node.  */
 288
 289 /* Number of operands and names for each clause.  */
 290 extern unsigned const char omp_clause_num_ops[];
 291 extern const char * const omp_clause_code_name[];
 292
 293 /* Clause codes.  Do not reorder, as this is used to index into the tables
 294    omp_clause_num_ops and omp_clause_code_name.  */
 295 enum omp_clause_code
 296 {
 297   /* Clause zero is special-cased inside the parser
 298      (c_parser_omp_variable_list).  */
 299   OMP_CLAUSE_ERROR = 0,
 300
 301   /* OpenMP clause: private (variable_list).  */
 302   OMP_CLAUSE_PRIVATE,
 303
 304   /* OpenMP clause: shared (variable_list).  */
 305   OMP_CLAUSE_SHARED,
 306
 307   /* OpenMP clause: firstprivate (variable_list).  */
 308   OMP_CLAUSE_FIRSTPRIVATE,
 309
 310   /* OpenMP clause: lastprivate (variable_list).  */
 311   OMP_CLAUSE_LASTPRIVATE,
 312
 313   /* OpenMP clause: reduction (operator:variable_list).
 314      OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator.
 315      Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var.
 316      Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var
 317                 into the shared one.
 318      Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL
 319                 placeholder used in OMP_CLAUSE_REDUCTION_MERGE.  */
 320   OMP_CLAUSE_REDUCTION,
 321
 322   /* OpenMP clause: copyin (variable_list).  */
 323   OMP_CLAUSE_COPYIN,
 324
 325   /* OpenMP clause: copyprivate (variable_list).  */
 326   OMP_CLAUSE_COPYPRIVATE,
 327
 328   /* OpenMP clause: if (scalar-expression).  */
 329   OMP_CLAUSE_IF,
 330
 331   /* OpenMP clause: num_threads (integer-expression).  */
 332   OMP_CLAUSE_NUM_THREADS,
 333
 334   /* OpenMP clause: schedule.  */
 335   OMP_CLAUSE_SCHEDULE,
 336
 337   /* OpenMP clause: nowait.  */
 338   OMP_CLAUSE_NOWAIT,
 339
 340   /* OpenMP clause: ordered.  */
 341   OMP_CLAUSE_ORDERED,
 342
 343   /* OpenMP clause: default.  */
 344   OMP_CLAUSE_DEFAULT
 345 };
 346 \f
 347 /* The definition of tree nodes fills the next several pages.  */
 348
 349 /* A tree node can represent a data type, a variable, an expression
 350    or a statement.  Each node has a TREE_CODE which says what kind of
 351    thing it represents.  Some common codes are:
 352    INTEGER_TYPE -- represents a type of integers.
 353    ARRAY_TYPE -- represents a type of pointer.
 354    VAR_DECL -- represents a declared variable.
 355    INTEGER_CST -- represents a constant integer value.
 356    PLUS_EXPR -- represents a sum (an expression).
 357
 358    As for the contents of a tree node: there are some fields
 359    that all nodes share.  Each TREE_CODE has various special-purpose
 360    fields as well.  The fields of a node are never accessed directly,
 361    always through accessor macros.  */
 362
 363 /* Every kind of tree node starts with this structure,
 364    so all nodes have these fields.
 365
 366    See the accessor macros, defined below, for documentation of the
 367    fields.  */
 368 union tree_ann_d;
 369
 370 struct tree_base GTY(())
 371 {
 372   ENUM_BITFIELD(tree_code) code : 16;
 373
 374   unsigned side_effects_flag : 1;
 375   unsigned constant_flag : 1;
 376   unsigned addressable_flag : 1;
 377   unsigned volatile_flag : 1;
 378   unsigned readonly_flag : 1;
 379   unsigned unsigned_flag : 1;
 380   unsigned asm_written_flag: 1;
 381   unsigned nowarning_flag : 1;
 382
 383   unsigned used_flag : 1;
 384   unsigned nothrow_flag : 1;
 385   unsigned static_flag : 1;
 386   unsigned public_flag : 1;
 387   unsigned private_flag : 1;
 388   unsigned protected_flag : 1;
 389   unsigned deprecated_flag : 1;
 390   unsigned invariant_flag : 1;
 391   unsigned saturating_flag : 1;
 392
 393   unsigned lang_flag_0 : 1;
 394   unsigned lang_flag_1 : 1;
 395   unsigned lang_flag_2 : 1;
 396   unsigned lang_flag_3 : 1;
 397   unsigned lang_flag_4 : 1;
 398   unsigned lang_flag_5 : 1;
 399   unsigned lang_flag_6 : 1;
 400   unsigned visited : 1;
 401
 402   unsigned spare : 23;
 403
 404   /* FIXME tuples: Eventually, we need to move this somewhere external to
 405      the trees.  */
 406   union tree_ann_d *ann;
 407 };
 408
 409 struct tree_common GTY(())
 410 {
 411   struct tree_base base;
 412   tree chain;
 413   tree type;
 414 };
 415
 416 /* GIMPLE_MODIFY_STMT */
 417 struct gimple_stmt GTY(())
 418 {
 419   struct tree_base base;
 420   source_locus locus;
 421   tree block;
 422   /* FIXME tuples: Eventually this should be of type ``struct gimple_expr''.  */
 423   tree GTY ((length ("TREE_CODE_LENGTH (TREE_CODE (&%h))"))) operands[1];
 424 };
 425
 426 /* The following table lists the uses of each of the above flags and
 427    for which types of nodes they are defined.  Note that expressions
 428    include decls.
 429
 430    addressable_flag:
 431
 432        TREE_ADDRESSABLE in
 433            VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
 434            ..._TYPE, IDENTIFIER_NODE.
 435            In a STMT_EXPR, it means we want the result of the enclosed
 436            expression.
 437        CALL_EXPR_TAILCALL in CALL_EXPR
 438        CASE_LOW_SEEN in CASE_LABEL_EXPR
 439
 440    static_flag:
 441
 442        TREE_STATIC in
 443            VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
 444        BINFO_VIRTUAL_P in
 445            TREE_BINFO
 446        TREE_SYMBOL_REFERENCED in
 447            IDENTIFIER_NODE
 448        CLEANUP_EH_ONLY in
 449            TARGET_EXPR, WITH_CLEANUP_EXPR
 450        TRY_CATCH_IS_CLEANUP in
 451            TRY_CATCH_EXPR
 452        ASM_INPUT_P in
 453            ASM_EXPR
 454        EH_FILTER_MUST_NOT_THROW in EH_FILTER_EXPR
 455        TYPE_REF_CAN_ALIAS_ALL in
 456            POINTER_TYPE, REFERENCE_TYPE
 457        MOVE_NONTEMPORAL in
 458            GIMPLE_MODIFY_STMT
 459        CASE_HIGH_SEEN in
 460            CASE_LABEL_EXPR
 461        CALL_CANNOT_INLINE_P in
 462            CALL_EXPR
 463
 464    public_flag:
 465
 466        TREE_OVERFLOW in
 467            INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
 468        TREE_PUBLIC in
 469            VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
 470        ASM_VOLATILE_P in
 471            ASM_EXPR
 472        CALL_EXPR_VA_ARG_PACK in
 473           CALL_EXPR
 474        TYPE_CACHED_VALUES_P in
 475           ..._TYPE
 476        SAVE_EXPR_RESOLVED_P in
 477           SAVE_EXPR
 478        OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in
 479           OMP_CLAUSE_LASTPRIVATE
 480        OMP_CLAUSE_PRIVATE_DEBUG in
 481           OMP_CLAUSE_PRIVATE
 482
 483    private_flag:
 484
 485        TREE_PRIVATE in
 486            ..._DECL
 487        CALL_EXPR_RETURN_SLOT_OPT in
 488            CALL_EXPR
 489        DECL_BY_REFERENCE in
 490            PARM_DECL, RESULT_DECL
 491        OMP_RETURN_NOWAIT in
 492            OMP_RETURN
 493        OMP_SECTION_LAST in
 494            OMP_SECTION
 495        OMP_PARALLEL_COMBINED in
 496            OMP_PARALLEL
 497
 498    protected_flag:
 499
 500        TREE_PROTECTED in
 501            BLOCK
 502            ..._DECL
 503        CALL_FROM_THUNK_P in
 504            CALL_EXPR
 505
 506    side_effects_flag:
 507
 508        TREE_SIDE_EFFECTS in
 509            all expressions
 510            all decls
 511            all constants
 512
 513        FORCED_LABEL in
 514            LABEL_DECL
 515
 516    volatile_flag:
 517
 518        TREE_THIS_VOLATILE in
 519            all expressions
 520        TYPE_VOLATILE in
 521            ..._TYPE
 522
 523    readonly_flag:
 524
 525        TREE_READONLY in
 526            all expressions
 527        TYPE_READONLY in
 528            ..._TYPE
 529
 530    constant_flag:
 531
 532        TREE_CONSTANT in
 533            all expressions
 534            all decls
 535            all constants
 536        TYPE_SIZES_GIMPLIFIED
 537            ..._TYPE
 538
 539    unsigned_flag:
 540
 541        TYPE_UNSIGNED in
 542            all types
 543        DECL_UNSIGNED in
 544            all decls
 545        BIT_FIELD_REF_UNSIGNED in
 546            BIT_FIELD_REF
 547
 548    asm_written_flag:
 549
 550        TREE_ASM_WRITTEN in
 551            VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
 552            BLOCK, SSA_NAME, STRING_CST
 553
 554    used_flag:
 555
 556        TREE_USED in
 557            expressions, IDENTIFIER_NODE
 558
 559    nothrow_flag:
 560
 561        TREE_NOTHROW in
 562            CALL_EXPR, FUNCTION_DECL
 563
 564        TYPE_ALIGN_OK in
 565            ..._TYPE
 566
 567        TREE_THIS_NOTRAP in
 568           (ALIGN/MISALIGNED_)INDIRECT_REF, ARRAY_REF, ARRAY_RANGE_REF
 569
 570    deprecated_flag:
 571
 572         TREE_DEPRECATED in
 573            ..._DECL
 574
 575         IDENTIFIER_TRANSPARENT_ALIAS in
 576            IDENTIFIER_NODE
 577
 578    visited:
 579
 580         Used in tree traversals to mark visited nodes.
 581
 582    invariant_flag:
 583
 584         TREE_INVARIANT in
 585             all expressions.
 586
 587    saturating_flag:
 588
 589        TYPE_SATURATING in
 590            all types
 591
 592    nowarning_flag:
 593
 594        TREE_NO_WARNING in
 595            ... any expr or decl node
 596 */
 597 #undef DEFTREESTRUCT
 598 #define DEFTREESTRUCT(ENUM, NAME) ENUM,
 599 enum tree_node_structure_enum {
 600 #include "treestruct.def"
 601   LAST_TS_ENUM
 602 };
 603 #undef DEFTREESTRUCT
 604
 605 /* Define accessors for the fields that all tree nodes have
 606    (though some fields are not used for all kinds of nodes).  */
 607
 608 /* The tree-code says what kind of node it is.
 609    Codes are defined in tree.def.  */
 610 #define TREE_CODE(NODE) ((enum tree_code) (NODE)->base.code)
 611 #define TREE_SET_CODE(NODE, VALUE) ((NODE)->base.code = (VALUE))
 612
 613 /* When checking is enabled, errors will be generated if a tree node
 614    is accessed incorrectly. The macros die with a fatal error.  */
 615 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
 616
 617 #define TREE_CHECK(T, CODE) __extension__                               \
 618 ({  __typeof (T) const __t = (T);                                       \
 619     if (TREE_CODE (__t) != (CODE))                                      \
 620       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 621                          (CODE), 0);                                    \
 622     __t; })
 623
 624 #define TREE_NOT_CHECK(T, CODE) __extension__                           \
 625 ({  __typeof (T) const __t = (T);                                       \
 626     if (TREE_CODE (__t) == (CODE))                                      \
 627       tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,     \
 628                              (CODE), 0);                                \
 629     __t; })
 630
 631 #define TREE_CHECK2(T, CODE1, CODE2) __extension__                      \
 632 ({  __typeof (T) const __t = (T);                                       \
 633     if (TREE_CODE (__t) != (CODE1)                                      \
 634         && TREE_CODE (__t) != (CODE2))                                  \
 635       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 636                          (CODE1), (CODE2), 0);                          \
 637     __t; })
 638
 639 #define TREE_NOT_CHECK2(T, CODE1, CODE2) __extension__                  \
 640 ({  __typeof (T) const __t = (T);                                       \
 641     if (TREE_CODE (__t) == (CODE1)                                      \
 642         || TREE_CODE (__t) == (CODE2))                                  \
 643       tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,     \
 644                              (CODE1), (CODE2), 0);                      \
 645     __t; })
 646
 647 #define TREE_CHECK3(T, CODE1, CODE2, CODE3) __extension__               \
 648 ({  __typeof (T) const __t = (T);                                       \
 649     if (TREE_CODE (__t) != (CODE1)                                      \
 650         && TREE_CODE (__t) != (CODE2)                                   \
 651         && TREE_CODE (__t) != (CODE3))                                  \
 652       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 653                              (CODE1), (CODE2), (CODE3), 0);             \
 654     __t; })
 655
 656 #define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) __extension__           \
 657 ({  __typeof (T) const __t = (T);                                       \
 658     if (TREE_CODE (__t) == (CODE1)                                      \
 659         || TREE_CODE (__t) == (CODE2)                                   \
 660         || TREE_CODE (__t) == (CODE3))                                  \
 661       tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,     \
 662                              (CODE1), (CODE2), (CODE3), 0);             \
 663     __t; })
 664
 665 #define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__        \
 666 ({  __typeof (T) const __t = (T);                                       \
 667     if (TREE_CODE (__t) != (CODE1)                                      \
 668         && TREE_CODE (__t) != (CODE2)                                   \
 669         && TREE_CODE (__t) != (CODE3)                                   \
 670         && TREE_CODE (__t) != (CODE4))                                  \
 671       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 672                              (CODE1), (CODE2), (CODE3), (CODE4), 0);    \
 673     __t; })
 674
 675 #define NON_TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) __extension__    \
 676 ({  __typeof (T) const __t = (T);                                       \
 677     if (TREE_CODE (__t) == (CODE1)                                      \
 678         || TREE_CODE (__t) == (CODE2)                                   \
 679         || TREE_CODE (__t) == (CODE3)                                   \
 680         || TREE_CODE (__t) == (CODE4))                                  \
 681       tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,     \
 682                              (CODE1), (CODE2), (CODE3), (CODE4), 0);    \
 683     __t; })
 684
 685 #define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
 686 ({  __typeof (T) const __t = (T);                                       \
 687     if (TREE_CODE (__t) != (CODE1)                                      \
 688         && TREE_CODE (__t) != (CODE2)                                   \
 689         && TREE_CODE (__t) != (CODE3)                                   \
 690         && TREE_CODE (__t) != (CODE4)                                   \
 691         && TREE_CODE (__t) != (CODE5))                                  \
 692       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 693                              (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
 694     __t; })
 695
 696 #define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) __extension__ \
 697 ({  __typeof (T) const __t = (T);                                       \
 698     if (TREE_CODE (__t) == (CODE1)                                      \
 699         || TREE_CODE (__t) == (CODE2)                                   \
 700         || TREE_CODE (__t) == (CODE3)                                   \
 701         || TREE_CODE (__t) == (CODE4)                                   \
 702         || TREE_CODE (__t) == (CODE5))                                  \
 703       tree_not_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,     \
 704                              (CODE1), (CODE2), (CODE3), (CODE4), (CODE5), 0);\
 705     __t; })
 706
 707 #define CONTAINS_STRUCT_CHECK(T, STRUCT) __extension__                  \
 708 ({  __typeof (T) const __t = (T);                                       \
 709   if (tree_contains_struct[TREE_CODE(__t)][(STRUCT)] != 1)              \
 710       tree_contains_struct_check_failed (__t, (STRUCT), __FILE__, __LINE__,     \
 711                                __FUNCTION__);                           \
 712     __t; })
 713
 714 #define TREE_CLASS_CHECK(T, CLASS) __extension__                        \
 715 ({  __typeof (T) const __t = (T);                                       \
 716     if (TREE_CODE_CLASS (TREE_CODE(__t)) != (CLASS))                    \
 717       tree_class_check_failed (__t, (CLASS), __FILE__, __LINE__,        \
 718                                __FUNCTION__);                           \
 719     __t; })
 720
 721 #define TREE_RANGE_CHECK(T, CODE1, CODE2) __extension__                 \
 722 ({  __typeof (T) const __t = (T);                                       \
 723     if (TREE_CODE (__t) < (CODE1) || TREE_CODE (__t) > (CODE2))         \
 724       tree_range_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,   \
 725                                (CODE1), (CODE2));                       \
 726     __t; })
 727
 728 #define OMP_CLAUSE_SUBCODE_CHECK(T, CODE) __extension__                 \
 729 ({  __typeof (T) const __t = (T);                                       \
 730     if (TREE_CODE (__t) != OMP_CLAUSE)                                  \
 731       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 732                          OMP_CLAUSE, 0);                                \
 733     if (__t->omp_clause.code != (CODE))                                 \
 734       omp_clause_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,   \
 735                                (CODE));                                 \
 736     __t; })
 737
 738 #define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) __extension__           \
 739 ({  __typeof (T) const __t = (T);                                       \
 740     if (TREE_CODE (__t) != OMP_CLAUSE)                                  \
 741       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 742                          OMP_CLAUSE, 0);                                \
 743     if ((int) __t->omp_clause.code < (int) (CODE1)                      \
 744         || (int) __t->omp_clause.code > (int) (CODE2))                  \
 745       omp_clause_range_check_failed (__t, __FILE__, __LINE__,           \
 746                                      __FUNCTION__, (CODE1), (CODE2));   \
 747     __t; })
 748
 749 /* These checks have to be special cased.  */
 750 #define EXPR_CHECK(T) __extension__                                     \
 751 ({  __typeof (T) const __t = (T);                                       \
 752     char const __c = TREE_CODE_CLASS (TREE_CODE (__t));                 \
 753     if (!IS_EXPR_CODE_CLASS (__c))                                      \
 754       tree_class_check_failed (__t, tcc_expression, __FILE__, __LINE__, \
 755                                __FUNCTION__);                           \
 756     __t; })
 757
 758 #define GIMPLE_STMT_CHECK(T) __extension__                              \
 759 ({  __typeof (T) const __t = (T);                                       \
 760     char const __c = TREE_CODE_CLASS (TREE_CODE (__t));                 \
 761     if (!IS_GIMPLE_STMT_CODE_CLASS (__c))                               \
 762       tree_class_check_failed (__t, tcc_gimple_stmt, __FILE__, __LINE__,\
 763                                __FUNCTION__);                           \
 764     __t; })
 765
 766 /* These checks have to be special cased.  */
 767 #define NON_TYPE_CHECK(T) __extension__                                 \
 768 ({  __typeof (T) const __t = (T);                                       \
 769     if (TYPE_P (__t))                                                   \
 770       tree_not_class_check_failed (__t, tcc_type, __FILE__, __LINE__,   \
 771                                    __FUNCTION__);                       \
 772     __t; })
 773
 774 #define TREE_VEC_ELT_CHECK(T, I) __extension__                          \
 775 (*({__typeof (T) const __t = (T);                                       \
 776     const int __i = (I);                                                \
 777     if (TREE_CODE (__t) != TREE_VEC)                                    \
 778       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 779                          TREE_VEC, 0);                                  \
 780     if (__i < 0 || __i >= __t->vec.length)                              \
 781       tree_vec_elt_check_failed (__i, __t->vec.length,                  \
 782                                  __FILE__, __LINE__, __FUNCTION__);     \
 783     &__t->vec.a[__i]; }))
 784
 785 #define PHI_NODE_ELT_CHECK(T, I) __extension__                          \
 786 (*({__typeof (T) const __t = (T);                                       \
 787     const int __i = (I);                                                \
 788     if (TREE_CODE (__t) != PHI_NODE)                                    \
 789       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 790                          PHI_NODE, 0);                                  \
 791     if (__i < 0 || __i >= __t->phi.capacity)                            \
 792       phi_node_elt_check_failed (__i, __t->phi.num_args,                \
 793                                  __FILE__, __LINE__, __FUNCTION__);     \
 794     &__t->phi.a[__i]; }))
 795
 796 #define OMP_CLAUSE_ELT_CHECK(T, I) __extension__                        \
 797 (*({__typeof (T) const __t = (T);                                               \
 798     const int __i = (I);                                                \
 799     if (TREE_CODE (__t) != OMP_CLAUSE)                                  \
 800       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__,         \
 801                          OMP_CLAUSE, 0);                                \
 802     if (__i < 0 || __i >= omp_clause_num_ops [__t->omp_clause.code])    \
 803       omp_clause_operand_check_failed (__i, __t, __FILE__, __LINE__,    \
 804                                        __FUNCTION__);                   \
 805     &__t->omp_clause.ops[__i]; }))
 806
 807 /* Special checks for TREE_OPERANDs.  */
 808 #define TREE_OPERAND_CHECK(T, I) __extension__                          \
 809 (*({__typeof (T) const __t = EXPR_CHECK (T);                            \
 810     const int __i = (I);                                                \
 811     if (GIMPLE_TUPLE_P (__t))                                           \
 812       gcc_unreachable ();                                               \
 813     if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))                    \
 814       tree_operand_check_failed (__i, __t,                              \
 815                                  __FILE__, __LINE__, __FUNCTION__);     \
 816     &__t->exp.operands[__i]; }))
 817
 818 #define TREE_OPERAND_CHECK_CODE(T, CODE, I) __extension__               \
 819 (*({__typeof (T) const __t = (T);                                       \
 820     const int __i = (I);                                                \
 821     if (TREE_CODE (__t) != CODE)                                        \
 822       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0);\
 823     if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))                    \
 824       tree_operand_check_failed (__i, __t,                              \
 825                                  __FILE__, __LINE__, __FUNCTION__);     \
 826     &__t->exp.operands[__i]; }))
 827
 828 /* Special checks for GIMPLE_STMT_OPERANDs.  */
 829 #define GIMPLE_STMT_OPERAND_CHECK(T, I) __extension__                   \
 830 (*({__typeof (T) const __t = GIMPLE_STMT_CHECK (T);                     \
 831     const int __i = (I);                                                \
 832     if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))                    \
 833       tree_operand_check_failed (__i, __t,                              \
 834                                  __FILE__, __LINE__, __FUNCTION__);     \
 835     &__t->gstmt.operands[__i]; }))
 836
 837 #define TREE_RTL_OPERAND_CHECK(T, CODE, I) __extension__                \
 838 (*(rtx *)                                                               \
 839  ({__typeof (T) const __t = (T);                                        \
 840     const int __i = (I);                                                \
 841     if (TREE_CODE (__t) != (CODE))                                      \
 842       tree_check_failed (__t, __FILE__, __LINE__, __FUNCTION__, (CODE), 0); \
 843     if (__i < 0 || __i >= TREE_OPERAND_LENGTH (__t))                    \
 844       tree_operand_check_failed (__i, __t,                              \
 845                                  __FILE__, __LINE__, __FUNCTION__);     \
 846     &__t->exp.operands[__i]; }))
 847
 848 /* Nodes are chained together for many purposes.
 849    Types are chained together to record them for being output to the debugger
 850    (see the function `chain_type').
 851    Decls in the same scope are chained together to record the contents
 852    of the scope.
 853    Statement nodes for successive statements used to be chained together.
 854    Often lists of things are represented by TREE_LIST nodes that
 855    are chained together.  */
 856
 857 #define TREE_CHAIN(NODE) __extension__ \
 858 (*({__typeof (NODE) const __t = (NODE);                         \
 859     if (GIMPLE_TUPLE_P (__t))                                   \
 860       gcc_unreachable ();                                       \
 861     &__t->common.chain; }))
 862
 863 /* In all nodes that are expressions, this is the data type of the expression.
 864    In POINTER_TYPE nodes, this is the type that the pointer points to.
 865    In ARRAY_TYPE nodes, this is the type of the elements.
 866    In VECTOR_TYPE nodes, this is the type of the elements.  */
 867 #define TREE_TYPE(NODE) __extension__ \
 868 (*({__typeof (NODE) const __t = (NODE);                                 \
 869     if (GIMPLE_TUPLE_P (__t))                                   \
 870       gcc_unreachable ();                                       \
 871     &__t->common.type; }))
 872
 873 extern void tree_contains_struct_check_failed (const_tree,
 874                                                const enum tree_node_structure_enum,
 875                                                const char *, int, const char *)
 876   ATTRIBUTE_NORETURN;
 877
 878 extern void tree_check_failed (const_tree, const char *, int, const char *,
 879                                ...) ATTRIBUTE_NORETURN;
 880 extern void tree_not_check_failed (const_tree, const char *, int, const char *,
 881                                    ...) ATTRIBUTE_NORETURN;
 882 extern void tree_class_check_failed (const_tree, const enum tree_code_class,
 883                                      const char *, int, const char *)
 884     ATTRIBUTE_NORETURN;
 885 extern void tree_range_check_failed (const_tree, const char *, int,
 886                                      const char *, enum tree_code,
 887                                      enum tree_code);
 888 extern void tree_not_class_check_failed (const_tree,
 889                                          const enum tree_code_class,
 890                                          const char *, int, const char *)
 891     ATTRIBUTE_NORETURN;
 892 extern void tree_vec_elt_check_failed (int, int, const char *,
 893                                        int, const char *)
 894     ATTRIBUTE_NORETURN;
 895 extern void phi_node_elt_check_failed (int, int, const char *,
 896                                        int, const char *)
 897     ATTRIBUTE_NORETURN;
 898 extern void tree_operand_check_failed (int, const_tree,
 899                                        const char *, int, const char *)
 900     ATTRIBUTE_NORETURN;
 901 extern void omp_clause_check_failed (const_tree, const char *, int,
 902                                      const char *, enum omp_clause_code)
 903     ATTRIBUTE_NORETURN;
 904 extern void omp_clause_operand_check_failed (int, const_tree, const char *,
 905                                              int, const char *)
 906     ATTRIBUTE_NORETURN;
 907 extern void omp_clause_range_check_failed (const_tree, const char *, int,
 908                                const char *, enum omp_clause_code,
 909                                enum omp_clause_code)
 910     ATTRIBUTE_NORETURN;
 911
 912 #else /* not ENABLE_TREE_CHECKING, or not gcc */
 913
 914 #define CONTAINS_STRUCT_CHECK(T, ENUM)          (T)
 915 #define TREE_CHECK(T, CODE)                     (T)
 916 #define TREE_NOT_CHECK(T, CODE)                 (T)
 917 #define TREE_CHECK2(T, CODE1, CODE2)            (T)
 918 #define TREE_NOT_CHECK2(T, CODE1, CODE2)        (T)
 919 #define TREE_CHECK3(T, CODE1, CODE2, CODE3)     (T)
 920 #define TREE_NOT_CHECK3(T, CODE1, CODE2, CODE3) (T)
 921 #define TREE_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
 922 #define TREE_NOT_CHECK4(T, CODE1, CODE2, CODE3, CODE4) (T)
 923 #define TREE_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
 924 #define TREE_NOT_CHECK5(T, CODE1, CODE2, CODE3, CODE4, CODE5) (T)
 925 #define TREE_CLASS_CHECK(T, CODE)               (T)
 926 #define TREE_RANGE_CHECK(T, CODE1, CODE2)       (T)
 927 #define EXPR_CHECK(T)                           (T)
 928 #define GIMPLE_STMT_CHECK(T)                    (T)
 929 #define NON_TYPE_CHECK(T)                       (T)
 930 #define TREE_VEC_ELT_CHECK(T, I)                ((T)->vec.a[I])
 931 #define TREE_OPERAND_CHECK(T, I)                ((T)->exp.operands[I])
 932 #define TREE_OPERAND_CHECK_CODE(T, CODE, I)     ((T)->exp.operands[I])
 933 #define GIMPLE_STMT_OPERAND_CHECK(T, I)         ((T)->gstmt.operands[I])
 934 #define TREE_RTL_OPERAND_CHECK(T, CODE, I)  (*(rtx *) &((T)->exp.operands[I]))
 935 #define PHI_NODE_ELT_CHECK(T, i)        ((T)->phi.a[i])
 936 #define OMP_CLAUSE_ELT_CHECK(T, i)              ((T)->omp_clause.ops[i])
 937 #define OMP_CLAUSE_RANGE_CHECK(T, CODE1, CODE2) (T)
 938 #define OMP_CLAUSE_SUBCODE_CHECK(T, CODE)       (T)
 939
 940 #define TREE_CHAIN(NODE) ((NODE)->common.chain)
 941 #define TREE_TYPE(NODE) ((NODE)->common.type)
 942
 943 #endif
 944
 945 #define TREE_BLOCK(NODE)                *(tree_block (NODE))
 946
 947 #include "tree-check.h"
 948
 949 #define TYPE_CHECK(T)           TREE_CLASS_CHECK (T, tcc_type)
 950 #define DECL_MINIMAL_CHECK(T)   CONTAINS_STRUCT_CHECK (T, TS_DECL_MINIMAL)
 951 #define TREE_MEMORY_TAG_CHECK(T)       CONTAINS_STRUCT_CHECK (T, TS_MEMORY_TAG)
 952 #define DECL_COMMON_CHECK(T)    CONTAINS_STRUCT_CHECK (T, TS_DECL_COMMON)
 953 #define DECL_WRTL_CHECK(T)      CONTAINS_STRUCT_CHECK (T, TS_DECL_WRTL)
 954 #define DECL_WITH_VIS_CHECK(T)  CONTAINS_STRUCT_CHECK (T, TS_DECL_WITH_VIS)
 955 #define DECL_NON_COMMON_CHECK(T) CONTAINS_STRUCT_CHECK (T, TS_DECL_NON_COMMON)
 956 #define CST_CHECK(T)            TREE_CLASS_CHECK (T, tcc_constant)
 957 #define STMT_CHECK(T)           TREE_CLASS_CHECK (T, tcc_statement)
 958 #define VL_EXP_CHECK(T)         TREE_CLASS_CHECK (T, tcc_vl_exp)
 959 #define FUNC_OR_METHOD_CHECK(T) TREE_CHECK2 (T, FUNCTION_TYPE, METHOD_TYPE)
 960 #define PTR_OR_REF_CHECK(T)     TREE_CHECK2 (T, POINTER_TYPE, REFERENCE_TYPE)
 961
 962 #define RECORD_OR_UNION_CHECK(T)        \
 963   TREE_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
 964 #define NOT_RECORD_OR_UNION_CHECK(T) \
 965   TREE_NOT_CHECK3 (T, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE)
 966
 967 #define NUMERICAL_TYPE_CHECK(T)                                 \
 968   TREE_CHECK5 (T, INTEGER_TYPE, ENUMERAL_TYPE, BOOLEAN_TYPE, REAL_TYPE, \
 969                FIXED_POINT_TYPE)
 970
 971 /* Nonzero if NODE is a GIMPLE statement.  */
 972 #define GIMPLE_STMT_P(NODE) \
 973   (TREE_CODE_CLASS (TREE_CODE ((NODE))) == tcc_gimple_stmt)
 974
 975 /* Nonzero if NODE is a GIMPLE tuple.  */
 976 #define GIMPLE_TUPLE_P(NODE) (GIMPLE_STMT_P (NODE) || TREE_CODE (NODE) == PHI_NODE)
 977
 978 /* A GIMPLE tuple that has a ``locus'' field.  */
 979 #define GIMPLE_TUPLE_HAS_LOCUS_P(NODE) GIMPLE_STMT_P ((NODE))
 980
 981 /* Like TREE_OPERAND but works with GIMPLE stmt tuples as well.
 982
 983    If you know the NODE is a GIMPLE statement, use GIMPLE_STMT_OPERAND.  If the
 984    NODE code is unknown at compile time, use this macro.  */
 985 #define GENERIC_TREE_OPERAND(NODE, I) *(generic_tree_operand ((NODE), (I)))
 986
 987 /* Like TREE_TYPE but returns void_type_node for gimple tuples that have
 988    no type.  */
 989
 990 #define GENERIC_TREE_TYPE(NODE) *(generic_tree_type ((NODE)))
 991
 992 /* Here is how primitive or already-canonicalized types' hash codes
 993    are made.  */
 994 #define TYPE_HASH(TYPE) (TYPE_UID (TYPE))
 995
 996 /* A simple hash function for an arbitrary tree node.  This must not be
 997    used in hash tables which are saved to a PCH.  */
 998 #define TREE_HASH(NODE) ((size_t) (NODE) & 0777777)
 999
1000 /* The TREE_CHAIN but it is able to handle tuples.  */
1001 #define GENERIC_NEXT(NODE)                                      \
1002   (TREE_CODE (NODE) == PHI_NODE ? PHI_CHAIN (NODE) :            \
1003      GIMPLE_STMT_P (NODE) ? NULL_TREE : TREE_CHAIN (NODE))
1004
1005 /* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
1006    that don't change the machine mode.  */
1007
1008 #define STRIP_NOPS(EXP)                                         \
1009   while ((TREE_CODE (EXP) == NOP_EXPR                           \
1010           || TREE_CODE (EXP) == CONVERT_EXPR                    \
1011           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
1012          && TREE_OPERAND (EXP, 0) != error_mark_node            \
1013          && (TYPE_MODE (TREE_TYPE (EXP))                        \
1014              == TYPE_MODE (GENERIC_TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
1015     (EXP) = TREE_OPERAND (EXP, 0)
1016
1017 /* Like STRIP_NOPS, but don't let the signedness change either.  */
1018
1019 #define STRIP_SIGN_NOPS(EXP) \
1020   while ((TREE_CODE (EXP) == NOP_EXPR                           \
1021           || TREE_CODE (EXP) == CONVERT_EXPR                    \
1022           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
1023          && TREE_OPERAND (EXP, 0) != error_mark_node            \
1024          && (TYPE_MODE (TREE_TYPE (EXP))                        \
1025              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))  \
1026          && (TYPE_UNSIGNED (TREE_TYPE (EXP))                    \
1027              == TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0)))) \
1028          && (POINTER_TYPE_P (TREE_TYPE (EXP))                   \
1029              == POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
1030     (EXP) = TREE_OPERAND (EXP, 0)
1031
1032 /* Like STRIP_NOPS, but don't alter the TREE_TYPE either.  */
1033
1034 #define STRIP_TYPE_NOPS(EXP) \
1035   while ((TREE_CODE (EXP) == NOP_EXPR                           \
1036           || TREE_CODE (EXP) == CONVERT_EXPR                    \
1037           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
1038          && TREE_OPERAND (EXP, 0) != error_mark_node            \
1039          && (TREE_TYPE (EXP)                                    \
1040              == TREE_TYPE (TREE_OPERAND (EXP, 0))))             \
1041     (EXP) = TREE_OPERAND (EXP, 0)
1042
1043 /* Remove unnecessary type conversions according to
1044    tree_ssa_useless_type_conversion.  */
1045
1046 #define STRIP_USELESS_TYPE_CONVERSION(EXP)                              \
1047       while (tree_ssa_useless_type_conversion (EXP))                    \
1048         EXP = TREE_OPERAND (EXP, 0)
1049
1050 /* Nonzero if TYPE represents an integral type.  Note that we do not
1051    include COMPLEX types here.  Keep these checks in ascending code
1052    order.  */
1053
1054 #define INTEGRAL_TYPE_P(TYPE)  \
1055   (TREE_CODE (TYPE) == ENUMERAL_TYPE  \
1056    || TREE_CODE (TYPE) == BOOLEAN_TYPE \
1057    || TREE_CODE (TYPE) == INTEGER_TYPE)
1058
1059 /* Nonzero if TYPE represents a non-saturating fixed-point type.  */
1060
1061 #define NON_SAT_FIXED_POINT_TYPE_P(TYPE) \
1062   (TREE_CODE (TYPE) == FIXED_POINT_TYPE && !TYPE_SATURATING (TYPE))
1063
1064 /* Nonzero if TYPE represents a saturating fixed-point type.  */
1065
1066 #define SAT_FIXED_POINT_TYPE_P(TYPE) \
1067   (TREE_CODE (TYPE) == FIXED_POINT_TYPE && TYPE_SATURATING (TYPE))
1068
1069 /* Nonzero if TYPE represents a fixed-point type.  */
1070
1071 #define FIXED_POINT_TYPE_P(TYPE)        (TREE_CODE (TYPE) == FIXED_POINT_TYPE)
1072
1073 /* Nonzero if TYPE represents a scalar floating-point type.  */
1074
1075 #define SCALAR_FLOAT_TYPE_P(TYPE) (TREE_CODE (TYPE) == REAL_TYPE)
1076
1077 /* Nonzero if TYPE represents a complex floating-point type.  */
1078
1079 #define COMPLEX_FLOAT_TYPE_P(TYPE)      \
1080   (TREE_CODE (TYPE) == COMPLEX_TYPE     \
1081    && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
1082
1083 /* Nonzero if TYPE represents a vector floating-point type.  */
1084
1085 #define VECTOR_FLOAT_TYPE_P(TYPE)       \
1086   (TREE_CODE (TYPE) == VECTOR_TYPE      \
1087    && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE)
1088
1089 /* Nonzero if TYPE represents a floating-point type, including complex
1090    and vector floating-point types.  The vector and complex check does
1091    not use the previous two macros to enable early folding.  */
1092
1093 #define FLOAT_TYPE_P(TYPE)                      \
1094   (SCALAR_FLOAT_TYPE_P (TYPE)                   \
1095    || ((TREE_CODE (TYPE) == COMPLEX_TYPE        \
1096         || TREE_CODE (TYPE) == VECTOR_TYPE)     \
1097        && SCALAR_FLOAT_TYPE_P (TREE_TYPE (TYPE))))
1098
1099 /* Nonzero if TYPE represents a decimal floating-point type.  */
1100 #define DECIMAL_FLOAT_TYPE_P(TYPE)              \
1101   (SCALAR_FLOAT_TYPE_P (TYPE)                   \
1102    && DECIMAL_FLOAT_MODE_P (TYPE_MODE (TYPE)))
1103
1104 /* Nonzero if TYPE represents an aggregate (multi-component) type.
1105    Keep these checks in ascending code order.  */
1106
1107 #define AGGREGATE_TYPE_P(TYPE) \
1108   (TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
1109    || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE)
1110
1111 /* Nonzero if TYPE represents a pointer or reference type.
1112    (It should be renamed to INDIRECT_TYPE_P.)  Keep these checks in
1113    ascending code order.  */
1114
1115 #define POINTER_TYPE_P(TYPE) \
1116   (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
1117
1118 /* Nonzero if this type is a complete type.  */
1119 #define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
1120
1121 /* Nonzero if this type is the (possibly qualified) void type.  */
1122 #define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)
1123
1124 /* Nonzero if this type is complete or is cv void.  */
1125 #define COMPLETE_OR_VOID_TYPE_P(NODE) \
1126   (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
1127
1128 /* Nonzero if this type is complete or is an array with unspecified bound.  */
1129 #define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
1130   (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
1131
1132 \f
1133 /* Define many boolean fields that all tree nodes have.  */
1134
1135 /* In VAR_DECL nodes, nonzero means address of this is needed.
1136    So it cannot be in a register.
1137    In a FUNCTION_DECL, nonzero means its address is needed.
1138    So it must be compiled even if it is an inline function.
1139    In a FIELD_DECL node, it means that the programmer is permitted to
1140    construct the address of this field.  This is used for aliasing
1141    purposes: see record_component_aliases.
1142    In CONSTRUCTOR nodes, it means object constructed must be in memory.
1143    In LABEL_DECL nodes, it means a goto for this label has been seen
1144    from a place outside all binding contours that restore stack levels.
1145    In ..._TYPE nodes, it means that objects of this type must
1146    be fully addressable.  This means that pieces of this
1147    object cannot go into register parameters, for example.
1148    In IDENTIFIER_NODEs, this means that some extern decl for this name
1149    had its address taken.  That matters for inline functions.  */
1150 #define TREE_ADDRESSABLE(NODE) ((NODE)->base.addressable_flag)
1151
1152 /* Set on a CALL_EXPR if the call is in a tail position, ie. just before the
1153    exit of a function.  Calls for which this is true are candidates for tail
1154    call optimizations.  */
1155 #define CALL_EXPR_TAILCALL(NODE) \
1156   (CALL_EXPR_CHECK(NODE)->base.addressable_flag)
1157
1158 /* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
1159    CASE_LOW operand has been processed.  */
1160 #define CASE_LOW_SEEN(NODE) \
1161   (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
1162
1163 /* In a VAR_DECL, nonzero means allocate static storage.
1164    In a FUNCTION_DECL, nonzero if function has been defined.
1165    In a CONSTRUCTOR, nonzero means allocate static storage.
1166
1167    ??? This is also used in lots of other nodes in unclear ways which
1168    should be cleaned up some day.  */
1169 #define TREE_STATIC(NODE) ((NODE)->base.static_flag)
1170
1171 /* In a TARGET_EXPR or WITH_CLEANUP_EXPR, means that the pertinent cleanup
1172    should only be executed if an exception is thrown, not on normal exit
1173    of its scope.  */
1174 #define CLEANUP_EH_ONLY(NODE) ((NODE)->base.static_flag)
1175
1176 /* In a TRY_CATCH_EXPR, means that the handler should be considered a
1177    separate cleanup in honor_protect_cleanup_actions.  */
1178 #define TRY_CATCH_IS_CLEANUP(NODE) \
1179   (TRY_CATCH_EXPR_CHECK (NODE)->base.static_flag)
1180
1181 /* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
1182    CASE_HIGH operand has been processed.  */
1183 #define CASE_HIGH_SEEN(NODE) \
1184   (CASE_LABEL_EXPR_CHECK (NODE)->base.static_flag)
1185
1186 /* Used to mark a CALL_EXPR as not suitable for inlining.  */
1187 #define CALL_CANNOT_INLINE_P(NODE) ((NODE)->base.static_flag)
1188
1189 /* In an expr node (usually a conversion) this means the node was made
1190    implicitly and should not lead to any sort of warning.  In a decl node,
1191    warnings concerning the decl should be suppressed.  This is used at
1192    least for used-before-set warnings, and it set after one warning is
1193    emitted.  */
1194 #define TREE_NO_WARNING(NODE) ((NODE)->base.nowarning_flag)
1195
1196 /* In an IDENTIFIER_NODE, this means that assemble_name was called with
1197    this string as an argument.  */
1198 #define TREE_SYMBOL_REFERENCED(NODE) \
1199   (IDENTIFIER_NODE_CHECK (NODE)->base.static_flag)
1200
1201 /* Nonzero in a pointer or reference type means the data pointed to
1202    by this type can alias anything.  */
1203 #define TYPE_REF_CAN_ALIAS_ALL(NODE) \
1204   (PTR_OR_REF_CHECK (NODE)->base.static_flag)
1205
1206 /* In a MODIFY_EXPR, means that the store in the expression is nontemporal.  */
1207 #define MOVE_NONTEMPORAL(NODE) \
1208   (GIMPLE_MODIFY_STMT_CHECK (NODE)->base.static_flag)
1209
1210 /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
1211    there was an overflow in folding.  */
1212
1213 #define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag)
1214
1215 /* ??? This is an obsolete synonym for TREE_OVERFLOW.  */
1216 #define TREE_CONSTANT_OVERFLOW(NODE) TREE_OVERFLOW(NODE)
1217
1218 /* TREE_OVERFLOW can only be true for EXPR of CONSTANT_CLASS_P.  */
1219
1220 #define TREE_OVERFLOW_P(EXPR) \
1221  (CONSTANT_CLASS_P (EXPR) && TREE_OVERFLOW (EXPR))
1222
1223 /* In a VAR_DECL, FUNCTION_DECL, NAMESPACE_DECL or TYPE_DECL,
1224    nonzero means name is to be accessible from outside this module.
1225    In an IDENTIFIER_NODE, nonzero means an external declaration
1226    accessible from outside this module was previously seen
1227    for this name in an inner scope.  */
1228 #define TREE_PUBLIC(NODE) ((NODE)->base.public_flag)
1229
1230 /* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
1231    of cached values, or is something else.  */
1232 #define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->base.public_flag)
1233
1234 /* In a SAVE_EXPR, indicates that the original expression has already
1235    been substituted with a VAR_DECL that contains the value.  */
1236 #define SAVE_EXPR_RESOLVED_P(NODE) \
1237   (TREE_CHECK (NODE, SAVE_EXPR)->base.public_flag)
1238
1239 /* Set on a CALL_EXPR if this stdarg call should be passed the argument
1240    pack.  */
1241 #define CALL_EXPR_VA_ARG_PACK(NODE) \
1242   (CALL_EXPR_CHECK(NODE)->base.public_flag)
1243
1244 /* In any expression, decl, or constant, nonzero means it has side effects or
1245    reevaluation of the whole expression could produce a different value.
1246    This is set if any subexpression is a function call, a side effect or a
1247    reference to a volatile variable.  In a ..._DECL, this is set only if the
1248    declaration said `volatile'.  This will never be set for a constant.  */
1249 #define TREE_SIDE_EFFECTS(NODE) \
1250   (NON_TYPE_CHECK (NODE)->base.side_effects_flag)
1251
1252 /* In a LABEL_DECL, nonzero means this label had its address taken
1253    and therefore can never be deleted and is a jump target for
1254    computed gotos.  */
1255 #define FORCED_LABEL(NODE) ((NODE)->base.side_effects_flag)
1256
1257 /* Nonzero means this expression is volatile in the C sense:
1258    its address should be of type `volatile WHATEVER *'.
1259    In other words, the declared item is volatile qualified.
1260    This is used in _DECL nodes and _REF nodes.
1261    On a FUNCTION_DECL node, this means the function does not
1262    return normally.  This is the same effect as setting
1263    the attribute noreturn on the function in C.
1264
1265    In a ..._TYPE node, means this type is volatile-qualified.
1266    But use TYPE_VOLATILE instead of this macro when the node is a type,
1267    because eventually we may make that a different bit.
1268
1269    If this bit is set in an expression, so is TREE_SIDE_EFFECTS.  */
1270 #define TREE_THIS_VOLATILE(NODE) ((NODE)->base.volatile_flag)
1271
1272 /* Nonzero means this node will not trap.  In an INDIRECT_REF, means
1273    accessing the memory pointed to won't generate a trap.  However,
1274    this only applies to an object when used appropriately: it doesn't
1275    mean that writing a READONLY mem won't trap. Similarly for
1276    ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.
1277
1278    In ARRAY_REF and ARRAY_RANGE_REF means that we know that the index
1279    (or slice of the array) always belongs to the range of the array.
1280    I.e. that the access will not trap, provided that the access to
1281    the base to the array will not trap.  */
1282 #define TREE_THIS_NOTRAP(NODE) ((NODE)->base.nothrow_flag)
1283
1284 /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
1285    nonzero means it may not be the lhs of an assignment.  */
1286 #define TREE_READONLY(NODE) (NON_TYPE_CHECK (NODE)->base.readonly_flag)
1287
1288 /* Nonzero if NODE is a _DECL with TREE_READONLY set.  */
1289 #define TREE_READONLY_DECL_P(NODE)\
1290         (DECL_P (NODE) && TREE_READONLY (NODE))
1291
1292 /* Value of expression is constant.  Always on in all ..._CST nodes.  May
1293    also appear in an expression or decl where the value is constant.  */
1294 #define TREE_CONSTANT(NODE) (NON_TYPE_CHECK (NODE)->base.constant_flag)
1295
1296 /* Nonzero if NODE, a type, has had its sizes gimplified.  */
1297 #define TYPE_SIZES_GIMPLIFIED(NODE) \
1298   (TYPE_CHECK (NODE)->base.constant_flag)
1299
1300 /* In a decl (most significantly a FIELD_DECL), means an unsigned field.  */
1301 #define DECL_UNSIGNED(NODE) \
1302   (DECL_COMMON_CHECK (NODE)->base.unsigned_flag)
1303
1304 /* In a BIT_FIELD_REF, means the bitfield is to be interpreted as unsigned.  */
1305 #define BIT_FIELD_REF_UNSIGNED(NODE) \
1306   (BIT_FIELD_REF_CHECK (NODE)->base.unsigned_flag)
1307
1308 /* In integral and pointer types, means an unsigned type.  */
1309 #define TYPE_UNSIGNED(NODE) (TYPE_CHECK (NODE)->base.unsigned_flag)
1310
1311 /* Nonzero in a VAR_DECL or STRING_CST means assembler code has been written.
1312    Nonzero in a FUNCTION_DECL means that the function has been compiled.
1313    This is interesting in an inline function, since it might not need
1314    to be compiled separately.
1315    Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
1316    if the sdb debugging info for the type has been written.
1317    In a BLOCK node, nonzero if reorder_blocks has already seen this block.
1318    In an SSA_NAME node, nonzero if the SSA_NAME occurs in an abnormal
1319    PHI node.  */
1320 #define TREE_ASM_WRITTEN(NODE) ((NODE)->base.asm_written_flag)
1321
1322 /* Nonzero in a _DECL if the name is used in its scope.
1323    Nonzero in an expr node means inhibit warning if value is unused.
1324    In IDENTIFIER_NODEs, this means that some extern decl for this name
1325    was used.
1326    In a BLOCK, this means that the block contains variables that are used.  */
1327 #define TREE_USED(NODE) ((NODE)->base.used_flag)
1328
1329 /* In a FUNCTION_DECL, nonzero means a call to the function cannot throw
1330    an exception.  In a CALL_EXPR, nonzero means the call cannot throw.  */
1331 #define TREE_NOTHROW(NODE) ((NODE)->base.nothrow_flag)
1332
1333 /* In a CALL_EXPR, means that it's safe to use the target of the call
1334    expansion as the return slot for a call that returns in memory.  */
1335 #define CALL_EXPR_RETURN_SLOT_OPT(NODE) ((NODE)->base.private_flag)
1336
1337 /* In a RESULT_DECL or PARM_DECL, means that it is passed by invisible
1338    reference (and the TREE_TYPE is a pointer to the true type).  */
1339 #define DECL_BY_REFERENCE(NODE) \
1340   (DECL_COMMON_CHECK (NODE)->base.private_flag)
1341
1342 /* In a CALL_EXPR, means that the call is the jump from a thunk to the
1343    thunked-to function.  */
1344 #define CALL_FROM_THUNK_P(NODE) \
1345   (CALL_EXPR_CHECK (NODE)->base.protected_flag)
1346
1347 /* In a type, nonzero means that all objects of the type are guaranteed by the
1348    language or front-end to be properly aligned, so we can indicate that a MEM
1349    of this type is aligned at least to the alignment of the type, even if it
1350    doesn't appear that it is.  We see this, for example, in object-oriented
1351    languages where a tag field may show this is an object of a more-aligned
1352    variant of the more generic type.
1353
1354    In an SSA_NAME node, nonzero if the SSA_NAME node is on the SSA_NAME
1355    freelist.  */
1356 #define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->base.nothrow_flag)
1357
1358 /* Used in classes in C++.  */
1359 #define TREE_PRIVATE(NODE) ((NODE)->base.private_flag)
1360 /* Used in classes in C++.
1361    In a BLOCK node, this is BLOCK_HANDLER_BLOCK.  */
1362 #define TREE_PROTECTED(NODE) ((NODE)->base.protected_flag)
1363
1364 /* Nonzero in a _DECL if the use of the name is defined as a
1365    deprecated feature by __attribute__((deprecated)).  */
1366 #define TREE_DEPRECATED(NODE) \
1367   ((NODE)->base.deprecated_flag)
1368
1369 /* Nonzero in an IDENTIFIER_NODE if the name is a local alias, whose
1370    uses are to be substituted for uses of the TREE_CHAINed identifier.  */
1371 #define IDENTIFIER_TRANSPARENT_ALIAS(NODE) \
1372   (IDENTIFIER_NODE_CHECK (NODE)->base.deprecated_flag)
1373
1374 /* Value of expression is function invariant.  A strict subset of
1375    TREE_CONSTANT, such an expression is constant over any one function
1376    invocation, though not across different invocations.  May appear in
1377    any expression node.  */
1378 #define TREE_INVARIANT(NODE) ((NODE)->base.invariant_flag)
1379
1380 /* In fixed-point types, means a saturating type.  */
1381 #define TYPE_SATURATING(NODE) ((NODE)->base.saturating_flag)
1382
1383 /* These flags are available for each language front end to use internally.  */
1384 #define TREE_LANG_FLAG_0(NODE) ((NODE)->base.lang_flag_0)
1385 #define TREE_LANG_FLAG_1(NODE) ((NODE)->base.lang_flag_1)
1386 #define TREE_LANG_FLAG_2(NODE) ((NODE)->base.lang_flag_2)
1387 #define TREE_LANG_FLAG_3(NODE) ((NODE)->base.lang_flag_3)
1388 #define TREE_LANG_FLAG_4(NODE) ((NODE)->base.lang_flag_4)
1389 #define TREE_LANG_FLAG_5(NODE) ((NODE)->base.lang_flag_5)
1390 #define TREE_LANG_FLAG_6(NODE) ((NODE)->base.lang_flag_6)
1391 \f
1392 /* Define additional fields and accessors for nodes representing constants.  */
1393
1394 /* In an INTEGER_CST node.  These two together make a 2-word integer.
1395    If the data type is signed, the value is sign-extended to 2 words
1396    even though not all of them may really be in use.
1397    In an unsigned constant shorter than 2 words, the extra bits are 0.  */
1398 #define TREE_INT_CST(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)
1399 #define TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low)
1400 #define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)
1401
1402 #define INT_CST_LT(A, B)                                \
1403   (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B)        \
1404    || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B)   \
1405        && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
1406
1407 #define INT_CST_LT_UNSIGNED(A, B)                               \
1408   (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)              \
1409     < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))           \
1410    || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)          \
1411         == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))      \
1412        && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
1413
1414 struct tree_int_cst GTY(())
1415 {
1416   struct tree_common common;
1417   double_int int_cst;
1418 };
1419
1420 /* In a REAL_CST node.  struct real_value is an opaque entity, with
1421    manipulators defined in real.h.  We don't want tree.h depending on
1422    real.h and transitively on tm.h.  */
1423 struct real_value;
1424
1425 #define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
1426 #define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
1427
1428 struct tree_real_cst GTY(())
1429 {
1430   struct tree_common common;
1431   struct real_value * real_cst_ptr;
1432 };
1433
1434 /* In a FIXED_CST node.  */
1435 struct fixed_value;
1436
1437 #define TREE_FIXED_CST_PTR(NODE) (FIXED_CST_CHECK (NODE)->fixed_cst.fixed_cst_ptr)
1438 #define TREE_FIXED_CST(NODE) (*TREE_FIXED_CST_PTR (NODE))
1439
1440 struct tree_fixed_cst GTY(())
1441 {
1442   struct tree_common common;
1443   struct fixed_value * fixed_cst_ptr;
1444 };
1445
1446 /* In a STRING_CST */
1447 #define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
1448 #define TREE_STRING_POINTER(NODE) \
1449   ((const char *)(STRING_CST_CHECK (NODE)->string.str))
1450
1451 struct tree_string GTY(())
1452 {
1453   struct tree_common common;
1454   int length;
1455   char str[1];
1456 };
1457
1458 /* In a COMPLEX_CST node.  */
1459 #define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
1460 #define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
1461
1462 struct tree_complex GTY(())
1463 {
1464   struct tree_common common;
1465   tree real;
1466   tree imag;
1467 };
1468
1469 /* In a VECTOR_CST node.  */
1470 #define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)
1471
1472 struct tree_vector GTY(())
1473 {
1474   struct tree_common common;
1475   tree elements;
1476 };
1477 \f
1478 #include "symtab.h"
1479
1480 /* Define fields and accessors for some special-purpose tree nodes.  */
1481
1482 #define IDENTIFIER_LENGTH(NODE) \
1483   (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
1484 #define IDENTIFIER_POINTER(NODE) \
1485   ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
1486 #define IDENTIFIER_HASH_VALUE(NODE) \
1487   (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
1488
1489 /* Translate a hash table identifier pointer to a tree_identifier
1490    pointer, and vice versa.  */
1491
1492 #define HT_IDENT_TO_GCC_IDENT(NODE) \
1493   ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
1494 #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
1495
1496 struct tree_identifier GTY(())
1497 {
1498   struct tree_common common;
1499   struct ht_identifier id;
1500 };
1501
1502 /* In a TREE_LIST node.  */
1503 #define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
1504 #define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
1505
1506 struct tree_list GTY(())
1507 {
1508   struct tree_common common;
1509   tree purpose;
1510   tree value;
1511 };
1512
1513 /* In a TREE_VEC node.  */
1514 #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
1515 #define TREE_VEC_END(NODE) \
1516   ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
1517
1518 #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
1519
1520 struct tree_vec GTY(())
1521 {
1522   struct tree_common common;
1523   int length;
1524   tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
1525 };
1526
1527 /* In a CONSTRUCTOR node.  */
1528 #define CONSTRUCTOR_ELTS(NODE) (CONSTRUCTOR_CHECK (NODE)->constructor.elts)
1529
1530 /* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding the
1531    value of each element (stored within VAL). IX must be a scratch variable
1532    of unsigned integer type.  */
1533 #define FOR_EACH_CONSTRUCTOR_VALUE(V, IX, VAL) \
1534   for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
1535                ? false \
1536                : ((VAL = VEC_index (constructor_elt, V, IX)->value), \
1537                true); \
1538        (IX)++)
1539
1540 /* Iterate through the vector V of CONSTRUCTOR_ELT elements, yielding both
1541    the value of each element (stored within VAL) and its index (stored
1542    within INDEX). IX must be a scratch variable of unsigned integer type.  */
1543 #define FOR_EACH_CONSTRUCTOR_ELT(V, IX, INDEX, VAL) \
1544   for (IX = 0; (IX >= VEC_length (constructor_elt, V)) \
1545                ? false \
1546                : ((VAL = VEC_index (constructor_elt, V, IX)->value), \
1547                   (INDEX = VEC_index (constructor_elt, V, IX)->index), \
1548                true); \
1549        (IX)++)
1550
1551 /* Append a new constructor element to V, with the specified INDEX and VAL.  */
1552 #define CONSTRUCTOR_APPEND_ELT(V, INDEX, VALUE) \
1553   do { \
1554     constructor_elt *_ce___ = VEC_safe_push (constructor_elt, gc, V, NULL); \
1555     _ce___->index = INDEX; \
1556     _ce___->value = VALUE; \
1557   } while (0)
1558
1559 /* A single element of a CONSTRUCTOR. VALUE holds the actual value of the
1560    element. INDEX can optionally design the position of VALUE: in arrays,
1561    it is the index where VALUE has to be placed; in structures, it is the
1562    FIELD_DECL of the member.  */
1563 typedef struct constructor_elt_d GTY(())
1564 {
1565   tree index;
1566   tree value;
1567 } constructor_elt;
1568
1569 DEF_VEC_O(constructor_elt);
1570 DEF_VEC_ALLOC_O(constructor_elt,gc);
1571
1572 struct tree_constructor GTY(())
1573 {
1574   struct tree_common common;
1575   VEC(constructor_elt,gc) *elts;
1576 };
1577
1578 /* Define fields and accessors for some nodes that represent expressions.  */
1579
1580 /* Nonzero if NODE is an empty statement (NOP_EXPR <0>).  */
1581 #define IS_EMPTY_STMT(NODE)     (TREE_CODE (NODE) == NOP_EXPR \
1582                                  && VOID_TYPE_P (TREE_TYPE (NODE)) \
1583                                  && integer_zerop (TREE_OPERAND (NODE, 0)))
1584
1585 /* In ordinary expression nodes.  */
1586 #define TREE_OPERAND_LENGTH(NODE) tree_operand_length (NODE)
1587 #define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
1588
1589 /* In a tcc_vl_exp node, operand 0 is an INT_CST node holding the operand
1590    length.  Its value includes the length operand itself; that is,
1591    the minimum valid length is 1.
1592    Note that we have to bypass the use of TREE_OPERAND to access
1593    that field to avoid infinite recursion in expanding the macros.  */
1594 #define VL_EXP_OPERAND_LENGTH(NODE) \
1595   ((int)TREE_INT_CST_LOW (VL_EXP_CHECK (NODE)->exp.operands[0]))
1596
1597 /* In gimple statements.  */
1598 #define GIMPLE_STMT_OPERAND(NODE, I) GIMPLE_STMT_OPERAND_CHECK (NODE, I)
1599 #define GIMPLE_STMT_LOCUS(NODE) (GIMPLE_STMT_CHECK (NODE)->gstmt.locus)
1600 #define GIMPLE_STMT_BLOCK(NODE) (GIMPLE_STMT_CHECK (NODE)->gstmt.block)
1601
1602 /* In a LOOP_EXPR node.  */
1603 #define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
1604
1605 /* The source location of this expression.  Non-tree_exp nodes such as
1606    decls and constants can be shared among multiple locations, so
1607    return nothing.  */
1608 #define EXPR_LOCATION(NODE) expr_location ((NODE))
1609 #define SET_EXPR_LOCATION(NODE, FROM) set_expr_location ((NODE), (FROM))
1610 #define EXPR_HAS_LOCATION(NODE) expr_has_location ((NODE))
1611 #define EXPR_LOCUS(NODE) expr_locus ((NODE))
1612 #define SET_EXPR_LOCUS(NODE, FROM) set_expr_locus ((NODE), (FROM))
1613 #define EXPR_FILENAME(NODE) (expr_filename ((NODE)))
1614 #define EXPR_LINENO(NODE) (expr_lineno ((NODE)))
1615
1616 /* True if a tree is an expression or statement that can have a
1617    location.  */
1618 #define CAN_HAVE_LOCATION_P(NODE) (EXPR_P (NODE) || GIMPLE_STMT_P (NODE))
1619
1620 /* In a TARGET_EXPR node.  */
1621 #define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
1622 #define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
1623 #define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
1624
1625 /* DECL_EXPR accessor. This gives access to the DECL associated with
1626    the given declaration statement.  */
1627 #define DECL_EXPR_DECL(NODE)    TREE_OPERAND (DECL_EXPR_CHECK (NODE), 0)
1628
1629 #define EXIT_EXPR_COND(NODE)         TREE_OPERAND (EXIT_EXPR_CHECK (NODE), 0)
1630
1631 /* SWITCH_EXPR accessors. These give access to the condition, body and
1632    original condition type (before any compiler conversions)
1633    of the switch statement, respectively.  */
1634 #define SWITCH_COND(NODE)       TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 0)
1635 #define SWITCH_BODY(NODE)       TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 1)
1636 #define SWITCH_LABELS(NODE)     TREE_OPERAND (SWITCH_EXPR_CHECK (NODE), 2)
1637
1638 /* CASE_LABEL_EXPR accessors. These give access to the high and low values
1639    of a case label, respectively.  */
1640 #define CASE_LOW(NODE)                  TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 0)
1641 #define CASE_HIGH(NODE)                 TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 1)
1642 #define CASE_LABEL(NODE)                TREE_OPERAND (CASE_LABEL_EXPR_CHECK (NODE), 2)
1643
1644 /* The operands of a TARGET_MEM_REF.  */
1645 #define TMR_SYMBOL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 0))
1646 #define TMR_BASE(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 1))
1647 #define TMR_INDEX(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 2))
1648 #define TMR_STEP(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 3))
1649 #define TMR_OFFSET(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 4))
1650 #define TMR_ORIGINAL(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 5))
1651 #define TMR_TAG(NODE) (TREE_OPERAND (TARGET_MEM_REF_CHECK (NODE), 6))
1652
1653 /* The operands of a BIND_EXPR.  */
1654 #define BIND_EXPR_VARS(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 0))
1655 #define BIND_EXPR_BODY(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 1))
1656 #define BIND_EXPR_BLOCK(NODE) (TREE_OPERAND (BIND_EXPR_CHECK (NODE), 2))
1657
1658 /* GOTO_EXPR accessor. This gives access to the label associated with
1659    a goto statement.  */
1660 #define GOTO_DESTINATION(NODE)  TREE_OPERAND ((NODE), 0)
1661
1662 /* ASM_EXPR accessors. ASM_STRING returns a STRING_CST for the
1663    instruction (e.g., "mov x, y"). ASM_OUTPUTS, ASM_INPUTS, and
1664    ASM_CLOBBERS represent the outputs, inputs, and clobbers for the
1665    statement.  */
1666 #define ASM_STRING(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 0)
1667 #define ASM_OUTPUTS(NODE)       TREE_OPERAND (ASM_EXPR_CHECK (NODE), 1)
1668 #define ASM_INPUTS(NODE)        TREE_OPERAND (ASM_EXPR_CHECK (NODE), 2)
1669 #define ASM_CLOBBERS(NODE)      TREE_OPERAND (ASM_EXPR_CHECK (NODE), 3)
1670 /* Nonzero if we want to create an ASM_INPUT instead of an
1671    ASM_OPERAND with no operands.  */
1672 #define ASM_INPUT_P(NODE) (TREE_STATIC (NODE))
1673 #define ASM_VOLATILE_P(NODE) (TREE_PUBLIC (NODE))
1674
1675 /* COND_EXPR accessors.  */
1676 #define COND_EXPR_COND(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 0))
1677 #define COND_EXPR_THEN(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 1))
1678 #define COND_EXPR_ELSE(NODE)    (TREE_OPERAND (COND_EXPR_CHECK (NODE), 2))
1679
1680 /* Accessors for the chains of recurrences.  */
1681 #define CHREC_VAR(NODE)           TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 0)
1682 #define CHREC_LEFT(NODE)          TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 1)
1683 #define CHREC_RIGHT(NODE)         TREE_OPERAND (POLYNOMIAL_CHREC_CHECK (NODE), 2)
1684 #define CHREC_VARIABLE(NODE)      TREE_INT_CST_LOW (CHREC_VAR (NODE))
1685
1686 /* LABEL_EXPR accessor. This gives access to the label associated with
1687    the given label expression.  */
1688 #define LABEL_EXPR_LABEL(NODE)  TREE_OPERAND (LABEL_EXPR_CHECK (NODE), 0)
1689
1690 /* VDEF_EXPR accessors are specified in tree-flow.h, along with the other
1691    accessors for SSA operands.  */
1692
1693 /* CATCH_EXPR accessors.  */
1694 #define CATCH_TYPES(NODE)       TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 0)
1695 #define CATCH_BODY(NODE)        TREE_OPERAND (CATCH_EXPR_CHECK (NODE), 1)
1696
1697 /* EH_FILTER_EXPR accessors.  */
1698 #define EH_FILTER_TYPES(NODE)   TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 0)
1699 #define EH_FILTER_FAILURE(NODE) TREE_OPERAND (EH_FILTER_EXPR_CHECK (NODE), 1)
1700 #define EH_FILTER_MUST_NOT_THROW(NODE) TREE_STATIC (EH_FILTER_EXPR_CHECK (NODE))
1701
1702 /* CHANGE_DYNAMIC_TYPE_EXPR accessors.  */
1703 #define CHANGE_DYNAMIC_TYPE_NEW_TYPE(NODE) \
1704   TREE_OPERAND (CHANGE_DYNAMIC_TYPE_EXPR_CHECK (NODE), 0)
1705 #define CHANGE_DYNAMIC_TYPE_LOCATION(NODE) \
1706   TREE_OPERAND (CHANGE_DYNAMIC_TYPE_EXPR_CHECK (NODE), 1)
1707
1708 /* OBJ_TYPE_REF accessors.  */
1709 #define OBJ_TYPE_REF_EXPR(NODE)   TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 0)
1710 #define OBJ_TYPE_REF_OBJECT(NODE) TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 1)
1711 #define OBJ_TYPE_REF_TOKEN(NODE)  TREE_OPERAND (OBJ_TYPE_REF_CHECK (NODE), 2)
1712
1713 /* ASSERT_EXPR accessors.  */
1714 #define ASSERT_EXPR_VAR(NODE)   TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 0)
1715 #define ASSERT_EXPR_COND(NODE)  TREE_OPERAND (ASSERT_EXPR_CHECK (NODE), 1)
1716
1717 /* CALL_EXPR accessors.
1718  */
1719 #define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)
1720 #define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)
1721 #define CALL_EXPR_ARGS(NODE) call_expr_arglist (NODE)
1722 #define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)
1723 #define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
1724
1725 /* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
1726    We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
1727    the argument count is zero when checking is enabled.  Instead, do
1728    the pointer arithmetic to advance past the 3 fixed operands in a
1729    CALL_EXPR.  That produces a valid pointer to just past the end of the
1730    operand array, even if it's not valid to dereference it.  */
1731 #define CALL_EXPR_ARGP(NODE) \
1732   (&(TREE_OPERAND (CALL_EXPR_CHECK (NODE), 0)) + 3)
1733
1734 /* OpenMP directive and clause accessors.  */
1735
1736 #define OMP_BODY(NODE) \
1737   TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_CRITICAL), 0)
1738 #define OMP_CLAUSES(NODE) \
1739   TREE_OPERAND (TREE_RANGE_CHECK (NODE, OMP_PARALLEL, OMP_SINGLE), 1)
1740
1741 #define OMP_PARALLEL_BODY(NODE)    TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 0)
1742 #define OMP_PARALLEL_CLAUSES(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 1)
1743 #define OMP_PARALLEL_FN(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 2)
1744 #define OMP_PARALLEL_DATA_ARG(NODE) TREE_OPERAND (OMP_PARALLEL_CHECK (NODE), 3)
1745
1746 #define OMP_FOR_BODY(NODE)         TREE_OPERAND (OMP_FOR_CHECK (NODE), 0)
1747 #define OMP_FOR_CLAUSES(NODE)      TREE_OPERAND (OMP_FOR_CHECK (NODE), 1)
1748 #define OMP_FOR_INIT(NODE)         TREE_OPERAND (OMP_FOR_CHECK (NODE), 2)
1749 #define OMP_FOR_COND(NODE)         TREE_OPERAND (OMP_FOR_CHECK (NODE), 3)
1750 #define OMP_FOR_INCR(NODE)         TREE_OPERAND (OMP_FOR_CHECK (NODE), 4)
1751 #define OMP_FOR_PRE_BODY(NODE)     TREE_OPERAND (OMP_FOR_CHECK (NODE), 5)
1752
1753 #define OMP_SECTIONS_BODY(NODE)    TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 0)
1754 #define OMP_SECTIONS_CLAUSES(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 1)
1755 #define OMP_SECTIONS_CONTROL(NODE) TREE_OPERAND (OMP_SECTIONS_CHECK (NODE), 2)
1756
1757 #define OMP_SECTION_BODY(NODE)     TREE_OPERAND (OMP_SECTION_CHECK (NODE), 0)
1758
1759 #define OMP_SINGLE_BODY(NODE)      TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 0)
1760 #define OMP_SINGLE_CLAUSES(NODE)   TREE_OPERAND (OMP_SINGLE_CHECK (NODE), 1)
1761
1762 #define OMP_MASTER_BODY(NODE)      TREE_OPERAND (OMP_MASTER_CHECK (NODE), 0)
1763
1764 #define OMP_ORDERED_BODY(NODE)     TREE_OPERAND (OMP_ORDERED_CHECK (NODE), 0)
1765
1766 #define OMP_CRITICAL_BODY(NODE)    TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 0)
1767 #define OMP_CRITICAL_NAME(NODE)    TREE_OPERAND (OMP_CRITICAL_CHECK (NODE), 1)
1768
1769 #define OMP_CLAUSE_CHAIN(NODE)     TREE_CHAIN (OMP_CLAUSE_CHECK (NODE))
1770 #define OMP_CLAUSE_DECL(NODE)                                           \
1771   OMP_CLAUSE_OPERAND (OMP_CLAUSE_RANGE_CHECK (OMP_CLAUSE_CHECK (NODE),  \
1772                                               OMP_CLAUSE_PRIVATE,       \
1773                                               OMP_CLAUSE_COPYPRIVATE), 0)
1774
1775 /* True on an OMP_SECTION statement that was the last lexical member.
1776    This status is meaningful in the implementation of lastprivate.  */
1777 #define OMP_SECTION_LAST(NODE) \
1778   TREE_PRIVATE (OMP_SECTION_CHECK (NODE))
1779
1780 /* True on an OMP_RETURN statement if the return does not require a
1781    thread synchronization via some sort of barrier.  The exact barrier
1782    that would otherwise be emitted is dependent on the OMP statement
1783    with which this return is associated.  */
1784 #define OMP_RETURN_NOWAIT(NODE) \
1785   TREE_PRIVATE (OMP_RETURN_CHECK (NODE))
1786
1787 /* True on an OMP_PARALLEL statement if it represents an explicit
1788    combined parallel work-sharing constructs.  */
1789 #define OMP_PARALLEL_COMBINED(NODE) \
1790   TREE_PRIVATE (OMP_PARALLEL_CHECK (NODE))
1791
1792 /* True on a PRIVATE clause if its decl is kept around for debugging
1793    information only and its DECL_VALUE_EXPR is supposed to point
1794    to what it has been remapped to.  */
1795 #define OMP_CLAUSE_PRIVATE_DEBUG(NODE) \
1796   TREE_PUBLIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_PRIVATE))
1797
1798 /* True on a LASTPRIVATE clause if a FIRSTPRIVATE clause for the same
1799    decl is present in the chain.  */
1800 #define OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE(NODE) \
1801   TREE_PUBLIC (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_LASTPRIVATE))
1802
1803 #define OMP_CLAUSE_IF_EXPR(NODE) \
1804   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_IF), 0)
1805 #define OMP_CLAUSE_NUM_THREADS_EXPR(NODE) \
1806   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_NUM_THREADS),0)
1807 #define OMP_CLAUSE_SCHEDULE_CHUNK_EXPR(NODE) \
1808   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE), 0)
1809
1810 #define OMP_CLAUSE_REDUCTION_CODE(NODE) \
1811   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION)->omp_clause.subcode.reduction_code)
1812 #define OMP_CLAUSE_REDUCTION_INIT(NODE) \
1813   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 1)
1814 #define OMP_CLAUSE_REDUCTION_MERGE(NODE) \
1815   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 2)
1816 #define OMP_CLAUSE_REDUCTION_PLACEHOLDER(NODE) \
1817   OMP_CLAUSE_OPERAND (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_REDUCTION), 3)
1818
1819 enum omp_clause_schedule_kind
1820 {
1821   OMP_CLAUSE_SCHEDULE_STATIC,
1822   OMP_CLAUSE_SCHEDULE_DYNAMIC,
1823   OMP_CLAUSE_SCHEDULE_GUIDED,
1824   OMP_CLAUSE_SCHEDULE_RUNTIME
1825 };
1826
1827 #define OMP_CLAUSE_SCHEDULE_KIND(NODE) \
1828   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_SCHEDULE)->omp_clause.subcode.schedule_kind)
1829
1830 enum omp_clause_default_kind
1831 {
1832   OMP_CLAUSE_DEFAULT_UNSPECIFIED,
1833   OMP_CLAUSE_DEFAULT_SHARED,
1834   OMP_CLAUSE_DEFAULT_NONE,
1835   OMP_CLAUSE_DEFAULT_PRIVATE
1836 };
1837
1838 #define OMP_CLAUSE_DEFAULT_KIND(NODE) \
1839   (OMP_CLAUSE_SUBCODE_CHECK (NODE, OMP_CLAUSE_DEFAULT)->omp_clause.subcode.default_kind)
1840
1841 struct tree_exp GTY(())
1842 {
1843   struct tree_common common;
1844   source_locus locus;
1845   tree block;
1846   tree GTY ((special ("tree_exp"),
1847              desc ("TREE_CODE ((tree) &%0)")))
1848     operands[1];
1849 };
1850 \f
1851 /* SSA_NAME accessors.  */
1852
1853 /* Returns the variable being referenced.  Once released, this is the
1854    only field that can be relied upon.  */
1855 #define SSA_NAME_VAR(NODE)      SSA_NAME_CHECK (NODE)->ssa_name.var
1856
1857 /* Returns the statement which defines this reference.   Note that
1858    we use the same field when chaining SSA_NAME nodes together on
1859    the SSA_NAME freelist.  */
1860 #define SSA_NAME_DEF_STMT(NODE) SSA_NAME_CHECK (NODE)->common.chain
1861
1862 /* Returns the SSA version number of this SSA name.  Note that in
1863    tree SSA, version numbers are not per variable and may be recycled.  */
1864 #define SSA_NAME_VERSION(NODE)  SSA_NAME_CHECK (NODE)->ssa_name.version
1865
1866 /* Nonzero if this SSA name occurs in an abnormal PHI.  SSA_NAMES are
1867    never output, so we can safely use the ASM_WRITTEN_FLAG for this
1868    status bit.  */
1869 #define SSA_NAME_OCCURS_IN_ABNORMAL_PHI(NODE) \
1870     SSA_NAME_CHECK (NODE)->base.asm_written_flag
1871
1872 /* Nonzero if this SSA_NAME expression is currently on the free list of
1873    SSA_NAMES.  Using NOTHROW_FLAG seems reasonably safe since throwing
1874    has no meaning for an SSA_NAME.  */
1875 #define SSA_NAME_IN_FREE_LIST(NODE) \
1876     SSA_NAME_CHECK (NODE)->base.nothrow_flag
1877
1878 /* Nonzero if this SSA_NAME is the default definition for the
1879    underlying symbol.  A default SSA name is created for symbol S if
1880    the very first reference to S in the function is a read operation.
1881    Default definitions are always created by an empty statement and
1882    belong to no basic block.  */
1883 #define SSA_NAME_IS_DEFAULT_DEF(NODE)   \
1884     SSA_NAME_CHECK (NODE)->base.volatile_flag
1885
1886 /* Attributes for SSA_NAMEs for pointer-type variables.  */
1887 #define SSA_NAME_PTR_INFO(N) \
1888     SSA_NAME_CHECK (N)->ssa_name.ptr_info
1889
1890 /* Get the value of this SSA_NAME, if available.  */
1891 #define SSA_NAME_VALUE(N) \
1892    SSA_NAME_CHECK (N)->ssa_name.value_handle
1893
1894 #ifndef _TREE_FLOW_H
1895 struct ptr_info_def;
1896 #endif
1897
1898
1899
1900 /* Immediate use linking structure.  This structure is used for maintaining
1901    a doubly linked list of uses of an SSA_NAME.  */
1902 typedef struct ssa_use_operand_d GTY(())
1903 {
1904   struct ssa_use_operand_d* GTY((skip(""))) prev;
1905   struct ssa_use_operand_d* GTY((skip(""))) next;
1906   tree GTY((skip(""))) stmt;
1907   tree *GTY((skip(""))) use;
1908 } ssa_use_operand_t;
1909
1910 /* Return the immediate_use information for an SSA_NAME. */
1911 #define SSA_NAME_IMM_USE_NODE(NODE) SSA_NAME_CHECK (NODE)->ssa_name.imm_uses
1912
1913 struct tree_ssa_name GTY(())
1914 {
1915   struct tree_common common;
1916
1917   /* _DECL wrapped by this SSA name.  */
1918   tree var;
1919
1920   /* SSA version number.  */
1921   unsigned int version;
1922
1923   /* Pointer attributes used for alias analysis.  */
1924   struct ptr_info_def *ptr_info;
1925
1926   /* Value for SSA name used by various passes.
1927
1928      Right now only invariants are allowed to persist beyond a pass in
1929      this field; in the future we will allow VALUE_HANDLEs to persist
1930      as well.  */
1931   tree value_handle;
1932
1933   /* Immediate uses list for this SSA_NAME.  */
1934   struct ssa_use_operand_d imm_uses;
1935 };
1936 \f
1937 /* In a PHI_NODE node.  */
1938
1939 /* These 2 macros should be considered off limits for use by developers.  If
1940    you wish to access the use or def fields of a PHI_NODE in the SSA
1941    optimizers, use the accessor macros found in tree-ssa-operands.h.
1942    These two macros are to be used only by those accessor macros, and other
1943    select places where we *absolutely* must take the address of the tree.  */
1944
1945 #define PHI_RESULT_TREE(NODE)           PHI_NODE_CHECK (NODE)->phi.result
1946 #define PHI_ARG_DEF_TREE(NODE, I)       PHI_NODE_ELT_CHECK (NODE, I).def
1947
1948 /* PHI_NODEs for each basic block are chained together in a single linked
1949    list.  The head of the list is linked from the block annotation, and
1950    the link to the next PHI is in PHI_CHAIN.  */
1951 #define PHI_CHAIN(NODE)                 PHI_NODE_CHECK (NODE)->phi.chain
1952
1953 #define PHI_NUM_ARGS(NODE)              PHI_NODE_CHECK (NODE)->phi.num_args
1954 #define PHI_ARG_CAPACITY(NODE)          PHI_NODE_CHECK (NODE)->phi.capacity
1955 #define PHI_ARG_ELT(NODE, I)            PHI_NODE_ELT_CHECK (NODE, I)
1956 #define PHI_ARG_EDGE(NODE, I)           (EDGE_PRED (PHI_BB ((NODE)), (I)))
1957 #define PHI_BB(NODE)                    PHI_NODE_CHECK (NODE)->phi.bb
1958 #define PHI_ARG_IMM_USE_NODE(NODE, I)   PHI_NODE_ELT_CHECK (NODE, I).imm_use
1959
1960 struct phi_arg_d GTY(())
1961 {
1962   /* imm_use MUST be the first element in struct because we do some
1963      pointer arithmetic with it.  See phi_arg_index_from_use.  */
1964   struct ssa_use_operand_d imm_use;
1965   tree def;
1966 };
1967
1968 struct tree_phi_node GTY(())
1969 {
1970   struct tree_base common;
1971   tree chain;
1972   tree result;
1973   int num_args;
1974   int capacity;
1975
1976   /* Basic block holding this PHI node.  */
1977   struct basic_block_def *bb;
1978
1979   /* Arguments of the PHI node.  These are maintained in the same
1980      order as predecessor edge vector BB->PREDS.  */
1981   struct phi_arg_d GTY ((length ("((tree)&%h)->phi.num_args"))) a[1];
1982 };
1983
1984 \f
1985 #define OMP_CLAUSE_CODE(NODE)                                   \
1986         (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
1987
1988 #define OMP_CLAUSE_SET_CODE(NODE, CODE)                         \
1989         ((OMP_CLAUSE_CHECK (NODE))->omp_clause.code = (CODE))
1990
1991 #define OMP_CLAUSE_CODE(NODE)                                   \
1992         (OMP_CLAUSE_CHECK (NODE))->omp_clause.code
1993
1994 #define OMP_CLAUSE_OPERAND(NODE, I)                             \
1995         OMP_CLAUSE_ELT_CHECK (NODE, I)
1996
1997 struct tree_omp_clause GTY(())
1998 {
1999   struct tree_common common;
2000   enum omp_clause_code code;
2001   union omp_clause_subcode {
2002     enum omp_clause_default_kind  default_kind;
2003     enum omp_clause_schedule_kind schedule_kind;
2004     enum tree_code                reduction_code;
2005   } GTY ((skip)) subcode;
2006   tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) ops[1];
2007 };
2008 \f
2009
2010 struct varray_head_tag;
2011
2012 /* In a BLOCK node.  */
2013 #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
2014 #define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
2015 #define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
2016 /* Note: when changing this, make sure to find the places
2017    that use chainon or nreverse.  */
2018 #define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
2019 #define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
2020 #define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)
2021
2022 /* Nonzero means that this block is prepared to handle exceptions
2023    listed in the BLOCK_VARS slot.  */
2024 #define BLOCK_HANDLER_BLOCK(NODE) \
2025   (BLOCK_CHECK (NODE)->block.handler_block_flag)
2026
2027 /* An index number for this block.  These values are not guaranteed to
2028    be unique across functions -- whether or not they are depends on
2029    the debugging output format in use.  */
2030 #define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
2031
2032 /* If block reordering splits a lexical block into discontiguous
2033    address ranges, we'll make a copy of the original block.
2034
2035    Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
2036    In that case, we have one source block that has been replicated
2037    (through inlining or unrolling) into many logical blocks, and that
2038    these logical blocks have different physical variables in them.
2039
2040    In this case, we have one logical block split into several
2041    non-contiguous address ranges.  Most debug formats can't actually
2042    represent this idea directly, so we fake it by creating multiple
2043    logical blocks with the same variables in them.  However, for those
2044    that do support non-contiguous regions, these allow the original
2045    logical block to be reconstructed, along with the set of address
2046    ranges.
2047
2048    One of the logical block fragments is arbitrarily chosen to be
2049    the ORIGIN.  The other fragments will point to the origin via
2050    BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
2051    be null.  The list of fragments will be chained through
2052    BLOCK_FRAGMENT_CHAIN from the origin.  */
2053
2054 #define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
2055 #define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
2056
2057 /* For an inlined function, this gives the location where it was called
2058    from.  This is only set in the top level block, which corresponds to the
2059    inlined function scope.  This is used in the debug output routines.  */
2060
2061 #define BLOCK_SOURCE_LOCATION(NODE) (BLOCK_CHECK (NODE)->block.locus)
2062
2063 struct tree_block GTY(())
2064 {
2065   struct tree_common common;
2066
2067   unsigned handler_block_flag : 1;
2068   unsigned abstract_flag : 1;
2069   unsigned block_num : 30;
2070
2071   location_t locus;
2072
2073   tree vars;
2074   tree subblocks;
2075   tree supercontext;
2076   tree abstract_origin;
2077   tree fragment_origin;
2078   tree fragment_chain;
2079 };
2080 \f
2081 /* Define fields and accessors for nodes representing data types.  */
2082
2083 /* See tree.def for documentation of the use of these fields.
2084    Look at the documentation of the various ..._TYPE tree codes.
2085
2086    Note that the type.values, type.minval, and type.maxval fields are
2087    overloaded and used for different macros in different kinds of types.
2088    Each macro must check to ensure the tree node is of the proper kind of
2089    type.  Note also that some of the front-ends also overload these fields,
2090    so they must be checked as well.  */
2091
2092 #define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid)
2093 #define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
2094 #define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
2095 #define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
2096 #define TYPE_VALUES(NODE) (ENUMERAL_TYPE_CHECK (NODE)->type.values)
2097 #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type.values)
2098 #define TYPE_FIELDS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.values)
2099 #define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type.values)
2100 #define TYPE_ORIG_SIZE_TYPE(NODE)                       \
2101   (INTEGER_TYPE_CHECK (NODE)->type.values               \
2102   ? TREE_TYPE ((NODE)->type.values) : NULL_TREE)
2103 #define TYPE_METHODS(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.maxval)
2104 #define TYPE_VFIELD(NODE) (RECORD_OR_UNION_CHECK (NODE)->type.minval)
2105 #define TYPE_ARG_TYPES(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.values)
2106 #define TYPE_METHOD_BASETYPE(NODE) (FUNC_OR_METHOD_CHECK (NODE)->type.maxval)
2107 #define TYPE_OFFSET_BASETYPE(NODE) (OFFSET_TYPE_CHECK (NODE)->type.maxval)
2108 #define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to)
2109 #define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to)
2110 #define TYPE_NEXT_PTR_TO(NODE) (POINTER_TYPE_CHECK (NODE)->type.minval)
2111 #define TYPE_NEXT_REF_TO(NODE) (REFERENCE_TYPE_CHECK (NODE)->type.minval)
2112 #define TYPE_MIN_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.minval)
2113 #define TYPE_MAX_VALUE(NODE) (NUMERICAL_TYPE_CHECK (NODE)->type.maxval)
2114 #define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
2115 #define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
2116 #define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
2117 #define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
2118 #define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
2119 #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
2120 #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
2121 #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
2122
2123 /* The "canonical" type for this type node, which can be used to
2124    compare the type for equality with another type. If two types are
2125    equal (based on the semantics of the language), then they will have
2126    equivalent TYPE_CANONICAL entries.
2127
2128    As a special case, if TYPE_CANONICAL is NULL_TREE, then it cannot
2129    be used for comparison against other types. Instead, the type is
2130    said to require structural equality checks, described in
2131    TYPE_STRUCTURAL_EQUALITY_P. */
2132 #define TYPE_CANONICAL(NODE) (TYPE_CHECK (NODE)->type.canonical)
2133 /* Indicates that the type node requires structural equality
2134    checks. The compiler will need to look at the composition of the
2135    type to determine whether it is equal to another type, rather than
2136    just comparing canonical type pointers. For instance, we would need
2137    to look at the return and parameter types of a FUNCTION_TYPE
2138    node. */
2139 #define TYPE_STRUCTURAL_EQUALITY_P(NODE) (TYPE_CANONICAL (NODE) == NULL_TREE)
2140 /* Sets the TYPE_CANONICAL field to NULL_TREE, indicating that the
2141    type node requires structural equality. */
2142 #define SET_TYPE_STRUCTURAL_EQUALITY(NODE) (TYPE_CANONICAL (NODE) = NULL_TREE)
2143 #define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)
2144 #define TYPE_IBIT(NODE) (GET_MODE_IBIT (TYPE_MODE (NODE)))
2145 #define TYPE_FBIT(NODE) (GET_MODE_FBIT (TYPE_MODE (NODE)))
2146
2147 /* For a VECTOR_TYPE node, this describes a different type which is emitted
2148    in the debugging output.  We use this to describe a vector as a
2149    structure containing an array.  */
2150 #define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (VECTOR_TYPE_CHECK (NODE)->type.values)
2151
2152 /* For record and union types, information about this type, as a base type
2153    for itself.  */
2154 #define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type.binfo)
2155
2156 /* For non record and union types, used in a language-dependent way.  */
2157 #define TYPE_LANG_SLOT_1(NODE) (NOT_RECORD_OR_UNION_CHECK(NODE)->type.binfo)
2158
2159 /* The (language-specific) typed-based alias set for this type.
2160    Objects whose TYPE_ALIAS_SETs are different cannot alias each
2161    other.  If the TYPE_ALIAS_SET is -1, no alias set has yet been
2162    assigned to this type.  If the TYPE_ALIAS_SET is 0, objects of this
2163    type can alias objects of any type.  */
2164 #define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type.alias_set)
2165
2166 /* Nonzero iff the typed-based alias set for this type has been
2167    calculated.  */
2168 #define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1)
2169
2170 /* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
2171    to this type.  */
2172 #define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type.attributes)
2173
2174 /* The alignment necessary for objects of this type.
2175    The value is an int, measured in bits.  */
2176 #define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align)
2177
2178 /* 1 if the alignment for this type was requested by "aligned" attribute,
2179    0 if it is the default for this type.  */
2180 #define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)
2181
2182 /* The alignment for NODE, in bytes.  */
2183 #define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
2184
2185 /* If your language allows you to declare types, and you want debug info
2186    for them, then you need to generate corresponding TYPE_DECL nodes.
2187    These "stub" TYPE_DECL nodes have no name, and simply point at the
2188    type node.  You then set the TYPE_STUB_DECL field of the type node
2189    to point back at the TYPE_DECL node.  This allows the debug routines
2190    to know that the two nodes represent the same type, so that we only
2191    get one debug info record for them.  */
2192 #define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE)
2193
2194 /* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
2195    has BLKmode only because it lacks the alignment requirement for
2196    its size.  */
2197 #define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
2198
2199 /* In an INTEGER_TYPE, it means the type represents a size.  We use
2200    this both for validity checking and to permit optimizations that
2201    are unsafe for other types.  Note that the C `size_t' type should
2202    *not* have this flag set.  The `size_t' type is simply a typedef
2203    for an ordinary integer type that happens to be the type of an
2204    expression returned by `sizeof'; `size_t' has no special
2205    properties.  Expressions whose type have TYPE_IS_SIZETYPE set are
2206    always actual sizes.  */
2207 #define TYPE_IS_SIZETYPE(NODE) \
2208   (INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)
2209
2210 /* In a FUNCTION_TYPE, indicates that the function returns with the stack
2211    pointer depressed.  */
2212 #define TYPE_RETURNS_STACK_DEPRESSED(NODE) \
2213   (FUNCTION_TYPE_CHECK (NODE)->type.no_force_blk_flag)
2214
2215 /* Nonzero in a type considered volatile as a whole.  */
2216 #define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->base.volatile_flag)
2217
2218 /* Means this type is const-qualified.  */
2219 #define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->base.readonly_flag)
2220
2221 /* If nonzero, this type is `restrict'-qualified, in the C sense of
2222    the term.  */
2223 #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
2224
2225 /* There is a TYPE_QUAL value for each type qualifier.  They can be
2226    combined by bitwise-or to form the complete set of qualifiers for a
2227    type.  */
2228
2229 #define TYPE_UNQUALIFIED   0x0
2230 #define TYPE_QUAL_CONST    0x1
2231 #define TYPE_QUAL_VOLATILE 0x2
2232 #define TYPE_QUAL_RESTRICT 0x4
2233
2234 /* The set of type qualifiers for this type.  */
2235 #define TYPE_QUALS(NODE)                                        \
2236   ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)                     \
2237    | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)                \
2238    | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
2239
2240 /* These flags are available for each language front end to use internally.  */
2241 #define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
2242 #define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type.lang_flag_1)
2243 #define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type.lang_flag_2)
2244 #define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type.lang_flag_3)
2245 #define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type.lang_flag_4)
2246 #define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5)
2247 #define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6)
2248
2249 /* Used to keep track of visited nodes in tree traversals.  This is set to
2250    0 by copy_node and make_node.  */
2251 #define TREE_VISITED(NODE) ((NODE)->base.visited)
2252
2253 /* If set in an ARRAY_TYPE, indicates a string type (for languages
2254    that distinguish string from array of char).
2255    If set in a INTEGER_TYPE, indicates a character type.  */
2256 #define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag)
2257
2258 /* If non-NULL, this is an upper bound of the size (in bytes) of an
2259    object of the given ARRAY_TYPE.  This allows temporaries to be
2260    allocated.  */
2261 #define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
2262   (ARRAY_TYPE_CHECK (ARRAY_TYPE)->type.maxval)
2263
2264 /* For a VECTOR_TYPE, this is the number of sub-parts of the vector.  */
2265 #define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
2266   (((unsigned HOST_WIDE_INT) 1) \
2267    << VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision)
2268
2269 /* Set precision to n when we have 2^n sub-parts of the vector.  */
2270 #define SET_TYPE_VECTOR_SUBPARTS(VECTOR_TYPE, X) \
2271   (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.precision = exact_log2 (X))
2272
2273 /* Indicates that objects of this type must be initialized by calling a
2274    function when they are created.  */
2275 #define TYPE_NEEDS_CONSTRUCTING(NODE) \
2276   (TYPE_CHECK (NODE)->type.needs_constructing_flag)
2277
2278 /* Indicates that objects of this type (a UNION_TYPE), should be passed
2279    the same way that the first union alternative would be passed.  */
2280 #define TYPE_TRANSPARENT_UNION(NODE)  \
2281   (UNION_TYPE_CHECK (NODE)->type.transparent_union_flag)
2282
2283 /* For an ARRAY_TYPE, indicates that it is not permitted to
2284    take the address of a component of the type.  */
2285 #define TYPE_NONALIASED_COMPONENT(NODE) \
2286   (ARRAY_TYPE_CHECK (NODE)->type.transparent_union_flag)
2287
2288 /* Indicated that objects of this type should be laid out in as
2289    compact a way as possible.  */
2290 #define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
2291
2292 /* Used by type_contains_placeholder_p to avoid recomputation.
2293    Values are: 0 (unknown), 1 (false), 2 (true).  Never access
2294    this field directly.  */
2295 #define TYPE_CONTAINS_PLACEHOLDER_INTERNAL(NODE) \
2296   (TYPE_CHECK (NODE)->type.contains_placeholder_bits)
2297
2298 struct die_struct;
2299
2300 struct tree_type GTY(())
2301 {
2302   struct tree_common common;
2303   tree values;
2304   tree size;
2305   tree size_unit;
2306   tree attributes;
2307   unsigned int uid;
2308
2309   unsigned int precision : 9;
2310   ENUM_BITFIELD(machine_mode) mode : 7;
2311
2312   unsigned string_flag : 1;
2313   unsigned no_force_blk_flag : 1;
2314   unsigned needs_constructing_flag : 1;
2315   unsigned transparent_union_flag : 1;
2316   unsigned packed_flag : 1;
2317   unsigned restrict_flag : 1;
2318   unsigned contains_placeholder_bits : 2;
2319
2320   unsigned lang_flag_0 : 1;
2321   unsigned lang_flag_1 : 1;
2322   unsigned lang_flag_2 : 1;
2323   unsigned lang_flag_3 : 1;
2324   unsigned lang_flag_4 : 1;
2325   unsigned lang_flag_5 : 1;
2326   unsigned lang_flag_6 : 1;
2327   unsigned user_align : 1;
2328
2329   unsigned int align;
2330   tree pointer_to;
2331   tree reference_to;
2332   union tree_type_symtab {
2333     int GTY ((tag ("0"))) address;
2334     const char * GTY ((tag ("1"))) pointer;
2335     struct die_struct * GTY ((tag ("2"))) die;
2336   } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
2337           descbits ("2"))) symtab;
2338   tree name;
2339   tree minval;
2340   tree maxval;
2341   tree next_variant;
2342   tree main_variant;
2343   tree binfo;
2344   tree context;
2345   tree canonical;
2346   alias_set_type alias_set;
2347   /* Points to a structure whose details depend on the language in use.  */
2348   struct lang_type *lang_specific;
2349 };
2350 \f
2351 /* Define accessor macros for information about type inheritance
2352    and basetypes.
2353
2354    A "basetype" means a particular usage of a data type for inheritance
2355    in another type.  Each such basetype usage has its own "binfo"
2356    object to describe it.  The binfo object is a TREE_VEC node.
2357
2358    Inheritance is represented by the binfo nodes allocated for a
2359    given type.  For example, given types C and D, such that D is
2360    inherited by C, 3 binfo nodes will be allocated: one for describing
2361    the binfo properties of C, similarly one for D, and one for
2362    describing the binfo properties of D as a base type for C.
2363    Thus, given a pointer to class C, one can get a pointer to the binfo
2364    of D acting as a basetype for C by looking at C's binfo's basetypes.  */
2365
2366 /* BINFO specific flags.  */
2367
2368 /* Nonzero means that the derivation chain is via a `virtual' declaration.  */
2369 #define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag)
2370
2371 /* Flags for language dependent use.  */
2372 #define BINFO_MARKED(NODE) TREE_LANG_FLAG_0(TREE_BINFO_CHECK(NODE))
2373 #define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1(TREE_BINFO_CHECK(NODE))
2374 #define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2(TREE_BINFO_CHECK(NODE))
2375 #define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3(TREE_BINFO_CHECK(NODE))
2376 #define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4(TREE_BINFO_CHECK(NODE))
2377 #define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5(TREE_BINFO_CHECK(NODE))
2378 #define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6(TREE_BINFO_CHECK(NODE))
2379
2380 /* The actual data type node being inherited in this basetype.  */
2381 #define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE))
2382
2383 /* The offset where this basetype appears in its containing type.
2384    BINFO_OFFSET slot holds the offset (in bytes)
2385    from the base of the complete object to the base of the part of the
2386    object that is allocated on behalf of this `type'.
2387    This is always 0 except when there is multiple inheritance.  */
2388
2389 #define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset)
2390 #define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
2391
2392 /* The virtual function table belonging to this basetype.  Virtual
2393    function tables provide a mechanism for run-time method dispatching.
2394    The entries of a virtual function table are language-dependent.  */
2395
2396 #define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable)
2397
2398 /* The virtual functions in the virtual function table.  This is
2399    a TREE_LIST that is used as an initial approximation for building
2400    a virtual function table for this basetype.  */
2401 #define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals)
2402
2403 /* A vector of binfos for the direct basetypes inherited by this
2404    basetype.
2405
2406    If this basetype describes type D as inherited in C, and if the
2407    basetypes of D are E and F, then this vector contains binfos for
2408    inheritance of E and F by C.  */
2409 #define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK(NODE)->binfo.base_binfos)
2410
2411 /* The number of basetypes for NODE.  */
2412 #define BINFO_N_BASE_BINFOS(NODE) (VEC_length (tree, BINFO_BASE_BINFOS (NODE)))
2413
2414 /* Accessor macro to get to the Nth base binfo of this binfo.  */
2415 #define BINFO_BASE_BINFO(NODE,N) \
2416  (VEC_index (tree, BINFO_BASE_BINFOS (NODE), (N)))
2417 #define BINFO_BASE_ITERATE(NODE,N,B) \
2418  (VEC_iterate (tree, BINFO_BASE_BINFOS (NODE), (N), (B)))
2419 #define BINFO_BASE_APPEND(NODE,T) \
2420  (VEC_quick_push (tree, BINFO_BASE_BINFOS (NODE), (T)))
2421
2422 /* For a BINFO record describing a virtual base class, i.e., one where
2423    TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
2424    base.  The actual contents are language-dependent.  In the C++
2425    front-end this field is an INTEGER_CST giving an offset into the
2426    vtable where the offset to the virtual base can be found.  */
2427 #define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field)
2428
2429 /* Indicates the accesses this binfo has to its bases. The values are
2430    access_public_node, access_protected_node or access_private_node.
2431    If this array is not present, public access is implied.  */
2432 #define BINFO_BASE_ACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses)
2433
2434 #define BINFO_BASE_ACCESS(NODE,N) \
2435   VEC_index (tree, BINFO_BASE_ACCESSES (NODE), (N))
2436 #define BINFO_BASE_ACCESS_APPEND(NODE,T) \
2437   VEC_quick_push (tree, BINFO_BASE_ACCESSES (NODE), (T))
2438
2439 /* The index in the VTT where this subobject's sub-VTT can be found.
2440    NULL_TREE if there is no sub-VTT.  */
2441 #define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_subvtt)
2442
2443 /* The index in the VTT where the vptr for this subobject can be
2444    found.  NULL_TREE if there is no secondary vptr in the VTT.  */
2445 #define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr)
2446
2447 /* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
2448    inheriting this base for non-virtual bases. For virtual bases it
2449    points either to the binfo for which this is a primary binfo, or to
2450    the binfo of the most derived type.  */
2451 #define BINFO_INHERITANCE_CHAIN(NODE) \
2452         (TREE_BINFO_CHECK(NODE)->binfo.inheritance)
2453
2454 struct tree_binfo GTY (())
2455 {
2456   struct tree_common common;
2457
2458   tree offset;
2459   tree vtable;
2460   tree virtuals;
2461   tree vptr_field;
2462   VEC(tree,gc) *base_accesses;
2463   tree inheritance;
2464
2465   tree vtt_subvtt;
2466   tree vtt_vptr;
2467
2468   VEC(tree,none) base_binfos;
2469 };
2470
2471 \f
2472 /* Define fields and accessors for nodes representing declared names.  */
2473
2474 /* Nonzero if DECL represents a variable for the SSA passes.  */
2475 #define SSA_VAR_P(DECL)                                                 \
2476         (TREE_CODE (DECL) == VAR_DECL                                   \
2477          || TREE_CODE (DECL) == PARM_DECL                               \
2478          || TREE_CODE (DECL) == RESULT_DECL                             \
2479          || MTAG_P (DECL)                                               \
2480          || (TREE_CODE (DECL) == SSA_NAME                               \
2481              && (TREE_CODE (SSA_NAME_VAR (DECL)) == VAR_DECL            \
2482                  || TREE_CODE (SSA_NAME_VAR (DECL)) == PARM_DECL        \
2483                  || TREE_CODE (SSA_NAME_VAR (DECL)) == RESULT_DECL      \
2484                  || MTAG_P (SSA_NAME_VAR (DECL)))))
2485
2486
2487
2488
2489 /* Enumerate visibility settings.  */
2490 #ifndef SYMBOL_VISIBILITY_DEFINED
2491 #define SYMBOL_VISIBILITY_DEFINED
2492 enum symbol_visibility
2493 {
2494   VISIBILITY_DEFAULT,
2495   VISIBILITY_PROTECTED,
2496   VISIBILITY_HIDDEN,
2497   VISIBILITY_INTERNAL
2498 };
2499 #endif
2500
2501 struct function;
2502
2503
2504 /* This is the name of the object as written by the user.
2505    It is an IDENTIFIER_NODE.  */
2506 #define DECL_NAME(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.name)
2507
2508 /* Every ..._DECL node gets a unique number.  */
2509 #define DECL_UID(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.uid)
2510
2511 /* These two fields describe where in the source code the declaration
2512    was.  If the declaration appears in several places (as for a C
2513    function that is declared first and then defined later), this
2514    information should refer to the definition.  */
2515 #define DECL_SOURCE_LOCATION(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.locus)
2516 #define DECL_SOURCE_FILE(NODE) LOCATION_FILE (DECL_SOURCE_LOCATION (NODE))
2517 #define DECL_SOURCE_LINE(NODE) LOCATION_LINE (DECL_SOURCE_LOCATION (NODE))
2518 #ifdef USE_MAPPED_LOCATION
2519 #define DECL_IS_BUILTIN(DECL) \
2520   (DECL_SOURCE_LOCATION (DECL) <= BUILTINS_LOCATION)
2521 #else
2522 #define DECL_IS_BUILTIN(DECL) (DECL_SOURCE_LINE(DECL) == 0)
2523 #endif
2524
2525 /*  For FIELD_DECLs, this is the RECORD_TYPE, UNION_TYPE, or
2526     QUAL_UNION_TYPE node that the field is a member of.  For VAR_DECL,
2527     PARM_DECL, FUNCTION_DECL, LABEL_DECL, and CONST_DECL nodes, this
2528     points to either the FUNCTION_DECL for the containing function,
2529     the RECORD_TYPE or UNION_TYPE for the containing type, or
2530     NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
2531     scope".  */
2532 #define DECL_CONTEXT(NODE) (DECL_MINIMAL_CHECK (NODE)->decl_minimal.context)
2533 #define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl_minimal.context)
2534 struct tree_decl_minimal GTY(())
2535 {
2536   struct tree_common common;
2537   location_t locus;
2538   unsigned int uid;
2539   tree name;
2540   tree context;
2541 };
2542
2543 /* When computing aliasing information, we represent the memory pointed-to
2544    by pointers with artificial variables called "memory tags" (MT).  There
2545    are two kinds of tags, namely symbol and name:
2546
2547    Symbol tags (SMT) are used in flow-insensitive alias analysis, they
2548    represent all the pointed-to locations and variables pointed-to by
2549    the same pointer symbol.  Usually, this set is computed using
2550    type-based analysis (i.e., alias set classes), but this may not
2551    always be the case.
2552
2553    Name tags (NMT) are used in flow-sensitive points-to alias
2554    analysis, they represent the variables and memory locations
2555    pointed-to by a specific SSA_NAME pointer.
2556
2557    In general, given a pointer P with a symbol tag SMT, the alias set
2558    of SMT should be the union of all the alias sets of the NMTs of
2559    every SSA_NAME for P.  */
2560 struct tree_memory_tag GTY(())
2561 {
2562   struct tree_decl_minimal common;
2563
2564   bitmap GTY ((skip)) aliases;
2565
2566   /* True if this tag has global scope.  */
2567   unsigned int is_global : 1;
2568
2569   /* True if this tag is the first field of an aggregate type that
2570      can be used to find adjacent SFTs belonging to the same aggregate.  */
2571   unsigned int base_for_components : 1;
2572
2573   /* True if this tag should not be grouped into a memory partition.  */
2574   unsigned int unpartitionable : 1;
2575 };
2576
2577 #define MTAG_GLOBAL(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.is_global)
2578 #define MTAG_ALIASES(NODE) (TREE_MEMORY_TAG_CHECK (NODE)->mtag.aliases)
2579
2580 struct tree_struct_field_tag GTY(())
2581 {
2582   struct tree_memory_tag common;
2583
2584   /* Parent variable.  */
2585   tree parent_var;
2586
2587   /* Offset inside structure.  */
2588   unsigned HOST_WIDE_INT offset;
2589
2590   /* Size of the field.  */
2591   unsigned HOST_WIDE_INT size;
2592
2593   /* Alias set for a DECL_NONADDRESSABLE_P field.  Otherwise -1.  */
2594   alias_set_type alias_set;
2595 };
2596 #define SFT_PARENT_VAR(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.parent_var)
2597 #define SFT_OFFSET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.offset)
2598 #define SFT_SIZE(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.size)
2599 #define SFT_NONADDRESSABLE_P(NODE) \
2600   (STRUCT_FIELD_TAG_CHECK (NODE)->sft.alias_set != -1)
2601 #define SFT_ALIAS_SET(NODE) (STRUCT_FIELD_TAG_CHECK (NODE)->sft.alias_set)
2602 #define SFT_UNPARTITIONABLE_P(NODE) \
2603   (STRUCT_FIELD_TAG_CHECK (NODE)->sft.common.unpartitionable)
2604 #define SFT_BASE_FOR_COMPONENTS_P(NODE) \
2605   (STRUCT_FIELD_TAG_CHECK (NODE)->sft.common.base_for_components)
2606
2607 /* Memory Partition Tags (MPTs) group memory symbols under one
2608    common name for the purposes of placing memory PHI nodes.  */
2609
2610 struct tree_memory_partition_tag GTY(())
2611 {
2612   struct tree_memory_tag common;
2613
2614   /* Set of symbols grouped under this MPT.  */
2615   bitmap symbols;
2616 };
2617
2618 #define MPT_SYMBOLS(NODE)       (MEMORY_PARTITION_TAG_CHECK (NODE)->mpt.symbols)
2619
2620
2621 /* For any sort of a ..._DECL node, this points to the original (abstract)
2622    decl node which this decl is an instance of, or else it is NULL indicating
2623    that this decl is not an instance of some other decl.  For example,
2624    in a nested declaration of an inline function, this points back to the
2625    definition.  */
2626 #define DECL_ABSTRACT_ORIGIN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_origin)
2627
2628 /* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
2629    origin.  This is useful when setting the DECL_ABSTRACT_ORIGIN.  */
2630 #define DECL_ORIGIN(NODE) \
2631   (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
2632
2633 /* Nonzero for any sort of ..._DECL node means this decl node represents an
2634    inline instance of some original (abstract) decl from an inline function;
2635    suppress any warnings about shadowing some other variable.  FUNCTION_DECL
2636    nodes can also have their abstract origin set to themselves.  */
2637 #define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
2638                                 && DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
2639
2640 /* In a DECL this is the field where attributes are stored.  */
2641 #define DECL_ATTRIBUTES(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.attributes)
2642
2643 /* For a FUNCTION_DECL, holds the tree of BINDINGs.
2644    For a TRANSLATION_UNIT_DECL, holds the namespace's BLOCK.
2645    For a VAR_DECL, holds the initial value.
2646    For a PARM_DECL, not used--default
2647    values for parameters are encoded in the type of the function,
2648    not in the PARM_DECL slot.
2649    For a FIELD_DECL, this is used for enumeration values and the C
2650    frontend uses it for temporarily storing bitwidth of bitfields.
2651
2652    ??? Need to figure out some way to check this isn't a PARM_DECL.  */
2653 #define DECL_INITIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.initial)
2654
2655 /* Holds the size of the datum, in bits, as a tree expression.
2656    Need not be constant.  */
2657 #define DECL_SIZE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size)
2658 /* Likewise for the size in bytes.  */
2659 #define DECL_SIZE_UNIT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.size_unit)
2660 /* Holds the alignment required for the datum, in bits.  */
2661 #define DECL_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.align)
2662 /* The alignment of NODE, in bytes.  */
2663 #define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
2664 /* Set if the alignment of this DECL has been set by the user, for
2665    example with an 'aligned' attribute.  */
2666 #define DECL_USER_ALIGN(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.user_align)
2667 /* Holds the machine mode corresponding to the declaration of a variable or
2668    field.  Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
2669    FIELD_DECL.  */
2670 #define DECL_MODE(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.mode)
2671
2672 /* For FUNCTION_DECL, if it is built-in, this identifies which built-in
2673    operation it is.  Note, however, that this field is overloaded, with
2674    DECL_BUILT_IN_CLASS as the discriminant, so the latter must always be
2675    checked before any access to the former.  */
2676 #define DECL_FUNCTION_CODE(NODE) \
2677   (FUNCTION_DECL_CHECK (NODE)->function_decl.function_code)
2678 #define DECL_DEBUG_EXPR_IS_FROM(NODE) \
2679   (DECL_COMMON_CHECK (NODE)->decl_common.debug_expr_is_from)
2680
2681 /* Nonzero for a given ..._DECL node means that the name of this node should
2682    be ignored for symbolic debug purposes.  */
2683 #define DECL_IGNORED_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.ignored_flag)
2684
2685 /* Nonzero for a given ..._DECL node means that this node represents an
2686    "abstract instance" of the given declaration (e.g. in the original
2687    declaration of an inline function).  When generating symbolic debugging
2688    information, we mustn't try to generate any address information for nodes
2689    marked as "abstract instances" because we don't actually generate
2690    any code or allocate any data space for such instances.  */
2691 #define DECL_ABSTRACT(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.abstract_flag)
2692
2693 /* Language-specific decl information.  */
2694 #define DECL_LANG_SPECIFIC(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_specific)
2695
2696 /* In a VAR_DECL or FUNCTION_DECL, nonzero means external reference:
2697    do not allocate storage, and refer to a definition elsewhere.  Note that
2698    this does not necessarily imply the entity represented by NODE
2699    has no program source-level definition in this translation unit.  For
2700    example, for a FUNCTION_DECL, DECL_SAVED_TREE may be non-NULL and
2701    DECL_EXTERNAL may be true simultaneously; that can be the case for
2702    a C99 "extern inline" function.  */
2703 #define DECL_EXTERNAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.decl_flag_2)
2704
2705 /* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
2706    For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
2707
2708    For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
2709
2710    Also set in some languages for variables, etc., outside the normal
2711    lexical scope, such as class instance variables.  */
2712 #define DECL_NONLOCAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.nonlocal_flag)
2713
2714 /* Used in VAR_DECLs to indicate that the variable is a vtable.
2715    Used in FIELD_DECLs for vtable pointers.
2716    Used in FUNCTION_DECLs to indicate that the function is virtual.  */
2717 #define DECL_VIRTUAL_P(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.virtual_flag)
2718
2719 /* Used to indicate that this DECL represents a compiler-generated entity.  */
2720 #define DECL_ARTIFICIAL(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.artificial_flag)
2721
2722 /* Additional flags for language-specific uses.  */
2723 #define DECL_LANG_FLAG_0(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_0)
2724 #define DECL_LANG_FLAG_1(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_1)
2725 #define DECL_LANG_FLAG_2(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_2)
2726 #define DECL_LANG_FLAG_3(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_3)
2727 #define DECL_LANG_FLAG_4(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_4)
2728 #define DECL_LANG_FLAG_5(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_5)
2729 #define DECL_LANG_FLAG_6(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_6)
2730 #define DECL_LANG_FLAG_7(NODE) (DECL_COMMON_CHECK (NODE)->decl_common.lang_flag_7)
2731
2732 /* Used to indicate an alias set for the memory pointed to by this
2733    particular FIELD_DECL, PARM_DECL, or VAR_DECL, which must have
2734    pointer (or reference) type.  */
2735 #define DECL_POINTER_ALIAS_SET(NODE) \
2736   (DECL_COMMON_CHECK (NODE)->decl_common.pointer_alias_set)
2737
2738 /* Nonzero if an alias set has been assigned to this declaration.  */
2739 #define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
2740   (DECL_POINTER_ALIAS_SET (NODE) != - 1)
2741
2742 /* Nonzero for a decl which is at file scope.  */
2743 #define DECL_FILE_SCOPE_P(EXP)                                  \
2744   (! DECL_CONTEXT (EXP)                                         \
2745    || TREE_CODE (DECL_CONTEXT (EXP)) == TRANSLATION_UNIT_DECL)
2746
2747 /* Nonzero for a decl that is decorated using attribute used.
2748    This indicates compiler tools that this decl needs to be preserved.  */
2749 #define DECL_PRESERVE_P(DECL) \
2750   DECL_COMMON_CHECK (DECL)->decl_common.preserve_flag
2751
2752 /* For function local variables of COMPLEX and VECTOR types,
2753    indicates that the variable is not aliased, and that all
2754    modifications to the variable have been adjusted so that
2755    they are killing assignments.  Thus the variable may now
2756    be treated as a GIMPLE register, and use real instead of
2757    virtual ops in SSA form.  */
2758 #define DECL_GIMPLE_REG_P(DECL) \
2759   DECL_COMMON_CHECK (DECL)->decl_common.gimple_reg_flag
2760
2761 /* For a DECL with pointer type, this is set if Type Based Alias
2762    Analysis should not be applied to this DECL.  */
2763 #define DECL_NO_TBAA_P(DECL) \
2764   DECL_COMMON_CHECK (DECL)->decl_common.no_tbaa_flag
2765
2766 struct tree_decl_common GTY(())
2767 {
2768   struct tree_decl_minimal common;
2769   tree size;
2770
2771   ENUM_BITFIELD(machine_mode) mode : 8;
2772
2773   unsigned nonlocal_flag : 1;
2774   unsigned virtual_flag : 1;
2775   unsigned ignored_flag : 1;
2776   unsigned abstract_flag : 1;
2777   unsigned artificial_flag : 1;
2778   unsigned user_align : 1;
2779   unsigned preserve_flag: 1;
2780   unsigned debug_expr_is_from : 1;
2781
2782   unsigned lang_flag_0 : 1;
2783   unsigned lang_flag_1 : 1;
2784   unsigned lang_flag_2 : 1;
2785   unsigned lang_flag_3 : 1;
2786   unsigned lang_flag_4 : 1;
2787   unsigned lang_flag_5 : 1;
2788   unsigned lang_flag_6 : 1;
2789   unsigned lang_flag_7 : 1;
2790
2791   /* In LABEL_DECL, this is DECL_ERROR_ISSUED.
2792      In VAR_DECL and PARM_DECL, this is DECL_REGISTER.  */
2793   unsigned decl_flag_0 : 1;
2794   /* In FIELD_DECL, this is DECL_PACKED.  */
2795   unsigned decl_flag_1 : 1;
2796   /* In FIELD_DECL, this is DECL_BIT_FIELD
2797      In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL.
2798      In TYPE_DECL, this is TYPE_DECL_SUPRESS_DEBUG.  */
2799   unsigned decl_flag_2 : 1;
2800   /* In FIELD_DECL, this is DECL_NONADDRESSABLE_P
2801      In VAR_DECL and PARM_DECL, this is DECL_HAS_VALUE_EXPR.  */
2802   unsigned decl_flag_3 : 1;
2803   /* Logically, these two would go in a theoretical base shared by var and
2804      parm decl. */
2805   unsigned gimple_reg_flag : 1;
2806   /* In a DECL with pointer type, set if no TBAA should be done.  */
2807   unsigned no_tbaa_flag : 1;
2808   /* Padding so that 'align' can be on a 32-bit boundary.  */
2809   unsigned decl_common_unused : 2;
2810
2811   unsigned int align : 24;
2812   /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs.  */
2813   unsigned int off_align : 8;
2814
2815   tree size_unit;
2816   tree initial;
2817   tree attributes;
2818   tree abstract_origin;
2819
2820   alias_set_type pointer_alias_set;
2821   /* Points to a structure whose details depend on the language in use.  */
2822   struct lang_decl *lang_specific;
2823 };
2824
2825 extern tree decl_value_expr_lookup (tree);
2826 extern void decl_value_expr_insert (tree, tree);
2827
2828 /* In a VAR_DECL or PARM_DECL, the location at which the value may be found,
2829    if transformations have made this more complicated than evaluating the
2830    decl itself.  This should only be used for debugging; once this field has
2831    been set, the decl itself may not legitimately appear in the function.  */
2832 #define DECL_HAS_VALUE_EXPR_P(NODE) \
2833   (TREE_CHECK2 (NODE, VAR_DECL, PARM_DECL)->decl_common.decl_flag_3)
2834 #define DECL_VALUE_EXPR(NODE) \
2835   (decl_value_expr_lookup (DECL_WRTL_CHECK (NODE)))
2836 #define SET_DECL_VALUE_EXPR(NODE, VAL)                  \
2837   (decl_value_expr_insert (DECL_WRTL_CHECK (NODE), VAL))
2838
2839 /* Holds the RTL expression for the value of a variable or function.
2840    This value can be evaluated lazily for functions, variables with
2841    static storage duration, and labels.  */
2842 #define DECL_RTL(NODE)                                  \
2843   (DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl            \
2844    ? (NODE)->decl_with_rtl.rtl                                  \
2845    : (make_decl_rtl (NODE), (NODE)->decl_with_rtl.rtl))
2846
2847 /* Set the DECL_RTL for NODE to RTL.  */
2848 #define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
2849
2850 /* Returns nonzero if NODE is a tree node that can contain RTL.  */
2851 #define HAS_RTL_P(NODE) (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WRTL))
2852
2853 /* Returns nonzero if the DECL_RTL for NODE has already been set.  */
2854 #define DECL_RTL_SET_P(NODE)  (HAS_RTL_P (NODE) && DECL_WRTL_CHECK (NODE)->decl_with_rtl.rtl != NULL)
2855
2856 /* Copy the RTL from NODE1 to NODE2.  If the RTL was not set for
2857    NODE1, it will not be set for NODE2; this is a lazy copy.  */
2858 #define COPY_DECL_RTL(NODE1, NODE2) \
2859   (DECL_WRTL_CHECK (NODE2)->decl_with_rtl.rtl = DECL_WRTL_CHECK (NODE1)->decl_with_rtl.rtl)
2860
2861 /* The DECL_RTL for NODE, if it is set, or NULL, if it is not set.  */
2862 #define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
2863
2864 /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.  */
2865 #define DECL_REGISTER(NODE) (DECL_WRTL_CHECK (NODE)->decl_common.decl_flag_0)
2866
2867 struct tree_decl_with_rtl GTY(())
2868 {
2869   struct tree_decl_common common;
2870   rtx rtl;
2871 };
2872
2873 /* In a FIELD_DECL, this is the field position, counting in bytes, of the
2874    DECL_OFFSET_ALIGN-bit-sized word containing the bit closest to the beginning
2875    of the structure.  */
2876 #define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.offset)
2877
2878 /* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
2879    field from DECL_FIELD_OFFSET.  This field may be nonzero even for fields
2880    that are not bit fields (since DECL_OFFSET_ALIGN may be larger than the
2881    natural alignment of the field's type).  */
2882 #define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_offset)
2883
2884 /* In a FIELD_DECL, this indicates whether the field was a bit-field and
2885    if so, the type that was originally specified for it.
2886    TREE_TYPE may have been modified (in finish_struct).  */
2887 #define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.bit_field_type)
2888
2889 /* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
2890    if nonzero, indicates that the field occupies the type.  */
2891 #define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.qualifier)
2892
2893 /* For FIELD_DECLs, off_align holds the number of low-order bits of
2894    DECL_FIELD_OFFSET which are known to be always zero.
2895    DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
2896    has.  */
2897 #define DECL_OFFSET_ALIGN(NODE) \
2898   (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl_common.off_align)
2899
2900 /* Specify that DECL_ALIGN(NODE) is a multiple of X.  */
2901 #define SET_DECL_OFFSET_ALIGN(NODE, X) \
2902   (FIELD_DECL_CHECK (NODE)->decl_common.off_align = exact_log2 ((X) & -(X)))
2903 /* 1 if the alignment for this type was requested by "aligned" attribute,
2904    0 if it is the default for this type.  */
2905
2906 /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
2907    which this FIELD_DECL is defined.  This information is needed when
2908    writing debugging information about vfield and vbase decls for C++.  */
2909 #define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->field_decl.fcontext)
2910
2911 /* In a FIELD_DECL, indicates this field should be bit-packed.  */
2912 #define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_1)
2913
2914 /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
2915    specially.  */
2916 #define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_2)
2917
2918 /* Used in a FIELD_DECL to indicate that we cannot form the address of
2919    this component.  */
2920 #define DECL_NONADDRESSABLE_P(NODE) \
2921   (FIELD_DECL_CHECK (NODE)->decl_common.decl_flag_3)
2922
2923 struct tree_field_decl GTY(())
2924 {
2925   struct tree_decl_common common;
2926
2927   tree offset;
2928   tree bit_field_type;
2929   tree qualifier;
2930   tree bit_offset;
2931   tree fcontext;
2932
2933 };
2934
2935 /* A numeric unique identifier for a LABEL_DECL.  The UID allocation is
2936    dense, unique within any one function, and may be used to index arrays.
2937    If the value is -1, then no UID has been assigned.  */
2938 #define LABEL_DECL_UID(NODE) \
2939   (LABEL_DECL_CHECK (NODE)->decl_common.pointer_alias_set)
2940
2941 /* In LABEL_DECL nodes, nonzero means that an error message about
2942    jumping into such a binding contour has been printed for this label.  */
2943 #define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl_common.decl_flag_0)
2944
2945 struct tree_label_decl GTY(())
2946 {
2947   struct tree_decl_with_rtl common;
2948 };
2949
2950 struct tree_result_decl GTY(())
2951 {
2952   struct tree_decl_with_rtl common;
2953 };
2954
2955 struct tree_const_decl GTY(())
2956 {
2957   struct tree_decl_with_rtl common;
2958 };
2959
2960 /* For a PARM_DECL, records the data type used to pass the argument,
2961    which may be different from the type seen in the program.  */
2962 #define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl_common.initial)
2963
2964 /* For PARM_DECL, holds an RTL for the stack slot or register
2965    where the data was actually passed.  */
2966 #define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->parm_decl.incoming_rtl)
2967
2968 struct tree_parm_decl GTY(())
2969 {
2970   struct tree_decl_with_rtl common;
2971   rtx incoming_rtl;
2972 };
2973
2974
2975 /* Nonzero in a decl means that the gimplifier has seen (or placed)
2976    this variable in a BIND_EXPR.  */
2977 #define DECL_SEEN_IN_BIND_EXPR_P(NODE) \
2978   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.seen_in_bind_expr)
2979
2980 /* Used to indicate that the linkage status of this DECL is not yet known,
2981    so it should not be output now.  */
2982 #define DECL_DEFER_OUTPUT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.defer_output)
2983
2984 /* Nonzero for a given ..._DECL node means that no warnings should be
2985    generated just because this node is unused.  */
2986 #define DECL_IN_SYSTEM_HEADER(NODE) \
2987   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.in_system_header_flag)
2988
2989   /* Used to indicate that this DECL has weak linkage.  */
2990 #define DECL_WEAK(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.weak_flag)
2991
2992 /* Internal to the gimplifier.  Indicates that the value is a formal
2993    temporary controlled by the gimplifier.  */
2994 #define DECL_GIMPLE_FORMAL_TEMP_P(DECL) \
2995   DECL_WITH_VIS_CHECK (DECL)->decl_with_vis.gimple_formal_temp
2996
2997 /* Used to indicate that the DECL is a dllimport.  */
2998 #define DECL_DLLIMPORT_P(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.dllimport_flag)
2999
3000 /* DECL_BASED_ON_RESTRICT_P records whether a VAR_DECL is a temporary
3001    based on a variable with a restrict qualified type.  If it is,
3002    DECL_RESTRICT_BASE returns the restrict qualified variable on which
3003    it is based.  */
3004
3005 #define DECL_BASED_ON_RESTRICT_P(NODE) \
3006   (VAR_DECL_CHECK (NODE)->decl_with_vis.based_on_restrict_p)
3007 #define DECL_GET_RESTRICT_BASE(NODE) \
3008   (decl_restrict_base_lookup (VAR_DECL_CHECK (NODE)))
3009 #define SET_DECL_RESTRICT_BASE(NODE, VAL) \
3010   (decl_restrict_base_insert (VAR_DECL_CHECK (NODE), (VAL)))
3011
3012 extern tree decl_restrict_base_lookup (tree);
3013 extern void decl_restrict_base_insert (tree, tree);
3014
3015 /* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
3016    not be put out unless it is needed in this translation unit.
3017    Entities like this are shared across translation units (like weak
3018    entities), but are guaranteed to be generated by any translation
3019    unit that needs them, and therefore need not be put out anywhere
3020    where they are not needed.  DECL_COMDAT is just a hint to the
3021    back-end; it is up to front-ends which set this flag to ensure
3022    that there will never be any harm, other than bloat, in putting out
3023    something which is DECL_COMDAT.  */
3024 #define DECL_COMDAT(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.comdat_flag)
3025
3026 /* A replaceable function is one which may be replaced at link-time
3027    with an entirely different definition, provided that the
3028    replacement has the same type.  For example, functions declared
3029    with __attribute__((weak)) on most systems are replaceable.
3030
3031    COMDAT functions are not replaceable, since all definitions of the
3032    function must be equivalent.  It is important that COMDAT functions
3033    not be treated as replaceable so that use of C++ template
3034    instantiations is not penalized.
3035
3036    For example, DECL_REPLACEABLE is used to determine whether or not a
3037    function (including a template instantiation) which is not
3038    explicitly declared "inline" can be inlined.  If the function is
3039    DECL_REPLACEABLE then it is not safe to do the inlining, since the
3040    implementation chosen at link-time may be different.  However, a
3041    function that is not DECL_REPLACEABLE can be inlined, since all
3042    versions of the function will be functionally identical.  */
3043 #define DECL_REPLACEABLE_P(NODE) \
3044   (!DECL_COMDAT (NODE) && !targetm.binds_local_p (NODE))
3045
3046 /* The name of the object as the assembler will see it (but before any
3047    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
3048    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
3049 #define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
3050
3051 /* Return true if NODE is a NODE that can contain a DECL_ASSEMBLER_NAME.
3052    This is true of all DECL nodes except FIELD_DECL.  */
3053 #define HAS_DECL_ASSEMBLER_NAME_P(NODE) \
3054   (CODE_CONTAINS_STRUCT (TREE_CODE (NODE), TS_DECL_WITH_VIS))
3055
3056 /* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set.  If zero,
3057    the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
3058    yet.  */
3059 #define DECL_ASSEMBLER_NAME_SET_P(NODE) \
3060   (HAS_DECL_ASSEMBLER_NAME_P (NODE) &&  DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name != NULL_TREE)
3061
3062 /* Set the DECL_ASSEMBLER_NAME for NODE to NAME.  */
3063 #define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
3064   (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.assembler_name = (NAME))
3065
3066 /* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2.  Note that if DECL1's
3067    DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
3068    the DECL_ASSEMBLER_NAME of either DECL to be set.  In other words, the
3069    semantics of using this macro, are different than saying:
3070
3071      SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
3072
3073    which will try to set the DECL_ASSEMBLER_NAME for DECL1.  */
3074
3075 #define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2)                          \
3076   (DECL_ASSEMBLER_NAME_SET_P (DECL1)                                    \
3077    ? (void) SET_DECL_ASSEMBLER_NAME (DECL2,                             \
3078                                      DECL_ASSEMBLER_NAME (DECL1))       \
3079    : (void) 0)
3080
3081 /* Records the section name in a section attribute.  Used to pass
3082    the name from decl_attributes to make_function_rtl and make_decl_rtl.  */
3083 #define DECL_SECTION_NAME(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.section_name)
3084
3085 /* Value of the decls's visibility attribute */
3086 #define DECL_VISIBILITY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility)
3087
3088 /* Nonzero means that the decl had its visibility specified rather than
3089    being inferred.  */
3090 #define DECL_VISIBILITY_SPECIFIED(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.visibility_specified)
3091
3092 /* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
3093    multiple translation units should be merged.  */
3094 #define DECL_ONE_ONLY(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.one_only)
3095
3096 struct tree_decl_with_vis GTY(())
3097 {
3098  struct tree_decl_with_rtl common;
3099  tree assembler_name;
3100  tree section_name;
3101
3102  /* Belong to VAR_DECL exclusively.  */
3103  unsigned defer_output:1;
3104  unsigned hard_register:1;
3105  unsigned thread_local:1;
3106  unsigned common_flag:1;
3107  unsigned in_text_section : 1;
3108  unsigned gimple_formal_temp : 1;
3109  unsigned dllimport_flag : 1;
3110  unsigned based_on_restrict_p : 1;
3111  /* Used by C++.  Might become a generic decl flag.  */
3112  unsigned shadowed_for_var_p : 1;
3113
3114  /* Don't belong to VAR_DECL exclusively.  */
3115  unsigned in_system_header_flag : 1;
3116  unsigned weak_flag:1;
3117  unsigned seen_in_bind_expr : 1;
3118  unsigned comdat_flag : 1;
3119  ENUM_BITFIELD(symbol_visibility) visibility : 2;
3120  unsigned visibility_specified : 1;
3121  /* Belong to FUNCTION_DECL exclusively.  */
3122  unsigned one_only : 1;
3123  unsigned init_priority_p:1;
3124
3125  /* Belongs to VAR_DECL exclusively.  */
3126  ENUM_BITFIELD(tls_model) tls_model : 3;
3127  /* 11 unused bits. */
3128 };
3129
3130 /* In a VAR_DECL that's static,
3131    nonzero if the space is in the text section.  */
3132 #define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.in_text_section)
3133
3134 /* Nonzero for a given ..._DECL node means that this node should be
3135    put in .common, if possible.  If a DECL_INITIAL is given, and it
3136    is not error_mark_node, then the decl cannot be put in .common.  */
3137 #define DECL_COMMON(NODE) (DECL_WITH_VIS_CHECK (NODE)->decl_with_vis.common_flag)
3138
3139 /* In a VAR_DECL, nonzero if the decl is a register variable with
3140    an explicit asm specification.  */
3141 #define DECL_HARD_REGISTER(NODE)  (VAR_DECL_CHECK (NODE)->decl_with_vis.hard_register)
3142
3143 extern tree decl_debug_expr_lookup (tree);
3144 extern void decl_debug_expr_insert (tree, tree);
3145 /* For VAR_DECL, this is set to either an expression that it was split
3146    from (if DECL_DEBUG_EXPR_IS_FROM is true), otherwise a tree_list of
3147    subexpressions that it was split into.  */
3148 #define DECL_DEBUG_EXPR(NODE) \
3149   (decl_debug_expr_lookup (VAR_DECL_CHECK (NODE)))
3150
3151 #define SET_DECL_DEBUG_EXPR(NODE, VAL) \
3152   (decl_debug_expr_insert (VAR_DECL_CHECK (NODE), VAL))
3153
3154 /* An initializationp priority.  */
3155 typedef unsigned short priority_type;
3156
3157 extern priority_type decl_init_priority_lookup (tree);
3158 extern priority_type decl_fini_priority_lookup (tree);
3159 extern void decl_init_priority_insert (tree, priority_type);
3160 extern void decl_fini_priority_insert (tree, priority_type);
3161
3162 /* In a non-local VAR_DECL with static storage duration, true if the
3163    variable has an initialization priority.  If false, the variable
3164    will be initialized at the DEFAULT_INIT_PRIORITY.  */
3165 #define DECL_HAS_INIT_PRIORITY_P(NODE) \
3166   (VAR_DECL_CHECK (NODE)->decl_with_vis.init_priority_p)
3167
3168 /* For a VAR_DECL or FUNCTION_DECL the initialization priority of
3169    NODE.  */
3170 #define DECL_INIT_PRIORITY(NODE) \
3171   (decl_init_priority_lookup (NODE))
3172 /* Set the initialization priority for NODE to VAL.  */
3173 #define SET_DECL_INIT_PRIORITY(NODE, VAL) \
3174   (decl_init_priority_insert (NODE, VAL))
3175
3176 /* For a FUNCTION_DECL the finalization priority of NODE.  */
3177 #define DECL_FINI_PRIORITY(NODE) \
3178   (decl_fini_priority_lookup (NODE))
3179 /* Set the finalization priority for NODE to VAL.  */
3180 #define SET_DECL_FINI_PRIORITY(NODE, VAL) \
3181   (decl_fini_priority_insert (NODE, VAL))
3182
3183 /* The initialization priority for entities for which no explicit
3184    initialization priority has been specified.  */
3185 #define DEFAULT_INIT_PRIORITY 65535
3186
3187 /* The maximum allowed initialization priority.  */
3188 #define MAX_INIT_PRIORITY 65535
3189
3190 /* The largest priority value reserved for use by system runtime
3191    libraries.  */
3192 #define MAX_RESERVED_INIT_PRIORITY 100
3193
3194 /* In a VAR_DECL, the model to use if the data should be allocated from
3195    thread-local storage.  */
3196 #define DECL_TLS_MODEL(NODE) (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model)
3197
3198 /* In a VAR_DECL, nonzero if the data should be allocated from
3199    thread-local storage.  */
3200 #define DECL_THREAD_LOCAL_P(NODE) \
3201   (VAR_DECL_CHECK (NODE)->decl_with_vis.tls_model != TLS_MODEL_NONE)
3202
3203 struct tree_var_decl GTY(())
3204 {
3205   struct tree_decl_with_vis common;
3206 };
3207
3208
3209 /* This field is used to reference anything in decl.result and is meant only
3210    for use by the garbage collector.  */
3211 #define DECL_RESULT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.result)
3212
3213 /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
3214    Before the struct containing the FUNCTION_DECL is laid out,
3215    DECL_VINDEX may point to a FUNCTION_DECL in a base class which
3216    is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
3217    function.  When the class is laid out, this pointer is changed
3218    to an INTEGER_CST node which is suitable for use as an index
3219    into the virtual function table.
3220    C++ also uses this field in namespaces, hence the DECL_NON_COMMON_CHECK.  */
3221 #define DECL_VINDEX(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.vindex)
3222
3223 struct tree_decl_non_common GTY(())
3224
3225 {
3226   struct tree_decl_with_vis common;
3227   /* C++ uses this in namespaces.  */
3228   tree saved_tree;
3229   /* C++ uses this in templates.  */
3230   tree arguments;
3231   /* Almost all FE's use this.  */
3232   tree result;
3233   /* C++ uses this in namespaces.  */
3234   tree vindex;
3235 };
3236
3237 /* In FUNCTION_DECL, holds the decl for the return value.  */
3238 #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.result)
3239
3240 /* In a FUNCTION_DECL, nonzero if the function cannot be inlined.  */
3241 #define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.uninlinable)
3242
3243 /* In a FUNCTION_DECL, the saved representation of the body of the
3244    entire function.  */
3245 #define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.saved_tree)
3246
3247 /* Nonzero in a FUNCTION_DECL means this function should be treated
3248    as if it were a malloc, meaning it returns a pointer that is
3249    not an alias.  */
3250 #define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.malloc_flag)
3251
3252 /* Nonzero in a FUNCTION_DECL means this function should be treated as
3253    C++ operator new, meaning that it returns a pointer for which we
3254    should not use type based aliasing.  */
3255 #define DECL_IS_OPERATOR_NEW(NODE) \
3256   (FUNCTION_DECL_CHECK (NODE)->function_decl.operator_new_flag)
3257
3258 /* Nonzero in a FUNCTION_DECL means this function may return more
3259    than once.  */
3260 #define DECL_IS_RETURNS_TWICE(NODE) \
3261   (FUNCTION_DECL_CHECK (NODE)->function_decl.returns_twice_flag)
3262
3263 /* Nonzero in a FUNCTION_DECL means this function should be treated
3264    as "pure" function (like const function, but may read global memory).  */
3265 #define DECL_IS_PURE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.pure_flag)
3266
3267 /* Nonzero in a FUNCTION_DECL means this function should be treated
3268    as "novops" function (function that does not read global memory,
3269    but may have arbitrary side effects).  */
3270 #define DECL_IS_NOVOPS(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.novops_flag)
3271
3272 /* Used in FUNCTION_DECLs to indicate that they should be run automatically
3273    at the beginning or end of execution.  */
3274 #define DECL_STATIC_CONSTRUCTOR(NODE) \
3275   (FUNCTION_DECL_CHECK (NODE)->function_decl.static_ctor_flag)
3276
3277 #define DECL_STATIC_DESTRUCTOR(NODE) \
3278 (FUNCTION_DECL_CHECK (NODE)->function_decl.static_dtor_flag)
3279
3280 /* Used in FUNCTION_DECLs to indicate that function entry and exit should
3281    be instrumented with calls to support routines.  */
3282 #define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
3283   (FUNCTION_DECL_CHECK (NODE)->function_decl.no_instrument_function_entry_exit)
3284
3285 /* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
3286    disabled in this function.  */
3287 #define DECL_NO_LIMIT_STACK(NODE) \
3288   (FUNCTION_DECL_CHECK (NODE)->function_decl.no_limit_stack)
3289
3290 /* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
3291    static chain is not needed.  */
3292 #define DECL_NO_STATIC_CHAIN(NODE) \
3293   (FUNCTION_DECL_CHECK (NODE)->function_decl.regdecl_flag)
3294
3295 /* Nonzero for a decl that cgraph has decided should be inlined into
3296    at least one call site.  It is not meaningful to look at this
3297    directly; always use cgraph_function_possibly_inlined_p.  */
3298 #define DECL_POSSIBLY_INLINED(DECL) \
3299   FUNCTION_DECL_CHECK (DECL)->function_decl.possibly_inlined
3300
3301 /* Nonzero in a FUNCTION_DECL means this function can be substituted
3302    where it is called.  */
3303 #define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.inline_flag)
3304
3305 /* Nonzero in a FUNCTION_DECL means that this function was declared inline,
3306    such as via the `inline' keyword in C/C++.  This flag controls the linkage
3307    semantics of 'inline'; whether or not the function is inlined is
3308    controlled by DECL_INLINE.  */
3309 #define DECL_DECLARED_INLINE_P(NODE) \
3310   (FUNCTION_DECL_CHECK (NODE)->function_decl.declared_inline_flag)
3311
3312 /* Nonzero in a FUNCTION_DECL that should be always inlined by the inliner
3313    disregarding size and cost heuristics.  This is equivalent to using
3314    the always_inline attribute without the required diagnostics if the
3315    function cannot be inlined.  */
3316 #define DECL_DISREGARD_INLINE_LIMITS(NODE) \
3317   (FUNCTION_DECL_CHECK (NODE)->function_decl.disregard_inline_limits)
3318
3319 /* For FUNCTION_DECL, this holds a pointer to a structure ("struct function")
3320    that describes the status of this function.  */
3321 #define DECL_STRUCT_FUNCTION(NODE) (FUNCTION_DECL_CHECK (NODE)->function_decl.f)
3322
3323 /* In a FUNCTION_DECL, nonzero means a built in function.  */
3324 #define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
3325
3326 /* For a builtin function, identify which part of the compiler defined it.  */
3327 #define DECL_BUILT_IN_CLASS(NODE) \
3328    (FUNCTION_DECL_CHECK (NODE)->function_decl.built_in_class)
3329
3330 /* In FUNCTION_DECL, a chain of ..._DECL nodes.
3331    VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
3332    uses.  */
3333 #define DECL_ARGUMENTS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl_non_common.arguments)
3334 #define DECL_ARGUMENT_FLD(NODE) (DECL_NON_COMMON_CHECK (NODE)->decl_non_common.arguments)
3335
3336 /* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the
3337    arguments/result/saved_tree fields by front ends.   It was either inherit
3338    FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL,
3339    which seemed a bit strange.  */
3340
3341 struct tree_function_decl GTY(())
3342 {
3343   struct tree_decl_non_common common;
3344
3345   struct function *f;
3346
3347   /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
3348      DECL_FUNCTION_CODE.  Otherwise unused.
3349      ???  The bitfield needs to be able to hold all target function
3350           codes as well.  */
3351   ENUM_BITFIELD(built_in_function) function_code : 11;
3352   ENUM_BITFIELD(built_in_class) built_in_class : 2;
3353
3354   unsigned static_ctor_flag : 1;
3355   unsigned static_dtor_flag : 1;
3356   unsigned uninlinable : 1;
3357
3358   unsigned possibly_inlined : 1;
3359   unsigned novops_flag : 1;
3360   unsigned returns_twice_flag : 1;
3361   unsigned malloc_flag : 1;
3362   unsigned operator_new_flag : 1;
3363   unsigned pure_flag : 1;
3364   unsigned declared_inline_flag : 1;
3365   unsigned regdecl_flag : 1;
3366
3367   unsigned inline_flag : 1;
3368   unsigned no_instrument_function_entry_exit : 1;
3369   unsigned no_limit_stack : 1;
3370   unsigned disregard_inline_limits : 1;
3371
3372   /* 4 bits left */
3373 };
3374
3375 /* For a TYPE_DECL, holds the "original" type.  (TREE_TYPE has the copy.) */
3376 #define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl_non_common.result)
3377
3378 /* In a TYPE_DECL nonzero means the detail info about this type is not dumped
3379    into stabs.  Instead it will generate cross reference ('x') of names.
3380    This uses the same flag as DECL_EXTERNAL.  */
3381 #define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
3382   (TYPE_DECL_CHECK (NODE)->decl_common.decl_flag_2)
3383
3384 struct tree_type_decl GTY(())
3385 {
3386   struct tree_decl_non_common common;
3387
3388 };
3389 \f
3390 /* A STATEMENT_LIST chains statements together in GENERIC and GIMPLE.
3391    To reduce overhead, the nodes containing the statements are not trees.
3392    This avoids the overhead of tree_common on all linked list elements.
3393
3394    Use the interface in tree-iterator.h to access this node.  */
3395
3396 #define STATEMENT_LIST_HEAD(NODE) \
3397   (STATEMENT_LIST_CHECK (NODE)->stmt_list.head)
3398 #define STATEMENT_LIST_TAIL(NODE) \
3399   (STATEMENT_LIST_CHECK (NODE)->stmt_list.tail)
3400
3401 struct tree_statement_list_node
3402   GTY ((chain_next ("%h.next"), chain_prev ("%h.prev")))
3403 {
3404   struct tree_statement_list_node *prev;
3405   struct tree_statement_list_node *next;
3406   tree stmt;
3407 };
3408
3409 struct tree_statement_list
3410   GTY(())
3411 {
3412   struct tree_common common;
3413   struct tree_statement_list_node *head;
3414   struct tree_statement_list_node *tail;
3415 };
3416
3417 #define VALUE_HANDLE_ID(NODE)           \
3418   (VALUE_HANDLE_CHECK (NODE)->value_handle.id)
3419
3420 #define VALUE_HANDLE_EXPR_SET(NODE)     \
3421   (VALUE_HANDLE_CHECK (NODE)->value_handle.expr_set)
3422
3423 /* Defined and used in tree-ssa-pre.c.  */
3424
3425 struct tree_value_handle GTY(())
3426 {
3427   struct tree_common common;
3428
3429   /* The set of expressions represented by this handle.  */
3430   struct bitmap_set * GTY ((skip)) expr_set;
3431
3432   /* Unique ID for this value handle.  IDs are handed out in a
3433      conveniently dense form starting at 0, so that we can make
3434      bitmaps of value handles.  */
3435   unsigned int id;
3436 };
3437 \f
3438 /* Define the overall contents of a tree node.
3439    It may be any of the structures declared above
3440    for various types of node.  */
3441
3442 union tree_node GTY ((ptr_alias (union lang_tree_node),
3443                       desc ("tree_node_structure (&%h)")))
3444 {
3445   struct tree_base GTY ((tag ("TS_BASE"))) base;
3446   struct tree_common GTY ((tag ("TS_COMMON"))) common;
3447   struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
3448   struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
3449   struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst;
3450   struct tree_vector GTY ((tag ("TS_VECTOR"))) vector;
3451   struct tree_string GTY ((tag ("TS_STRING"))) string;
3452   struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
3453   struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
3454   struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal;
3455   struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common;
3456   struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl;
3457   struct tree_decl_non_common  GTY ((tag ("TS_DECL_NON_COMMON"))) decl_non_common;
3458   struct tree_parm_decl  GTY  ((tag ("TS_PARM_DECL"))) parm_decl;
3459   struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis;
3460   struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl;
3461   struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl;
3462   struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl;
3463   struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl;
3464   struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl;
3465   struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl;
3466   struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl;
3467   struct tree_type GTY ((tag ("TS_TYPE"))) type;
3468   struct tree_list GTY ((tag ("TS_LIST"))) list;
3469   struct tree_vec GTY ((tag ("TS_VEC"))) vec;
3470   struct tree_exp GTY ((tag ("TS_EXP"))) exp;
3471   struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name;
3472   struct tree_phi_node GTY ((tag ("TS_PHI_NODE"))) phi;
3473   struct tree_block GTY ((tag ("TS_BLOCK"))) block;
3474   struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo;
3475   struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list;
3476   struct gimple_stmt GTY ((tag ("TS_GIMPLE_STATEMENT"))) gstmt;
3477   struct tree_value_handle GTY ((tag ("TS_VALUE_HANDLE"))) value_handle;
3478   struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor;
3479   struct tree_memory_tag GTY ((tag ("TS_MEMORY_TAG"))) mtag;
3480   struct tree_struct_field_tag GTY ((tag ("TS_STRUCT_FIELD_TAG"))) sft;
3481   struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause;
3482   struct tree_memory_partition_tag GTY ((tag ("TS_MEMORY_PARTITION_TAG"))) mpt;
3483 };
3484 \f
3485 /* Standard named or nameless data types of the C compiler.  */
3486
3487 enum tree_index
3488 {
3489   TI_ERROR_MARK,
3490   TI_INTQI_TYPE,
3491   TI_INTHI_TYPE,
3492   TI_INTSI_TYPE,
3493   TI_INTDI_TYPE,
3494   TI_INTTI_TYPE,
3495
3496   TI_UINTQI_TYPE,
3497   TI_UINTHI_TYPE,
3498   TI_UINTSI_TYPE,
3499   TI_UINTDI_TYPE,
3500   TI_UINTTI_TYPE,
3501
3502   TI_UINT32_TYPE,
3503   TI_UINT64_TYPE,
3504
3505   TI_INTEGER_ZERO,
3506   TI_INTEGER_ONE,
3507   TI_INTEGER_MINUS_ONE,
3508   TI_NULL_POINTER,
3509
3510   TI_SIZE_ZERO,
3511   TI_SIZE_ONE,
3512
3513   TI_BITSIZE_ZERO,
3514   TI_BITSIZE_ONE,
3515   TI_BITSIZE_UNIT,
3516
3517   TI_PUBLIC,
3518   TI_PROTECTED,
3519   TI_PRIVATE,
3520
3521   TI_BOOLEAN_FALSE,
3522   TI_BOOLEAN_TRUE,
3523
3524   TI_COMPLEX_INTEGER_TYPE,
3525   TI_COMPLEX_FLOAT_TYPE,
3526   TI_COMPLEX_DOUBLE_TYPE,
3527   TI_COMPLEX_LONG_DOUBLE_TYPE,
3528
3529   TI_FLOAT_TYPE,
3530   TI_DOUBLE_TYPE,
3531   TI_LONG_DOUBLE_TYPE,
3532
3533   TI_FLOAT_PTR_TYPE,
3534   TI_DOUBLE_PTR_TYPE,
3535   TI_LONG_DOUBLE_PTR_TYPE,
3536   TI_INTEGER_PTR_TYPE,
3537
3538   TI_VOID_TYPE,
3539   TI_PTR_TYPE,
3540   TI_CONST_PTR_TYPE,
3541   TI_SIZE_TYPE,
3542   TI_PID_TYPE,
3543   TI_PTRDIFF_TYPE,
3544   TI_VA_LIST_TYPE,
3545   TI_VA_LIST_GPR_COUNTER_FIELD,
3546   TI_VA_LIST_FPR_COUNTER_FIELD,
3547   TI_BOOLEAN_TYPE,
3548   TI_FILEPTR_TYPE,
3549
3550   TI_DFLOAT32_TYPE,
3551   TI_DFLOAT64_TYPE,
3552   TI_DFLOAT128_TYPE,
3553   TI_DFLOAT32_PTR_TYPE,
3554   TI_DFLOAT64_PTR_TYPE,
3555   TI_DFLOAT128_PTR_TYPE,
3556
3557   TI_VOID_LIST_NODE,
3558
3559   TI_MAIN_IDENTIFIER,
3560
3561   TI_SAT_SFRACT_TYPE,
3562   TI_SAT_FRACT_TYPE,
3563   TI_SAT_LFRACT_TYPE,
3564   TI_SAT_LLFRACT_TYPE,
3565   TI_SAT_USFRACT_TYPE,
3566   TI_SAT_UFRACT_TYPE,
3567   TI_SAT_ULFRACT_TYPE,
3568   TI_SAT_ULLFRACT_TYPE,
3569   TI_SFRACT_TYPE,
3570   TI_FRACT_TYPE,
3571   TI_LFRACT_TYPE,
3572   TI_LLFRACT_TYPE,
3573   TI_USFRACT_TYPE,
3574   TI_UFRACT_TYPE,
3575   TI_ULFRACT_TYPE,
3576   TI_ULLFRACT_TYPE,
3577   TI_SAT_SACCUM_TYPE,
3578   TI_SAT_ACCUM_TYPE,
3579   TI_SAT_LACCUM_TYPE,
3580   TI_SAT_LLACCUM_TYPE,
3581   TI_SAT_USACCUM_TYPE,
3582   TI_SAT_UACCUM_TYPE,
3583   TI_SAT_ULACCUM_TYPE,
3584   TI_SAT_ULLACCUM_TYPE,
3585   TI_SACCUM_TYPE,
3586   TI_ACCUM_TYPE,
3587   TI_LACCUM_TYPE,
3588   TI_LLACCUM_TYPE,
3589   TI_USACCUM_TYPE,
3590   TI_UACCUM_TYPE,
3591   TI_ULACCUM_TYPE,
3592   TI_ULLACCUM_TYPE,
3593   TI_QQ_TYPE,
3594   TI_HQ_TYPE,
3595   TI_SQ_TYPE,
3596   TI_DQ_TYPE,
3597   TI_TQ_TYPE,
3598   TI_UQQ_TYPE,
3599   TI_UHQ_TYPE,
3600   TI_USQ_TYPE,
3601   TI_UDQ_TYPE,
3602   TI_UTQ_TYPE,
3603   TI_SAT_QQ_TYPE,
3604   TI_SAT_HQ_TYPE,
3605   TI_SAT_SQ_TYPE,
3606   TI_SAT_DQ_TYPE,
3607   TI_SAT_TQ_TYPE,
3608   TI_SAT_UQQ_TYPE,
3609   TI_SAT_UHQ_TYPE,
3610   TI_SAT_USQ_TYPE,
3611   TI_SAT_UDQ_TYPE,
3612   TI_SAT_UTQ_TYPE,
3613   TI_HA_TYPE,
3614   TI_SA_TYPE,
3615   TI_DA_TYPE,
3616   TI_TA_TYPE,
3617   TI_UHA_TYPE,
3618   TI_USA_TYPE,
3619   TI_UDA_TYPE,
3620   TI_UTA_TYPE,
3621   TI_SAT_HA_TYPE,
3622   TI_SAT_SA_TYPE,
3623   TI_SAT_DA_TYPE,
3624   TI_SAT_TA_TYPE,
3625   TI_SAT_UHA_TYPE,
3626   TI_SAT_USA_TYPE,
3627   TI_SAT_UDA_TYPE,
3628   TI_SAT_UTA_TYPE,
3629
3630   TI_MAX
3631 };
3632
3633 extern GTY(()) tree global_trees[TI_MAX];
3634
3635 #define error_mark_node                 global_trees[TI_ERROR_MARK]
3636
3637 #define intQI_type_node                 global_trees[TI_INTQI_TYPE]
3638 #define intHI_type_node                 global_trees[TI_INTHI_TYPE]
3639 #define intSI_type_node                 global_trees[TI_INTSI_TYPE]
3640 #define intDI_type_node                 global_trees[TI_INTDI_TYPE]
3641 #define intTI_type_node                 global_trees[TI_INTTI_TYPE]
3642
3643 #define unsigned_intQI_type_node        global_trees[TI_UINTQI_TYPE]
3644 #define unsigned_intHI_type_node        global_trees[TI_UINTHI_TYPE]
3645 #define unsigned_intSI_type_node        global_trees[TI_UINTSI_TYPE]
3646 #define unsigned_intDI_type_node        global_trees[TI_UINTDI_TYPE]
3647 #define unsigned_intTI_type_node        global_trees[TI_UINTTI_TYPE]
3648
3649 #define uint32_type_node                global_trees[TI_UINT32_TYPE]
3650 #define uint64_type_node                global_trees[TI_UINT64_TYPE]
3651
3652 #define integer_zero_node               global_trees[TI_INTEGER_ZERO]
3653 #define integer_one_node                global_trees[TI_INTEGER_ONE]
3654 #define integer_minus_one_node          global_trees[TI_INTEGER_MINUS_ONE]
3655 #define size_zero_node                  global_trees[TI_SIZE_ZERO]
3656 #define size_one_node                   global_trees[TI_SIZE_ONE]
3657 #define bitsize_zero_node               global_trees[TI_BITSIZE_ZERO]
3658 #define bitsize_one_node                global_trees[TI_BITSIZE_ONE]
3659 #define bitsize_unit_node               global_trees[TI_BITSIZE_UNIT]
3660
3661 /* Base access nodes.  */
3662 #define access_public_node              global_trees[TI_PUBLIC]
3663 #define access_protected_node           global_trees[TI_PROTECTED]
3664 #define access_private_node             global_trees[TI_PRIVATE]
3665
3666 #define null_pointer_node               global_trees[TI_NULL_POINTER]
3667
3668 #define float_type_node                 global_trees[TI_FLOAT_TYPE]
3669 #define double_type_node                global_trees[TI_DOUBLE_TYPE]
3670 #define long_double_type_node           global_trees[TI_LONG_DOUBLE_TYPE]
3671
3672 #define float_ptr_type_node             global_trees[TI_FLOAT_PTR_TYPE]
3673 #define double_ptr_type_node            global_trees[TI_DOUBLE_PTR_TYPE]
3674 #define long_double_ptr_type_node       global_trees[TI_LONG_DOUBLE_PTR_TYPE]
3675 #define integer_ptr_type_node           global_trees[TI_INTEGER_PTR_TYPE]
3676
3677 #define complex_integer_type_node       global_trees[TI_COMPLEX_INTEGER_TYPE]
3678 #define complex_float_type_node         global_trees[TI_COMPLEX_FLOAT_TYPE]
3679 #define complex_double_type_node        global_trees[TI_COMPLEX_DOUBLE_TYPE]
3680 #define complex_long_double_type_node   global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
3681
3682 #define void_type_node                  global_trees[TI_VOID_TYPE]
3683 /* The C type `void *'.  */
3684 #define ptr_type_node                   global_trees[TI_PTR_TYPE]
3685 /* The C type `const void *'.  */
3686 #define const_ptr_type_node             global_trees[TI_CONST_PTR_TYPE]
3687 /* The C type `size_t'.  */
3688 #define size_type_node                  global_trees[TI_SIZE_TYPE]
3689 #define pid_type_node                   global_trees[TI_PID_TYPE]
3690 #define ptrdiff_type_node               global_trees[TI_PTRDIFF_TYPE]
3691 #define va_list_type_node               global_trees[TI_VA_LIST_TYPE]
3692 #define va_list_gpr_counter_field       global_trees[TI_VA_LIST_GPR_COUNTER_FIELD]
3693 #define va_list_fpr_counter_field       global_trees[TI_VA_LIST_FPR_COUNTER_FIELD]
3694 /* The C type `FILE *'.  */
3695 #define fileptr_type_node               global_trees[TI_FILEPTR_TYPE]
3696
3697 #define boolean_type_node               global_trees[TI_BOOLEAN_TYPE]
3698 #define boolean_false_node              global_trees[TI_BOOLEAN_FALSE]
3699 #define boolean_true_node               global_trees[TI_BOOLEAN_TRUE]
3700
3701 /* The decimal floating point types. */
3702 #define dfloat32_type_node              global_trees[TI_DFLOAT32_TYPE]
3703 #define dfloat64_type_node              global_trees[TI_DFLOAT64_TYPE]
3704 #define dfloat128_type_node             global_trees[TI_DFLOAT128_TYPE]
3705 #define dfloat32_ptr_type_node          global_trees[TI_DFLOAT32_PTR_TYPE]
3706 #define dfloat64_ptr_type_node          global_trees[TI_DFLOAT64_PTR_TYPE]
3707 #define dfloat128_ptr_type_node         global_trees[TI_DFLOAT128_PTR_TYPE]
3708
3709 /* The fixed-point types.  */
3710 #define sat_short_fract_type_node       global_trees[TI_SAT_SFRACT_TYPE]
3711 #define sat_fract_type_node             global_trees[TI_SAT_FRACT_TYPE]
3712 #define sat_long_fract_type_node        global_trees[TI_SAT_LFRACT_TYPE]
3713 #define sat_long_long_fract_type_node   global_trees[TI_SAT_LLFRACT_TYPE]
3714 #define sat_unsigned_short_fract_type_node \
3715                                         global_trees[TI_SAT_USFRACT_TYPE]
3716 #define sat_unsigned_fract_type_node    global_trees[TI_SAT_UFRACT_TYPE]
3717 #define sat_unsigned_long_fract_type_node \
3718                                         global_trees[TI_SAT_ULFRACT_TYPE]
3719 #define sat_unsigned_long_long_fract_type_node \
3720                                         global_trees[TI_SAT_ULLFRACT_TYPE]
3721 #define short_fract_type_node           global_trees[TI_SFRACT_TYPE]
3722 #define fract_type_node                 global_trees[TI_FRACT_TYPE]
3723 #define long_fract_type_node            global_trees[TI_LFRACT_TYPE]
3724 #define long_long_fract_type_node       global_trees[TI_LLFRACT_TYPE]
3725 #define unsigned_short_fract_type_node  global_trees[TI_USFRACT_TYPE]
3726 #define unsigned_fract_type_node        global_trees[TI_UFRACT_TYPE]
3727 #define unsigned_long_fract_type_node   global_trees[TI_ULFRACT_TYPE]
3728 #define unsigned_long_long_fract_type_node \
3729                                         global_trees[TI_ULLFRACT_TYPE]
3730 #define sat_short_accum_type_node       global_trees[TI_SAT_SACCUM_TYPE]
3731 #define sat_accum_type_node             global_trees[TI_SAT_ACCUM_TYPE]
3732 #define sat_long_accum_type_node        global_trees[TI_SAT_LACCUM_TYPE]
3733 #define sat_long_long_accum_type_node   global_trees[TI_SAT_LLACCUM_TYPE]
3734 #define sat_unsigned_short_accum_type_node \
3735                                         global_trees[TI_SAT_USACCUM_TYPE]
3736 #define sat_unsigned_accum_type_node    global_trees[TI_SAT_UACCUM_TYPE]
3737 #define sat_unsigned_long_accum_type_node \
3738                                         global_trees[TI_SAT_ULACCUM_TYPE]
3739 #define sat_unsigned_long_long_accum_type_node \
3740                                         global_trees[TI_SAT_ULLACCUM_TYPE]
3741 #define short_accum_type_node           global_trees[TI_SACCUM_TYPE]
3742 #define accum_type_node                 global_trees[TI_ACCUM_TYPE]
3743 #define long_accum_type_node            global_trees[TI_LACCUM_TYPE]
3744 #define long_long_accum_type_node       global_trees[TI_LLACCUM_TYPE]
3745 #define unsigned_short_accum_type_node  global_trees[TI_USACCUM_TYPE]
3746 #define unsigned_accum_type_node        global_trees[TI_UACCUM_TYPE]
3747 #define unsigned_long_accum_type_node   global_trees[TI_ULACCUM_TYPE]
3748 #define unsigned_long_long_accum_type_node \
3749                                         global_trees[TI_ULLACCUM_TYPE]
3750 #define qq_type_node                    global_trees[TI_QQ_TYPE]
3751 #define hq_type_node                    global_trees[TI_HQ_TYPE]
3752 #define sq_type_node                    global_trees[TI_SQ_TYPE]
3753 #define dq_type_node                    global_trees[TI_DQ_TYPE]
3754 #define tq_type_node                    global_trees[TI_TQ_TYPE]
3755 #define uqq_type_node                   global_trees[TI_UQQ_TYPE]
3756 #define uhq_type_node                   global_trees[TI_UHQ_TYPE]
3757 #define usq_type_node                   global_trees[TI_USQ_TYPE]
3758 #define udq_type_node                   global_trees[TI_UDQ_TYPE]
3759 #define utq_type_node                   global_trees[TI_UTQ_TYPE]
3760 #define sat_qq_type_node                global_trees[TI_SAT_QQ_TYPE]
3761 #define sat_hq_type_node                global_trees[TI_SAT_HQ_TYPE]
3762 #define sat_sq_type_node                global_trees[TI_SAT_SQ_TYPE]
3763 #define sat_dq_type_node                global_trees[TI_SAT_DQ_TYPE]
3764 #define sat_tq_type_node                global_trees[TI_SAT_TQ_TYPE]
3765 #define sat_uqq_type_node               global_trees[TI_SAT_UQQ_TYPE]
3766 #define sat_uhq_type_node               global_trees[TI_SAT_UHQ_TYPE]
3767 #define sat_usq_type_node               global_trees[TI_SAT_USQ_TYPE]
3768 #define sat_udq_type_node               global_trees[TI_SAT_UDQ_TYPE]
3769 #define sat_utq_type_node               global_trees[TI_SAT_UTQ_TYPE]
3770 #define ha_type_node                    global_trees[TI_HA_TYPE]
3771 #define sa_type_node                    global_trees[TI_SA_TYPE]
3772 #define da_type_node                    global_trees[TI_DA_TYPE]
3773 #define ta_type_node                    global_trees[TI_TA_TYPE]
3774 #define uha_type_node                   global_trees[TI_UHA_TYPE]
3775 #define usa_type_node                   global_trees[TI_USA_TYPE]
3776 #define uda_type_node                   global_trees[TI_UDA_TYPE]
3777 #define uta_type_node                   global_trees[TI_UTA_TYPE]
3778 #define sat_ha_type_node                global_trees[TI_SAT_HA_TYPE]
3779 #define sat_sa_type_node                global_trees[TI_SAT_SA_TYPE]
3780 #define sat_da_type_node                global_trees[TI_SAT_DA_TYPE]
3781 #define sat_ta_type_node                global_trees[TI_SAT_TA_TYPE]
3782 #define sat_uha_type_node               global_trees[TI_SAT_UHA_TYPE]
3783 #define sat_usa_type_node               global_trees[TI_SAT_USA_TYPE]
3784 #define sat_uda_type_node               global_trees[TI_SAT_UDA_TYPE]
3785 #define sat_uta_type_node               global_trees[TI_SAT_UTA_TYPE]
3786
3787 /* The node that should be placed at the end of a parameter list to
3788    indicate that the function does not take a variable number of
3789    arguments.  The TREE_VALUE will be void_type_node and there will be
3790    no TREE_CHAIN.  Language-independent code should not assume
3791    anything else about this node.  */
3792 #define void_list_node                  global_trees[TI_VOID_LIST_NODE]
3793
3794 #define main_identifier_node            global_trees[TI_MAIN_IDENTIFIER]
3795 #define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
3796
3797 /* An enumeration of the standard C integer types.  These must be
3798    ordered so that shorter types appear before longer ones, and so
3799    that signed types appear before unsigned ones, for the correct
3800    functioning of interpret_integer() in c-lex.c.  */
3801 enum integer_type_kind
3802 {
3803   itk_char,
3804   itk_signed_char,
3805   itk_unsigned_char,
3806   itk_short,
3807   itk_unsigned_short,
3808   itk_int,
3809   itk_unsigned_int,
3810   itk_long,
3811   itk_unsigned_long,
3812   itk_long_long,
3813   itk_unsigned_long_long,
3814   itk_none
3815 };
3816
3817 typedef enum integer_type_kind integer_type_kind;
3818
3819 /* The standard C integer types.  Use integer_type_kind to index into
3820    this array.  */
3821 extern GTY(()) tree integer_types[itk_none];
3822
3823 #define char_type_node                  integer_types[itk_char]
3824 #define signed_char_type_node           integer_types[itk_signed_char]
3825 #define unsigned_char_type_node         integer_types[itk_unsigned_char]
3826 #define short_integer_type_node         integer_types[itk_short]
3827 #define short_unsigned_type_node        integer_types[itk_unsigned_short]
3828 #define integer_type_node               integer_types[itk_int]
3829 #define unsigned_type_node              integer_types[itk_unsigned_int]
3830 #define long_integer_type_node          integer_types[itk_long]
3831 #define long_unsigned_type_node         integer_types[itk_unsigned_long]
3832 #define long_long_integer_type_node     integer_types[itk_long_long]
3833 #define long_long_unsigned_type_node    integer_types[itk_unsigned_long_long]
3834 \f
3835 /* Set to the default thread-local storage (tls) model to use.  */
3836
3837 extern enum tls_model flag_tls_default;
3838
3839 \f
3840 /* A pointer-to-function member type looks like:
3841
3842      struct {
3843        __P __pfn;
3844        ptrdiff_t __delta;
3845      };
3846
3847    If __pfn is NULL, it is a NULL pointer-to-member-function.
3848
3849    (Because the vtable is always the first thing in the object, we
3850    don't need its offset.)  If the function is virtual, then PFN is
3851    one plus twice the index into the vtable; otherwise, it is just a
3852    pointer to the function.
3853
3854    Unfortunately, using the lowest bit of PFN doesn't work in
3855    architectures that don't impose alignment requirements on function
3856    addresses, or that use the lowest bit to tell one ISA from another,
3857    for example.  For such architectures, we use the lowest bit of
3858    DELTA instead of the lowest bit of the PFN, and DELTA will be
3859    multiplied by 2.  */
3860
3861 enum ptrmemfunc_vbit_where_t
3862 {
3863   ptrmemfunc_vbit_in_pfn,
3864   ptrmemfunc_vbit_in_delta
3865 };
3866 \f
3867 #define NULL_TREE (tree) NULL
3868
3869 extern tree decl_assembler_name (tree);
3870 extern bool decl_assembler_name_equal (tree decl, tree asmname);
3871
3872 /* Compute the number of bytes occupied by 'node'.  This routine only
3873    looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.  */
3874
3875 extern size_t tree_size (const_tree);
3876
3877 /* Compute the number of bytes occupied by a tree with code CODE.  This
3878    function cannot be used for TREE_VEC or PHI_NODE codes, which are of
3879    variable length.  */
3880 extern size_t tree_code_size (enum tree_code);
3881
3882 /* Lowest level primitive for allocating a node.
3883    The TREE_CODE is the only argument.  Contents are initialized
3884    to zero except for a few of the common fields.  */
3885
3886 extern tree make_node_stat (enum tree_code MEM_STAT_DECL);
3887 #define make_node(t) make_node_stat (t MEM_STAT_INFO)
3888
3889 /* Make a copy of a node, with all the same contents.  */
3890
3891 extern tree copy_node_stat (tree MEM_STAT_DECL);
3892 #define copy_node(t) copy_node_stat (t MEM_STAT_INFO)
3893
3894 /* Make a copy of a chain of TREE_LIST nodes.  */
3895
3896 extern tree copy_list (tree);
3897
3898 /* Make a BINFO.  */
3899 extern tree make_tree_binfo_stat (unsigned MEM_STAT_DECL);
3900 #define make_tree_binfo(t) make_tree_binfo_stat (t MEM_STAT_INFO)
3901
3902 /* Make a TREE_VEC.  */
3903
3904 extern tree make_tree_vec_stat (int MEM_STAT_DECL);
3905 #define make_tree_vec(t) make_tree_vec_stat (t MEM_STAT_INFO)
3906
3907 /* Tree nodes for SSA analysis.  */
3908
3909 extern void init_phinodes (void);
3910 extern void fini_phinodes (void);
3911 extern void release_phi_node (tree);
3912 #ifdef GATHER_STATISTICS
3913 extern void phinodes_print_statistics (void);
3914 #endif
3915
3916 extern void init_ssanames (void);
3917 extern void fini_ssanames (void);
3918 extern tree make_ssa_name (tree, tree);
3919 extern tree duplicate_ssa_name (tree, tree);
3920 extern void duplicate_ssa_name_ptr_info (tree, struct ptr_info_def *);
3921 extern void release_ssa_name (tree);
3922 extern void release_defs (tree);
3923 extern void replace_ssa_name_symbol (tree, tree);
3924
3925 #ifdef GATHER_STATISTICS
3926 extern void ssanames_print_statistics (void);
3927 #endif
3928
3929 /* Return the (unique) IDENTIFIER_NODE node for a given name.
3930    The name is supplied as a char *.  */
3931
3932 extern tree get_identifier (const char *);
3933
3934 #if GCC_VERSION >= 3000
3935 #define get_identifier(str) \
3936   (__builtin_constant_p (str)                           \
3937     ? get_identifier_with_length ((str), strlen (str))  \
3938     : get_identifier (str))
3939 #endif
3940
3941
3942 /* Identical to get_identifier, except that the length is assumed
3943    known.  */
3944
3945 extern tree get_identifier_with_length (const char *, size_t);
3946
3947 /* If an identifier with the name TEXT (a null-terminated string) has
3948    previously been referred to, return that node; otherwise return
3949    NULL_TREE.  */
3950
3951 extern tree maybe_get_identifier (const char *);
3952
3953 /* Construct various types of nodes.  */
3954
3955 extern tree build_nt (enum tree_code, ...);
3956 extern tree build_nt_call_list (tree, tree);
3957
3958 extern tree build0_stat (enum tree_code, tree MEM_STAT_DECL);
3959 #define build0(c,t) build0_stat (c,t MEM_STAT_INFO)
3960 extern tree build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
3961 #define build1(c,t1,t2) build1_stat (c,t1,t2 MEM_STAT_INFO)
3962 extern tree build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
3963 #define build2(c,t1,t2,t3) build2_stat (c,t1,t2,t3 MEM_STAT_INFO)
3964 extern tree build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
3965 #define build3(c,t1,t2,t3,t4) build3_stat (c,t1,t2,t3,t4 MEM_STAT_INFO)
3966 extern tree build4_stat (enum tree_code, tree, tree, tree, tree,
3967                          tree MEM_STAT_DECL);
3968 #define build4(c,t1,t2,t3,t4,t5) build4_stat (c,t1,t2,t3,t4,t5 MEM_STAT_INFO)
3969 extern tree build5_stat (enum tree_code, tree, tree, tree, tree, tree,
3970                          tree MEM_STAT_DECL);
3971 #define build5(c,t1,t2,t3,t4,t5,t6) build5_stat (c,t1,t2,t3,t4,t5,t6 MEM_STAT_INFO)
3972 extern tree build7_stat (enum tree_code, tree, tree, tree, tree, tree,
3973                          tree, tree, tree MEM_STAT_DECL);
3974 #define build7(c,t1,t2,t3,t4,t5,t6,t7,t8) \
3975   build7_stat (c,t1,t2,t3,t4,t5,t6,t7,t8 MEM_STAT_INFO)
3976
3977 extern tree build_gimple_modify_stmt_stat (tree, tree MEM_STAT_DECL);
3978 #define build_gimple_modify_stmt(t1,t2) \
3979   build_gimple_modify_stmt_stat (t1,t2 MEM_STAT_INFO)
3980
3981 extern tree build_int_cst (tree, HOST_WIDE_INT);
3982 extern tree build_int_cst_type (tree, HOST_WIDE_INT);
3983 extern tree build_int_cstu (tree, unsigned HOST_WIDE_INT);
3984 extern tree build_int_cst_wide (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT);
3985 extern tree build_int_cst_wide_type (tree,
3986                                      unsigned HOST_WIDE_INT, HOST_WIDE_INT);
3987 extern tree build_vector (tree, tree);
3988 extern tree build_vector_from_ctor (tree, VEC(constructor_elt,gc) *);
3989 extern tree build_constructor (tree, VEC(constructor_elt,gc) *);
3990 extern tree build_constructor_single (tree, tree, tree);
3991 extern tree build_constructor_from_list (tree, tree);
3992 extern tree build_real_from_int_cst (tree, const_tree);
3993 extern tree build_complex (tree, tree, tree);
3994 extern tree build_one_cst (tree);
3995 extern tree build_string (int, const char *);
3996 extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL);
3997 #define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO)
3998 extern tree build_decl_stat (enum tree_code, tree, tree MEM_STAT_DECL);
3999 extern tree build_fn_decl (const char *, tree);
4000 #define build_decl(c,t,q) build_decl_stat (c,t,q MEM_STAT_INFO)
4001 extern tree build_block (tree, tree, tree, tree);
4002 #ifndef USE_MAPPED_LOCATION
4003 extern void annotate_with_file_line (tree, const char *, int);
4004 extern void annotate_with_locus (tree, location_t);
4005 #endif
4006 extern tree build_empty_stmt (void);
4007 extern tree build_omp_clause (enum omp_clause_code);
4008
4009 extern tree build_vl_exp_stat (enum tree_code, int MEM_STAT_DECL);
4010 #define build_vl_exp(c,n) build_vl_exp_stat (c,n MEM_STAT_INFO)
4011
4012 extern tree build_call_list (tree, tree, tree);
4013 extern tree build_call_nary (tree, tree, int, ...);
4014 extern tree build_call_valist (tree, tree, int, va_list);
4015 extern tree build_call_array (tree, tree, int, tree*);
4016
4017 /* Construct various nodes representing data types.  */
4018
4019 extern tree make_signed_type (int);
4020 extern tree make_unsigned_type (int);
4021 extern tree signed_or_unsigned_type_for (int, tree);
4022 extern tree signed_type_for (tree);
4023 extern tree unsigned_type_for (tree);
4024 extern void initialize_sizetypes (bool);
4025 extern void set_sizetype (tree);
4026 extern void fixup_unsigned_type (tree);
4027 extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool);
4028 extern tree build_pointer_type (tree);
4029 extern tree build_reference_type_for_mode (tree, enum machine_mode, bool);
4030 extern tree build_reference_type (tree);
4031 extern tree build_vector_type_for_mode (tree, enum machine_mode);
4032 extern tree build_vector_type (tree innertype, int nunits);
4033 extern tree build_type_no_quals (tree);
4034 extern tree build_index_type (tree);
4035 extern tree build_index_2_type (tree, tree);
4036 extern tree build_array_type (tree, tree);
4037 extern tree build_function_type (tree, tree);
4038 extern tree build_function_type_list (tree, ...);
4039 extern tree build_method_type_directly (tree, tree, tree);
4040 extern tree build_method_type (tree, tree);
4041 extern tree build_offset_type (tree, tree);
4042 extern tree build_complex_type (tree);
4043 extern tree build_resx (int);
4044 extern tree array_type_nelts (const_tree);
4045 extern bool in_array_bounds_p (tree);
4046 extern bool range_in_array_bounds_p (tree);
4047
4048 extern tree value_member (tree, tree);
4049 extern tree purpose_member (const_tree, tree);
4050
4051 extern int attribute_list_equal (const_tree, const_tree);
4052 extern int attribute_list_contained (const_tree, const_tree);
4053 extern int tree_int_cst_equal (const_tree, const_tree);
4054 extern int tree_int_cst_lt (const_tree, const_tree);
4055 extern int tree_int_cst_compare (const_tree, const_tree);
4056 extern int host_integerp (const_tree, int);
4057 extern HOST_WIDE_INT tree_low_cst (const_tree, int);
4058 extern int tree_int_cst_msb (const_tree);
4059 extern int tree_int_cst_sgn (const_tree);
4060 extern int tree_int_cst_sign_bit (const_tree);
4061 extern bool tree_expr_nonnegative_p (tree);
4062 extern bool tree_expr_nonnegative_warnv_p (tree, bool *);
4063 extern bool may_negate_without_overflow_p (const_tree);
4064 extern tree get_inner_array_type (const_tree);
4065
4066 /* Construct various nodes representing fract or accum data types.  */
4067
4068 extern tree make_fract_type (int, int, int);
4069 extern tree make_accum_type (int, int, int);
4070
4071 #define make_signed_fract_type(P) make_fract_type (P, 0, 0)
4072 #define make_unsigned_fract_type(P) make_fract_type (P, 1, 0)
4073 #define make_sat_signed_fract_type(P) make_fract_type (P, 0, 1)
4074 #define make_sat_unsigned_fract_type(P) make_fract_type (P, 1, 1)
4075 #define make_signed_accum_type(P) make_accum_type (P, 0, 0)
4076 #define make_unsigned_accum_type(P) make_accum_type (P, 1, 0)
4077 #define make_sat_signed_accum_type(P) make_accum_type (P, 0, 1)
4078 #define make_sat_unsigned_accum_type(P) make_accum_type (P, 1, 1)
4079
4080 #define make_or_reuse_signed_fract_type(P) \
4081                 make_or_reuse_fract_type (P, 0, 0)
4082 #define make_or_reuse_unsigned_fract_type(P) \
4083                 make_or_reuse_fract_type (P, 1, 0)
4084 #define make_or_reuse_sat_signed_fract_type(P) \
4085                 make_or_reuse_fract_type (P, 0, 1)
4086 #define make_or_reuse_sat_unsigned_fract_type(P) \
4087                 make_or_reuse_fract_type (P, 1, 1)
4088 #define make_or_reuse_signed_accum_type(P) \
4089                 make_or_reuse_accum_type (P, 0, 0)
4090 #define make_or_reuse_unsigned_accum_type(P) \
4091                 make_or_reuse_accum_type (P, 1, 0)
4092 #define make_or_reuse_sat_signed_accum_type(P) \
4093                 make_or_reuse_accum_type (P, 0, 1)
4094 #define make_or_reuse_sat_unsigned_accum_type(P) \
4095                 make_or_reuse_accum_type (P, 1, 1)
4096
4097 /* From expmed.c.  Since rtl.h is included after tree.h, we can't
4098    put the prototype here.  Rtl.h does declare the prototype if
4099    tree.h had been included.  */
4100
4101 extern tree make_tree (tree, rtx);
4102 \f
4103 /* Return a type like TTYPE except that its TYPE_ATTRIBUTES
4104    is ATTRIBUTE.
4105
4106    Such modified types already made are recorded so that duplicates
4107    are not made.  */
4108
4109 extern tree build_type_attribute_variant (tree, tree);
4110 extern tree build_decl_attribute_variant (tree, tree);
4111
4112 /* Structure describing an attribute and a function to handle it.  */
4113 struct attribute_spec
4114 {
4115   /* The name of the attribute (without any leading or trailing __),
4116      or NULL to mark the end of a table of attributes.  */
4117   const char *const name;
4118   /* The minimum length of the list of arguments of the attribute.  */
4119   const int min_length;
4120   /* The maximum length of the list of arguments of the attribute
4121      (-1 for no maximum).  */
4122   const int max_length;
4123   /* Whether this attribute requires a DECL.  If it does, it will be passed
4124      from types of DECLs, function return types and array element types to
4125      the DECLs, function types and array types respectively; but when
4126      applied to a type in any other circumstances, it will be ignored with
4127      a warning.  (If greater control is desired for a given attribute,
4128      this should be false, and the flags argument to the handler may be
4129      used to gain greater control in that case.)  */
4130   const bool decl_required;
4131   /* Whether this attribute requires a type.  If it does, it will be passed
4132      from a DECL to the type of that DECL.  */
4133   const bool type_required;
4134   /* Whether this attribute requires a function (or method) type.  If it does,
4135      it will be passed from a function pointer type to the target type,
4136      and from a function return type (which is not itself a function
4137      pointer type) to the function type.  */
4138   const bool function_type_required;
4139   /* Function to handle this attribute.  NODE points to the node to which
4140      the attribute is to be applied.  If a DECL, it should be modified in
4141      place; if a TYPE, a copy should be created.  NAME is the name of the
4142      attribute (possibly with leading or trailing __).  ARGS is the TREE_LIST
4143      of the arguments (which may be NULL).  FLAGS gives further information
4144      about the context of the attribute.  Afterwards, the attributes will
4145      be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
4146      unless *NO_ADD_ATTRS is set to true (which should be done on error,
4147      as well as in any other cases when the attributes should not be added
4148      to the DECL or TYPE).  Depending on FLAGS, any attributes to be
4149      applied to another type or DECL later may be returned;
4150      otherwise the return value should be NULL_TREE.  This pointer may be
4151      NULL if no special handling is required beyond the checks implied
4152      by the rest of this structure.  */
4153   tree (*const handler) (tree *node, tree name, tree args,
4154                                  int flags, bool *no_add_attrs);
4155 };
4156
4157 /* Flags that may be passed in the third argument of decl_attributes, and
4158    to handler functions for attributes.  */
4159 enum attribute_flags
4160 {
4161   /* The type passed in is the type of a DECL, and any attributes that
4162      should be passed in again to be applied to the DECL rather than the
4163      type should be returned.  */
4164   ATTR_FLAG_DECL_NEXT = 1,
4165   /* The type passed in is a function return type, and any attributes that
4166      should be passed in again to be applied to the function type rather
4167      than the return type should be returned.  */
4168   ATTR_FLAG_FUNCTION_NEXT = 2,
4169   /* The type passed in is an array element type, and any attributes that
4170      should be passed in again to be applied to the array type rather
4171      than the element type should be returned.  */
4172   ATTR_FLAG_ARRAY_NEXT = 4,
4173   /* The type passed in is a structure, union or enumeration type being
4174      created, and should be modified in place.  */
4175   ATTR_FLAG_TYPE_IN_PLACE = 8,
4176   /* The attributes are being applied by default to a library function whose
4177      name indicates known behavior, and should be silently ignored if they
4178      are not in fact compatible with the function type.  */
4179   ATTR_FLAG_BUILT_IN = 16
4180 };
4181
4182 /* Default versions of target-overridable functions.  */
4183
4184 extern tree merge_decl_attributes (tree, tree);
4185 extern tree merge_type_attributes (tree, tree);
4186
4187 /* Given a tree node and a string, return nonzero if the tree node is
4188    a valid attribute name for the string.  */
4189
4190 extern int is_attribute_p (const char *, const_tree);
4191
4192 /* Given an attribute name and a list of attributes, return the list element
4193    of the attribute or NULL_TREE if not found.  */
4194
4195 extern tree lookup_attribute (const char *, tree);
4196
4197 /* Remove any instances of attribute ATTR_NAME in LIST and return the
4198    modified list.  */
4199
4200 extern tree remove_attribute (const char *, tree);
4201
4202 /* Given two attributes lists, return a list of their union.  */
4203
4204 extern tree merge_attributes (tree, tree);
4205
4206 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
4207 /* Given two Windows decl attributes lists, possibly including
4208    dllimport, return a list of their union .  */
4209 extern tree merge_dllimport_decl_attributes (tree, tree);
4210
4211 /* Handle a "dllimport" or "dllexport" attribute.  */
4212 extern tree handle_dll_attribute (tree *, tree, tree, int, bool *);
4213 #endif
4214
4215 /* Check whether CAND is suitable to be returned from get_qualified_type
4216    (BASE, TYPE_QUALS).  */
4217
4218 extern bool check_qualified_type (const_tree, const_tree, int);
4219
4220 /* Return a version of the TYPE, qualified as indicated by the
4221    TYPE_QUALS, if one exists.  If no qualified version exists yet,
4222    return NULL_TREE.  */
4223
4224 extern tree get_qualified_type (tree, int);
4225
4226 /* Like get_qualified_type, but creates the type if it does not
4227    exist.  This function never returns NULL_TREE.  */
4228
4229 extern tree build_qualified_type (tree, int);
4230
4231 /* Like build_qualified_type, but only deals with the `const' and
4232    `volatile' qualifiers.  This interface is retained for backwards
4233    compatibility with the various front-ends; new code should use
4234    build_qualified_type instead.  */
4235
4236 #define build_type_variant(TYPE, CONST_P, VOLATILE_P)                   \
4237   build_qualified_type ((TYPE),                                         \
4238                         ((CONST_P) ? TYPE_QUAL_CONST : 0)               \
4239                         | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
4240
4241 /* Make a copy of a type node.  */
4242
4243 extern tree build_distinct_type_copy (tree);
4244 extern tree build_variant_type_copy (tree);
4245
4246 /* Finish up a builtin RECORD_TYPE. Give it a name and provide its
4247    fields. Optionally specify an alignment, and then lay it out.  */
4248
4249 extern void finish_builtin_struct (tree, const char *,
4250                                                          tree, tree);
4251
4252 /* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
4253    TYPE_ALIGN and TYPE_MODE fields.  If called more than once on one
4254    node, does nothing except for the first time.  */
4255
4256 extern void layout_type (tree);
4257
4258 /* These functions allow a front-end to perform a manual layout of a
4259    RECORD_TYPE.  (For instance, if the placement of subsequent fields
4260    depends on the placement of fields so far.)  Begin by calling
4261    start_record_layout.  Then, call place_field for each of the
4262    fields.  Then, call finish_record_layout.  See layout_type for the
4263    default way in which these functions are used.  */
4264
4265 typedef struct record_layout_info_s
4266 {
4267   /* The RECORD_TYPE that we are laying out.  */
4268   tree t;
4269   /* The offset into the record so far, in bytes, not including bits in
4270      BITPOS.  */
4271   tree offset;
4272   /* The last known alignment of SIZE.  */
4273   unsigned int offset_align;
4274   /* The bit position within the last OFFSET_ALIGN bits, in bits.  */
4275   tree bitpos;
4276   /* The alignment of the record so far, in bits.  */
4277   unsigned int record_align;
4278   /* The alignment of the record so far, ignoring #pragma pack and
4279      __attribute__ ((packed)), in bits.  */
4280   unsigned int unpacked_align;
4281   /* The previous field layed out.  */
4282   tree prev_field;
4283   /* The static variables (i.e., class variables, as opposed to
4284      instance variables) encountered in T.  */
4285   tree pending_statics;
4286   /* Bits remaining in the current alignment group */
4287   int remaining_in_alignment;
4288   /* True if we've seen a packed field that didn't have normal
4289      alignment anyway.  */
4290   int packed_maybe_necessary;
4291 } *record_layout_info;
4292
4293 extern record_layout_info start_record_layout (tree);
4294 extern tree bit_from_pos (tree, tree);
4295 extern tree byte_from_pos (tree, tree);
4296 extern void pos_from_bit (tree *, tree *, unsigned int, tree);
4297 extern void normalize_offset (tree *, tree *, unsigned int);
4298 extern tree rli_size_unit_so_far (record_layout_info);
4299 extern tree rli_size_so_far (record_layout_info);
4300 extern void normalize_rli (record_layout_info);
4301 extern void place_field (record_layout_info, tree);
4302 extern void compute_record_mode (tree);
4303 extern void finish_record_layout (record_layout_info, int);
4304
4305 /* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
4306    return a canonicalized ..._TYPE node, so that duplicates are not made.
4307    How the hash code is computed is up to the caller, as long as any two
4308    callers that could hash identical-looking type nodes agree.  */
4309
4310 extern tree type_hash_canon (unsigned int, tree);
4311
4312 /* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
4313    calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
4314    fields.  Call this only once for any given decl node.
4315
4316    Second argument is the boundary that this field can be assumed to
4317    be starting at (in bits).  Zero means it can be assumed aligned
4318    on any boundary that may be needed.  */
4319
4320 extern void layout_decl (tree, unsigned);
4321
4322 /* Given a VAR_DECL, PARM_DECL or RESULT_DECL, clears the results of
4323    a previous call to layout_decl and calls it again.  */
4324
4325 extern void relayout_decl (tree);
4326
4327 /* Return the mode for data of a given size SIZE and mode class CLASS.
4328    If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
4329    The value is BLKmode if no other mode is found.  This is like
4330    mode_for_size, but is passed a tree.  */
4331
4332 extern enum machine_mode mode_for_size_tree (const_tree, enum mode_class, int);
4333
4334 /* Return an expr equal to X but certainly not valid as an lvalue.  */
4335
4336 extern tree non_lvalue (tree);
4337
4338 extern tree convert (tree, tree);
4339 extern unsigned int expr_align (const_tree);
4340 extern tree expr_first (tree);
4341 extern tree expr_last (tree);
4342 extern tree expr_only (tree);
4343 extern tree size_in_bytes (const_tree);
4344 extern HOST_WIDE_INT int_size_in_bytes (const_tree);
4345 extern HOST_WIDE_INT max_int_size_in_bytes (const_tree);
4346 extern tree bit_position (const_tree);
4347 extern HOST_WIDE_INT int_bit_position (const_tree);
4348 extern tree byte_position (const_tree);
4349 extern HOST_WIDE_INT int_byte_position (const_tree);
4350
4351 /* Define data structures, macros, and functions for handling sizes
4352    and the various types used to represent sizes.  */
4353
4354 enum size_type_kind
4355 {
4356   SIZETYPE,             /* Normal representation of sizes in bytes.  */
4357   SSIZETYPE,            /* Signed representation of sizes in bytes.  */
4358   BITSIZETYPE,          /* Normal representation of sizes in bits.  */
4359   SBITSIZETYPE,         /* Signed representation of sizes in bits.  */
4360   TYPE_KIND_LAST};
4361
4362 extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST];
4363
4364 #define sizetype sizetype_tab[(int) SIZETYPE]
4365 #define bitsizetype sizetype_tab[(int) BITSIZETYPE]
4366 #define ssizetype sizetype_tab[(int) SSIZETYPE]
4367 #define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
4368
4369 extern tree size_int_kind (HOST_WIDE_INT, enum size_type_kind);
4370 extern tree size_binop (enum tree_code, tree, tree);
4371 extern tree size_diffop (tree, tree);
4372
4373 #define size_int(L) size_int_kind (L, SIZETYPE)
4374 #define ssize_int(L) size_int_kind (L, SSIZETYPE)
4375 #define bitsize_int(L) size_int_kind (L, BITSIZETYPE)
4376 #define sbitsize_int(L) size_int_kind (L, SBITSIZETYPE)
4377
4378 extern tree round_up (tree, int);
4379 extern tree round_down (tree, int);
4380 extern tree get_pending_sizes (void);
4381 extern void put_pending_size (tree);
4382 extern void put_pending_sizes (tree);
4383
4384 /* Type for sizes of data-type.  */
4385
4386 #define BITS_PER_UNIT_LOG \
4387   ((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \
4388    + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
4389    + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
4390
4391 /* If nonzero, an upper limit on alignment of structure fields, in bits,  */
4392 extern unsigned int maximum_field_alignment;
4393 /* and its original value in bytes, specified via -fpack-struct=<value>.  */
4394 extern unsigned int initial_max_fld_align;
4395
4396 /* Concatenate two lists (chains of TREE_LIST nodes) X and Y
4397    by making the last node in X point to Y.
4398    Returns X, except if X is 0 returns Y.  */
4399
4400 extern tree chainon (tree, tree);
4401
4402 /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.  */
4403
4404 extern tree tree_cons_stat (tree, tree, tree MEM_STAT_DECL);
4405 #define tree_cons(t,q,w) tree_cons_stat (t,q,w MEM_STAT_INFO)
4406
4407 /* Return the last tree node in a chain.  */
4408
4409 extern tree tree_last (tree);
4410
4411 /* Reverse the order of elements in a chain, and return the new head.  */
4412
4413 extern tree nreverse (tree);
4414
4415 /* Returns the length of a chain of nodes
4416    (number of chain pointers to follow before reaching a null pointer).  */
4417
4418 extern int list_length (const_tree);
4419
4420 /* Returns the number of FIELD_DECLs in a type.  */
4421
4422 extern int fields_length (const_tree);
4423
4424 /* Given an initializer INIT, return TRUE if INIT is zero or some
4425    aggregate of zeros.  Otherwise return FALSE.  */
4426
4427 extern bool initializer_zerop (const_tree);
4428
4429 /* Examine CTOR to discover:
4430    * how many scalar fields are set to nonzero values,
4431      and place it in *P_NZ_ELTS;
4432    * how many scalar fields in total are in CTOR,
4433      and place it in *P_ELT_COUNT.
4434    * if a type is a union, and the initializer from the constructor
4435      is not the largest element in the union, then set *p_must_clear.
4436
4437    Return whether or not CTOR is a valid static constant initializer, the same
4438    as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0".  */
4439
4440 extern bool categorize_ctor_elements (const_tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
4441                                       bool *);
4442
4443 extern HOST_WIDE_INT count_type_elements (const_tree, bool);
4444
4445 /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0.  */
4446
4447 extern int integer_zerop (const_tree);
4448
4449 /* integer_onep (tree x) is nonzero if X is an integer constant of value 1.  */
4450
4451 extern int integer_onep (const_tree);
4452
4453 /* integer_all_onesp (tree x) is nonzero if X is an integer constant
4454    all of whose significant bits are 1.  */
4455
4456 extern int integer_all_onesp (const_tree);
4457
4458 /* integer_pow2p (tree x) is nonzero is X is an integer constant with
4459    exactly one bit 1.  */
4460
4461 extern int integer_pow2p (const_tree);
4462
4463 /* integer_nonzerop (tree x) is nonzero if X is an integer constant
4464    with a nonzero value.  */
4465
4466 extern int integer_nonzerop (const_tree);
4467
4468 extern bool cst_and_fits_in_hwi (const_tree);
4469 extern tree num_ending_zeros (const_tree);
4470
4471 /* fixed_zerop (tree x) is nonzero if X is a fixed-point constant of
4472    value 0.  */
4473
4474 extern int fixed_zerop (const_tree);
4475
4476 /* staticp (tree x) is nonzero if X is a reference to data allocated
4477    at a fixed address in memory.  Returns the outermost data.  */
4478
4479 extern tree staticp (tree);
4480
4481 /* save_expr (EXP) returns an expression equivalent to EXP
4482    but it can be used multiple times within context CTX
4483    and only evaluate EXP once.  */
4484
4485 extern tree save_expr (tree);
4486
4487 /* Look inside EXPR and into any simple arithmetic operations.  Return
4488    the innermost non-arithmetic node.  */
4489
4490 extern tree skip_simple_arithmetic (tree);
4491
4492 /* Return which tree structure is used by T.  */
4493
4494 enum tree_node_structure_enum tree_node_structure (const_tree);
4495
4496 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
4497    or offset that depends on a field within a record.
4498
4499    Note that we only allow such expressions within simple arithmetic
4500    or a COND_EXPR.  */
4501
4502 extern bool contains_placeholder_p (const_tree);
4503
4504 /* This macro calls the above function but short-circuits the common
4505    case of a constant to save time.  Also check for null.  */
4506
4507 #define CONTAINS_PLACEHOLDER_P(EXP) \
4508   ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
4509
4510 /* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
4511    This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
4512    positions.  */
4513
4514 extern bool type_contains_placeholder_p (tree);
4515
4516 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
4517    return a tree with all occurrences of references to F in a
4518    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
4519    contains only arithmetic expressions.  */
4520
4521 extern tree substitute_in_expr (tree, tree, tree);
4522
4523 /* This macro calls the above function but short-circuits the common
4524    case of a constant to save time and also checks for NULL.  */
4525
4526 #define SUBSTITUTE_IN_EXPR(EXP, F, R) \
4527   ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP) : substitute_in_expr (EXP, F, R))
4528
4529 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
4530    for it within OBJ, a tree that is an object or a chain of references.  */
4531
4532 extern tree substitute_placeholder_in_expr (tree, tree);
4533
4534 /* This macro calls the above function but short-circuits the common
4535    case of a constant to save time and also checks for NULL.  */
4536
4537 #define SUBSTITUTE_PLACEHOLDER_IN_EXPR(EXP, OBJ) \
4538   ((EXP) == 0 || TREE_CONSTANT (EXP) ? (EXP)    \
4539    : substitute_placeholder_in_expr (EXP, OBJ))
4540
4541 /* variable_size (EXP) is like save_expr (EXP) except that it
4542    is for the special case of something that is part of a
4543    variable size for a data type.  It makes special arrangements
4544    to compute the value at the right time when the data type
4545    belongs to a function parameter.  */
4546
4547 extern tree variable_size (tree);
4548
4549 /* stabilize_reference (EXP) returns a reference equivalent to EXP
4550    but it can be used multiple times
4551    and only evaluate the subexpressions once.  */
4552
4553 extern tree stabilize_reference (tree);
4554
4555 /* Subroutine of stabilize_reference; this is called for subtrees of
4556    references.  Any expression with side-effects must be put in a SAVE_EXPR
4557    to ensure that it is only evaluated once.  */
4558
4559 extern tree stabilize_reference_1 (tree);
4560
4561 /* Return EXP, stripped of any conversions to wider types
4562    in such a way that the result of converting to type FOR_TYPE
4563    is the same as if EXP were converted to FOR_TYPE.
4564    If FOR_TYPE is 0, it signifies EXP's type.  */
4565
4566 extern tree get_unwidened (tree, tree);
4567
4568 /* Return OP or a simpler expression for a narrower value
4569    which can be sign-extended or zero-extended to give back OP.
4570    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4571    or 0 if the value should be sign-extended.  */
4572
4573 extern tree get_narrower (tree, int *);
4574
4575 /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
4576    look for nested component-refs or array-refs at constant positions
4577    and find the ultimate containing object, which is returned.  */
4578
4579 extern tree get_inner_reference (tree, HOST_WIDE_INT *, HOST_WIDE_INT *,
4580                                  tree *, enum machine_mode *, int *, int *,
4581                                  bool);
4582
4583 /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
4584    look for whether EXP or any nested component-refs within EXP is marked
4585    as PACKED.  */
4586
4587 extern bool contains_packed_reference (const_tree exp);
4588
4589 /* Return 1 if T is an expression that get_inner_reference handles.  */
4590
4591 extern int handled_component_p (const_tree);
4592
4593 /* Return a tree of sizetype representing the size, in bytes, of the element
4594    of EXP, an ARRAY_REF.  */
4595
4596 extern tree array_ref_element_size (tree);
4597
4598 /* Return a tree representing the lower bound of the array mentioned in
4599    EXP, an ARRAY_REF.  */
4600
4601 extern tree array_ref_low_bound (tree);
4602
4603 /* Return a tree representing the upper bound of the array mentioned in
4604    EXP, an ARRAY_REF.  */
4605
4606 extern tree array_ref_up_bound (tree);
4607
4608 /* Return a tree representing the offset, in bytes, of the field referenced
4609    by EXP.  This does not include any offset in DECL_FIELD_BIT_OFFSET.  */
4610
4611 extern tree component_ref_field_offset (tree);
4612
4613 /* Given a DECL or TYPE, return the scope in which it was declared, or
4614    NUL_TREE if there is no containing scope.  */
4615
4616 extern tree get_containing_scope (const_tree);
4617
4618 /* Return the FUNCTION_DECL which provides this _DECL with its context,
4619    or zero if none.  */
4620 extern tree decl_function_context (const_tree);
4621
4622 /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
4623    this _DECL with its context, or zero if none.  */
4624 extern tree decl_type_context (const_tree);
4625
4626 /* Return 1 if EXPR is the real constant zero.  */
4627 extern int real_zerop (const_tree);
4628 \f
4629 /* Declare commonly used variables for tree structure.  */
4630
4631 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
4632    Zero means allow extended lvalues.  */
4633
4634 extern int pedantic_lvalues;
4635
4636 /* Points to the FUNCTION_DECL of the function whose body we are reading.  */
4637
4638 extern GTY(()) tree current_function_decl;
4639
4640 /* Nonzero means a FUNC_BEGIN label was emitted.  */
4641 extern GTY(()) const char * current_function_func_begin_label;
4642 \f
4643 /* Iterator for going through the function arguments.  */
4644 typedef struct {
4645   tree fntype;                  /* function type declaration */
4646   tree next;                    /* TREE_LIST pointing to the next argument */
4647 } function_args_iterator;
4648
4649 /* Initialize the iterator I with arguments from function FNDECL  */
4650
4651 static inline void
4652 function_args_iter_init (function_args_iterator *i, tree fntype)
4653 {
4654   i->fntype = fntype;
4655   i->next = TYPE_ARG_TYPES (fntype);
4656 }
4657
4658 /* Return a pointer that holds the next argument if there are more arguments to
4659    handle, otherwise return NULL.  */
4660
4661 static inline tree *
4662 function_args_iter_cond_ptr (function_args_iterator *i)
4663 {
4664   return (i->next) ? &TREE_VALUE (i->next) : NULL;
4665 }
4666
4667 /* Return the next argument if there are more arguments to handle, otherwise
4668    return NULL.  */
4669
4670 static inline tree
4671 function_args_iter_cond (function_args_iterator *i)
4672 {
4673   return (i->next) ? TREE_VALUE (i->next) : NULL_TREE;
4674 }
4675
4676 /* Advance to the next argument.  */
4677 static inline void
4678 function_args_iter_next (function_args_iterator *i)
4679 {
4680   gcc_assert (i->next != NULL_TREE);
4681   i->next = TREE_CHAIN (i->next);
4682 }
4683
4684 /* Loop over all function arguments of FNTYPE.  In each iteration, PTR is set
4685    to point to the next tree element.  ITER is an instance of
4686    function_args_iterator used to iterate the arguments.  */
4687 #define FOREACH_FUNCTION_ARGS_PTR(FNTYPE, PTR, ITER)                    \
4688   for (function_args_iter_init (&(ITER), (FNTYPE));                     \
4689        (PTR = function_args_iter_cond_ptr (&(ITER))) != NULL;           \
4690        function_args_iter_next (&(ITER)))
4691
4692 /* Loop over all function arguments of FNTYPE.  In each iteration, TREE is set
4693    to the next tree element.  ITER is an instance of function_args_iterator
4694    used to iterate the arguments.  */
4695 #define FOREACH_FUNCTION_ARGS(FNTYPE, TREE, ITER)                       \
4696   for (function_args_iter_init (&(ITER), (FNTYPE));                     \
4697        (TREE = function_args_iter_cond (&(ITER))) != NULL_TREE;         \
4698        function_args_iter_next (&(ITER)))
4699
4700
4701 \f
4702 /* In tree.c */
4703 extern unsigned crc32_string (unsigned, const char *);
4704 extern void clean_symbol_name (char *);
4705 extern tree get_file_function_name (const char *);
4706 extern tree get_callee_fndecl (const_tree);
4707 extern void change_decl_assembler_name (tree, tree);
4708 extern int type_num_arguments (const_tree);
4709 extern bool associative_tree_code (enum tree_code);
4710 extern bool commutative_tree_code (enum tree_code);
4711 extern tree upper_bound_in_type (tree, tree);
4712 extern tree lower_bound_in_type (tree, tree);
4713 extern int operand_equal_for_phi_arg_p (const_tree, const_tree);
4714 extern bool empty_body_p (tree);
4715 extern tree call_expr_arg (tree, int);
4716 extern tree *call_expr_argp (tree, int);
4717 extern tree call_expr_arglist (tree);
4718 extern bool stdarg_p (tree);
4719 extern bool prototype_p (tree);
4720 extern int function_args_count (tree);
4721 extern bool auto_var_in_fn_p (const_tree, const_tree);
4722 \f
4723 /* In stmt.c */
4724
4725 extern void expand_expr_stmt (tree);
4726 extern int warn_if_unused_value (const_tree, location_t);
4727 extern void expand_label (tree);
4728 extern void expand_goto (tree);
4729
4730 extern rtx expand_stack_save (void);
4731 extern void expand_stack_restore (tree);
4732 extern void expand_return (tree);
4733 extern int is_body_block (const_tree);
4734
4735 /* In tree-eh.c */
4736 extern void using_eh_for_cleanups (void);
4737
4738 /* In fold-const.c */
4739
4740 /* Non-zero if we are folding constants inside an initializer; zero
4741    otherwise.  */
4742 extern int folding_initializer;
4743
4744 /* Convert between trees and native memory representation.  */
4745 extern int native_encode_expr (const_tree, unsigned char *, int);
4746 extern tree native_interpret_expr (tree, const unsigned char *, int);
4747
4748 /* Fold constants as much as possible in an expression.
4749    Returns the simplified expression.
4750    Acts only on the top level of the expression;
4751    if the argument itself cannot be simplified, its
4752    subexpressions are not changed.  */
4753
4754 extern tree fold (tree);
4755 extern tree fold_unary (enum tree_code, tree, tree);
4756 extern tree fold_binary (enum tree_code, tree, tree, tree);
4757 extern tree fold_ternary (enum tree_code, tree, tree, tree, tree);
4758 extern tree fold_build1_stat (enum tree_code, tree, tree MEM_STAT_DECL);
4759 #define fold_build1(c,t1,t2) fold_build1_stat (c, t1, t2 MEM_STAT_INFO)
4760 extern tree fold_build2_stat (enum tree_code, tree, tree, tree MEM_STAT_DECL);
4761 #define fold_build2(c,t1,t2,t3) fold_build2_stat (c, t1, t2, t3 MEM_STAT_INFO)
4762 extern tree fold_build3_stat (enum tree_code, tree, tree, tree, tree MEM_STAT_DECL);
4763 #define fold_build3(c,t1,t2,t3,t4) fold_build3_stat (c, t1, t2, t3, t4 MEM_STAT_INFO)
4764 extern tree fold_build1_initializer (enum tree_code, tree, tree);
4765 extern tree fold_build2_initializer (enum tree_code, tree, tree, tree);
4766 extern tree fold_build3_initializer (enum tree_code, tree, tree, tree, tree);
4767 extern tree fold_build_call_array (tree, tree, int, tree *);
4768 extern tree fold_build_call_array_initializer (tree, tree, int, tree *);
4769 extern bool fold_convertible_p (const_tree, const_tree);
4770 extern tree fold_convert (tree, tree);
4771 extern tree fold_single_bit_test (enum tree_code, tree, tree, tree);
4772 extern tree fold_ignored_result (tree);
4773 extern tree fold_abs_const (tree, tree);
4774 extern tree fold_indirect_ref_1 (tree, tree);
4775 extern void fold_defer_overflow_warnings (void);
4776 extern void fold_undefer_overflow_warnings (bool, const_tree, int);
4777 extern void fold_undefer_and_ignore_overflow_warnings (void);
4778 extern bool fold_deferring_overflow_warnings_p (void);
4779 extern tree maybe_fold_offset_to_reference (tree, tree, tree);
4780
4781 extern tree force_fit_type_double (tree, unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4782                                    int, bool);
4783
4784 extern int fit_double_type (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4785                             unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, const_tree);
4786 extern int add_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4787                                  unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4788                                  unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
4789                                  bool);
4790 #define add_double(l1,h1,l2,h2,lv,hv) \
4791   add_double_with_sign (l1, h1, l2, h2, lv, hv, false)
4792 extern int neg_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4793                        unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4794 extern int mul_double_with_sign (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4795                                  unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4796                                  unsigned HOST_WIDE_INT *, HOST_WIDE_INT *,
4797                                  bool);
4798 #define mul_double(l1,h1,l2,h2,lv,hv) \
4799   mul_double_with_sign (l1, h1, l2, h2, lv, hv, false)
4800 extern void lshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4801                            HOST_WIDE_INT, unsigned int,
4802                            unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
4803 extern void rshift_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4804                            HOST_WIDE_INT, unsigned int,
4805                            unsigned HOST_WIDE_INT *, HOST_WIDE_INT *, int);
4806 extern void lrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4807                             HOST_WIDE_INT, unsigned int,
4808                             unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4809 extern void rrotate_double (unsigned HOST_WIDE_INT, HOST_WIDE_INT,
4810                             HOST_WIDE_INT, unsigned int,
4811                             unsigned HOST_WIDE_INT *, HOST_WIDE_INT *);
4812
4813 extern int div_and_round_double (enum tree_code, int, unsigned HOST_WIDE_INT,
4814                                  HOST_WIDE_INT, unsigned HOST_WIDE_INT,
4815                                  HOST_WIDE_INT, unsigned HOST_WIDE_INT *,
4816                                  HOST_WIDE_INT *, unsigned HOST_WIDE_INT *,
4817                                  HOST_WIDE_INT *);
4818
4819 enum operand_equal_flag
4820 {
4821   OEP_ONLY_CONST = 1,
4822   OEP_PURE_SAME = 2
4823 };
4824
4825 extern int operand_equal_p (const_tree, const_tree, unsigned int);
4826 extern int multiple_of_p (tree, const_tree, const_tree);
4827 extern tree omit_one_operand (tree, tree, tree);
4828 extern tree omit_two_operands (tree, tree, tree, tree);
4829 extern tree invert_truthvalue (tree);
4830 extern tree fold_truth_not_expr (tree);
4831 extern tree fold_unary_to_constant (enum tree_code, tree, tree);
4832 extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
4833 extern tree fold_read_from_constant_string (tree);
4834 extern tree int_const_binop (enum tree_code, const_tree, const_tree, int);
4835 extern tree build_fold_addr_expr (tree);
4836 extern tree fold_build_cleanup_point_expr (tree type, tree expr);
4837 extern tree fold_strip_sign_ops (tree);
4838 extern tree build_fold_addr_expr_with_type (tree, tree);
4839 extern tree build_fold_indirect_ref (tree);
4840 extern tree fold_indirect_ref (tree);
4841 extern tree constant_boolean_node (int, tree);
4842 extern tree build_low_bits_mask (tree, unsigned);
4843
4844 extern bool tree_swap_operands_p (const_tree, const_tree, bool);
4845 extern void swap_tree_operands (tree, tree *, tree *);
4846 extern enum tree_code swap_tree_comparison (enum tree_code);
4847
4848 extern bool ptr_difference_const (tree, tree, HOST_WIDE_INT *);
4849 extern enum tree_code invert_tree_comparison (enum tree_code, bool);
4850
4851 extern bool tree_expr_nonzero_p (tree);
4852 extern bool tree_expr_nonzero_warnv_p (tree, bool *);
4853
4854 extern bool fold_real_zero_addition_p (const_tree, const_tree, int);
4855
4856 /* In builtins.c */
4857 extern tree fold_call_expr (tree, bool);
4858 extern tree fold_builtin_fputs (tree, tree, bool, bool, tree);
4859 extern tree fold_builtin_strcpy (tree, tree, tree, tree);
4860 extern tree fold_builtin_strncpy (tree, tree, tree, tree, tree);
4861 extern tree fold_builtin_memory_chk (tree, tree, tree, tree, tree, tree, bool,
4862                                      enum built_in_function);
4863 extern tree fold_builtin_stxcpy_chk (tree, tree, tree, tree, tree, bool,
4864                                      enum built_in_function);
4865 extern tree fold_builtin_strncpy_chk (tree, tree, tree, tree, tree);
4866 extern tree fold_builtin_snprintf_chk (tree, tree, enum built_in_function);
4867 extern bool fold_builtin_next_arg (tree, bool);
4868 extern enum built_in_function builtin_mathfn_code (const_tree);
4869 extern tree build_function_call_expr (tree, tree);
4870 extern tree fold_builtin_call_array (tree, tree, int, tree *);
4871 extern void debug_fold_checksum (const_tree);
4872 extern tree build_call_expr (tree, int, ...);
4873 extern tree mathfn_built_in (tree, enum built_in_function fn);
4874 extern tree strip_float_extensions (tree);
4875 extern tree c_strlen (tree, int);
4876 extern tree std_gimplify_va_arg_expr (tree, tree, tree *, tree *);
4877 extern tree build_va_arg_indirect_ref (tree);
4878 extern tree build_string_literal (int, const char *);
4879 extern bool validate_arglist (const_tree, ...);
4880 extern rtx builtin_memset_read_str (void *, HOST_WIDE_INT, enum machine_mode);
4881 extern int get_pointer_alignment (tree, unsigned int);
4882
4883 /* In convert.c */
4884 extern tree strip_float_extensions (tree);
4885
4886 /* In alias.c */
4887 extern void record_component_aliases (tree);
4888 extern alias_set_type get_alias_set (tree);
4889 extern int alias_sets_conflict_p (alias_set_type, alias_set_type);
4890 extern int alias_sets_must_conflict_p (alias_set_type, alias_set_type);
4891 extern int objects_must_conflict_p (tree, tree);
4892
4893 /* In tree.c */
4894 extern int really_constant_p (const_tree);
4895 extern int int_fits_type_p (const_tree, const_tree);
4896 #ifndef GENERATOR_FILE
4897 extern void get_type_static_bounds (const_tree, mpz_t, mpz_t);
4898 #endif
4899 extern bool variably_modified_type_p (tree, tree);
4900 extern int tree_log2 (const_tree);
4901 extern int tree_floor_log2 (const_tree);
4902 extern int simple_cst_equal (const_tree, const_tree);
4903 extern hashval_t iterative_hash_expr (const_tree, hashval_t);
4904 extern int compare_tree_int (const_tree, unsigned HOST_WIDE_INT);
4905 extern int type_list_equal (const_tree, const_tree);
4906 extern int chain_member (const_tree, const_tree);
4907 extern tree type_hash_lookup (unsigned int, tree);
4908 extern void type_hash_add (unsigned int, tree);
4909 extern int simple_cst_list_equal (const_tree, const_tree);
4910 extern void dump_tree_statistics (void);
4911 extern void expand_function_end (void);
4912 extern void expand_function_start (tree);
4913 extern void stack_protect_prologue (void);
4914 extern void stack_protect_epilogue (void);
4915 extern void recompute_tree_invariant_for_addr_expr (tree);
4916 extern bool needs_to_live_in_memory (const_tree);
4917 extern tree reconstruct_complex_type (tree, tree);
4918
4919 extern int real_onep (const_tree);
4920 extern int real_twop (const_tree);
4921 extern int real_minus_onep (const_tree);
4922 extern void init_ttree (void);
4923 extern void build_common_tree_nodes (bool, bool);
4924 extern void build_common_tree_nodes_2 (int);
4925 extern void build_common_builtin_nodes (void);
4926 extern tree build_nonstandard_integer_type (unsigned HOST_WIDE_INT, int);
4927 extern tree build_range_type (tree, tree, tree);
4928 extern HOST_WIDE_INT int_cst_value (const_tree);
4929 extern tree build_addr (tree, tree);
4930
4931 extern bool fields_compatible_p (const_tree, const_tree);
4932 extern tree find_compatible_field (tree, tree);
4933
4934 extern location_t expr_location (const_tree);
4935 extern void set_expr_location (tree, location_t);
4936 extern bool expr_has_location (const_tree);
4937
4938 #ifdef USE_MAPPED_LOCATION
4939 extern source_locus *expr_locus (const_tree);
4940 extern void set_expr_locus (tree, source_location *);
4941 #else
4942 extern source_locus expr_locus (const_tree);
4943 extern void set_expr_locus (tree, source_locus loc);
4944 #endif
4945 extern const char *expr_filename (const_tree);
4946 extern int expr_lineno (const_tree);
4947
4948 extern tree *tree_block (tree);
4949 extern tree *generic_tree_operand (tree, int);
4950 extern tree *generic_tree_type (tree);
4951 extern location_t *block_nonartificial_location (tree);
4952
4953 /* In function.c */
4954 extern void expand_main_function (void);
4955 extern void init_dummy_function_start (void);
4956 extern void expand_dummy_function_end (void);
4957 extern unsigned int init_function_for_compilation (void);
4958 extern void allocate_struct_function (tree, bool);
4959 extern void push_struct_function (tree fndecl);
4960 extern void init_function_start (tree);
4961 extern bool use_register_for_decl (const_tree);
4962 extern void generate_setjmp_warnings (void);
4963 extern void init_temp_slots (void);
4964 extern void free_temp_slots (void);
4965 extern void pop_temp_slots (void);
4966 extern void push_temp_slots (void);
4967 extern void preserve_temp_slots (rtx);
4968 extern int aggregate_value_p (const_tree, const_tree);
4969 extern void push_function_context (void);
4970 extern void pop_function_context (void);
4971 extern void push_function_context_to (tree);
4972 extern void pop_function_context_from (tree);
4973 extern tree gimplify_parameters (void);
4974
4975 /* In print-rtl.c */
4976 #ifdef BUFSIZ
4977 extern void print_rtl (FILE *, const_rtx);
4978 #endif
4979
4980 /* In print-tree.c */
4981 extern void debug_tree (tree);
4982 #ifdef BUFSIZ
4983 extern void dump_addr (FILE*, const char *, const void *);
4984 extern void print_node (FILE *, const char *, tree, int);
4985 extern void print_node_brief (FILE *, const char *, const_tree, int);
4986 extern void indent_to (FILE *, int);
4987 #endif
4988
4989 /* In tree-inline.c:  */
4990 extern bool debug_find_tree (tree, tree);
4991 /* This is in tree-inline.c since the routine uses
4992    data structures from the inliner.  */
4993 extern tree unsave_expr_now (tree);
4994 extern tree build_duplicate_type (tree);
4995
4996 /* In calls.c */
4997
4998 /* Nonzero if this is a call to a function whose return value depends
4999    solely on its arguments, has no side effects, and does not read
5000    global memory.  */
5001 #define ECF_CONST               1
5002 /* Nonzero if this call will never return.  */
5003 #define ECF_NORETURN            2
5004 /* Nonzero if this is a call to malloc or a related function.  */
5005 #define ECF_MALLOC              4
5006 /* Nonzero if it is plausible that this is a call to alloca.  */
5007 #define ECF_MAY_BE_ALLOCA       8
5008 /* Nonzero if this is a call to a function that won't throw an exception.  */
5009 #define ECF_NOTHROW             16
5010 /* Nonzero if this is a call to setjmp or a related function.  */
5011 #define ECF_RETURNS_TWICE       32
5012 /* Nonzero if this call replaces the current stack frame.  */
5013 #define ECF_SIBCALL             64
5014 /* Nonzero if this is a call to "pure" function (like const function,
5015    but may read memory.  */
5016 #define ECF_PURE                128
5017 /* Nonzero if this is a call to a function that returns with the stack
5018    pointer depressed.  */
5019 #define ECF_SP_DEPRESSED        256
5020 /* Create libcall block around the call.  */
5021 #define ECF_LIBCALL_BLOCK       512
5022 /* Function does not read or write memory (but may have side effects, so
5023    it does not necessarily fit ECF_CONST).  */
5024 #define ECF_NOVOPS              1024
5025
5026 extern int flags_from_decl_or_type (const_tree);
5027 extern int call_expr_flags (const_tree);
5028
5029 extern int setjmp_call_p (const_tree);
5030 extern bool alloca_call_p (const_tree);
5031 extern bool must_pass_in_stack_var_size (enum machine_mode, const_tree);
5032 extern bool must_pass_in_stack_var_size_or_pad (enum machine_mode, const_tree);
5033
5034 /* In attribs.c.  */
5035
5036 extern const struct attribute_spec *lookup_attribute_spec (tree);
5037
5038 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
5039    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
5040    it should be modified in place; if a TYPE, a copy should be created
5041    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
5042    information, in the form of a bitwise OR of flags in enum attribute_flags
5043    from tree.h.  Depending on these flags, some attributes may be
5044    returned to be applied at a later stage (for example, to apply
5045    a decl attribute to the declaration rather than to its type).  */
5046 extern tree decl_attributes (tree *, tree, int);
5047
5048 /* In integrate.c */
5049 extern void set_decl_abstract_flags (tree, int);
5050 extern void set_decl_origin_self (tree);
5051
5052 /* In stor-layout.c */
5053 extern void set_min_and_max_values_for_integral_type (tree, int, bool);
5054 extern void fixup_signed_type (tree);
5055 extern void internal_reference_types (void);
5056 extern unsigned int update_alignment_for_field (record_layout_info, tree,
5057                                                 unsigned int);
5058 /* varasm.c */
5059 extern void make_decl_rtl (tree);
5060 extern void make_decl_one_only (tree);
5061 extern int supports_one_only (void);
5062 extern void resolve_unique_section (tree, int, int);
5063 extern void mark_referenced (tree);
5064 extern void mark_decl_referenced (tree);
5065 extern void notice_global_symbol (tree);
5066 extern void set_user_assembler_name (tree, const char *);
5067 extern void process_pending_assemble_externals (void);
5068 extern void finish_aliases_1 (void);
5069 extern void finish_aliases_2 (void);
5070 extern tree emutls_decl (tree);
5071
5072 /* In stmt.c */
5073 extern void expand_computed_goto (tree);
5074 extern bool parse_output_constraint (const char **, int, int, int,
5075                                      bool *, bool *, bool *);
5076 extern bool parse_input_constraint (const char **, int, int, int, int,
5077                                     const char * const *, bool *, bool *);
5078 extern void expand_asm_expr (tree);
5079 extern tree resolve_asm_operand_names (tree, tree, tree);
5080 extern void expand_case (tree);
5081 extern void expand_decl (tree);
5082 extern void expand_anon_union_decl (tree, tree, tree);
5083 #ifdef HARD_CONST
5084 /* Silly ifdef to avoid having all includers depend on hard-reg-set.h.  */
5085 extern tree tree_overlaps_hard_reg_set (tree, HARD_REG_SET *);
5086 #endif
5087
5088 /* In gimplify.c.  */
5089 extern tree create_artificial_label (void);
5090 extern void gimplify_function_tree (tree);
5091 extern const char *get_name (const_tree);
5092 extern tree unshare_expr (tree);
5093 extern void sort_case_labels (tree);
5094 \f
5095 /* Interface of the DWARF2 unwind info support.  */
5096
5097 /* Generate a new label for the CFI info to refer to.  */
5098
5099 extern char *dwarf2out_cfi_label (void);
5100
5101 /* Entry point to update the canonical frame address (CFA).  */
5102
5103 extern void dwarf2out_def_cfa (const char *, unsigned, HOST_WIDE_INT);
5104
5105 /* Add the CFI for saving a register window.  */
5106
5107 extern void dwarf2out_window_save (const char *);
5108
5109 /* Add a CFI to update the running total of the size of arguments pushed
5110    onto the stack.  */
5111
5112 extern void dwarf2out_args_size (const char *, HOST_WIDE_INT);
5113
5114 /* Entry point for saving a register to the stack.  */
5115
5116 extern void dwarf2out_reg_save (const char *, unsigned, HOST_WIDE_INT);
5117
5118 /* Entry point for saving the return address in the stack.  */
5119
5120 extern void dwarf2out_return_save (const char *, HOST_WIDE_INT);
5121
5122 /* Entry point for saving the return address in a register.  */
5123
5124 extern void dwarf2out_return_reg (const char *, unsigned);
5125
5126 /* Entry point for saving the first register into the second.  */
5127
5128 extern void dwarf2out_reg_save_reg (const char *, rtx, rtx);
5129
5130 /* In tree-inline.c  */
5131
5132 /* The type of a set of already-visited pointers.  Functions for creating
5133    and manipulating it are declared in pointer-set.h */
5134 struct pointer_set_t;
5135
5136 /* The type of a callback function for walking over tree structure.  */
5137
5138 typedef tree (*walk_tree_fn) (tree *, int *, void *);
5139
5140 /* The type of a callback function that represents a custom walk_tree.  */
5141
5142 typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *),
5143                               void *, struct pointer_set_t*);
5144
5145 extern tree walk_tree_1 (tree*, walk_tree_fn, void*, struct pointer_set_t*,
5146                          walk_tree_lh);
5147 extern tree walk_tree_without_duplicates_1 (tree*, walk_tree_fn, void*,
5148                                             walk_tree_lh);
5149 #define walk_tree(a,b,c,d) \
5150         walk_tree_1 (a, b, c, d, NULL)
5151 #define walk_tree_without_duplicates(a,b,c) \
5152         walk_tree_without_duplicates_1 (a, b, c, NULL)
5153
5154 /* Assign the RTX to declaration.  */
5155
5156 extern void set_decl_rtl (tree, rtx);
5157 extern void set_decl_incoming_rtl (tree, rtx, bool);
5158 \f
5159 /* Enum and arrays used for tree allocation stats.
5160    Keep in sync with tree.c:tree_node_kind_names.  */
5161 typedef enum
5162 {
5163   d_kind,
5164   t_kind,
5165   b_kind,
5166   s_kind,
5167   r_kind,
5168   e_kind,
5169   c_kind,
5170   id_kind,
5171   perm_list_kind,
5172   temp_list_kind,
5173   vec_kind,
5174   binfo_kind,
5175   phi_kind,
5176   ssa_name_kind,
5177   constr_kind,
5178   x_kind,
5179   lang_decl,
5180   lang_type,
5181   omp_clause_kind,
5182   gimple_stmt_kind,
5183   all_kinds
5184 } tree_node_kind;
5185
5186 extern int tree_node_counts[];
5187 extern int tree_node_sizes[];
5188
5189 /* True if we are in gimple form and the actions of the folders need to
5190    be restricted.  False if we are not in gimple form and folding is not
5191    restricted to creating gimple expressions.  */
5192 extern bool in_gimple_form;
5193
5194 /* In tree-gimple.c.  */
5195 extern tree get_base_address (tree t);
5196
5197 /* In tree-vectorizer.c.  */
5198 extern void vect_set_verbosity_level (const char *);
5199
5200 /* In tree.c.  */
5201
5202 struct tree_map_base GTY(())
5203 {
5204   tree from;
5205 };
5206
5207 extern int tree_map_base_eq (const void *, const void *);
5208 extern unsigned int tree_map_base_hash (const void *);
5209 extern int tree_map_base_marked_p (const void *);
5210
5211 /* Map from a tree to another tree.  */
5212
5213 struct tree_map GTY(())
5214 {
5215   struct tree_map_base base;
5216   unsigned int hash;
5217   tree to;
5218 };
5219
5220 #define tree_map_eq tree_map_base_eq
5221 extern unsigned int tree_map_hash (const void *);
5222 #define tree_map_marked_p tree_map_base_marked_p
5223
5224 /* Map from a tree to an int.  */
5225
5226 struct tree_int_map GTY(())
5227 {
5228   struct tree_map_base base;
5229   unsigned int to;
5230 };
5231
5232 #define tree_int_map_eq tree_map_base_eq
5233 #define tree_int_map_hash tree_map_base_hash
5234 #define tree_int_map_marked_p tree_map_base_marked_p
5235
5236 /* Map from a tree to initialization/finalization priorities.  */
5237
5238 struct tree_priority_map GTY(())
5239 {
5240   struct tree_map_base base;
5241   priority_type init;
5242   priority_type fini;
5243 };
5244
5245 #define tree_priority_map_eq tree_map_base_eq
5246 #define tree_priority_map_hash tree_map_base_hash
5247 #define tree_priority_map_marked_p tree_map_base_marked_p
5248
5249 /* In tree-ssa-address.c.  */
5250 extern tree tree_mem_ref_addr (tree, tree);
5251 extern void copy_mem_ref_info (tree, tree);
5252
5253 /* In tree-vrp.c */
5254 extern bool ssa_name_nonzero_p (const_tree);
5255 extern bool ssa_name_nonnegative_p (const_tree);
5256
5257 /* In tree-object-size.c.  */
5258 extern void init_object_sizes (void);
5259 extern void fini_object_sizes (void);
5260 extern unsigned HOST_WIDE_INT compute_builtin_object_size (tree, int);
5261
5262 /* In expr.c.  */
5263 extern unsigned HOST_WIDE_INT highest_pow2_factor (const_tree);
5264
5265 /* In tree-inline.c.  */
5266
5267 void init_inline_once (void);
5268
5269 /* Compute the number of operands in an expression node NODE.  For
5270    tcc_vl_exp nodes like CALL_EXPRs, this is stored in the node itself,
5271    otherwise it is looked up from the node's code.  */
5272 static inline int
5273 tree_operand_length (const_tree node)
5274 {
5275   if (VL_EXP_CLASS_P (node))
5276     return VL_EXP_OPERAND_LENGTH (node);
5277   else
5278     return TREE_CODE_LENGTH (TREE_CODE (node));
5279 }
5280
5281 /* Abstract iterators for CALL_EXPRs.  These static inline definitions
5282    have to go towards the end of tree.h so that union tree_node is fully
5283    defined by this point.  */
5284
5285 /* Structure containing iterator state.  */
5286 typedef struct call_expr_arg_iterator_d GTY (())
5287 {
5288   tree t;       /* the call_expr */
5289   int n;        /* argument count */
5290   int i;        /* next argument index */
5291 } call_expr_arg_iterator;
5292
5293 typedef struct const_call_expr_arg_iterator_d GTY (())
5294 {
5295   const_tree t; /* the call_expr */
5296   int n;        /* argument count */
5297   int i;        /* next argument index */
5298 } const_call_expr_arg_iterator;
5299
5300 /* Initialize the abstract argument list iterator object ITER with the
5301    arguments from CALL_EXPR node EXP.  */
5302 static inline void
5303 init_call_expr_arg_iterator (tree exp, call_expr_arg_iterator *iter)
5304 {
5305   iter->t = exp;
5306   iter->n = call_expr_nargs (exp);
5307   iter->i = 0;
5308 }
5309
5310 static inline void
5311 init_const_call_expr_arg_iterator (const_tree exp, const_call_expr_arg_iterator *iter)
5312 {
5313   iter->t = exp;
5314   iter->n = call_expr_nargs (exp);
5315   iter->i = 0;
5316 }
5317
5318 /* Return the next argument from abstract argument list iterator object ITER,
5319    and advance its state.  Return NULL_TREE if there are no more arguments.  */
5320 static inline tree
5321 next_call_expr_arg (call_expr_arg_iterator *iter)
5322 {
5323   tree result;
5324   if (iter->i >= iter->n)
5325     return NULL_TREE;
5326   result = CALL_EXPR_ARG (iter->t, iter->i);
5327   iter->i++;
5328   return result;
5329 }
5330
5331 static inline const_tree
5332 next_const_call_expr_arg (const_call_expr_arg_iterator *iter)
5333 {
5334   const_tree result;
5335   if (iter->i >= iter->n)
5336     return NULL_TREE;
5337   result = CALL_EXPR_ARG (iter->t, iter->i);
5338   iter->i++;
5339   return result;
5340 }
5341
5342 /* Initialize the abstract argument list iterator object ITER, then advance
5343    past and return the first argument.  Useful in for expressions, e.g.
5344      for (arg = first_call_expr_arg (exp, &iter); arg;
5345           arg = next_call_expr_arg (&iter))   */
5346 static inline tree
5347 first_call_expr_arg (tree exp, call_expr_arg_iterator *iter)
5348 {
5349   init_call_expr_arg_iterator (exp, iter);
5350   return next_call_expr_arg (iter);
5351 }
5352
5353 static inline const_tree
5354 first_const_call_expr_arg (const_tree exp, const_call_expr_arg_iterator *iter)
5355 {
5356   init_const_call_expr_arg_iterator (exp, iter);
5357   return next_const_call_expr_arg (iter);
5358 }
5359
5360 /* Test whether there are more arguments in abstract argument list iterator
5361    ITER, without changing its state.  */
5362 static inline bool
5363 more_call_expr_args_p (const call_expr_arg_iterator *iter)
5364 {
5365   return (iter->i < iter->n);
5366 }
5367
5368 static inline bool
5369 more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter)
5370 {
5371   return (iter->i < iter->n);
5372 }
5373
5374 /* Iterate through each argument ARG of CALL_EXPR CALL, using variable ITER
5375    (of type call_expr_arg_iterator) to hold the iteration state.  */
5376 #define FOR_EACH_CALL_EXPR_ARG(arg, iter, call)                 \
5377   for ((arg) = first_call_expr_arg ((call), &(iter)); (arg);    \
5378        (arg) = next_call_expr_arg (&(iter)))
5379
5380 #define FOR_EACH_CONST_CALL_EXPR_ARG(arg, iter, call)                   \
5381   for ((arg) = first_const_call_expr_arg ((call), &(iter)); (arg);      \
5382        (arg) = next_const_call_expr_arg (&(iter)))
5383
5384 #endif  /* GCC_TREE_H  */