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