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 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, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #ifndef GCC_TREE_H
  23 #define GCC_TREE_H
  24
  25 #include "machmode.h"
  26 #include "version.h"
  27 #include "input.h"
  28
  29 /* Codes of tree nodes */
  30
  31 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
  32
  33 enum tree_code {
  34 #include "tree.def"
  35
  36   LAST_AND_UNUSED_TREE_CODE     /* A convenient way to get a value for
  37                                    NUM_TREE_CODE.  */
  38 };
  39
  40 #undef DEFTREECODE
  41
  42 /* Number of language-independent tree codes.  */
  43 #define NUM_TREE_CODES ((int) LAST_AND_UNUSED_TREE_CODE)
  44
  45 /* Indexed by enum tree_code, contains a character which is
  46    `<' for a comparison expression, `1', for a unary arithmetic
  47    expression, `2' for a binary arithmetic expression, `e' for
  48    other types of expressions, `r' for a reference, `c' for a
  49    constant, `d' for a decl, `t' for a type, `s' for a statement,
  50    and `x' for anything else (TREE_LIST, IDENTIFIER, etc).  */
  51
  52 #define MAX_TREE_CODES 256
  53 extern const char tree_code_type[];
  54 #define TREE_CODE_CLASS(CODE)   tree_code_type[(int) (CODE)]
  55
  56 /* Returns nonzero iff CLASS is the tree-code class of an
  57    expression.  */
  58
  59 #define IS_EXPR_CODE_CLASS(CLASS) \
  60   ((CLASS) == '<' || (CLASS) == '1' || (CLASS) == '2' || (CLASS) == 'e')
  61
  62 /* Number of argument-words in each kind of tree-node.  */
  63
  64 extern const unsigned char tree_code_length[];
  65 #define TREE_CODE_LENGTH(CODE)  tree_code_length[(int) (CODE)]
  66
  67 /* Names of tree components.  */
  68
  69 extern const char *const tree_code_name[];
  70 \f
  71 /* Classify which part of the compiler has defined a given builtin function.
  72    Note that we assume below that this is no more than two bits.  */
  73 enum built_in_class
  74 {
  75   NOT_BUILT_IN = 0,
  76   BUILT_IN_FRONTEND,
  77   BUILT_IN_MD,
  78   BUILT_IN_NORMAL
  79 };
  80
  81 /* Names for the above.  */
  82 extern const char *const built_in_class_names[4];
  83
  84 /* Codes that identify the various built in functions
  85    so that expand_call can identify them quickly.  */
  86
  87 #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM) ENUM,
  88 enum built_in_function
  89 {
  90 #include "builtins.def"
  91
  92   /* Upper bound on non-language-specific builtins.  */
  93   END_BUILTINS
  94 };
  95 #undef DEF_BUILTIN
  96
  97 /* Names for the above.  */
  98 extern const char *const built_in_names[(int) END_BUILTINS];
  99
 100 /* An array of _DECL trees for the above.  */
 101 extern GTY(()) tree built_in_decls[(int) END_BUILTINS];
 102 extern GTY(()) tree implicit_built_in_decls[(int) END_BUILTINS];
 103 \f
 104 /* The definition of tree nodes fills the next several pages.  */
 105
 106 /* A tree node can represent a data type, a variable, an expression
 107    or a statement.  Each node has a TREE_CODE which says what kind of
 108    thing it represents.  Some common codes are:
 109    INTEGER_TYPE -- represents a type of integers.
 110    ARRAY_TYPE -- represents a type of pointer.
 111    VAR_DECL -- represents a declared variable.
 112    INTEGER_CST -- represents a constant integer value.
 113    PLUS_EXPR -- represents a sum (an expression).
 114
 115    As for the contents of a tree node: there are some fields
 116    that all nodes share.  Each TREE_CODE has various special-purpose
 117    fields as well.  The fields of a node are never accessed directly,
 118    always through accessor macros.  */
 119
 120 /* Every kind of tree node starts with this structure,
 121    so all nodes have these fields.
 122
 123    See the accessor macros, defined below, for documentation of the
 124    fields.  */
 125
 126 struct tree_common GTY(())
 127 {
 128   tree chain;
 129   tree type;
 130
 131   ENUM_BITFIELD(tree_code) code : 8;
 132
 133   unsigned side_effects_flag : 1;
 134   unsigned constant_flag : 1;
 135   unsigned addressable_flag : 1;
 136   unsigned volatile_flag : 1;
 137   unsigned readonly_flag : 1;
 138   unsigned unsigned_flag : 1;
 139   unsigned asm_written_flag: 1;
 140   unsigned unused_0 : 1;
 141
 142   unsigned used_flag : 1;
 143   unsigned nothrow_flag : 1;
 144   unsigned static_flag : 1;
 145   unsigned public_flag : 1;
 146   unsigned private_flag : 1;
 147   unsigned protected_flag : 1;
 148   unsigned deprecated_flag : 1;
 149   unsigned unused_1 : 1;
 150
 151   unsigned lang_flag_0 : 1;
 152   unsigned lang_flag_1 : 1;
 153   unsigned lang_flag_2 : 1;
 154   unsigned lang_flag_3 : 1;
 155   unsigned lang_flag_4 : 1;
 156   unsigned lang_flag_5 : 1;
 157   unsigned lang_flag_6 : 1;
 158   unsigned unused_2 : 1;
 159 };
 160
 161 /* The following table lists the uses of each of the above flags and
 162    for which types of nodes they are defined.  Note that expressions
 163    include decls.
 164
 165    addressable_flag:
 166
 167        TREE_ADDRESSABLE in
 168            VAR_DECL, FUNCTION_DECL, FIELD_DECL, CONSTRUCTOR, LABEL_DECL,
 169            ..._TYPE, IDENTIFIER_NODE.
 170            In a STMT_EXPR, it means we want the result of the enclosed
 171            expression.
 172
 173    static_flag:
 174
 175        TREE_STATIC in
 176            VAR_DECL, FUNCTION_DECL, CONSTRUCTOR, ADDR_EXPR
 177        TREE_NO_UNUSED_WARNING in
 178            CONVERT_EXPR, NOP_EXPR, COMPOUND_EXPR
 179        TREE_VIA_VIRTUAL in
 180            TREE_LIST or TREE_VEC
 181        TREE_CONSTANT_OVERFLOW in
 182            INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
 183        TREE_SYMBOL_REFERENCED in
 184            IDENTIFIER_NODE
 185        CLEANUP_EH_ONLY in
 186            TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT,
 187            TREE_LIST elements of a block's cleanup list.
 188
 189    public_flag:
 190
 191        TREE_OVERFLOW in
 192            INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST
 193        TREE_PUBLIC in
 194            VAR_DECL or FUNCTION_DECL or IDENTIFIER_NODE
 195        EXPR_WFL_EMIT_LINE_NOTE in
 196            EXPR_WITH_FILE_LOCATION
 197
 198    private_flag:
 199
 200        TREE_PRIVATE in
 201            ..._DECL
 202        CALL_EXPR_HAS_RETURN_SLOT_ADDR in
 203            CALL_EXPR
 204
 205    protected_flag:
 206
 207        TREE_PROTECTED in
 208            BLOCK
 209            ..._DECL
 210
 211    side_effects_flag:
 212
 213        TREE_SIDE_EFFECTS in
 214            all expressions
 215
 216    volatile_flag:
 217
 218        TREE_THIS_VOLATILE in
 219            all expressions
 220        TYPE_VOLATILE in
 221            ..._TYPE
 222
 223    readonly_flag:
 224
 225        TREE_READONLY in
 226            all expressions
 227        TYPE_READONLY in
 228            ..._TYPE
 229
 230    constant_flag:
 231
 232        TREE_CONSTANT in
 233            all expressions
 234
 235    unsigned_flag:
 236
 237        TREE_UNSIGNED in
 238            INTEGER_TYPE, ENUMERAL_TYPE, FIELD_DECL
 239        SAVE_EXPR_NOPLACEHOLDER in
 240            SAVE_EXPR
 241
 242    asm_written_flag:
 243
 244        TREE_ASM_WRITTEN in
 245            VAR_DECL, FUNCTION_DECL, RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE
 246            BLOCK
 247
 248    used_flag:
 249
 250        TREE_USED in
 251            expressions, IDENTIFIER_NODE
 252
 253    nothrow_flag:
 254
 255        TREE_NOTHROW in
 256            CALL_EXPR, FUNCTION_DECL
 257
 258    deprecated_flag:
 259
 260         TREE_DEPRECATED in
 261            ..._DECL
 262 */
 263
 264 /* Define accessors for the fields that all tree nodes have
 265    (though some fields are not used for all kinds of nodes).  */
 266
 267 /* The tree-code says what kind of node it is.
 268    Codes are defined in tree.def.  */
 269 #define TREE_CODE(NODE) ((enum tree_code) (NODE)->common.code)
 270 #define TREE_SET_CODE(NODE, VALUE) \
 271 ((NODE)->common.code = (ENUM_BITFIELD (tree_code)) (VALUE))
 272
 273 /* When checking is enabled, errors will be generated if a tree node
 274    is accessed incorrectly. The macros abort with a fatal error.  */
 275 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
 276
 277 #define TREE_CHECK(t, code) __extension__                               \
 278 ({  const tree __t = (t);                                               \
 279     if (TREE_CODE(__t) != (code))                                       \
 280       tree_check_failed (__t, code, __FILE__, __LINE__, __FUNCTION__);  \
 281     __t; })
 282 #define TREE_CLASS_CHECK(t, class) __extension__                        \
 283 ({  const tree __t = (t);                                               \
 284     if (TREE_CODE_CLASS(TREE_CODE(__t)) != (class))                     \
 285       tree_class_check_failed (__t, class, __FILE__, __LINE__,          \
 286                                __FUNCTION__);                           \
 287     __t; })
 288
 289 /* These checks have to be special cased.  */
 290 #define EXPR_CHECK(t) __extension__                                     \
 291 ({  const tree __t = (t);                                               \
 292     char const __c = TREE_CODE_CLASS(TREE_CODE(__t));                   \
 293     if (__c != 'r' && __c != 's' && __c != '<'                          \
 294         && __c != '1' && __c != '2' && __c != 'e')                      \
 295       tree_class_check_failed (__t, 'e', __FILE__, __LINE__,            \
 296                                __FUNCTION__);                           \
 297     __t; })
 298
 299 #define TREE_VEC_ELT_CHECK(t, i) __extension__                          \
 300 (*({const tree __t = t;                                                 \
 301     const int __i = (i);                                                \
 302     if (TREE_CODE (__t) != TREE_VEC)                                    \
 303       tree_check_failed (__t, TREE_VEC,                                 \
 304                          __FILE__, __LINE__, __FUNCTION__);             \
 305     if (__i < 0 || __i >= __t->vec.length)                              \
 306       tree_vec_elt_check_failed (__i, __t->vec.length,                  \
 307                                  __FILE__, __LINE__, __FUNCTION__);     \
 308     &__t->vec.a[__i]; }))
 309
 310 /* Special checks for TREE_OPERANDs.  */
 311 #define TREE_OPERAND_CHECK(t, i) __extension__                          \
 312 (*({const tree __t = EXPR_CHECK(t);                                     \
 313     const int __i = (i);                                                \
 314     if (__i < 0 || __i >= TREE_CODE_LENGTH (TREE_CODE (__t)))           \
 315       tree_operand_check_failed (__i, TREE_CODE (__t),                  \
 316                                  __FILE__, __LINE__, __FUNCTION__);     \
 317     &__t->exp.operands[__i]; }))
 318
 319 #define TREE_OPERAND_CHECK_CODE(t, code, i) __extension__               \
 320 (*({const tree __t = t;                                                 \
 321     const int __i = (i);                                                \
 322     const enum tree_code __code = code;                                 \
 323     if (TREE_CODE (__t) != __code)                                      \
 324       tree_check_failed (__t, __code,                                   \
 325                          __FILE__, __LINE__, __FUNCTION__);             \
 326     if (__i < 0 || __i >= TREE_CODE_LENGTH (__code))                    \
 327       tree_operand_check_failed (__i, __code,                           \
 328                                  __FILE__, __LINE__, __FUNCTION__);     \
 329     &__t->exp.operands[__i]; }))
 330
 331 #define TREE_RTL_OPERAND_CHECK(t, code, i) __extension__                \
 332 (*(rtx *)                                                               \
 333  ({const tree __t = t;                                                  \
 334     const int __i = (i);                                                \
 335     const enum tree_code __code = code;                                 \
 336     if (TREE_CODE (__t) != __code)                                      \
 337       tree_check_failed (__t, __code,                                   \
 338                          __FILE__, __LINE__, __FUNCTION__);             \
 339     if (__i < 0 || __i >= TREE_CODE_LENGTH (__code))                    \
 340       tree_operand_check_failed (__i, __code,                           \
 341                                  __FILE__, __LINE__, __FUNCTION__);     \
 342     &__t->exp.operands[__i]; }))
 343
 344 extern void tree_check_failed PARAMS ((const tree, enum tree_code,
 345                                        const char *, int, const char *))
 346     ATTRIBUTE_NORETURN;
 347 extern void tree_class_check_failed PARAMS ((const tree, int,
 348                                              const char *, int, const char *))
 349     ATTRIBUTE_NORETURN;
 350 extern void tree_vec_elt_check_failed PARAMS ((int, int, const char *,
 351                                                int, const char *))
 352     ATTRIBUTE_NORETURN;
 353
 354 extern void tree_operand_check_failed PARAMS ((int, enum tree_code,
 355                                                const char *, int, const char *))
 356     ATTRIBUTE_NORETURN;
 357
 358 #else /* not ENABLE_TREE_CHECKING, or not gcc */
 359
 360 #define TREE_CHECK(t, code)             (t)
 361 #define TREE_CLASS_CHECK(t, code)       (t)
 362 #define EXPR_CHECK(t)                   (t)
 363 #define TREE_VEC_ELT_CHECK(t, i)        ((t)->vec.a[i])
 364 #define TREE_OPERAND_CHECK(t, i)        ((t)->exp.operands[i])
 365 #define TREE_OPERAND_CHECK_CODE(t, code, i) ((t)->exp.operands[i])
 366 #define TREE_RTL_OPERAND_CHECK(t, code, i)  (*(rtx *) &((t)->exp.operands[i]))
 367
 368 #endif
 369
 370 #include "tree-check.h"
 371
 372 #define TYPE_CHECK(tree)        TREE_CLASS_CHECK  (tree, 't')
 373 #define DECL_CHECK(tree)        TREE_CLASS_CHECK  (tree, 'd')
 374 #define CST_CHECK(tree)         TREE_CLASS_CHECK  (tree, 'c')
 375
 376 /* In all nodes that are expressions, this is the data type of the expression.
 377    In POINTER_TYPE nodes, this is the type that the pointer points to.
 378    In ARRAY_TYPE nodes, this is the type of the elements.
 379    In VECTOR_TYPE nodes, this is the type of the elements.  */
 380 #define TREE_TYPE(NODE) ((NODE)->common.type)
 381
 382 /* Here is how primitive or already-canonicalized types' hash codes
 383    are made.  */
 384 #define TYPE_HASH(TYPE) ((size_t) (TYPE) & 0777777)
 385
 386 /* Nodes are chained together for many purposes.
 387    Types are chained together to record them for being output to the debugger
 388    (see the function `chain_type').
 389    Decls in the same scope are chained together to record the contents
 390    of the scope.
 391    Statement nodes for successive statements used to be chained together.
 392    Often lists of things are represented by TREE_LIST nodes that
 393    are chained together.  */
 394
 395 #define TREE_CHAIN(NODE) ((NODE)->common.chain)
 396
 397 /* Given an expression as a tree, strip any NON_LVALUE_EXPRs and NOP_EXPRs
 398    that don't change the machine mode.  */
 399
 400 #define STRIP_NOPS(EXP)                                         \
 401   while ((TREE_CODE (EXP) == NOP_EXPR                           \
 402           || TREE_CODE (EXP) == CONVERT_EXPR                    \
 403           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
 404          && TREE_OPERAND (EXP, 0) != error_mark_node            \
 405          && (TYPE_MODE (TREE_TYPE (EXP))                        \
 406              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
 407     (EXP) = TREE_OPERAND (EXP, 0)
 408
 409 /* Like STRIP_NOPS, but don't let the signedness change either.  */
 410
 411 #define STRIP_SIGN_NOPS(EXP) \
 412   while ((TREE_CODE (EXP) == NOP_EXPR                           \
 413           || TREE_CODE (EXP) == CONVERT_EXPR                    \
 414           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
 415          && TREE_OPERAND (EXP, 0) != error_mark_node            \
 416          && (TYPE_MODE (TREE_TYPE (EXP))                        \
 417              == TYPE_MODE (TREE_TYPE (TREE_OPERAND (EXP, 0))))  \
 418          && (TREE_UNSIGNED (TREE_TYPE (EXP))                    \
 419              == TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
 420     (EXP) = TREE_OPERAND (EXP, 0)
 421
 422 /* Like STRIP_NOPS, but don't alter the TREE_TYPE main variant either.  */
 423
 424 #define STRIP_MAIN_TYPE_NOPS(EXP)                                       \
 425   while ((TREE_CODE (EXP) == NOP_EXPR                                   \
 426           || TREE_CODE (EXP) == CONVERT_EXPR                            \
 427           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                        \
 428          && TREE_OPERAND (EXP, 0) != error_mark_node                    \
 429          && (TYPE_MAIN_VARIANT (TREE_TYPE (EXP))                        \
 430              == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (EXP, 0))))) \
 431     (EXP) = TREE_OPERAND (EXP, 0)
 432
 433 /* Like STRIP_NOPS, but don't alter the TREE_TYPE either.  */
 434
 435 #define STRIP_TYPE_NOPS(EXP) \
 436   while ((TREE_CODE (EXP) == NOP_EXPR                           \
 437           || TREE_CODE (EXP) == CONVERT_EXPR                    \
 438           || TREE_CODE (EXP) == NON_LVALUE_EXPR)                \
 439          && TREE_OPERAND (EXP, 0) != error_mark_node            \
 440          && (TREE_TYPE (EXP)                                    \
 441              == TREE_TYPE (TREE_OPERAND (EXP, 0))))             \
 442     (EXP) = TREE_OPERAND (EXP, 0)
 443
 444 /* Nonzero if TYPE represents an integral type.  Note that we do not
 445    include COMPLEX types here.  */
 446
 447 #define INTEGRAL_TYPE_P(TYPE)  \
 448   (TREE_CODE (TYPE) == INTEGER_TYPE || TREE_CODE (TYPE) == ENUMERAL_TYPE  \
 449    || TREE_CODE (TYPE) == BOOLEAN_TYPE || TREE_CODE (TYPE) == CHAR_TYPE)
 450
 451 /* Nonzero if TYPE represents a floating-point type, including complex
 452    floating-point types.  */
 453
 454 #define FLOAT_TYPE_P(TYPE)              \
 455   (TREE_CODE (TYPE) == REAL_TYPE        \
 456    || (TREE_CODE (TYPE) == COMPLEX_TYPE \
 457        && TREE_CODE (TREE_TYPE (TYPE)) == REAL_TYPE))
 458
 459 /* Nonzero if TYPE represents an aggregate (multi-component) type.  */
 460
 461 #define AGGREGATE_TYPE_P(TYPE) \
 462   (TREE_CODE (TYPE) == ARRAY_TYPE || TREE_CODE (TYPE) == RECORD_TYPE \
 463    || TREE_CODE (TYPE) == UNION_TYPE || TREE_CODE (TYPE) == QUAL_UNION_TYPE \
 464    || TREE_CODE (TYPE) == SET_TYPE)
 465
 466 /* Nonzero if TYPE represents a pointer or reference type.
 467    (It should be renamed to INDIRECT_TYPE_P.)  */
 468
 469 #define POINTER_TYPE_P(TYPE) \
 470   (TREE_CODE (TYPE) == POINTER_TYPE || TREE_CODE (TYPE) == REFERENCE_TYPE)
 471
 472 /* Nonzero if this type is a complete type.  */
 473 #define COMPLETE_TYPE_P(NODE) (TYPE_SIZE (NODE) != NULL_TREE)
 474
 475 /* Nonzero if this type is the (possibly qualified) void type.  */
 476 #define VOID_TYPE_P(NODE) (TREE_CODE (NODE) == VOID_TYPE)
 477
 478 /* Nonzero if this type is complete or is cv void.  */
 479 #define COMPLETE_OR_VOID_TYPE_P(NODE) \
 480   (COMPLETE_TYPE_P (NODE) || VOID_TYPE_P (NODE))
 481
 482 /* Nonzero if this type is complete or is an array with unspecified bound.  */
 483 #define COMPLETE_OR_UNBOUND_ARRAY_TYPE_P(NODE) \
 484   (COMPLETE_TYPE_P (TREE_CODE (NODE) == ARRAY_TYPE ? TREE_TYPE (NODE) : (NODE)))
 485
 486 /* Nonzero if TYPE represents a type.  */
 487
 488 #define TYPE_P(TYPE)    (TREE_CODE_CLASS (TREE_CODE (TYPE)) == 't')
 489 \f
 490 /* Define many boolean fields that all tree nodes have.  */
 491
 492 /* In VAR_DECL nodes, nonzero means address of this is needed.
 493    So it cannot be in a register.
 494    In a FUNCTION_DECL, nonzero means its address is needed.
 495    So it must be compiled even if it is an inline function.
 496    In a FIELD_DECL node, it means that the programmer is permitted to
 497    construct the address of this field.  This is used for aliasing
 498    purposes: see record_component_aliases.
 499    In CONSTRUCTOR nodes, it means object constructed must be in memory.
 500    In LABEL_DECL nodes, it means a goto for this label has been seen
 501    from a place outside all binding contours that restore stack levels.
 502    In ..._TYPE nodes, it means that objects of this type must
 503    be fully addressable.  This means that pieces of this
 504    object cannot go into register parameters, for example.
 505    In IDENTIFIER_NODEs, this means that some extern decl for this name
 506    had its address taken.  That matters for inline functions.  */
 507 #define TREE_ADDRESSABLE(NODE) ((NODE)->common.addressable_flag)
 508
 509 /* In a VAR_DECL, nonzero means allocate static storage.
 510    In a FUNCTION_DECL, nonzero if function has been defined.
 511    In a CONSTRUCTOR, nonzero means allocate static storage.  */
 512 #define TREE_STATIC(NODE) ((NODE)->common.static_flag)
 513
 514 /* In a TARGET_EXPR, WITH_CLEANUP_EXPR, CLEANUP_STMT, or element of a
 515    block's cleanup list, means that the pertinent cleanup should only be
 516    executed if an exception is thrown, not on normal exit of its scope.  */
 517 #define CLEANUP_EH_ONLY(NODE) ((NODE)->common.static_flag)
 518
 519 /* In a CONVERT_EXPR, NOP_EXPR or COMPOUND_EXPR, this means the node was
 520    made implicitly and should not lead to an "unused value" warning.  */
 521 #define TREE_NO_UNUSED_WARNING(NODE) ((NODE)->common.static_flag)
 522
 523 /* Nonzero for a TREE_LIST or TREE_VEC node means that the derivation
 524    chain is via a `virtual' declaration.  */
 525 #define TREE_VIA_VIRTUAL(NODE) ((NODE)->common.static_flag)
 526
 527 /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST this means
 528    there was an overflow in folding.  This is distinct from
 529    TREE_OVERFLOW because ANSI C requires a diagnostic when overflows
 530    occur in constant expressions.  */
 531 #define TREE_CONSTANT_OVERFLOW(NODE) ((NODE)->common.static_flag)
 532
 533 /* In an IDENTIFIER_NODE, this means that assemble_name was called with
 534    this string as an argument.  */
 535 #define TREE_SYMBOL_REFERENCED(NODE) \
 536   (IDENTIFIER_NODE_CHECK (NODE)->common.static_flag)
 537
 538 /* In an INTEGER_CST, REAL_CST, COMPLEX_CST, or VECTOR_CST, this means
 539    there was an overflow in folding, and no warning has been issued
 540    for this subexpression.  TREE_OVERFLOW implies
 541    TREE_CONSTANT_OVERFLOW, but not vice versa.  */
 542 #define TREE_OVERFLOW(NODE) ((NODE)->common.public_flag)
 543
 544 /* In a VAR_DECL or FUNCTION_DECL,
 545    nonzero means name is to be accessible from outside this module.
 546    In an IDENTIFIER_NODE, nonzero means an external declaration
 547    accessible from outside this module was previously seen
 548    for this name in an inner scope.  */
 549 #define TREE_PUBLIC(NODE) ((NODE)->common.public_flag)
 550
 551 /* In any expression, nonzero means it has side effects or reevaluation
 552    of the whole expression could produce a different value.
 553    This is set if any subexpression is a function call, a side effect
 554    or a reference to a volatile variable.
 555    In a ..._DECL, this is set only if the declaration said `volatile'.  */
 556 #define TREE_SIDE_EFFECTS(NODE) ((NODE)->common.side_effects_flag)
 557
 558 /* Nonzero means this expression is volatile in the C sense:
 559    its address should be of type `volatile WHATEVER *'.
 560    In other words, the declared item is volatile qualified.
 561    This is used in _DECL nodes and _REF nodes.
 562
 563    In a ..._TYPE node, means this type is volatile-qualified.
 564    But use TYPE_VOLATILE instead of this macro when the node is a type,
 565    because eventually we may make that a different bit.
 566
 567    If this bit is set in an expression, so is TREE_SIDE_EFFECTS.  */
 568 #define TREE_THIS_VOLATILE(NODE) ((NODE)->common.volatile_flag)
 569
 570 /* In a VAR_DECL, PARM_DECL or FIELD_DECL, or any kind of ..._REF node,
 571    nonzero means it may not be the lhs of an assignment.
 572    In a ..._TYPE node, means this type is const-qualified
 573    (but the macro TYPE_READONLY should be used instead of this macro
 574    when the node is a type).  */
 575 #define TREE_READONLY(NODE) ((NODE)->common.readonly_flag)
 576
 577 /* Nonzero if NODE is a _DECL with TREE_READONLY set.  */
 578 #define TREE_READONLY_DECL_P(NODE) (TREE_READONLY (NODE) && DECL_P (NODE))
 579
 580 /* Value of expression is constant.
 581    Always appears in all ..._CST nodes.
 582    May also appear in an arithmetic expression, an ADDR_EXPR or a CONSTRUCTOR
 583    if the value is constant.  */
 584 #define TREE_CONSTANT(NODE) ((NODE)->common.constant_flag)
 585
 586 /* In INTEGER_TYPE or ENUMERAL_TYPE nodes, means an unsigned type.
 587    In FIELD_DECL nodes, means an unsigned bit field.  */
 588 #define TREE_UNSIGNED(NODE) ((NODE)->common.unsigned_flag)
 589
 590 #define TYPE_TRAP_SIGNED(NODE) \
 591   (flag_trapv && ! TREE_UNSIGNED (TYPE_CHECK (NODE)))
 592
 593 /* Nonzero in a VAR_DECL means assembler code has been written.
 594    Nonzero in a FUNCTION_DECL means that the function has been compiled.
 595    This is interesting in an inline function, since it might not need
 596    to be compiled separately.
 597    Nonzero in a RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE or ENUMERAL_TYPE
 598    if the sdb debugging info for the type has been written.
 599    In a BLOCK node, nonzero if reorder_blocks has already seen this block.  */
 600 #define TREE_ASM_WRITTEN(NODE) ((NODE)->common.asm_written_flag)
 601
 602 /* Nonzero in a _DECL if the name is used in its scope.
 603    Nonzero in an expr node means inhibit warning if value is unused.
 604    In IDENTIFIER_NODEs, this means that some extern decl for this name
 605    was used.  */
 606 #define TREE_USED(NODE) ((NODE)->common.used_flag)
 607
 608 /* In a FUNCTION_DECL, nonzero means a call to the function cannot throw
 609    an exception.  In a CALL_EXPR, nonzero means the call cannot throw.  */
 610 #define TREE_NOTHROW(NODE) ((NODE)->common.nothrow_flag)
 611
 612 /* In a CALL_EXPR, means that the address of the return slot is part of the
 613    argument list.  */
 614 #define CALL_EXPR_HAS_RETURN_SLOT_ADDR(NODE) ((NODE)->common.private_flag)
 615
 616 /* In a type, nonzero means that all objects of the type are guaranteed by the
 617    language or front-end to be properly aligned, so we can indicate that a MEM
 618    of this type is aligned at least to the alignment of the type, even if it
 619    doesn't appear that it is.  We see this, for example, in object-oriented
 620    languages where a tag field may show this is an object of a more-aligned
 621    variant of the more generic type.  */
 622 #define TYPE_ALIGN_OK(NODE) (TYPE_CHECK (NODE)->common.nothrow_flag)
 623
 624 /* Used in classes in C++.  */
 625 #define TREE_PRIVATE(NODE) ((NODE)->common.private_flag)
 626 /* Used in classes in C++.
 627    In a BLOCK node, this is BLOCK_HANDLER_BLOCK.  */
 628 #define TREE_PROTECTED(NODE) ((NODE)->common.protected_flag)
 629
 630 /* Nonzero in an IDENTIFIER_NODE if the use of the name is defined as a
 631    deprecated feature by __attribute__((deprecated)).  */
 632 #define TREE_DEPRECATED(NODE) ((NODE)->common.deprecated_flag)
 633
 634 /* These flags are available for each language front end to use internally.  */
 635 #define TREE_LANG_FLAG_0(NODE) ((NODE)->common.lang_flag_0)
 636 #define TREE_LANG_FLAG_1(NODE) ((NODE)->common.lang_flag_1)
 637 #define TREE_LANG_FLAG_2(NODE) ((NODE)->common.lang_flag_2)
 638 #define TREE_LANG_FLAG_3(NODE) ((NODE)->common.lang_flag_3)
 639 #define TREE_LANG_FLAG_4(NODE) ((NODE)->common.lang_flag_4)
 640 #define TREE_LANG_FLAG_5(NODE) ((NODE)->common.lang_flag_5)
 641 #define TREE_LANG_FLAG_6(NODE) ((NODE)->common.lang_flag_6)
 642 \f
 643 /* Define additional fields and accessors for nodes representing constants.  */
 644
 645 /* In an INTEGER_CST node.  These two together make a 2-word integer.
 646    If the data type is signed, the value is sign-extended to 2 words
 647    even though not all of them may really be in use.
 648    In an unsigned constant shorter than 2 words, the extra bits are 0.  */
 649 #define TREE_INT_CST(NODE) (INTEGER_CST_CHECK (NODE)->int_cst.int_cst)
 650 #define TREE_INT_CST_LOW(NODE) (TREE_INT_CST (NODE).low)
 651 #define TREE_INT_CST_HIGH(NODE) (TREE_INT_CST (NODE).high)
 652
 653 #define INT_CST_LT(A, B)                                \
 654   (TREE_INT_CST_HIGH (A) < TREE_INT_CST_HIGH (B)        \
 655    || (TREE_INT_CST_HIGH (A) == TREE_INT_CST_HIGH (B)   \
 656        && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
 657
 658 #define INT_CST_LT_UNSIGNED(A, B)                               \
 659   (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)              \
 660     < (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))           \
 661    || (((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (A)          \
 662         == (unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (B))      \
 663        && TREE_INT_CST_LOW (A) < TREE_INT_CST_LOW (B)))
 664
 665 struct tree_int_cst GTY(())
 666 {
 667   struct tree_common common;
 668   /* A sub-struct is necessary here because the function `const_hash'
 669      wants to scan both words as a unit and taking the address of the
 670      sub-struct yields the properly inclusive bounded pointer.  */
 671   struct tree_int_cst_lowhi {
 672     unsigned HOST_WIDE_INT low;
 673     HOST_WIDE_INT high;
 674   } int_cst;
 675 };
 676
 677 /* In a REAL_CST node.  struct real_value is an opaque entity, with
 678    manipulators defined in real.h.  We don't want tree.h depending on
 679    real.h and transitively on tm.h.  */
 680 struct real_value;
 681
 682 #define TREE_REAL_CST_PTR(NODE) (REAL_CST_CHECK (NODE)->real_cst.real_cst_ptr)
 683 #define TREE_REAL_CST(NODE) (*TREE_REAL_CST_PTR (NODE))
 684
 685 struct tree_real_cst GTY(())
 686 {
 687   struct tree_common common;
 688   struct real_value * real_cst_ptr;
 689 };
 690
 691 /* In a STRING_CST */
 692 #define TREE_STRING_LENGTH(NODE) (STRING_CST_CHECK (NODE)->string.length)
 693 #define TREE_STRING_POINTER(NODE) (STRING_CST_CHECK (NODE)->string.pointer)
 694
 695 struct tree_string GTY(())
 696 {
 697   struct tree_common common;
 698   int length;
 699   const char *pointer;
 700 };
 701
 702 /* In a COMPLEX_CST node.  */
 703 #define TREE_REALPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.real)
 704 #define TREE_IMAGPART(NODE) (COMPLEX_CST_CHECK (NODE)->complex.imag)
 705
 706 struct tree_complex GTY(())
 707 {
 708   struct tree_common common;
 709   tree real;
 710   tree imag;
 711 };
 712
 713 /* In a VECTOR_CST node.  */
 714 #define TREE_VECTOR_CST_ELTS(NODE) (VECTOR_CST_CHECK (NODE)->vector.elements)
 715
 716 struct tree_vector GTY(())
 717 {
 718   struct tree_common common;
 719   tree elements;
 720 };
 721 \f
 722 #include "hashtable.h"
 723
 724 /* Define fields and accessors for some special-purpose tree nodes.  */
 725
 726 #define IDENTIFIER_LENGTH(NODE) \
 727   (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.len)
 728 #define IDENTIFIER_POINTER(NODE) \
 729   ((const char *) IDENTIFIER_NODE_CHECK (NODE)->identifier.id.str)
 730 #define IDENTIFIER_HASH_VALUE(NODE) \
 731   (IDENTIFIER_NODE_CHECK (NODE)->identifier.id.hash_value)
 732
 733 /* Translate a hash table identifier pointer to a tree_identifier
 734    pointer, and vice versa.  */
 735
 736 #define HT_IDENT_TO_GCC_IDENT(NODE) \
 737   ((tree) ((char *) (NODE) - sizeof (struct tree_common)))
 738 #define GCC_IDENT_TO_HT_IDENT(NODE) (&((struct tree_identifier *) (NODE))->id)
 739
 740 struct tree_identifier GTY(())
 741 {
 742   struct tree_common common;
 743   struct ht_identifier id;
 744 };
 745
 746 /* In a TREE_LIST node.  */
 747 #define TREE_PURPOSE(NODE) (TREE_LIST_CHECK (NODE)->list.purpose)
 748 #define TREE_VALUE(NODE) (TREE_LIST_CHECK (NODE)->list.value)
 749
 750 struct tree_list GTY(())
 751 {
 752   struct tree_common common;
 753   tree purpose;
 754   tree value;
 755 };
 756
 757 /* In a TREE_VEC node.  */
 758 #define TREE_VEC_LENGTH(NODE) (TREE_VEC_CHECK (NODE)->vec.length)
 759 #define TREE_VEC_END(NODE) \
 760   ((void) TREE_VEC_CHECK (NODE), &((NODE)->vec.a[(NODE)->vec.length]))
 761
 762 #define TREE_VEC_ELT(NODE,I) TREE_VEC_ELT_CHECK (NODE, I)
 763
 764 struct tree_vec GTY(())
 765 {
 766   struct tree_common common;
 767   int length;
 768   tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1];
 769 };
 770
 771 /* Define fields and accessors for some nodes that represent expressions.  */
 772
 773 /* In a SAVE_EXPR node.  */
 774 #define SAVE_EXPR_CONTEXT(NODE) TREE_OPERAND_CHECK_CODE (NODE, SAVE_EXPR, 1)
 775 #define SAVE_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, SAVE_EXPR, 2)
 776
 777 #define SAVE_EXPR_NOPLACEHOLDER(NODE) TREE_UNSIGNED (SAVE_EXPR_CHECK (NODE))
 778 /* Nonzero if the SAVE_EXPRs value should be kept, even if it occurs
 779    both in normal code and in a handler.  (Normally, in a handler, all
 780    SAVE_EXPRs are unsaved, meaning that their values are
 781    recalculated.)  */
 782 #define SAVE_EXPR_PERSISTENT_P(NODE) TREE_ASM_WRITTEN (SAVE_EXPR_CHECK (NODE))
 783
 784 /* In a RTL_EXPR node.  */
 785 #define RTL_EXPR_SEQUENCE(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 0)
 786 #define RTL_EXPR_RTL(NODE) TREE_RTL_OPERAND_CHECK (NODE, RTL_EXPR, 1)
 787
 788 /* In a WITH_CLEANUP_EXPR node.  */
 789 #define WITH_CLEANUP_EXPR_RTL(NODE) \
 790   TREE_RTL_OPERAND_CHECK (NODE, WITH_CLEANUP_EXPR, 2)
 791
 792 /* In a CONSTRUCTOR node.  */
 793 #define CONSTRUCTOR_ELTS(NODE) TREE_OPERAND_CHECK_CODE (NODE, CONSTRUCTOR, 0)
 794
 795 /* In ordinary expression nodes.  */
 796 #define TREE_OPERAND(NODE, I) TREE_OPERAND_CHECK (NODE, I)
 797 #define TREE_COMPLEXITY(NODE) (EXPR_CHECK (NODE)->exp.complexity)
 798
 799 /* In a LABELED_BLOCK_EXPR node.  */
 800 #define LABELED_BLOCK_LABEL(NODE) \
 801   TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 0)
 802 #define LABELED_BLOCK_BODY(NODE) \
 803   TREE_OPERAND_CHECK_CODE (NODE, LABELED_BLOCK_EXPR, 1)
 804
 805 /* In an EXIT_BLOCK_EXPR node.  */
 806 #define EXIT_BLOCK_LABELED_BLOCK(NODE) \
 807   TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 0)
 808 #define EXIT_BLOCK_RETURN(NODE) TREE_OPERAND_CHECK_CODE (NODE, EXIT_BLOCK_EXPR, 1)
 809
 810 /* In a LOOP_EXPR node.  */
 811 #define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)
 812
 813 /* In an EXPR_WITH_FILE_LOCATION node.  */
 814 #define EXPR_WFL_EMIT_LINE_NOTE(NODE) \
 815   (EXPR_WITH_FILE_LOCATION_CHECK (NODE)->common.public_flag)
 816 #define EXPR_WFL_NODE(NODE) \
 817   TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 0)
 818 #define EXPR_WFL_FILENAME_NODE(NODE) \
 819   TREE_OPERAND_CHECK_CODE (NODE, EXPR_WITH_FILE_LOCATION, 1)
 820 #define EXPR_WFL_FILENAME(NODE) \
 821   IDENTIFIER_POINTER (EXPR_WFL_FILENAME_NODE (NODE))
 822 /* ??? Java uses this in all expressions.  */
 823 #define EXPR_WFL_LINECOL(NODE) (EXPR_CHECK (NODE)->exp.complexity)
 824 #define EXPR_WFL_LINENO(NODE) (EXPR_WFL_LINECOL (NODE) >> 12)
 825 #define EXPR_WFL_COLNO(NODE) (EXPR_WFL_LINECOL (NODE) & 0xfff)
 826 #define EXPR_WFL_SET_LINECOL(NODE, LINE, COL) \
 827   (EXPR_WFL_LINECOL(NODE) = ((LINE) << 12) | ((COL) & 0xfff))
 828
 829 /* In a TARGET_EXPR node.  */
 830 #define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0)
 831 #define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1)
 832 #define TARGET_EXPR_CLEANUP(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 2)
 833
 834 struct tree_exp GTY(())
 835 {
 836   struct tree_common common;
 837   int complexity;
 838   tree GTY ((special ("tree_exp"),
 839              desc ("TREE_CODE ((tree) &%0)")))
 840     operands[1];
 841 };
 842 \f
 843 /* In a BLOCK node.  */
 844 #define BLOCK_VARS(NODE) (BLOCK_CHECK (NODE)->block.vars)
 845 #define BLOCK_SUBBLOCKS(NODE) (BLOCK_CHECK (NODE)->block.subblocks)
 846 #define BLOCK_SUPERCONTEXT(NODE) (BLOCK_CHECK (NODE)->block.supercontext)
 847 /* Note: when changing this, make sure to find the places
 848    that use chainon or nreverse.  */
 849 #define BLOCK_CHAIN(NODE) TREE_CHAIN (BLOCK_CHECK (NODE))
 850 #define BLOCK_ABSTRACT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.abstract_origin)
 851 #define BLOCK_ABSTRACT(NODE) (BLOCK_CHECK (NODE)->block.abstract_flag)
 852
 853 /* Nonzero means that this block is prepared to handle exceptions
 854    listed in the BLOCK_VARS slot.  */
 855 #define BLOCK_HANDLER_BLOCK(NODE) \
 856   (BLOCK_CHECK (NODE)->block.handler_block_flag)
 857
 858 /* An index number for this block.  These values are not guaranteed to
 859    be unique across functions -- whether or not they are depends on
 860    the debugging output format in use.  */
 861 #define BLOCK_NUMBER(NODE) (BLOCK_CHECK (NODE)->block.block_num)
 862
 863 /* If block reordering splits a lexical block into discontiguous
 864    address ranges, we'll make a copy of the original block.
 865
 866    Note that this is logically distinct from BLOCK_ABSTRACT_ORIGIN.
 867    In that case, we have one source block that has been replicated
 868    (through inlining or unrolling) into many logical blocks, and that
 869    these logical blocks have different physical variables in them.
 870
 871    In this case, we have one logical block split into several
 872    non-contiguous address ranges.  Most debug formats can't actually
 873    represent this idea directly, so we fake it by creating multiple
 874    logical blocks with the same variables in them.  However, for those
 875    that do support non-contiguous regions, these allow the original
 876    logical block to be reconstructed, along with the set of address
 877    ranges.
 878
 879    One of the logical block fragments is arbitrarily chosen to be
 880    the ORIGIN.  The other fragments will point to the origin via
 881    BLOCK_FRAGMENT_ORIGIN; the origin itself will have this pointer
 882    be null.  The list of fragments will be chained through
 883    BLOCK_FRAGMENT_CHAIN from the origin.  */
 884
 885 #define BLOCK_FRAGMENT_ORIGIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_origin)
 886 #define BLOCK_FRAGMENT_CHAIN(NODE) (BLOCK_CHECK (NODE)->block.fragment_chain)
 887
 888 struct tree_block GTY(())
 889 {
 890   struct tree_common common;
 891
 892   unsigned handler_block_flag : 1;
 893   unsigned abstract_flag : 1;
 894   unsigned block_num : 30;
 895
 896   tree vars;
 897   tree subblocks;
 898   tree supercontext;
 899   tree abstract_origin;
 900   tree fragment_origin;
 901   tree fragment_chain;
 902 };
 903 \f
 904 /* Define fields and accessors for nodes representing data types.  */
 905
 906 /* See tree.def for documentation of the use of these fields.
 907    Look at the documentation of the various ..._TYPE tree codes.  */
 908
 909 #define TYPE_UID(NODE) (TYPE_CHECK (NODE)->type.uid)
 910 #define TYPE_SIZE(NODE) (TYPE_CHECK (NODE)->type.size)
 911 #define TYPE_SIZE_UNIT(NODE) (TYPE_CHECK (NODE)->type.size_unit)
 912 #define TYPE_MODE(NODE) (TYPE_CHECK (NODE)->type.mode)
 913 #define TYPE_VALUES(NODE) (TYPE_CHECK (NODE)->type.values)
 914 #define TYPE_DOMAIN(NODE) (TYPE_CHECK (NODE)->type.values)
 915 #define TYPE_FIELDS(NODE) (TYPE_CHECK (NODE)->type.values)
 916 #define TYPE_METHODS(NODE) (TYPE_CHECK (NODE)->type.maxval)
 917 #define TYPE_VFIELD(NODE) (TYPE_CHECK (NODE)->type.minval)
 918 #define TYPE_ARG_TYPES(NODE) (TYPE_CHECK (NODE)->type.values)
 919 #define TYPE_METHOD_BASETYPE(NODE) (TYPE_CHECK (NODE)->type.maxval)
 920 #define TYPE_OFFSET_BASETYPE(NODE) (TYPE_CHECK (NODE)->type.maxval)
 921 #define TYPE_POINTER_TO(NODE) (TYPE_CHECK (NODE)->type.pointer_to)
 922 #define TYPE_REFERENCE_TO(NODE) (TYPE_CHECK (NODE)->type.reference_to)
 923 #define TYPE_MIN_VALUE(NODE) (TYPE_CHECK (NODE)->type.minval)
 924 #define TYPE_MAX_VALUE(NODE) (TYPE_CHECK (NODE)->type.maxval)
 925 #define TYPE_PRECISION(NODE) (TYPE_CHECK (NODE)->type.precision)
 926 #define TYPE_SYMTAB_ADDRESS(NODE) (TYPE_CHECK (NODE)->type.symtab.address)
 927 #define TYPE_SYMTAB_POINTER(NODE) (TYPE_CHECK (NODE)->type.symtab.pointer)
 928 #define TYPE_SYMTAB_DIE(NODE) (TYPE_CHECK (NODE)->type.symtab.die)
 929 #define TYPE_NAME(NODE) (TYPE_CHECK (NODE)->type.name)
 930 #define TYPE_NEXT_VARIANT(NODE) (TYPE_CHECK (NODE)->type.next_variant)
 931 #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
 932 #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
 933 #define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)
 934
 935 /* For a VECTOR_TYPE node, this describes a different type which is emitted
 936    in the debugging output.  We use this to describe a vector as a
 937    structure containing an array.  */
 938 #define TYPE_DEBUG_REPRESENTATION_TYPE(NODE) (TYPE_CHECK (NODE)->type.values)
 939
 940 /* For aggregate types, information about this type, as a base type
 941    for itself.  Used in a language-dependent way for types that are
 942    neither a RECORD_TYPE, QUAL_UNION_TYPE, nor a UNION_TYPE.  */
 943 #define TYPE_BINFO(NODE) (TYPE_CHECK (NODE)->type.binfo)
 944
 945 /* The (language-specific) typed-based alias set for this type.
 946    Objects whose TYPE_ALIAS_SETs are different cannot alias each
 947    other.  If the TYPE_ALIAS_SET is -1, no alias set has yet been
 948    assigned to this type.  If the TYPE_ALIAS_SET is 0, objects of this
 949    type can alias objects of any type.  */
 950 #define TYPE_ALIAS_SET(NODE) (TYPE_CHECK (NODE)->type.alias_set)
 951
 952 /* Nonzero iff the typed-based alias set for this type has been
 953    calculated.  */
 954 #define TYPE_ALIAS_SET_KNOWN_P(NODE) (TYPE_CHECK (NODE)->type.alias_set != -1)
 955
 956 /* A TREE_LIST of IDENTIFIER nodes of the attributes that apply
 957    to this type.  */
 958 #define TYPE_ATTRIBUTES(NODE) (TYPE_CHECK (NODE)->type.attributes)
 959
 960 /* The alignment necessary for objects of this type.
 961    The value is an int, measured in bits.  */
 962 #define TYPE_ALIGN(NODE) (TYPE_CHECK (NODE)->type.align)
 963
 964 /* 1 if the alignment for this type was requested by "aligned" attribute,
 965    0 if it is the default for this type.  */
 966 #define TYPE_USER_ALIGN(NODE) (TYPE_CHECK (NODE)->type.user_align)
 967
 968 /* The alignment for NODE, in bytes.  */
 969 #define TYPE_ALIGN_UNIT(NODE) (TYPE_ALIGN (NODE) / BITS_PER_UNIT)
 970
 971 /* If your language allows you to declare types, and you want debug info
 972    for them, then you need to generate corresponding TYPE_DECL nodes.
 973    These "stub" TYPE_DECL nodes have no name, and simply point at the
 974    type node.  You then set the TYPE_STUB_DECL field of the type node
 975    to point back at the TYPE_DECL node.  This allows the debug routines
 976    to know that the two nodes represent the same type, so that we only
 977    get one debug info record for them.  */
 978 #define TYPE_STUB_DECL(NODE) TREE_CHAIN (NODE)
 979
 980 /* In a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, it means the type
 981    has BLKmode only because it lacks the alignment requirement for
 982    its size.  */
 983 #define TYPE_NO_FORCE_BLK(NODE) (TYPE_CHECK (NODE)->type.no_force_blk_flag)
 984
 985 /* In an INTEGER_TYPE, it means the type represents a size.  We use
 986    this both for validity checking and to permit optimizations that
 987    are unsafe for other types.  Note that the C `size_t' type should
 988    *not* have this flag set.  The `size_t' type is simply a typedef
 989    for an ordinary integer type that happens to be the type of an
 990    expression returned by `sizeof'; `size_t' has no special
 991    properties.  Expressions whose type have TYPE_IS_SIZETYPE set are
 992    always actual sizes.  */
 993 #define TYPE_IS_SIZETYPE(NODE) \
 994   (INTEGER_TYPE_CHECK (NODE)->type.no_force_blk_flag)
 995
 996 /* In a FUNCTION_TYPE, indicates that the function returns with the stack
 997    pointer depressed.  */
 998 #define TYPE_RETURNS_STACK_DEPRESSED(NODE) \
 999   (FUNCTION_TYPE_CHECK (NODE)->type.no_force_blk_flag)
1000
1001 /* Nonzero in a type considered volatile as a whole.  */
1002 #define TYPE_VOLATILE(NODE) (TYPE_CHECK (NODE)->common.volatile_flag)
1003
1004 /* Means this type is const-qualified.  */
1005 #define TYPE_READONLY(NODE) (TYPE_CHECK (NODE)->common.readonly_flag)
1006
1007 /* If nonzero, this type is `restrict'-qualified, in the C sense of
1008    the term.  */
1009 #define TYPE_RESTRICT(NODE) (TYPE_CHECK (NODE)->type.restrict_flag)
1010
1011 /* There is a TYPE_QUAL value for each type qualifier.  They can be
1012    combined by bitwise-or to form the complete set of qualifiers for a
1013    type.  */
1014
1015 #define TYPE_UNQUALIFIED   0x0
1016 #define TYPE_QUAL_CONST    0x1
1017 #define TYPE_QUAL_VOLATILE 0x2
1018 #define TYPE_QUAL_RESTRICT 0x4
1019
1020 /* The set of type qualifiers for this type.  */
1021 #define TYPE_QUALS(NODE)                                        \
1022   ((TYPE_READONLY (NODE) * TYPE_QUAL_CONST)                     \
1023    | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)                \
1024    | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT))
1025
1026 /* These flags are available for each language front end to use internally.  */
1027 #define TYPE_LANG_FLAG_0(NODE) (TYPE_CHECK (NODE)->type.lang_flag_0)
1028 #define TYPE_LANG_FLAG_1(NODE) (TYPE_CHECK (NODE)->type.lang_flag_1)
1029 #define TYPE_LANG_FLAG_2(NODE) (TYPE_CHECK (NODE)->type.lang_flag_2)
1030 #define TYPE_LANG_FLAG_3(NODE) (TYPE_CHECK (NODE)->type.lang_flag_3)
1031 #define TYPE_LANG_FLAG_4(NODE) (TYPE_CHECK (NODE)->type.lang_flag_4)
1032 #define TYPE_LANG_FLAG_5(NODE) (TYPE_CHECK (NODE)->type.lang_flag_5)
1033 #define TYPE_LANG_FLAG_6(NODE) (TYPE_CHECK (NODE)->type.lang_flag_6)
1034
1035 /* If set in an ARRAY_TYPE, indicates a string type (for languages
1036    that distinguish string from array of char).
1037    If set in a SET_TYPE, indicates a bitstring type.  */
1038 #define TYPE_STRING_FLAG(NODE) (TYPE_CHECK (NODE)->type.string_flag)
1039
1040 /* If non-NULL, this is an upper bound of the size (in bytes) of an
1041    object of the given ARRAY_TYPE.  This allows temporaries to be
1042    allocated.  */
1043 #define TYPE_ARRAY_MAX_SIZE(ARRAY_TYPE) \
1044   TYPE_MAX_VALUE (ARRAY_TYPE_CHECK (ARRAY_TYPE))
1045
1046 /* For a VECTOR_TYPE, this is the number of sub-parts of the vector.  */
1047 #define TYPE_VECTOR_SUBPARTS(VECTOR_TYPE) \
1048   GET_MODE_NUNITS (VECTOR_TYPE_CHECK (VECTOR_TYPE)->type.mode)
1049
1050   /* Indicates that objects of this type must be initialized by calling a
1051    function when they are created.  */
1052 #define TYPE_NEEDS_CONSTRUCTING(NODE) \
1053   (TYPE_CHECK (NODE)->type.needs_constructing_flag)
1054
1055 /* Indicates that objects of this type (a UNION_TYPE), should be passed
1056    the same way that the first union alternative would be passed.  */
1057 #define TYPE_TRANSPARENT_UNION(NODE)  \
1058   (UNION_TYPE_CHECK (NODE)->type.transparent_union_flag)
1059
1060 /* For an ARRAY_TYPE, indicates that it is not permitted to
1061    take the address of a component of the type.  */
1062 #define TYPE_NONALIASED_COMPONENT(NODE) \
1063   (ARRAY_TYPE_CHECK (NODE)->type.transparent_union_flag)
1064
1065 /* Indicated that objects of this type should be laid out in as
1066    compact a way as possible.  */
1067 #define TYPE_PACKED(NODE) (TYPE_CHECK (NODE)->type.packed_flag)
1068
1069 struct die_struct;
1070
1071 struct tree_type GTY(())
1072 {
1073   struct tree_common common;
1074   tree values;
1075   tree size;
1076   tree size_unit;
1077   tree attributes;
1078   unsigned int uid;
1079
1080   unsigned int precision : 9;
1081   ENUM_BITFIELD(machine_mode) mode : 7;
1082
1083   unsigned string_flag : 1;
1084   unsigned no_force_blk_flag : 1;
1085   unsigned needs_constructing_flag : 1;
1086   unsigned transparent_union_flag : 1;
1087   unsigned packed_flag : 1;
1088   unsigned restrict_flag : 1;
1089   unsigned spare : 2;
1090
1091   unsigned lang_flag_0 : 1;
1092   unsigned lang_flag_1 : 1;
1093   unsigned lang_flag_2 : 1;
1094   unsigned lang_flag_3 : 1;
1095   unsigned lang_flag_4 : 1;
1096   unsigned lang_flag_5 : 1;
1097   unsigned lang_flag_6 : 1;
1098   unsigned user_align : 1;
1099
1100   unsigned int align;
1101   tree pointer_to;
1102   tree reference_to;
1103   union tree_type_symtab {
1104     int GTY ((tag ("0"))) address;
1105     char * GTY ((tag ("1"))) pointer;
1106     struct die_struct * GTY ((tag ("2"))) die;
1107   } GTY ((desc ("debug_hooks == &sdb_debug_hooks ? 1 : debug_hooks == &dwarf2_debug_hooks ? 2 : 0"),
1108           descbits ("2"))) symtab;
1109   tree name;
1110   tree minval;
1111   tree maxval;
1112   tree next_variant;
1113   tree main_variant;
1114   tree binfo;
1115   tree context;
1116   HOST_WIDE_INT alias_set;
1117   /* Points to a structure whose details depend on the language in use.  */
1118   struct lang_type *lang_specific;
1119 };
1120 \f
1121 /* Define accessor macros for information about type inheritance
1122    and basetypes.
1123
1124    A "basetype" means a particular usage of a data type for inheritance
1125    in another type.  Each such basetype usage has its own "binfo"
1126    object to describe it.  The binfo object is a TREE_VEC node.
1127
1128    Inheritance is represented by the binfo nodes allocated for a
1129    given type.  For example, given types C and D, such that D is
1130    inherited by C, 3 binfo nodes will be allocated: one for describing
1131    the binfo properties of C, similarly one for D, and one for
1132    describing the binfo properties of D as a base type for C.
1133    Thus, given a pointer to class C, one can get a pointer to the binfo
1134    of D acting as a basetype for C by looking at C's binfo's basetypes.  */
1135
1136 /* The actual data type node being inherited in this basetype.  */
1137 #define BINFO_TYPE(NODE) TREE_TYPE (NODE)
1138
1139 /* The offset where this basetype appears in its containing type.
1140    BINFO_OFFSET slot holds the offset (in bytes)
1141    from the base of the complete object to the base of the part of the
1142    object that is allocated on behalf of this `type'.
1143    This is always 0 except when there is multiple inheritance.  */
1144
1145 #define BINFO_OFFSET(NODE) TREE_VEC_ELT ((NODE), 1)
1146 #define TYPE_BINFO_OFFSET(NODE) BINFO_OFFSET (TYPE_BINFO (NODE))
1147 #define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
1148
1149 /* The virtual function table belonging to this basetype.  Virtual
1150    function tables provide a mechanism for run-time method dispatching.
1151    The entries of a virtual function table are language-dependent.  */
1152
1153 #define BINFO_VTABLE(NODE) TREE_VEC_ELT ((NODE), 2)
1154 #define TYPE_BINFO_VTABLE(NODE) BINFO_VTABLE (TYPE_BINFO (NODE))
1155
1156 /* The virtual functions in the virtual function table.  This is
1157    a TREE_LIST that is used as an initial approximation for building
1158    a virtual function table for this basetype.  */
1159 #define BINFO_VIRTUALS(NODE) TREE_VEC_ELT ((NODE), 3)
1160 #define TYPE_BINFO_VIRTUALS(NODE) BINFO_VIRTUALS (TYPE_BINFO (NODE))
1161
1162 /* A vector of binfos for the direct basetypes inherited by this
1163    basetype.
1164
1165    If this basetype describes type D as inherited in C, and if the
1166    basetypes of D are E and F, then this vector contains binfos for
1167    inheritance of E and F by C.
1168
1169    ??? This could probably be done by just allocating the
1170    base types at the end of this TREE_VEC (instead of using
1171    another TREE_VEC).  This would simplify the calculation
1172    of how many basetypes a given type had.  */
1173 #define BINFO_BASETYPES(NODE) TREE_VEC_ELT ((NODE), 4)
1174 #define TYPE_BINFO_BASETYPES(NODE) TREE_VEC_ELT (TYPE_BINFO (NODE), 4)
1175
1176 /* The number of basetypes for NODE.  */
1177 #define BINFO_N_BASETYPES(NODE) \
1178   (BINFO_BASETYPES (NODE) ? TREE_VEC_LENGTH (BINFO_BASETYPES (NODE)) : 0)
1179
1180 /* Accessor macro to get to the Nth basetype of this basetype.  */
1181 #define BINFO_BASETYPE(NODE,N) TREE_VEC_ELT (BINFO_BASETYPES (NODE), (N))
1182 #define TYPE_BINFO_BASETYPE(NODE,N) \
1183   BINFO_TYPE (TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (NODE)), (N)))
1184
1185 /* For a BINFO record describing a virtual base class, i.e., one where
1186    TREE_VIA_VIRTUAL is set, this field assists in locating the virtual
1187    base.  The actual contents are language-dependent.  In the C++
1188    front-end this field is an INTEGER_CST giving an offset into the
1189    vtable where the offset to the virtual base can be found.  */
1190 #define BINFO_VPTR_FIELD(NODE) TREE_VEC_ELT (NODE, 5)
1191
1192 /* Indicates the accesses this binfo has to its bases. The values are
1193    access_public_node, access_protected_node or access_private_node.
1194    If this array is not present, public access is implied.  */
1195 #define BINFO_BASEACCESSES(NODE) TREE_VEC_ELT ((NODE), 6)
1196 #define BINFO_BASEACCESS(NODE,N) TREE_VEC_ELT (BINFO_BASEACCESSES(NODE), (N))
1197
1198 /* Number of language independent elements in a binfo.  Languages may
1199    add additional trailing elements.  */
1200
1201 #define BINFO_ELTS 7
1202
1203 /* Slot used to build a chain that represents a use of inheritance.
1204    For example, if X is derived from Y, and Y is derived from Z,
1205    then this field can be used to link the binfo node for X to
1206    the binfo node for X's Y to represent the use of inheritance
1207    from X to Y.  Similarly, this slot of the binfo node for X's Y
1208    can point to the Z from which Y is inherited (in X's inheritance
1209    hierarchy).  In this fashion, one can represent and traverse specific
1210    uses of inheritance using the binfo nodes themselves (instead of
1211    consing new space pointing to binfo nodes).
1212    It is up to the language-dependent front-ends to maintain
1213    this information as necessary.  */
1214 #define BINFO_INHERITANCE_CHAIN(NODE) TREE_VEC_ELT ((NODE), 0)
1215 \f
1216 /* Define fields and accessors for nodes representing declared names.  */
1217
1218 /* Nonzero if DECL represents a decl.  */
1219 #define DECL_P(DECL)    (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd')
1220
1221 /* This is the name of the object as written by the user.
1222    It is an IDENTIFIER_NODE.  */
1223 #define DECL_NAME(NODE) (DECL_CHECK (NODE)->decl.name)
1224
1225 /* The name of the object as the assembler will see it (but before any
1226    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
1227    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
1228 #define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
1229
1230 /* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set.  If zero,
1231    the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
1232    yet.  */
1233 #define DECL_ASSEMBLER_NAME_SET_P(NODE) \
1234   (DECL_CHECK (NODE)->decl.assembler_name != NULL_TREE)
1235
1236 /* Set the DECL_ASSEMBLER_NAME for NODE to NAME.  */
1237 #define SET_DECL_ASSEMBLER_NAME(NODE, NAME) \
1238   (DECL_CHECK (NODE)->decl.assembler_name = (NAME))
1239
1240 /* Copy the DECL_ASSEMBLER_NAME from DECL1 to DECL2.  Note that if DECL1's
1241    DECL_ASSEMBLER_NAME has not yet been set, using this macro will not cause
1242    the DECL_ASSEMBLER_NAME of either DECL to be set.  In other words, the
1243    semantics of using this macro, are different than saying:
1244
1245      SET_DECL_ASSEMBLER_NAME(DECL2, DECL_ASSEMBLER_NAME (DECL1))
1246
1247    which will try to set the DECL_ASSEMBLER_NAME for DECL1.  */
1248
1249 #define COPY_DECL_ASSEMBLER_NAME(DECL1, DECL2)                          \
1250   (DECL_ASSEMBLER_NAME_SET_P (DECL1)                                    \
1251    ? (void) SET_DECL_ASSEMBLER_NAME (DECL2,                             \
1252                                      DECL_ASSEMBLER_NAME (DECL1))       \
1253    : (void) 0)
1254
1255 /* Records the section name in a section attribute.  Used to pass
1256    the name from decl_attributes to make_function_rtl and make_decl_rtl.  */
1257 #define DECL_SECTION_NAME(NODE) (DECL_CHECK (NODE)->decl.section_name)
1258
1259 /*  For FIELD_DECLs, this is the
1260     RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE node that the field is
1261     a member of.  For VAR_DECL, PARM_DECL, FUNCTION_DECL, LABEL_DECL,
1262     and CONST_DECL nodes, this points to either the FUNCTION_DECL for the
1263     containing function, the RECORD_TYPE or UNION_TYPE for the containing
1264     type, or NULL_TREE if the given decl has "file scope".  */
1265 #define DECL_CONTEXT(NODE) (DECL_CHECK (NODE)->decl.context)
1266 #define DECL_FIELD_CONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.context)
1267 /* In a DECL this is the field where attributes are stored.  */
1268 #define DECL_ATTRIBUTES(NODE) (DECL_CHECK (NODE)->decl.attributes)
1269 /* In a FIELD_DECL, this is the field position, counting in bytes, of the
1270    byte containing the bit closest to the beginning of the structure.  */
1271 #define DECL_FIELD_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->decl.arguments)
1272 /* In a FIELD_DECL, this is the offset, in bits, of the first bit of the
1273    field from DECL_FIELD_OFFSET.  */
1274 #define DECL_FIELD_BIT_OFFSET(NODE) (FIELD_DECL_CHECK (NODE)->decl.u2.t)
1275 /* In a FIELD_DECL, this indicates whether the field was a bit-field and
1276    if so, the type that was originally specified for it.
1277    TREE_TYPE may have been modified (in finish_struct).  */
1278 #define DECL_BIT_FIELD_TYPE(NODE) (FIELD_DECL_CHECK (NODE)->decl.result)
1279 /* In FUNCTION_DECL, a chain of ..._DECL nodes.
1280    VAR_DECL and PARM_DECL reserve the arguments slot for language-specific
1281    uses.  */
1282 #define DECL_ARGUMENTS(NODE) (DECL_CHECK (NODE)->decl.arguments)
1283 /* This field is used to reference anything in decl.result and is meant only
1284    for use by the garbage collector.  */
1285 #define DECL_RESULT_FLD(NODE) (DECL_CHECK (NODE)->decl.result)
1286 /* In FUNCTION_DECL, holds the decl for the return value.  */
1287 #define DECL_RESULT(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.result)
1288 /* For a TYPE_DECL, holds the "original" type.  (TREE_TYPE has the copy.) */
1289 #define DECL_ORIGINAL_TYPE(NODE) (TYPE_DECL_CHECK (NODE)->decl.result)
1290 /* In PARM_DECL, holds the type as written (perhaps a function or array).  */
1291 #define DECL_ARG_TYPE_AS_WRITTEN(NODE) (PARM_DECL_CHECK (NODE)->decl.result)
1292 /* For a FUNCTION_DECL, holds the tree of BINDINGs.
1293    For a VAR_DECL, holds the initial value.
1294    For a PARM_DECL, not used--default
1295    values for parameters are encoded in the type of the function,
1296    not in the PARM_DECL slot.  */
1297 #define DECL_INITIAL(NODE) (DECL_CHECK (NODE)->decl.initial)
1298 /* For a PARM_DECL, records the data type used to pass the argument,
1299    which may be different from the type seen in the program.  */
1300 #define DECL_ARG_TYPE(NODE) (PARM_DECL_CHECK (NODE)->decl.initial)
1301 /* For a FIELD_DECL in a QUAL_UNION_TYPE, records the expression, which
1302    if nonzero, indicates that the field occupies the type.  */
1303 #define DECL_QUALIFIER(NODE) (FIELD_DECL_CHECK (NODE)->decl.initial)
1304 /* These two fields describe where in the source code the declaration
1305    was.  If the declaration appears in several places (as for a C
1306    function that is declared first and then defined later), this
1307    information should refer to the definition.  */
1308 #define DECL_SOURCE_LOCATION(NODE) (DECL_CHECK (NODE)->decl.locus)
1309 #define DECL_SOURCE_FILE(NODE) (DECL_SOURCE_LOCATION (NODE).file)
1310 #define DECL_SOURCE_LINE(NODE) (DECL_SOURCE_LOCATION (NODE).line)
1311 /* Holds the size of the datum, in bits, as a tree expression.
1312    Need not be constant.  */
1313 #define DECL_SIZE(NODE) (DECL_CHECK (NODE)->decl.size)
1314 /* Likewise for the size in bytes.  */
1315 #define DECL_SIZE_UNIT(NODE) (DECL_CHECK (NODE)->decl.size_unit)
1316 /* Holds the alignment required for the datum, in bits.  */
1317 #define DECL_ALIGN(NODE) (DECL_CHECK (NODE)->decl.u1.a.align)
1318 /* The alignment of NODE, in bytes.  */
1319 #define DECL_ALIGN_UNIT(NODE) (DECL_ALIGN (NODE) / BITS_PER_UNIT)
1320 /* For FIELD_DECLs, off_align holds the number of low-order bits of
1321    DECL_FIELD_OFFSET which are known to be always zero.
1322    DECL_OFFSET_ALIGN thus returns the alignment that DECL_FIELD_OFFSET
1323    has.  */
1324 #define DECL_OFFSET_ALIGN(NODE) \
1325   (((unsigned HOST_WIDE_INT)1) << FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align)
1326 /* Specify that DECL_ALIGN(NODE) is a multiple of X.  */
1327 #define SET_DECL_OFFSET_ALIGN(NODE, X) \
1328   (FIELD_DECL_CHECK (NODE)->decl.u1.a.off_align = exact_log2 ((X) & -(X)))
1329 /* 1 if the alignment for this type was requested by "aligned" attribute,
1330    0 if it is the default for this type.  */
1331 #define DECL_USER_ALIGN(NODE) (DECL_CHECK (NODE)->decl.user_align)
1332 /* Holds the machine mode corresponding to the declaration of a variable or
1333    field.  Always equal to TYPE_MODE (TREE_TYPE (decl)) except for a
1334    FIELD_DECL.  */
1335 #define DECL_MODE(NODE) (DECL_CHECK (NODE)->decl.mode)
1336 /* Holds the RTL expression for the value of a variable or function.  If
1337    PROMOTED_MODE is defined, the mode of this expression may not be same
1338    as DECL_MODE.  In that case, DECL_MODE contains the mode corresponding
1339    to the variable's data type, while the mode
1340    of DECL_RTL is the mode actually used to contain the data.
1341
1342    This value can be evaluated lazily for functions, variables with
1343    static storage duration, and labels.  */
1344 #define DECL_RTL(NODE)                                  \
1345   (DECL_CHECK (NODE)->decl.rtl                          \
1346    ? (NODE)->decl.rtl                                   \
1347    : (make_decl_rtl (NODE, NULL), (NODE)->decl.rtl))
1348 /* Set the DECL_RTL for NODE to RTL.  */
1349 #define SET_DECL_RTL(NODE, RTL) set_decl_rtl (NODE, RTL)
1350 /* Returns nonzero if the DECL_RTL for NODE has already been set.  */
1351 #define DECL_RTL_SET_P(NODE)  (DECL_CHECK (NODE)->decl.rtl != NULL)
1352 /* Copy the RTL from NODE1 to NODE2.  If the RTL was not set for
1353    NODE1, it will not be set for NODE2; this is a lazy copy.  */
1354 #define COPY_DECL_RTL(NODE1, NODE2) \
1355   (DECL_CHECK (NODE2)->decl.rtl = DECL_CHECK (NODE1)->decl.rtl)
1356 /* The DECL_RTL for NODE, if it is set, or NULL, if it is not set.  */
1357 #define DECL_RTL_IF_SET(NODE) (DECL_RTL_SET_P (NODE) ? DECL_RTL (NODE) : NULL)
1358
1359 /* For PARM_DECL, holds an RTL for the stack slot or register
1360    where the data was actually passed.  */
1361 #define DECL_INCOMING_RTL(NODE) (PARM_DECL_CHECK (NODE)->decl.u2.r)
1362
1363 /* For FUNCTION_DECL, if it is inline, holds the saved insn chain.  */
1364 #define DECL_SAVED_INSNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u2.f)
1365
1366 /* For FUNCTION_DECL, if it is built-in,
1367    this identifies which built-in operation it is.  */
1368 #define DECL_FUNCTION_CODE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.u1.f)
1369
1370 /* The DECL_VINDEX is used for FUNCTION_DECLS in two different ways.
1371    Before the struct containing the FUNCTION_DECL is laid out,
1372    DECL_VINDEX may point to a FUNCTION_DECL in a base class which
1373    is the FUNCTION_DECL which this FUNCTION_DECL will replace as a virtual
1374    function.  When the class is laid out, this pointer is changed
1375    to an INTEGER_CST node which is suitable for use as an index
1376    into the virtual function table.  */
1377 #define DECL_VINDEX(NODE) (DECL_CHECK (NODE)->decl.vindex)
1378
1379 /* For FIELD_DECLS, DECL_FCONTEXT is the *first* baseclass in
1380    which this FIELD_DECL is defined.  This information is needed when
1381    writing debugging information about vfield and vbase decls for C++.  */
1382 #define DECL_FCONTEXT(NODE) (FIELD_DECL_CHECK (NODE)->decl.vindex)
1383
1384 /* Every ..._DECL node gets a unique number.  */
1385 #define DECL_UID(NODE) (DECL_CHECK (NODE)->decl.uid)
1386
1387 /* For any sort of a ..._DECL node, this points to the original (abstract)
1388    decl node which this decl is an instance of, or else it is NULL indicating
1389    that this decl is not an instance of some other decl.  For example,
1390    in a nested declaration of an inline function, this points back to the
1391    definition.  */
1392 #define DECL_ABSTRACT_ORIGIN(NODE) (DECL_CHECK (NODE)->decl.abstract_origin)
1393
1394 /* Like DECL_ABSTRACT_ORIGIN, but returns NODE if there's no abstract
1395    origin.  This is useful when setting the DECL_ABSTRACT_ORIGIN.  */
1396 #define DECL_ORIGIN(NODE) \
1397   (DECL_ABSTRACT_ORIGIN (NODE) ? DECL_ABSTRACT_ORIGIN (NODE) : (NODE))
1398
1399 /* Nonzero for any sort of ..._DECL node means this decl node represents an
1400    inline instance of some original (abstract) decl from an inline function;
1401    suppress any warnings about shadowing some other variable.  FUNCTION_DECL
1402    nodes can also have their abstract origin set to themselves.  */
1403 #define DECL_FROM_INLINE(NODE) (DECL_ABSTRACT_ORIGIN (NODE) != NULL_TREE \
1404                                 && DECL_ABSTRACT_ORIGIN (NODE) != (NODE))
1405
1406 /* Nonzero if a _DECL means that the name of this decl should be ignored
1407    for symbolic debug purposes.  */
1408 #define DECL_IGNORED_P(NODE) (DECL_CHECK (NODE)->decl.ignored_flag)
1409
1410 /* Nonzero for a given ..._DECL node means that this node represents an
1411    "abstract instance" of the given declaration (e.g. in the original
1412    declaration of an inline function).  When generating symbolic debugging
1413    information, we mustn't try to generate any address information for nodes
1414    marked as "abstract instances" because we don't actually generate
1415    any code or allocate any data space for such instances.  */
1416 #define DECL_ABSTRACT(NODE) (DECL_CHECK (NODE)->decl.abstract_flag)
1417
1418 /* Nonzero if a _DECL means that no warnings should be generated just
1419    because this decl is unused.  */
1420 #define DECL_IN_SYSTEM_HEADER(NODE) \
1421   (DECL_CHECK (NODE)->decl.in_system_header_flag)
1422
1423 /* Nonzero for a given ..._DECL node means that this node should be
1424    put in .common, if possible.  If a DECL_INITIAL is given, and it
1425    is not error_mark_node, then the decl cannot be put in .common.  */
1426 #define DECL_COMMON(NODE) (DECL_CHECK (NODE)->decl.common_flag)
1427
1428 /* Language-specific decl information.  */
1429 #define DECL_LANG_SPECIFIC(NODE) (DECL_CHECK (NODE)->decl.lang_specific)
1430
1431 /* In a VAR_DECL or FUNCTION_DECL,
1432    nonzero means external reference:
1433    do not allocate storage, and refer to a definition elsewhere.  */
1434 #define DECL_EXTERNAL(NODE) (DECL_CHECK (NODE)->decl.external_flag)
1435
1436 /* In a VAR_DECL for a RECORD_TYPE, sets number for non-init_priority
1437    initializations.  */
1438 #define DEFAULT_INIT_PRIORITY 65535
1439 #define MAX_INIT_PRIORITY 65535
1440 #define MAX_RESERVED_INIT_PRIORITY 100
1441
1442 /* In a TYPE_DECL
1443    nonzero means the detail info about this type is not dumped into stabs.
1444    Instead it will generate cross reference ('x') of names.
1445    This uses the same flag as DECL_EXTERNAL.  */
1446 #define TYPE_DECL_SUPPRESS_DEBUG(NODE) \
1447   (TYPE_DECL_CHECK (NODE)->decl.external_flag)
1448
1449 /* In VAR_DECL and PARM_DECL nodes, nonzero means declared `register'.  */
1450 #define DECL_REGISTER(NODE) (DECL_CHECK (NODE)->decl.regdecl_flag)
1451
1452 /* In LABEL_DECL nodes, nonzero means that an error message about
1453    jumping into such a binding contour has been printed for this label.  */
1454 #define DECL_ERROR_ISSUED(NODE) (LABEL_DECL_CHECK (NODE)->decl.regdecl_flag)
1455
1456 /* In a FIELD_DECL, indicates this field should be bit-packed.  */
1457 #define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl.regdecl_flag)
1458
1459 /* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
1460    static chain is not needed.  */
1461 #define DECL_NO_STATIC_CHAIN(NODE) \
1462   (FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
1463
1464 /* Nonzero in a ..._DECL means this variable is ref'd from a nested function.
1465    For VAR_DECL nodes, PARM_DECL nodes, and FUNCTION_DECL nodes.
1466
1467    For LABEL_DECL nodes, nonzero if nonlocal gotos to the label are permitted.
1468
1469    Also set in some languages for variables, etc., outside the normal
1470    lexical scope, such as class instance variables.  */
1471 #define DECL_NONLOCAL(NODE) (DECL_CHECK (NODE)->decl.nonlocal_flag)
1472
1473 /* Nonzero in a FUNCTION_DECL means this function can be substituted
1474    where it is called.  */
1475 #define DECL_INLINE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inline_flag)
1476
1477 /* Nonzero in a FUNCTION_DECL means this function has been found inlinable
1478    only by virtue of -finline-functions  */
1479 #define DID_INLINE_FUNC(NODE) \
1480   (FUNCTION_DECL_CHECK (NODE)->decl.inlined_function_flag)
1481
1482 /* In a FUNCTION_DECL, nonzero if the function cannot be inlined.  */
1483 #define DECL_UNINLINABLE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.uninlinable)
1484
1485 /* In a VAR_DECL, nonzero if the data should be allocated from
1486    thread-local storage.  */
1487 #define DECL_THREAD_LOCAL(NODE) (VAR_DECL_CHECK (NODE)->decl.thread_local_flag)
1488
1489 /* In a FUNCTION_DECL, the saved representation of the body of the
1490    entire function.  Usually a COMPOUND_STMT, but in C++ this may also
1491    be a RETURN_INIT, CTOR_INITIALIZER, or TRY_BLOCK.  */
1492 #define DECL_SAVED_TREE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.saved_tree)
1493
1494 /* List of FUNCTION_DECLs inlined into this function's body.  */
1495 #define DECL_INLINED_FNS(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.inlined_fns)
1496
1497 /* Nonzero in a FUNCTION_DECL means this function should be treated
1498    as if it were a malloc, meaning it returns a pointer that is
1499    not an alias.  */
1500 #define DECL_IS_MALLOC(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.malloc_flag)
1501
1502 /* Nonzero in a FUNCTION_DECL means this function should be treated
1503    as "pure" function (like const function, but may read global memory).  */
1504 #define DECL_IS_PURE(NODE) (FUNCTION_DECL_CHECK (NODE)->decl.pure_flag)
1505
1506 /* Nonzero in a FIELD_DECL means it is a bit field, and must be accessed
1507    specially.  */
1508 #define DECL_BIT_FIELD(NODE) (FIELD_DECL_CHECK (NODE)->decl.bit_field_flag)
1509
1510 /* In a LABEL_DECL, nonzero means label was defined inside a binding
1511    contour that restored a stack level and which is now exited.  */
1512 #define DECL_TOO_LATE(NODE) (LABEL_DECL_CHECK (NODE)->decl.bit_field_flag)
1513
1514 /* Unused in FUNCTION_DECL.  */
1515
1516 /* In a VAR_DECL that's static,
1517    nonzero if the space is in the text section.  */
1518 #define DECL_IN_TEXT_SECTION(NODE) (VAR_DECL_CHECK (NODE)->decl.bit_field_flag)
1519
1520 /* In a FUNCTION_DECL, nonzero means a built in function.  */
1521 #define DECL_BUILT_IN(NODE) (DECL_BUILT_IN_CLASS (NODE) != NOT_BUILT_IN)
1522
1523 /* For a builtin function, identify which part of the compiler defined it.  */
1524 #define DECL_BUILT_IN_CLASS(NODE) \
1525    (FUNCTION_DECL_CHECK (NODE)->decl.built_in_class)
1526
1527 /* Used in VAR_DECLs to indicate that the variable is a vtable.
1528    Used in FIELD_DECLs for vtable pointers.
1529    Used in FUNCTION_DECLs to indicate that the function is virtual.  */
1530 #define DECL_VIRTUAL_P(NODE) (DECL_CHECK (NODE)->decl.virtual_flag)
1531
1532 /* Used to indicate that the linkage status of this DECL is not yet known,
1533    so it should not be output now.  */
1534 #define DECL_DEFER_OUTPUT(NODE) (DECL_CHECK (NODE)->decl.defer_output)
1535
1536 /* Used in PARM_DECLs whose type are unions to indicate that the
1537    argument should be passed in the same way that the first union
1538    alternative would be passed.  */
1539 #define DECL_TRANSPARENT_UNION(NODE) \
1540   (PARM_DECL_CHECK (NODE)->decl.transparent_union)
1541
1542 /* Used in FUNCTION_DECLs to indicate that they should be run automatically
1543    at the beginning or end of execution.  */
1544 #define DECL_STATIC_CONSTRUCTOR(NODE) \
1545   (FUNCTION_DECL_CHECK (NODE)->decl.static_ctor_flag)
1546
1547 #define DECL_STATIC_DESTRUCTOR(NODE) \
1548 (FUNCTION_DECL_CHECK (NODE)->decl.static_dtor_flag)
1549
1550 /* Used to indicate that this DECL represents a compiler-generated entity.  */
1551 #define DECL_ARTIFICIAL(NODE) (DECL_CHECK (NODE)->decl.artificial_flag)
1552
1553 /* Used to indicate that this DECL has weak linkage.  */
1554 #define DECL_WEAK(NODE) (DECL_CHECK (NODE)->decl.weak_flag)
1555
1556 /* Used in TREE_PUBLIC decls to indicate that copies of this DECL in
1557    multiple translation units should be merged.  */
1558 #define DECL_ONE_ONLY(NODE) (DECL_CHECK (NODE)->decl.transparent_union)
1559
1560 /* Used in a DECL to indicate that, even if it TREE_PUBLIC, it need
1561    not be put out unless it is needed in this translation unit.
1562    Entities like this are shared across translation units (like weak
1563    entities), but are guaranteed to be generated by any translation
1564    unit that needs them, and therefore need not be put out anywhere
1565    where they are not needed.  DECL_COMDAT is just a hint to the
1566    back-end; it is up to front-ends which set this flag to ensure
1567    that there will never be any harm, other than bloat, in putting out
1568    something which is DECL_COMDAT.  */
1569 #define DECL_COMDAT(NODE) (DECL_CHECK (NODE)->decl.comdat_flag)
1570
1571 /* Used in FUNCTION_DECLs to indicate that function entry and exit should
1572    be instrumented with calls to support routines.  */
1573 #define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) \
1574   (FUNCTION_DECL_CHECK (NODE)->decl.no_instrument_function_entry_exit)
1575
1576 /* Used in FUNCTION_DECLs to indicate that limit-stack-* should be
1577    disabled in this function.  */
1578 #define DECL_NO_LIMIT_STACK(NODE) \
1579   (FUNCTION_DECL_CHECK (NODE)->decl.no_limit_stack)
1580
1581 /* Additional flags for language-specific uses.  */
1582 #define DECL_LANG_FLAG_0(NODE) (DECL_CHECK (NODE)->decl.lang_flag_0)
1583 #define DECL_LANG_FLAG_1(NODE) (DECL_CHECK (NODE)->decl.lang_flag_1)
1584 #define DECL_LANG_FLAG_2(NODE) (DECL_CHECK (NODE)->decl.lang_flag_2)
1585 #define DECL_LANG_FLAG_3(NODE) (DECL_CHECK (NODE)->decl.lang_flag_3)
1586 #define DECL_LANG_FLAG_4(NODE) (DECL_CHECK (NODE)->decl.lang_flag_4)
1587 #define DECL_LANG_FLAG_5(NODE) (DECL_CHECK (NODE)->decl.lang_flag_5)
1588 #define DECL_LANG_FLAG_6(NODE) (DECL_CHECK (NODE)->decl.lang_flag_6)
1589 #define DECL_LANG_FLAG_7(NODE) (DECL_CHECK (NODE)->decl.lang_flag_7)
1590
1591 /* Used to indicate that the pointer to this DECL cannot be treated as
1592    an address constant.  */
1593 #define DECL_NON_ADDR_CONST_P(NODE) (DECL_CHECK (NODE)->decl.non_addr_const_p)
1594
1595 /* Used in a FIELD_DECL to indicate that we cannot form the address of
1596    this component.  */
1597 #define DECL_NONADDRESSABLE_P(NODE) \
1598   (FIELD_DECL_CHECK (NODE)->decl.non_addressable)
1599
1600 /* Used to indicate an alias set for the memory pointed to by this
1601    particular FIELD_DECL, PARM_DECL, or VAR_DECL, which must have
1602    pointer (or reference) type.  */
1603 #define DECL_POINTER_ALIAS_SET(NODE) \
1604   (DECL_CHECK (NODE)->decl.pointer_alias_set)
1605
1606 /* Nonzero if an alias set has been assigned to this declaration.  */
1607 #define DECL_POINTER_ALIAS_SET_KNOWN_P(NODE) \
1608   (DECL_POINTER_ALIAS_SET (NODE) != - 1)
1609
1610 struct function;
1611
1612 struct tree_decl GTY(())
1613 {
1614   struct tree_common common;
1615   location_t locus;
1616   unsigned int uid;
1617   tree size;
1618   ENUM_BITFIELD(machine_mode) mode : 8;
1619
1620   unsigned external_flag : 1;
1621   unsigned nonlocal_flag : 1;
1622   unsigned regdecl_flag : 1;
1623   unsigned inline_flag : 1;
1624   unsigned bit_field_flag : 1;
1625   unsigned virtual_flag : 1;
1626   unsigned ignored_flag : 1;
1627   unsigned abstract_flag : 1;
1628
1629   unsigned in_system_header_flag : 1;
1630   unsigned common_flag : 1;
1631   unsigned defer_output : 1;
1632   unsigned transparent_union : 1;
1633   unsigned static_ctor_flag : 1;
1634   unsigned static_dtor_flag : 1;
1635   unsigned artificial_flag : 1;
1636   unsigned weak_flag : 1;
1637
1638   unsigned non_addr_const_p : 1;
1639   unsigned no_instrument_function_entry_exit : 1;
1640   unsigned comdat_flag : 1;
1641   unsigned malloc_flag : 1;
1642   unsigned no_limit_stack : 1;
1643   ENUM_BITFIELD(built_in_class) built_in_class : 2;
1644   unsigned pure_flag : 1;
1645
1646   unsigned non_addressable : 1;
1647   unsigned user_align : 1;
1648   unsigned uninlinable : 1;
1649   unsigned thread_local_flag : 1;
1650   unsigned inlined_function_flag : 1;
1651   unsigned unused : 3;
1652   /* three unused bits.  */
1653
1654   unsigned lang_flag_0 : 1;
1655   unsigned lang_flag_1 : 1;
1656   unsigned lang_flag_2 : 1;
1657   unsigned lang_flag_3 : 1;
1658   unsigned lang_flag_4 : 1;
1659   unsigned lang_flag_5 : 1;
1660   unsigned lang_flag_6 : 1;
1661   unsigned lang_flag_7 : 1;
1662
1663   union tree_decl_u1 {
1664     /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is
1665        DECL_FUNCTION_CODE.  */
1666     enum built_in_function f;
1667     /* In a FUNCTION_DECL for which DECL_BUILT_IN does not hold, this
1668        is used by language-dependent code.  */
1669     HOST_WIDE_INT i;
1670     /* DECL_ALIGN and DECL_OFFSET_ALIGN.  (These are not used for
1671        FUNCTION_DECLs).  */
1672     struct tree_decl_u1_a {
1673       unsigned int align : 24;
1674       unsigned int off_align : 8;
1675     } a;
1676   } GTY ((skip (""))) u1;
1677
1678   tree size_unit;
1679   tree name;
1680   tree context;
1681   tree arguments;       /* Also used for DECL_FIELD_OFFSET */
1682   tree result;  /* Also used for DECL_BIT_FIELD_TYPE */
1683   tree initial; /* Also used for DECL_QUALIFIER */
1684   tree abstract_origin;
1685   tree assembler_name;
1686   tree section_name;
1687   tree attributes;
1688   rtx rtl;      /* RTL representation for object.  */
1689
1690   /* In FUNCTION_DECL, if it is inline, holds the saved insn chain.
1691      In FIELD_DECL, is DECL_FIELD_BIT_OFFSET.
1692      In PARM_DECL, holds an RTL for the stack slot
1693      of register where the data was actually passed.
1694      Used by Chill and Java in LABEL_DECL and by C++ and Java in VAR_DECL.  */
1695   union tree_decl_u2 {
1696     struct function * GTY ((tag ("FUNCTION_DECL"))) f;
1697     rtx GTY ((tag ("PARM_DECL"))) r;
1698     tree GTY ((tag ("FIELD_DECL"))) t;
1699     int GTY ((tag ("VAR_DECL"))) i;
1700   } GTY ((desc ("TREE_CODE((tree) &(%0))"))) u2;
1701
1702   /* In a FUNCTION_DECL, this is DECL_SAVED_TREE.  */
1703   tree saved_tree;
1704
1705   /* In a FUNCTION_DECL, these are function data which is to be kept
1706      as long as FUNCTION_DECL is kept.  */
1707   tree inlined_fns;
1708
1709   tree vindex;
1710   HOST_WIDE_INT pointer_alias_set;
1711   /* Points to a structure whose details depend on the language in use.  */
1712   struct lang_decl *lang_specific;
1713 };
1714 \f
1715 enum tree_node_structure_enum {
1716   TS_COMMON,
1717   TS_INT_CST,
1718   TS_REAL_CST,
1719   TS_VECTOR,
1720   TS_STRING,
1721   TS_COMPLEX,
1722   TS_IDENTIFIER,
1723   TS_DECL,
1724   TS_TYPE,
1725   TS_LIST,
1726   TS_VEC,
1727   TS_EXP,
1728   TS_BLOCK,
1729   LAST_TS_ENUM
1730 };
1731
1732 /* Define the overall contents of a tree node.
1733    It may be any of the structures declared above
1734    for various types of node.  */
1735
1736 union tree_node GTY ((ptr_alias (union lang_tree_node),
1737                       desc ("tree_node_structure (&%h)")))
1738 {
1739   struct tree_common GTY ((tag ("TS_COMMON"))) common;
1740   struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst;
1741   struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst;
1742   struct tree_vector GTY ((tag ("TS_VECTOR"))) vector;
1743   struct tree_string GTY ((tag ("TS_STRING"))) string;
1744   struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex;
1745   struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier;
1746   struct tree_decl GTY ((tag ("TS_DECL"))) decl;
1747   struct tree_type GTY ((tag ("TS_TYPE"))) type;
1748   struct tree_list GTY ((tag ("TS_LIST"))) list;
1749   struct tree_vec GTY ((tag ("TS_VEC"))) vec;
1750   struct tree_exp GTY ((tag ("TS_EXP"))) exp;
1751   struct tree_block GTY ((tag ("TS_BLOCK"))) block;
1752  };
1753 \f
1754 /* Standard named or nameless data types of the C compiler.  */
1755
1756 enum tree_index
1757 {
1758   TI_ERROR_MARK,
1759   TI_INTQI_TYPE,
1760   TI_INTHI_TYPE,
1761   TI_INTSI_TYPE,
1762   TI_INTDI_TYPE,
1763   TI_INTTI_TYPE,
1764
1765   TI_UINTQI_TYPE,
1766   TI_UINTHI_TYPE,
1767   TI_UINTSI_TYPE,
1768   TI_UINTDI_TYPE,
1769   TI_UINTTI_TYPE,
1770
1771   TI_INTEGER_ZERO,
1772   TI_INTEGER_ONE,
1773   TI_INTEGER_MINUS_ONE,
1774   TI_NULL_POINTER,
1775
1776   TI_SIZE_ZERO,
1777   TI_SIZE_ONE,
1778
1779   TI_BITSIZE_ZERO,
1780   TI_BITSIZE_ONE,
1781   TI_BITSIZE_UNIT,
1782
1783   TI_COMPLEX_INTEGER_TYPE,
1784   TI_COMPLEX_FLOAT_TYPE,
1785   TI_COMPLEX_DOUBLE_TYPE,
1786   TI_COMPLEX_LONG_DOUBLE_TYPE,
1787
1788   TI_FLOAT_TYPE,
1789   TI_DOUBLE_TYPE,
1790   TI_LONG_DOUBLE_TYPE,
1791
1792   TI_VOID_TYPE,
1793   TI_PTR_TYPE,
1794   TI_CONST_PTR_TYPE,
1795   TI_SIZE_TYPE,
1796   TI_PTRDIFF_TYPE,
1797   TI_VA_LIST_TYPE,
1798
1799   TI_VOID_LIST_NODE,
1800
1801   TI_UV4SF_TYPE,
1802   TI_UV4SI_TYPE,
1803   TI_UV8HI_TYPE,
1804   TI_UV8QI_TYPE,
1805   TI_UV4HI_TYPE,
1806   TI_UV2HI_TYPE,
1807   TI_UV2SI_TYPE,
1808   TI_UV2SF_TYPE,
1809   TI_UV2DI_TYPE,
1810   TI_UV1DI_TYPE,
1811   TI_UV16QI_TYPE,
1812
1813   TI_V4SF_TYPE,
1814   TI_V16SF_TYPE,
1815   TI_V4SI_TYPE,
1816   TI_V8HI_TYPE,
1817   TI_V8QI_TYPE,
1818   TI_V4HI_TYPE,
1819   TI_V2HI_TYPE,
1820   TI_V2SI_TYPE,
1821   TI_V2SF_TYPE,
1822   TI_V2DF_TYPE,
1823   TI_V2DI_TYPE,
1824   TI_V1DI_TYPE,
1825   TI_V16QI_TYPE,
1826
1827   TI_MAIN_IDENTIFIER,
1828
1829   TI_MAX
1830 };
1831
1832 extern GTY(()) tree global_trees[TI_MAX];
1833
1834 #define error_mark_node                 global_trees[TI_ERROR_MARK]
1835
1836 #define intQI_type_node                 global_trees[TI_INTQI_TYPE]
1837 #define intHI_type_node                 global_trees[TI_INTHI_TYPE]
1838 #define intSI_type_node                 global_trees[TI_INTSI_TYPE]
1839 #define intDI_type_node                 global_trees[TI_INTDI_TYPE]
1840 #define intTI_type_node                 global_trees[TI_INTTI_TYPE]
1841
1842 #define unsigned_intQI_type_node        global_trees[TI_UINTQI_TYPE]
1843 #define unsigned_intHI_type_node        global_trees[TI_UINTHI_TYPE]
1844 #define unsigned_intSI_type_node        global_trees[TI_UINTSI_TYPE]
1845 #define unsigned_intDI_type_node        global_trees[TI_UINTDI_TYPE]
1846 #define unsigned_intTI_type_node        global_trees[TI_UINTTI_TYPE]
1847
1848 #define integer_zero_node               global_trees[TI_INTEGER_ZERO]
1849 #define integer_one_node                global_trees[TI_INTEGER_ONE]
1850 #define integer_minus_one_node          global_trees[TI_INTEGER_MINUS_ONE]
1851 #define size_zero_node                  global_trees[TI_SIZE_ZERO]
1852 #define size_one_node                   global_trees[TI_SIZE_ONE]
1853 #define bitsize_zero_node               global_trees[TI_BITSIZE_ZERO]
1854 #define bitsize_one_node                global_trees[TI_BITSIZE_ONE]
1855 #define bitsize_unit_node               global_trees[TI_BITSIZE_UNIT]
1856
1857 /* Base access nodes.  */
1858 #define access_public_node              NULL_TREE
1859 #define access_protected_node           size_zero_node
1860 #define access_private_node             size_one_node
1861
1862 #define null_pointer_node               global_trees[TI_NULL_POINTER]
1863
1864 #define float_type_node                 global_trees[TI_FLOAT_TYPE]
1865 #define double_type_node                global_trees[TI_DOUBLE_TYPE]
1866 #define long_double_type_node           global_trees[TI_LONG_DOUBLE_TYPE]
1867
1868 #define complex_integer_type_node       global_trees[TI_COMPLEX_INTEGER_TYPE]
1869 #define complex_float_type_node         global_trees[TI_COMPLEX_FLOAT_TYPE]
1870 #define complex_double_type_node        global_trees[TI_COMPLEX_DOUBLE_TYPE]
1871 #define complex_long_double_type_node   global_trees[TI_COMPLEX_LONG_DOUBLE_TYPE]
1872
1873 #define void_type_node                  global_trees[TI_VOID_TYPE]
1874 /* The C type `void *'.  */
1875 #define ptr_type_node                   global_trees[TI_PTR_TYPE]
1876 /* The C type `const void *'.  */
1877 #define const_ptr_type_node             global_trees[TI_CONST_PTR_TYPE]
1878 /* The C type `size_t'.  */
1879 #define size_type_node                  global_trees[TI_SIZE_TYPE]
1880 #define ptrdiff_type_node               global_trees[TI_PTRDIFF_TYPE]
1881 #define va_list_type_node               global_trees[TI_VA_LIST_TYPE]
1882
1883 /* The node that should be placed at the end of a parameter list to
1884    indicate that the function does not take a variable number of
1885    arguments.  The TREE_VALUE will be void_type_node and there will be
1886    no TREE_CHAIN.  Language-independent code should not assume
1887    anything else about this node.  */
1888 #define void_list_node                  global_trees[TI_VOID_LIST_NODE]
1889
1890 #define main_identifier_node            global_trees[TI_MAIN_IDENTIFIER]
1891 #define MAIN_NAME_P(NODE) (IDENTIFIER_NODE_CHECK (NODE) == main_identifier_node)
1892
1893 #define unsigned_V16QI_type_node        global_trees[TI_UV16QI_TYPE]
1894 #define unsigned_V4SI_type_node         global_trees[TI_UV4SI_TYPE]
1895 #define unsigned_V8QI_type_node         global_trees[TI_UV8QI_TYPE]
1896 #define unsigned_V8HI_type_node         global_trees[TI_UV8HI_TYPE]
1897 #define unsigned_V4HI_type_node         global_trees[TI_UV4HI_TYPE]
1898 #define unsigned_V2HI_type_node         global_trees[TI_UV2HI_TYPE]
1899 #define unsigned_V2SI_type_node         global_trees[TI_UV2SI_TYPE]
1900 #define unsigned_V2DI_type_node         global_trees[TI_UV2DI_TYPE]
1901 #define unsigned_V1DI_type_node         global_trees[TI_UV1DI_TYPE]
1902
1903 #define V16QI_type_node                 global_trees[TI_V16QI_TYPE]
1904 #define V4SF_type_node                  global_trees[TI_V4SF_TYPE]
1905 #define V4SI_type_node                  global_trees[TI_V4SI_TYPE]
1906 #define V8QI_type_node                  global_trees[TI_V8QI_TYPE]
1907 #define V8HI_type_node                  global_trees[TI_V8HI_TYPE]
1908 #define V4HI_type_node                  global_trees[TI_V4HI_TYPE]
1909 #define V2HI_type_node                  global_trees[TI_V2HI_TYPE]
1910 #define V2SI_type_node                  global_trees[TI_V2SI_TYPE]
1911 #define V2SF_type_node                  global_trees[TI_V2SF_TYPE]
1912 #define V2DI_type_node                  global_trees[TI_V2DI_TYPE]
1913 #define V2DF_type_node                  global_trees[TI_V2DF_TYPE]
1914 #define V16SF_type_node                 global_trees[TI_V16SF_TYPE]
1915 #define V1DI_type_node                  global_trees[TI_V1DI_TYPE]
1916
1917 /* An enumeration of the standard C integer types.  These must be
1918    ordered so that shorter types appear before longer ones, and so
1919    that signed types appear before unsigned ones, for the correct
1920    functioning of interpret_integer() in c-lex.c.  */
1921 enum integer_type_kind
1922 {
1923   itk_char,
1924   itk_signed_char,
1925   itk_unsigned_char,
1926   itk_short,
1927   itk_unsigned_short,
1928   itk_int,
1929   itk_unsigned_int,
1930   itk_long,
1931   itk_unsigned_long,
1932   itk_long_long,
1933   itk_unsigned_long_long,
1934   itk_none
1935 };
1936
1937 typedef enum integer_type_kind integer_type_kind;
1938
1939 /* The standard C integer types.  Use integer_type_kind to index into
1940    this array.  */
1941 extern GTY(()) tree integer_types[itk_none];
1942
1943 #define char_type_node                  integer_types[itk_char]
1944 #define signed_char_type_node           integer_types[itk_signed_char]
1945 #define unsigned_char_type_node         integer_types[itk_unsigned_char]
1946 #define short_integer_type_node         integer_types[itk_short]
1947 #define short_unsigned_type_node        integer_types[itk_unsigned_short]
1948 #define integer_type_node               integer_types[itk_int]
1949 #define unsigned_type_node              integer_types[itk_unsigned_int]
1950 #define long_integer_type_node          integer_types[itk_long]
1951 #define long_unsigned_type_node         integer_types[itk_unsigned_long]
1952 #define long_long_integer_type_node     integer_types[itk_long_long]
1953 #define long_long_unsigned_type_node    integer_types[itk_unsigned_long_long]
1954 \f
1955 /* Set to the default thread-local storage (tls) model to use.  */
1956
1957 enum tls_model {
1958   TLS_MODEL_GLOBAL_DYNAMIC = 1,
1959   TLS_MODEL_LOCAL_DYNAMIC,
1960   TLS_MODEL_INITIAL_EXEC,
1961   TLS_MODEL_LOCAL_EXEC
1962 };
1963
1964 extern enum tls_model flag_tls_default;
1965
1966 /* Enumerate visibility settings.  */
1967
1968 enum symbol_visibility
1969 {
1970   VISIBILITY_DEFAULT,
1971   VISIBILITY_INTERNAL,
1972   VISIBILITY_HIDDEN,
1973   VISIBILITY_PROTECTED
1974 };
1975 \f
1976 /* A pointer-to-function member type looks like:
1977
1978      struct {
1979        __P __pfn;
1980        ptrdiff_t __delta;
1981      };
1982
1983    If __pfn is NULL, it is a NULL pointer-to-member-function.
1984
1985    (Because the vtable is always the first thing in the object, we
1986    don't need its offset.)  If the function is virtual, then PFN is
1987    one plus twice the index into the vtable; otherwise, it is just a
1988    pointer to the function.
1989
1990    Unfortunately, using the lowest bit of PFN doesn't work in
1991    architectures that don't impose alignment requirements on function
1992    addresses, or that use the lowest bit to tell one ISA from another,
1993    for example.  For such architectures, we use the lowest bit of
1994    DELTA instead of the lowest bit of the PFN, and DELTA will be
1995    multiplied by 2.  */
1996
1997 enum ptrmemfunc_vbit_where_t
1998 {
1999   ptrmemfunc_vbit_in_pfn,
2000   ptrmemfunc_vbit_in_delta
2001 };
2002 \f
2003 #define NULL_TREE (tree) NULL
2004
2005 /* Approximate positive square root of a host double.  This is for
2006    statistical reports, not code generation.  */
2007 extern double approx_sqrt               PARAMS ((double));
2008
2009 extern tree decl_assembler_name         PARAMS ((tree));
2010
2011 /* Compute the number of bytes occupied by 'node'.  This routine only
2012    looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.  */
2013
2014 extern size_t tree_size                 PARAMS ((tree));
2015
2016 /* Lowest level primitive for allocating a node.
2017    The TREE_CODE is the only argument.  Contents are initialized
2018    to zero except for a few of the common fields.  */
2019
2020 extern tree make_node                   PARAMS ((enum tree_code));
2021
2022 /* Make a copy of a node, with all the same contents.  */
2023
2024 extern tree copy_node                   PARAMS ((tree));
2025
2026 /* Make a copy of a chain of TREE_LIST nodes.  */
2027
2028 extern tree copy_list                   PARAMS ((tree));
2029
2030 /* Make a TREE_VEC.  */
2031
2032 extern tree make_tree_vec               PARAMS ((int));
2033
2034 /* Return the (unique) IDENTIFIER_NODE node for a given name.
2035    The name is supplied as a char *.  */
2036
2037 extern tree get_identifier              PARAMS ((const char *));
2038
2039 /* Identical to get_identifier, except that the length is assumed
2040    known.  */
2041
2042 extern tree get_identifier_with_length  PARAMS ((const char *, unsigned int));
2043
2044 /* If an identifier with the name TEXT (a null-terminated string) has
2045    previously been referred to, return that node; otherwise return
2046    NULL_TREE.  */
2047
2048 extern tree maybe_get_identifier        PARAMS ((const char *));
2049
2050 /* Construct various types of nodes.  */
2051
2052 #define build_int_2(LO, HI)  \
2053   build_int_2_wide ((unsigned HOST_WIDE_INT) (LO), (HOST_WIDE_INT) (HI))
2054
2055 extern tree build                       PARAMS ((enum tree_code, tree, ...));
2056 extern tree build_nt                    PARAMS ((enum tree_code, ...));
2057
2058 extern tree build_int_2_wide            PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT));
2059 extern tree build_vector                PARAMS ((tree, tree));
2060 extern tree build_constructor           PARAMS ((tree, tree));
2061 extern tree build_real_from_int_cst     PARAMS ((tree, tree));
2062 extern tree build_complex               PARAMS ((tree, tree, tree));
2063 extern tree build_string                PARAMS ((int, const char *));
2064 extern tree build1                      PARAMS ((enum tree_code, tree, tree));
2065 extern tree build_tree_list             PARAMS ((tree, tree));
2066 extern tree build_decl                  PARAMS ((enum tree_code, tree, tree));
2067 extern tree build_block                 PARAMS ((tree, tree, tree, tree, tree));
2068 extern tree build_expr_wfl              PARAMS ((tree, const char *, int, int));
2069
2070 /* Construct various nodes representing data types.  */
2071
2072 extern tree make_signed_type            PARAMS ((int));
2073 extern tree make_unsigned_type          PARAMS ((int));
2074 extern void initialize_sizetypes        PARAMS ((void));
2075 extern void set_sizetype                PARAMS ((tree));
2076 extern void fixup_unsigned_type         PARAMS ((tree));
2077 extern tree build_pointer_type_for_mode PARAMS ((tree, enum machine_mode));
2078 extern tree build_pointer_type          PARAMS ((tree));
2079 extern tree build_reference_type_for_mode PARAMS ((tree, enum machine_mode));
2080 extern tree build_reference_type        PARAMS ((tree));
2081 extern tree build_type_no_quals         PARAMS ((tree));
2082 extern tree build_index_type            PARAMS ((tree));
2083 extern tree build_index_2_type          PARAMS ((tree, tree));
2084 extern tree build_array_type            PARAMS ((tree, tree));
2085 extern tree build_function_type         PARAMS ((tree, tree));
2086 extern tree build_function_type_list    PARAMS ((tree, ...));
2087 extern tree build_method_type           PARAMS ((tree, tree));
2088 extern tree build_offset_type           PARAMS ((tree, tree));
2089 extern tree build_complex_type          PARAMS ((tree));
2090 extern tree array_type_nelts            PARAMS ((tree));
2091
2092 extern tree value_member                PARAMS ((tree, tree));
2093 extern tree purpose_member              PARAMS ((tree, tree));
2094 extern tree binfo_member                PARAMS ((tree, tree));
2095 extern unsigned int attribute_hash_list PARAMS ((tree));
2096 extern int attribute_list_equal         PARAMS ((tree, tree));
2097 extern int attribute_list_contained     PARAMS ((tree, tree));
2098 extern int tree_int_cst_equal           PARAMS ((tree, tree));
2099 extern int tree_int_cst_lt              PARAMS ((tree, tree));
2100 extern int tree_int_cst_compare         PARAMS ((tree, tree));
2101 extern int host_integerp                PARAMS ((tree, int));
2102 extern HOST_WIDE_INT tree_low_cst       PARAMS ((tree, int));
2103 extern int tree_int_cst_msb             PARAMS ((tree));
2104 extern int tree_int_cst_sgn             PARAMS ((tree));
2105 extern int tree_expr_nonnegative_p      PARAMS ((tree));
2106 extern int rtl_expr_nonnegative_p       PARAMS ((rtx));
2107 extern tree get_inner_array_type        PARAMS ((tree));
2108
2109 /* From expmed.c.  Since rtl.h is included after tree.h, we can't
2110    put the prototype here.  Rtl.h does declare the prototype if
2111    tree.h had been included.  */
2112
2113 extern tree make_tree                   PARAMS ((tree, rtx));
2114 \f
2115 /* Return a type like TTYPE except that its TYPE_ATTRIBUTES
2116    is ATTRIBUTE.
2117
2118    Such modified types already made are recorded so that duplicates
2119    are not made.  */
2120
2121 extern tree build_type_attribute_variant PARAMS ((tree, tree));
2122 extern tree build_decl_attribute_variant PARAMS ((tree, tree));
2123
2124 /* Structure describing an attribute and a function to handle it.  */
2125 struct attribute_spec
2126 {
2127   /* The name of the attribute (without any leading or trailing __),
2128      or NULL to mark the end of a table of attributes.  */
2129   const char *const name;
2130   /* The minimum length of the list of arguments of the attribute.  */
2131   const int min_length;
2132   /* The maximum length of the list of arguments of the attribute
2133      (-1 for no maximum).  */
2134   const int max_length;
2135   /* Whether this attribute requires a DECL.  If it does, it will be passed
2136      from types of DECLs, function return types and array element types to
2137      the DECLs, function types and array types respectively; but when
2138      applied to a type in any other circumstances, it will be ignored with
2139      a warning.  (If greater control is desired for a given attribute,
2140      this should be false, and the flags argument to the handler may be
2141      used to gain greater control in that case.)  */
2142   const bool decl_required;
2143   /* Whether this attribute requires a type.  If it does, it will be passed
2144      from a DECL to the type of that DECL.  */
2145   const bool type_required;
2146   /* Whether this attribute requires a function (or method) type.  If it does,
2147      it will be passed from a function pointer type to the target type,
2148      and from a function return type (which is not itself a function
2149      pointer type) to the function type.  */
2150   const bool function_type_required;
2151   /* Function to handle this attribute.  NODE points to the node to which
2152      the attribute is to be applied.  If a DECL, it should be modified in
2153      place; if a TYPE, a copy should be created.  NAME is the name of the
2154      attribute (possibly with leading or trailing __).  ARGS is the TREE_LIST
2155      of the arguments (which may be NULL).  FLAGS gives further information
2156      about the context of the attribute.  Afterwards, the attributes will
2157      be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as appropriate,
2158      unless *NO_ADD_ATTRS is set to true (which should be done on error,
2159      as well as in any other cases when the attributes should not be added
2160      to the DECL or TYPE).  Depending on FLAGS, any attributes to be
2161      applied to another type or DECL later may be returned;
2162      otherwise the return value should be NULL_TREE.  This pointer may be
2163      NULL if no special handling is required beyond the checks implied
2164      by the rest of this structure.  */
2165   tree (*const handler) PARAMS ((tree *node, tree name, tree args,
2166                                  int flags, bool *no_add_attrs));
2167 };
2168
2169 /* Flags that may be passed in the third argument of decl_attributes, and
2170    to handler functions for attributes.  */
2171 enum attribute_flags
2172 {
2173   /* The type passed in is the type of a DECL, and any attributes that
2174      should be passed in again to be applied to the DECL rather than the
2175      type should be returned.  */
2176   ATTR_FLAG_DECL_NEXT = 1,
2177   /* The type passed in is a function return type, and any attributes that
2178      should be passed in again to be applied to the function type rather
2179      than the return type should be returned.  */
2180   ATTR_FLAG_FUNCTION_NEXT = 2,
2181   /* The type passed in is an array element type, and any attributes that
2182      should be passed in again to be applied to the array type rather
2183      than the element type should be returned.  */
2184   ATTR_FLAG_ARRAY_NEXT = 4,
2185   /* The type passed in is a structure, union or enumeration type being
2186      created, and should be modified in place.  */
2187   ATTR_FLAG_TYPE_IN_PLACE = 8,
2188   /* The attributes are being applied by default to a library function whose
2189      name indicates known behavior, and should be silently ignored if they
2190      are not in fact compatible with the function type.  */
2191   ATTR_FLAG_BUILT_IN = 16
2192 };
2193
2194 /* Default versions of target-overridable functions.  */
2195
2196 extern tree merge_decl_attributes PARAMS ((tree, tree));
2197 extern tree merge_type_attributes PARAMS ((tree, tree));
2198 extern void default_register_cpp_builtins PARAMS ((struct cpp_reader *));
2199
2200 /* Split a list of declspecs and attributes into two.  */
2201
2202 extern void split_specs_attrs           PARAMS ((tree, tree *, tree *));
2203
2204 /* Strip attributes from a list of combined specs and attrs.  */
2205
2206 extern tree strip_attrs                 PARAMS ((tree));
2207
2208 /* Return 1 if an attribute and its arguments are valid for a decl or type.  */
2209
2210 extern int valid_machine_attribute      PARAMS ((tree, tree, tree, tree));
2211
2212 /* Given a tree node and a string, return nonzero if the tree node is
2213    a valid attribute name for the string.  */
2214
2215 extern int is_attribute_p               PARAMS ((const char *, tree));
2216
2217 /* Given an attribute name and a list of attributes, return the list element
2218    of the attribute or NULL_TREE if not found.  */
2219
2220 extern tree lookup_attribute            PARAMS ((const char *, tree));
2221
2222 /* Given two attributes lists, return a list of their union.  */
2223
2224 extern tree merge_attributes            PARAMS ((tree, tree));
2225
2226 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
2227 /* Given two Windows decl attributes lists, possibly including
2228    dllimport, return a list of their union .  */
2229 extern tree merge_dllimport_decl_attributes PARAMS ((tree, tree));
2230 #endif
2231
2232 /* Return a version of the TYPE, qualified as indicated by the
2233    TYPE_QUALS, if one exists.  If no qualified version exists yet,
2234    return NULL_TREE.  */
2235
2236 extern tree get_qualified_type          PARAMS ((tree, int));
2237
2238 /* Like get_qualified_type, but creates the type if it does not
2239    exist.  This function never returns NULL_TREE.  */
2240
2241 extern tree build_qualified_type        PARAMS ((tree, int));
2242
2243 /* Like build_qualified_type, but only deals with the `const' and
2244    `volatile' qualifiers.  This interface is retained for backwards
2245    compatibility with the various front-ends; new code should use
2246    build_qualified_type instead.  */
2247
2248 #define build_type_variant(TYPE, CONST_P, VOLATILE_P)                   \
2249   build_qualified_type ((TYPE),                                         \
2250                         ((CONST_P) ? TYPE_QUAL_CONST : 0)               \
2251                         | ((VOLATILE_P) ? TYPE_QUAL_VOLATILE : 0))
2252
2253 /* Make a copy of a type node.  */
2254
2255 extern tree build_type_copy             PARAMS ((tree));
2256
2257 /* Finish up a builtin RECORD_TYPE. Give it a name and provide its
2258    fields. Optionally specify an alignment, and then lsy it out.  */
2259
2260 extern void finish_builtin_struct               PARAMS ((tree, const char *,
2261                                                          tree, tree));
2262
2263 /* Given a ..._TYPE node, calculate the TYPE_SIZE, TYPE_SIZE_UNIT,
2264    TYPE_ALIGN and TYPE_MODE fields.  If called more than once on one
2265    node, does nothing except for the first time.  */
2266
2267 extern void layout_type                 PARAMS ((tree));
2268
2269 /* These functions allow a front-end to perform a manual layout of a
2270    RECORD_TYPE.  (For instance, if the placement of subsequent fields
2271    depends on the placement of fields so far.)  Begin by calling
2272    start_record_layout.  Then, call place_field for each of the
2273    fields.  Then, call finish_record_layout.  See layout_type for the
2274    default way in which these functions are used.  */
2275
2276 typedef struct record_layout_info_s
2277 {
2278   /* The RECORD_TYPE that we are laying out.  */
2279   tree t;
2280   /* The offset into the record so far, in bytes, not including bits in
2281      BITPOS.  */
2282   tree offset;
2283   /* The last known alignment of SIZE.  */
2284   unsigned int offset_align;
2285   /* The bit position within the last OFFSET_ALIGN bits, in bits.  */
2286   tree bitpos;
2287   /* The alignment of the record so far, in bits.  */
2288   unsigned int record_align;
2289   /* The alignment of the record so far, ignoring #pragma pack and
2290      __attribute__ ((packed)), in bits.  */
2291   unsigned int unpacked_align;
2292   /* The previous field layed out.  */
2293   tree prev_field;
2294   /* The static variables (i.e., class variables, as opposed to
2295      instance variables) encountered in T.  */
2296   tree pending_statics;
2297   /* Bits remaining in the current alignment group */
2298   int remaining_in_alignment;
2299   /* True if we've seen a packed field that didn't have normal
2300      alignment anyway.  */
2301   int packed_maybe_necessary;
2302 } *record_layout_info;
2303
2304 extern void set_lang_adjust_rli         PARAMS ((void (*) PARAMS
2305                                                  ((record_layout_info))));
2306 extern record_layout_info start_record_layout PARAMS ((tree));
2307 extern tree bit_from_pos                PARAMS ((tree, tree));
2308 extern tree byte_from_pos               PARAMS ((tree, tree));
2309 extern void pos_from_bit                PARAMS ((tree *, tree *, unsigned int,
2310                                                  tree));
2311 extern void normalize_offset            PARAMS ((tree *, tree *,
2312                                                  unsigned int));
2313 extern tree rli_size_unit_so_far        PARAMS ((record_layout_info));
2314 extern tree rli_size_so_far             PARAMS ((record_layout_info));
2315 extern void normalize_rli               PARAMS ((record_layout_info));
2316 extern void place_field                 PARAMS ((record_layout_info, tree));
2317 extern void compute_record_mode         PARAMS ((tree));
2318 extern void finish_record_layout        PARAMS ((record_layout_info, int));
2319
2320 /* Given a hashcode and a ..._TYPE node (for which the hashcode was made),
2321    return a canonicalized ..._TYPE node, so that duplicates are not made.
2322    How the hash code is computed is up to the caller, as long as any two
2323    callers that could hash identical-looking type nodes agree.  */
2324
2325 extern tree type_hash_canon             PARAMS ((unsigned int, tree));
2326
2327 /* Given a VAR_DECL, PARM_DECL, RESULT_DECL or FIELD_DECL node,
2328    calculates the DECL_SIZE, DECL_SIZE_UNIT, DECL_ALIGN and DECL_MODE
2329    fields.  Call this only once for any given decl node.
2330
2331    Second argument is the boundary that this field can be assumed to
2332    be starting at (in bits).  Zero means it can be assumed aligned
2333    on any boundary that may be needed.  */
2334
2335 extern void layout_decl                 PARAMS ((tree, unsigned));
2336
2337 /* Return the mode for data of a given size SIZE and mode class CLASS.
2338    If LIMIT is nonzero, then don't use modes bigger than MAX_FIXED_MODE_SIZE.
2339    The value is BLKmode if no other mode is found.  This is like
2340    mode_for_size, but is passed a tree.  */
2341
2342 extern enum machine_mode mode_for_size_tree PARAMS ((tree, enum mode_class,
2343                                                      int));
2344
2345 /* Return an expr equal to X but certainly not valid as an lvalue.  */
2346
2347 extern tree non_lvalue                  PARAMS ((tree));
2348 extern tree pedantic_non_lvalue         PARAMS ((tree));
2349
2350 extern tree convert                     PARAMS ((tree, tree));
2351 extern unsigned int expr_align          PARAMS ((tree));
2352 extern tree expr_first                  PARAMS ((tree));
2353 extern tree expr_last                   PARAMS ((tree));
2354 extern int expr_length                  PARAMS ((tree));
2355 extern tree size_in_bytes               PARAMS ((tree));
2356 extern HOST_WIDE_INT int_size_in_bytes  PARAMS ((tree));
2357 extern tree bit_position                PARAMS ((tree));
2358 extern HOST_WIDE_INT int_bit_position   PARAMS ((tree));
2359 extern tree byte_position               PARAMS ((tree));
2360 extern HOST_WIDE_INT int_byte_position  PARAMS ((tree));
2361
2362 /* Define data structures, macros, and functions for handling sizes
2363    and the various types used to represent sizes.  */
2364
2365 enum size_type_kind
2366 {
2367   SIZETYPE,             /* Normal representation of sizes in bytes.  */
2368   SSIZETYPE,            /* Signed representation of sizes in bytes.  */
2369   USIZETYPE,            /* Unsigned representation of sizes in bytes.  */
2370   BITSIZETYPE,          /* Normal representation of sizes in bits.  */
2371   SBITSIZETYPE,         /* Signed representation of sizes in bits.  */
2372   UBITSIZETYPE,         /* Unsifgned representation of sizes in bits.  */
2373   TYPE_KIND_LAST};
2374
2375 extern GTY(()) tree sizetype_tab[(int) TYPE_KIND_LAST];
2376
2377 #define sizetype sizetype_tab[(int) SIZETYPE]
2378 #define bitsizetype sizetype_tab[(int) BITSIZETYPE]
2379 #define ssizetype sizetype_tab[(int) SSIZETYPE]
2380 #define usizetype sizetype_tab[(int) USIZETYPE]
2381 #define sbitsizetype sizetype_tab[(int) SBITSIZETYPE]
2382 #define ubitsizetype sizetype_tab[(int) UBITSIZETYPE]
2383
2384 extern tree size_binop                  PARAMS ((enum tree_code, tree, tree));
2385 extern tree size_diffop                 PARAMS ((tree, tree));
2386 extern tree size_int_wide               PARAMS ((HOST_WIDE_INT,
2387                                                  enum size_type_kind));
2388 extern tree size_int_type_wide          PARAMS ((HOST_WIDE_INT, tree));
2389
2390 #define size_int_type(L, T) size_int_type_wide ((HOST_WIDE_INT) (L), T)
2391 #define size_int(L) size_int_wide ((HOST_WIDE_INT) (L), SIZETYPE)
2392 #define ssize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SSIZETYPE)
2393 #define bitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), BITSIZETYPE)
2394 #define sbitsize_int(L) size_int_wide ((HOST_WIDE_INT) (L), SBITSIZETYPE)
2395
2396 extern tree round_up                    PARAMS ((tree, int));
2397 extern tree round_down                  PARAMS ((tree, int));
2398 extern tree get_pending_sizes           PARAMS ((void));
2399 extern int is_pending_size              PARAMS ((tree));
2400 extern void put_pending_size            PARAMS ((tree));
2401 extern void put_pending_sizes           PARAMS ((tree));
2402
2403 /* Type for sizes of data-type.  */
2404
2405 #define BITS_PER_UNIT_LOG \
2406   ((BITS_PER_UNIT > 1) + (BITS_PER_UNIT > 2) + (BITS_PER_UNIT > 4) \
2407    + (BITS_PER_UNIT > 8) + (BITS_PER_UNIT > 16) + (BITS_PER_UNIT > 32) \
2408    + (BITS_PER_UNIT > 64) + (BITS_PER_UNIT > 128) + (BITS_PER_UNIT > 256))
2409
2410 /* If nonzero, an upper limit on alignment of structure fields, in bits.  */
2411 extern unsigned int maximum_field_alignment;
2412
2413 /* If nonzero, the alignment of a bitstring or (power-)set value, in bits.  */
2414 extern unsigned int set_alignment;
2415
2416 /* Concatenate two lists (chains of TREE_LIST nodes) X and Y
2417    by making the last node in X point to Y.
2418    Returns X, except if X is 0 returns Y.  */
2419
2420 extern tree chainon                     PARAMS ((tree, tree));
2421
2422 /* Make a new TREE_LIST node from specified PURPOSE, VALUE and CHAIN.  */
2423
2424 extern tree tree_cons                   PARAMS ((tree, tree, tree));
2425
2426 /* Return the last tree node in a chain.  */
2427
2428 extern tree tree_last                   PARAMS ((tree));
2429
2430 /* Reverse the order of elements in a chain, and return the new head.  */
2431
2432 extern tree nreverse                    PARAMS ((tree));
2433
2434 /* Returns the length of a chain of nodes
2435    (number of chain pointers to follow before reaching a null pointer).  */
2436
2437 extern int list_length                  PARAMS ((tree));
2438
2439 /* Returns the number of FIELD_DECLs in a type.  */
2440
2441 extern int fields_length                PARAMS ((tree));
2442
2443 /* Given an initializer INIT, return TRUE if INIT is zero or some
2444    aggregate of zeros.  Otherwise return FALSE.  */
2445
2446 extern bool initializer_zerop           PARAMS ((tree));
2447
2448 /* integer_zerop (tree x) is nonzero if X is an integer constant of value 0 */
2449
2450 extern int integer_zerop                PARAMS ((tree));
2451
2452 /* integer_onep (tree x) is nonzero if X is an integer constant of value 1 */
2453
2454 extern int integer_onep                 PARAMS ((tree));
2455
2456 /* integer_all_onesp (tree x) is nonzero if X is an integer constant
2457    all of whose significant bits are 1.  */
2458
2459 extern int integer_all_onesp            PARAMS ((tree));
2460
2461 /* integer_pow2p (tree x) is nonzero is X is an integer constant with
2462    exactly one bit 1.  */
2463
2464 extern int integer_pow2p                PARAMS ((tree));
2465
2466 /* integer_nonzerop (tree x) is nonzero if X is an integer constant
2467    with a nonzero value.  */
2468
2469 extern int integer_nonzerop             PARAMS ((tree));
2470
2471 /* staticp (tree x) is nonzero if X is a reference to data allocated
2472    at a fixed address in memory.  */
2473
2474 extern int staticp                      PARAMS ((tree));
2475
2476 /* Gets an error if argument X is not an lvalue.
2477    Also returns 1 if X is an lvalue, 0 if not.  */
2478
2479 extern int lvalue_or_else               PARAMS ((tree, const char *));
2480
2481 /* save_expr (EXP) returns an expression equivalent to EXP
2482    but it can be used multiple times within context CTX
2483    and only evaluate EXP once.  */
2484
2485 extern tree save_expr                   PARAMS ((tree));
2486
2487 /* Look inside EXPR and into any simple arithmetic operations.  Return
2488    the innermost non-arithmetic node.  */
2489
2490 extern tree skip_simple_arithmetic      PARAMS ((tree));
2491
2492 /* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a
2493    SAVE_EXPR.  Return FALSE otherwise.  */
2494
2495 extern bool saved_expr_p                PARAMS ((tree));
2496
2497 /* Returns the index of the first non-tree operand for CODE, or the number
2498    of operands if all are trees.  */
2499
2500 extern int first_rtl_op                 PARAMS ((enum tree_code));
2501
2502 /* Return which tree structure is used by T.  */
2503
2504 enum tree_node_structure_enum tree_node_structure PARAMS ((tree));
2505
2506 /* unsave_expr (EXP) returns an expression equivalent to EXP but it
2507    can be used multiple times and will evaluate EXP in its entirety
2508    each time.  */
2509
2510 extern tree unsave_expr                 PARAMS ((tree));
2511
2512 /* Reset EXP in place so that it can be expanded again.  Does not
2513    recurse into subtrees.  */
2514
2515 extern void unsave_expr_1               PARAMS ((tree));
2516
2517 /* Return 0 if it is safe to evaluate EXPR multiple times,
2518    return 1 if it is safe if EXPR is unsaved afterward, or
2519    return 2 if it is completely unsafe.  */
2520 extern int unsafe_for_reeval            PARAMS ((tree));
2521
2522 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2523    or offset that depends on a field within a record.
2524
2525    Note that we only allow such expressions within simple arithmetic
2526    or a COND_EXPR.  */
2527
2528 extern bool contains_placeholder_p      PARAMS ((tree));
2529
2530 /* This macro calls the above function but short-circuits the common
2531    case of a constant to save time.  Also check for null.  */
2532
2533 #define CONTAINS_PLACEHOLDER_P(EXP) \
2534   ((EXP) != 0 && ! TREE_CONSTANT (EXP) && contains_placeholder_p (EXP))
2535
2536 /* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
2537    This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
2538    positions.  */
2539
2540 extern bool type_contains_placeholder_p PARAMS ((tree));
2541
2542 /* Return 1 if EXP contains any expressions that produce cleanups for an
2543    outer scope to deal with.  Used by fold.  */
2544
2545 extern int has_cleanups                 PARAMS ((tree));
2546
2547 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2548    return a tree with all occurrences of references to F in a
2549    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
2550    contains only arithmetic expressions.  */
2551
2552 extern tree substitute_in_expr          PARAMS ((tree, tree, tree));
2553
2554 /* variable_size (EXP) is like save_expr (EXP) except that it
2555    is for the special case of something that is part of a
2556    variable size for a data type.  It makes special arrangements
2557    to compute the value at the right time when the data type
2558    belongs to a function parameter.  */
2559
2560 extern tree variable_size               PARAMS ((tree));
2561
2562 /* stabilize_reference (EXP) returns an reference equivalent to EXP
2563    but it can be used multiple times
2564    and only evaluate the subexpressions once.  */
2565
2566 extern tree stabilize_reference         PARAMS ((tree));
2567
2568 /* Subroutine of stabilize_reference; this is called for subtrees of
2569    references.  Any expression with side-effects must be put in a SAVE_EXPR
2570    to ensure that it is only evaluated once.  */
2571
2572 extern tree stabilize_reference_1       PARAMS ((tree));
2573
2574 /* Return EXP, stripped of any conversions to wider types
2575    in such a way that the result of converting to type FOR_TYPE
2576    is the same as if EXP were converted to FOR_TYPE.
2577    If FOR_TYPE is 0, it signifies EXP's type.  */
2578
2579 extern tree get_unwidened               PARAMS ((tree, tree));
2580
2581 /* Return OP or a simpler expression for a narrower value
2582    which can be sign-extended or zero-extended to give back OP.
2583    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
2584    or 0 if the value should be sign-extended.  */
2585
2586 extern tree get_narrower                PARAMS ((tree, int *));
2587
2588 /* Given an expression EXP that may be a COMPONENT_REF or an ARRAY_REF,
2589    look for nested component-refs or array-refs at constant positions
2590    and find the ultimate containing object, which is returned.  */
2591
2592 extern tree get_inner_reference         PARAMS ((tree, HOST_WIDE_INT *,
2593                                                  HOST_WIDE_INT *, tree *,
2594                                                  enum machine_mode *, int *,
2595                                                  int *));
2596
2597 /* Return 1 if T is an expression that get_inner_reference handles.  */
2598
2599 extern int handled_component_p          PARAMS ((tree));
2600
2601 /* Given a DECL or TYPE, return the scope in which it was declared, or
2602    NUL_TREE if there is no containing scope.  */
2603
2604 extern tree get_containing_scope        PARAMS ((tree));
2605
2606 /* Return the FUNCTION_DECL which provides this _DECL with its context,
2607    or zero if none.  */
2608 extern tree decl_function_context       PARAMS ((tree));
2609
2610 /* Return the RECORD_TYPE, UNION_TYPE, or QUAL_UNION_TYPE which provides
2611    this _DECL with its context, or zero if none.  */
2612 extern tree decl_type_context           PARAMS ((tree));
2613
2614 /* Given the FUNCTION_DECL for the current function,
2615    return zero if it is ok for this function to be inline.
2616    Otherwise return a warning message with a single %s
2617    for the function's name.  */
2618
2619 extern const char *function_cannot_inline_p     PARAMS ((tree));
2620
2621 /* Return 1 if EXPR is the real constant zero.  */
2622 extern int real_zerop PARAMS ((tree));
2623 \f
2624 /* Declare commonly used variables for tree structure.  */
2625
2626 /* Nonzero means lvalues are limited to those valid in pedantic ANSI C.
2627    Zero means allow extended lvalues.  */
2628
2629 extern int pedantic_lvalues;
2630
2631 /* Nonzero means can safely call expand_expr now;
2632    otherwise layout_type puts variable sizes onto `pending_sizes' instead.  */
2633
2634 extern int immediate_size_expand;
2635
2636 /* Points to the FUNCTION_DECL of the function whose body we are reading.  */
2637
2638 extern GTY(()) tree current_function_decl;
2639
2640 /* Nonzero means a FUNC_BEGIN label was emitted.  */
2641 extern GTY(()) tree current_function_func_begin_label;
2642
2643 /* Nonzero means all ..._TYPE nodes should be allocated permanently.  */
2644
2645 extern int all_types_permanent;
2646
2647 /* Declare a predefined function.  Return the declaration.  This function is
2648    provided by each language frontend.  */
2649 extern tree builtin_function            PARAMS ((const char *, tree, int,
2650                                                enum built_in_class,
2651                                                const char *, tree));
2652 \f
2653 /* In tree.c */
2654 extern void clean_symbol_name                   PARAMS ((char *));
2655 extern tree get_file_function_name_long         PARAMS ((const char *));
2656 extern tree get_set_constructor_bits            PARAMS ((tree, char *, int));
2657 extern tree get_set_constructor_bytes           PARAMS ((tree,
2658                                                        unsigned char *, int));
2659 extern tree get_callee_fndecl                   PARAMS ((tree));
2660 extern void set_decl_assembler_name             PARAMS ((tree));
2661 extern int type_num_arguments                   PARAMS ((tree));
2662 extern tree lhd_unsave_expr_now         PARAMS ((tree));
2663
2664 \f
2665 /* In stmt.c */
2666
2667 extern void expand_fixups                       PARAMS ((rtx));
2668 extern tree expand_start_stmt_expr              PARAMS ((int));
2669 extern tree expand_end_stmt_expr                PARAMS ((tree));
2670 extern void expand_expr_stmt                    PARAMS ((tree));
2671 extern void expand_expr_stmt_value              PARAMS ((tree, int, int));
2672 extern int warn_if_unused_value                 PARAMS ((tree));
2673 extern void expand_decl_init                    PARAMS ((tree));
2674 extern void clear_last_expr                     PARAMS ((void));
2675 extern void expand_label                        PARAMS ((tree));
2676 extern void expand_goto                         PARAMS ((tree));
2677 extern void expand_asm                          PARAMS ((tree, int));
2678 extern void expand_start_cond                   PARAMS ((tree, int));
2679 extern void expand_end_cond                     PARAMS ((void));
2680 extern void expand_start_else                   PARAMS ((void));
2681 extern void expand_start_elseif                 PARAMS ((tree));
2682 extern struct nesting *expand_start_loop        PARAMS ((int));
2683 extern struct nesting *expand_start_loop_continue_elsewhere     PARAMS ((int));
2684 extern struct nesting *expand_start_null_loop   PARAMS ((void));
2685 extern void expand_loop_continue_here           PARAMS ((void));
2686 extern void expand_end_loop                     PARAMS ((void));
2687 extern void expand_end_null_loop                PARAMS ((void));
2688 extern int expand_continue_loop                 PARAMS ((struct nesting *));
2689 extern int expand_exit_loop                     PARAMS ((struct nesting *));
2690 extern int expand_exit_loop_if_false            PARAMS ((struct nesting *,
2691                                                          tree));
2692 extern int expand_exit_loop_top_cond            PARAMS ((struct nesting *,
2693                                                          tree));
2694 extern int expand_exit_something                PARAMS ((void));
2695
2696 extern void expand_return                       PARAMS ((tree));
2697 extern int optimize_tail_recursion              PARAMS ((tree, rtx));
2698 extern void expand_start_bindings_and_block     PARAMS ((int, tree));
2699 #define expand_start_bindings(flags) \
2700   expand_start_bindings_and_block(flags, NULL_TREE)
2701 extern void expand_end_bindings                 PARAMS ((tree, int, int));
2702 extern void warn_about_unused_variables         PARAMS ((tree));
2703 extern void start_cleanup_deferral              PARAMS ((void));
2704 extern void end_cleanup_deferral                PARAMS ((void));
2705 extern int is_body_block                        PARAMS ((tree));
2706
2707 extern int conditional_context                  PARAMS ((void));
2708 extern struct nesting * current_nesting_level   PARAMS ((void));
2709 extern tree last_cleanup_this_contour           PARAMS ((void));
2710 extern void expand_start_case                   PARAMS ((int, tree, tree,
2711                                                        const char *));
2712 extern void expand_end_case_type                PARAMS ((tree, tree));
2713 #define expand_end_case(cond) expand_end_case_type (cond, NULL)
2714 extern int add_case_node                        PARAMS ((tree, tree,
2715                                                          tree, tree *));
2716 extern int pushcase                             PARAMS ((tree,
2717                                                        tree (*) (tree, tree),
2718                                                        tree, tree *));
2719 extern int pushcase_range                       PARAMS ((tree, tree,
2720                                                        tree (*) (tree, tree),
2721                                                        tree, tree *));
2722 extern void using_eh_for_cleanups               PARAMS ((void));
2723
2724 /* In fold-const.c */
2725
2726 /* Fold constants as much as possible in an expression.
2727    Returns the simplified expression.
2728    Acts only on the top level of the expression;
2729    if the argument itself cannot be simplified, its
2730    subexpressions are not changed.  */
2731
2732 extern tree fold                PARAMS ((tree));
2733
2734 extern int force_fit_type       PARAMS ((tree, int));
2735 extern int add_double           PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2736                                          unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2737                                          unsigned HOST_WIDE_INT *,
2738                                          HOST_WIDE_INT *));
2739 extern int neg_double           PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2740                                          unsigned HOST_WIDE_INT *,
2741                                          HOST_WIDE_INT *));
2742 extern int mul_double           PARAMS ((unsigned HOST_WIDE_INT,
2743                                          HOST_WIDE_INT,
2744                                          unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2745                                          unsigned HOST_WIDE_INT *,
2746                                          HOST_WIDE_INT *));
2747 extern void lshift_double       PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2748                                          HOST_WIDE_INT, unsigned int,
2749                                          unsigned HOST_WIDE_INT *,
2750                                          HOST_WIDE_INT *, int));
2751 extern void rshift_double       PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2752                                          HOST_WIDE_INT, unsigned int,
2753                                          unsigned HOST_WIDE_INT *,
2754                                          HOST_WIDE_INT *, int));
2755 extern void lrotate_double      PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2756                                          HOST_WIDE_INT, unsigned int,
2757                                          unsigned HOST_WIDE_INT *,
2758                                          HOST_WIDE_INT *));
2759 extern void rrotate_double      PARAMS ((unsigned HOST_WIDE_INT, HOST_WIDE_INT,
2760                                          HOST_WIDE_INT, unsigned int,
2761                                          unsigned HOST_WIDE_INT *,
2762                                          HOST_WIDE_INT *));
2763
2764 extern int div_and_round_double         PARAMS ((enum tree_code, int,
2765                                                  unsigned HOST_WIDE_INT,
2766                                                  HOST_WIDE_INT,
2767                                                  unsigned HOST_WIDE_INT,
2768                                                  HOST_WIDE_INT,
2769                                                  unsigned HOST_WIDE_INT *,
2770                                                  HOST_WIDE_INT *,
2771                                                  unsigned HOST_WIDE_INT *,
2772                                                  HOST_WIDE_INT *));
2773
2774 extern int operand_equal_p      PARAMS ((tree, tree, int));
2775 extern tree omit_one_operand    PARAMS ((tree, tree, tree));
2776 extern tree invert_truthvalue   PARAMS ((tree));
2777
2778 /* In builtins.c */
2779 extern tree fold_builtin                                PARAMS ((tree));
2780 extern enum built_in_function builtin_mathfn_code       PARAMS ((tree));
2781 extern tree build_function_call_expr                    PARAMS ((tree, tree));
2782 extern tree mathfn_built_in                             PARAMS ((tree, enum built_in_function fn));
2783 extern tree strip_float_extensions                      PARAMS ((tree));
2784
2785 /* In convert.c */
2786 extern tree strip_float_extensions                      PARAMS ((tree));
2787
2788 /* In alias.c */
2789 extern void record_component_aliases            PARAMS ((tree));
2790 extern HOST_WIDE_INT get_alias_set              PARAMS ((tree));
2791 extern int alias_sets_conflict_p                PARAMS ((HOST_WIDE_INT,
2792                                                          HOST_WIDE_INT));
2793 extern int readonly_fields_p                    PARAMS ((tree));
2794 extern int objects_must_conflict_p              PARAMS ((tree, tree));
2795
2796 /* In tree.c */
2797 extern int really_constant_p            PARAMS ((tree));
2798 extern int int_fits_type_p              PARAMS ((tree, tree));
2799 extern bool variably_modified_type_p    PARAMS ((tree));
2800 extern int tree_log2                    PARAMS ((tree));
2801 extern int tree_floor_log2              PARAMS ((tree));
2802 extern int simple_cst_equal             PARAMS ((tree, tree));
2803 extern unsigned int iterative_hash_expr PARAMS ((tree, unsigned int));
2804 extern int compare_tree_int             PARAMS ((tree,
2805                                                  unsigned HOST_WIDE_INT));
2806 extern int type_list_equal              PARAMS ((tree, tree));
2807 extern int chain_member                 PARAMS ((tree, tree));
2808 extern tree type_hash_lookup            PARAMS ((unsigned int, tree));
2809 extern void type_hash_add               PARAMS ((unsigned int, tree));
2810 extern unsigned int type_hash_list      PARAMS ((tree));
2811 extern int simple_cst_list_equal        PARAMS ((tree, tree));
2812 extern void dump_tree_statistics        PARAMS ((void));
2813 extern void expand_function_end         PARAMS ((const char *, int, int));
2814 extern void expand_function_start       PARAMS ((tree, int));
2815 extern void expand_pending_sizes        PARAMS ((tree));
2816
2817 extern int real_onep                    PARAMS ((tree));
2818 extern int real_twop                    PARAMS ((tree));
2819 extern int real_minus_onep              PARAMS ((tree));
2820 extern void init_ttree                  PARAMS ((void));
2821 extern void build_common_tree_nodes     PARAMS ((int));
2822 extern void build_common_tree_nodes_2   PARAMS ((int));
2823 extern tree build_range_type            PARAMS ((tree, tree, tree));
2824
2825 /* In function.c */
2826 extern void setjmp_protect_args         PARAMS ((void));
2827 extern void setjmp_protect              PARAMS ((tree));
2828 extern void expand_main_function        PARAMS ((void));
2829 extern void init_dummy_function_start   PARAMS ((void));
2830 extern void expand_dummy_function_end   PARAMS ((void));
2831 extern void init_function_for_compilation       PARAMS ((void));
2832 extern void init_function_start         PARAMS ((tree, const char *, int));
2833 extern void assign_parms                PARAMS ((tree));
2834 extern void put_var_into_stack          PARAMS ((tree, int));
2835 extern void flush_addressof             PARAMS ((tree));
2836 extern void uninitialized_vars_warning  PARAMS ((tree));
2837 extern void setjmp_args_warning         PARAMS ((void));
2838 extern void mark_all_temps_used         PARAMS ((void));
2839 extern void init_temp_slots             PARAMS ((void));
2840 extern void combine_temp_slots          PARAMS ((void));
2841 extern void free_temp_slots             PARAMS ((void));
2842 extern void pop_temp_slots              PARAMS ((void));
2843 extern void push_temp_slots             PARAMS ((void));
2844 extern void preserve_temp_slots         PARAMS ((rtx));
2845 extern void preserve_rtl_expr_temps     PARAMS ((tree));
2846 extern int aggregate_value_p            PARAMS ((tree));
2847 extern void free_temps_for_rtl_expr     PARAMS ((tree));
2848 extern void instantiate_virtual_regs    PARAMS ((tree, rtx));
2849 extern void unshare_all_rtl             PARAMS ((tree, rtx));
2850 extern void push_function_context       PARAMS ((void));
2851 extern void pop_function_context        PARAMS ((void));
2852 extern void push_function_context_to    PARAMS ((tree));
2853 extern void pop_function_context_from   PARAMS ((tree));
2854
2855 /* In print-rtl.c */
2856 #ifdef BUFSIZ
2857 extern void print_rtl                   PARAMS ((FILE *, rtx));
2858 #endif
2859
2860 /* In print-tree.c */
2861 extern void debug_tree                  PARAMS ((tree));
2862 #ifdef BUFSIZ
2863 extern void print_node                  PARAMS ((FILE *, const char *, tree,
2864                                                  int));
2865 extern void print_node_brief            PARAMS ((FILE *, const char *, tree,
2866                                                  int));
2867 extern void indent_to                   PARAMS ((FILE *, int));
2868 #endif
2869
2870 /* In expr.c */
2871 extern int apply_args_register_offset           PARAMS ((int));
2872 extern rtx expand_builtin_return_addr
2873         PARAMS ((enum built_in_function, int, rtx));
2874 extern void check_max_integer_computation_mode  PARAMS ((tree));
2875
2876 /* In emit-rtl.c */
2877 extern void start_sequence_for_rtl_expr         PARAMS ((tree));
2878 extern rtx emit_line_note               PARAMS ((const char *, int));
2879
2880 /* In calls.c */
2881
2882 extern int setjmp_call_p                PARAMS ((tree));
2883 extern bool alloca_call_p               PARAMS ((tree));
2884
2885 /* In attribs.c.  */
2886
2887 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
2888    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
2889    it should be modified in place; if a TYPE, a copy should be created
2890    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
2891    information, in the form of a bitwise OR of flags in enum attribute_flags
2892    from tree.h.  Depending on these flags, some attributes may be
2893    returned to be applied at a later stage (for example, to apply
2894    a decl attribute to the declaration rather than to its type).  */
2895 extern tree decl_attributes             PARAMS ((tree *, tree, int));
2896
2897 /* In integrate.c */
2898 extern void save_for_inline             PARAMS ((tree));
2899 extern void set_decl_abstract_flags     PARAMS ((tree, int));
2900 extern void output_inline_function      PARAMS ((tree));
2901 extern void set_decl_origin_self        PARAMS ((tree));
2902
2903 /* In stor-layout.c */
2904 extern void fixup_signed_type           PARAMS ((tree));
2905 extern void internal_reference_types    PARAMS ((void));
2906
2907 /* varasm.c */
2908 extern void make_decl_rtl               PARAMS ((tree, const char *));
2909 extern void make_decl_one_only          PARAMS ((tree));
2910 extern int supports_one_only            PARAMS ((void));
2911 extern void variable_section            PARAMS ((tree, int));
2912 enum tls_model decl_tls_model           PARAMS ((tree));
2913 enum symbol_visibility decl_visibility  PARAMS ((tree));
2914
2915 /* In stmt.c */
2916 extern void emit_nop                    PARAMS ((void));
2917 extern void expand_computed_goto        PARAMS ((tree));
2918 extern bool parse_output_constraint     PARAMS ((const char **,
2919                                                  int, int, int,
2920                                                  bool *, bool *, bool *));
2921 extern void expand_asm_operands         PARAMS ((tree, tree, tree, tree, int,
2922                                                  const char *, int));
2923 extern tree resolve_asm_operand_names (tree, tree, tree);
2924 extern int any_pending_cleanups         PARAMS ((int));
2925 extern void init_stmt_for_function      PARAMS ((void));
2926 extern void expand_start_target_temps   PARAMS ((void));
2927 extern void expand_end_target_temps     PARAMS ((void));
2928 extern void expand_elseif               PARAMS ((tree));
2929 extern void save_stack_pointer          PARAMS ((void));
2930 extern void expand_decl                 PARAMS ((tree));
2931 extern int expand_decl_cleanup          PARAMS ((tree, tree));
2932 extern int expand_decl_cleanup_eh       PARAMS ((tree, tree, int));
2933 extern void expand_anon_union_decl      PARAMS ((tree, tree, tree));
2934 extern void expand_start_case_dummy     PARAMS ((void));
2935 extern HOST_WIDE_INT all_cases_count    PARAMS ((tree, int *));
2936 extern void check_for_full_enumeration_handling PARAMS ((tree));
2937 extern void declare_nonlocal_label      PARAMS ((tree));
2938 extern void default_flag_random_seed    PARAMS ((void));
2939
2940 /* If KIND=='I', return a suitable global initializer (constructor) name.
2941    If KIND=='D', return a suitable global clean-up (destructor) name.  */
2942 extern tree get_file_function_name PARAMS ((int));
2943 \f
2944 /* Interface of the DWARF2 unwind info support.  */
2945
2946 /* Generate a new label for the CFI info to refer to.  */
2947
2948 extern char *dwarf2out_cfi_label        PARAMS ((void));
2949
2950 /* Entry point to update the canonical frame address (CFA).  */
2951
2952 extern void dwarf2out_def_cfa           PARAMS ((const char *, unsigned, long));
2953
2954 /* Add the CFI for saving a register window.  */
2955
2956 extern void dwarf2out_window_save       PARAMS ((const char *));
2957
2958 /* Add a CFI to update the running total of the size of arguments pushed
2959    onto the stack.  */
2960
2961 extern void dwarf2out_args_size         PARAMS ((const char *, long));
2962
2963 /* Entry point for saving a register to the stack.  */
2964
2965 extern void dwarf2out_reg_save          PARAMS ((const char *, unsigned, long));
2966
2967 /* Entry point for saving the return address in the stack.  */
2968
2969 extern void dwarf2out_return_save       PARAMS ((const char *, long));
2970
2971 /* Entry point for saving the return address in a register.  */
2972
2973 extern void dwarf2out_return_reg        PARAMS ((const char *, unsigned));
2974
2975 /* The type of a function that walks over tree structure.  */
2976
2977 typedef tree (*walk_tree_fn)            PARAMS ((tree *, int *, void *));
2978
2979 /* In tree-dump.c */
2980
2981 /* Different tree dump places.  When you add new tree dump places,
2982    extend the DUMP_FILES array in tree-dump.c */
2983 enum tree_dump_index
2984 {
2985   TDI_all,                      /* dump the whole translation unit */
2986   TDI_class,                    /* dump class hierarchy */
2987   TDI_original,                 /* dump each function before optimizing it */
2988   TDI_optimized,                /* dump each function after optimizing it */
2989   TDI_inlined,                  /* dump each function after inlining
2990                                    within it.  */
2991   TDI_end
2992 };
2993
2994 /* Bit masks to control tree dumping. Not all values are applicable to
2995    all tree dumps. Add new ones at the end. When you define new
2996    values, extend the DUMP_OPTIONS array in tree-dump.c */
2997 #define TDF_ADDRESS     (1 << 0)        /* dump node addresses */
2998 #define TDF_SLIM        (1 << 1)        /* don't go wild following links */
2999
3000 typedef struct dump_info *dump_info_p;
3001
3002 extern int dump_flag                    PARAMS ((dump_info_p, int, tree));
3003 extern int dump_enabled_p               PARAMS ((enum tree_dump_index));
3004 extern FILE *dump_begin                 PARAMS ((enum tree_dump_index, int *));
3005 extern void dump_end                    PARAMS ((enum tree_dump_index, FILE *));
3006 extern void dump_node                   PARAMS ((tree, int, FILE *));
3007 extern int dump_switch_p                PARAMS ((const char *));
3008 extern const char *dump_flag_name       PARAMS ((enum tree_dump_index));
3009 /* Assign the RTX to declaration.  */
3010
3011 extern void set_decl_rtl                PARAMS ((tree, rtx));
3012 \f
3013 /* Redefine abort to report an internal error w/o coredump, and
3014    reporting the location of the error in the source file.  This logic
3015    is duplicated in rtl.h and tree.h because every file that needs the
3016    special abort includes one or both.  toplev.h gets too few files,
3017    system.h gets too many.  */
3018
3019 extern void fancy_abort PARAMS ((const char *, int, const char *))
3020     ATTRIBUTE_NORETURN;
3021 #define abort() fancy_abort (__FILE__, __LINE__, __FUNCTION__)
3022
3023 #endif  /* GCC_TREE_H  */