gimple.h revision 1.6
1/* Gimple IR definitions. 2 3 Copyright (C) 2007-2016 Free Software Foundation, Inc. 4 Contributed by Aldy Hernandez <aldyh@redhat.com> 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 3, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING3. If not see 20<http://www.gnu.org/licenses/>. */ 21 22#ifndef GCC_GIMPLE_H 23#define GCC_GIMPLE_H 24 25#include "tree-ssa-alias.h" 26#include "gimple-expr.h" 27 28typedef gimple *gimple_seq_node; 29 30enum gimple_code { 31#define DEFGSCODE(SYM, STRING, STRUCT) SYM, 32#include "gimple.def" 33#undef DEFGSCODE 34 LAST_AND_UNUSED_GIMPLE_CODE 35}; 36 37extern const char *const gimple_code_name[]; 38extern const unsigned char gimple_rhs_class_table[]; 39 40/* Strip the outermost pointer, from tr1/type_traits. */ 41template<typename T> struct remove_pointer { typedef T type; }; 42template<typename T> struct remove_pointer<T *> { typedef T type; }; 43 44/* Error out if a gimple tuple is addressed incorrectly. */ 45#if defined ENABLE_GIMPLE_CHECKING 46#define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR) 47extern void gimple_check_failed (const gimple *, const char *, int, \ 48 const char *, enum gimple_code, \ 49 enum tree_code) ATTRIBUTE_NORETURN; 50 51#define GIMPLE_CHECK(GS, CODE) \ 52 do { \ 53 const gimple *__gs = (GS); \ 54 if (gimple_code (__gs) != (CODE)) \ 55 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \ 56 (CODE), ERROR_MARK); \ 57 } while (0) 58template <typename T> 59static inline T 60GIMPLE_CHECK2(const gimple *gs, 61#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) 62 const char *file = __builtin_FILE (), 63 int line = __builtin_LINE (), 64 const char *fun = __builtin_FUNCTION ()) 65#else 66 const char *file = __FILE__, 67 int line = __LINE__, 68 const char *fun = NULL) 69#endif 70{ 71 T ret = dyn_cast <T> (gs); 72 if (!ret) 73 gimple_check_failed (gs, file, line, fun, 74 remove_pointer<T>::type::code_, ERROR_MARK); 75 return ret; 76} 77template <typename T> 78static inline T 79GIMPLE_CHECK2(gimple *gs, 80#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8) 81 const char *file = __builtin_FILE (), 82 int line = __builtin_LINE (), 83 const char *fun = __builtin_FUNCTION ()) 84#else 85 const char *file = __FILE__, 86 int line = __LINE__, 87 const char *fun = NULL) 88#endif 89{ 90 T ret = dyn_cast <T> (gs); 91 if (!ret) 92 gimple_check_failed (gs, file, line, fun, 93 remove_pointer<T>::type::code_, ERROR_MARK); 94 return ret; 95} 96#else /* not ENABLE_GIMPLE_CHECKING */ 97#define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR))) 98#define GIMPLE_CHECK(GS, CODE) (void)0 99template <typename T> 100static inline T 101GIMPLE_CHECK2(gimple *gs) 102{ 103 return as_a <T> (gs); 104} 105template <typename T> 106static inline T 107GIMPLE_CHECK2(const gimple *gs) 108{ 109 return as_a <T> (gs); 110} 111#endif 112 113/* Class of GIMPLE expressions suitable for the RHS of assignments. See 114 get_gimple_rhs_class. */ 115enum gimple_rhs_class 116{ 117 GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */ 118 GIMPLE_TERNARY_RHS, /* The expression is a ternary operation. */ 119 GIMPLE_BINARY_RHS, /* The expression is a binary operation. */ 120 GIMPLE_UNARY_RHS, /* The expression is a unary operation. */ 121 GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA 122 name, a _DECL, a _REF, etc. */ 123}; 124 125/* Specific flags for individual GIMPLE statements. These flags are 126 always stored in gimple.subcode and they may only be 127 defined for statement codes that do not use subcodes. 128 129 Values for the masks can overlap as long as the overlapping values 130 are never used in the same statement class. 131 132 The maximum mask value that can be defined is 1 << 15 (i.e., each 133 statement code can hold up to 16 bitflags). 134 135 Keep this list sorted. */ 136enum gf_mask { 137 GF_ASM_INPUT = 1 << 0, 138 GF_ASM_VOLATILE = 1 << 1, 139 GF_CALL_FROM_THUNK = 1 << 0, 140 GF_CALL_RETURN_SLOT_OPT = 1 << 1, 141 GF_CALL_TAILCALL = 1 << 2, 142 GF_CALL_VA_ARG_PACK = 1 << 3, 143 GF_CALL_NOTHROW = 1 << 4, 144 GF_CALL_ALLOCA_FOR_VAR = 1 << 5, 145 GF_CALL_INTERNAL = 1 << 6, 146 GF_CALL_CTRL_ALTERING = 1 << 7, 147 GF_CALL_WITH_BOUNDS = 1 << 8, 148 GF_OMP_PARALLEL_COMBINED = 1 << 0, 149 GF_OMP_PARALLEL_GRID_PHONY = 1 << 1, 150 GF_OMP_TASK_TASKLOOP = 1 << 0, 151 GF_OMP_FOR_KIND_MASK = (1 << 4) - 1, 152 GF_OMP_FOR_KIND_FOR = 0, 153 GF_OMP_FOR_KIND_DISTRIBUTE = 1, 154 GF_OMP_FOR_KIND_TASKLOOP = 2, 155 GF_OMP_FOR_KIND_CILKFOR = 3, 156 GF_OMP_FOR_KIND_OACC_LOOP = 4, 157 GF_OMP_FOR_KIND_GRID_LOOP = 5, 158 /* Flag for SIMD variants of OMP_FOR kinds. */ 159 GF_OMP_FOR_SIMD = 1 << 3, 160 GF_OMP_FOR_KIND_SIMD = GF_OMP_FOR_SIMD | 0, 161 GF_OMP_FOR_KIND_CILKSIMD = GF_OMP_FOR_SIMD | 1, 162 GF_OMP_FOR_COMBINED = 1 << 4, 163 GF_OMP_FOR_COMBINED_INTO = 1 << 5, 164 GF_OMP_FOR_GRID_PHONY = 1 << 6, 165 GF_OMP_TARGET_KIND_MASK = (1 << 4) - 1, 166 GF_OMP_TARGET_KIND_REGION = 0, 167 GF_OMP_TARGET_KIND_DATA = 1, 168 GF_OMP_TARGET_KIND_UPDATE = 2, 169 GF_OMP_TARGET_KIND_ENTER_DATA = 3, 170 GF_OMP_TARGET_KIND_EXIT_DATA = 4, 171 GF_OMP_TARGET_KIND_OACC_PARALLEL = 5, 172 GF_OMP_TARGET_KIND_OACC_KERNELS = 6, 173 GF_OMP_TARGET_KIND_OACC_DATA = 7, 174 GF_OMP_TARGET_KIND_OACC_UPDATE = 8, 175 GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA = 9, 176 GF_OMP_TARGET_KIND_OACC_DECLARE = 10, 177 GF_OMP_TARGET_KIND_OACC_HOST_DATA = 11, 178 GF_OMP_TEAMS_GRID_PHONY = 1 << 0, 179 180 /* True on an GIMPLE_OMP_RETURN statement if the return does not require 181 a thread synchronization via some sort of barrier. The exact barrier 182 that would otherwise be emitted is dependent on the OMP statement with 183 which this return is associated. */ 184 GF_OMP_RETURN_NOWAIT = 1 << 0, 185 186 GF_OMP_SECTION_LAST = 1 << 0, 187 GF_OMP_ATOMIC_NEED_VALUE = 1 << 0, 188 GF_OMP_ATOMIC_SEQ_CST = 1 << 1, 189 GF_PREDICT_TAKEN = 1 << 15 190}; 191 192/* Currently, there are only two types of gimple debug stmt. Others are 193 envisioned, for example, to enable the generation of is_stmt notes 194 in line number information, to mark sequence points, etc. This 195 subcode is to be used to tell them apart. */ 196enum gimple_debug_subcode { 197 GIMPLE_DEBUG_BIND = 0, 198 GIMPLE_DEBUG_SOURCE_BIND = 1 199}; 200 201/* Masks for selecting a pass local flag (PLF) to work on. These 202 masks are used by gimple_set_plf and gimple_plf. */ 203enum plf_mask { 204 GF_PLF_1 = 1 << 0, 205 GF_PLF_2 = 1 << 1 206}; 207 208/* Data structure definitions for GIMPLE tuples. NOTE: word markers 209 are for 64 bit hosts. */ 210 211struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"), 212 chain_next ("%h.next"), variable_size)) 213 gimple 214{ 215 /* [ WORD 1 ] 216 Main identifying code for a tuple. */ 217 ENUM_BITFIELD(gimple_code) code : 8; 218 219 /* Nonzero if a warning should not be emitted on this tuple. */ 220 unsigned int no_warning : 1; 221 222 /* Nonzero if this tuple has been visited. Passes are responsible 223 for clearing this bit before using it. */ 224 unsigned int visited : 1; 225 226 /* Nonzero if this tuple represents a non-temporal move. */ 227 unsigned int nontemporal_move : 1; 228 229 /* Pass local flags. These flags are free for any pass to use as 230 they see fit. Passes should not assume that these flags contain 231 any useful value when the pass starts. Any initial state that 232 the pass requires should be set on entry to the pass. See 233 gimple_set_plf and gimple_plf for usage. */ 234 unsigned int plf : 2; 235 236 /* Nonzero if this statement has been modified and needs to have its 237 operands rescanned. */ 238 unsigned modified : 1; 239 240 /* Nonzero if this statement contains volatile operands. */ 241 unsigned has_volatile_ops : 1; 242 243 /* Padding to get subcode to 16 bit alignment. */ 244 unsigned pad : 1; 245 246 /* The SUBCODE field can be used for tuple-specific flags for tuples 247 that do not require subcodes. Note that SUBCODE should be at 248 least as wide as tree codes, as several tuples store tree codes 249 in there. */ 250 unsigned int subcode : 16; 251 252 /* UID of this statement. This is used by passes that want to 253 assign IDs to statements. It must be assigned and used by each 254 pass. By default it should be assumed to contain garbage. */ 255 unsigned uid; 256 257 /* [ WORD 2 ] 258 Locus information for debug info. */ 259 location_t location; 260 261 /* Number of operands in this tuple. */ 262 unsigned num_ops; 263 264 /* [ WORD 3 ] 265 Basic block holding this statement. */ 266 basic_block bb; 267 268 /* [ WORD 4-5 ] 269 Linked lists of gimple statements. The next pointers form 270 a NULL terminated list, the prev pointers are a cyclic list. 271 A gimple statement is hence also a double-ended list of 272 statements, with the pointer itself being the first element, 273 and the prev pointer being the last. */ 274 gimple *next; 275 gimple *GTY((skip)) prev; 276}; 277 278 279/* Base structure for tuples with operands. */ 280 281/* This gimple subclass has no tag value. */ 282struct GTY(()) 283 gimple_statement_with_ops_base : public gimple 284{ 285 /* [ WORD 1-6 ] : base class */ 286 287 /* [ WORD 7 ] 288 SSA operand vectors. NOTE: It should be possible to 289 amalgamate these vectors with the operand vector OP. However, 290 the SSA operand vectors are organized differently and contain 291 more information (like immediate use chaining). */ 292 struct use_optype_d GTY((skip (""))) *use_ops; 293}; 294 295 296/* Statements that take register operands. */ 297 298struct GTY((tag("GSS_WITH_OPS"))) 299 gimple_statement_with_ops : public gimple_statement_with_ops_base 300{ 301 /* [ WORD 1-7 ] : base class */ 302 303 /* [ WORD 8 ] 304 Operand vector. NOTE! This must always be the last field 305 of this structure. In particular, this means that this 306 structure cannot be embedded inside another one. */ 307 tree GTY((length ("%h.num_ops"))) op[1]; 308}; 309 310 311/* Base for statements that take both memory and register operands. */ 312 313struct GTY((tag("GSS_WITH_MEM_OPS_BASE"))) 314 gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base 315{ 316 /* [ WORD 1-7 ] : base class */ 317 318 /* [ WORD 8-9 ] 319 Virtual operands for this statement. The GC will pick them 320 up via the ssa_names array. */ 321 tree GTY((skip (""))) vdef; 322 tree GTY((skip (""))) vuse; 323}; 324 325 326/* Statements that take both memory and register operands. */ 327 328struct GTY((tag("GSS_WITH_MEM_OPS"))) 329 gimple_statement_with_memory_ops : 330 public gimple_statement_with_memory_ops_base 331{ 332 /* [ WORD 1-9 ] : base class */ 333 334 /* [ WORD 10 ] 335 Operand vector. NOTE! This must always be the last field 336 of this structure. In particular, this means that this 337 structure cannot be embedded inside another one. */ 338 tree GTY((length ("%h.num_ops"))) op[1]; 339}; 340 341 342/* Call statements that take both memory and register operands. */ 343 344struct GTY((tag("GSS_CALL"))) 345 gcall : public gimple_statement_with_memory_ops_base 346{ 347 /* [ WORD 1-9 ] : base class */ 348 349 /* [ WORD 10-13 ] */ 350 struct pt_solution call_used; 351 struct pt_solution call_clobbered; 352 353 /* [ WORD 14 ] */ 354 union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) { 355 tree GTY ((tag ("0"))) fntype; 356 enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn; 357 } u; 358 359 /* [ WORD 15 ] 360 Operand vector. NOTE! This must always be the last field 361 of this structure. In particular, this means that this 362 structure cannot be embedded inside another one. */ 363 tree GTY((length ("%h.num_ops"))) op[1]; 364 365 static const enum gimple_code code_ = GIMPLE_CALL; 366}; 367 368 369/* OMP statements. */ 370 371struct GTY((tag("GSS_OMP"))) 372 gimple_statement_omp : public gimple 373{ 374 /* [ WORD 1-6 ] : base class */ 375 376 /* [ WORD 7 ] */ 377 gimple_seq body; 378}; 379 380 381/* GIMPLE_BIND */ 382 383struct GTY((tag("GSS_BIND"))) 384 gbind : public gimple 385{ 386 /* [ WORD 1-6 ] : base class */ 387 388 /* [ WORD 7 ] 389 Variables declared in this scope. */ 390 tree vars; 391 392 /* [ WORD 8 ] 393 This is different than the BLOCK field in gimple, 394 which is analogous to TREE_BLOCK (i.e., the lexical block holding 395 this statement). This field is the equivalent of BIND_EXPR_BLOCK 396 in tree land (i.e., the lexical scope defined by this bind). See 397 gimple-low.c. */ 398 tree block; 399 400 /* [ WORD 9 ] */ 401 gimple_seq body; 402}; 403 404 405/* GIMPLE_CATCH */ 406 407struct GTY((tag("GSS_CATCH"))) 408 gcatch : public gimple 409{ 410 /* [ WORD 1-6 ] : base class */ 411 412 /* [ WORD 7 ] */ 413 tree types; 414 415 /* [ WORD 8 ] */ 416 gimple_seq handler; 417}; 418 419 420/* GIMPLE_EH_FILTER */ 421 422struct GTY((tag("GSS_EH_FILTER"))) 423 geh_filter : public gimple 424{ 425 /* [ WORD 1-6 ] : base class */ 426 427 /* [ WORD 7 ] 428 Filter types. */ 429 tree types; 430 431 /* [ WORD 8 ] 432 Failure actions. */ 433 gimple_seq failure; 434}; 435 436/* GIMPLE_EH_ELSE */ 437 438struct GTY((tag("GSS_EH_ELSE"))) 439 geh_else : public gimple 440{ 441 /* [ WORD 1-6 ] : base class */ 442 443 /* [ WORD 7,8 ] */ 444 gimple_seq n_body, e_body; 445}; 446 447/* GIMPLE_EH_MUST_NOT_THROW */ 448 449struct GTY((tag("GSS_EH_MNT"))) 450 geh_mnt : public gimple 451{ 452 /* [ WORD 1-6 ] : base class */ 453 454 /* [ WORD 7 ] Abort function decl. */ 455 tree fndecl; 456}; 457 458/* GIMPLE_PHI */ 459 460struct GTY((tag("GSS_PHI"))) 461 gphi : public gimple 462{ 463 /* [ WORD 1-6 ] : base class */ 464 465 /* [ WORD 7 ] */ 466 unsigned capacity; 467 unsigned nargs; 468 469 /* [ WORD 8 ] */ 470 tree result; 471 472 /* [ WORD 9 ] */ 473 struct phi_arg_d GTY ((length ("%h.nargs"))) args[1]; 474}; 475 476 477/* GIMPLE_RESX, GIMPLE_EH_DISPATCH */ 478 479struct GTY((tag("GSS_EH_CTRL"))) 480 gimple_statement_eh_ctrl : public gimple 481{ 482 /* [ WORD 1-6 ] : base class */ 483 484 /* [ WORD 7 ] 485 Exception region number. */ 486 int region; 487}; 488 489struct GTY((tag("GSS_EH_CTRL"))) 490 gresx : public gimple_statement_eh_ctrl 491{ 492 /* No extra fields; adds invariant: 493 stmt->code == GIMPLE_RESX. */ 494}; 495 496struct GTY((tag("GSS_EH_CTRL"))) 497 geh_dispatch : public gimple_statement_eh_ctrl 498{ 499 /* No extra fields; adds invariant: 500 stmt->code == GIMPLE_EH_DISPATH. */ 501}; 502 503 504/* GIMPLE_TRY */ 505 506struct GTY((tag("GSS_TRY"))) 507 gtry : public gimple 508{ 509 /* [ WORD 1-6 ] : base class */ 510 511 /* [ WORD 7 ] 512 Expression to evaluate. */ 513 gimple_seq eval; 514 515 /* [ WORD 8 ] 516 Cleanup expression. */ 517 gimple_seq cleanup; 518}; 519 520/* Kind of GIMPLE_TRY statements. */ 521enum gimple_try_flags 522{ 523 /* A try/catch. */ 524 GIMPLE_TRY_CATCH = 1 << 0, 525 526 /* A try/finally. */ 527 GIMPLE_TRY_FINALLY = 1 << 1, 528 GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY, 529 530 /* Analogous to TRY_CATCH_IS_CLEANUP. */ 531 GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2 532}; 533 534/* GIMPLE_WITH_CLEANUP_EXPR */ 535 536struct GTY((tag("GSS_WCE"))) 537 gimple_statement_wce : public gimple 538{ 539 /* [ WORD 1-6 ] : base class */ 540 541 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be 542 executed if an exception is thrown, not on normal exit of its 543 scope. This flag is analogous to the CLEANUP_EH_ONLY flag 544 in TARGET_EXPRs. */ 545 546 /* [ WORD 7 ] 547 Cleanup expression. */ 548 gimple_seq cleanup; 549}; 550 551 552/* GIMPLE_ASM */ 553 554struct GTY((tag("GSS_ASM"))) 555 gasm : public gimple_statement_with_memory_ops_base 556{ 557 /* [ WORD 1-9 ] : base class */ 558 559 /* [ WORD 10 ] 560 __asm__ statement. */ 561 const char *string; 562 563 /* [ WORD 11 ] 564 Number of inputs, outputs, clobbers, labels. */ 565 unsigned char ni; 566 unsigned char no; 567 unsigned char nc; 568 unsigned char nl; 569 570 /* [ WORD 12 ] 571 Operand vector. NOTE! This must always be the last field 572 of this structure. In particular, this means that this 573 structure cannot be embedded inside another one. */ 574 tree GTY((length ("%h.num_ops"))) op[1]; 575}; 576 577/* GIMPLE_OMP_CRITICAL */ 578 579struct GTY((tag("GSS_OMP_CRITICAL"))) 580 gomp_critical : public gimple_statement_omp 581{ 582 /* [ WORD 1-7 ] : base class */ 583 584 /* [ WORD 8 ] */ 585 tree clauses; 586 587 /* [ WORD 9 ] 588 Critical section name. */ 589 tree name; 590}; 591 592 593struct GTY(()) gimple_omp_for_iter { 594 /* Condition code. */ 595 enum tree_code cond; 596 597 /* Index variable. */ 598 tree index; 599 600 /* Initial value. */ 601 tree initial; 602 603 /* Final value. */ 604 tree final; 605 606 /* Increment. */ 607 tree incr; 608}; 609 610/* GIMPLE_OMP_FOR */ 611 612struct GTY((tag("GSS_OMP_FOR"))) 613 gomp_for : public gimple_statement_omp 614{ 615 /* [ WORD 1-7 ] : base class */ 616 617 /* [ WORD 8 ] */ 618 tree clauses; 619 620 /* [ WORD 9 ] 621 Number of elements in iter array. */ 622 size_t collapse; 623 624 /* [ WORD 10 ] */ 625 struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter; 626 627 /* [ WORD 11 ] 628 Pre-body evaluated before the loop body begins. */ 629 gimple_seq pre_body; 630}; 631 632 633/* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK */ 634 635struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT"))) 636 gimple_statement_omp_parallel_layout : public gimple_statement_omp 637{ 638 /* [ WORD 1-7 ] : base class */ 639 640 /* [ WORD 8 ] 641 Clauses. */ 642 tree clauses; 643 644 /* [ WORD 9 ] 645 Child function holding the body of the parallel region. */ 646 tree child_fn; 647 648 /* [ WORD 10 ] 649 Shared data argument. */ 650 tree data_arg; 651}; 652 653/* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */ 654struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT"))) 655 gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout 656{ 657 /* No extra fields; adds invariant: 658 stmt->code == GIMPLE_OMP_PARALLEL 659 || stmt->code == GIMPLE_OMP_TASK. */ 660}; 661 662/* GIMPLE_OMP_PARALLEL */ 663struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT"))) 664 gomp_parallel : public gimple_statement_omp_taskreg 665{ 666 /* No extra fields; adds invariant: 667 stmt->code == GIMPLE_OMP_PARALLEL. */ 668}; 669 670/* GIMPLE_OMP_TARGET */ 671struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT"))) 672 gomp_target : public gimple_statement_omp_parallel_layout 673{ 674 /* No extra fields; adds invariant: 675 stmt->code == GIMPLE_OMP_TARGET. */ 676}; 677 678/* GIMPLE_OMP_TASK */ 679 680struct GTY((tag("GSS_OMP_TASK"))) 681 gomp_task : public gimple_statement_omp_taskreg 682{ 683 /* [ WORD 1-10 ] : base class */ 684 685 /* [ WORD 11 ] 686 Child function holding firstprivate initialization if needed. */ 687 tree copy_fn; 688 689 /* [ WORD 12-13 ] 690 Size and alignment in bytes of the argument data block. */ 691 tree arg_size; 692 tree arg_align; 693}; 694 695 696/* GIMPLE_OMP_SECTION */ 697/* Uses struct gimple_statement_omp. */ 698 699 700/* GIMPLE_OMP_SECTIONS */ 701 702struct GTY((tag("GSS_OMP_SECTIONS"))) 703 gomp_sections : public gimple_statement_omp 704{ 705 /* [ WORD 1-7 ] : base class */ 706 707 /* [ WORD 8 ] */ 708 tree clauses; 709 710 /* [ WORD 9 ] 711 The control variable used for deciding which of the sections to 712 execute. */ 713 tree control; 714}; 715 716/* GIMPLE_OMP_CONTINUE. 717 718 Note: This does not inherit from gimple_statement_omp, because we 719 do not need the body field. */ 720 721struct GTY((tag("GSS_OMP_CONTINUE"))) 722 gomp_continue : public gimple 723{ 724 /* [ WORD 1-6 ] : base class */ 725 726 /* [ WORD 7 ] */ 727 tree control_def; 728 729 /* [ WORD 8 ] */ 730 tree control_use; 731}; 732 733/* GIMPLE_OMP_SINGLE, GIMPLE_OMP_TEAMS, GIMPLE_OMP_ORDERED */ 734 735struct GTY((tag("GSS_OMP_SINGLE_LAYOUT"))) 736 gimple_statement_omp_single_layout : public gimple_statement_omp 737{ 738 /* [ WORD 1-7 ] : base class */ 739 740 /* [ WORD 8 ] */ 741 tree clauses; 742}; 743 744struct GTY((tag("GSS_OMP_SINGLE_LAYOUT"))) 745 gomp_single : public gimple_statement_omp_single_layout 746{ 747 /* No extra fields; adds invariant: 748 stmt->code == GIMPLE_OMP_SINGLE. */ 749}; 750 751struct GTY((tag("GSS_OMP_SINGLE_LAYOUT"))) 752 gomp_teams : public gimple_statement_omp_single_layout 753{ 754 /* No extra fields; adds invariant: 755 stmt->code == GIMPLE_OMP_TEAMS. */ 756}; 757 758struct GTY((tag("GSS_OMP_SINGLE_LAYOUT"))) 759 gomp_ordered : public gimple_statement_omp_single_layout 760{ 761 /* No extra fields; adds invariant: 762 stmt->code == GIMPLE_OMP_ORDERED. */ 763}; 764 765 766/* GIMPLE_OMP_ATOMIC_LOAD. 767 Note: This is based on gimple, not g_s_omp, because g_s_omp 768 contains a sequence, which we don't need here. */ 769 770struct GTY((tag("GSS_OMP_ATOMIC_LOAD"))) 771 gomp_atomic_load : public gimple 772{ 773 /* [ WORD 1-6 ] : base class */ 774 775 /* [ WORD 7-8 ] */ 776 tree rhs, lhs; 777}; 778 779/* GIMPLE_OMP_ATOMIC_STORE. 780 See note on GIMPLE_OMP_ATOMIC_LOAD. */ 781 782struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT"))) 783 gimple_statement_omp_atomic_store_layout : public gimple 784{ 785 /* [ WORD 1-6 ] : base class */ 786 787 /* [ WORD 7 ] */ 788 tree val; 789}; 790 791struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT"))) 792 gomp_atomic_store : 793 public gimple_statement_omp_atomic_store_layout 794{ 795 /* No extra fields; adds invariant: 796 stmt->code == GIMPLE_OMP_ATOMIC_STORE. */ 797}; 798 799struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT"))) 800 gimple_statement_omp_return : 801 public gimple_statement_omp_atomic_store_layout 802{ 803 /* No extra fields; adds invariant: 804 stmt->code == GIMPLE_OMP_RETURN. */ 805}; 806 807/* GIMPLE_TRANSACTION. */ 808 809/* Bits to be stored in the GIMPLE_TRANSACTION subcode. */ 810 811/* The __transaction_atomic was declared [[outer]] or it is 812 __transaction_relaxed. */ 813#define GTMA_IS_OUTER (1u << 0) 814#define GTMA_IS_RELAXED (1u << 1) 815#define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED) 816 817/* The transaction is seen to not have an abort. */ 818#define GTMA_HAVE_ABORT (1u << 2) 819/* The transaction is seen to have loads or stores. */ 820#define GTMA_HAVE_LOAD (1u << 3) 821#define GTMA_HAVE_STORE (1u << 4) 822/* The transaction MAY enter serial irrevocable mode in its dynamic scope. */ 823#define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5) 824/* The transaction WILL enter serial irrevocable mode. 825 An irrevocable block post-dominates the entire transaction, such 826 that all invocations of the transaction will go serial-irrevocable. 827 In such case, we don't bother instrumenting the transaction, and 828 tell the runtime that it should begin the transaction in 829 serial-irrevocable mode. */ 830#define GTMA_DOES_GO_IRREVOCABLE (1u << 6) 831/* The transaction contains no instrumentation code whatsover, most 832 likely because it is guaranteed to go irrevocable upon entry. */ 833#define GTMA_HAS_NO_INSTRUMENTATION (1u << 7) 834 835struct GTY((tag("GSS_TRANSACTION"))) 836 gtransaction : public gimple_statement_with_memory_ops_base 837{ 838 /* [ WORD 1-9 ] : base class */ 839 840 /* [ WORD 10 ] */ 841 gimple_seq body; 842 843 /* [ WORD 11-13 ] */ 844 tree label_norm; 845 tree label_uninst; 846 tree label_over; 847}; 848 849#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM, 850enum gimple_statement_structure_enum { 851#include "gsstruct.def" 852 LAST_GSS_ENUM 853}; 854#undef DEFGSSTRUCT 855 856/* A statement with the invariant that 857 stmt->code == GIMPLE_COND 858 i.e. a conditional jump statement. */ 859 860struct GTY((tag("GSS_WITH_OPS"))) 861 gcond : public gimple_statement_with_ops 862{ 863 /* no additional fields; this uses the layout for GSS_WITH_OPS. */ 864 static const enum gimple_code code_ = GIMPLE_COND; 865}; 866 867/* A statement with the invariant that 868 stmt->code == GIMPLE_DEBUG 869 i.e. a debug statement. */ 870 871struct GTY((tag("GSS_WITH_OPS"))) 872 gdebug : public gimple_statement_with_ops 873{ 874 /* no additional fields; this uses the layout for GSS_WITH_OPS. */ 875}; 876 877/* A statement with the invariant that 878 stmt->code == GIMPLE_GOTO 879 i.e. a goto statement. */ 880 881struct GTY((tag("GSS_WITH_OPS"))) 882 ggoto : public gimple_statement_with_ops 883{ 884 /* no additional fields; this uses the layout for GSS_WITH_OPS. */ 885}; 886 887/* A statement with the invariant that 888 stmt->code == GIMPLE_LABEL 889 i.e. a label statement. */ 890 891struct GTY((tag("GSS_WITH_OPS"))) 892 glabel : public gimple_statement_with_ops 893{ 894 /* no additional fields; this uses the layout for GSS_WITH_OPS. */ 895}; 896 897/* A statement with the invariant that 898 stmt->code == GIMPLE_SWITCH 899 i.e. a switch statement. */ 900 901struct GTY((tag("GSS_WITH_OPS"))) 902 gswitch : public gimple_statement_with_ops 903{ 904 /* no additional fields; this uses the layout for GSS_WITH_OPS. */ 905}; 906 907/* A statement with the invariant that 908 stmt->code == GIMPLE_ASSIGN 909 i.e. an assignment statement. */ 910 911struct GTY((tag("GSS_WITH_MEM_OPS"))) 912 gassign : public gimple_statement_with_memory_ops 913{ 914 static const enum gimple_code code_ = GIMPLE_ASSIGN; 915 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */ 916}; 917 918/* A statement with the invariant that 919 stmt->code == GIMPLE_RETURN 920 i.e. a return statement. */ 921 922struct GTY((tag("GSS_WITH_MEM_OPS"))) 923 greturn : public gimple_statement_with_memory_ops 924{ 925 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */ 926}; 927 928template <> 929template <> 930inline bool 931is_a_helper <gasm *>::test (gimple *gs) 932{ 933 return gs->code == GIMPLE_ASM; 934} 935 936template <> 937template <> 938inline bool 939is_a_helper <gassign *>::test (gimple *gs) 940{ 941 return gs->code == GIMPLE_ASSIGN; 942} 943 944template <> 945template <> 946inline bool 947is_a_helper <const gassign *>::test (const gimple *gs) 948{ 949 return gs->code == GIMPLE_ASSIGN; 950} 951 952template <> 953template <> 954inline bool 955is_a_helper <gbind *>::test (gimple *gs) 956{ 957 return gs->code == GIMPLE_BIND; 958} 959 960template <> 961template <> 962inline bool 963is_a_helper <gcall *>::test (gimple *gs) 964{ 965 return gs->code == GIMPLE_CALL; 966} 967 968template <> 969template <> 970inline bool 971is_a_helper <gcatch *>::test (gimple *gs) 972{ 973 return gs->code == GIMPLE_CATCH; 974} 975 976template <> 977template <> 978inline bool 979is_a_helper <gcond *>::test (gimple *gs) 980{ 981 return gs->code == GIMPLE_COND; 982} 983 984template <> 985template <> 986inline bool 987is_a_helper <const gcond *>::test (const gimple *gs) 988{ 989 return gs->code == GIMPLE_COND; 990} 991 992template <> 993template <> 994inline bool 995is_a_helper <gdebug *>::test (gimple *gs) 996{ 997 return gs->code == GIMPLE_DEBUG; 998} 999 1000template <> 1001template <> 1002inline bool 1003is_a_helper <ggoto *>::test (gimple *gs) 1004{ 1005 return gs->code == GIMPLE_GOTO; 1006} 1007 1008template <> 1009template <> 1010inline bool 1011is_a_helper <glabel *>::test (gimple *gs) 1012{ 1013 return gs->code == GIMPLE_LABEL; 1014} 1015 1016template <> 1017template <> 1018inline bool 1019is_a_helper <gresx *>::test (gimple *gs) 1020{ 1021 return gs->code == GIMPLE_RESX; 1022} 1023 1024template <> 1025template <> 1026inline bool 1027is_a_helper <geh_dispatch *>::test (gimple *gs) 1028{ 1029 return gs->code == GIMPLE_EH_DISPATCH; 1030} 1031 1032template <> 1033template <> 1034inline bool 1035is_a_helper <geh_else *>::test (gimple *gs) 1036{ 1037 return gs->code == GIMPLE_EH_ELSE; 1038} 1039 1040template <> 1041template <> 1042inline bool 1043is_a_helper <geh_filter *>::test (gimple *gs) 1044{ 1045 return gs->code == GIMPLE_EH_FILTER; 1046} 1047 1048template <> 1049template <> 1050inline bool 1051is_a_helper <geh_mnt *>::test (gimple *gs) 1052{ 1053 return gs->code == GIMPLE_EH_MUST_NOT_THROW; 1054} 1055 1056template <> 1057template <> 1058inline bool 1059is_a_helper <gomp_atomic_load *>::test (gimple *gs) 1060{ 1061 return gs->code == GIMPLE_OMP_ATOMIC_LOAD; 1062} 1063 1064template <> 1065template <> 1066inline bool 1067is_a_helper <gomp_atomic_store *>::test (gimple *gs) 1068{ 1069 return gs->code == GIMPLE_OMP_ATOMIC_STORE; 1070} 1071 1072template <> 1073template <> 1074inline bool 1075is_a_helper <gimple_statement_omp_return *>::test (gimple *gs) 1076{ 1077 return gs->code == GIMPLE_OMP_RETURN; 1078} 1079 1080template <> 1081template <> 1082inline bool 1083is_a_helper <gomp_continue *>::test (gimple *gs) 1084{ 1085 return gs->code == GIMPLE_OMP_CONTINUE; 1086} 1087 1088template <> 1089template <> 1090inline bool 1091is_a_helper <gomp_critical *>::test (gimple *gs) 1092{ 1093 return gs->code == GIMPLE_OMP_CRITICAL; 1094} 1095 1096template <> 1097template <> 1098inline bool 1099is_a_helper <gomp_ordered *>::test (gimple *gs) 1100{ 1101 return gs->code == GIMPLE_OMP_ORDERED; 1102} 1103 1104template <> 1105template <> 1106inline bool 1107is_a_helper <gomp_for *>::test (gimple *gs) 1108{ 1109 return gs->code == GIMPLE_OMP_FOR; 1110} 1111 1112template <> 1113template <> 1114inline bool 1115is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs) 1116{ 1117 return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK; 1118} 1119 1120template <> 1121template <> 1122inline bool 1123is_a_helper <gomp_parallel *>::test (gimple *gs) 1124{ 1125 return gs->code == GIMPLE_OMP_PARALLEL; 1126} 1127 1128template <> 1129template <> 1130inline bool 1131is_a_helper <gomp_target *>::test (gimple *gs) 1132{ 1133 return gs->code == GIMPLE_OMP_TARGET; 1134} 1135 1136template <> 1137template <> 1138inline bool 1139is_a_helper <gomp_sections *>::test (gimple *gs) 1140{ 1141 return gs->code == GIMPLE_OMP_SECTIONS; 1142} 1143 1144template <> 1145template <> 1146inline bool 1147is_a_helper <gomp_single *>::test (gimple *gs) 1148{ 1149 return gs->code == GIMPLE_OMP_SINGLE; 1150} 1151 1152template <> 1153template <> 1154inline bool 1155is_a_helper <gomp_teams *>::test (gimple *gs) 1156{ 1157 return gs->code == GIMPLE_OMP_TEAMS; 1158} 1159 1160template <> 1161template <> 1162inline bool 1163is_a_helper <gomp_task *>::test (gimple *gs) 1164{ 1165 return gs->code == GIMPLE_OMP_TASK; 1166} 1167 1168template <> 1169template <> 1170inline bool 1171is_a_helper <gphi *>::test (gimple *gs) 1172{ 1173 return gs->code == GIMPLE_PHI; 1174} 1175 1176template <> 1177template <> 1178inline bool 1179is_a_helper <greturn *>::test (gimple *gs) 1180{ 1181 return gs->code == GIMPLE_RETURN; 1182} 1183 1184template <> 1185template <> 1186inline bool 1187is_a_helper <gswitch *>::test (gimple *gs) 1188{ 1189 return gs->code == GIMPLE_SWITCH; 1190} 1191 1192template <> 1193template <> 1194inline bool 1195is_a_helper <gtransaction *>::test (gimple *gs) 1196{ 1197 return gs->code == GIMPLE_TRANSACTION; 1198} 1199 1200template <> 1201template <> 1202inline bool 1203is_a_helper <gtry *>::test (gimple *gs) 1204{ 1205 return gs->code == GIMPLE_TRY; 1206} 1207 1208template <> 1209template <> 1210inline bool 1211is_a_helper <gimple_statement_wce *>::test (gimple *gs) 1212{ 1213 return gs->code == GIMPLE_WITH_CLEANUP_EXPR; 1214} 1215 1216template <> 1217template <> 1218inline bool 1219is_a_helper <const gasm *>::test (const gimple *gs) 1220{ 1221 return gs->code == GIMPLE_ASM; 1222} 1223 1224template <> 1225template <> 1226inline bool 1227is_a_helper <const gbind *>::test (const gimple *gs) 1228{ 1229 return gs->code == GIMPLE_BIND; 1230} 1231 1232template <> 1233template <> 1234inline bool 1235is_a_helper <const gcall *>::test (const gimple *gs) 1236{ 1237 return gs->code == GIMPLE_CALL; 1238} 1239 1240template <> 1241template <> 1242inline bool 1243is_a_helper <const gcatch *>::test (const gimple *gs) 1244{ 1245 return gs->code == GIMPLE_CATCH; 1246} 1247 1248template <> 1249template <> 1250inline bool 1251is_a_helper <const gresx *>::test (const gimple *gs) 1252{ 1253 return gs->code == GIMPLE_RESX; 1254} 1255 1256template <> 1257template <> 1258inline bool 1259is_a_helper <const geh_dispatch *>::test (const gimple *gs) 1260{ 1261 return gs->code == GIMPLE_EH_DISPATCH; 1262} 1263 1264template <> 1265template <> 1266inline bool 1267is_a_helper <const geh_filter *>::test (const gimple *gs) 1268{ 1269 return gs->code == GIMPLE_EH_FILTER; 1270} 1271 1272template <> 1273template <> 1274inline bool 1275is_a_helper <const gomp_atomic_load *>::test (const gimple *gs) 1276{ 1277 return gs->code == GIMPLE_OMP_ATOMIC_LOAD; 1278} 1279 1280template <> 1281template <> 1282inline bool 1283is_a_helper <const gomp_atomic_store *>::test (const gimple *gs) 1284{ 1285 return gs->code == GIMPLE_OMP_ATOMIC_STORE; 1286} 1287 1288template <> 1289template <> 1290inline bool 1291is_a_helper <const gimple_statement_omp_return *>::test (const gimple *gs) 1292{ 1293 return gs->code == GIMPLE_OMP_RETURN; 1294} 1295 1296template <> 1297template <> 1298inline bool 1299is_a_helper <const gomp_continue *>::test (const gimple *gs) 1300{ 1301 return gs->code == GIMPLE_OMP_CONTINUE; 1302} 1303 1304template <> 1305template <> 1306inline bool 1307is_a_helper <const gomp_critical *>::test (const gimple *gs) 1308{ 1309 return gs->code == GIMPLE_OMP_CRITICAL; 1310} 1311 1312template <> 1313template <> 1314inline bool 1315is_a_helper <const gomp_ordered *>::test (const gimple *gs) 1316{ 1317 return gs->code == GIMPLE_OMP_ORDERED; 1318} 1319 1320template <> 1321template <> 1322inline bool 1323is_a_helper <const gomp_for *>::test (const gimple *gs) 1324{ 1325 return gs->code == GIMPLE_OMP_FOR; 1326} 1327 1328template <> 1329template <> 1330inline bool 1331is_a_helper <const gimple_statement_omp_taskreg *>::test (const gimple *gs) 1332{ 1333 return gs->code == GIMPLE_OMP_PARALLEL || gs->code == GIMPLE_OMP_TASK; 1334} 1335 1336template <> 1337template <> 1338inline bool 1339is_a_helper <const gomp_parallel *>::test (const gimple *gs) 1340{ 1341 return gs->code == GIMPLE_OMP_PARALLEL; 1342} 1343 1344template <> 1345template <> 1346inline bool 1347is_a_helper <const gomp_target *>::test (const gimple *gs) 1348{ 1349 return gs->code == GIMPLE_OMP_TARGET; 1350} 1351 1352template <> 1353template <> 1354inline bool 1355is_a_helper <const gomp_sections *>::test (const gimple *gs) 1356{ 1357 return gs->code == GIMPLE_OMP_SECTIONS; 1358} 1359 1360template <> 1361template <> 1362inline bool 1363is_a_helper <const gomp_single *>::test (const gimple *gs) 1364{ 1365 return gs->code == GIMPLE_OMP_SINGLE; 1366} 1367 1368template <> 1369template <> 1370inline bool 1371is_a_helper <const gomp_teams *>::test (const gimple *gs) 1372{ 1373 return gs->code == GIMPLE_OMP_TEAMS; 1374} 1375 1376template <> 1377template <> 1378inline bool 1379is_a_helper <const gomp_task *>::test (const gimple *gs) 1380{ 1381 return gs->code == GIMPLE_OMP_TASK; 1382} 1383 1384template <> 1385template <> 1386inline bool 1387is_a_helper <const gphi *>::test (const gimple *gs) 1388{ 1389 return gs->code == GIMPLE_PHI; 1390} 1391 1392template <> 1393template <> 1394inline bool 1395is_a_helper <const gtransaction *>::test (const gimple *gs) 1396{ 1397 return gs->code == GIMPLE_TRANSACTION; 1398} 1399 1400/* Offset in bytes to the location of the operand vector. 1401 Zero if there is no operand vector for this tuple structure. */ 1402extern size_t const gimple_ops_offset_[]; 1403 1404/* Map GIMPLE codes to GSS codes. */ 1405extern enum gimple_statement_structure_enum const gss_for_code_[]; 1406 1407/* This variable holds the currently expanded gimple statement for purposes 1408 of comminucating the profile info to the builtin expanders. */ 1409extern gimple *currently_expanding_gimple_stmt; 1410 1411#define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO) 1412gimple *gimple_alloc_stat (enum gimple_code, unsigned MEM_STAT_DECL); 1413greturn *gimple_build_return (tree); 1414void gimple_call_reset_alias_info (gcall *); 1415gcall *gimple_build_call_vec (tree, vec<tree> ); 1416gcall *gimple_build_call (tree, unsigned, ...); 1417gcall *gimple_build_call_valist (tree, unsigned, va_list); 1418gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...); 1419gcall *gimple_build_call_internal_vec (enum internal_fn, vec<tree> ); 1420gcall *gimple_build_call_from_tree (tree); 1421gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_INFO); 1422gassign *gimple_build_assign (tree, enum tree_code, 1423 tree, tree, tree CXX_MEM_STAT_INFO); 1424gassign *gimple_build_assign (tree, enum tree_code, 1425 tree, tree CXX_MEM_STAT_INFO); 1426gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO); 1427gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree); 1428gcond *gimple_build_cond_from_tree (tree, tree, tree); 1429void gimple_cond_set_condition_from_tree (gcond *, tree); 1430glabel *gimple_build_label (tree label); 1431ggoto *gimple_build_goto (tree dest); 1432gimple *gimple_build_nop (void); 1433gbind *gimple_build_bind (tree, gimple_seq, tree); 1434gasm *gimple_build_asm_vec (const char *, vec<tree, va_gc> *, 1435 vec<tree, va_gc> *, vec<tree, va_gc> *, 1436 vec<tree, va_gc> *); 1437gcatch *gimple_build_catch (tree, gimple_seq); 1438geh_filter *gimple_build_eh_filter (tree, gimple_seq); 1439geh_mnt *gimple_build_eh_must_not_throw (tree); 1440geh_else *gimple_build_eh_else (gimple_seq, gimple_seq); 1441gtry *gimple_build_try (gimple_seq, gimple_seq, 1442 enum gimple_try_flags); 1443gimple *gimple_build_wce (gimple_seq); 1444gresx *gimple_build_resx (int); 1445gswitch *gimple_build_switch_nlabels (unsigned, tree, tree); 1446gswitch *gimple_build_switch (tree, tree, vec<tree> ); 1447geh_dispatch *gimple_build_eh_dispatch (int); 1448gdebug *gimple_build_debug_bind_stat (tree, tree, gimple * MEM_STAT_DECL); 1449#define gimple_build_debug_bind(var,val,stmt) \ 1450 gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) 1451gdebug *gimple_build_debug_source_bind_stat (tree, tree, gimple * MEM_STAT_DECL); 1452#define gimple_build_debug_source_bind(var,val,stmt) \ 1453 gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO) 1454gomp_critical *gimple_build_omp_critical (gimple_seq, tree, tree); 1455gomp_for *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq); 1456gomp_parallel *gimple_build_omp_parallel (gimple_seq, tree, tree, tree); 1457gomp_task *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, 1458 tree, tree); 1459gimple *gimple_build_omp_section (gimple_seq); 1460gimple *gimple_build_omp_master (gimple_seq); 1461gimple *gimple_build_omp_grid_body (gimple_seq); 1462gimple *gimple_build_omp_taskgroup (gimple_seq); 1463gomp_continue *gimple_build_omp_continue (tree, tree); 1464gomp_ordered *gimple_build_omp_ordered (gimple_seq, tree); 1465gimple *gimple_build_omp_return (bool); 1466gomp_sections *gimple_build_omp_sections (gimple_seq, tree); 1467gimple *gimple_build_omp_sections_switch (void); 1468gomp_single *gimple_build_omp_single (gimple_seq, tree); 1469gomp_target *gimple_build_omp_target (gimple_seq, int, tree); 1470gomp_teams *gimple_build_omp_teams (gimple_seq, tree); 1471gomp_atomic_load *gimple_build_omp_atomic_load (tree, tree); 1472gomp_atomic_store *gimple_build_omp_atomic_store (tree); 1473gtransaction *gimple_build_transaction (gimple_seq); 1474extern void gimple_seq_add_stmt (gimple_seq *, gimple *); 1475extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *); 1476void gimple_seq_add_seq (gimple_seq *, gimple_seq); 1477void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq); 1478extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator, 1479 location_t); 1480extern void annotate_all_with_location (gimple_seq, location_t); 1481bool empty_body_p (gimple_seq); 1482gimple_seq gimple_seq_copy (gimple_seq); 1483bool gimple_call_same_target_p (const gimple *, const gimple *); 1484int gimple_call_flags (const gimple *); 1485int gimple_call_arg_flags (const gcall *, unsigned); 1486int gimple_call_return_flags (const gcall *); 1487bool gimple_assign_copy_p (gimple *); 1488bool gimple_assign_ssa_name_copy_p (gimple *); 1489bool gimple_assign_unary_nop_p (gimple *); 1490void gimple_set_bb (gimple *, basic_block); 1491void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree); 1492void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code, 1493 tree, tree, tree); 1494tree gimple_get_lhs (const gimple *); 1495void gimple_set_lhs (gimple *, tree); 1496gimple *gimple_copy (gimple *); 1497bool gimple_has_side_effects (const gimple *); 1498bool gimple_could_trap_p_1 (gimple *, bool, bool); 1499bool gimple_could_trap_p (gimple *); 1500bool gimple_assign_rhs_could_trap_p (gimple *); 1501extern void dump_gimple_statistics (void); 1502unsigned get_gimple_rhs_num_ops (enum tree_code); 1503extern tree canonicalize_cond_expr_cond (tree); 1504gcall *gimple_call_copy_skip_args (gcall *, bitmap); 1505extern bool gimple_compare_field_offset (tree, tree); 1506extern tree gimple_unsigned_type (tree); 1507extern tree gimple_signed_type (tree); 1508extern alias_set_type gimple_get_alias_set (tree); 1509extern bool gimple_ior_addresses_taken (bitmap, gimple *); 1510extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree); 1511extern combined_fn gimple_call_combined_fn (const gimple *); 1512extern bool gimple_call_builtin_p (const gimple *); 1513extern bool gimple_call_builtin_p (const gimple *, enum built_in_class); 1514extern bool gimple_call_builtin_p (const gimple *, enum built_in_function); 1515extern bool gimple_asm_clobbers_memory_p (const gasm *); 1516extern void dump_decl_set (FILE *, bitmap); 1517extern bool nonfreeing_call_p (gimple *); 1518extern bool nonbarrier_call_p (gimple *); 1519extern bool infer_nonnull_range (gimple *, tree); 1520extern bool infer_nonnull_range_by_dereference (gimple *, tree); 1521extern bool infer_nonnull_range_by_attribute (gimple *, tree); 1522extern void sort_case_labels (vec<tree>); 1523extern void preprocess_case_label_vec_for_gimple (vec<tree>, tree, tree *); 1524extern void gimple_seq_set_location (gimple_seq, location_t); 1525extern void gimple_seq_discard (gimple_seq); 1526extern void maybe_remove_unused_call_args (struct function *, gimple *); 1527 1528/* Formal (expression) temporary table handling: multiple occurrences of 1529 the same scalar expression are evaluated into the same temporary. */ 1530 1531typedef struct gimple_temp_hash_elt 1532{ 1533 tree val; /* Key */ 1534 tree temp; /* Value */ 1535} elt_t; 1536 1537/* Get the number of the next statement uid to be allocated. */ 1538static inline unsigned int 1539gimple_stmt_max_uid (struct function *fn) 1540{ 1541 return fn->last_stmt_uid; 1542} 1543 1544/* Set the number of the next statement uid to be allocated. */ 1545static inline void 1546set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid) 1547{ 1548 fn->last_stmt_uid = maxid; 1549} 1550 1551/* Set the number of the next statement uid to be allocated. */ 1552static inline unsigned int 1553inc_gimple_stmt_max_uid (struct function *fn) 1554{ 1555 return fn->last_stmt_uid++; 1556} 1557 1558/* Return the first node in GIMPLE sequence S. */ 1559 1560static inline gimple_seq_node 1561gimple_seq_first (gimple_seq s) 1562{ 1563 return s; 1564} 1565 1566 1567/* Return the first statement in GIMPLE sequence S. */ 1568 1569static inline gimple * 1570gimple_seq_first_stmt (gimple_seq s) 1571{ 1572 gimple_seq_node n = gimple_seq_first (s); 1573 return n; 1574} 1575 1576/* Return the first statement in GIMPLE sequence S as a gbind *, 1577 verifying that it has code GIMPLE_BIND in a checked build. */ 1578 1579static inline gbind * 1580gimple_seq_first_stmt_as_a_bind (gimple_seq s) 1581{ 1582 gimple_seq_node n = gimple_seq_first (s); 1583 return as_a <gbind *> (n); 1584} 1585 1586 1587/* Return the last node in GIMPLE sequence S. */ 1588 1589static inline gimple_seq_node 1590gimple_seq_last (gimple_seq s) 1591{ 1592 return s ? s->prev : NULL; 1593} 1594 1595 1596/* Return the last statement in GIMPLE sequence S. */ 1597 1598static inline gimple * 1599gimple_seq_last_stmt (gimple_seq s) 1600{ 1601 gimple_seq_node n = gimple_seq_last (s); 1602 return n; 1603} 1604 1605 1606/* Set the last node in GIMPLE sequence *PS to LAST. */ 1607 1608static inline void 1609gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last) 1610{ 1611 (*ps)->prev = last; 1612} 1613 1614 1615/* Set the first node in GIMPLE sequence *PS to FIRST. */ 1616 1617static inline void 1618gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first) 1619{ 1620 *ps = first; 1621} 1622 1623 1624/* Return true if GIMPLE sequence S is empty. */ 1625 1626static inline bool 1627gimple_seq_empty_p (gimple_seq s) 1628{ 1629 return s == NULL; 1630} 1631 1632/* Allocate a new sequence and initialize its first element with STMT. */ 1633 1634static inline gimple_seq 1635gimple_seq_alloc_with_stmt (gimple *stmt) 1636{ 1637 gimple_seq seq = NULL; 1638 gimple_seq_add_stmt (&seq, stmt); 1639 return seq; 1640} 1641 1642 1643/* Returns the sequence of statements in BB. */ 1644 1645static inline gimple_seq 1646bb_seq (const_basic_block bb) 1647{ 1648 return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL; 1649} 1650 1651static inline gimple_seq * 1652bb_seq_addr (basic_block bb) 1653{ 1654 return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL; 1655} 1656 1657/* Sets the sequence of statements in BB to SEQ. */ 1658 1659static inline void 1660set_bb_seq (basic_block bb, gimple_seq seq) 1661{ 1662 gcc_checking_assert (!(bb->flags & BB_RTL)); 1663 bb->il.gimple.seq = seq; 1664} 1665 1666 1667/* Return the code for GIMPLE statement G. */ 1668 1669static inline enum gimple_code 1670gimple_code (const gimple *g) 1671{ 1672 return g->code; 1673} 1674 1675 1676/* Return the GSS code used by a GIMPLE code. */ 1677 1678static inline enum gimple_statement_structure_enum 1679gss_for_code (enum gimple_code code) 1680{ 1681 gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE); 1682 return gss_for_code_[code]; 1683} 1684 1685 1686/* Return which GSS code is used by GS. */ 1687 1688static inline enum gimple_statement_structure_enum 1689gimple_statement_structure (gimple *gs) 1690{ 1691 return gss_for_code (gimple_code (gs)); 1692} 1693 1694 1695/* Return true if statement G has sub-statements. This is only true for 1696 High GIMPLE statements. */ 1697 1698static inline bool 1699gimple_has_substatements (gimple *g) 1700{ 1701 switch (gimple_code (g)) 1702 { 1703 case GIMPLE_BIND: 1704 case GIMPLE_CATCH: 1705 case GIMPLE_EH_FILTER: 1706 case GIMPLE_EH_ELSE: 1707 case GIMPLE_TRY: 1708 case GIMPLE_OMP_FOR: 1709 case GIMPLE_OMP_MASTER: 1710 case GIMPLE_OMP_TASKGROUP: 1711 case GIMPLE_OMP_ORDERED: 1712 case GIMPLE_OMP_SECTION: 1713 case GIMPLE_OMP_PARALLEL: 1714 case GIMPLE_OMP_TASK: 1715 case GIMPLE_OMP_SECTIONS: 1716 case GIMPLE_OMP_SINGLE: 1717 case GIMPLE_OMP_TARGET: 1718 case GIMPLE_OMP_TEAMS: 1719 case GIMPLE_OMP_CRITICAL: 1720 case GIMPLE_WITH_CLEANUP_EXPR: 1721 case GIMPLE_TRANSACTION: 1722 case GIMPLE_OMP_GRID_BODY: 1723 return true; 1724 1725 default: 1726 return false; 1727 } 1728} 1729 1730 1731/* Return the basic block holding statement G. */ 1732 1733static inline basic_block 1734gimple_bb (const gimple *g) 1735{ 1736 return g->bb; 1737} 1738 1739 1740/* Return the lexical scope block holding statement G. */ 1741 1742static inline tree 1743gimple_block (const gimple *g) 1744{ 1745 return LOCATION_BLOCK (g->location); 1746} 1747 1748 1749/* Set BLOCK to be the lexical scope block holding statement G. */ 1750 1751static inline void 1752gimple_set_block (gimple *g, tree block) 1753{ 1754 g->location = set_block (g->location, block); 1755} 1756 1757 1758/* Return location information for statement G. */ 1759 1760static inline location_t 1761gimple_location (const gimple *g) 1762{ 1763 return g->location; 1764} 1765 1766/* Return location information for statement G if g is not NULL. 1767 Otherwise, UNKNOWN_LOCATION is returned. */ 1768 1769static inline location_t 1770gimple_location_safe (const gimple *g) 1771{ 1772 return g ? gimple_location (g) : UNKNOWN_LOCATION; 1773} 1774 1775/* Set location information for statement G. */ 1776 1777static inline void 1778gimple_set_location (gimple *g, location_t location) 1779{ 1780 g->location = location; 1781} 1782 1783 1784/* Return true if G contains location information. */ 1785 1786static inline bool 1787gimple_has_location (const gimple *g) 1788{ 1789 return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION; 1790} 1791 1792 1793/* Return the file name of the location of STMT. */ 1794 1795static inline const char * 1796gimple_filename (const gimple *stmt) 1797{ 1798 return LOCATION_FILE (gimple_location (stmt)); 1799} 1800 1801 1802/* Return the line number of the location of STMT. */ 1803 1804static inline int 1805gimple_lineno (const gimple *stmt) 1806{ 1807 return LOCATION_LINE (gimple_location (stmt)); 1808} 1809 1810 1811/* Determine whether SEQ is a singleton. */ 1812 1813static inline bool 1814gimple_seq_singleton_p (gimple_seq seq) 1815{ 1816 return ((gimple_seq_first (seq) != NULL) 1817 && (gimple_seq_first (seq) == gimple_seq_last (seq))); 1818} 1819 1820/* Return true if no warnings should be emitted for statement STMT. */ 1821 1822static inline bool 1823gimple_no_warning_p (const gimple *stmt) 1824{ 1825 return stmt->no_warning; 1826} 1827 1828/* Set the no_warning flag of STMT to NO_WARNING. */ 1829 1830static inline void 1831gimple_set_no_warning (gimple *stmt, bool no_warning) 1832{ 1833 stmt->no_warning = (unsigned) no_warning; 1834} 1835 1836/* Set the visited status on statement STMT to VISITED_P. 1837 1838 Please note that this 'visited' property of the gimple statement is 1839 supposed to be undefined at pass boundaries. This means that a 1840 given pass should not assume it contains any useful value when the 1841 pass starts and thus can set it to any value it sees fit. 1842 1843 You can learn more about the visited property of the gimple 1844 statement by reading the comments of the 'visited' data member of 1845 struct gimple. 1846 */ 1847 1848static inline void 1849gimple_set_visited (gimple *stmt, bool visited_p) 1850{ 1851 stmt->visited = (unsigned) visited_p; 1852} 1853 1854 1855/* Return the visited status for statement STMT. 1856 1857 Please note that this 'visited' property of the gimple statement is 1858 supposed to be undefined at pass boundaries. This means that a 1859 given pass should not assume it contains any useful value when the 1860 pass starts and thus can set it to any value it sees fit. 1861 1862 You can learn more about the visited property of the gimple 1863 statement by reading the comments of the 'visited' data member of 1864 struct gimple. */ 1865 1866static inline bool 1867gimple_visited_p (gimple *stmt) 1868{ 1869 return stmt->visited; 1870} 1871 1872 1873/* Set pass local flag PLF on statement STMT to VAL_P. 1874 1875 Please note that this PLF property of the gimple statement is 1876 supposed to be undefined at pass boundaries. This means that a 1877 given pass should not assume it contains any useful value when the 1878 pass starts and thus can set it to any value it sees fit. 1879 1880 You can learn more about the PLF property by reading the comment of 1881 the 'plf' data member of struct gimple_statement_structure. */ 1882 1883static inline void 1884gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p) 1885{ 1886 if (val_p) 1887 stmt->plf |= (unsigned int) plf; 1888 else 1889 stmt->plf &= ~((unsigned int) plf); 1890} 1891 1892 1893/* Return the value of pass local flag PLF on statement STMT. 1894 1895 Please note that this 'plf' property of the gimple statement is 1896 supposed to be undefined at pass boundaries. This means that a 1897 given pass should not assume it contains any useful value when the 1898 pass starts and thus can set it to any value it sees fit. 1899 1900 You can learn more about the plf property by reading the comment of 1901 the 'plf' data member of struct gimple_statement_structure. */ 1902 1903static inline unsigned int 1904gimple_plf (gimple *stmt, enum plf_mask plf) 1905{ 1906 return stmt->plf & ((unsigned int) plf); 1907} 1908 1909 1910/* Set the UID of statement. 1911 1912 Please note that this UID property is supposed to be undefined at 1913 pass boundaries. This means that a given pass should not assume it 1914 contains any useful value when the pass starts and thus can set it 1915 to any value it sees fit. */ 1916 1917static inline void 1918gimple_set_uid (gimple *g, unsigned uid) 1919{ 1920 g->uid = uid; 1921} 1922 1923 1924/* Return the UID of statement. 1925 1926 Please note that this UID property is supposed to be undefined at 1927 pass boundaries. This means that a given pass should not assume it 1928 contains any useful value when the pass starts and thus can set it 1929 to any value it sees fit. */ 1930 1931static inline unsigned 1932gimple_uid (const gimple *g) 1933{ 1934 return g->uid; 1935} 1936 1937 1938/* Make statement G a singleton sequence. */ 1939 1940static inline void 1941gimple_init_singleton (gimple *g) 1942{ 1943 g->next = NULL; 1944 g->prev = g; 1945} 1946 1947 1948/* Return true if GIMPLE statement G has register or memory operands. */ 1949 1950static inline bool 1951gimple_has_ops (const gimple *g) 1952{ 1953 return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN; 1954} 1955 1956template <> 1957template <> 1958inline bool 1959is_a_helper <const gimple_statement_with_ops *>::test (const gimple *gs) 1960{ 1961 return gimple_has_ops (gs); 1962} 1963 1964template <> 1965template <> 1966inline bool 1967is_a_helper <gimple_statement_with_ops *>::test (gimple *gs) 1968{ 1969 return gimple_has_ops (gs); 1970} 1971 1972/* Return true if GIMPLE statement G has memory operands. */ 1973 1974static inline bool 1975gimple_has_mem_ops (const gimple *g) 1976{ 1977 return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN; 1978} 1979 1980template <> 1981template <> 1982inline bool 1983is_a_helper <const gimple_statement_with_memory_ops *>::test (const gimple *gs) 1984{ 1985 return gimple_has_mem_ops (gs); 1986} 1987 1988template <> 1989template <> 1990inline bool 1991is_a_helper <gimple_statement_with_memory_ops *>::test (gimple *gs) 1992{ 1993 return gimple_has_mem_ops (gs); 1994} 1995 1996/* Return the set of USE operands for statement G. */ 1997 1998static inline struct use_optype_d * 1999gimple_use_ops (const gimple *g) 2000{ 2001 const gimple_statement_with_ops *ops_stmt = 2002 dyn_cast <const gimple_statement_with_ops *> (g); 2003 if (!ops_stmt) 2004 return NULL; 2005 return ops_stmt->use_ops; 2006} 2007 2008 2009/* Set USE to be the set of USE operands for statement G. */ 2010 2011static inline void 2012gimple_set_use_ops (gimple *g, struct use_optype_d *use) 2013{ 2014 gimple_statement_with_ops *ops_stmt = 2015 as_a <gimple_statement_with_ops *> (g); 2016 ops_stmt->use_ops = use; 2017} 2018 2019 2020/* Return the single VUSE operand of the statement G. */ 2021 2022static inline tree 2023gimple_vuse (const gimple *g) 2024{ 2025 const gimple_statement_with_memory_ops *mem_ops_stmt = 2026 dyn_cast <const gimple_statement_with_memory_ops *> (g); 2027 if (!mem_ops_stmt) 2028 return NULL_TREE; 2029 return mem_ops_stmt->vuse; 2030} 2031 2032/* Return the single VDEF operand of the statement G. */ 2033 2034static inline tree 2035gimple_vdef (const gimple *g) 2036{ 2037 const gimple_statement_with_memory_ops *mem_ops_stmt = 2038 dyn_cast <const gimple_statement_with_memory_ops *> (g); 2039 if (!mem_ops_stmt) 2040 return NULL_TREE; 2041 return mem_ops_stmt->vdef; 2042} 2043 2044/* Return the single VUSE operand of the statement G. */ 2045 2046static inline tree * 2047gimple_vuse_ptr (gimple *g) 2048{ 2049 gimple_statement_with_memory_ops *mem_ops_stmt = 2050 dyn_cast <gimple_statement_with_memory_ops *> (g); 2051 if (!mem_ops_stmt) 2052 return NULL; 2053 return &mem_ops_stmt->vuse; 2054} 2055 2056/* Return the single VDEF operand of the statement G. */ 2057 2058static inline tree * 2059gimple_vdef_ptr (gimple *g) 2060{ 2061 gimple_statement_with_memory_ops *mem_ops_stmt = 2062 dyn_cast <gimple_statement_with_memory_ops *> (g); 2063 if (!mem_ops_stmt) 2064 return NULL; 2065 return &mem_ops_stmt->vdef; 2066} 2067 2068/* Set the single VUSE operand of the statement G. */ 2069 2070static inline void 2071gimple_set_vuse (gimple *g, tree vuse) 2072{ 2073 gimple_statement_with_memory_ops *mem_ops_stmt = 2074 as_a <gimple_statement_with_memory_ops *> (g); 2075 mem_ops_stmt->vuse = vuse; 2076} 2077 2078/* Set the single VDEF operand of the statement G. */ 2079 2080static inline void 2081gimple_set_vdef (gimple *g, tree vdef) 2082{ 2083 gimple_statement_with_memory_ops *mem_ops_stmt = 2084 as_a <gimple_statement_with_memory_ops *> (g); 2085 mem_ops_stmt->vdef = vdef; 2086} 2087 2088 2089/* Return true if statement G has operands and the modified field has 2090 been set. */ 2091 2092static inline bool 2093gimple_modified_p (const gimple *g) 2094{ 2095 return (gimple_has_ops (g)) ? (bool) g->modified : false; 2096} 2097 2098 2099/* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has 2100 a MODIFIED field. */ 2101 2102static inline void 2103gimple_set_modified (gimple *s, bool modifiedp) 2104{ 2105 if (gimple_has_ops (s)) 2106 s->modified = (unsigned) modifiedp; 2107} 2108 2109 2110/* Return the tree code for the expression computed by STMT. This is 2111 only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For 2112 GIMPLE_CALL, return CALL_EXPR as the expression code for 2113 consistency. This is useful when the caller needs to deal with the 2114 three kinds of computation that GIMPLE supports. */ 2115 2116static inline enum tree_code 2117gimple_expr_code (const gimple *stmt) 2118{ 2119 enum gimple_code code = gimple_code (stmt); 2120 if (code == GIMPLE_ASSIGN || code == GIMPLE_COND) 2121 return (enum tree_code) stmt->subcode; 2122 else 2123 { 2124 gcc_gimple_checking_assert (code == GIMPLE_CALL); 2125 return CALL_EXPR; 2126 } 2127} 2128 2129 2130/* Return true if statement STMT contains volatile operands. */ 2131 2132static inline bool 2133gimple_has_volatile_ops (const gimple *stmt) 2134{ 2135 if (gimple_has_mem_ops (stmt)) 2136 return stmt->has_volatile_ops; 2137 else 2138 return false; 2139} 2140 2141 2142/* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */ 2143 2144static inline void 2145gimple_set_has_volatile_ops (gimple *stmt, bool volatilep) 2146{ 2147 if (gimple_has_mem_ops (stmt)) 2148 stmt->has_volatile_ops = (unsigned) volatilep; 2149} 2150 2151/* Return true if STMT is in a transaction. */ 2152 2153static inline bool 2154gimple_in_transaction (const gimple *stmt) 2155{ 2156 return bb_in_transaction (gimple_bb (stmt)); 2157} 2158 2159/* Return true if statement STMT may access memory. */ 2160 2161static inline bool 2162gimple_references_memory_p (gimple *stmt) 2163{ 2164 return gimple_has_mem_ops (stmt) && gimple_vuse (stmt); 2165} 2166 2167 2168/* Return the subcode for OMP statement S. */ 2169 2170static inline unsigned 2171gimple_omp_subcode (const gimple *s) 2172{ 2173 gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD 2174 && gimple_code (s) <= GIMPLE_OMP_TEAMS); 2175 return s->subcode; 2176} 2177 2178/* Set the subcode for OMP statement S to SUBCODE. */ 2179 2180static inline void 2181gimple_omp_set_subcode (gimple *s, unsigned int subcode) 2182{ 2183 /* We only have 16 bits for the subcode. Assert that we are not 2184 overflowing it. */ 2185 gcc_gimple_checking_assert (subcode < (1 << 16)); 2186 s->subcode = subcode; 2187} 2188 2189/* Set the nowait flag on OMP_RETURN statement S. */ 2190 2191static inline void 2192gimple_omp_return_set_nowait (gimple *s) 2193{ 2194 GIMPLE_CHECK (s, GIMPLE_OMP_RETURN); 2195 s->subcode |= GF_OMP_RETURN_NOWAIT; 2196} 2197 2198 2199/* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT 2200 flag set. */ 2201 2202static inline bool 2203gimple_omp_return_nowait_p (const gimple *g) 2204{ 2205 GIMPLE_CHECK (g, GIMPLE_OMP_RETURN); 2206 return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0; 2207} 2208 2209 2210/* Set the LHS of OMP return. */ 2211 2212static inline void 2213gimple_omp_return_set_lhs (gimple *g, tree lhs) 2214{ 2215 gimple_statement_omp_return *omp_return_stmt = 2216 as_a <gimple_statement_omp_return *> (g); 2217 omp_return_stmt->val = lhs; 2218} 2219 2220 2221/* Get the LHS of OMP return. */ 2222 2223static inline tree 2224gimple_omp_return_lhs (const gimple *g) 2225{ 2226 const gimple_statement_omp_return *omp_return_stmt = 2227 as_a <const gimple_statement_omp_return *> (g); 2228 return omp_return_stmt->val; 2229} 2230 2231 2232/* Return a pointer to the LHS of OMP return. */ 2233 2234static inline tree * 2235gimple_omp_return_lhs_ptr (gimple *g) 2236{ 2237 gimple_statement_omp_return *omp_return_stmt = 2238 as_a <gimple_statement_omp_return *> (g); 2239 return &omp_return_stmt->val; 2240} 2241 2242 2243/* Return true if OMP section statement G has the GF_OMP_SECTION_LAST 2244 flag set. */ 2245 2246static inline bool 2247gimple_omp_section_last_p (const gimple *g) 2248{ 2249 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION); 2250 return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0; 2251} 2252 2253 2254/* Set the GF_OMP_SECTION_LAST flag on G. */ 2255 2256static inline void 2257gimple_omp_section_set_last (gimple *g) 2258{ 2259 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION); 2260 g->subcode |= GF_OMP_SECTION_LAST; 2261} 2262 2263 2264/* Return true if OMP parallel statement G has the 2265 GF_OMP_PARALLEL_COMBINED flag set. */ 2266 2267static inline bool 2268gimple_omp_parallel_combined_p (const gimple *g) 2269{ 2270 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL); 2271 return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0; 2272} 2273 2274 2275/* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean 2276 value of COMBINED_P. */ 2277 2278static inline void 2279gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p) 2280{ 2281 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL); 2282 if (combined_p) 2283 g->subcode |= GF_OMP_PARALLEL_COMBINED; 2284 else 2285 g->subcode &= ~GF_OMP_PARALLEL_COMBINED; 2286} 2287 2288 2289/* Return true if OMP atomic load/store statement G has the 2290 GF_OMP_ATOMIC_NEED_VALUE flag set. */ 2291 2292static inline bool 2293gimple_omp_atomic_need_value_p (const gimple *g) 2294{ 2295 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD) 2296 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); 2297 return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_NEED_VALUE) != 0; 2298} 2299 2300 2301/* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */ 2302 2303static inline void 2304gimple_omp_atomic_set_need_value (gimple *g) 2305{ 2306 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD) 2307 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); 2308 g->subcode |= GF_OMP_ATOMIC_NEED_VALUE; 2309} 2310 2311 2312/* Return true if OMP atomic load/store statement G has the 2313 GF_OMP_ATOMIC_SEQ_CST flag set. */ 2314 2315static inline bool 2316gimple_omp_atomic_seq_cst_p (const gimple *g) 2317{ 2318 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD) 2319 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); 2320 return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_SEQ_CST) != 0; 2321} 2322 2323 2324/* Set the GF_OMP_ATOMIC_SEQ_CST flag on G. */ 2325 2326static inline void 2327gimple_omp_atomic_set_seq_cst (gimple *g) 2328{ 2329 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD) 2330 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE); 2331 g->subcode |= GF_OMP_ATOMIC_SEQ_CST; 2332} 2333 2334 2335/* Return the number of operands for statement GS. */ 2336 2337static inline unsigned 2338gimple_num_ops (const gimple *gs) 2339{ 2340 return gs->num_ops; 2341} 2342 2343 2344/* Set the number of operands for statement GS. */ 2345 2346static inline void 2347gimple_set_num_ops (gimple *gs, unsigned num_ops) 2348{ 2349 gs->num_ops = num_ops; 2350} 2351 2352 2353/* Return the array of operands for statement GS. */ 2354 2355static inline tree * 2356gimple_ops (gimple *gs) 2357{ 2358 size_t off; 2359 2360 /* All the tuples have their operand vector at the very bottom 2361 of the structure. Note that those structures that do not 2362 have an operand vector have a zero offset. */ 2363 off = gimple_ops_offset_[gimple_statement_structure (gs)]; 2364 gcc_gimple_checking_assert (off != 0); 2365 2366 return (tree *) ((char *) gs + off); 2367} 2368 2369 2370/* Return operand I for statement GS. */ 2371 2372static inline tree 2373gimple_op (const gimple *gs, unsigned i) 2374{ 2375 if (gimple_has_ops (gs)) 2376 { 2377 gcc_gimple_checking_assert (i < gimple_num_ops (gs)); 2378 return gimple_ops (CONST_CAST_GIMPLE (gs))[i]; 2379 } 2380 else 2381 return NULL_TREE; 2382} 2383 2384/* Return a pointer to operand I for statement GS. */ 2385 2386static inline tree * 2387gimple_op_ptr (gimple *gs, unsigned i) 2388{ 2389 if (gimple_has_ops (gs)) 2390 { 2391 gcc_gimple_checking_assert (i < gimple_num_ops (gs)); 2392 return gimple_ops (gs) + i; 2393 } 2394 else 2395 return NULL; 2396} 2397 2398/* Set operand I of statement GS to OP. */ 2399 2400static inline void 2401gimple_set_op (gimple *gs, unsigned i, tree op) 2402{ 2403 gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs)); 2404 2405 /* Note. It may be tempting to assert that OP matches 2406 is_gimple_operand, but that would be wrong. Different tuples 2407 accept slightly different sets of tree operands. Each caller 2408 should perform its own validation. */ 2409 gimple_ops (gs)[i] = op; 2410} 2411 2412/* Return true if GS is a GIMPLE_ASSIGN. */ 2413 2414static inline bool 2415is_gimple_assign (const gimple *gs) 2416{ 2417 return gimple_code (gs) == GIMPLE_ASSIGN; 2418} 2419 2420/* Determine if expression CODE is one of the valid expressions that can 2421 be used on the RHS of GIMPLE assignments. */ 2422 2423static inline enum gimple_rhs_class 2424get_gimple_rhs_class (enum tree_code code) 2425{ 2426 return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code]; 2427} 2428 2429/* Return the LHS of assignment statement GS. */ 2430 2431static inline tree 2432gimple_assign_lhs (const gassign *gs) 2433{ 2434 return gs->op[0]; 2435} 2436 2437static inline tree 2438gimple_assign_lhs (const gimple *gs) 2439{ 2440 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs); 2441 return gimple_assign_lhs (ass); 2442} 2443 2444 2445/* Return a pointer to the LHS of assignment statement GS. */ 2446 2447static inline tree * 2448gimple_assign_lhs_ptr (gassign *gs) 2449{ 2450 return &gs->op[0]; 2451} 2452 2453static inline tree * 2454gimple_assign_lhs_ptr (gimple *gs) 2455{ 2456 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2457 return gimple_assign_lhs_ptr (ass); 2458} 2459 2460 2461/* Set LHS to be the LHS operand of assignment statement GS. */ 2462 2463static inline void 2464gimple_assign_set_lhs (gassign *gs, tree lhs) 2465{ 2466 gs->op[0] = lhs; 2467 2468 if (lhs && TREE_CODE (lhs) == SSA_NAME) 2469 SSA_NAME_DEF_STMT (lhs) = gs; 2470} 2471 2472static inline void 2473gimple_assign_set_lhs (gimple *gs, tree lhs) 2474{ 2475 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2476 gimple_assign_set_lhs (ass, lhs); 2477} 2478 2479 2480/* Return the first operand on the RHS of assignment statement GS. */ 2481 2482static inline tree 2483gimple_assign_rhs1 (const gassign *gs) 2484{ 2485 return gs->op[1]; 2486} 2487 2488static inline tree 2489gimple_assign_rhs1 (const gimple *gs) 2490{ 2491 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs); 2492 return gimple_assign_rhs1 (ass); 2493} 2494 2495 2496/* Return a pointer to the first operand on the RHS of assignment 2497 statement GS. */ 2498 2499static inline tree * 2500gimple_assign_rhs1_ptr (gassign *gs) 2501{ 2502 return &gs->op[1]; 2503} 2504 2505static inline tree * 2506gimple_assign_rhs1_ptr (gimple *gs) 2507{ 2508 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2509 return gimple_assign_rhs1_ptr (ass); 2510} 2511 2512/* Set RHS to be the first operand on the RHS of assignment statement GS. */ 2513 2514static inline void 2515gimple_assign_set_rhs1 (gassign *gs, tree rhs) 2516{ 2517 gs->op[1] = rhs; 2518} 2519 2520static inline void 2521gimple_assign_set_rhs1 (gimple *gs, tree rhs) 2522{ 2523 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2524 gimple_assign_set_rhs1 (ass, rhs); 2525} 2526 2527 2528/* Return the second operand on the RHS of assignment statement GS. 2529 If GS does not have two operands, NULL is returned instead. */ 2530 2531static inline tree 2532gimple_assign_rhs2 (const gassign *gs) 2533{ 2534 if (gimple_num_ops (gs) >= 3) 2535 return gs->op[2]; 2536 else 2537 return NULL_TREE; 2538} 2539 2540static inline tree 2541gimple_assign_rhs2 (const gimple *gs) 2542{ 2543 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs); 2544 return gimple_assign_rhs2 (ass); 2545} 2546 2547 2548/* Return a pointer to the second operand on the RHS of assignment 2549 statement GS. */ 2550 2551static inline tree * 2552gimple_assign_rhs2_ptr (gassign *gs) 2553{ 2554 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3); 2555 return &gs->op[2]; 2556} 2557 2558static inline tree * 2559gimple_assign_rhs2_ptr (gimple *gs) 2560{ 2561 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2562 return gimple_assign_rhs2_ptr (ass); 2563} 2564 2565 2566/* Set RHS to be the second operand on the RHS of assignment statement GS. */ 2567 2568static inline void 2569gimple_assign_set_rhs2 (gassign *gs, tree rhs) 2570{ 2571 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3); 2572 gs->op[2] = rhs; 2573} 2574 2575static inline void 2576gimple_assign_set_rhs2 (gimple *gs, tree rhs) 2577{ 2578 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2579 return gimple_assign_set_rhs2 (ass, rhs); 2580} 2581 2582/* Return the third operand on the RHS of assignment statement GS. 2583 If GS does not have two operands, NULL is returned instead. */ 2584 2585static inline tree 2586gimple_assign_rhs3 (const gassign *gs) 2587{ 2588 if (gimple_num_ops (gs) >= 4) 2589 return gs->op[3]; 2590 else 2591 return NULL_TREE; 2592} 2593 2594static inline tree 2595gimple_assign_rhs3 (const gimple *gs) 2596{ 2597 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs); 2598 return gimple_assign_rhs3 (ass); 2599} 2600 2601/* Return a pointer to the third operand on the RHS of assignment 2602 statement GS. */ 2603 2604static inline tree * 2605gimple_assign_rhs3_ptr (gimple *gs) 2606{ 2607 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2608 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4); 2609 return &ass->op[3]; 2610} 2611 2612 2613/* Set RHS to be the third operand on the RHS of assignment statement GS. */ 2614 2615static inline void 2616gimple_assign_set_rhs3 (gassign *gs, tree rhs) 2617{ 2618 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4); 2619 gs->op[3] = rhs; 2620} 2621 2622static inline void 2623gimple_assign_set_rhs3 (gimple *gs, tree rhs) 2624{ 2625 gassign *ass = GIMPLE_CHECK2<gassign *> (gs); 2626 gimple_assign_set_rhs3 (ass, rhs); 2627} 2628 2629 2630/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers 2631 which expect to see only two operands. */ 2632 2633static inline void 2634gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, 2635 tree op1, tree op2) 2636{ 2637 gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL); 2638} 2639 2640/* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers 2641 which expect to see only one operands. */ 2642 2643static inline void 2644gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code, 2645 tree op1) 2646{ 2647 gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL); 2648} 2649 2650/* Returns true if GS is a nontemporal move. */ 2651 2652static inline bool 2653gimple_assign_nontemporal_move_p (const gassign *gs) 2654{ 2655 return gs->nontemporal_move; 2656} 2657 2658/* Sets nontemporal move flag of GS to NONTEMPORAL. */ 2659 2660static inline void 2661gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal) 2662{ 2663 GIMPLE_CHECK (gs, GIMPLE_ASSIGN); 2664 gs->nontemporal_move = nontemporal; 2665} 2666 2667 2668/* Return the code of the expression computed on the rhs of assignment 2669 statement GS. In case that the RHS is a single object, returns the 2670 tree code of the object. */ 2671 2672static inline enum tree_code 2673gimple_assign_rhs_code (const gassign *gs) 2674{ 2675 enum tree_code code = (enum tree_code) gs->subcode; 2676 /* While we initially set subcode to the TREE_CODE of the rhs for 2677 GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay 2678 in sync when we rewrite stmts into SSA form or do SSA propagations. */ 2679 if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS) 2680 code = TREE_CODE (gs->op[1]); 2681 2682 return code; 2683} 2684 2685static inline enum tree_code 2686gimple_assign_rhs_code (const gimple *gs) 2687{ 2688 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs); 2689 return gimple_assign_rhs_code (ass); 2690} 2691 2692 2693/* Set CODE to be the code for the expression computed on the RHS of 2694 assignment S. */ 2695 2696static inline void 2697gimple_assign_set_rhs_code (gimple *s, enum tree_code code) 2698{ 2699 GIMPLE_CHECK (s, GIMPLE_ASSIGN); 2700 s->subcode = code; 2701} 2702 2703 2704/* Return the gimple rhs class of the code of the expression computed on 2705 the rhs of assignment statement GS. 2706 This will never return GIMPLE_INVALID_RHS. */ 2707 2708static inline enum gimple_rhs_class 2709gimple_assign_rhs_class (const gimple *gs) 2710{ 2711 return get_gimple_rhs_class (gimple_assign_rhs_code (gs)); 2712} 2713 2714/* Return true if GS is an assignment with a singleton RHS, i.e., 2715 there is no operator associated with the assignment itself. 2716 Unlike gimple_assign_copy_p, this predicate returns true for 2717 any RHS operand, including those that perform an operation 2718 and do not have the semantics of a copy, such as COND_EXPR. */ 2719 2720static inline bool 2721gimple_assign_single_p (const gimple *gs) 2722{ 2723 return (is_gimple_assign (gs) 2724 && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS); 2725} 2726 2727/* Return true if GS performs a store to its lhs. */ 2728 2729static inline bool 2730gimple_store_p (const gimple *gs) 2731{ 2732 tree lhs = gimple_get_lhs (gs); 2733 return lhs && !is_gimple_reg (lhs); 2734} 2735 2736/* Return true if GS is an assignment that loads from its rhs1. */ 2737 2738static inline bool 2739gimple_assign_load_p (const gimple *gs) 2740{ 2741 tree rhs; 2742 if (!gimple_assign_single_p (gs)) 2743 return false; 2744 rhs = gimple_assign_rhs1 (gs); 2745 if (TREE_CODE (rhs) == WITH_SIZE_EXPR) 2746 return true; 2747 rhs = get_base_address (rhs); 2748 return (DECL_P (rhs) 2749 || TREE_CODE (rhs) == MEM_REF || TREE_CODE (rhs) == TARGET_MEM_REF); 2750} 2751 2752 2753/* Return true if S is a type-cast assignment. */ 2754 2755static inline bool 2756gimple_assign_cast_p (const gimple *s) 2757{ 2758 if (is_gimple_assign (s)) 2759 { 2760 enum tree_code sc = gimple_assign_rhs_code (s); 2761 return CONVERT_EXPR_CODE_P (sc) 2762 || sc == VIEW_CONVERT_EXPR 2763 || sc == FIX_TRUNC_EXPR; 2764 } 2765 2766 return false; 2767} 2768 2769/* Return true if S is a clobber statement. */ 2770 2771static inline bool 2772gimple_clobber_p (const gimple *s) 2773{ 2774 return gimple_assign_single_p (s) 2775 && TREE_CLOBBER_P (gimple_assign_rhs1 (s)); 2776} 2777 2778/* Return true if GS is a GIMPLE_CALL. */ 2779 2780static inline bool 2781is_gimple_call (const gimple *gs) 2782{ 2783 return gimple_code (gs) == GIMPLE_CALL; 2784} 2785 2786/* Return the LHS of call statement GS. */ 2787 2788static inline tree 2789gimple_call_lhs (const gcall *gs) 2790{ 2791 return gs->op[0]; 2792} 2793 2794static inline tree 2795gimple_call_lhs (const gimple *gs) 2796{ 2797 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2798 return gimple_call_lhs (gc); 2799} 2800 2801 2802/* Return a pointer to the LHS of call statement GS. */ 2803 2804static inline tree * 2805gimple_call_lhs_ptr (gcall *gs) 2806{ 2807 return &gs->op[0]; 2808} 2809 2810static inline tree * 2811gimple_call_lhs_ptr (gimple *gs) 2812{ 2813 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 2814 return gimple_call_lhs_ptr (gc); 2815} 2816 2817 2818/* Set LHS to be the LHS operand of call statement GS. */ 2819 2820static inline void 2821gimple_call_set_lhs (gcall *gs, tree lhs) 2822{ 2823 gs->op[0] = lhs; 2824 if (lhs && TREE_CODE (lhs) == SSA_NAME) 2825 SSA_NAME_DEF_STMT (lhs) = gs; 2826} 2827 2828static inline void 2829gimple_call_set_lhs (gimple *gs, tree lhs) 2830{ 2831 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 2832 gimple_call_set_lhs (gc, lhs); 2833} 2834 2835 2836/* Return true if call GS calls an internal-only function, as enumerated 2837 by internal_fn. */ 2838 2839static inline bool 2840gimple_call_internal_p (const gcall *gs) 2841{ 2842 return (gs->subcode & GF_CALL_INTERNAL) != 0; 2843} 2844 2845static inline bool 2846gimple_call_internal_p (const gimple *gs) 2847{ 2848 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2849 return gimple_call_internal_p (gc); 2850} 2851 2852 2853/* Return true if call GS is marked as instrumented by 2854 Pointer Bounds Checker. */ 2855 2856static inline bool 2857gimple_call_with_bounds_p (const gcall *gs) 2858{ 2859 return (gs->subcode & GF_CALL_WITH_BOUNDS) != 0; 2860} 2861 2862static inline bool 2863gimple_call_with_bounds_p (const gimple *gs) 2864{ 2865 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2866 return gimple_call_with_bounds_p (gc); 2867} 2868 2869 2870/* If INSTRUMENTED_P is true, marm statement GS as instrumented by 2871 Pointer Bounds Checker. */ 2872 2873static inline void 2874gimple_call_set_with_bounds (gcall *gs, bool with_bounds) 2875{ 2876 if (with_bounds) 2877 gs->subcode |= GF_CALL_WITH_BOUNDS; 2878 else 2879 gs->subcode &= ~GF_CALL_WITH_BOUNDS; 2880} 2881 2882static inline void 2883gimple_call_set_with_bounds (gimple *gs, bool with_bounds) 2884{ 2885 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 2886 gimple_call_set_with_bounds (gc, with_bounds); 2887} 2888 2889 2890/* Return the target of internal call GS. */ 2891 2892static inline enum internal_fn 2893gimple_call_internal_fn (const gcall *gs) 2894{ 2895 gcc_gimple_checking_assert (gimple_call_internal_p (gs)); 2896 return gs->u.internal_fn; 2897} 2898 2899static inline enum internal_fn 2900gimple_call_internal_fn (const gimple *gs) 2901{ 2902 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2903 return gimple_call_internal_fn (gc); 2904} 2905 2906/* Return true, if this internal gimple call is unique. */ 2907 2908static inline bool 2909gimple_call_internal_unique_p (const gcall *gs) 2910{ 2911 return gimple_call_internal_fn (gs) == IFN_UNIQUE; 2912} 2913 2914static inline bool 2915gimple_call_internal_unique_p (const gimple *gs) 2916{ 2917 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2918 return gimple_call_internal_unique_p (gc); 2919} 2920 2921/* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt 2922 that could alter control flow. */ 2923 2924static inline void 2925gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p) 2926{ 2927 if (ctrl_altering_p) 2928 s->subcode |= GF_CALL_CTRL_ALTERING; 2929 else 2930 s->subcode &= ~GF_CALL_CTRL_ALTERING; 2931} 2932 2933static inline void 2934gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p) 2935{ 2936 gcall *gc = GIMPLE_CHECK2<gcall *> (s); 2937 gimple_call_set_ctrl_altering (gc, ctrl_altering_p); 2938} 2939 2940/* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING 2941 flag is set. Such call could not be a stmt in the middle of a bb. */ 2942 2943static inline bool 2944gimple_call_ctrl_altering_p (const gcall *gs) 2945{ 2946 return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0; 2947} 2948 2949static inline bool 2950gimple_call_ctrl_altering_p (const gimple *gs) 2951{ 2952 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2953 return gimple_call_ctrl_altering_p (gc); 2954} 2955 2956 2957/* Return the function type of the function called by GS. */ 2958 2959static inline tree 2960gimple_call_fntype (const gcall *gs) 2961{ 2962 if (gimple_call_internal_p (gs)) 2963 return NULL_TREE; 2964 return gs->u.fntype; 2965} 2966 2967static inline tree 2968gimple_call_fntype (const gimple *gs) 2969{ 2970 const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs); 2971 return gimple_call_fntype (call_stmt); 2972} 2973 2974/* Set the type of the function called by CALL_STMT to FNTYPE. */ 2975 2976static inline void 2977gimple_call_set_fntype (gcall *call_stmt, tree fntype) 2978{ 2979 gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt)); 2980 call_stmt->u.fntype = fntype; 2981} 2982 2983 2984/* Return the tree node representing the function called by call 2985 statement GS. */ 2986 2987static inline tree 2988gimple_call_fn (const gcall *gs) 2989{ 2990 return gs->op[1]; 2991} 2992 2993static inline tree 2994gimple_call_fn (const gimple *gs) 2995{ 2996 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 2997 return gimple_call_fn (gc); 2998} 2999 3000/* Return a pointer to the tree node representing the function called by call 3001 statement GS. */ 3002 3003static inline tree * 3004gimple_call_fn_ptr (gcall *gs) 3005{ 3006 return &gs->op[1]; 3007} 3008 3009static inline tree * 3010gimple_call_fn_ptr (gimple *gs) 3011{ 3012 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 3013 return gimple_call_fn_ptr (gc); 3014} 3015 3016 3017/* Set FN to be the function called by call statement GS. */ 3018 3019static inline void 3020gimple_call_set_fn (gcall *gs, tree fn) 3021{ 3022 gcc_gimple_checking_assert (!gimple_call_internal_p (gs)); 3023 gs->op[1] = fn; 3024} 3025 3026 3027/* Set FNDECL to be the function called by call statement GS. */ 3028 3029static inline void 3030gimple_call_set_fndecl (gcall *gs, tree decl) 3031{ 3032 gcc_gimple_checking_assert (!gimple_call_internal_p (gs)); 3033 gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR, 3034 build_pointer_type (TREE_TYPE (decl)), decl); 3035} 3036 3037static inline void 3038gimple_call_set_fndecl (gimple *gs, tree decl) 3039{ 3040 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 3041 gimple_call_set_fndecl (gc, decl); 3042} 3043 3044 3045/* Set internal function FN to be the function called by call statement CALL_STMT. */ 3046 3047static inline void 3048gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn) 3049{ 3050 gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt)); 3051 call_stmt->u.internal_fn = fn; 3052} 3053 3054 3055/* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it. 3056 Otherwise return NULL. This function is analogous to 3057 get_callee_fndecl in tree land. */ 3058 3059static inline tree 3060gimple_call_fndecl (const gcall *gs) 3061{ 3062 return gimple_call_addr_fndecl (gimple_call_fn (gs)); 3063} 3064 3065static inline tree 3066gimple_call_fndecl (const gimple *gs) 3067{ 3068 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 3069 return gimple_call_fndecl (gc); 3070} 3071 3072 3073/* Return the type returned by call statement GS. */ 3074 3075static inline tree 3076gimple_call_return_type (const gcall *gs) 3077{ 3078 tree type = gimple_call_fntype (gs); 3079 3080 if (type == NULL_TREE) 3081 return TREE_TYPE (gimple_call_lhs (gs)); 3082 3083 /* The type returned by a function is the type of its 3084 function type. */ 3085 return TREE_TYPE (type); 3086} 3087 3088 3089/* Return the static chain for call statement GS. */ 3090 3091static inline tree 3092gimple_call_chain (const gcall *gs) 3093{ 3094 return gs->op[2]; 3095} 3096 3097static inline tree 3098gimple_call_chain (const gimple *gs) 3099{ 3100 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 3101 return gimple_call_chain (gc); 3102} 3103 3104 3105/* Return a pointer to the static chain for call statement CALL_STMT. */ 3106 3107static inline tree * 3108gimple_call_chain_ptr (gcall *call_stmt) 3109{ 3110 return &call_stmt->op[2]; 3111} 3112 3113/* Set CHAIN to be the static chain for call statement CALL_STMT. */ 3114 3115static inline void 3116gimple_call_set_chain (gcall *call_stmt, tree chain) 3117{ 3118 call_stmt->op[2] = chain; 3119} 3120 3121 3122/* Return the number of arguments used by call statement GS. */ 3123 3124static inline unsigned 3125gimple_call_num_args (const gcall *gs) 3126{ 3127 return gimple_num_ops (gs) - 3; 3128} 3129 3130static inline unsigned 3131gimple_call_num_args (const gimple *gs) 3132{ 3133 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 3134 return gimple_call_num_args (gc); 3135} 3136 3137 3138/* Return the argument at position INDEX for call statement GS. */ 3139 3140static inline tree 3141gimple_call_arg (const gcall *gs, unsigned index) 3142{ 3143 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3); 3144 return gs->op[index + 3]; 3145} 3146 3147static inline tree 3148gimple_call_arg (const gimple *gs, unsigned index) 3149{ 3150 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs); 3151 return gimple_call_arg (gc, index); 3152} 3153 3154 3155/* Return a pointer to the argument at position INDEX for call 3156 statement GS. */ 3157 3158static inline tree * 3159gimple_call_arg_ptr (gcall *gs, unsigned index) 3160{ 3161 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3); 3162 return &gs->op[index + 3]; 3163} 3164 3165static inline tree * 3166gimple_call_arg_ptr (gimple *gs, unsigned index) 3167{ 3168 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 3169 return gimple_call_arg_ptr (gc, index); 3170} 3171 3172 3173/* Set ARG to be the argument at position INDEX for call statement GS. */ 3174 3175static inline void 3176gimple_call_set_arg (gcall *gs, unsigned index, tree arg) 3177{ 3178 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3); 3179 gs->op[index + 3] = arg; 3180} 3181 3182static inline void 3183gimple_call_set_arg (gimple *gs, unsigned index, tree arg) 3184{ 3185 gcall *gc = GIMPLE_CHECK2<gcall *> (gs); 3186 gimple_call_set_arg (gc, index, arg); 3187} 3188 3189 3190/* If TAIL_P is true, mark call statement S as being a tail call 3191 (i.e., a call just before the exit of a function). These calls are 3192 candidate for tail call optimization. */ 3193 3194static inline void 3195gimple_call_set_tail (gcall *s, bool tail_p) 3196{ 3197 if (tail_p) 3198 s->subcode |= GF_CALL_TAILCALL; 3199 else 3200 s->subcode &= ~GF_CALL_TAILCALL; 3201} 3202 3203 3204/* Return true if GIMPLE_CALL S is marked as a tail call. */ 3205 3206static inline bool 3207gimple_call_tail_p (gcall *s) 3208{ 3209 return (s->subcode & GF_CALL_TAILCALL) != 0; 3210} 3211 3212 3213/* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return 3214 slot optimization. This transformation uses the target of the call 3215 expansion as the return slot for calls that return in memory. */ 3216 3217static inline void 3218gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p) 3219{ 3220 if (return_slot_opt_p) 3221 s->subcode |= GF_CALL_RETURN_SLOT_OPT; 3222 else 3223 s->subcode &= ~GF_CALL_RETURN_SLOT_OPT; 3224} 3225 3226 3227/* Return true if S is marked for return slot optimization. */ 3228 3229static inline bool 3230gimple_call_return_slot_opt_p (gcall *s) 3231{ 3232 return (s->subcode & GF_CALL_RETURN_SLOT_OPT) != 0; 3233} 3234 3235 3236/* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a 3237 thunk to the thunked-to function. */ 3238 3239static inline void 3240gimple_call_set_from_thunk (gcall *s, bool from_thunk_p) 3241{ 3242 if (from_thunk_p) 3243 s->subcode |= GF_CALL_FROM_THUNK; 3244 else 3245 s->subcode &= ~GF_CALL_FROM_THUNK; 3246} 3247 3248 3249/* Return true if GIMPLE_CALL S is a jump from a thunk. */ 3250 3251static inline bool 3252gimple_call_from_thunk_p (gcall *s) 3253{ 3254 return (s->subcode & GF_CALL_FROM_THUNK) != 0; 3255} 3256 3257 3258/* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the 3259 argument pack in its argument list. */ 3260 3261static inline void 3262gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p) 3263{ 3264 if (pass_arg_pack_p) 3265 s->subcode |= GF_CALL_VA_ARG_PACK; 3266 else 3267 s->subcode &= ~GF_CALL_VA_ARG_PACK; 3268} 3269 3270 3271/* Return true if GIMPLE_CALL S is a stdarg call that needs the 3272 argument pack in its argument list. */ 3273 3274static inline bool 3275gimple_call_va_arg_pack_p (gcall *s) 3276{ 3277 return (s->subcode & GF_CALL_VA_ARG_PACK) != 0; 3278} 3279 3280 3281/* Return true if S is a noreturn call. */ 3282 3283static inline bool 3284gimple_call_noreturn_p (const gcall *s) 3285{ 3286 return (gimple_call_flags (s) & ECF_NORETURN) != 0; 3287} 3288 3289static inline bool 3290gimple_call_noreturn_p (const gimple *s) 3291{ 3292 const gcall *gc = GIMPLE_CHECK2<const gcall *> (s); 3293 return gimple_call_noreturn_p (gc); 3294} 3295 3296 3297/* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw 3298 even if the called function can throw in other cases. */ 3299 3300static inline void 3301gimple_call_set_nothrow (gcall *s, bool nothrow_p) 3302{ 3303 if (nothrow_p) 3304 s->subcode |= GF_CALL_NOTHROW; 3305 else 3306 s->subcode &= ~GF_CALL_NOTHROW; 3307} 3308 3309/* Return true if S is a nothrow call. */ 3310 3311static inline bool 3312gimple_call_nothrow_p (gcall *s) 3313{ 3314 return (gimple_call_flags (s) & ECF_NOTHROW) != 0; 3315} 3316 3317/* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that 3318 is known to be emitted for VLA objects. Those are wrapped by 3319 stack_save/stack_restore calls and hence can't lead to unbounded 3320 stack growth even when they occur in loops. */ 3321 3322static inline void 3323gimple_call_set_alloca_for_var (gcall *s, bool for_var) 3324{ 3325 if (for_var) 3326 s->subcode |= GF_CALL_ALLOCA_FOR_VAR; 3327 else 3328 s->subcode &= ~GF_CALL_ALLOCA_FOR_VAR; 3329} 3330 3331/* Return true of S is a call to builtin_alloca emitted for VLA objects. */ 3332 3333static inline bool 3334gimple_call_alloca_for_var_p (gcall *s) 3335{ 3336 return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0; 3337} 3338 3339/* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */ 3340 3341static inline void 3342gimple_call_copy_flags (gcall *dest_call, gcall *orig_call) 3343{ 3344 dest_call->subcode = orig_call->subcode; 3345} 3346 3347 3348/* Return a pointer to the points-to solution for the set of call-used 3349 variables of the call CALL_STMT. */ 3350 3351static inline struct pt_solution * 3352gimple_call_use_set (gcall *call_stmt) 3353{ 3354 return &call_stmt->call_used; 3355} 3356 3357 3358/* Return a pointer to the points-to solution for the set of call-used 3359 variables of the call CALL_STMT. */ 3360 3361static inline struct pt_solution * 3362gimple_call_clobber_set (gcall *call_stmt) 3363{ 3364 return &call_stmt->call_clobbered; 3365} 3366 3367 3368/* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a 3369 non-NULL lhs. */ 3370 3371static inline bool 3372gimple_has_lhs (gimple *stmt) 3373{ 3374 if (is_gimple_assign (stmt)) 3375 return true; 3376 if (gcall *call = dyn_cast <gcall *> (stmt)) 3377 return gimple_call_lhs (call) != NULL_TREE; 3378 return false; 3379} 3380 3381 3382/* Return the code of the predicate computed by conditional statement GS. */ 3383 3384static inline enum tree_code 3385gimple_cond_code (const gcond *gs) 3386{ 3387 return (enum tree_code) gs->subcode; 3388} 3389 3390static inline enum tree_code 3391gimple_cond_code (const gimple *gs) 3392{ 3393 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs); 3394 return gimple_cond_code (gc); 3395} 3396 3397 3398/* Set CODE to be the predicate code for the conditional statement GS. */ 3399 3400static inline void 3401gimple_cond_set_code (gcond *gs, enum tree_code code) 3402{ 3403 gs->subcode = code; 3404} 3405 3406 3407/* Return the LHS of the predicate computed by conditional statement GS. */ 3408 3409static inline tree 3410gimple_cond_lhs (const gcond *gs) 3411{ 3412 return gs->op[0]; 3413} 3414 3415static inline tree 3416gimple_cond_lhs (const gimple *gs) 3417{ 3418 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs); 3419 return gimple_cond_lhs (gc); 3420} 3421 3422/* Return the pointer to the LHS of the predicate computed by conditional 3423 statement GS. */ 3424 3425static inline tree * 3426gimple_cond_lhs_ptr (gcond *gs) 3427{ 3428 return &gs->op[0]; 3429} 3430 3431/* Set LHS to be the LHS operand of the predicate computed by 3432 conditional statement GS. */ 3433 3434static inline void 3435gimple_cond_set_lhs (gcond *gs, tree lhs) 3436{ 3437 gs->op[0] = lhs; 3438} 3439 3440 3441/* Return the RHS operand of the predicate computed by conditional GS. */ 3442 3443static inline tree 3444gimple_cond_rhs (const gcond *gs) 3445{ 3446 return gs->op[1]; 3447} 3448 3449static inline tree 3450gimple_cond_rhs (const gimple *gs) 3451{ 3452 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs); 3453 return gimple_cond_rhs (gc); 3454} 3455 3456/* Return the pointer to the RHS operand of the predicate computed by 3457 conditional GS. */ 3458 3459static inline tree * 3460gimple_cond_rhs_ptr (gcond *gs) 3461{ 3462 return &gs->op[1]; 3463} 3464 3465 3466/* Set RHS to be the RHS operand of the predicate computed by 3467 conditional statement GS. */ 3468 3469static inline void 3470gimple_cond_set_rhs (gcond *gs, tree rhs) 3471{ 3472 gs->op[1] = rhs; 3473} 3474 3475 3476/* Return the label used by conditional statement GS when its 3477 predicate evaluates to true. */ 3478 3479static inline tree 3480gimple_cond_true_label (const gcond *gs) 3481{ 3482 return gs->op[2]; 3483} 3484 3485 3486/* Set LABEL to be the label used by conditional statement GS when its 3487 predicate evaluates to true. */ 3488 3489static inline void 3490gimple_cond_set_true_label (gcond *gs, tree label) 3491{ 3492 gs->op[2] = label; 3493} 3494 3495 3496/* Set LABEL to be the label used by conditional statement GS when its 3497 predicate evaluates to false. */ 3498 3499static inline void 3500gimple_cond_set_false_label (gcond *gs, tree label) 3501{ 3502 gs->op[3] = label; 3503} 3504 3505 3506/* Return the label used by conditional statement GS when its 3507 predicate evaluates to false. */ 3508 3509static inline tree 3510gimple_cond_false_label (const gcond *gs) 3511{ 3512 return gs->op[3]; 3513} 3514 3515 3516/* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */ 3517 3518static inline void 3519gimple_cond_make_false (gcond *gs) 3520{ 3521 gimple_cond_set_lhs (gs, boolean_false_node); 3522 gimple_cond_set_rhs (gs, boolean_false_node); 3523 gs->subcode = NE_EXPR; 3524} 3525 3526 3527/* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */ 3528 3529static inline void 3530gimple_cond_make_true (gcond *gs) 3531{ 3532 gimple_cond_set_lhs (gs, boolean_true_node); 3533 gimple_cond_set_rhs (gs, boolean_false_node); 3534 gs->subcode = NE_EXPR; 3535} 3536 3537/* Check if conditional statemente GS is of the form 'if (1 == 1)', 3538 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */ 3539 3540static inline bool 3541gimple_cond_true_p (const gcond *gs) 3542{ 3543 tree lhs = gimple_cond_lhs (gs); 3544 tree rhs = gimple_cond_rhs (gs); 3545 enum tree_code code = gimple_cond_code (gs); 3546 3547 if (lhs != boolean_true_node && lhs != boolean_false_node) 3548 return false; 3549 3550 if (rhs != boolean_true_node && rhs != boolean_false_node) 3551 return false; 3552 3553 if (code == NE_EXPR && lhs != rhs) 3554 return true; 3555 3556 if (code == EQ_EXPR && lhs == rhs) 3557 return true; 3558 3559 return false; 3560} 3561 3562/* Check if conditional statement GS is of the form 'if (1 != 1)', 3563 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */ 3564 3565static inline bool 3566gimple_cond_false_p (const gcond *gs) 3567{ 3568 tree lhs = gimple_cond_lhs (gs); 3569 tree rhs = gimple_cond_rhs (gs); 3570 enum tree_code code = gimple_cond_code (gs); 3571 3572 if (lhs != boolean_true_node && lhs != boolean_false_node) 3573 return false; 3574 3575 if (rhs != boolean_true_node && rhs != boolean_false_node) 3576 return false; 3577 3578 if (code == NE_EXPR && lhs == rhs) 3579 return true; 3580 3581 if (code == EQ_EXPR && lhs != rhs) 3582 return true; 3583 3584 return false; 3585} 3586 3587/* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */ 3588 3589static inline void 3590gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs, 3591 tree rhs) 3592{ 3593 gimple_cond_set_code (stmt, code); 3594 gimple_cond_set_lhs (stmt, lhs); 3595 gimple_cond_set_rhs (stmt, rhs); 3596} 3597 3598/* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */ 3599 3600static inline tree 3601gimple_label_label (const glabel *gs) 3602{ 3603 return gs->op[0]; 3604} 3605 3606 3607/* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement 3608 GS. */ 3609 3610static inline void 3611gimple_label_set_label (glabel *gs, tree label) 3612{ 3613 gs->op[0] = label; 3614} 3615 3616 3617/* Return the destination of the unconditional jump GS. */ 3618 3619static inline tree 3620gimple_goto_dest (const gimple *gs) 3621{ 3622 GIMPLE_CHECK (gs, GIMPLE_GOTO); 3623 return gimple_op (gs, 0); 3624} 3625 3626 3627/* Set DEST to be the destination of the unconditonal jump GS. */ 3628 3629static inline void 3630gimple_goto_set_dest (ggoto *gs, tree dest) 3631{ 3632 gs->op[0] = dest; 3633} 3634 3635 3636/* Return the variables declared in the GIMPLE_BIND statement GS. */ 3637 3638static inline tree 3639gimple_bind_vars (const gbind *bind_stmt) 3640{ 3641 return bind_stmt->vars; 3642} 3643 3644 3645/* Set VARS to be the set of variables declared in the GIMPLE_BIND 3646 statement GS. */ 3647 3648static inline void 3649gimple_bind_set_vars (gbind *bind_stmt, tree vars) 3650{ 3651 bind_stmt->vars = vars; 3652} 3653 3654 3655/* Append VARS to the set of variables declared in the GIMPLE_BIND 3656 statement GS. */ 3657 3658static inline void 3659gimple_bind_append_vars (gbind *bind_stmt, tree vars) 3660{ 3661 bind_stmt->vars = chainon (bind_stmt->vars, vars); 3662} 3663 3664 3665static inline gimple_seq * 3666gimple_bind_body_ptr (gbind *bind_stmt) 3667{ 3668 return &bind_stmt->body; 3669} 3670 3671/* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */ 3672 3673static inline gimple_seq 3674gimple_bind_body (gbind *gs) 3675{ 3676 return *gimple_bind_body_ptr (gs); 3677} 3678 3679 3680/* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND 3681 statement GS. */ 3682 3683static inline void 3684gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq) 3685{ 3686 bind_stmt->body = seq; 3687} 3688 3689 3690/* Append a statement to the end of a GIMPLE_BIND's body. */ 3691 3692static inline void 3693gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt) 3694{ 3695 gimple_seq_add_stmt (&bind_stmt->body, stmt); 3696} 3697 3698 3699/* Append a sequence of statements to the end of a GIMPLE_BIND's body. */ 3700 3701static inline void 3702gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq) 3703{ 3704 gimple_seq_add_seq (&bind_stmt->body, seq); 3705} 3706 3707 3708/* Return the TREE_BLOCK node associated with GIMPLE_BIND statement 3709 GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */ 3710 3711static inline tree 3712gimple_bind_block (const gbind *bind_stmt) 3713{ 3714 return bind_stmt->block; 3715} 3716 3717 3718/* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND 3719 statement GS. */ 3720 3721static inline void 3722gimple_bind_set_block (gbind *bind_stmt, tree block) 3723{ 3724 gcc_gimple_checking_assert (block == NULL_TREE 3725 || TREE_CODE (block) == BLOCK); 3726 bind_stmt->block = block; 3727} 3728 3729 3730/* Return the number of input operands for GIMPLE_ASM ASM_STMT. */ 3731 3732static inline unsigned 3733gimple_asm_ninputs (const gasm *asm_stmt) 3734{ 3735 return asm_stmt->ni; 3736} 3737 3738 3739/* Return the number of output operands for GIMPLE_ASM ASM_STMT. */ 3740 3741static inline unsigned 3742gimple_asm_noutputs (const gasm *asm_stmt) 3743{ 3744 return asm_stmt->no; 3745} 3746 3747 3748/* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */ 3749 3750static inline unsigned 3751gimple_asm_nclobbers (const gasm *asm_stmt) 3752{ 3753 return asm_stmt->nc; 3754} 3755 3756/* Return the number of label operands for GIMPLE_ASM ASM_STMT. */ 3757 3758static inline unsigned 3759gimple_asm_nlabels (const gasm *asm_stmt) 3760{ 3761 return asm_stmt->nl; 3762} 3763 3764/* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */ 3765 3766static inline tree 3767gimple_asm_input_op (const gasm *asm_stmt, unsigned index) 3768{ 3769 gcc_gimple_checking_assert (index < asm_stmt->ni); 3770 return asm_stmt->op[index + asm_stmt->no]; 3771} 3772 3773/* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */ 3774 3775static inline void 3776gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op) 3777{ 3778 gcc_gimple_checking_assert (index < asm_stmt->ni 3779 && TREE_CODE (in_op) == TREE_LIST); 3780 asm_stmt->op[index + asm_stmt->no] = in_op; 3781} 3782 3783 3784/* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */ 3785 3786static inline tree 3787gimple_asm_output_op (const gasm *asm_stmt, unsigned index) 3788{ 3789 gcc_gimple_checking_assert (index < asm_stmt->no); 3790 return asm_stmt->op[index]; 3791} 3792 3793/* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */ 3794 3795static inline void 3796gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op) 3797{ 3798 gcc_gimple_checking_assert (index < asm_stmt->no 3799 && TREE_CODE (out_op) == TREE_LIST); 3800 asm_stmt->op[index] = out_op; 3801} 3802 3803 3804/* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */ 3805 3806static inline tree 3807gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index) 3808{ 3809 gcc_gimple_checking_assert (index < asm_stmt->nc); 3810 return asm_stmt->op[index + asm_stmt->ni + asm_stmt->no]; 3811} 3812 3813 3814/* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */ 3815 3816static inline void 3817gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op) 3818{ 3819 gcc_gimple_checking_assert (index < asm_stmt->nc 3820 && TREE_CODE (clobber_op) == TREE_LIST); 3821 asm_stmt->op[index + asm_stmt->ni + asm_stmt->no] = clobber_op; 3822} 3823 3824/* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */ 3825 3826static inline tree 3827gimple_asm_label_op (const gasm *asm_stmt, unsigned index) 3828{ 3829 gcc_gimple_checking_assert (index < asm_stmt->nl); 3830 return asm_stmt->op[index + asm_stmt->ni + asm_stmt->nc]; 3831} 3832 3833/* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */ 3834 3835static inline void 3836gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op) 3837{ 3838 gcc_gimple_checking_assert (index < asm_stmt->nl 3839 && TREE_CODE (label_op) == TREE_LIST); 3840 asm_stmt->op[index + asm_stmt->ni + asm_stmt->nc] = label_op; 3841} 3842 3843/* Return the string representing the assembly instruction in 3844 GIMPLE_ASM ASM_STMT. */ 3845 3846static inline const char * 3847gimple_asm_string (const gasm *asm_stmt) 3848{ 3849 return asm_stmt->string; 3850} 3851 3852 3853/* Return true ASM_STMT ASM_STMT is an asm statement marked volatile. */ 3854 3855static inline bool 3856gimple_asm_volatile_p (const gasm *asm_stmt) 3857{ 3858 return (asm_stmt->subcode & GF_ASM_VOLATILE) != 0; 3859} 3860 3861 3862/* If VOLATLE_P is true, mark asm statement ASM_STMT as volatile. */ 3863 3864static inline void 3865gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p) 3866{ 3867 if (volatile_p) 3868 asm_stmt->subcode |= GF_ASM_VOLATILE; 3869 else 3870 asm_stmt->subcode &= ~GF_ASM_VOLATILE; 3871} 3872 3873 3874/* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT. */ 3875 3876static inline void 3877gimple_asm_set_input (gasm *asm_stmt, bool input_p) 3878{ 3879 if (input_p) 3880 asm_stmt->subcode |= GF_ASM_INPUT; 3881 else 3882 asm_stmt->subcode &= ~GF_ASM_INPUT; 3883} 3884 3885 3886/* Return true if asm ASM_STMT is an ASM_INPUT. */ 3887 3888static inline bool 3889gimple_asm_input_p (const gasm *asm_stmt) 3890{ 3891 return (asm_stmt->subcode & GF_ASM_INPUT) != 0; 3892} 3893 3894 3895/* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */ 3896 3897static inline tree 3898gimple_catch_types (const gcatch *catch_stmt) 3899{ 3900 return catch_stmt->types; 3901} 3902 3903 3904/* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */ 3905 3906static inline tree * 3907gimple_catch_types_ptr (gcatch *catch_stmt) 3908{ 3909 return &catch_stmt->types; 3910} 3911 3912 3913/* Return a pointer to the GIMPLE sequence representing the body of 3914 the handler of GIMPLE_CATCH statement CATCH_STMT. */ 3915 3916static inline gimple_seq * 3917gimple_catch_handler_ptr (gcatch *catch_stmt) 3918{ 3919 return &catch_stmt->handler; 3920} 3921 3922 3923/* Return the GIMPLE sequence representing the body of the handler of 3924 GIMPLE_CATCH statement CATCH_STMT. */ 3925 3926static inline gimple_seq 3927gimple_catch_handler (gcatch *catch_stmt) 3928{ 3929 return *gimple_catch_handler_ptr (catch_stmt); 3930} 3931 3932 3933/* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT. */ 3934 3935static inline void 3936gimple_catch_set_types (gcatch *catch_stmt, tree t) 3937{ 3938 catch_stmt->types = t; 3939} 3940 3941 3942/* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */ 3943 3944static inline void 3945gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler) 3946{ 3947 catch_stmt->handler = handler; 3948} 3949 3950 3951/* Return the types handled by GIMPLE_EH_FILTER statement GS. */ 3952 3953static inline tree 3954gimple_eh_filter_types (const gimple *gs) 3955{ 3956 const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs); 3957 return eh_filter_stmt->types; 3958} 3959 3960 3961/* Return a pointer to the types handled by GIMPLE_EH_FILTER statement 3962 GS. */ 3963 3964static inline tree * 3965gimple_eh_filter_types_ptr (gimple *gs) 3966{ 3967 geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs); 3968 return &eh_filter_stmt->types; 3969} 3970 3971 3972/* Return a pointer to the sequence of statement to execute when 3973 GIMPLE_EH_FILTER statement fails. */ 3974 3975static inline gimple_seq * 3976gimple_eh_filter_failure_ptr (gimple *gs) 3977{ 3978 geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs); 3979 return &eh_filter_stmt->failure; 3980} 3981 3982 3983/* Return the sequence of statement to execute when GIMPLE_EH_FILTER 3984 statement fails. */ 3985 3986static inline gimple_seq 3987gimple_eh_filter_failure (gimple *gs) 3988{ 3989 return *gimple_eh_filter_failure_ptr (gs); 3990} 3991 3992 3993/* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER 3994 EH_FILTER_STMT. */ 3995 3996static inline void 3997gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types) 3998{ 3999 eh_filter_stmt->types = types; 4000} 4001 4002 4003/* Set FAILURE to be the sequence of statements to execute on failure 4004 for GIMPLE_EH_FILTER EH_FILTER_STMT. */ 4005 4006static inline void 4007gimple_eh_filter_set_failure (geh_filter *eh_filter_stmt, 4008 gimple_seq failure) 4009{ 4010 eh_filter_stmt->failure = failure; 4011} 4012 4013/* Get the function decl to be called by the MUST_NOT_THROW region. */ 4014 4015static inline tree 4016gimple_eh_must_not_throw_fndecl (geh_mnt *eh_mnt_stmt) 4017{ 4018 return eh_mnt_stmt->fndecl; 4019} 4020 4021/* Set the function decl to be called by GS to DECL. */ 4022 4023static inline void 4024gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt, 4025 tree decl) 4026{ 4027 eh_mnt_stmt->fndecl = decl; 4028} 4029 4030/* GIMPLE_EH_ELSE accessors. */ 4031 4032static inline gimple_seq * 4033gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt) 4034{ 4035 return &eh_else_stmt->n_body; 4036} 4037 4038static inline gimple_seq 4039gimple_eh_else_n_body (geh_else *eh_else_stmt) 4040{ 4041 return *gimple_eh_else_n_body_ptr (eh_else_stmt); 4042} 4043 4044static inline gimple_seq * 4045gimple_eh_else_e_body_ptr (geh_else *eh_else_stmt) 4046{ 4047 return &eh_else_stmt->e_body; 4048} 4049 4050static inline gimple_seq 4051gimple_eh_else_e_body (geh_else *eh_else_stmt) 4052{ 4053 return *gimple_eh_else_e_body_ptr (eh_else_stmt); 4054} 4055 4056static inline void 4057gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq) 4058{ 4059 eh_else_stmt->n_body = seq; 4060} 4061 4062static inline void 4063gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq) 4064{ 4065 eh_else_stmt->e_body = seq; 4066} 4067 4068/* GIMPLE_TRY accessors. */ 4069 4070/* Return the kind of try block represented by GIMPLE_TRY GS. This is 4071 either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */ 4072 4073static inline enum gimple_try_flags 4074gimple_try_kind (const gimple *gs) 4075{ 4076 GIMPLE_CHECK (gs, GIMPLE_TRY); 4077 return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND); 4078} 4079 4080 4081/* Set the kind of try block represented by GIMPLE_TRY GS. */ 4082 4083static inline void 4084gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind) 4085{ 4086 gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH 4087 || kind == GIMPLE_TRY_FINALLY); 4088 if (gimple_try_kind (gs) != kind) 4089 gs->subcode = (unsigned int) kind; 4090} 4091 4092 4093/* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */ 4094 4095static inline bool 4096gimple_try_catch_is_cleanup (const gimple *gs) 4097{ 4098 gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH); 4099 return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0; 4100} 4101 4102 4103/* Return a pointer to the sequence of statements used as the 4104 body for GIMPLE_TRY GS. */ 4105 4106static inline gimple_seq * 4107gimple_try_eval_ptr (gimple *gs) 4108{ 4109 gtry *try_stmt = as_a <gtry *> (gs); 4110 return &try_stmt->eval; 4111} 4112 4113 4114/* Return the sequence of statements used as the body for GIMPLE_TRY GS. */ 4115 4116static inline gimple_seq 4117gimple_try_eval (gimple *gs) 4118{ 4119 return *gimple_try_eval_ptr (gs); 4120} 4121 4122 4123/* Return a pointer to the sequence of statements used as the cleanup body for 4124 GIMPLE_TRY GS. */ 4125 4126static inline gimple_seq * 4127gimple_try_cleanup_ptr (gimple *gs) 4128{ 4129 gtry *try_stmt = as_a <gtry *> (gs); 4130 return &try_stmt->cleanup; 4131} 4132 4133 4134/* Return the sequence of statements used as the cleanup body for 4135 GIMPLE_TRY GS. */ 4136 4137static inline gimple_seq 4138gimple_try_cleanup (gimple *gs) 4139{ 4140 return *gimple_try_cleanup_ptr (gs); 4141} 4142 4143 4144/* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */ 4145 4146static inline void 4147gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup) 4148{ 4149 gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH); 4150 if (catch_is_cleanup) 4151 g->subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP; 4152 else 4153 g->subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP; 4154} 4155 4156 4157/* Set EVAL to be the sequence of statements to use as the body for 4158 GIMPLE_TRY TRY_STMT. */ 4159 4160static inline void 4161gimple_try_set_eval (gtry *try_stmt, gimple_seq eval) 4162{ 4163 try_stmt->eval = eval; 4164} 4165 4166 4167/* Set CLEANUP to be the sequence of statements to use as the cleanup 4168 body for GIMPLE_TRY TRY_STMT. */ 4169 4170static inline void 4171gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup) 4172{ 4173 try_stmt->cleanup = cleanup; 4174} 4175 4176 4177/* Return a pointer to the cleanup sequence for cleanup statement GS. */ 4178 4179static inline gimple_seq * 4180gimple_wce_cleanup_ptr (gimple *gs) 4181{ 4182 gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs); 4183 return &wce_stmt->cleanup; 4184} 4185 4186 4187/* Return the cleanup sequence for cleanup statement GS. */ 4188 4189static inline gimple_seq 4190gimple_wce_cleanup (gimple *gs) 4191{ 4192 return *gimple_wce_cleanup_ptr (gs); 4193} 4194 4195 4196/* Set CLEANUP to be the cleanup sequence for GS. */ 4197 4198static inline void 4199gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup) 4200{ 4201 gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs); 4202 wce_stmt->cleanup = cleanup; 4203} 4204 4205 4206/* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */ 4207 4208static inline bool 4209gimple_wce_cleanup_eh_only (const gimple *gs) 4210{ 4211 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR); 4212 return gs->subcode != 0; 4213} 4214 4215 4216/* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */ 4217 4218static inline void 4219gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p) 4220{ 4221 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR); 4222 gs->subcode = (unsigned int) eh_only_p; 4223} 4224 4225 4226/* Return the maximum number of arguments supported by GIMPLE_PHI GS. */ 4227 4228static inline unsigned 4229gimple_phi_capacity (const gimple *gs) 4230{ 4231 const gphi *phi_stmt = as_a <const gphi *> (gs); 4232 return phi_stmt->capacity; 4233} 4234 4235 4236/* Return the number of arguments in GIMPLE_PHI GS. This must always 4237 be exactly the number of incoming edges for the basic block holding 4238 GS. */ 4239 4240static inline unsigned 4241gimple_phi_num_args (const gimple *gs) 4242{ 4243 const gphi *phi_stmt = as_a <const gphi *> (gs); 4244 return phi_stmt->nargs; 4245} 4246 4247 4248/* Return the SSA name created by GIMPLE_PHI GS. */ 4249 4250static inline tree 4251gimple_phi_result (const gimple *gs) 4252{ 4253 const gphi *phi_stmt = as_a <const gphi *> (gs); 4254 return phi_stmt->result; 4255} 4256 4257/* Return a pointer to the SSA name created by GIMPLE_PHI GS. */ 4258 4259static inline tree * 4260gimple_phi_result_ptr (gimple *gs) 4261{ 4262 gphi *phi_stmt = as_a <gphi *> (gs); 4263 return &phi_stmt->result; 4264} 4265 4266/* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */ 4267 4268static inline void 4269gimple_phi_set_result (gphi *phi, tree result) 4270{ 4271 phi->result = result; 4272 if (result && TREE_CODE (result) == SSA_NAME) 4273 SSA_NAME_DEF_STMT (result) = phi; 4274} 4275 4276 4277/* Return the PHI argument corresponding to incoming edge INDEX for 4278 GIMPLE_PHI GS. */ 4279 4280static inline struct phi_arg_d * 4281gimple_phi_arg (gimple *gs, unsigned index) 4282{ 4283 gphi *phi_stmt = as_a <gphi *> (gs); 4284 gcc_gimple_checking_assert (index <= phi_stmt->capacity); 4285 return &(phi_stmt->args[index]); 4286} 4287 4288/* Set PHIARG to be the argument corresponding to incoming edge INDEX 4289 for GIMPLE_PHI PHI. */ 4290 4291static inline void 4292gimple_phi_set_arg (gphi *phi, unsigned index, struct phi_arg_d * phiarg) 4293{ 4294 gcc_gimple_checking_assert (index <= phi->nargs); 4295 phi->args[index] = *phiarg; 4296} 4297 4298/* Return the PHI nodes for basic block BB, or NULL if there are no 4299 PHI nodes. */ 4300 4301static inline gimple_seq 4302phi_nodes (const_basic_block bb) 4303{ 4304 gcc_checking_assert (!(bb->flags & BB_RTL)); 4305 return bb->il.gimple.phi_nodes; 4306} 4307 4308/* Return a pointer to the PHI nodes for basic block BB. */ 4309 4310static inline gimple_seq * 4311phi_nodes_ptr (basic_block bb) 4312{ 4313 gcc_checking_assert (!(bb->flags & BB_RTL)); 4314 return &bb->il.gimple.phi_nodes; 4315} 4316 4317/* Return the tree operand for argument I of PHI node GS. */ 4318 4319static inline tree 4320gimple_phi_arg_def (gimple *gs, size_t index) 4321{ 4322 return gimple_phi_arg (gs, index)->def; 4323} 4324 4325 4326/* Return a pointer to the tree operand for argument I of phi node PHI. */ 4327 4328static inline tree * 4329gimple_phi_arg_def_ptr (gphi *phi, size_t index) 4330{ 4331 return &gimple_phi_arg (phi, index)->def; 4332} 4333 4334/* Return the edge associated with argument I of phi node PHI. */ 4335 4336static inline edge 4337gimple_phi_arg_edge (gphi *phi, size_t i) 4338{ 4339 return EDGE_PRED (gimple_bb (phi), i); 4340} 4341 4342/* Return the source location of gimple argument I of phi node PHI. */ 4343 4344static inline source_location 4345gimple_phi_arg_location (gphi *phi, size_t i) 4346{ 4347 return gimple_phi_arg (phi, i)->locus; 4348} 4349 4350/* Return the source location of the argument on edge E of phi node PHI. */ 4351 4352static inline source_location 4353gimple_phi_arg_location_from_edge (gphi *phi, edge e) 4354{ 4355 return gimple_phi_arg (phi, e->dest_idx)->locus; 4356} 4357 4358/* Set the source location of gimple argument I of phi node PHI to LOC. */ 4359 4360static inline void 4361gimple_phi_arg_set_location (gphi *phi, size_t i, source_location loc) 4362{ 4363 gimple_phi_arg (phi, i)->locus = loc; 4364} 4365 4366/* Return TRUE if argument I of phi node PHI has a location record. */ 4367 4368static inline bool 4369gimple_phi_arg_has_location (gphi *phi, size_t i) 4370{ 4371 return gimple_phi_arg_location (phi, i) != UNKNOWN_LOCATION; 4372} 4373 4374 4375/* Return the region number for GIMPLE_RESX RESX_STMT. */ 4376 4377static inline int 4378gimple_resx_region (const gresx *resx_stmt) 4379{ 4380 return resx_stmt->region; 4381} 4382 4383/* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */ 4384 4385static inline void 4386gimple_resx_set_region (gresx *resx_stmt, int region) 4387{ 4388 resx_stmt->region = region; 4389} 4390 4391/* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */ 4392 4393static inline int 4394gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt) 4395{ 4396 return eh_dispatch_stmt->region; 4397} 4398 4399/* Set REGION to be the region number for GIMPLE_EH_DISPATCH 4400 EH_DISPATCH_STMT. */ 4401 4402static inline void 4403gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region) 4404{ 4405 eh_dispatch_stmt->region = region; 4406} 4407 4408/* Return the number of labels associated with the switch statement GS. */ 4409 4410static inline unsigned 4411gimple_switch_num_labels (const gswitch *gs) 4412{ 4413 unsigned num_ops; 4414 GIMPLE_CHECK (gs, GIMPLE_SWITCH); 4415 num_ops = gimple_num_ops (gs); 4416 gcc_gimple_checking_assert (num_ops > 1); 4417 return num_ops - 1; 4418} 4419 4420 4421/* Set NLABELS to be the number of labels for the switch statement GS. */ 4422 4423static inline void 4424gimple_switch_set_num_labels (gswitch *g, unsigned nlabels) 4425{ 4426 GIMPLE_CHECK (g, GIMPLE_SWITCH); 4427 gimple_set_num_ops (g, nlabels + 1); 4428} 4429 4430 4431/* Return the index variable used by the switch statement GS. */ 4432 4433static inline tree 4434gimple_switch_index (const gswitch *gs) 4435{ 4436 return gs->op[0]; 4437} 4438 4439 4440/* Return a pointer to the index variable for the switch statement GS. */ 4441 4442static inline tree * 4443gimple_switch_index_ptr (gswitch *gs) 4444{ 4445 return &gs->op[0]; 4446} 4447 4448 4449/* Set INDEX to be the index variable for switch statement GS. */ 4450 4451static inline void 4452gimple_switch_set_index (gswitch *gs, tree index) 4453{ 4454 gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index)); 4455 gs->op[0] = index; 4456} 4457 4458 4459/* Return the label numbered INDEX. The default label is 0, followed by any 4460 labels in a switch statement. */ 4461 4462static inline tree 4463gimple_switch_label (const gswitch *gs, unsigned index) 4464{ 4465 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1); 4466 return gs->op[index + 1]; 4467} 4468 4469/* Set the label number INDEX to LABEL. 0 is always the default label. */ 4470 4471static inline void 4472gimple_switch_set_label (gswitch *gs, unsigned index, tree label) 4473{ 4474 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1 4475 && (label == NULL_TREE 4476 || TREE_CODE (label) == CASE_LABEL_EXPR)); 4477 gs->op[index + 1] = label; 4478} 4479 4480/* Return the default label for a switch statement. */ 4481 4482static inline tree 4483gimple_switch_default_label (const gswitch *gs) 4484{ 4485 tree label = gimple_switch_label (gs, 0); 4486 gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label)); 4487 return label; 4488} 4489 4490/* Set the default label for a switch statement. */ 4491 4492static inline void 4493gimple_switch_set_default_label (gswitch *gs, tree label) 4494{ 4495 gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label)); 4496 gimple_switch_set_label (gs, 0, label); 4497} 4498 4499/* Return true if GS is a GIMPLE_DEBUG statement. */ 4500 4501static inline bool 4502is_gimple_debug (const gimple *gs) 4503{ 4504 return gimple_code (gs) == GIMPLE_DEBUG; 4505} 4506 4507/* Return true if S is a GIMPLE_DEBUG BIND statement. */ 4508 4509static inline bool 4510gimple_debug_bind_p (const gimple *s) 4511{ 4512 if (is_gimple_debug (s)) 4513 return s->subcode == GIMPLE_DEBUG_BIND; 4514 4515 return false; 4516} 4517 4518/* Return the variable bound in a GIMPLE_DEBUG bind statement. */ 4519 4520static inline tree 4521gimple_debug_bind_get_var (gimple *dbg) 4522{ 4523 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4524 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4525 return gimple_op (dbg, 0); 4526} 4527 4528/* Return the value bound to the variable in a GIMPLE_DEBUG bind 4529 statement. */ 4530 4531static inline tree 4532gimple_debug_bind_get_value (gimple *dbg) 4533{ 4534 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4535 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4536 return gimple_op (dbg, 1); 4537} 4538 4539/* Return a pointer to the value bound to the variable in a 4540 GIMPLE_DEBUG bind statement. */ 4541 4542static inline tree * 4543gimple_debug_bind_get_value_ptr (gimple *dbg) 4544{ 4545 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4546 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4547 return gimple_op_ptr (dbg, 1); 4548} 4549 4550/* Set the variable bound in a GIMPLE_DEBUG bind statement. */ 4551 4552static inline void 4553gimple_debug_bind_set_var (gimple *dbg, tree var) 4554{ 4555 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4556 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4557 gimple_set_op (dbg, 0, var); 4558} 4559 4560/* Set the value bound to the variable in a GIMPLE_DEBUG bind 4561 statement. */ 4562 4563static inline void 4564gimple_debug_bind_set_value (gimple *dbg, tree value) 4565{ 4566 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4567 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4568 gimple_set_op (dbg, 1, value); 4569} 4570 4571/* The second operand of a GIMPLE_DEBUG_BIND, when the value was 4572 optimized away. */ 4573#define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */ 4574 4575/* Remove the value bound to the variable in a GIMPLE_DEBUG bind 4576 statement. */ 4577 4578static inline void 4579gimple_debug_bind_reset_value (gimple *dbg) 4580{ 4581 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4582 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4583 gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE); 4584} 4585 4586/* Return true if the GIMPLE_DEBUG bind statement is bound to a 4587 value. */ 4588 4589static inline bool 4590gimple_debug_bind_has_value_p (gimple *dbg) 4591{ 4592 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4593 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg)); 4594 return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE; 4595} 4596 4597#undef GIMPLE_DEBUG_BIND_NOVALUE 4598 4599/* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */ 4600 4601static inline bool 4602gimple_debug_source_bind_p (const gimple *s) 4603{ 4604 if (is_gimple_debug (s)) 4605 return s->subcode == GIMPLE_DEBUG_SOURCE_BIND; 4606 4607 return false; 4608} 4609 4610/* Return the variable bound in a GIMPLE_DEBUG source bind statement. */ 4611 4612static inline tree 4613gimple_debug_source_bind_get_var (gimple *dbg) 4614{ 4615 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4616 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); 4617 return gimple_op (dbg, 0); 4618} 4619 4620/* Return the value bound to the variable in a GIMPLE_DEBUG source bind 4621 statement. */ 4622 4623static inline tree 4624gimple_debug_source_bind_get_value (gimple *dbg) 4625{ 4626 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4627 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); 4628 return gimple_op (dbg, 1); 4629} 4630 4631/* Return a pointer to the value bound to the variable in a 4632 GIMPLE_DEBUG source bind statement. */ 4633 4634static inline tree * 4635gimple_debug_source_bind_get_value_ptr (gimple *dbg) 4636{ 4637 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4638 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); 4639 return gimple_op_ptr (dbg, 1); 4640} 4641 4642/* Set the variable bound in a GIMPLE_DEBUG source bind statement. */ 4643 4644static inline void 4645gimple_debug_source_bind_set_var (gimple *dbg, tree var) 4646{ 4647 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4648 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); 4649 gimple_set_op (dbg, 0, var); 4650} 4651 4652/* Set the value bound to the variable in a GIMPLE_DEBUG source bind 4653 statement. */ 4654 4655static inline void 4656gimple_debug_source_bind_set_value (gimple *dbg, tree value) 4657{ 4658 GIMPLE_CHECK (dbg, GIMPLE_DEBUG); 4659 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg)); 4660 gimple_set_op (dbg, 1, value); 4661} 4662 4663/* Return the line number for EXPR, or return -1 if we have no line 4664 number information for it. */ 4665static inline int 4666get_lineno (const gimple *stmt) 4667{ 4668 location_t loc; 4669 4670 if (!stmt) 4671 return -1; 4672 4673 loc = gimple_location (stmt); 4674 if (loc == UNKNOWN_LOCATION) 4675 return -1; 4676 4677 return LOCATION_LINE (loc); 4678} 4679 4680/* Return a pointer to the body for the OMP statement GS. */ 4681 4682static inline gimple_seq * 4683gimple_omp_body_ptr (gimple *gs) 4684{ 4685 return &static_cast <gimple_statement_omp *> (gs)->body; 4686} 4687 4688/* Return the body for the OMP statement GS. */ 4689 4690static inline gimple_seq 4691gimple_omp_body (gimple *gs) 4692{ 4693 return *gimple_omp_body_ptr (gs); 4694} 4695 4696/* Set BODY to be the body for the OMP statement GS. */ 4697 4698static inline void 4699gimple_omp_set_body (gimple *gs, gimple_seq body) 4700{ 4701 static_cast <gimple_statement_omp *> (gs)->body = body; 4702} 4703 4704 4705/* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */ 4706 4707static inline tree 4708gimple_omp_critical_name (const gomp_critical *crit_stmt) 4709{ 4710 return crit_stmt->name; 4711} 4712 4713 4714/* Return a pointer to the name associated with OMP critical statement 4715 CRIT_STMT. */ 4716 4717static inline tree * 4718gimple_omp_critical_name_ptr (gomp_critical *crit_stmt) 4719{ 4720 return &crit_stmt->name; 4721} 4722 4723 4724/* Set NAME to be the name associated with OMP critical statement 4725 CRIT_STMT. */ 4726 4727static inline void 4728gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name) 4729{ 4730 crit_stmt->name = name; 4731} 4732 4733 4734/* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */ 4735 4736static inline tree 4737gimple_omp_critical_clauses (const gomp_critical *crit_stmt) 4738{ 4739 return crit_stmt->clauses; 4740} 4741 4742 4743/* Return a pointer to the clauses associated with OMP critical statement 4744 CRIT_STMT. */ 4745 4746static inline tree * 4747gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt) 4748{ 4749 return &crit_stmt->clauses; 4750} 4751 4752 4753/* Set CLAUSES to be the clauses associated with OMP critical statement 4754 CRIT_STMT. */ 4755 4756static inline void 4757gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses) 4758{ 4759 crit_stmt->clauses = clauses; 4760} 4761 4762 4763/* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */ 4764 4765static inline tree 4766gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt) 4767{ 4768 return ord_stmt->clauses; 4769} 4770 4771 4772/* Return a pointer to the clauses associated with OMP ordered statement 4773 ORD_STMT. */ 4774 4775static inline tree * 4776gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt) 4777{ 4778 return &ord_stmt->clauses; 4779} 4780 4781 4782/* Set CLAUSES to be the clauses associated with OMP ordered statement 4783 ORD_STMT. */ 4784 4785static inline void 4786gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses) 4787{ 4788 ord_stmt->clauses = clauses; 4789} 4790 4791 4792/* Return the kind of the OMP_FOR statemement G. */ 4793 4794static inline int 4795gimple_omp_for_kind (const gimple *g) 4796{ 4797 GIMPLE_CHECK (g, GIMPLE_OMP_FOR); 4798 return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK); 4799} 4800 4801 4802/* Set the kind of the OMP_FOR statement G. */ 4803 4804static inline void 4805gimple_omp_for_set_kind (gomp_for *g, int kind) 4806{ 4807 g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK) 4808 | (kind & GF_OMP_FOR_KIND_MASK); 4809} 4810 4811 4812/* Return true if OMP_FOR statement G has the 4813 GF_OMP_FOR_COMBINED flag set. */ 4814 4815static inline bool 4816gimple_omp_for_combined_p (const gimple *g) 4817{ 4818 GIMPLE_CHECK (g, GIMPLE_OMP_FOR); 4819 return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0; 4820} 4821 4822 4823/* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on 4824 the boolean value of COMBINED_P. */ 4825 4826static inline void 4827gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p) 4828{ 4829 if (combined_p) 4830 g->subcode |= GF_OMP_FOR_COMBINED; 4831 else 4832 g->subcode &= ~GF_OMP_FOR_COMBINED; 4833} 4834 4835 4836/* Return true if the OMP_FOR statement G has the 4837 GF_OMP_FOR_COMBINED_INTO flag set. */ 4838 4839static inline bool 4840gimple_omp_for_combined_into_p (const gimple *g) 4841{ 4842 GIMPLE_CHECK (g, GIMPLE_OMP_FOR); 4843 return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0; 4844} 4845 4846 4847/* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending 4848 on the boolean value of COMBINED_P. */ 4849 4850static inline void 4851gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p) 4852{ 4853 if (combined_p) 4854 g->subcode |= GF_OMP_FOR_COMBINED_INTO; 4855 else 4856 g->subcode &= ~GF_OMP_FOR_COMBINED_INTO; 4857} 4858 4859 4860/* Return the clauses associated with the OMP_FOR statement GS. */ 4861 4862static inline tree 4863gimple_omp_for_clauses (const gimple *gs) 4864{ 4865 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs); 4866 return omp_for_stmt->clauses; 4867} 4868 4869 4870/* Return a pointer to the clauses associated with the OMP_FOR statement 4871 GS. */ 4872 4873static inline tree * 4874gimple_omp_for_clauses_ptr (gimple *gs) 4875{ 4876 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4877 return &omp_for_stmt->clauses; 4878} 4879 4880 4881/* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement 4882 GS. */ 4883 4884static inline void 4885gimple_omp_for_set_clauses (gimple *gs, tree clauses) 4886{ 4887 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4888 omp_for_stmt->clauses = clauses; 4889} 4890 4891 4892/* Get the collapse count of the OMP_FOR statement GS. */ 4893 4894static inline size_t 4895gimple_omp_for_collapse (gimple *gs) 4896{ 4897 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4898 return omp_for_stmt->collapse; 4899} 4900 4901 4902/* Return the condition code associated with the OMP_FOR statement GS. */ 4903 4904static inline enum tree_code 4905gimple_omp_for_cond (const gimple *gs, size_t i) 4906{ 4907 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs); 4908 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4909 return omp_for_stmt->iter[i].cond; 4910} 4911 4912 4913/* Set COND to be the condition code for the OMP_FOR statement GS. */ 4914 4915static inline void 4916gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond) 4917{ 4918 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4919 gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison 4920 && i < omp_for_stmt->collapse); 4921 omp_for_stmt->iter[i].cond = cond; 4922} 4923 4924 4925/* Return the index variable for the OMP_FOR statement GS. */ 4926 4927static inline tree 4928gimple_omp_for_index (const gimple *gs, size_t i) 4929{ 4930 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs); 4931 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4932 return omp_for_stmt->iter[i].index; 4933} 4934 4935 4936/* Return a pointer to the index variable for the OMP_FOR statement GS. */ 4937 4938static inline tree * 4939gimple_omp_for_index_ptr (gimple *gs, size_t i) 4940{ 4941 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4942 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4943 return &omp_for_stmt->iter[i].index; 4944} 4945 4946 4947/* Set INDEX to be the index variable for the OMP_FOR statement GS. */ 4948 4949static inline void 4950gimple_omp_for_set_index (gimple *gs, size_t i, tree index) 4951{ 4952 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4953 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4954 omp_for_stmt->iter[i].index = index; 4955} 4956 4957 4958/* Return the initial value for the OMP_FOR statement GS. */ 4959 4960static inline tree 4961gimple_omp_for_initial (const gimple *gs, size_t i) 4962{ 4963 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs); 4964 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4965 return omp_for_stmt->iter[i].initial; 4966} 4967 4968 4969/* Return a pointer to the initial value for the OMP_FOR statement GS. */ 4970 4971static inline tree * 4972gimple_omp_for_initial_ptr (gimple *gs, size_t i) 4973{ 4974 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4975 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4976 return &omp_for_stmt->iter[i].initial; 4977} 4978 4979 4980/* Set INITIAL to be the initial value for the OMP_FOR statement GS. */ 4981 4982static inline void 4983gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial) 4984{ 4985 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 4986 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4987 omp_for_stmt->iter[i].initial = initial; 4988} 4989 4990 4991/* Return the final value for the OMP_FOR statement GS. */ 4992 4993static inline tree 4994gimple_omp_for_final (const gimple *gs, size_t i) 4995{ 4996 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs); 4997 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 4998 return omp_for_stmt->iter[i].final; 4999} 5000 5001 5002/* Return a pointer to the final value for the OMP_FOR statement GS. */ 5003 5004static inline tree * 5005gimple_omp_for_final_ptr (gimple *gs, size_t i) 5006{ 5007 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 5008 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 5009 return &omp_for_stmt->iter[i].final; 5010} 5011 5012 5013/* Set FINAL to be the final value for the OMP_FOR statement GS. */ 5014 5015static inline void 5016gimple_omp_for_set_final (gimple *gs, size_t i, tree final) 5017{ 5018 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 5019 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 5020 omp_for_stmt->iter[i].final = final; 5021} 5022 5023 5024/* Return the increment value for the OMP_FOR statement GS. */ 5025 5026static inline tree 5027gimple_omp_for_incr (const gimple *gs, size_t i) 5028{ 5029 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs); 5030 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 5031 return omp_for_stmt->iter[i].incr; 5032} 5033 5034 5035/* Return a pointer to the increment value for the OMP_FOR statement GS. */ 5036 5037static inline tree * 5038gimple_omp_for_incr_ptr (gimple *gs, size_t i) 5039{ 5040 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 5041 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 5042 return &omp_for_stmt->iter[i].incr; 5043} 5044 5045 5046/* Set INCR to be the increment value for the OMP_FOR statement GS. */ 5047 5048static inline void 5049gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr) 5050{ 5051 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 5052 gcc_gimple_checking_assert (i < omp_for_stmt->collapse); 5053 omp_for_stmt->iter[i].incr = incr; 5054} 5055 5056 5057/* Return a pointer to the sequence of statements to execute before the OMP_FOR 5058 statement GS starts. */ 5059 5060static inline gimple_seq * 5061gimple_omp_for_pre_body_ptr (gimple *gs) 5062{ 5063 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 5064 return &omp_for_stmt->pre_body; 5065} 5066 5067 5068/* Return the sequence of statements to execute before the OMP_FOR 5069 statement GS starts. */ 5070 5071static inline gimple_seq 5072gimple_omp_for_pre_body (gimple *gs) 5073{ 5074 return *gimple_omp_for_pre_body_ptr (gs); 5075} 5076 5077 5078/* Set PRE_BODY to be the sequence of statements to execute before the 5079 OMP_FOR statement GS starts. */ 5080 5081static inline void 5082gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body) 5083{ 5084 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs); 5085 omp_for_stmt->pre_body = pre_body; 5086} 5087 5088/* Return the kernel_phony of OMP_FOR statement. */ 5089 5090static inline bool 5091gimple_omp_for_grid_phony (const gomp_for *omp_for) 5092{ 5093 return (gimple_omp_subcode (omp_for) & GF_OMP_FOR_GRID_PHONY) != 0; 5094} 5095 5096/* Set kernel_phony flag of OMP_FOR to VALUE. */ 5097 5098static inline void 5099gimple_omp_for_set_grid_phony (gomp_for *omp_for, bool value) 5100{ 5101 if (value) 5102 omp_for->subcode |= GF_OMP_FOR_GRID_PHONY; 5103 else 5104 omp_for->subcode &= ~GF_OMP_FOR_GRID_PHONY; 5105} 5106 5107/* Return the clauses associated with OMP_PARALLEL GS. */ 5108 5109static inline tree 5110gimple_omp_parallel_clauses (const gimple *gs) 5111{ 5112 const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs); 5113 return omp_parallel_stmt->clauses; 5114} 5115 5116 5117/* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */ 5118 5119static inline tree * 5120gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt) 5121{ 5122 return &omp_parallel_stmt->clauses; 5123} 5124 5125 5126/* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */ 5127 5128static inline void 5129gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt, 5130 tree clauses) 5131{ 5132 omp_parallel_stmt->clauses = clauses; 5133} 5134 5135 5136/* Return the child function used to hold the body of OMP_PARALLEL_STMT. */ 5137 5138static inline tree 5139gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt) 5140{ 5141 return omp_parallel_stmt->child_fn; 5142} 5143 5144/* Return a pointer to the child function used to hold the body of 5145 OMP_PARALLEL_STMT. */ 5146 5147static inline tree * 5148gimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt) 5149{ 5150 return &omp_parallel_stmt->child_fn; 5151} 5152 5153 5154/* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */ 5155 5156static inline void 5157gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt, 5158 tree child_fn) 5159{ 5160 omp_parallel_stmt->child_fn = child_fn; 5161} 5162 5163 5164/* Return the artificial argument used to send variables and values 5165 from the parent to the children threads in OMP_PARALLEL_STMT. */ 5166 5167static inline tree 5168gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt) 5169{ 5170 return omp_parallel_stmt->data_arg; 5171} 5172 5173 5174/* Return a pointer to the data argument for OMP_PARALLEL_STMT. */ 5175 5176static inline tree * 5177gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt) 5178{ 5179 return &omp_parallel_stmt->data_arg; 5180} 5181 5182 5183/* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */ 5184 5185static inline void 5186gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt, 5187 tree data_arg) 5188{ 5189 omp_parallel_stmt->data_arg = data_arg; 5190} 5191 5192/* Return the kernel_phony flag of OMP_PARALLEL_STMT. */ 5193 5194static inline bool 5195gimple_omp_parallel_grid_phony (const gomp_parallel *stmt) 5196{ 5197 return (gimple_omp_subcode (stmt) & GF_OMP_PARALLEL_GRID_PHONY) != 0; 5198} 5199 5200/* Set kernel_phony flag of OMP_PARALLEL_STMT to VALUE. */ 5201 5202static inline void 5203gimple_omp_parallel_set_grid_phony (gomp_parallel *stmt, bool value) 5204{ 5205 if (value) 5206 stmt->subcode |= GF_OMP_PARALLEL_GRID_PHONY; 5207 else 5208 stmt->subcode &= ~GF_OMP_PARALLEL_GRID_PHONY; 5209} 5210 5211/* Return the clauses associated with OMP_TASK GS. */ 5212 5213static inline tree 5214gimple_omp_task_clauses (const gimple *gs) 5215{ 5216 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs); 5217 return omp_task_stmt->clauses; 5218} 5219 5220 5221/* Return a pointer to the clauses associated with OMP_TASK GS. */ 5222 5223static inline tree * 5224gimple_omp_task_clauses_ptr (gimple *gs) 5225{ 5226 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5227 return &omp_task_stmt->clauses; 5228} 5229 5230 5231/* Set CLAUSES to be the list of clauses associated with OMP_TASK 5232 GS. */ 5233 5234static inline void 5235gimple_omp_task_set_clauses (gimple *gs, tree clauses) 5236{ 5237 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5238 omp_task_stmt->clauses = clauses; 5239} 5240 5241 5242/* Return true if OMP task statement G has the 5243 GF_OMP_TASK_TASKLOOP flag set. */ 5244 5245static inline bool 5246gimple_omp_task_taskloop_p (const gimple *g) 5247{ 5248 GIMPLE_CHECK (g, GIMPLE_OMP_TASK); 5249 return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKLOOP) != 0; 5250} 5251 5252 5253/* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean 5254 value of TASKLOOP_P. */ 5255 5256static inline void 5257gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p) 5258{ 5259 GIMPLE_CHECK (g, GIMPLE_OMP_TASK); 5260 if (taskloop_p) 5261 g->subcode |= GF_OMP_TASK_TASKLOOP; 5262 else 5263 g->subcode &= ~GF_OMP_TASK_TASKLOOP; 5264} 5265 5266 5267/* Return the child function used to hold the body of OMP_TASK GS. */ 5268 5269static inline tree 5270gimple_omp_task_child_fn (const gimple *gs) 5271{ 5272 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs); 5273 return omp_task_stmt->child_fn; 5274} 5275 5276/* Return a pointer to the child function used to hold the body of 5277 OMP_TASK GS. */ 5278 5279static inline tree * 5280gimple_omp_task_child_fn_ptr (gimple *gs) 5281{ 5282 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5283 return &omp_task_stmt->child_fn; 5284} 5285 5286 5287/* Set CHILD_FN to be the child function for OMP_TASK GS. */ 5288 5289static inline void 5290gimple_omp_task_set_child_fn (gimple *gs, tree child_fn) 5291{ 5292 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5293 omp_task_stmt->child_fn = child_fn; 5294} 5295 5296 5297/* Return the artificial argument used to send variables and values 5298 from the parent to the children threads in OMP_TASK GS. */ 5299 5300static inline tree 5301gimple_omp_task_data_arg (const gimple *gs) 5302{ 5303 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs); 5304 return omp_task_stmt->data_arg; 5305} 5306 5307 5308/* Return a pointer to the data argument for OMP_TASK GS. */ 5309 5310static inline tree * 5311gimple_omp_task_data_arg_ptr (gimple *gs) 5312{ 5313 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5314 return &omp_task_stmt->data_arg; 5315} 5316 5317 5318/* Set DATA_ARG to be the data argument for OMP_TASK GS. */ 5319 5320static inline void 5321gimple_omp_task_set_data_arg (gimple *gs, tree data_arg) 5322{ 5323 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5324 omp_task_stmt->data_arg = data_arg; 5325} 5326 5327 5328/* Return the clauses associated with OMP_TASK GS. */ 5329 5330static inline tree 5331gimple_omp_taskreg_clauses (const gimple *gs) 5332{ 5333 const gimple_statement_omp_taskreg *omp_taskreg_stmt 5334 = as_a <const gimple_statement_omp_taskreg *> (gs); 5335 return omp_taskreg_stmt->clauses; 5336} 5337 5338 5339/* Return a pointer to the clauses associated with OMP_TASK GS. */ 5340 5341static inline tree * 5342gimple_omp_taskreg_clauses_ptr (gimple *gs) 5343{ 5344 gimple_statement_omp_taskreg *omp_taskreg_stmt 5345 = as_a <gimple_statement_omp_taskreg *> (gs); 5346 return &omp_taskreg_stmt->clauses; 5347} 5348 5349 5350/* Set CLAUSES to be the list of clauses associated with OMP_TASK 5351 GS. */ 5352 5353static inline void 5354gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses) 5355{ 5356 gimple_statement_omp_taskreg *omp_taskreg_stmt 5357 = as_a <gimple_statement_omp_taskreg *> (gs); 5358 omp_taskreg_stmt->clauses = clauses; 5359} 5360 5361 5362/* Return the child function used to hold the body of OMP_TASK GS. */ 5363 5364static inline tree 5365gimple_omp_taskreg_child_fn (const gimple *gs) 5366{ 5367 const gimple_statement_omp_taskreg *omp_taskreg_stmt 5368 = as_a <const gimple_statement_omp_taskreg *> (gs); 5369 return omp_taskreg_stmt->child_fn; 5370} 5371 5372/* Return a pointer to the child function used to hold the body of 5373 OMP_TASK GS. */ 5374 5375static inline tree * 5376gimple_omp_taskreg_child_fn_ptr (gimple *gs) 5377{ 5378 gimple_statement_omp_taskreg *omp_taskreg_stmt 5379 = as_a <gimple_statement_omp_taskreg *> (gs); 5380 return &omp_taskreg_stmt->child_fn; 5381} 5382 5383 5384/* Set CHILD_FN to be the child function for OMP_TASK GS. */ 5385 5386static inline void 5387gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn) 5388{ 5389 gimple_statement_omp_taskreg *omp_taskreg_stmt 5390 = as_a <gimple_statement_omp_taskreg *> (gs); 5391 omp_taskreg_stmt->child_fn = child_fn; 5392} 5393 5394 5395/* Return the artificial argument used to send variables and values 5396 from the parent to the children threads in OMP_TASK GS. */ 5397 5398static inline tree 5399gimple_omp_taskreg_data_arg (const gimple *gs) 5400{ 5401 const gimple_statement_omp_taskreg *omp_taskreg_stmt 5402 = as_a <const gimple_statement_omp_taskreg *> (gs); 5403 return omp_taskreg_stmt->data_arg; 5404} 5405 5406 5407/* Return a pointer to the data argument for OMP_TASK GS. */ 5408 5409static inline tree * 5410gimple_omp_taskreg_data_arg_ptr (gimple *gs) 5411{ 5412 gimple_statement_omp_taskreg *omp_taskreg_stmt 5413 = as_a <gimple_statement_omp_taskreg *> (gs); 5414 return &omp_taskreg_stmt->data_arg; 5415} 5416 5417 5418/* Set DATA_ARG to be the data argument for OMP_TASK GS. */ 5419 5420static inline void 5421gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg) 5422{ 5423 gimple_statement_omp_taskreg *omp_taskreg_stmt 5424 = as_a <gimple_statement_omp_taskreg *> (gs); 5425 omp_taskreg_stmt->data_arg = data_arg; 5426} 5427 5428 5429/* Return the copy function used to hold the body of OMP_TASK GS. */ 5430 5431static inline tree 5432gimple_omp_task_copy_fn (const gimple *gs) 5433{ 5434 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs); 5435 return omp_task_stmt->copy_fn; 5436} 5437 5438/* Return a pointer to the copy function used to hold the body of 5439 OMP_TASK GS. */ 5440 5441static inline tree * 5442gimple_omp_task_copy_fn_ptr (gimple *gs) 5443{ 5444 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5445 return &omp_task_stmt->copy_fn; 5446} 5447 5448 5449/* Set CHILD_FN to be the copy function for OMP_TASK GS. */ 5450 5451static inline void 5452gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn) 5453{ 5454 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5455 omp_task_stmt->copy_fn = copy_fn; 5456} 5457 5458 5459/* Return size of the data block in bytes in OMP_TASK GS. */ 5460 5461static inline tree 5462gimple_omp_task_arg_size (const gimple *gs) 5463{ 5464 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs); 5465 return omp_task_stmt->arg_size; 5466} 5467 5468 5469/* Return a pointer to the data block size for OMP_TASK GS. */ 5470 5471static inline tree * 5472gimple_omp_task_arg_size_ptr (gimple *gs) 5473{ 5474 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5475 return &omp_task_stmt->arg_size; 5476} 5477 5478 5479/* Set ARG_SIZE to be the data block size for OMP_TASK GS. */ 5480 5481static inline void 5482gimple_omp_task_set_arg_size (gimple *gs, tree arg_size) 5483{ 5484 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5485 omp_task_stmt->arg_size = arg_size; 5486} 5487 5488 5489/* Return align of the data block in bytes in OMP_TASK GS. */ 5490 5491static inline tree 5492gimple_omp_task_arg_align (const gimple *gs) 5493{ 5494 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs); 5495 return omp_task_stmt->arg_align; 5496} 5497 5498 5499/* Return a pointer to the data block align for OMP_TASK GS. */ 5500 5501static inline tree * 5502gimple_omp_task_arg_align_ptr (gimple *gs) 5503{ 5504 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5505 return &omp_task_stmt->arg_align; 5506} 5507 5508 5509/* Set ARG_SIZE to be the data block align for OMP_TASK GS. */ 5510 5511static inline void 5512gimple_omp_task_set_arg_align (gimple *gs, tree arg_align) 5513{ 5514 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs); 5515 omp_task_stmt->arg_align = arg_align; 5516} 5517 5518 5519/* Return the clauses associated with OMP_SINGLE GS. */ 5520 5521static inline tree 5522gimple_omp_single_clauses (const gimple *gs) 5523{ 5524 const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs); 5525 return omp_single_stmt->clauses; 5526} 5527 5528 5529/* Return a pointer to the clauses associated with OMP_SINGLE GS. */ 5530 5531static inline tree * 5532gimple_omp_single_clauses_ptr (gimple *gs) 5533{ 5534 gomp_single *omp_single_stmt = as_a <gomp_single *> (gs); 5535 return &omp_single_stmt->clauses; 5536} 5537 5538 5539/* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */ 5540 5541static inline void 5542gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses) 5543{ 5544 omp_single_stmt->clauses = clauses; 5545} 5546 5547 5548/* Return the clauses associated with OMP_TARGET GS. */ 5549 5550static inline tree 5551gimple_omp_target_clauses (const gimple *gs) 5552{ 5553 const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs); 5554 return omp_target_stmt->clauses; 5555} 5556 5557 5558/* Return a pointer to the clauses associated with OMP_TARGET GS. */ 5559 5560static inline tree * 5561gimple_omp_target_clauses_ptr (gimple *gs) 5562{ 5563 gomp_target *omp_target_stmt = as_a <gomp_target *> (gs); 5564 return &omp_target_stmt->clauses; 5565} 5566 5567 5568/* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */ 5569 5570static inline void 5571gimple_omp_target_set_clauses (gomp_target *omp_target_stmt, 5572 tree clauses) 5573{ 5574 omp_target_stmt->clauses = clauses; 5575} 5576 5577 5578/* Return the kind of the OMP_TARGET G. */ 5579 5580static inline int 5581gimple_omp_target_kind (const gimple *g) 5582{ 5583 GIMPLE_CHECK (g, GIMPLE_OMP_TARGET); 5584 return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK); 5585} 5586 5587 5588/* Set the kind of the OMP_TARGET G. */ 5589 5590static inline void 5591gimple_omp_target_set_kind (gomp_target *g, int kind) 5592{ 5593 g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK) 5594 | (kind & GF_OMP_TARGET_KIND_MASK); 5595} 5596 5597 5598/* Return the child function used to hold the body of OMP_TARGET_STMT. */ 5599 5600static inline tree 5601gimple_omp_target_child_fn (const gomp_target *omp_target_stmt) 5602{ 5603 return omp_target_stmt->child_fn; 5604} 5605 5606/* Return a pointer to the child function used to hold the body of 5607 OMP_TARGET_STMT. */ 5608 5609static inline tree * 5610gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt) 5611{ 5612 return &omp_target_stmt->child_fn; 5613} 5614 5615 5616/* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */ 5617 5618static inline void 5619gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt, 5620 tree child_fn) 5621{ 5622 omp_target_stmt->child_fn = child_fn; 5623} 5624 5625 5626/* Return the artificial argument used to send variables and values 5627 from the parent to the children threads in OMP_TARGET_STMT. */ 5628 5629static inline tree 5630gimple_omp_target_data_arg (const gomp_target *omp_target_stmt) 5631{ 5632 return omp_target_stmt->data_arg; 5633} 5634 5635 5636/* Return a pointer to the data argument for OMP_TARGET GS. */ 5637 5638static inline tree * 5639gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt) 5640{ 5641 return &omp_target_stmt->data_arg; 5642} 5643 5644 5645/* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */ 5646 5647static inline void 5648gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt, 5649 tree data_arg) 5650{ 5651 omp_target_stmt->data_arg = data_arg; 5652} 5653 5654 5655/* Return the clauses associated with OMP_TEAMS GS. */ 5656 5657static inline tree 5658gimple_omp_teams_clauses (const gimple *gs) 5659{ 5660 const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs); 5661 return omp_teams_stmt->clauses; 5662} 5663 5664 5665/* Return a pointer to the clauses associated with OMP_TEAMS GS. */ 5666 5667static inline tree * 5668gimple_omp_teams_clauses_ptr (gimple *gs) 5669{ 5670 gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs); 5671 return &omp_teams_stmt->clauses; 5672} 5673 5674 5675/* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */ 5676 5677static inline void 5678gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses) 5679{ 5680 omp_teams_stmt->clauses = clauses; 5681} 5682 5683/* Return the kernel_phony flag of an OMP_TEAMS_STMT. */ 5684 5685static inline bool 5686gimple_omp_teams_grid_phony (const gomp_teams *omp_teams_stmt) 5687{ 5688 return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_GRID_PHONY) != 0; 5689} 5690 5691/* Set kernel_phony flag of an OMP_TEAMS_STMT to VALUE. */ 5692 5693static inline void 5694gimple_omp_teams_set_grid_phony (gomp_teams *omp_teams_stmt, bool value) 5695{ 5696 if (value) 5697 omp_teams_stmt->subcode |= GF_OMP_TEAMS_GRID_PHONY; 5698 else 5699 omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_GRID_PHONY; 5700} 5701 5702/* Return the clauses associated with OMP_SECTIONS GS. */ 5703 5704static inline tree 5705gimple_omp_sections_clauses (const gimple *gs) 5706{ 5707 const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs); 5708 return omp_sections_stmt->clauses; 5709} 5710 5711 5712/* Return a pointer to the clauses associated with OMP_SECTIONS GS. */ 5713 5714static inline tree * 5715gimple_omp_sections_clauses_ptr (gimple *gs) 5716{ 5717 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs); 5718 return &omp_sections_stmt->clauses; 5719} 5720 5721 5722/* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS 5723 GS. */ 5724 5725static inline void 5726gimple_omp_sections_set_clauses (gimple *gs, tree clauses) 5727{ 5728 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs); 5729 omp_sections_stmt->clauses = clauses; 5730} 5731 5732 5733/* Return the control variable associated with the GIMPLE_OMP_SECTIONS 5734 in GS. */ 5735 5736static inline tree 5737gimple_omp_sections_control (const gimple *gs) 5738{ 5739 const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs); 5740 return omp_sections_stmt->control; 5741} 5742 5743 5744/* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS 5745 GS. */ 5746 5747static inline tree * 5748gimple_omp_sections_control_ptr (gimple *gs) 5749{ 5750 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs); 5751 return &omp_sections_stmt->control; 5752} 5753 5754 5755/* Set CONTROL to be the set of clauses associated with the 5756 GIMPLE_OMP_SECTIONS in GS. */ 5757 5758static inline void 5759gimple_omp_sections_set_control (gimple *gs, tree control) 5760{ 5761 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs); 5762 omp_sections_stmt->control = control; 5763} 5764 5765 5766/* Set the value being stored in an atomic store. */ 5767 5768static inline void 5769gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val) 5770{ 5771 store_stmt->val = val; 5772} 5773 5774 5775/* Return the value being stored in an atomic store. */ 5776 5777static inline tree 5778gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt) 5779{ 5780 return store_stmt->val; 5781} 5782 5783 5784/* Return a pointer to the value being stored in an atomic store. */ 5785 5786static inline tree * 5787gimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt) 5788{ 5789 return &store_stmt->val; 5790} 5791 5792 5793/* Set the LHS of an atomic load. */ 5794 5795static inline void 5796gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs) 5797{ 5798 load_stmt->lhs = lhs; 5799} 5800 5801 5802/* Get the LHS of an atomic load. */ 5803 5804static inline tree 5805gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt) 5806{ 5807 return load_stmt->lhs; 5808} 5809 5810 5811/* Return a pointer to the LHS of an atomic load. */ 5812 5813static inline tree * 5814gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt) 5815{ 5816 return &load_stmt->lhs; 5817} 5818 5819 5820/* Set the RHS of an atomic load. */ 5821 5822static inline void 5823gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs) 5824{ 5825 load_stmt->rhs = rhs; 5826} 5827 5828 5829/* Get the RHS of an atomic load. */ 5830 5831static inline tree 5832gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt) 5833{ 5834 return load_stmt->rhs; 5835} 5836 5837 5838/* Return a pointer to the RHS of an atomic load. */ 5839 5840static inline tree * 5841gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt) 5842{ 5843 return &load_stmt->rhs; 5844} 5845 5846 5847/* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */ 5848 5849static inline tree 5850gimple_omp_continue_control_def (const gomp_continue *cont_stmt) 5851{ 5852 return cont_stmt->control_def; 5853} 5854 5855/* The same as above, but return the address. */ 5856 5857static inline tree * 5858gimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt) 5859{ 5860 return &cont_stmt->control_def; 5861} 5862 5863/* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */ 5864 5865static inline void 5866gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def) 5867{ 5868 cont_stmt->control_def = def; 5869} 5870 5871 5872/* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */ 5873 5874static inline tree 5875gimple_omp_continue_control_use (const gomp_continue *cont_stmt) 5876{ 5877 return cont_stmt->control_use; 5878} 5879 5880 5881/* The same as above, but return the address. */ 5882 5883static inline tree * 5884gimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt) 5885{ 5886 return &cont_stmt->control_use; 5887} 5888 5889 5890/* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */ 5891 5892static inline void 5893gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use) 5894{ 5895 cont_stmt->control_use = use; 5896} 5897 5898/* Return a pointer to the body for the GIMPLE_TRANSACTION statement 5899 TRANSACTION_STMT. */ 5900 5901static inline gimple_seq * 5902gimple_transaction_body_ptr (gtransaction *transaction_stmt) 5903{ 5904 return &transaction_stmt->body; 5905} 5906 5907/* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */ 5908 5909static inline gimple_seq 5910gimple_transaction_body (gtransaction *transaction_stmt) 5911{ 5912 return transaction_stmt->body; 5913} 5914 5915/* Return the label associated with a GIMPLE_TRANSACTION. */ 5916 5917static inline tree 5918gimple_transaction_label_norm (const gtransaction *transaction_stmt) 5919{ 5920 return transaction_stmt->label_norm; 5921} 5922 5923static inline tree * 5924gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt) 5925{ 5926 return &transaction_stmt->label_norm; 5927} 5928 5929static inline tree 5930gimple_transaction_label_uninst (const gtransaction *transaction_stmt) 5931{ 5932 return transaction_stmt->label_uninst; 5933} 5934 5935static inline tree * 5936gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt) 5937{ 5938 return &transaction_stmt->label_uninst; 5939} 5940 5941static inline tree 5942gimple_transaction_label_over (const gtransaction *transaction_stmt) 5943{ 5944 return transaction_stmt->label_over; 5945} 5946 5947static inline tree * 5948gimple_transaction_label_over_ptr (gtransaction *transaction_stmt) 5949{ 5950 return &transaction_stmt->label_over; 5951} 5952 5953/* Return the subcode associated with a GIMPLE_TRANSACTION. */ 5954 5955static inline unsigned int 5956gimple_transaction_subcode (const gtransaction *transaction_stmt) 5957{ 5958 return transaction_stmt->subcode; 5959} 5960 5961/* Set BODY to be the body for the GIMPLE_TRANSACTION statement 5962 TRANSACTION_STMT. */ 5963 5964static inline void 5965gimple_transaction_set_body (gtransaction *transaction_stmt, 5966 gimple_seq body) 5967{ 5968 transaction_stmt->body = body; 5969} 5970 5971/* Set the label associated with a GIMPLE_TRANSACTION. */ 5972 5973static inline void 5974gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label) 5975{ 5976 transaction_stmt->label_norm = label; 5977} 5978 5979static inline void 5980gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label) 5981{ 5982 transaction_stmt->label_uninst = label; 5983} 5984 5985static inline void 5986gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label) 5987{ 5988 transaction_stmt->label_over = label; 5989} 5990 5991/* Set the subcode associated with a GIMPLE_TRANSACTION. */ 5992 5993static inline void 5994gimple_transaction_set_subcode (gtransaction *transaction_stmt, 5995 unsigned int subcode) 5996{ 5997 transaction_stmt->subcode = subcode; 5998} 5999 6000/* Return a pointer to the return value for GIMPLE_RETURN GS. */ 6001 6002static inline tree * 6003gimple_return_retval_ptr (greturn *gs) 6004{ 6005 return &gs->op[0]; 6006} 6007 6008/* Return the return value for GIMPLE_RETURN GS. */ 6009 6010static inline tree 6011gimple_return_retval (const greturn *gs) 6012{ 6013 return gs->op[0]; 6014} 6015 6016 6017/* Set RETVAL to be the return value for GIMPLE_RETURN GS. */ 6018 6019static inline void 6020gimple_return_set_retval (greturn *gs, tree retval) 6021{ 6022 gs->op[0] = retval; 6023} 6024 6025 6026/* Return the return bounds for GIMPLE_RETURN GS. */ 6027 6028static inline tree 6029gimple_return_retbnd (const gimple *gs) 6030{ 6031 GIMPLE_CHECK (gs, GIMPLE_RETURN); 6032 return gimple_op (gs, 1); 6033} 6034 6035 6036/* Set RETVAL to be the return bounds for GIMPLE_RETURN GS. */ 6037 6038static inline void 6039gimple_return_set_retbnd (gimple *gs, tree retval) 6040{ 6041 GIMPLE_CHECK (gs, GIMPLE_RETURN); 6042 gimple_set_op (gs, 1, retval); 6043} 6044 6045 6046/* Returns true when the gimple statement STMT is any of the OMP types. */ 6047 6048#define CASE_GIMPLE_OMP \ 6049 case GIMPLE_OMP_PARALLEL: \ 6050 case GIMPLE_OMP_TASK: \ 6051 case GIMPLE_OMP_FOR: \ 6052 case GIMPLE_OMP_SECTIONS: \ 6053 case GIMPLE_OMP_SECTIONS_SWITCH: \ 6054 case GIMPLE_OMP_SINGLE: \ 6055 case GIMPLE_OMP_TARGET: \ 6056 case GIMPLE_OMP_TEAMS: \ 6057 case GIMPLE_OMP_SECTION: \ 6058 case GIMPLE_OMP_MASTER: \ 6059 case GIMPLE_OMP_TASKGROUP: \ 6060 case GIMPLE_OMP_ORDERED: \ 6061 case GIMPLE_OMP_CRITICAL: \ 6062 case GIMPLE_OMP_RETURN: \ 6063 case GIMPLE_OMP_ATOMIC_LOAD: \ 6064 case GIMPLE_OMP_ATOMIC_STORE: \ 6065 case GIMPLE_OMP_CONTINUE: \ 6066 case GIMPLE_OMP_GRID_BODY 6067 6068static inline bool 6069is_gimple_omp (const gimple *stmt) 6070{ 6071 switch (gimple_code (stmt)) 6072 { 6073 CASE_GIMPLE_OMP: 6074 return true; 6075 default: 6076 return false; 6077 } 6078} 6079 6080/* Return true if the OMP gimple statement STMT is any of the OpenACC types 6081 specifically. */ 6082 6083static inline bool 6084is_gimple_omp_oacc (const gimple *stmt) 6085{ 6086 gcc_assert (is_gimple_omp (stmt)); 6087 switch (gimple_code (stmt)) 6088 { 6089 case GIMPLE_OMP_FOR: 6090 switch (gimple_omp_for_kind (stmt)) 6091 { 6092 case GF_OMP_FOR_KIND_OACC_LOOP: 6093 return true; 6094 default: 6095 return false; 6096 } 6097 case GIMPLE_OMP_TARGET: 6098 switch (gimple_omp_target_kind (stmt)) 6099 { 6100 case GF_OMP_TARGET_KIND_OACC_PARALLEL: 6101 case GF_OMP_TARGET_KIND_OACC_KERNELS: 6102 case GF_OMP_TARGET_KIND_OACC_DATA: 6103 case GF_OMP_TARGET_KIND_OACC_UPDATE: 6104 case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA: 6105 case GF_OMP_TARGET_KIND_OACC_DECLARE: 6106 case GF_OMP_TARGET_KIND_OACC_HOST_DATA: 6107 return true; 6108 default: 6109 return false; 6110 } 6111 default: 6112 return false; 6113 } 6114} 6115 6116 6117/* Return true if the OMP gimple statement STMT is offloaded. */ 6118 6119static inline bool 6120is_gimple_omp_offloaded (const gimple *stmt) 6121{ 6122 gcc_assert (is_gimple_omp (stmt)); 6123 switch (gimple_code (stmt)) 6124 { 6125 case GIMPLE_OMP_TARGET: 6126 switch (gimple_omp_target_kind (stmt)) 6127 { 6128 case GF_OMP_TARGET_KIND_REGION: 6129 case GF_OMP_TARGET_KIND_OACC_PARALLEL: 6130 case GF_OMP_TARGET_KIND_OACC_KERNELS: 6131 return true; 6132 default: 6133 return false; 6134 } 6135 default: 6136 return false; 6137 } 6138} 6139 6140 6141/* Returns TRUE if statement G is a GIMPLE_NOP. */ 6142 6143static inline bool 6144gimple_nop_p (const gimple *g) 6145{ 6146 return gimple_code (g) == GIMPLE_NOP; 6147} 6148 6149 6150/* Return true if GS is a GIMPLE_RESX. */ 6151 6152static inline bool 6153is_gimple_resx (const gimple *gs) 6154{ 6155 return gimple_code (gs) == GIMPLE_RESX; 6156} 6157 6158/* Return the type of the main expression computed by STMT. Return 6159 void_type_node if the statement computes nothing. */ 6160 6161static inline tree 6162gimple_expr_type (const gimple *stmt) 6163{ 6164 enum gimple_code code = gimple_code (stmt); 6165 /* In general we want to pass out a type that can be substituted 6166 for both the RHS and the LHS types if there is a possibly 6167 useless conversion involved. That means returning the 6168 original RHS type as far as we can reconstruct it. */ 6169 if (code == GIMPLE_CALL) 6170 { 6171 const gcall *call_stmt = as_a <const gcall *> (stmt); 6172 if (gimple_call_internal_p (call_stmt) 6173 && gimple_call_internal_fn (call_stmt) == IFN_MASK_STORE) 6174 return TREE_TYPE (gimple_call_arg (call_stmt, 3)); 6175 else 6176 return gimple_call_return_type (call_stmt); 6177 } 6178 else if (code == GIMPLE_ASSIGN) 6179 { 6180 if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR) 6181 return TREE_TYPE (gimple_assign_rhs1 (stmt)); 6182 else 6183 /* As fallback use the type of the LHS. */ 6184 return TREE_TYPE (gimple_get_lhs (stmt)); 6185 } 6186 else if (code == GIMPLE_COND) 6187 return boolean_type_node; 6188 else 6189 return void_type_node; 6190} 6191 6192/* Enum and arrays used for allocation stats. Keep in sync with 6193 gimple.c:gimple_alloc_kind_names. */ 6194enum gimple_alloc_kind 6195{ 6196 gimple_alloc_kind_assign, /* Assignments. */ 6197 gimple_alloc_kind_phi, /* PHI nodes. */ 6198 gimple_alloc_kind_cond, /* Conditionals. */ 6199 gimple_alloc_kind_rest, /* Everything else. */ 6200 gimple_alloc_kind_all 6201}; 6202 6203extern int gimple_alloc_counts[]; 6204extern int gimple_alloc_sizes[]; 6205 6206/* Return the allocation kind for a given stmt CODE. */ 6207static inline enum gimple_alloc_kind 6208gimple_alloc_kind (enum gimple_code code) 6209{ 6210 switch (code) 6211 { 6212 case GIMPLE_ASSIGN: 6213 return gimple_alloc_kind_assign; 6214 case GIMPLE_PHI: 6215 return gimple_alloc_kind_phi; 6216 case GIMPLE_COND: 6217 return gimple_alloc_kind_cond; 6218 default: 6219 return gimple_alloc_kind_rest; 6220 } 6221} 6222 6223/* Return true if a location should not be emitted for this statement 6224 by annotate_all_with_location. */ 6225 6226static inline bool 6227gimple_do_not_emit_location_p (gimple *g) 6228{ 6229 return gimple_plf (g, GF_PLF_1); 6230} 6231 6232/* Mark statement G so a location will not be emitted by 6233 annotate_one_with_location. */ 6234 6235static inline void 6236gimple_set_do_not_emit_location (gimple *g) 6237{ 6238 /* The PLF flags are initialized to 0 when a new tuple is created, 6239 so no need to initialize it anywhere. */ 6240 gimple_set_plf (g, GF_PLF_1, true); 6241} 6242 6243 6244/* Macros for showing usage statistics. */ 6245#define SCALE(x) ((unsigned long) ((x) < 1024*10 \ 6246 ? (x) \ 6247 : ((x) < 1024*1024*10 \ 6248 ? (x) / 1024 \ 6249 : (x) / (1024*1024)))) 6250 6251#define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M')) 6252 6253#endif /* GCC_GIMPLE_H */ 6254