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