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