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