1 /* Core data structures for the 'tree' type. 2 Copyright (C) 1989-2019 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_TREE_CORE_H 21 #define GCC_TREE_CORE_H 22 23 #include "symtab.h" 24 25 /* This file contains all the data structures that define the 'tree' type. 26 There are no accessor macros nor functions in this file. Only the 27 basic data structures, extern declarations and type definitions. */ 28 29 /*--------------------------------------------------------------------------- 30 Forward type declarations. Mostly to avoid including unnecessary headers 31 ---------------------------------------------------------------------------*/ 32 struct function; 33 struct real_value; 34 struct fixed_value; 35 struct ptr_info_def; 36 struct range_info_def; 37 struct die_struct; 38 39 40 /*--------------------------------------------------------------------------- 41 #defined constants 42 ---------------------------------------------------------------------------*/ 43 /* Nonzero if this is a call to a function whose return value depends 44 solely on its arguments, has no side effects, and does not read 45 global memory. This corresponds to TREE_READONLY for function 46 decls. */ 47 #define ECF_CONST (1 << 0) 48 49 /* Nonzero if this is a call to "pure" function (like const function, 50 but may read memory. This corresponds to DECL_PURE_P for function 51 decls. */ 52 #define ECF_PURE (1 << 1) 53 54 /* Nonzero if this is ECF_CONST or ECF_PURE but cannot be proven to no 55 infinite loop. This corresponds to DECL_LOOPING_CONST_OR_PURE_P 56 for function decls.*/ 57 #define ECF_LOOPING_CONST_OR_PURE (1 << 2) 58 59 /* Nonzero if this call will never return. */ 60 #define ECF_NORETURN (1 << 3) 61 62 /* Nonzero if this is a call to malloc or a related function. */ 63 #define ECF_MALLOC (1 << 4) 64 65 /* Nonzero if it is plausible that this is a call to alloca. */ 66 #define ECF_MAY_BE_ALLOCA (1 << 5) 67 68 /* Nonzero if this is a call to a function that won't throw an exception. */ 69 #define ECF_NOTHROW (1 << 6) 70 71 /* Nonzero if this is a call to setjmp or a related function. */ 72 #define ECF_RETURNS_TWICE (1 << 7) 73 74 /* Nonzero if this call replaces the current stack frame. */ 75 #define ECF_SIBCALL (1 << 8) 76 77 /* Function does not read or write memory (but may have side effects, so 78 it does not necessarily fit ECF_CONST). */ 79 #define ECF_NOVOPS (1 << 9) 80 81 /* The function does not lead to calls within current function unit. */ 82 #define ECF_LEAF (1 << 10) 83 84 /* Nonzero if this call returns its first argument. */ 85 #define ECF_RET1 (1 << 11) 86 87 /* Nonzero if this call does not affect transactions. */ 88 #define ECF_TM_PURE (1 << 12) 89 90 /* Nonzero if this call is into the transaction runtime library. */ 91 #define ECF_TM_BUILTIN (1 << 13) 92 93 /* Nonzero if this is an indirect call by descriptor. */ 94 #define ECF_BY_DESCRIPTOR (1 << 14) 95 96 /* Nonzero if this is a cold function. */ 97 #define ECF_COLD (1 << 15) 98 99 /* Call argument flags. */ 100 /* Nonzero if the argument is not dereferenced recursively, thus only 101 directly reachable memory is read or written. */ 102 #define EAF_DIRECT (1 << 0) 103 104 /* Nonzero if memory reached by the argument is not clobbered. */ 105 #define EAF_NOCLOBBER (1 << 1) 106 107 /* Nonzero if the argument does not escape. */ 108 #define EAF_NOESCAPE (1 << 2) 109 110 /* Nonzero if the argument is not used by the function. */ 111 #define EAF_UNUSED (1 << 3) 112 113 /* Call return flags. */ 114 /* Mask for the argument number that is returned. Lower two bits of 115 the return flags, encodes argument slots zero to three. */ 116 #define ERF_RETURN_ARG_MASK (3) 117 118 /* Nonzero if the return value is equal to the argument number 119 flags & ERF_RETURN_ARG_MASK. */ 120 #define ERF_RETURNS_ARG (1 << 2) 121 122 /* Nonzero if the return value does not alias with anything. Functions 123 with the malloc attribute have this set on their return value. */ 124 #define ERF_NOALIAS (1 << 3) 125 126 127 /*--------------------------------------------------------------------------- 128 Enumerations 129 ---------------------------------------------------------------------------*/ 130 /* Codes of tree nodes. */ 131 #define DEFTREECODE(SYM, STRING, TYPE, NARGS) SYM, 132 #define END_OF_BASE_TREE_CODES LAST_AND_UNUSED_TREE_CODE, 133 134 enum tree_code { 135 #include "all-tree.def" 136 MAX_TREE_CODES 137 }; 138 139 #undef DEFTREECODE 140 #undef END_OF_BASE_TREE_CODES 141 142 /* Number of language-independent tree codes. */ 143 #define NUM_TREE_CODES \ 144 ((int) LAST_AND_UNUSED_TREE_CODE) 145 146 #define CODE_CONTAINS_STRUCT(CODE, STRUCT) \ 147 (tree_contains_struct[(CODE)][(STRUCT)]) 148 149 150 /* Classify which part of the compiler has defined a given builtin function. 151 Note that we assume below that this is no more than two bits. */ 152 enum built_in_class { 153 NOT_BUILT_IN = 0, 154 BUILT_IN_FRONTEND, 155 BUILT_IN_MD, 156 BUILT_IN_NORMAL 157 }; 158 159 /* Last marker used for LTO stremaing of built_in_class. We cannot add it 160 to the enum since we need the enumb to fit in 2 bits. */ 161 #define BUILT_IN_LAST (BUILT_IN_NORMAL + 1) 162 163 /* Codes that identify the various built in functions 164 so that expand_call can identify them quickly. */ 165 #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) ENUM, 166 enum built_in_function { 167 #include "builtins.def" 168 /* Complex division routines in libgcc. These are done via builtins 169 because emit_library_call_value can't handle complex values. */ 170 BUILT_IN_COMPLEX_MUL_MIN, 171 BUILT_IN_COMPLEX_MUL_MAX 172 = BUILT_IN_COMPLEX_MUL_MIN 173 + MAX_MODE_COMPLEX_FLOAT 174 - MIN_MODE_COMPLEX_FLOAT, 175 176 BUILT_IN_COMPLEX_DIV_MIN, 177 BUILT_IN_COMPLEX_DIV_MAX 178 = BUILT_IN_COMPLEX_DIV_MIN 179 + MAX_MODE_COMPLEX_FLOAT 180 - MIN_MODE_COMPLEX_FLOAT, 181 182 /* Upper bound on non-language-specific builtins. */ 183 END_BUILTINS 184 }; 185 186 /* Internal functions. */ 187 enum internal_fn { 188 #define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) IFN_##CODE, 189 #include "internal-fn.def" 190 IFN_LAST 191 }; 192 193 /* An enum that combines target-independent built-in functions with 194 internal functions, so that they can be treated in a similar way. 195 The numbers for built-in functions are the same as for the 196 built_in_function enum. The numbers for internal functions 197 start at END_BUITLINS. */ 198 enum combined_fn { 199 #define DEF_BUILTIN(ENUM, N, C, T, LT, B, F, NA, AT, IM, COND) \ 200 CFN_##ENUM = int (ENUM), 201 #include "builtins.def" 202 203 204 #define DEF_INTERNAL_FN(CODE, FLAGS, FNSPEC) \ 205 CFN_##CODE = int (END_BUILTINS) + int (IFN_##CODE), 206 #include "internal-fn.def" 207 208 CFN_LAST 209 }; 210 211 /* Tree code classes. Each tree_code has an associated code class 212 represented by a TREE_CODE_CLASS. */ 213 enum tree_code_class { 214 tcc_exceptional, /* An exceptional code (fits no category). */ 215 tcc_constant, /* A constant. */ 216 /* Order of tcc_type and tcc_declaration is important. */ 217 tcc_type, /* A type object code. */ 218 tcc_declaration, /* A declaration (also serving as variable refs). */ 219 tcc_reference, /* A reference to storage. */ 220 tcc_comparison, /* A comparison expression. */ 221 tcc_unary, /* A unary arithmetic expression. */ 222 tcc_binary, /* A binary arithmetic expression. */ 223 tcc_statement, /* A statement expression, which have side effects 224 but usually no interesting value. */ 225 tcc_vl_exp, /* A function call or other expression with a 226 variable-length operand vector. */ 227 tcc_expression /* Any other expression. */ 228 }; 229 230 /* OMP_CLAUSE codes. Do not reorder, as this is used to index into 231 the tables omp_clause_num_ops and omp_clause_code_name. */ 232 enum omp_clause_code { 233 /* Clause zero is special-cased inside the parser 234 (c_parser_omp_variable_list). */ 235 OMP_CLAUSE_ERROR = 0, 236 237 /* OpenACC/OpenMP clause: private (variable_list). */ 238 OMP_CLAUSE_PRIVATE, 239 240 /* OpenMP clause: shared (variable_list). */ 241 OMP_CLAUSE_SHARED, 242 243 /* OpenACC/OpenMP clause: firstprivate (variable_list). */ 244 OMP_CLAUSE_FIRSTPRIVATE, 245 246 /* OpenMP clause: lastprivate (variable_list). */ 247 OMP_CLAUSE_LASTPRIVATE, 248 249 /* OpenACC/OpenMP clause: reduction (operator:variable_list). 250 OMP_CLAUSE_REDUCTION_CODE: The tree_code of the operator. 251 Operand 1: OMP_CLAUSE_REDUCTION_INIT: Stmt-list to initialize the var. 252 Operand 2: OMP_CLAUSE_REDUCTION_MERGE: Stmt-list to merge private var 253 into the shared one. 254 Operand 3: OMP_CLAUSE_REDUCTION_PLACEHOLDER: A dummy VAR_DECL 255 placeholder used in OMP_CLAUSE_REDUCTION_{INIT,MERGE}. 256 Operand 4: OMP_CLAUSE_REDUCTION_DECL_PLACEHOLDER: Another dummy 257 VAR_DECL placeholder, used like the above for C/C++ array 258 reductions. */ 259 OMP_CLAUSE_REDUCTION, 260 261 /* OpenMP clause: task_reduction (operator:variable_list). */ 262 OMP_CLAUSE_TASK_REDUCTION, 263 264 /* OpenMP clause: in_reduction (operator:variable_list). */ 265 OMP_CLAUSE_IN_REDUCTION, 266 267 /* OpenMP clause: copyin (variable_list). */ 268 OMP_CLAUSE_COPYIN, 269 270 /* OpenMP clause: copyprivate (variable_list). */ 271 OMP_CLAUSE_COPYPRIVATE, 272 273 /* OpenMP clause: linear (variable-list[:linear-step]). */ 274 OMP_CLAUSE_LINEAR, 275 276 /* OpenMP clause: aligned (variable-list[:alignment]). */ 277 OMP_CLAUSE_ALIGNED, 278 279 /* OpenMP clause: depend ({in,out,inout}:variable-list). */ 280 OMP_CLAUSE_DEPEND, 281 282 /* OpenMP clause: nontemporal (variable-list). */ 283 OMP_CLAUSE_NONTEMPORAL, 284 285 /* OpenMP clause: uniform (argument-list). */ 286 OMP_CLAUSE_UNIFORM, 287 288 /* OpenMP clause: to (extended-list). 289 Only when it appears in declare target. */ 290 OMP_CLAUSE_TO_DECLARE, 291 292 /* OpenMP clause: link (variable-list). */ 293 OMP_CLAUSE_LINK, 294 295 /* OpenMP clause: from (variable-list). */ 296 OMP_CLAUSE_FROM, 297 298 /* OpenMP clause: to (variable-list). */ 299 OMP_CLAUSE_TO, 300 301 /* OpenACC clauses: {copy, copyin, copyout, create, delete, deviceptr, 302 device, host (self), present, present_or_copy (pcopy), present_or_copyin 303 (pcopyin), present_or_copyout (pcopyout), present_or_create (pcreate)} 304 (variable-list). 305 306 OpenMP clause: map ({alloc:,to:,from:,tofrom:,}variable-list). */ 307 OMP_CLAUSE_MAP, 308 309 /* OpenACC clause: use_device (variable_list). 310 OpenMP clause: use_device_ptr (variable-list). */ 311 OMP_CLAUSE_USE_DEVICE_PTR, 312 313 /* OpenMP clause: is_device_ptr (variable-list). */ 314 OMP_CLAUSE_IS_DEVICE_PTR, 315 316 /* Internal structure to hold OpenACC cache directive's variable-list. 317 #pragma acc cache (variable-list). */ 318 OMP_CLAUSE__CACHE_, 319 320 /* OpenACC clause: gang [(gang-argument-list)]. 321 Where 322 gang-argument-list: [gang-argument-list, ] gang-argument 323 gang-argument: [num:] integer-expression 324 | static: size-expression 325 size-expression: * | integer-expression. */ 326 OMP_CLAUSE_GANG, 327 328 /* OpenACC clause: async [(integer-expression)]. */ 329 OMP_CLAUSE_ASYNC, 330 331 /* OpenACC clause: wait [(integer-expression-list)]. */ 332 OMP_CLAUSE_WAIT, 333 334 /* OpenACC clause: auto. */ 335 OMP_CLAUSE_AUTO, 336 337 /* OpenACC clause: seq. */ 338 OMP_CLAUSE_SEQ, 339 340 /* Internal clause: temporary for combined loops expansion. */ 341 OMP_CLAUSE__LOOPTEMP_, 342 343 /* Internal clause: temporary for task reductions. */ 344 OMP_CLAUSE__REDUCTEMP_, 345 346 /* OpenACC/OpenMP clause: if (scalar-expression). */ 347 OMP_CLAUSE_IF, 348 349 /* OpenMP clause: num_threads (integer-expression). */ 350 OMP_CLAUSE_NUM_THREADS, 351 352 /* OpenMP clause: schedule. */ 353 OMP_CLAUSE_SCHEDULE, 354 355 /* OpenMP clause: nowait. */ 356 OMP_CLAUSE_NOWAIT, 357 358 /* OpenMP clause: ordered [(constant-integer-expression)]. */ 359 OMP_CLAUSE_ORDERED, 360 361 /* OpenACC/OpenMP clause: default. */ 362 OMP_CLAUSE_DEFAULT, 363 364 /* OpenACC/OpenMP clause: collapse (constant-integer-expression). */ 365 OMP_CLAUSE_COLLAPSE, 366 367 /* OpenMP clause: untied. */ 368 OMP_CLAUSE_UNTIED, 369 370 /* OpenMP clause: final (scalar-expression). */ 371 OMP_CLAUSE_FINAL, 372 373 /* OpenMP clause: mergeable. */ 374 OMP_CLAUSE_MERGEABLE, 375 376 /* OpenMP clause: device (integer-expression). */ 377 OMP_CLAUSE_DEVICE, 378 379 /* OpenMP clause: dist_schedule (static[:chunk-size]). */ 380 OMP_CLAUSE_DIST_SCHEDULE, 381 382 /* OpenMP clause: inbranch. */ 383 OMP_CLAUSE_INBRANCH, 384 385 /* OpenMP clause: notinbranch. */ 386 OMP_CLAUSE_NOTINBRANCH, 387 388 /* OpenMP clause: num_teams(integer-expression). */ 389 OMP_CLAUSE_NUM_TEAMS, 390 391 /* OpenMP clause: thread_limit(integer-expression). */ 392 OMP_CLAUSE_THREAD_LIMIT, 393 394 /* OpenMP clause: proc_bind ({master,close,spread}). */ 395 OMP_CLAUSE_PROC_BIND, 396 397 /* OpenMP clause: safelen (constant-integer-expression). */ 398 OMP_CLAUSE_SAFELEN, 399 400 /* OpenMP clause: simdlen (constant-integer-expression). */ 401 OMP_CLAUSE_SIMDLEN, 402 403 /* OpenMP clause: for. */ 404 OMP_CLAUSE_FOR, 405 406 /* OpenMP clause: parallel. */ 407 OMP_CLAUSE_PARALLEL, 408 409 /* OpenMP clause: sections. */ 410 OMP_CLAUSE_SECTIONS, 411 412 /* OpenMP clause: taskgroup. */ 413 OMP_CLAUSE_TASKGROUP, 414 415 /* OpenMP clause: priority (integer-expression). */ 416 OMP_CLAUSE_PRIORITY, 417 418 /* OpenMP clause: grainsize (integer-expression). */ 419 OMP_CLAUSE_GRAINSIZE, 420 421 /* OpenMP clause: num_tasks (integer-expression). */ 422 OMP_CLAUSE_NUM_TASKS, 423 424 /* OpenMP clause: nogroup. */ 425 OMP_CLAUSE_NOGROUP, 426 427 /* OpenMP clause: threads. */ 428 OMP_CLAUSE_THREADS, 429 430 /* OpenMP clause: simd. */ 431 OMP_CLAUSE_SIMD, 432 433 /* OpenMP clause: hint (integer-expression). */ 434 OMP_CLAUSE_HINT, 435 436 /* OpenMP clause: defaultmap (tofrom: scalar). */ 437 OMP_CLAUSE_DEFAULTMAP, 438 439 /* Internally used only clause, holding SIMD uid. */ 440 OMP_CLAUSE__SIMDUID_, 441 442 /* Internally used only clause, flag whether this is SIMT simd 443 loop or not. */ 444 OMP_CLAUSE__SIMT_, 445 446 /* OpenACC clause: independent. */ 447 OMP_CLAUSE_INDEPENDENT, 448 449 /* OpenACC clause: worker [( [num:] integer-expression)]. */ 450 OMP_CLAUSE_WORKER, 451 452 /* OpenACC clause: vector [( [length:] integer-expression)]. */ 453 OMP_CLAUSE_VECTOR, 454 455 /* OpenACC clause: num_gangs (integer-expression). */ 456 OMP_CLAUSE_NUM_GANGS, 457 458 /* OpenACC clause: num_workers (integer-expression). */ 459 OMP_CLAUSE_NUM_WORKERS, 460 461 /* OpenACC clause: vector_length (integer-expression). */ 462 OMP_CLAUSE_VECTOR_LENGTH, 463 464 /* OpenACC clause: tile ( size-expr-list ). */ 465 OMP_CLAUSE_TILE, 466 467 /* OpenMP internal-only clause to specify grid dimensions of a gridified 468 kernel. */ 469 OMP_CLAUSE__GRIDDIM_, 470 471 /* OpenACC clause: if_present. */ 472 OMP_CLAUSE_IF_PRESENT, 473 474 /* OpenACC clause: finalize. */ 475 OMP_CLAUSE_FINALIZE 476 }; 477 478 #undef DEFTREESTRUCT 479 #define DEFTREESTRUCT(ENUM, NAME) ENUM, 480 enum tree_node_structure_enum { 481 #include "treestruct.def" 482 LAST_TS_ENUM 483 }; 484 #undef DEFTREESTRUCT 485 486 enum omp_clause_schedule_kind { 487 OMP_CLAUSE_SCHEDULE_STATIC, 488 OMP_CLAUSE_SCHEDULE_DYNAMIC, 489 OMP_CLAUSE_SCHEDULE_GUIDED, 490 OMP_CLAUSE_SCHEDULE_AUTO, 491 OMP_CLAUSE_SCHEDULE_RUNTIME, 492 OMP_CLAUSE_SCHEDULE_MASK = (1 << 3) - 1, 493 OMP_CLAUSE_SCHEDULE_MONOTONIC = (1 << 3), 494 OMP_CLAUSE_SCHEDULE_NONMONOTONIC = (1 << 4), 495 OMP_CLAUSE_SCHEDULE_LAST = 2 * OMP_CLAUSE_SCHEDULE_NONMONOTONIC - 1 496 }; 497 498 enum omp_clause_default_kind { 499 OMP_CLAUSE_DEFAULT_UNSPECIFIED, 500 OMP_CLAUSE_DEFAULT_SHARED, 501 OMP_CLAUSE_DEFAULT_NONE, 502 OMP_CLAUSE_DEFAULT_PRIVATE, 503 OMP_CLAUSE_DEFAULT_FIRSTPRIVATE, 504 OMP_CLAUSE_DEFAULT_PRESENT, 505 OMP_CLAUSE_DEFAULT_LAST 506 }; 507 508 enum omp_clause_defaultmap_kind { 509 OMP_CLAUSE_DEFAULTMAP_CATEGORY_UNSPECIFIED, 510 OMP_CLAUSE_DEFAULTMAP_CATEGORY_SCALAR, 511 OMP_CLAUSE_DEFAULTMAP_CATEGORY_AGGREGATE, 512 OMP_CLAUSE_DEFAULTMAP_CATEGORY_ALLOCATABLE, 513 OMP_CLAUSE_DEFAULTMAP_CATEGORY_POINTER, 514 OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK = 7, 515 OMP_CLAUSE_DEFAULTMAP_ALLOC = 1 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 516 OMP_CLAUSE_DEFAULTMAP_TO = 2 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 517 OMP_CLAUSE_DEFAULTMAP_FROM = 3 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 518 OMP_CLAUSE_DEFAULTMAP_TOFROM = 4 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 519 OMP_CLAUSE_DEFAULTMAP_FIRSTPRIVATE 520 = 5 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 521 OMP_CLAUSE_DEFAULTMAP_NONE = 6 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 522 OMP_CLAUSE_DEFAULTMAP_DEFAULT 523 = 7 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1), 524 OMP_CLAUSE_DEFAULTMAP_MASK = 7 * (OMP_CLAUSE_DEFAULTMAP_CATEGORY_MASK + 1) 525 }; 526 527 /* memory-order-clause on OpenMP atomic/flush constructs or 528 argument of atomic_default_mem_order clause. */ 529 enum omp_memory_order { 530 OMP_MEMORY_ORDER_UNSPECIFIED, 531 OMP_MEMORY_ORDER_RELAXED, 532 OMP_MEMORY_ORDER_ACQUIRE, 533 OMP_MEMORY_ORDER_RELEASE, 534 OMP_MEMORY_ORDER_ACQ_REL, 535 OMP_MEMORY_ORDER_SEQ_CST 536 }; 537 538 /* There is a TYPE_QUAL value for each type qualifier. They can be 539 combined by bitwise-or to form the complete set of qualifiers for a 540 type. */ 541 enum cv_qualifier { 542 TYPE_UNQUALIFIED = 0x0, 543 TYPE_QUAL_CONST = 0x1, 544 TYPE_QUAL_VOLATILE = 0x2, 545 TYPE_QUAL_RESTRICT = 0x4, 546 TYPE_QUAL_ATOMIC = 0x8 547 }; 548 549 /* Standard named or nameless data types of the C compiler. */ 550 enum tree_index { 551 TI_ERROR_MARK, 552 TI_INTQI_TYPE, 553 TI_INTHI_TYPE, 554 TI_INTSI_TYPE, 555 TI_INTDI_TYPE, 556 TI_INTTI_TYPE, 557 558 TI_UINTQI_TYPE, 559 TI_UINTHI_TYPE, 560 TI_UINTSI_TYPE, 561 TI_UINTDI_TYPE, 562 TI_UINTTI_TYPE, 563 564 TI_ATOMICQI_TYPE, 565 TI_ATOMICHI_TYPE, 566 TI_ATOMICSI_TYPE, 567 TI_ATOMICDI_TYPE, 568 TI_ATOMICTI_TYPE, 569 570 TI_UINT16_TYPE, 571 TI_UINT32_TYPE, 572 TI_UINT64_TYPE, 573 574 TI_VOID, 575 576 TI_INTEGER_ZERO, 577 TI_INTEGER_ONE, 578 TI_INTEGER_THREE, 579 TI_INTEGER_MINUS_ONE, 580 TI_NULL_POINTER, 581 582 TI_SIZE_ZERO, 583 TI_SIZE_ONE, 584 585 TI_BITSIZE_ZERO, 586 TI_BITSIZE_ONE, 587 TI_BITSIZE_UNIT, 588 589 TI_PUBLIC, 590 TI_PROTECTED, 591 TI_PRIVATE, 592 593 TI_BOOLEAN_FALSE, 594 TI_BOOLEAN_TRUE, 595 596 TI_FLOAT_TYPE, 597 TI_DOUBLE_TYPE, 598 TI_LONG_DOUBLE_TYPE, 599 600 /* The _FloatN and _FloatNx types must be consecutive, and in the 601 same sequence as the corresponding complex types, which must also 602 be consecutive; _FloatN must come before _FloatNx; the order must 603 also be the same as in the floatn_nx_types array and the RID_* 604 values in c-common.h. This is so that iterations over these 605 types work as intended. */ 606 TI_FLOAT16_TYPE, 607 TI_FLOATN_TYPE_FIRST = TI_FLOAT16_TYPE, 608 TI_FLOATN_NX_TYPE_FIRST = TI_FLOAT16_TYPE, 609 TI_FLOAT32_TYPE, 610 TI_FLOAT64_TYPE, 611 TI_FLOAT128_TYPE, 612 TI_FLOATN_TYPE_LAST = TI_FLOAT128_TYPE, 613 #define NUM_FLOATN_TYPES (TI_FLOATN_TYPE_LAST - TI_FLOATN_TYPE_FIRST + 1) 614 TI_FLOAT32X_TYPE, 615 TI_FLOATNX_TYPE_FIRST = TI_FLOAT32X_TYPE, 616 TI_FLOAT64X_TYPE, 617 TI_FLOAT128X_TYPE, 618 TI_FLOATNX_TYPE_LAST = TI_FLOAT128X_TYPE, 619 TI_FLOATN_NX_TYPE_LAST = TI_FLOAT128X_TYPE, 620 #define NUM_FLOATNX_TYPES (TI_FLOATNX_TYPE_LAST - TI_FLOATNX_TYPE_FIRST + 1) 621 #define NUM_FLOATN_NX_TYPES (TI_FLOATN_NX_TYPE_LAST \ 622 - TI_FLOATN_NX_TYPE_FIRST \ 623 + 1) 624 625 /* Put the complex types after their component types, so that in (sequential) 626 tree streaming we can assert that their component types have already been 627 handled (see tree-streamer.c:record_common_node). */ 628 TI_COMPLEX_INTEGER_TYPE, 629 TI_COMPLEX_FLOAT_TYPE, 630 TI_COMPLEX_DOUBLE_TYPE, 631 TI_COMPLEX_LONG_DOUBLE_TYPE, 632 633 TI_COMPLEX_FLOAT16_TYPE, 634 TI_COMPLEX_FLOATN_NX_TYPE_FIRST = TI_COMPLEX_FLOAT16_TYPE, 635 TI_COMPLEX_FLOAT32_TYPE, 636 TI_COMPLEX_FLOAT64_TYPE, 637 TI_COMPLEX_FLOAT128_TYPE, 638 TI_COMPLEX_FLOAT32X_TYPE, 639 TI_COMPLEX_FLOAT64X_TYPE, 640 TI_COMPLEX_FLOAT128X_TYPE, 641 642 TI_FLOAT_PTR_TYPE, 643 TI_DOUBLE_PTR_TYPE, 644 TI_LONG_DOUBLE_PTR_TYPE, 645 TI_INTEGER_PTR_TYPE, 646 647 TI_VOID_TYPE, 648 TI_PTR_TYPE, 649 TI_CONST_PTR_TYPE, 650 TI_SIZE_TYPE, 651 TI_PID_TYPE, 652 TI_PTRDIFF_TYPE, 653 TI_VA_LIST_TYPE, 654 TI_VA_LIST_GPR_COUNTER_FIELD, 655 TI_VA_LIST_FPR_COUNTER_FIELD, 656 TI_BOOLEAN_TYPE, 657 TI_FILEPTR_TYPE, 658 TI_CONST_TM_PTR_TYPE, 659 TI_FENV_T_PTR_TYPE, 660 TI_CONST_FENV_T_PTR_TYPE, 661 TI_FEXCEPT_T_PTR_TYPE, 662 TI_CONST_FEXCEPT_T_PTR_TYPE, 663 TI_POINTER_SIZED_TYPE, 664 665 TI_DFLOAT32_TYPE, 666 TI_DFLOAT64_TYPE, 667 TI_DFLOAT128_TYPE, 668 TI_DFLOAT32_PTR_TYPE, 669 TI_DFLOAT64_PTR_TYPE, 670 TI_DFLOAT128_PTR_TYPE, 671 672 TI_VOID_LIST_NODE, 673 674 TI_MAIN_IDENTIFIER, 675 676 TI_SAT_SFRACT_TYPE, 677 TI_SAT_FRACT_TYPE, 678 TI_SAT_LFRACT_TYPE, 679 TI_SAT_LLFRACT_TYPE, 680 TI_SAT_USFRACT_TYPE, 681 TI_SAT_UFRACT_TYPE, 682 TI_SAT_ULFRACT_TYPE, 683 TI_SAT_ULLFRACT_TYPE, 684 TI_SFRACT_TYPE, 685 TI_FRACT_TYPE, 686 TI_LFRACT_TYPE, 687 TI_LLFRACT_TYPE, 688 TI_USFRACT_TYPE, 689 TI_UFRACT_TYPE, 690 TI_ULFRACT_TYPE, 691 TI_ULLFRACT_TYPE, 692 TI_SAT_SACCUM_TYPE, 693 TI_SAT_ACCUM_TYPE, 694 TI_SAT_LACCUM_TYPE, 695 TI_SAT_LLACCUM_TYPE, 696 TI_SAT_USACCUM_TYPE, 697 TI_SAT_UACCUM_TYPE, 698 TI_SAT_ULACCUM_TYPE, 699 TI_SAT_ULLACCUM_TYPE, 700 TI_SACCUM_TYPE, 701 TI_ACCUM_TYPE, 702 TI_LACCUM_TYPE, 703 TI_LLACCUM_TYPE, 704 TI_USACCUM_TYPE, 705 TI_UACCUM_TYPE, 706 TI_ULACCUM_TYPE, 707 TI_ULLACCUM_TYPE, 708 TI_QQ_TYPE, 709 TI_HQ_TYPE, 710 TI_SQ_TYPE, 711 TI_DQ_TYPE, 712 TI_TQ_TYPE, 713 TI_UQQ_TYPE, 714 TI_UHQ_TYPE, 715 TI_USQ_TYPE, 716 TI_UDQ_TYPE, 717 TI_UTQ_TYPE, 718 TI_SAT_QQ_TYPE, 719 TI_SAT_HQ_TYPE, 720 TI_SAT_SQ_TYPE, 721 TI_SAT_DQ_TYPE, 722 TI_SAT_TQ_TYPE, 723 TI_SAT_UQQ_TYPE, 724 TI_SAT_UHQ_TYPE, 725 TI_SAT_USQ_TYPE, 726 TI_SAT_UDQ_TYPE, 727 TI_SAT_UTQ_TYPE, 728 TI_HA_TYPE, 729 TI_SA_TYPE, 730 TI_DA_TYPE, 731 TI_TA_TYPE, 732 TI_UHA_TYPE, 733 TI_USA_TYPE, 734 TI_UDA_TYPE, 735 TI_UTA_TYPE, 736 TI_SAT_HA_TYPE, 737 TI_SAT_SA_TYPE, 738 TI_SAT_DA_TYPE, 739 TI_SAT_TA_TYPE, 740 TI_SAT_UHA_TYPE, 741 TI_SAT_USA_TYPE, 742 TI_SAT_UDA_TYPE, 743 TI_SAT_UTA_TYPE, 744 745 TI_OPTIMIZATION_DEFAULT, 746 TI_OPTIMIZATION_CURRENT, 747 TI_TARGET_OPTION_DEFAULT, 748 TI_TARGET_OPTION_CURRENT, 749 TI_CURRENT_TARGET_PRAGMA, 750 TI_CURRENT_OPTIMIZE_PRAGMA, 751 752 TI_MAX 753 }; 754 755 /* An enumeration of the standard C integer types. These must be 756 ordered so that shorter types appear before longer ones, and so 757 that signed types appear before unsigned ones, for the correct 758 functioning of interpret_integer() in c-lex.c. */ 759 enum integer_type_kind { 760 itk_char, 761 itk_signed_char, 762 itk_unsigned_char, 763 itk_short, 764 itk_unsigned_short, 765 itk_int, 766 itk_unsigned_int, 767 itk_long, 768 itk_unsigned_long, 769 itk_long_long, 770 itk_unsigned_long_long, 771 772 itk_intN_0, 773 itk_unsigned_intN_0, 774 itk_intN_1, 775 itk_unsigned_intN_1, 776 itk_intN_2, 777 itk_unsigned_intN_2, 778 itk_intN_3, 779 itk_unsigned_intN_3, 780 781 itk_none 782 }; 783 784 /* A pointer-to-function member type looks like: 785 786 struct { 787 __P __pfn; 788 ptrdiff_t __delta; 789 }; 790 791 If __pfn is NULL, it is a NULL pointer-to-member-function. 792 793 (Because the vtable is always the first thing in the object, we 794 don't need its offset.) If the function is virtual, then PFN is 795 one plus twice the index into the vtable; otherwise, it is just a 796 pointer to the function. 797 798 Unfortunately, using the lowest bit of PFN doesn't work in 799 architectures that don't impose alignment requirements on function 800 addresses, or that use the lowest bit to tell one ISA from another, 801 for example. For such architectures, we use the lowest bit of 802 DELTA instead of the lowest bit of the PFN, and DELTA will be 803 multiplied by 2. */ 804 enum ptrmemfunc_vbit_where_t { 805 ptrmemfunc_vbit_in_pfn, 806 ptrmemfunc_vbit_in_delta 807 }; 808 809 /* Flags that may be passed in the third argument of decl_attributes, and 810 to handler functions for attributes. */ 811 enum attribute_flags { 812 /* The type passed in is the type of a DECL, and any attributes that 813 should be passed in again to be applied to the DECL rather than the 814 type should be returned. */ 815 ATTR_FLAG_DECL_NEXT = 1, 816 /* The type passed in is a function return type, and any attributes that 817 should be passed in again to be applied to the function type rather 818 than the return type should be returned. */ 819 ATTR_FLAG_FUNCTION_NEXT = 2, 820 /* The type passed in is an array element type, and any attributes that 821 should be passed in again to be applied to the array type rather 822 than the element type should be returned. */ 823 ATTR_FLAG_ARRAY_NEXT = 4, 824 /* The type passed in is a structure, union or enumeration type being 825 created, and should be modified in place. */ 826 ATTR_FLAG_TYPE_IN_PLACE = 8, 827 /* The attributes are being applied by default to a library function whose 828 name indicates known behavior, and should be silently ignored if they 829 are not in fact compatible with the function type. */ 830 ATTR_FLAG_BUILT_IN = 16, 831 /* A given attribute has been parsed as a C++-11 attribute. */ 832 ATTR_FLAG_CXX11 = 32 833 }; 834 835 /* Types used to represent sizes. */ 836 enum size_type_kind { 837 stk_sizetype, /* Normal representation of sizes in bytes. */ 838 stk_ssizetype, /* Signed representation of sizes in bytes. */ 839 stk_bitsizetype, /* Normal representation of sizes in bits. */ 840 stk_sbitsizetype, /* Signed representation of sizes in bits. */ 841 stk_type_kind_last 842 }; 843 844 enum operand_equal_flag { 845 OEP_ONLY_CONST = 1, 846 OEP_PURE_SAME = 2, 847 OEP_MATCH_SIDE_EFFECTS = 4, 848 OEP_ADDRESS_OF = 8, 849 /* Internal within operand_equal_p: */ 850 OEP_NO_HASH_CHECK = 16, 851 /* Internal within inchash::add_expr: */ 852 OEP_HASH_CHECK = 32, 853 /* Makes operand_equal_p handle more expressions: */ 854 OEP_LEXICOGRAPHIC = 64, 855 OEP_BITWISE = 128 856 }; 857 858 /* Enum and arrays used for tree allocation stats. 859 Keep in sync with tree.c:tree_node_kind_names. */ 860 enum tree_node_kind { 861 d_kind, 862 t_kind, 863 b_kind, 864 s_kind, 865 r_kind, 866 e_kind, 867 c_kind, 868 id_kind, 869 vec_kind, 870 binfo_kind, 871 ssa_name_kind, 872 constr_kind, 873 x_kind, 874 lang_decl, 875 lang_type, 876 omp_clause_kind, 877 all_kinds 878 }; 879 880 enum annot_expr_kind { 881 annot_expr_ivdep_kind, 882 annot_expr_unroll_kind, 883 annot_expr_no_vector_kind, 884 annot_expr_vector_kind, 885 annot_expr_parallel_kind, 886 annot_expr_kind_last 887 }; 888 889 /*--------------------------------------------------------------------------- 890 Type definitions 891 ---------------------------------------------------------------------------*/ 892 /* When processing aliases at the symbol table level, we need the 893 declaration of target. For this reason we need to queue aliases and 894 process them after all declarations has been produced. */ 895 struct GTY(()) alias_pair { 896 tree decl; 897 tree target; 898 }; 899 900 /* An initialization priority. */ 901 typedef unsigned short priority_type; 902 903 /* The type of a callback function for walking over tree structure. */ 904 typedef tree (*walk_tree_fn) (tree *, int *, void *); 905 906 /* The type of a callback function that represents a custom walk_tree. */ 907 typedef tree (*walk_tree_lh) (tree *, int *, tree (*) (tree *, int *, void *), 908 void *, hash_set<tree> *); 909 910 911 /*--------------------------------------------------------------------------- 912 Main data structures 913 ---------------------------------------------------------------------------*/ 914 /* A tree node can represent a data type, a variable, an expression 915 or a statement. Each node has a TREE_CODE which says what kind of 916 thing it represents. Some common codes are: 917 INTEGER_TYPE -- represents a type of integers. 918 ARRAY_TYPE -- represents a type of pointer. 919 VAR_DECL -- represents a declared variable. 920 INTEGER_CST -- represents a constant integer value. 921 PLUS_EXPR -- represents a sum (an expression). 922 923 As for the contents of a tree node: there are some fields 924 that all nodes share. Each TREE_CODE has various special-purpose 925 fields as well. The fields of a node are never accessed directly, 926 always through accessor macros. */ 927 928 /* Every kind of tree node starts with this structure, 929 so all nodes have these fields. 930 931 See the accessor macros, defined below, for documentation of the 932 fields, and the table below which connects the fields and the 933 accessor macros. */ 934 935 struct GTY(()) tree_base { 936 ENUM_BITFIELD(tree_code) code : 16; 937 938 unsigned side_effects_flag : 1; 939 unsigned constant_flag : 1; 940 unsigned addressable_flag : 1; 941 unsigned volatile_flag : 1; 942 unsigned readonly_flag : 1; 943 unsigned asm_written_flag: 1; 944 unsigned nowarning_flag : 1; 945 unsigned visited : 1; 946 947 unsigned used_flag : 1; 948 unsigned nothrow_flag : 1; 949 unsigned static_flag : 1; 950 unsigned public_flag : 1; 951 unsigned private_flag : 1; 952 unsigned protected_flag : 1; 953 unsigned deprecated_flag : 1; 954 unsigned default_def_flag : 1; 955 956 union { 957 /* The bits in the following structure should only be used with 958 accessor macros that constrain inputs with tree checking. */ 959 struct { 960 unsigned lang_flag_0 : 1; 961 unsigned lang_flag_1 : 1; 962 unsigned lang_flag_2 : 1; 963 unsigned lang_flag_3 : 1; 964 unsigned lang_flag_4 : 1; 965 unsigned lang_flag_5 : 1; 966 unsigned lang_flag_6 : 1; 967 unsigned saturating_flag : 1; 968 969 unsigned unsigned_flag : 1; 970 unsigned packed_flag : 1; 971 unsigned user_align : 1; 972 unsigned nameless_flag : 1; 973 unsigned atomic_flag : 1; 974 unsigned spare0 : 3; 975 976 unsigned spare1 : 8; 977 978 /* This field is only used with TREE_TYPE nodes; the only reason it is 979 present in tree_base instead of tree_type is to save space. The size 980 of the field must be large enough to hold addr_space_t values. */ 981 unsigned address_space : 8; 982 } bits; 983 984 /* The following fields are present in tree_base to save space. The 985 nodes using them do not require any of the flags above and so can 986 make better use of the 4-byte sized word. */ 987 988 /* The number of HOST_WIDE_INTs in an INTEGER_CST. */ 989 struct { 990 /* The number of HOST_WIDE_INTs if the INTEGER_CST is accessed in 991 its native precision. */ 992 unsigned char unextended; 993 994 /* The number of HOST_WIDE_INTs if the INTEGER_CST is extended to 995 wider precisions based on its TYPE_SIGN. */ 996 unsigned char extended; 997 998 /* The number of HOST_WIDE_INTs if the INTEGER_CST is accessed in 999 offset_int precision, with smaller integers being extended 1000 according to their TYPE_SIGN. This is equal to one of the two 1001 fields above but is cached for speed. */ 1002 unsigned char offset; 1003 } int_length; 1004 1005 /* VEC length. This field is only used with TREE_VEC. */ 1006 int length; 1007 1008 /* This field is only used with VECTOR_CST. */ 1009 struct { 1010 /* The value of VECTOR_CST_LOG2_NPATTERNS. */ 1011 unsigned int log2_npatterns : 8; 1012 1013 /* The value of VECTOR_CST_NELTS_PER_PATTERN. */ 1014 unsigned int nelts_per_pattern : 8; 1015 1016 /* For future expansion. */ 1017 unsigned int unused : 16; 1018 } vector_cst; 1019 1020 /* SSA version number. This field is only used with SSA_NAME. */ 1021 unsigned int version; 1022 1023 /* CHREC_VARIABLE. This field is only used with POLYNOMIAL_CHREC. */ 1024 unsigned int chrec_var; 1025 1026 /* Internal function code. */ 1027 enum internal_fn ifn; 1028 1029 /* OMP_ATOMIC* memory order. */ 1030 enum omp_memory_order omp_atomic_memory_order; 1031 1032 /* The following two fields are used for MEM_REF and TARGET_MEM_REF 1033 expression trees and specify known data non-dependences. For 1034 two memory references in a function they are known to not 1035 alias if dependence_info.clique are equal and dependence_info.base 1036 are distinct. Clique number zero means there is no information, 1037 clique number one is populated from function global information 1038 and thus needs no remapping on transforms like loop unrolling. */ 1039 struct { 1040 unsigned short clique; 1041 unsigned short base; 1042 } dependence_info; 1043 } GTY((skip(""))) u; 1044 }; 1045 1046 /* The following table lists the uses of each of the above flags and 1047 for which types of nodes they are defined. 1048 1049 addressable_flag: 1050 1051 TREE_ADDRESSABLE in 1052 VAR_DECL, PARM_DECL, RESULT_DECL, FUNCTION_DECL, LABEL_DECL 1053 SSA_NAME 1054 all types 1055 CONSTRUCTOR, IDENTIFIER_NODE 1056 STMT_EXPR 1057 1058 CALL_EXPR_TAILCALL in 1059 CALL_EXPR 1060 1061 CASE_LOW_SEEN in 1062 CASE_LABEL_EXPR 1063 1064 PREDICT_EXPR_OUTCOME in 1065 PREDICT_EXPR 1066 1067 static_flag: 1068 1069 TREE_STATIC in 1070 VAR_DECL, FUNCTION_DECL 1071 CONSTRUCTOR 1072 1073 TREE_NO_TRAMPOLINE in 1074 ADDR_EXPR 1075 1076 BINFO_VIRTUAL_P in 1077 TREE_BINFO 1078 1079 TREE_SYMBOL_REFERENCED in 1080 IDENTIFIER_NODE 1081 1082 CLEANUP_EH_ONLY in 1083 TARGET_EXPR, WITH_CLEANUP_EXPR 1084 1085 TRY_CATCH_IS_CLEANUP in 1086 TRY_CATCH_EXPR 1087 1088 ASM_INPUT_P in 1089 ASM_EXPR 1090 1091 TYPE_REF_CAN_ALIAS_ALL in 1092 POINTER_TYPE, REFERENCE_TYPE 1093 1094 CASE_HIGH_SEEN in 1095 CASE_LABEL_EXPR 1096 1097 ENUM_IS_SCOPED in 1098 ENUMERAL_TYPE 1099 1100 TRANSACTION_EXPR_OUTER in 1101 TRANSACTION_EXPR 1102 1103 SSA_NAME_ANTI_RANGE_P in 1104 SSA_NAME 1105 1106 MUST_TAIL_CALL in 1107 CALL_EXPR 1108 1109 public_flag: 1110 1111 TREE_OVERFLOW in 1112 INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST 1113 1114 TREE_PUBLIC in 1115 VAR_DECL, FUNCTION_DECL 1116 IDENTIFIER_NODE 1117 1118 CONSTRUCTOR_NO_CLEARING in 1119 CONSTRUCTOR 1120 1121 ASM_VOLATILE_P in 1122 ASM_EXPR 1123 1124 CALL_EXPR_VA_ARG_PACK in 1125 CALL_EXPR 1126 1127 TYPE_CACHED_VALUES_P in 1128 all types 1129 1130 SAVE_EXPR_RESOLVED_P in 1131 SAVE_EXPR 1132 1133 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE in 1134 OMP_CLAUSE_LASTPRIVATE 1135 1136 OMP_CLAUSE_PRIVATE_DEBUG in 1137 OMP_CLAUSE_PRIVATE 1138 1139 OMP_CLAUSE_LINEAR_NO_COPYIN in 1140 OMP_CLAUSE_LINEAR 1141 1142 OMP_CLAUSE_MAP_ZERO_BIAS_ARRAY_SECTION in 1143 OMP_CLAUSE_MAP 1144 1145 OMP_CLAUSE_REDUCTION_OMP_ORIG_REF in 1146 OMP_CLAUSE_{,TASK_,IN_}REDUCTION 1147 1148 TRANSACTION_EXPR_RELAXED in 1149 TRANSACTION_EXPR 1150 1151 FALLTHROUGH_LABEL_P in 1152 LABEL_DECL 1153 1154 SSA_NAME_IS_VIRTUAL_OPERAND in 1155 SSA_NAME 1156 1157 EXPR_LOCATION_WRAPPER_P in 1158 NON_LVALUE_EXPR, VIEW_CONVERT_EXPR 1159 1160 private_flag: 1161 1162 TREE_PRIVATE in 1163 all decls 1164 1165 CALL_EXPR_RETURN_SLOT_OPT in 1166 CALL_EXPR 1167 1168 OMP_SECTION_LAST in 1169 OMP_SECTION 1170 1171 OMP_PARALLEL_COMBINED in 1172 OMP_PARALLEL 1173 1174 OMP_CLAUSE_PRIVATE_OUTER_REF in 1175 OMP_CLAUSE_PRIVATE 1176 1177 OMP_CLAUSE_LINEAR_NO_COPYOUT in 1178 OMP_CLAUSE_LINEAR 1179 1180 TYPE_REF_IS_RVALUE in 1181 REFERENCE_TYPE 1182 1183 ENUM_IS_OPAQUE in 1184 ENUMERAL_TYPE 1185 1186 protected_flag: 1187 1188 TREE_PROTECTED in 1189 BLOCK 1190 all decls 1191 1192 CALL_FROM_THUNK_P and 1193 CALL_ALLOCA_FOR_VAR_P in 1194 CALL_EXPR 1195 1196 OMP_CLAUSE_LINEAR_VARIABLE_STRIDE in 1197 OMP_CLAUSE_LINEAR 1198 1199 ASM_INLINE_P in 1200 ASM_EXPR 1201 1202 side_effects_flag: 1203 1204 TREE_SIDE_EFFECTS in 1205 all expressions 1206 all decls 1207 all constants 1208 1209 FORCED_LABEL in 1210 LABEL_DECL 1211 1212 volatile_flag: 1213 1214 TREE_THIS_VOLATILE in 1215 all expressions 1216 all decls 1217 1218 TYPE_VOLATILE in 1219 all types 1220 1221 readonly_flag: 1222 1223 TREE_READONLY in 1224 all expressions 1225 all decls 1226 1227 TYPE_READONLY in 1228 all types 1229 1230 constant_flag: 1231 1232 TREE_CONSTANT in 1233 all expressions 1234 all decls 1235 all constants 1236 1237 TYPE_SIZES_GIMPLIFIED in 1238 all types 1239 1240 unsigned_flag: 1241 1242 TYPE_UNSIGNED in 1243 all types 1244 1245 DECL_UNSIGNED in 1246 all decls 1247 1248 asm_written_flag: 1249 1250 TREE_ASM_WRITTEN in 1251 VAR_DECL, FUNCTION_DECL, TYPE_DECL 1252 RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE 1253 BLOCK, STRING_CST 1254 1255 SSA_NAME_OCCURS_IN_ABNORMAL_PHI in 1256 SSA_NAME 1257 1258 used_flag: 1259 1260 TREE_USED in 1261 all expressions 1262 all decls 1263 IDENTIFIER_NODE 1264 1265 nothrow_flag: 1266 1267 TREE_NOTHROW in 1268 CALL_EXPR 1269 FUNCTION_DECL 1270 1271 TREE_THIS_NOTRAP in 1272 INDIRECT_REF, MEM_REF, TARGET_MEM_REF, ARRAY_REF, ARRAY_RANGE_REF 1273 1274 SSA_NAME_IN_FREE_LIST in 1275 SSA_NAME 1276 1277 DECL_NONALIASED in 1278 VAR_DECL 1279 1280 deprecated_flag: 1281 1282 TREE_DEPRECATED in 1283 all decls 1284 all types 1285 1286 IDENTIFIER_TRANSPARENT_ALIAS in 1287 IDENTIFIER_NODE 1288 1289 SSA_NAME_POINTS_TO_READONLY_MEMORY in 1290 SSA_NAME 1291 1292 visited: 1293 1294 TREE_VISITED in 1295 all trees (used liberally by many passes) 1296 1297 saturating_flag: 1298 1299 TYPE_REVERSE_STORAGE_ORDER in 1300 RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, ARRAY_TYPE 1301 1302 TYPE_SATURATING in 1303 other types 1304 1305 VAR_DECL_IS_VIRTUAL_OPERAND in 1306 VAR_DECL 1307 1308 nowarning_flag: 1309 1310 TREE_NO_WARNING in 1311 all expressions 1312 all decls 1313 1314 TYPE_ARTIFICIAL in 1315 all types 1316 1317 default_def_flag: 1318 1319 TYPE_FINAL_P in 1320 RECORD_TYPE, UNION_TYPE and QUAL_UNION_TYPE 1321 1322 TYPE_VECTOR_OPAQUE in 1323 VECTOR_TYPE 1324 1325 SSA_NAME_IS_DEFAULT_DEF in 1326 SSA_NAME 1327 1328 DECL_NONLOCAL_FRAME in 1329 VAR_DECL 1330 1331 REF_REVERSE_STORAGE_ORDER in 1332 BIT_FIELD_REF, MEM_REF 1333 1334 FUNC_ADDR_BY_DESCRIPTOR in 1335 ADDR_EXPR 1336 1337 CALL_EXPR_BY_DESCRIPTOR in 1338 CALL_EXPR 1339 */ 1340 1341 struct GTY(()) tree_typed { 1342 struct tree_base base; 1343 tree type; 1344 }; 1345 1346 struct GTY(()) tree_common { 1347 struct tree_typed typed; 1348 tree chain; 1349 }; 1350 1351 struct GTY(()) tree_int_cst { 1352 struct tree_typed typed; 1353 HOST_WIDE_INT val[1]; 1354 }; 1355 1356 1357 struct GTY(()) tree_real_cst { 1358 struct tree_typed typed; 1359 struct real_value * real_cst_ptr; 1360 }; 1361 1362 struct GTY(()) tree_fixed_cst { 1363 struct tree_typed typed; 1364 struct fixed_value * fixed_cst_ptr; 1365 }; 1366 1367 struct GTY(()) tree_string { 1368 struct tree_typed typed; 1369 int length; 1370 char str[1]; 1371 }; 1372 1373 struct GTY(()) tree_complex { 1374 struct tree_typed typed; 1375 tree real; 1376 tree imag; 1377 }; 1378 1379 struct GTY(()) tree_vector { 1380 struct tree_typed typed; 1381 tree GTY ((length ("vector_cst_encoded_nelts ((tree) &%h)"))) elts[1]; 1382 }; 1383 1384 struct GTY(()) tree_poly_int_cst { 1385 struct tree_typed typed; 1386 tree coeffs[NUM_POLY_INT_COEFFS]; 1387 }; 1388 1389 struct GTY(()) tree_identifier { 1390 struct tree_common common; 1391 struct ht_identifier id; 1392 }; 1393 1394 struct GTY(()) tree_list { 1395 struct tree_common common; 1396 tree purpose; 1397 tree value; 1398 }; 1399 1400 struct GTY(()) tree_vec { 1401 struct tree_common common; 1402 tree GTY ((length ("TREE_VEC_LENGTH ((tree)&%h)"))) a[1]; 1403 }; 1404 1405 /* A single element of a CONSTRUCTOR. VALUE holds the actual value of the 1406 element. INDEX can optionally design the position of VALUE: in arrays, 1407 it is the index where VALUE has to be placed; in structures, it is the 1408 FIELD_DECL of the member. */ 1409 struct GTY(()) constructor_elt { 1410 tree index; 1411 tree value; 1412 }; 1413 1414 struct GTY(()) tree_constructor { 1415 struct tree_typed typed; 1416 vec<constructor_elt, va_gc> *elts; 1417 }; 1418 1419 enum omp_clause_depend_kind 1420 { 1421 OMP_CLAUSE_DEPEND_IN, 1422 OMP_CLAUSE_DEPEND_OUT, 1423 OMP_CLAUSE_DEPEND_INOUT, 1424 OMP_CLAUSE_DEPEND_MUTEXINOUTSET, 1425 OMP_CLAUSE_DEPEND_SOURCE, 1426 OMP_CLAUSE_DEPEND_SINK, 1427 OMP_CLAUSE_DEPEND_DEPOBJ, 1428 OMP_CLAUSE_DEPEND_LAST 1429 }; 1430 1431 enum omp_clause_proc_bind_kind 1432 { 1433 /* Numbers should match omp_proc_bind_t enum in omp.h. */ 1434 OMP_CLAUSE_PROC_BIND_FALSE = 0, 1435 OMP_CLAUSE_PROC_BIND_TRUE = 1, 1436 OMP_CLAUSE_PROC_BIND_MASTER = 2, 1437 OMP_CLAUSE_PROC_BIND_CLOSE = 3, 1438 OMP_CLAUSE_PROC_BIND_SPREAD = 4, 1439 OMP_CLAUSE_PROC_BIND_LAST 1440 }; 1441 1442 enum omp_clause_linear_kind 1443 { 1444 OMP_CLAUSE_LINEAR_DEFAULT, 1445 OMP_CLAUSE_LINEAR_REF, 1446 OMP_CLAUSE_LINEAR_VAL, 1447 OMP_CLAUSE_LINEAR_UVAL 1448 }; 1449 1450 struct GTY(()) tree_exp { 1451 struct tree_typed typed; 1452 location_t locus; 1453 tree GTY ((special ("tree_exp"), 1454 desc ("TREE_CODE ((tree) &%0)"))) 1455 operands[1]; 1456 }; 1457 1458 /* Immediate use linking structure. This structure is used for maintaining 1459 a doubly linked list of uses of an SSA_NAME. */ 1460 struct GTY(()) ssa_use_operand_t { 1461 struct ssa_use_operand_t* GTY((skip(""))) prev; 1462 struct ssa_use_operand_t* GTY((skip(""))) next; 1463 /* Immediate uses for a given SSA name are maintained as a cyclic 1464 list. To recognize the root of this list, the location field 1465 needs to point to the original SSA name. Since statements and 1466 SSA names are of different data types, we need this union. See 1467 the explanation in struct imm_use_iterator. */ 1468 union { gimple *stmt; tree ssa_name; } GTY((skip(""))) loc; 1469 tree *GTY((skip(""))) use; 1470 }; 1471 1472 struct GTY(()) tree_ssa_name { 1473 struct tree_typed typed; 1474 1475 /* _DECL wrapped by this SSA name. */ 1476 tree var; 1477 1478 /* Statement that defines this SSA name. */ 1479 gimple *def_stmt; 1480 1481 /* Value range information. */ 1482 union ssa_name_info_type { 1483 /* Pointer attributes used for alias analysis. */ 1484 struct GTY ((tag ("0"))) ptr_info_def *ptr_info; 1485 /* Value range attributes used for zero/sign extension elimination. */ 1486 struct GTY ((tag ("1"))) range_info_def *range_info; 1487 } GTY ((desc ("%1.typed.type ?" \ 1488 "!POINTER_TYPE_P (TREE_TYPE ((tree)&%1)) : 2"))) info; 1489 1490 /* Immediate uses list for this SSA_NAME. */ 1491 struct ssa_use_operand_t imm_uses; 1492 }; 1493 1494 struct GTY(()) phi_arg_d { 1495 /* imm_use MUST be the first element in struct because we do some 1496 pointer arithmetic with it. See phi_arg_index_from_use. */ 1497 struct ssa_use_operand_t imm_use; 1498 tree def; 1499 location_t locus; 1500 }; 1501 1502 struct GTY(()) tree_omp_clause { 1503 struct tree_common common; 1504 location_t locus; 1505 enum omp_clause_code code; 1506 union omp_clause_subcode { 1507 enum omp_clause_default_kind default_kind; 1508 enum omp_clause_schedule_kind schedule_kind; 1509 enum omp_clause_depend_kind depend_kind; 1510 /* See include/gomp-constants.h for enum gomp_map_kind's values. */ 1511 unsigned int map_kind; 1512 enum omp_clause_proc_bind_kind proc_bind_kind; 1513 enum tree_code reduction_code; 1514 enum omp_clause_linear_kind linear_kind; 1515 enum tree_code if_modifier; 1516 enum omp_clause_defaultmap_kind defaultmap_kind; 1517 /* The dimension a OMP_CLAUSE__GRIDDIM_ clause of a gridified target 1518 construct describes. */ 1519 unsigned int dimension; 1520 } GTY ((skip)) subcode; 1521 1522 /* The gimplification of OMP_CLAUSE_REDUCTION_{INIT,MERGE} for omp-low's 1523 usage. */ 1524 gimple_seq gimple_reduction_init; 1525 gimple_seq gimple_reduction_merge; 1526 1527 tree GTY ((length ("omp_clause_num_ops[OMP_CLAUSE_CODE ((tree)&%h)]"))) 1528 ops[1]; 1529 }; 1530 1531 struct GTY(()) tree_block { 1532 struct tree_base base; 1533 tree chain; 1534 1535 unsigned block_num; 1536 1537 location_t locus; 1538 location_t end_locus; 1539 1540 tree vars; 1541 vec<tree, va_gc> *nonlocalized_vars; 1542 1543 tree subblocks; 1544 tree supercontext; 1545 tree abstract_origin; 1546 tree fragment_origin; 1547 tree fragment_chain; 1548 1549 /* Pointer to the DWARF lexical block. */ 1550 struct die_struct *die; 1551 }; 1552 1553 struct GTY(()) tree_type_common { 1554 struct tree_common common; 1555 tree size; 1556 tree size_unit; 1557 tree attributes; 1558 unsigned int uid; 1559 1560 unsigned int precision : 10; 1561 unsigned no_force_blk_flag : 1; 1562 unsigned needs_constructing_flag : 1; 1563 unsigned transparent_aggr_flag : 1; 1564 unsigned restrict_flag : 1; 1565 unsigned contains_placeholder_bits : 2; 1566 1567 ENUM_BITFIELD(machine_mode) mode : 8; 1568 1569 unsigned string_flag : 1; 1570 unsigned lang_flag_0 : 1; 1571 unsigned lang_flag_1 : 1; 1572 unsigned lang_flag_2 : 1; 1573 unsigned lang_flag_3 : 1; 1574 unsigned lang_flag_4 : 1; 1575 unsigned lang_flag_5 : 1; 1576 unsigned lang_flag_6 : 1; 1577 unsigned lang_flag_7 : 1; 1578 1579 /* TYPE_ALIGN in log2; this has to be large enough to hold values 1580 of the maximum of BIGGEST_ALIGNMENT and MAX_OFILE_ALIGNMENT, 1581 the latter being usually the larger. For ELF it is 8<<28, 1582 so we need to store the value 32 (not 31, as we need the zero 1583 as well), hence six bits. */ 1584 unsigned align : 6; 1585 unsigned warn_if_not_align : 6; 1586 unsigned typeless_storage : 1; 1587 unsigned empty_flag : 1; 1588 unsigned spare : 17; 1589 1590 alias_set_type alias_set; 1591 tree pointer_to; 1592 tree reference_to; 1593 union tree_type_symtab { 1594 int GTY ((tag ("TYPE_SYMTAB_IS_ADDRESS"))) address; 1595 struct die_struct * GTY ((tag ("TYPE_SYMTAB_IS_DIE"))) die; 1596 } GTY ((desc ("debug_hooks->tree_type_symtab_field"))) symtab; 1597 tree canonical; 1598 tree next_variant; 1599 tree main_variant; 1600 tree context; 1601 tree name; 1602 }; 1603 1604 struct GTY(()) tree_type_with_lang_specific { 1605 struct tree_type_common common; 1606 /* Points to a structure whose details depend on the language in use. */ 1607 struct lang_type *lang_specific; 1608 }; 1609 1610 struct GTY(()) tree_type_non_common { 1611 struct tree_type_with_lang_specific with_lang_specific; 1612 tree values; 1613 tree minval; 1614 tree maxval; 1615 tree lang_1; 1616 }; 1617 1618 struct GTY (()) tree_binfo { 1619 struct tree_common common; 1620 1621 tree offset; 1622 tree vtable; 1623 tree virtuals; 1624 tree vptr_field; 1625 vec<tree, va_gc> *base_accesses; 1626 tree inheritance; 1627 1628 tree vtt_subvtt; 1629 tree vtt_vptr; 1630 1631 vec<tree, va_gc> base_binfos; 1632 }; 1633 1634 struct GTY(()) tree_decl_minimal { 1635 struct tree_common common; 1636 location_t locus; 1637 unsigned int uid; 1638 tree name; 1639 tree context; 1640 }; 1641 1642 struct GTY(()) tree_decl_common { 1643 struct tree_decl_minimal common; 1644 tree size; 1645 1646 ENUM_BITFIELD(machine_mode) mode : 8; 1647 1648 unsigned nonlocal_flag : 1; 1649 unsigned virtual_flag : 1; 1650 unsigned ignored_flag : 1; 1651 unsigned abstract_flag : 1; 1652 unsigned artificial_flag : 1; 1653 unsigned preserve_flag: 1; 1654 unsigned debug_expr_is_from : 1; 1655 1656 unsigned lang_flag_0 : 1; 1657 unsigned lang_flag_1 : 1; 1658 unsigned lang_flag_2 : 1; 1659 unsigned lang_flag_3 : 1; 1660 unsigned lang_flag_4 : 1; 1661 unsigned lang_flag_5 : 1; 1662 unsigned lang_flag_6 : 1; 1663 unsigned lang_flag_7 : 1; 1664 unsigned lang_flag_8 : 1; 1665 1666 /* In VAR_DECL and PARM_DECL, this is DECL_REGISTER 1667 IN TRANSLATION_UNIT_DECL, this is TRANSLATION_UNIT_WARN_EMPTY_P. */ 1668 unsigned decl_flag_0 : 1; 1669 /* In FIELD_DECL, this is DECL_BIT_FIELD 1670 In VAR_DECL and FUNCTION_DECL, this is DECL_EXTERNAL. 1671 In TYPE_DECL, this is TYPE_DECL_SUPPRESS_DEBUG. */ 1672 unsigned decl_flag_1 : 1; 1673 /* In FIELD_DECL, this is DECL_NONADDRESSABLE_P 1674 In VAR_DECL, PARM_DECL and RESULT_DECL, this is 1675 DECL_HAS_VALUE_EXPR_P. */ 1676 unsigned decl_flag_2 : 1; 1677 /* In FIELD_DECL, this is DECL_PADDING_P. */ 1678 unsigned decl_flag_3 : 1; 1679 /* Logically, these two would go in a theoretical base shared by var and 1680 parm decl. */ 1681 unsigned gimple_reg_flag : 1; 1682 /* In VAR_DECL, PARM_DECL and RESULT_DECL, this is DECL_BY_REFERENCE. */ 1683 unsigned decl_by_reference_flag : 1; 1684 /* In a VAR_DECL and PARM_DECL, this is DECL_READ_P. */ 1685 unsigned decl_read_flag : 1; 1686 /* In a VAR_DECL or RESULT_DECL, this is DECL_NONSHAREABLE. */ 1687 /* In a PARM_DECL, this is DECL_HIDDEN_STRING_LENGTH. */ 1688 unsigned decl_nonshareable_flag : 1; 1689 1690 /* DECL_OFFSET_ALIGN, used only for FIELD_DECLs. */ 1691 unsigned int off_align : 6; 1692 1693 /* DECL_ALIGN. It should have the same size as TYPE_ALIGN. */ 1694 unsigned int align : 6; 1695 1696 /* DECL_WARN_IF_NOT_ALIGN. It should have the same size as 1697 TYPE_WARN_IF_NOT_ALIGN. */ 1698 unsigned int warn_if_not_align : 6; 1699 1700 /* 14 bits unused. */ 1701 1702 /* UID for points-to sets, stable over copying from inlining. */ 1703 unsigned int pt_uid; 1704 1705 tree size_unit; 1706 tree initial; 1707 tree attributes; 1708 tree abstract_origin; 1709 1710 /* Points to a structure whose details depend on the language in use. */ 1711 struct lang_decl *lang_specific; 1712 }; 1713 1714 struct GTY(()) tree_decl_with_rtl { 1715 struct tree_decl_common common; 1716 rtx rtl; 1717 }; 1718 1719 struct GTY(()) tree_field_decl { 1720 struct tree_decl_common common; 1721 1722 tree offset; 1723 tree bit_field_type; 1724 tree qualifier; 1725 tree bit_offset; 1726 tree fcontext; 1727 }; 1728 1729 struct GTY(()) tree_label_decl { 1730 struct tree_decl_with_rtl common; 1731 int label_decl_uid; 1732 int eh_landing_pad_nr; 1733 }; 1734 1735 struct GTY(()) tree_result_decl { 1736 struct tree_decl_with_rtl common; 1737 }; 1738 1739 struct GTY(()) tree_const_decl { 1740 struct tree_decl_common common; 1741 }; 1742 1743 struct GTY(()) tree_parm_decl { 1744 struct tree_decl_with_rtl common; 1745 rtx incoming_rtl; 1746 }; 1747 1748 struct GTY(()) tree_decl_with_vis { 1749 struct tree_decl_with_rtl common; 1750 tree assembler_name; 1751 struct symtab_node *symtab_node; 1752 1753 /* Belong to VAR_DECL exclusively. */ 1754 unsigned defer_output : 1; 1755 unsigned hard_register : 1; 1756 unsigned common_flag : 1; 1757 unsigned in_text_section : 1; 1758 unsigned in_constant_pool : 1; 1759 unsigned dllimport_flag : 1; 1760 /* Don't belong to VAR_DECL exclusively. */ 1761 unsigned weak_flag : 1; 1762 1763 unsigned seen_in_bind_expr : 1; 1764 unsigned comdat_flag : 1; 1765 /* Used for FUNCTION_DECL, VAR_DECL and in C++ for TYPE_DECL. */ 1766 ENUM_BITFIELD(symbol_visibility) visibility : 2; 1767 unsigned visibility_specified : 1; 1768 1769 /* Belong to FUNCTION_DECL exclusively. */ 1770 unsigned init_priority_p : 1; 1771 /* Used by C++ only. Might become a generic decl flag. */ 1772 unsigned shadowed_for_var_p : 1; 1773 /* Belong to FUNCTION_DECL exclusively. */ 1774 unsigned cxx_constructor : 1; 1775 /* Belong to FUNCTION_DECL exclusively. */ 1776 unsigned cxx_destructor : 1; 1777 /* Belong to FUNCTION_DECL exclusively. */ 1778 unsigned final : 1; 1779 /* Belong to FUNCTION_DECL exclusively. */ 1780 unsigned regdecl_flag : 1; 1781 /* 14 unused bits. */ 1782 }; 1783 1784 struct GTY(()) tree_var_decl { 1785 struct tree_decl_with_vis common; 1786 }; 1787 1788 struct GTY(()) tree_decl_non_common { 1789 struct tree_decl_with_vis common; 1790 /* Almost all FE's use this. */ 1791 tree result; 1792 }; 1793 1794 /* FUNCTION_DECL inherits from DECL_NON_COMMON because of the use of the 1795 arguments/result/saved_tree fields by front ends. It was either inherit 1796 FUNCTION_DECL from non_common, or inherit non_common from FUNCTION_DECL, 1797 which seemed a bit strange. */ 1798 1799 struct GTY(()) tree_function_decl { 1800 struct tree_decl_non_common common; 1801 1802 struct function *f; 1803 1804 /* Arguments of the function. */ 1805 tree arguments; 1806 /* The personality function. Used for stack unwinding. */ 1807 tree personality; 1808 1809 /* Function specific options that are used by this function. */ 1810 tree function_specific_target; /* target options */ 1811 tree function_specific_optimization; /* optimization options */ 1812 1813 /* Generic function body. */ 1814 tree saved_tree; 1815 /* Index within a virtual table. */ 1816 tree vindex; 1817 1818 /* In a FUNCTION_DECL for which DECL_BUILT_IN holds, this is 1819 DECL_FUNCTION_CODE. Otherwise unused. 1820 ??? The bitfield needs to be able to hold all target function 1821 codes as well. */ 1822 ENUM_BITFIELD(built_in_function) function_code : 12; 1823 ENUM_BITFIELD(built_in_class) built_in_class : 2; 1824 1825 unsigned static_ctor_flag : 1; 1826 unsigned static_dtor_flag : 1; 1827 1828 unsigned uninlinable : 1; 1829 unsigned possibly_inlined : 1; 1830 unsigned novops_flag : 1; 1831 unsigned returns_twice_flag : 1; 1832 unsigned malloc_flag : 1; 1833 unsigned operator_new_flag : 1; 1834 unsigned declared_inline_flag : 1; 1835 unsigned no_inline_warning_flag : 1; 1836 1837 unsigned no_instrument_function_entry_exit : 1; 1838 unsigned no_limit_stack : 1; 1839 unsigned disregard_inline_limits : 1; 1840 unsigned pure_flag : 1; 1841 unsigned looping_const_or_pure_flag : 1; 1842 unsigned has_debug_args_flag : 1; 1843 unsigned versioned_function : 1; 1844 unsigned lambda_function: 1; 1845 /* No bits left. */ 1846 }; 1847 1848 struct GTY(()) tree_translation_unit_decl { 1849 struct tree_decl_common common; 1850 /* Source language of this translation unit. Used for DWARF output. */ 1851 const char * GTY((skip(""))) language; 1852 /* TODO: Non-optimization used to build this translation unit. */ 1853 /* TODO: Root of a partial DWARF tree for global types and decls. */ 1854 }; 1855 1856 struct GTY(()) tree_type_decl { 1857 struct tree_decl_non_common common; 1858 1859 }; 1860 1861 struct GTY ((chain_next ("%h.next"), chain_prev ("%h.prev"))) tree_statement_list_node 1862 { 1863 struct tree_statement_list_node *prev; 1864 struct tree_statement_list_node *next; 1865 tree stmt; 1866 }; 1867 1868 struct GTY(()) tree_statement_list 1869 { 1870 struct tree_typed typed; 1871 struct tree_statement_list_node *head; 1872 struct tree_statement_list_node *tail; 1873 }; 1874 1875 1876 /* Optimization options used by a function. */ 1877 1878 struct GTY(()) tree_optimization_option { 1879 struct tree_base base; 1880 1881 /* The optimization options used by the user. */ 1882 struct cl_optimization *opts; 1883 1884 /* Target optabs for this set of optimization options. This is of 1885 type `struct target_optabs *'. */ 1886 void *GTY ((atomic)) optabs; 1887 1888 /* The value of this_target_optabs against which the optabs above were 1889 generated. */ 1890 struct target_optabs *GTY ((skip)) base_optabs; 1891 }; 1892 1893 /* Forward declaration, defined in target-globals.h. */ 1894 1895 struct GTY(()) target_globals; 1896 1897 /* Target options used by a function. */ 1898 1899 struct GTY(()) tree_target_option { 1900 struct tree_base base; 1901 1902 /* Target globals for the corresponding target option. */ 1903 struct target_globals *globals; 1904 1905 /* The optimization options used by the user. */ 1906 struct cl_target_option *opts; 1907 }; 1908 1909 /* Define the overall contents of a tree node. 1910 It may be any of the structures declared above 1911 for various types of node. */ 1912 union GTY ((ptr_alias (union lang_tree_node), 1913 desc ("tree_node_structure (&%h)"), variable_size)) tree_node { 1914 struct tree_base GTY ((tag ("TS_BASE"))) base; 1915 struct tree_typed GTY ((tag ("TS_TYPED"))) typed; 1916 struct tree_common GTY ((tag ("TS_COMMON"))) common; 1917 struct tree_int_cst GTY ((tag ("TS_INT_CST"))) int_cst; 1918 struct tree_poly_int_cst GTY ((tag ("TS_POLY_INT_CST"))) poly_int_cst; 1919 struct tree_real_cst GTY ((tag ("TS_REAL_CST"))) real_cst; 1920 struct tree_fixed_cst GTY ((tag ("TS_FIXED_CST"))) fixed_cst; 1921 struct tree_vector GTY ((tag ("TS_VECTOR"))) vector; 1922 struct tree_string GTY ((tag ("TS_STRING"))) string; 1923 struct tree_complex GTY ((tag ("TS_COMPLEX"))) complex; 1924 struct tree_identifier GTY ((tag ("TS_IDENTIFIER"))) identifier; 1925 struct tree_decl_minimal GTY((tag ("TS_DECL_MINIMAL"))) decl_minimal; 1926 struct tree_decl_common GTY ((tag ("TS_DECL_COMMON"))) decl_common; 1927 struct tree_decl_with_rtl GTY ((tag ("TS_DECL_WRTL"))) decl_with_rtl; 1928 struct tree_decl_non_common GTY ((tag ("TS_DECL_NON_COMMON"))) 1929 decl_non_common; 1930 struct tree_parm_decl GTY ((tag ("TS_PARM_DECL"))) parm_decl; 1931 struct tree_decl_with_vis GTY ((tag ("TS_DECL_WITH_VIS"))) decl_with_vis; 1932 struct tree_var_decl GTY ((tag ("TS_VAR_DECL"))) var_decl; 1933 struct tree_field_decl GTY ((tag ("TS_FIELD_DECL"))) field_decl; 1934 struct tree_label_decl GTY ((tag ("TS_LABEL_DECL"))) label_decl; 1935 struct tree_result_decl GTY ((tag ("TS_RESULT_DECL"))) result_decl; 1936 struct tree_const_decl GTY ((tag ("TS_CONST_DECL"))) const_decl; 1937 struct tree_type_decl GTY ((tag ("TS_TYPE_DECL"))) type_decl; 1938 struct tree_function_decl GTY ((tag ("TS_FUNCTION_DECL"))) function_decl; 1939 struct tree_translation_unit_decl GTY ((tag ("TS_TRANSLATION_UNIT_DECL"))) 1940 translation_unit_decl; 1941 struct tree_type_common GTY ((tag ("TS_TYPE_COMMON"))) type_common; 1942 struct tree_type_with_lang_specific GTY ((tag ("TS_TYPE_WITH_LANG_SPECIFIC"))) 1943 type_with_lang_specific; 1944 struct tree_type_non_common GTY ((tag ("TS_TYPE_NON_COMMON"))) 1945 type_non_common; 1946 struct tree_list GTY ((tag ("TS_LIST"))) list; 1947 struct tree_vec GTY ((tag ("TS_VEC"))) vec; 1948 struct tree_exp GTY ((tag ("TS_EXP"))) exp; 1949 struct tree_ssa_name GTY ((tag ("TS_SSA_NAME"))) ssa_name; 1950 struct tree_block GTY ((tag ("TS_BLOCK"))) block; 1951 struct tree_binfo GTY ((tag ("TS_BINFO"))) binfo; 1952 struct tree_statement_list GTY ((tag ("TS_STATEMENT_LIST"))) stmt_list; 1953 struct tree_constructor GTY ((tag ("TS_CONSTRUCTOR"))) constructor; 1954 struct tree_omp_clause GTY ((tag ("TS_OMP_CLAUSE"))) omp_clause; 1955 struct tree_optimization_option GTY ((tag ("TS_OPTIMIZATION"))) optimization; 1956 struct tree_target_option GTY ((tag ("TS_TARGET_OPTION"))) target_option; 1957 }; 1958 1959 /* Structure describing an attribute and a function to handle it. */ 1960 struct attribute_spec { 1961 /* The name of the attribute (without any leading or trailing __), 1962 or NULL to mark the end of a table of attributes. */ 1963 const char *name; 1964 /* The minimum length of the list of arguments of the attribute. */ 1965 int min_length; 1966 /* The maximum length of the list of arguments of the attribute 1967 (-1 for no maximum). */ 1968 int max_length; 1969 /* Whether this attribute requires a DECL. If it does, it will be passed 1970 from types of DECLs, function return types and array element types to 1971 the DECLs, function types and array types respectively; but when 1972 applied to a type in any other circumstances, it will be ignored with 1973 a warning. (If greater control is desired for a given attribute, 1974 this should be false, and the flags argument to the handler may be 1975 used to gain greater control in that case.) */ 1976 bool decl_required; 1977 /* Whether this attribute requires a type. If it does, it will be passed 1978 from a DECL to the type of that DECL. */ 1979 bool type_required; 1980 /* Whether this attribute requires a function (or method) type. If it does, 1981 it will be passed from a function pointer type to the target type, 1982 and from a function return type (which is not itself a function 1983 pointer type) to the function type. */ 1984 bool function_type_required; 1985 /* Specifies if attribute affects type's identity. */ 1986 bool affects_type_identity; 1987 /* Function to handle this attribute. NODE points to the node to which 1988 the attribute is to be applied. If a DECL, it should be modified in 1989 place; if a TYPE, a copy should be created. NAME is the canonicalized 1990 name of the attribute i.e. without any leading or trailing underscores. 1991 ARGS is the TREE_LIST of the arguments (which may be NULL). FLAGS gives 1992 further information about the context of the attribute. Afterwards, the 1993 attributes will be added to the DECL_ATTRIBUTES or TYPE_ATTRIBUTES, as 1994 appropriate, unless *NO_ADD_ATTRS is set to true (which should be done on 1995 error, as well as in any other cases when the attributes should not be 1996 added to the DECL or TYPE). Depending on FLAGS, any attributes to be 1997 applied to another type or DECL later may be returned; 1998 otherwise the return value should be NULL_TREE. This pointer may be 1999 NULL if no special handling is required beyond the checks implied 2000 by the rest of this structure. */ 2001 tree (*handler) (tree *node, tree name, tree args, 2002 int flags, bool *no_add_attrs); 2003 2004 /* Specifies the name of an attribute that's mutually exclusive with 2005 this one, and whether the relationship applies to the function, 2006 variable, or type form of the attribute. */ 2007 struct exclusions { 2008 const char *name; 2009 bool function; 2010 bool variable; 2011 bool type; 2012 }; 2013 2014 /* An array of attribute exclusions describing names of other attributes 2015 that this attribute is mutually exclusive with. */ 2016 const exclusions *exclude; 2017 }; 2018 2019 /* These functions allow a front-end to perform a manual layout of a 2020 RECORD_TYPE. (For instance, if the placement of subsequent fields 2021 depends on the placement of fields so far.) Begin by calling 2022 start_record_layout. Then, call place_field for each of the 2023 fields. Then, call finish_record_layout. See layout_type for the 2024 default way in which these functions are used. */ 2025 typedef struct record_layout_info_s { 2026 /* The RECORD_TYPE that we are laying out. */ 2027 tree t; 2028 /* The offset into the record so far, in bytes, not including bits in 2029 BITPOS. */ 2030 tree offset; 2031 /* The last known alignment of SIZE. */ 2032 unsigned int offset_align; 2033 /* The bit position within the last OFFSET_ALIGN bits, in bits. */ 2034 tree bitpos; 2035 /* The alignment of the record so far, in bits. */ 2036 unsigned int record_align; 2037 /* The alignment of the record so far, ignoring #pragma pack and 2038 __attribute__ ((packed)), in bits. */ 2039 unsigned int unpacked_align; 2040 /* The previous field laid out. */ 2041 tree prev_field; 2042 /* The static variables (i.e., class variables, as opposed to 2043 instance variables) encountered in T. */ 2044 vec<tree, va_gc> *pending_statics; 2045 /* Bits remaining in the current alignment group */ 2046 int remaining_in_alignment; 2047 /* True if we've seen a packed field that didn't have normal 2048 alignment anyway. */ 2049 int packed_maybe_necessary; 2050 } *record_layout_info; 2051 2052 /* Iterator for going through the function arguments. */ 2053 struct function_args_iterator { 2054 tree next; /* TREE_LIST pointing to the next argument */ 2055 }; 2056 2057 /* Structures to map from a tree to another tree. */ 2058 struct GTY(()) tree_map_base { 2059 tree from; 2060 }; 2061 2062 /* Map from a tree to another tree. */ 2063 2064 struct GTY((for_user)) tree_map { 2065 struct tree_map_base base; 2066 unsigned int hash; 2067 tree to; 2068 }; 2069 2070 /* Map from a decl tree to another tree. */ 2071 struct GTY((for_user)) tree_decl_map { 2072 struct tree_map_base base; 2073 tree to; 2074 }; 2075 2076 /* Map from a tree to an int. */ 2077 struct GTY((for_user)) tree_int_map { 2078 struct tree_map_base base; 2079 unsigned int to; 2080 }; 2081 2082 /* Map from a decl tree to a tree vector. */ 2083 struct GTY((for_user)) tree_vec_map { 2084 struct tree_map_base base; 2085 vec<tree, va_gc> *to; 2086 }; 2087 2088 /* Abstract iterators for CALL_EXPRs. These static inline definitions 2089 have to go towards the end of tree.h so that union tree_node is fully 2090 defined by this point. */ 2091 2092 /* Structure containing iterator state. */ 2093 struct call_expr_arg_iterator { 2094 tree t; /* the call_expr */ 2095 int n; /* argument count */ 2096 int i; /* next argument index */ 2097 }; 2098 2099 struct const_call_expr_arg_iterator { 2100 const_tree t; /* the call_expr */ 2101 int n; /* argument count */ 2102 int i; /* next argument index */ 2103 }; 2104 2105 /* The builtin_info structure holds the FUNCTION_DECL of the standard builtin 2106 function, and flags. */ 2107 struct GTY(()) builtin_info_type { 2108 tree decl; 2109 /* Whether the user can use <xxx> instead of explicitly using calls 2110 to __builtin_<xxx>. */ 2111 unsigned implicit_p : 1; 2112 /* Whether the user has provided a declaration of <xxx>. */ 2113 unsigned declared_p : 1; 2114 }; 2115 2116 /* Information about a _FloatN or _FloatNx type that may be 2117 supported. */ 2118 struct floatn_type_info { 2119 /* The number N in the type name. */ 2120 int n; 2121 /* Whether it is an extended type _FloatNx (true) or an interchange 2122 type (false). */ 2123 bool extended; 2124 }; 2125 2126 2127 /*--------------------------------------------------------------------------- 2128 Global variables 2129 ---------------------------------------------------------------------------*/ 2130 /* Matrix describing the structures contained in a given tree code. */ 2131 extern bool tree_contains_struct[MAX_TREE_CODES][64]; 2132 2133 /* Class of tree given its code. */ 2134 extern const enum tree_code_class tree_code_type[]; 2135 2136 /* Each tree code class has an associated string representation. 2137 These must correspond to the tree_code_class entries. */ 2138 extern const char *const tree_code_class_strings[]; 2139 2140 /* Number of argument-words in each kind of tree-node. */ 2141 extern const unsigned char tree_code_length[]; 2142 2143 /* Vector of all alias pairs for global symbols. */ 2144 extern GTY(()) vec<alias_pair, va_gc> *alias_pairs; 2145 2146 /* Names of all the built_in classes. */ 2147 extern const char *const built_in_class_names[BUILT_IN_LAST]; 2148 2149 /* Names of all the built_in functions. */ 2150 extern const char * built_in_names[(int) END_BUILTINS]; 2151 2152 /* Number of operands and names for each OMP_CLAUSE node. */ 2153 extern unsigned const char omp_clause_num_ops[]; 2154 extern const char * const omp_clause_code_name[]; 2155 2156 /* A vector of all translation-units. */ 2157 extern GTY (()) vec<tree, va_gc> *all_translation_units; 2158 2159 /* Vector of standard trees used by the C compiler. */ 2160 extern GTY(()) tree global_trees[TI_MAX]; 2161 2162 /* The standard C integer types. Use integer_type_kind to index into 2163 this array. */ 2164 extern GTY(()) tree integer_types[itk_none]; 2165 2166 /* Types used to represent sizes. */ 2167 extern GTY(()) tree sizetype_tab[(int) stk_type_kind_last]; 2168 2169 /* Arrays for keeping track of tree node statistics. */ 2170 extern uint64_t tree_node_counts[]; 2171 extern uint64_t tree_node_sizes[]; 2172 2173 /* True if we are in gimple form and the actions of the folders need to 2174 be restricted. False if we are not in gimple form and folding is not 2175 restricted to creating gimple expressions. */ 2176 extern bool in_gimple_form; 2177 2178 /* Functional interface to the builtin functions. */ 2179 extern GTY(()) builtin_info_type builtin_info[(int)END_BUILTINS]; 2180 2181 /* If nonzero, an upper limit on alignment of structure fields, in bits, */ 2182 extern unsigned int maximum_field_alignment; 2183 2184 /* Points to the FUNCTION_DECL of the function whose body we are reading. */ 2185 extern GTY(()) tree current_function_decl; 2186 2187 /* Nonzero means a FUNC_BEGIN label was emitted. */ 2188 extern GTY(()) const char * current_function_func_begin_label; 2189 2190 /* Information about the _FloatN and _FloatNx types. */ 2191 extern const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES]; 2192 2193 #endif // GCC_TREE_CORE_H 2194