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