c++: Prevent overwriting arguments when merging duplicates [PR112588]
[official-gcc.git] / gcc / gimple.h
blob8a8ca109bbff838d76e357a86b80390584b8189c
1 /* Gimple IR definitions.
3 Copyright (C) 2007-2024 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #ifndef GCC_GIMPLE_H
23 #define GCC_GIMPLE_H
25 #include "tree-ssa-alias.h"
26 #include "gimple-expr.h"
28 typedef gimple *gimple_seq_node;
30 enum gimple_code {
31 #define DEFGSCODE(SYM, STRING, STRUCT) SYM,
32 #include "gimple.def"
33 #undef DEFGSCODE
34 LAST_AND_UNUSED_GIMPLE_CODE
37 extern const char *const gimple_code_name[];
38 extern const unsigned char gimple_rhs_class_table[];
40 /* Strip the outermost pointer, from tr1/type_traits. */
41 template<typename T> struct remove_pointer { typedef T type; };
42 template<typename T> struct remove_pointer<T *> { typedef T type; };
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)
47 extern void gimple_check_failed (const gimple *, const char *, int, \
48 const char *, enum gimple_code, \
49 enum tree_code) ATTRIBUTE_NORETURN \
50 ATTRIBUTE_COLD;
52 #define GIMPLE_CHECK(GS, CODE) \
53 do { \
54 const gimple *__gs = (GS); \
55 if (gimple_code (__gs) != (CODE)) \
56 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \
57 (CODE), ERROR_MARK); \
58 } while (0)
59 template <typename T>
60 inline T
61 GIMPLE_CHECK2(const gimple *gs,
62 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
63 const char *file = __builtin_FILE (),
64 int line = __builtin_LINE (),
65 const char *fun = __builtin_FUNCTION ())
66 #else
67 const char *file = __FILE__,
68 int line = __LINE__,
69 const char *fun = NULL)
70 #endif
72 T ret = dyn_cast <T> (gs);
73 if (!ret)
74 gimple_check_failed (gs, file, line, fun,
75 remove_pointer<T>::type::code_, ERROR_MARK);
76 return ret;
78 template <typename T>
79 inline T
80 GIMPLE_CHECK2(gimple *gs,
81 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
82 const char *file = __builtin_FILE (),
83 int line = __builtin_LINE (),
84 const char *fun = __builtin_FUNCTION ())
85 #else
86 const char *file = __FILE__,
87 int line = __LINE__,
88 const char *fun = NULL)
89 #endif
91 T ret = dyn_cast <T> (gs);
92 if (!ret)
93 gimple_check_failed (gs, file, line, fun,
94 remove_pointer<T>::type::code_, ERROR_MARK);
95 return ret;
97 #else /* not ENABLE_GIMPLE_CHECKING */
98 #define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
99 #define GIMPLE_CHECK(GS, CODE) (void)0
100 template <typename T>
101 inline T
102 GIMPLE_CHECK2(gimple *gs)
104 return as_a <T> (gs);
106 template <typename T>
107 inline T
108 GIMPLE_CHECK2(const gimple *gs)
110 return as_a <T> (gs);
112 #endif
114 /* Class of GIMPLE expressions suitable for the RHS of assignments. See
115 get_gimple_rhs_class. */
116 enum gimple_rhs_class
118 GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */
119 GIMPLE_TERNARY_RHS, /* The expression is a ternary operation. */
120 GIMPLE_BINARY_RHS, /* The expression is a binary operation. */
121 GIMPLE_UNARY_RHS, /* The expression is a unary operation. */
122 GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA
123 name, a _DECL, a _REF, etc. */
126 /* Specific flags for individual GIMPLE statements. These flags are
127 always stored in gimple.subcode and they may only be
128 defined for statement codes that do not use subcodes.
130 Values for the masks can overlap as long as the overlapping values
131 are never used in the same statement class.
133 The maximum mask value that can be defined is 1 << 15 (i.e., each
134 statement code can hold up to 16 bitflags).
136 Keep this list sorted. */
137 enum gf_mask {
138 GF_ASM_INPUT = 1 << 0,
139 GF_ASM_VOLATILE = 1 << 1,
140 GF_ASM_INLINE = 1 << 2,
141 GF_CALL_FROM_THUNK = 1 << 0,
142 GF_CALL_RETURN_SLOT_OPT = 1 << 1,
143 GF_CALL_TAILCALL = 1 << 2,
144 GF_CALL_VA_ARG_PACK = 1 << 3,
145 GF_CALL_NOTHROW = 1 << 4,
146 GF_CALL_ALLOCA_FOR_VAR = 1 << 5,
147 GF_CALL_INTERNAL = 1 << 6,
148 GF_CALL_CTRL_ALTERING = 1 << 7,
149 GF_CALL_MUST_TAIL_CALL = 1 << 9,
150 GF_CALL_BY_DESCRIPTOR = 1 << 10,
151 GF_CALL_NOCF_CHECK = 1 << 11,
152 GF_CALL_FROM_NEW_OR_DELETE = 1 << 12,
153 GF_CALL_XTHROW = 1 << 13,
154 GF_OMP_PARALLEL_COMBINED = 1 << 0,
155 GF_OMP_TASK_TASKLOOP = 1 << 0,
156 GF_OMP_TASK_TASKWAIT = 1 << 1,
157 GF_OMP_FOR_KIND_MASK = (1 << 3) - 1,
158 GF_OMP_FOR_KIND_FOR = 0,
159 GF_OMP_FOR_KIND_DISTRIBUTE = 1,
160 GF_OMP_FOR_KIND_TASKLOOP = 2,
161 GF_OMP_FOR_KIND_OACC_LOOP = 4,
162 GF_OMP_FOR_KIND_SIMD = 5,
163 GF_OMP_FOR_COMBINED = 1 << 3,
164 GF_OMP_FOR_COMBINED_INTO = 1 << 4,
165 GF_OMP_TARGET_KIND_MASK = (1 << 5) - 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_SERIAL = 7,
174 GF_OMP_TARGET_KIND_OACC_DATA = 8,
175 GF_OMP_TARGET_KIND_OACC_UPDATE = 9,
176 GF_OMP_TARGET_KIND_OACC_ENTER_DATA = 10,
177 GF_OMP_TARGET_KIND_OACC_EXIT_DATA = 11,
178 GF_OMP_TARGET_KIND_OACC_DECLARE = 12,
179 GF_OMP_TARGET_KIND_OACC_HOST_DATA = 13,
180 /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
181 decomposed part, parallelized. */
182 GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED = 14,
183 /* A 'GF_OMP_TARGET_KIND_OACC_PARALLEL' representing an OpenACC 'kernels'
184 decomposed part, "gang-single". */
185 GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE = 15,
186 /* A 'GF_OMP_TARGET_KIND_OACC_DATA' representing an OpenACC 'kernels'
187 decomposed parts' 'data' construct. */
188 GF_OMP_TARGET_KIND_OACC_DATA_KERNELS = 16,
189 GF_OMP_TEAMS_HOST = 1 << 0,
191 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
192 a thread synchronization via some sort of barrier. The exact barrier
193 that would otherwise be emitted is dependent on the OMP statement with
194 which this return is associated. */
195 GF_OMP_RETURN_NOWAIT = 1 << 0,
197 GF_OMP_SECTION_LAST = 1 << 0,
198 GF_OMP_ORDERED_STANDALONE = 1 << 0,
199 GF_OMP_ATOMIC_MEMORY_ORDER = (1 << 6) - 1,
200 GF_OMP_ATOMIC_NEED_VALUE = 1 << 6,
201 GF_OMP_ATOMIC_WEAK = 1 << 7,
202 GF_PREDICT_TAKEN = 1 << 15
205 /* This subcode tells apart different kinds of stmts that are not used
206 for codegen, but rather to retain debug information. */
207 enum gimple_debug_subcode {
208 GIMPLE_DEBUG_BIND = 0,
209 GIMPLE_DEBUG_SOURCE_BIND = 1,
210 GIMPLE_DEBUG_BEGIN_STMT = 2,
211 GIMPLE_DEBUG_INLINE_ENTRY = 3
214 /* Masks for selecting a pass local flag (PLF) to work on. These
215 masks are used by gimple_set_plf and gimple_plf. */
216 enum plf_mask {
217 GF_PLF_1 = 1 << 0,
218 GF_PLF_2 = 1 << 1
221 /* Data structure definitions for GIMPLE tuples. NOTE: word markers
222 are for 64 bit hosts. */
224 struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
225 chain_next ("%h.next"), variable_size))
226 gimple
228 /* [ WORD 1 ]
229 Main identifying code for a tuple. */
230 ENUM_BITFIELD(gimple_code) code : 8;
232 /* Nonzero if a warning should not be emitted on this tuple. */
233 unsigned int no_warning : 1;
235 /* Nonzero if this tuple has been visited. Passes are responsible
236 for clearing this bit before using it. */
237 unsigned int visited : 1;
239 /* Nonzero if this tuple represents a non-temporal move. */
240 unsigned int nontemporal_move : 1;
242 /* Pass local flags. These flags are free for any pass to use as
243 they see fit. Passes should not assume that these flags contain
244 any useful value when the pass starts. Any initial state that
245 the pass requires should be set on entry to the pass. See
246 gimple_set_plf and gimple_plf for usage. */
247 unsigned int plf : 2;
249 /* Nonzero if this statement has been modified and needs to have its
250 operands rescanned. */
251 unsigned modified : 1;
253 /* Nonzero if this statement contains volatile operands. */
254 unsigned has_volatile_ops : 1;
256 /* Padding to get subcode to 16 bit alignment. */
257 unsigned pad : 1;
259 /* The SUBCODE field can be used for tuple-specific flags for tuples
260 that do not require subcodes. Note that SUBCODE should be at
261 least as wide as tree codes, as several tuples store tree codes
262 in there. */
263 unsigned int subcode : 16;
265 /* UID of this statement. This is used by passes that want to
266 assign IDs to statements. It must be assigned and used by each
267 pass. By default it should be assumed to contain garbage. */
268 unsigned uid;
270 /* [ WORD 2 ]
271 Locus information for debug info. */
272 location_t location;
274 /* Number of operands in this tuple. */
275 unsigned num_ops;
277 /* [ WORD 3 ]
278 Basic block holding this statement. */
279 basic_block bb;
281 /* [ WORD 4-5 ]
282 Linked lists of gimple statements. The next pointers form
283 a NULL terminated list, the prev pointers are a cyclic list.
284 A gimple statement is hence also a double-ended list of
285 statements, with the pointer itself being the first element,
286 and the prev pointer being the last. */
287 gimple *next;
288 gimple *GTY((skip)) prev;
292 /* Base structure for tuples with operands. */
294 /* This gimple subclass has no tag value. */
295 struct GTY(())
296 gimple_statement_with_ops_base : public gimple
298 /* [ WORD 1-6 ] : base class */
300 /* [ WORD 7 ]
301 SSA operand vectors. NOTE: It should be possible to
302 amalgamate these vectors with the operand vector OP. However,
303 the SSA operand vectors are organized differently and contain
304 more information (like immediate use chaining). */
305 struct use_optype_d GTY((skip (""))) *use_ops;
309 /* Statements that take register operands. */
311 struct GTY((tag("GSS_WITH_OPS")))
312 gimple_statement_with_ops : public gimple_statement_with_ops_base
314 /* [ WORD 1-7 ] : base class */
316 /* [ WORD 8 ]
317 Operand vector. NOTE! This must always be the last field
318 of this structure. In particular, this means that this
319 structure cannot be embedded inside another one. */
320 tree GTY((length ("%h.num_ops"))) op[1];
324 /* Base for statements that take both memory and register operands. */
326 struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
327 gimple_statement_with_memory_ops_base : public gimple_statement_with_ops_base
329 /* [ WORD 1-7 ] : base class */
331 /* [ WORD 8-9 ]
332 Virtual operands for this statement. The GC will pick them
333 up via the ssa_names array. */
334 tree GTY((skip (""))) vdef;
335 tree GTY((skip (""))) vuse;
339 /* Statements that take both memory and register operands. */
341 struct GTY((tag("GSS_WITH_MEM_OPS")))
342 gimple_statement_with_memory_ops :
343 public gimple_statement_with_memory_ops_base
345 /* [ WORD 1-9 ] : base class */
347 /* [ WORD 10 ]
348 Operand vector. NOTE! This must always be the last field
349 of this structure. In particular, this means that this
350 structure cannot be embedded inside another one. */
351 tree GTY((length ("%h.num_ops"))) op[1];
355 /* Call statements that take both memory and register operands. */
357 struct GTY((tag("GSS_CALL")))
358 gcall : public gimple_statement_with_memory_ops_base
360 /* [ WORD 1-9 ] : base class */
362 /* [ WORD 10-13 ] */
363 struct pt_solution call_used;
364 struct pt_solution call_clobbered;
366 /* [ WORD 14 ] */
367 union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
368 tree GTY ((tag ("0"))) fntype;
369 enum internal_fn GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn;
370 } u;
372 /* [ WORD 15 ]
373 Operand vector. NOTE! This must always be the last field
374 of this structure. In particular, this means that this
375 structure cannot be embedded inside another one. */
376 tree GTY((length ("%h.num_ops"))) op[1];
378 static const enum gimple_code code_ = GIMPLE_CALL;
382 /* OMP statements. */
384 struct GTY((tag("GSS_OMP")))
385 gimple_statement_omp : public gimple
387 /* [ WORD 1-6 ] : base class */
389 /* [ WORD 7 ] */
390 gimple_seq body;
394 /* GIMPLE_BIND */
396 struct GTY((tag("GSS_BIND")))
397 gbind : public gimple
399 /* [ WORD 1-6 ] : base class */
401 /* [ WORD 7 ]
402 Variables declared in this scope. */
403 tree vars;
405 /* [ WORD 8 ]
406 This is different than the BLOCK field in gimple,
407 which is analogous to TREE_BLOCK (i.e., the lexical block holding
408 this statement). This field is the equivalent of BIND_EXPR_BLOCK
409 in tree land (i.e., the lexical scope defined by this bind). See
410 gimple-low.cc. */
411 tree block;
413 /* [ WORD 9 ] */
414 gimple_seq body;
418 /* GIMPLE_CATCH */
420 struct GTY((tag("GSS_CATCH")))
421 gcatch : public gimple
423 /* [ WORD 1-6 ] : base class */
425 /* [ WORD 7 ] */
426 tree types;
428 /* [ WORD 8 ] */
429 gimple_seq handler;
433 /* GIMPLE_EH_FILTER */
435 struct GTY((tag("GSS_EH_FILTER")))
436 geh_filter : public gimple
438 /* [ WORD 1-6 ] : base class */
440 /* [ WORD 7 ]
441 Filter types. */
442 tree types;
444 /* [ WORD 8 ]
445 Failure actions. */
446 gimple_seq failure;
449 /* GIMPLE_EH_ELSE */
451 struct GTY((tag("GSS_EH_ELSE")))
452 geh_else : public gimple
454 /* [ WORD 1-6 ] : base class */
456 /* [ WORD 7,8 ] */
457 gimple_seq n_body, e_body;
460 /* GIMPLE_EH_MUST_NOT_THROW */
462 struct GTY((tag("GSS_EH_MNT")))
463 geh_mnt : public gimple
465 /* [ WORD 1-6 ] : base class */
467 /* [ WORD 7 ] Abort function decl. */
468 tree fndecl;
471 /* GIMPLE_PHI */
473 struct GTY((tag("GSS_PHI")))
474 gphi : public gimple
476 /* [ WORD 1-6 ] : base class */
478 /* [ WORD 7 ] */
479 unsigned capacity;
480 unsigned nargs;
482 /* [ WORD 8 ] */
483 tree result;
485 /* [ WORD 9 ] */
486 struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
490 /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
492 struct GTY((tag("GSS_EH_CTRL")))
493 gimple_statement_eh_ctrl : public gimple
495 /* [ WORD 1-6 ] : base class */
497 /* [ WORD 7 ]
498 Exception region number. */
499 int region;
502 struct GTY((tag("GSS_EH_CTRL")))
503 gresx : public gimple_statement_eh_ctrl
505 /* No extra fields; adds invariant:
506 stmt->code == GIMPLE_RESX. */
509 struct GTY((tag("GSS_EH_CTRL")))
510 geh_dispatch : public gimple_statement_eh_ctrl
512 /* No extra fields; adds invariant:
513 stmt->code == GIMPLE_EH_DISPATH. */
517 /* GIMPLE_TRY */
519 struct GTY((tag("GSS_TRY")))
520 gtry : public gimple
522 /* [ WORD 1-6 ] : base class */
524 /* [ WORD 7 ]
525 Expression to evaluate. */
526 gimple_seq eval;
528 /* [ WORD 8 ]
529 Cleanup expression. */
530 gimple_seq cleanup;
533 /* Kind of GIMPLE_TRY statements. */
534 enum gimple_try_flags
536 /* A try/catch. */
537 GIMPLE_TRY_CATCH = 1 << 0,
539 /* A try/finally. */
540 GIMPLE_TRY_FINALLY = 1 << 1,
541 GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY,
543 /* Analogous to TRY_CATCH_IS_CLEANUP. */
544 GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
547 /* GIMPLE_WITH_CLEANUP_EXPR */
549 struct GTY((tag("GSS_WCE")))
550 gimple_statement_wce : public gimple
552 /* [ WORD 1-6 ] : base class */
554 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
555 executed if an exception is thrown, not on normal exit of its
556 scope. This flag is analogous to the CLEANUP_EH_ONLY flag
557 in TARGET_EXPRs. */
559 /* [ WORD 7 ]
560 Cleanup expression. */
561 gimple_seq cleanup;
565 /* GIMPLE_ASM */
567 struct GTY((tag("GSS_ASM")))
568 gasm : public gimple_statement_with_memory_ops_base
570 /* [ WORD 1-9 ] : base class */
572 /* [ WORD 10 ]
573 __asm__ statement. */
574 const char *string;
576 /* [ WORD 11 ]
577 Number of inputs, outputs, clobbers, labels. */
578 unsigned char ni;
579 unsigned char no;
580 unsigned char nc;
581 unsigned char nl;
583 /* [ WORD 12 ]
584 Operand vector. NOTE! This must always be the last field
585 of this structure. In particular, this means that this
586 structure cannot be embedded inside another one. */
587 tree GTY((length ("%h.num_ops"))) op[1];
590 /* GIMPLE_OMP_CRITICAL */
592 struct GTY((tag("GSS_OMP_CRITICAL")))
593 gomp_critical : public gimple_statement_omp
595 /* [ WORD 1-7 ] : base class */
597 /* [ WORD 8 ] */
598 tree clauses;
600 /* [ WORD 9 ]
601 Critical section name. */
602 tree name;
606 struct GTY(()) gimple_omp_for_iter {
607 /* Condition code. */
608 enum tree_code cond;
610 /* Index variable. */
611 tree index;
613 /* Initial value. */
614 tree initial;
616 /* Final value. */
617 tree final;
619 /* Increment. */
620 tree incr;
623 /* GIMPLE_OMP_FOR */
625 struct GTY((tag("GSS_OMP_FOR")))
626 gomp_for : public gimple_statement_omp
628 /* [ WORD 1-7 ] : base class */
630 /* [ WORD 8 ] */
631 tree clauses;
633 /* [ WORD 9 ]
634 Number of elements in iter array. */
635 size_t collapse;
637 /* [ WORD 10 ] */
638 struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
640 /* [ WORD 11 ]
641 Pre-body evaluated before the loop body begins. */
642 gimple_seq pre_body;
646 /* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
648 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
649 gimple_statement_omp_parallel_layout : public gimple_statement_omp
651 /* [ WORD 1-7 ] : base class */
653 /* [ WORD 8 ]
654 Clauses. */
655 tree clauses;
657 /* [ WORD 9 ]
658 Child function holding the body of the parallel region. */
659 tree child_fn;
661 /* [ WORD 10 ]
662 Shared data argument. */
663 tree data_arg;
666 /* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
667 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
668 gimple_statement_omp_taskreg : public gimple_statement_omp_parallel_layout
670 /* No extra fields; adds invariant:
671 stmt->code == GIMPLE_OMP_PARALLEL
672 || stmt->code == GIMPLE_OMP_TASK
673 || stmt->code == GIMPLE_OMP_TEAMS. */
676 /* GIMPLE_OMP_PARALLEL */
677 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
678 gomp_parallel : public gimple_statement_omp_taskreg
680 /* No extra fields; adds invariant:
681 stmt->code == GIMPLE_OMP_PARALLEL. */
684 /* GIMPLE_OMP_TARGET */
685 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
686 gomp_target : public gimple_statement_omp_parallel_layout
688 /* No extra fields; adds invariant:
689 stmt->code == GIMPLE_OMP_TARGET. */
692 /* GIMPLE_OMP_TASK */
694 struct GTY((tag("GSS_OMP_TASK")))
695 gomp_task : public gimple_statement_omp_taskreg
697 /* [ WORD 1-10 ] : base class */
699 /* [ WORD 11 ]
700 Child function holding firstprivate initialization if needed. */
701 tree copy_fn;
703 /* [ WORD 12-13 ]
704 Size and alignment in bytes of the argument data block. */
705 tree arg_size;
706 tree arg_align;
710 /* GIMPLE_OMP_SECTION */
711 /* Uses struct gimple_statement_omp. */
714 /* GIMPLE_OMP_SECTIONS */
716 struct GTY((tag("GSS_OMP_SECTIONS")))
717 gomp_sections : public gimple_statement_omp
719 /* [ WORD 1-7 ] : base class */
721 /* [ WORD 8 ] */
722 tree clauses;
724 /* [ WORD 9 ]
725 The control variable used for deciding which of the sections to
726 execute. */
727 tree control;
730 /* GIMPLE_OMP_CONTINUE.
732 Note: This does not inherit from gimple_statement_omp, because we
733 do not need the body field. */
735 struct GTY((tag("GSS_OMP_CONTINUE")))
736 gomp_continue : public gimple
738 /* [ WORD 1-6 ] : base class */
740 /* [ WORD 7 ] */
741 tree control_def;
743 /* [ WORD 8 ] */
744 tree control_use;
747 /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP,
748 GIMPLE_OMP_SCAN, GIMPLE_OMP_MASKED, GIMPLE_OMP_SCOPE. */
750 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
751 gimple_statement_omp_single_layout : public gimple_statement_omp
753 /* [ WORD 1-7 ] : base class */
755 /* [ WORD 8 ] */
756 tree clauses;
759 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
760 gomp_single : public gimple_statement_omp_single_layout
762 /* No extra fields; adds invariant:
763 stmt->code == GIMPLE_OMP_SINGLE. */
766 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
767 gomp_teams : public gimple_statement_omp_taskreg
769 /* No extra fields; adds invariant:
770 stmt->code == GIMPLE_OMP_TEAMS. */
773 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
774 gomp_ordered : public gimple_statement_omp_single_layout
776 /* No extra fields; adds invariant:
777 stmt->code == GIMPLE_OMP_ORDERED. */
780 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
781 gomp_scan : public gimple_statement_omp_single_layout
783 /* No extra fields; adds invariant:
784 stmt->code == GIMPLE_OMP_SCAN. */
788 /* GIMPLE_OMP_ATOMIC_LOAD.
789 Note: This is based on gimple, not g_s_omp, because g_s_omp
790 contains a sequence, which we don't need here. */
792 struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
793 gomp_atomic_load : public gimple
795 /* [ WORD 1-6 ] : base class */
797 /* [ WORD 7-8 ] */
798 tree rhs, lhs;
801 /* GIMPLE_OMP_ATOMIC_STORE.
802 See note on GIMPLE_OMP_ATOMIC_LOAD. */
804 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
805 gimple_statement_omp_atomic_store_layout : public gimple
807 /* [ WORD 1-6 ] : base class */
809 /* [ WORD 7 ] */
810 tree val;
813 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
814 gomp_atomic_store :
815 public gimple_statement_omp_atomic_store_layout
817 /* No extra fields; adds invariant:
818 stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
821 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
822 gimple_statement_omp_return :
823 public gimple_statement_omp_atomic_store_layout
825 /* No extra fields; adds invariant:
826 stmt->code == GIMPLE_OMP_RETURN. */
829 /* Assumptions. */
831 struct GTY((tag("GSS_ASSUME")))
832 gimple_statement_assume : public gimple
834 /* [ WORD 1-6 ] : base class */
836 /* [ WORD 7 ] */
837 tree guard;
839 /* [ WORD 8 ] */
840 gimple_seq body;
843 /* GIMPLE_TRANSACTION. */
845 /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
847 /* The __transaction_atomic was declared [[outer]] or it is
848 __transaction_relaxed. */
849 #define GTMA_IS_OUTER (1u << 0)
850 #define GTMA_IS_RELAXED (1u << 1)
851 #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)
853 /* The transaction is seen to not have an abort. */
854 #define GTMA_HAVE_ABORT (1u << 2)
855 /* The transaction is seen to have loads or stores. */
856 #define GTMA_HAVE_LOAD (1u << 3)
857 #define GTMA_HAVE_STORE (1u << 4)
858 /* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
859 #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)
860 /* The transaction WILL enter serial irrevocable mode.
861 An irrevocable block post-dominates the entire transaction, such
862 that all invocations of the transaction will go serial-irrevocable.
863 In such case, we don't bother instrumenting the transaction, and
864 tell the runtime that it should begin the transaction in
865 serial-irrevocable mode. */
866 #define GTMA_DOES_GO_IRREVOCABLE (1u << 6)
867 /* The transaction contains no instrumentation code whatsover, most
868 likely because it is guaranteed to go irrevocable upon entry. */
869 #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
871 struct GTY((tag("GSS_TRANSACTION")))
872 gtransaction : public gimple_statement_with_memory_ops_base
874 /* [ WORD 1-9 ] : base class */
876 /* [ WORD 10 ] */
877 gimple_seq body;
879 /* [ WORD 11-13 ] */
880 tree label_norm;
881 tree label_uninst;
882 tree label_over;
885 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
886 enum gimple_statement_structure_enum {
887 #include "gsstruct.def"
888 LAST_GSS_ENUM
890 #undef DEFGSSTRUCT
892 /* A statement with the invariant that
893 stmt->code == GIMPLE_COND
894 i.e. a conditional jump statement. */
896 struct GTY((tag("GSS_WITH_OPS")))
897 gcond : public gimple_statement_with_ops
899 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
900 static const enum gimple_code code_ = GIMPLE_COND;
903 /* A statement with the invariant that
904 stmt->code == GIMPLE_DEBUG
905 i.e. a debug statement. */
907 struct GTY((tag("GSS_WITH_OPS")))
908 gdebug : public gimple_statement_with_ops
910 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
913 /* A statement with the invariant that
914 stmt->code == GIMPLE_GOTO
915 i.e. a goto statement. */
917 struct GTY((tag("GSS_WITH_OPS")))
918 ggoto : public gimple_statement_with_ops
920 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
923 /* A statement with the invariant that
924 stmt->code == GIMPLE_LABEL
925 i.e. a label statement. */
927 struct GTY((tag("GSS_WITH_OPS")))
928 glabel : public gimple_statement_with_ops
930 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
933 /* A statement with the invariant that
934 stmt->code == GIMPLE_SWITCH
935 i.e. a switch statement. */
937 struct GTY((tag("GSS_WITH_OPS")))
938 gswitch : public gimple_statement_with_ops
940 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
943 /* A statement with the invariant that
944 stmt->code == GIMPLE_ASSIGN
945 i.e. an assignment statement. */
947 struct GTY((tag("GSS_WITH_MEM_OPS")))
948 gassign : public gimple_statement_with_memory_ops
950 static const enum gimple_code code_ = GIMPLE_ASSIGN;
951 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
954 /* A statement with the invariant that
955 stmt->code == GIMPLE_RETURN
956 i.e. a return statement. */
958 struct GTY((tag("GSS_WITH_MEM_OPS")))
959 greturn : public gimple_statement_with_memory_ops
961 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
964 template <>
965 template <>
966 inline bool
967 is_a_helper <gasm *>::test (gimple *gs)
969 return gs->code == GIMPLE_ASM;
972 template <>
973 template <>
974 inline bool
975 is_a_helper <gassign *>::test (gimple *gs)
977 return gs->code == GIMPLE_ASSIGN;
980 template <>
981 template <>
982 inline bool
983 is_a_helper <const gassign *>::test (const gimple *gs)
985 return gs->code == GIMPLE_ASSIGN;
988 template <>
989 template <>
990 inline bool
991 is_a_helper <gbind *>::test (gimple *gs)
993 return gs->code == GIMPLE_BIND;
996 template <>
997 template <>
998 inline bool
999 is_a_helper <gcall *>::test (gimple *gs)
1001 return gs->code == GIMPLE_CALL;
1004 template <>
1005 template <>
1006 inline bool
1007 is_a_helper <gcatch *>::test (gimple *gs)
1009 return gs->code == GIMPLE_CATCH;
1012 template <>
1013 template <>
1014 inline bool
1015 is_a_helper <gcond *>::test (gimple *gs)
1017 return gs->code == GIMPLE_COND;
1020 template <>
1021 template <>
1022 inline bool
1023 is_a_helper <const gcond *>::test (const gimple *gs)
1025 return gs->code == GIMPLE_COND;
1028 template <>
1029 template <>
1030 inline bool
1031 is_a_helper <gdebug *>::test (gimple *gs)
1033 return gs->code == GIMPLE_DEBUG;
1036 template <>
1037 template <>
1038 inline bool
1039 is_a_helper <const gdebug *>::test (const gimple *gs)
1041 return gs->code == GIMPLE_DEBUG;
1044 template <>
1045 template <>
1046 inline bool
1047 is_a_helper <ggoto *>::test (gimple *gs)
1049 return gs->code == GIMPLE_GOTO;
1052 template <>
1053 template <>
1054 inline bool
1055 is_a_helper <const ggoto *>::test (const gimple *gs)
1057 return gs->code == GIMPLE_GOTO;
1060 template <>
1061 template <>
1062 inline bool
1063 is_a_helper <glabel *>::test (gimple *gs)
1065 return gs->code == GIMPLE_LABEL;
1068 template <>
1069 template <>
1070 inline bool
1071 is_a_helper <const glabel *>::test (const gimple *gs)
1073 return gs->code == GIMPLE_LABEL;
1076 template <>
1077 template <>
1078 inline bool
1079 is_a_helper <gresx *>::test (gimple *gs)
1081 return gs->code == GIMPLE_RESX;
1084 template <>
1085 template <>
1086 inline bool
1087 is_a_helper <geh_dispatch *>::test (gimple *gs)
1089 return gs->code == GIMPLE_EH_DISPATCH;
1092 template <>
1093 template <>
1094 inline bool
1095 is_a_helper <geh_else *>::test (gimple *gs)
1097 return gs->code == GIMPLE_EH_ELSE;
1100 template <>
1101 template <>
1102 inline bool
1103 is_a_helper <const geh_else *>::test (const gimple *gs)
1105 return gs->code == GIMPLE_EH_ELSE;
1108 template <>
1109 template <>
1110 inline bool
1111 is_a_helper <geh_filter *>::test (gimple *gs)
1113 return gs->code == GIMPLE_EH_FILTER;
1116 template <>
1117 template <>
1118 inline bool
1119 is_a_helper <geh_mnt *>::test (gimple *gs)
1121 return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1124 template <>
1125 template <>
1126 inline bool
1127 is_a_helper <const geh_mnt *>::test (const gimple *gs)
1129 return gs->code == GIMPLE_EH_MUST_NOT_THROW;
1132 template <>
1133 template <>
1134 inline bool
1135 is_a_helper <gomp_atomic_load *>::test (gimple *gs)
1137 return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1140 template <>
1141 template <>
1142 inline bool
1143 is_a_helper <gomp_atomic_store *>::test (gimple *gs)
1145 return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1148 template <>
1149 template <>
1150 inline bool
1151 is_a_helper <gimple_statement_omp_return *>::test (gimple *gs)
1153 return gs->code == GIMPLE_OMP_RETURN;
1156 template <>
1157 template <>
1158 inline bool
1159 is_a_helper <gomp_continue *>::test (gimple *gs)
1161 return gs->code == GIMPLE_OMP_CONTINUE;
1164 template <>
1165 template <>
1166 inline bool
1167 is_a_helper <gomp_critical *>::test (gimple *gs)
1169 return gs->code == GIMPLE_OMP_CRITICAL;
1172 template <>
1173 template <>
1174 inline bool
1175 is_a_helper <gomp_ordered *>::test (gimple *gs)
1177 return gs->code == GIMPLE_OMP_ORDERED;
1180 template <>
1181 template <>
1182 inline bool
1183 is_a_helper <gomp_scan *>::test (gimple *gs)
1185 return gs->code == GIMPLE_OMP_SCAN;
1188 template <>
1189 template <>
1190 inline bool
1191 is_a_helper <gomp_for *>::test (gimple *gs)
1193 return gs->code == GIMPLE_OMP_FOR;
1196 template <>
1197 template <>
1198 inline bool
1199 is_a_helper <gimple_statement_omp_taskreg *>::test (gimple *gs)
1201 return (gs->code == GIMPLE_OMP_PARALLEL
1202 || gs->code == GIMPLE_OMP_TASK
1203 || gs->code == GIMPLE_OMP_TEAMS);
1206 template <>
1207 template <>
1208 inline bool
1209 is_a_helper <gomp_parallel *>::test (gimple *gs)
1211 return gs->code == GIMPLE_OMP_PARALLEL;
1214 template <>
1215 template <>
1216 inline bool
1217 is_a_helper <gomp_target *>::test (gimple *gs)
1219 return gs->code == GIMPLE_OMP_TARGET;
1222 template <>
1223 template <>
1224 inline bool
1225 is_a_helper <gomp_sections *>::test (gimple *gs)
1227 return gs->code == GIMPLE_OMP_SECTIONS;
1230 template <>
1231 template <>
1232 inline bool
1233 is_a_helper <gomp_single *>::test (gimple *gs)
1235 return gs->code == GIMPLE_OMP_SINGLE;
1238 template <>
1239 template <>
1240 inline bool
1241 is_a_helper <gomp_teams *>::test (gimple *gs)
1243 return gs->code == GIMPLE_OMP_TEAMS;
1246 template <>
1247 template <>
1248 inline bool
1249 is_a_helper <gomp_task *>::test (gimple *gs)
1251 return gs->code == GIMPLE_OMP_TASK;
1254 template <>
1255 template <>
1256 inline bool
1257 is_a_helper <gphi *>::test (gimple *gs)
1259 return gs->code == GIMPLE_PHI;
1262 template <>
1263 template <>
1264 inline bool
1265 is_a_helper <greturn *>::test (gimple *gs)
1267 return gs->code == GIMPLE_RETURN;
1270 template <>
1271 template <>
1272 inline bool
1273 is_a_helper <gswitch *>::test (gimple *gs)
1275 return gs->code == GIMPLE_SWITCH;
1278 template <>
1279 template <>
1280 inline bool
1281 is_a_helper <const gswitch *>::test (const gimple *gs)
1283 return gs->code == GIMPLE_SWITCH;
1286 template <>
1287 template <>
1288 inline bool
1289 is_a_helper <gimple_statement_assume *>::test (gimple *gs)
1291 return gs->code == GIMPLE_ASSUME;
1294 template <>
1295 template <>
1296 inline bool
1297 is_a_helper <gtransaction *>::test (gimple *gs)
1299 return gs->code == GIMPLE_TRANSACTION;
1302 template <>
1303 template <>
1304 inline bool
1305 is_a_helper <gtry *>::test (gimple *gs)
1307 return gs->code == GIMPLE_TRY;
1310 template <>
1311 template <>
1312 inline bool
1313 is_a_helper <const gtry *>::test (const gimple *gs)
1315 return gs->code == GIMPLE_TRY;
1318 template <>
1319 template <>
1320 inline bool
1321 is_a_helper <gimple_statement_wce *>::test (gimple *gs)
1323 return gs->code == GIMPLE_WITH_CLEANUP_EXPR;
1326 template <>
1327 template <>
1328 inline bool
1329 is_a_helper <const gasm *>::test (const gimple *gs)
1331 return gs->code == GIMPLE_ASM;
1334 template <>
1335 template <>
1336 inline bool
1337 is_a_helper <const gbind *>::test (const gimple *gs)
1339 return gs->code == GIMPLE_BIND;
1342 template <>
1343 template <>
1344 inline bool
1345 is_a_helper <const gcall *>::test (const gimple *gs)
1347 return gs->code == GIMPLE_CALL;
1350 template <>
1351 template <>
1352 inline bool
1353 is_a_helper <const gcatch *>::test (const gimple *gs)
1355 return gs->code == GIMPLE_CATCH;
1358 template <>
1359 template <>
1360 inline bool
1361 is_a_helper <const gresx *>::test (const gimple *gs)
1363 return gs->code == GIMPLE_RESX;
1366 template <>
1367 template <>
1368 inline bool
1369 is_a_helper <const geh_dispatch *>::test (const gimple *gs)
1371 return gs->code == GIMPLE_EH_DISPATCH;
1374 template <>
1375 template <>
1376 inline bool
1377 is_a_helper <const geh_filter *>::test (const gimple *gs)
1379 return gs->code == GIMPLE_EH_FILTER;
1382 template <>
1383 template <>
1384 inline bool
1385 is_a_helper <const gomp_atomic_load *>::test (const gimple *gs)
1387 return gs->code == GIMPLE_OMP_ATOMIC_LOAD;
1390 template <>
1391 template <>
1392 inline bool
1393 is_a_helper <const gomp_atomic_store *>::test (const gimple *gs)
1395 return gs->code == GIMPLE_OMP_ATOMIC_STORE;
1398 template <>
1399 template <>
1400 inline bool
1401 is_a_helper <const gimple_statement_omp_return *>::test (const gimple *gs)
1403 return gs->code == GIMPLE_OMP_RETURN;
1406 template <>
1407 template <>
1408 inline bool
1409 is_a_helper <const gomp_continue *>::test (const gimple *gs)
1411 return gs->code == GIMPLE_OMP_CONTINUE;
1414 template <>
1415 template <>
1416 inline bool
1417 is_a_helper <const gomp_critical *>::test (const gimple *gs)
1419 return gs->code == GIMPLE_OMP_CRITICAL;
1422 template <>
1423 template <>
1424 inline bool
1425 is_a_helper <const gomp_ordered *>::test (const gimple *gs)
1427 return gs->code == GIMPLE_OMP_ORDERED;
1430 template <>
1431 template <>
1432 inline bool
1433 is_a_helper <const gomp_scan *>::test (const gimple *gs)
1435 return gs->code == GIMPLE_OMP_SCAN;
1438 template <>
1439 template <>
1440 inline bool
1441 is_a_helper <const gomp_for *>::test (const gimple *gs)
1443 return gs->code == GIMPLE_OMP_FOR;
1446 template <>
1447 template <>
1448 inline bool
1449 is_a_helper <const gimple_statement_omp_taskreg *>::test (const gimple *gs)
1451 return (gs->code == GIMPLE_OMP_PARALLEL
1452 || gs->code == GIMPLE_OMP_TASK
1453 || gs->code == GIMPLE_OMP_TEAMS);
1456 template <>
1457 template <>
1458 inline bool
1459 is_a_helper <const gomp_parallel *>::test (const gimple *gs)
1461 return gs->code == GIMPLE_OMP_PARALLEL;
1464 template <>
1465 template <>
1466 inline bool
1467 is_a_helper <const gomp_target *>::test (const gimple *gs)
1469 return gs->code == GIMPLE_OMP_TARGET;
1472 template <>
1473 template <>
1474 inline bool
1475 is_a_helper <const gomp_sections *>::test (const gimple *gs)
1477 return gs->code == GIMPLE_OMP_SECTIONS;
1480 template <>
1481 template <>
1482 inline bool
1483 is_a_helper <const gomp_single *>::test (const gimple *gs)
1485 return gs->code == GIMPLE_OMP_SINGLE;
1488 template <>
1489 template <>
1490 inline bool
1491 is_a_helper <const gomp_teams *>::test (const gimple *gs)
1493 return gs->code == GIMPLE_OMP_TEAMS;
1496 template <>
1497 template <>
1498 inline bool
1499 is_a_helper <const gomp_task *>::test (const gimple *gs)
1501 return gs->code == GIMPLE_OMP_TASK;
1504 template <>
1505 template <>
1506 inline bool
1507 is_a_helper <const gphi *>::test (const gimple *gs)
1509 return gs->code == GIMPLE_PHI;
1512 template <>
1513 template <>
1514 inline bool
1515 is_a_helper <const greturn *>::test (const gimple *gs)
1517 return gs->code == GIMPLE_RETURN;
1520 template <>
1521 template <>
1522 inline bool
1523 is_a_helper <const gimple_statement_assume *>::test (const gimple *gs)
1525 return gs->code == GIMPLE_ASSUME;
1528 template <>
1529 template <>
1530 inline bool
1531 is_a_helper <const gtransaction *>::test (const gimple *gs)
1533 return gs->code == GIMPLE_TRANSACTION;
1536 /* Offset in bytes to the location of the operand vector.
1537 Zero if there is no operand vector for this tuple structure. */
1538 extern size_t const gimple_ops_offset_[];
1540 /* Map GIMPLE codes to GSS codes. */
1541 extern enum gimple_statement_structure_enum const gss_for_code_[];
1543 /* This variable holds the currently expanded gimple statement for purposes
1544 of comminucating the profile info to the builtin expanders. */
1545 extern gimple *currently_expanding_gimple_stmt;
1547 size_t gimple_size (enum gimple_code code, unsigned num_ops = 0);
1548 void gimple_init (gimple *g, enum gimple_code code, unsigned num_ops);
1549 gimple *gimple_alloc (enum gimple_code, unsigned CXX_MEM_STAT_INFO);
1550 greturn *gimple_build_return (tree);
1551 void gimple_call_reset_alias_info (gcall *);
1552 gcall *gimple_build_call_vec (tree, const vec<tree> &);
1553 gcall *gimple_build_call (tree, unsigned, ...);
1554 gcall *gimple_build_call_valist (tree, unsigned, va_list);
1555 gcall *gimple_build_call_internal (enum internal_fn, unsigned, ...);
1556 gcall *gimple_build_call_internal_vec (enum internal_fn, const vec<tree> &);
1557 gcall *gimple_build_call_from_tree (tree, tree);
1558 gassign *gimple_build_assign (tree, tree CXX_MEM_STAT_INFO);
1559 gassign *gimple_build_assign (tree, enum tree_code,
1560 tree, tree, tree CXX_MEM_STAT_INFO);
1561 gassign *gimple_build_assign (tree, enum tree_code,
1562 tree, tree CXX_MEM_STAT_INFO);
1563 gassign *gimple_build_assign (tree, enum tree_code, tree CXX_MEM_STAT_INFO);
1564 gcond *gimple_build_cond (enum tree_code, tree, tree, tree, tree);
1565 gcond *gimple_build_cond_from_tree (tree, tree, tree);
1566 void gimple_cond_set_condition_from_tree (gcond *, tree);
1567 glabel *gimple_build_label (tree label);
1568 ggoto *gimple_build_goto (tree dest);
1569 gimple *gimple_build_nop (void);
1570 gbind *gimple_build_bind (tree, gimple_seq, tree);
1571 gasm *gimple_build_asm_vec (const char *, vec<tree, va_gc> *,
1572 vec<tree, va_gc> *, vec<tree, va_gc> *,
1573 vec<tree, va_gc> *);
1574 gcatch *gimple_build_catch (tree, gimple_seq);
1575 geh_filter *gimple_build_eh_filter (tree, gimple_seq);
1576 geh_mnt *gimple_build_eh_must_not_throw (tree);
1577 geh_else *gimple_build_eh_else (gimple_seq, gimple_seq);
1578 gtry *gimple_build_try (gimple_seq, gimple_seq,
1579 enum gimple_try_flags);
1580 gimple *gimple_build_wce (gimple_seq);
1581 gresx *gimple_build_resx (int);
1582 gswitch *gimple_build_switch_nlabels (unsigned, tree, tree);
1583 gswitch *gimple_build_switch (tree, tree, const vec<tree> &);
1584 geh_dispatch *gimple_build_eh_dispatch (int);
1585 gdebug *gimple_build_debug_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1586 gdebug *gimple_build_debug_source_bind (tree, tree, gimple * CXX_MEM_STAT_INFO);
1587 gdebug *gimple_build_debug_begin_stmt (tree, location_t CXX_MEM_STAT_INFO);
1588 gdebug *gimple_build_debug_inline_entry (tree, location_t CXX_MEM_STAT_INFO);
1589 gomp_critical *gimple_build_omp_critical (gimple_seq, tree, tree);
1590 gomp_for *gimple_build_omp_for (gimple_seq, int, tree, size_t, gimple_seq);
1591 gomp_parallel *gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
1592 gomp_task *gimple_build_omp_task (gimple_seq, tree, tree, tree, tree,
1593 tree, tree);
1594 gimple *gimple_build_omp_section (gimple_seq);
1595 gimple *gimple_build_omp_structured_block (gimple_seq);
1596 gimple *gimple_build_omp_scope (gimple_seq, tree);
1597 gimple *gimple_build_omp_master (gimple_seq);
1598 gimple *gimple_build_omp_masked (gimple_seq, tree);
1599 gimple *gimple_build_omp_taskgroup (gimple_seq, tree);
1600 gomp_continue *gimple_build_omp_continue (tree, tree);
1601 gomp_ordered *gimple_build_omp_ordered (gimple_seq, tree);
1602 gimple *gimple_build_omp_return (bool);
1603 gomp_scan *gimple_build_omp_scan (gimple_seq, tree);
1604 gomp_sections *gimple_build_omp_sections (gimple_seq, tree);
1605 gimple *gimple_build_omp_sections_switch (void);
1606 gomp_single *gimple_build_omp_single (gimple_seq, tree);
1607 gomp_target *gimple_build_omp_target (gimple_seq, int, tree);
1608 gomp_teams *gimple_build_omp_teams (gimple_seq, tree);
1609 gomp_atomic_load *gimple_build_omp_atomic_load (tree, tree,
1610 enum omp_memory_order);
1611 gomp_atomic_store *gimple_build_omp_atomic_store (tree, enum omp_memory_order);
1612 gimple *gimple_build_assume (tree, gimple_seq);
1613 gtransaction *gimple_build_transaction (gimple_seq);
1614 extern void gimple_seq_add_stmt (gimple_seq *, gimple *);
1615 extern void gimple_seq_add_stmt_without_update (gimple_seq *, gimple *);
1616 void gimple_seq_add_seq (gimple_seq *, gimple_seq);
1617 void gimple_seq_add_seq_without_update (gimple_seq *, gimple_seq);
1618 extern void annotate_all_with_location_after (gimple_seq, gimple_stmt_iterator,
1619 location_t);
1620 extern void annotate_all_with_location (gimple_seq, location_t);
1621 bool empty_body_p (gimple_seq);
1622 gimple_seq gimple_seq_copy (gimple_seq);
1623 bool gimple_call_same_target_p (const gimple *, const gimple *);
1624 int gimple_call_flags (const gimple *);
1625 int gimple_call_arg_flags (const gcall *, unsigned);
1626 int gimple_call_retslot_flags (const gcall *);
1627 int gimple_call_static_chain_flags (const gcall *);
1628 int gimple_call_return_flags (const gcall *);
1629 bool gimple_call_nonnull_result_p (gcall *);
1630 tree gimple_call_nonnull_arg (gcall *);
1631 bool gimple_assign_copy_p (gimple *);
1632 bool gimple_assign_ssa_name_copy_p (gimple *);
1633 bool gimple_assign_unary_nop_p (gimple *);
1634 bool gimple_assign_load_p (const gimple *);
1635 void gimple_set_bb (gimple *, basic_block);
1636 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
1637 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
1638 tree, tree, tree);
1639 tree gimple_get_lhs (const gimple *);
1640 void gimple_set_lhs (gimple *, tree);
1641 gimple *gimple_copy (gimple *);
1642 void gimple_move_vops (gimple *, gimple *);
1643 bool gimple_has_side_effects (const gimple *);
1644 bool gimple_could_trap_p_1 (const gimple *, bool, bool);
1645 bool gimple_could_trap_p (const gimple *);
1646 bool gimple_assign_rhs_could_trap_p (gimple *);
1647 extern void dump_gimple_statistics (void);
1648 unsigned get_gimple_rhs_num_ops (enum tree_code);
1649 gcall *gimple_call_copy_skip_args (gcall *, bitmap);
1650 extern bool gimple_compare_field_offset (tree, tree);
1651 extern tree gimple_unsigned_type (tree);
1652 extern tree gimple_signed_type (tree);
1653 extern alias_set_type gimple_get_alias_set (tree);
1654 extern bool gimple_ior_addresses_taken (bitmap, gimple *);
1655 extern bool gimple_builtin_call_types_compatible_p (const gimple *, tree);
1656 extern combined_fn gimple_call_combined_fn (const gimple *);
1657 extern bool gimple_call_operator_delete_p (const gcall *);
1658 extern bool gimple_call_builtin_p (const gimple *);
1659 extern bool gimple_call_builtin_p (const gimple *, enum built_in_class);
1660 extern bool gimple_call_builtin_p (const gimple *, enum built_in_function);
1661 extern bool gimple_asm_clobbers_memory_p (const gasm *);
1662 extern void dump_decl_set (FILE *, bitmap);
1663 extern bool nonfreeing_call_p (gimple *);
1664 extern bool nonbarrier_call_p (gimple *);
1665 extern bool infer_nonnull_range (gimple *, tree);
1666 extern bool infer_nonnull_range_by_dereference (gimple *, tree);
1667 extern bool infer_nonnull_range_by_attribute (gimple *, tree);
1668 extern void sort_case_labels (vec<tree> &);
1669 extern void preprocess_case_label_vec_for_gimple (vec<tree> &, tree, tree *);
1670 extern void gimple_seq_set_location (gimple_seq, location_t);
1671 extern void gimple_seq_discard (gimple_seq);
1672 extern void maybe_remove_unused_call_args (struct function *, gimple *);
1673 extern bool gimple_inexpensive_call_p (gcall *);
1674 extern bool stmt_can_terminate_bb_p (gimple *);
1675 extern location_t gimple_or_expr_nonartificial_location (gimple *, tree);
1676 gcall *gimple_build_builtin_unreachable (location_t);
1678 /* Return the disposition for a warning (or all warnings by default)
1679 for a statement. */
1680 extern bool warning_suppressed_p (const gimple *, opt_code = all_warnings)
1681 ATTRIBUTE_NONNULL (1);
1682 /* Set the disposition for a warning (or all warnings by default)
1683 at a location to enabled by default. */
1684 extern void suppress_warning (gimple *, opt_code = all_warnings,
1685 bool = true) ATTRIBUTE_NONNULL (1);
1687 /* Copy the warning disposition mapping from one statement to another. */
1688 extern void copy_warning (gimple *, const gimple *)
1689 ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1690 /* Copy the warning disposition mapping from an expression to a statement. */
1691 extern void copy_warning (gimple *, const_tree)
1692 ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1693 /* Copy the warning disposition mapping from a statement to an expression. */
1694 extern void copy_warning (tree, const gimple *)
1695 ATTRIBUTE_NONNULL (1) ATTRIBUTE_NONNULL (2);
1697 /* Formal (expression) temporary table handling: multiple occurrences of
1698 the same scalar expression are evaluated into the same temporary. */
1700 typedef struct gimple_temp_hash_elt
1702 tree val; /* Key */
1703 tree temp; /* Value */
1704 } elt_t;
1706 /* Get the number of the next statement uid to be allocated. */
1707 inline unsigned int
1708 gimple_stmt_max_uid (struct function *fn)
1710 return fn->last_stmt_uid;
1713 /* Set the number of the next statement uid to be allocated. */
1714 inline void
1715 set_gimple_stmt_max_uid (struct function *fn, unsigned int maxid)
1717 fn->last_stmt_uid = maxid;
1720 /* Set the number of the next statement uid to be allocated. */
1721 inline unsigned int
1722 inc_gimple_stmt_max_uid (struct function *fn)
1724 return fn->last_stmt_uid++;
1727 /* Return the first node in GIMPLE sequence S. */
1729 inline gimple_seq_node
1730 gimple_seq_first (gimple_seq s)
1732 return s;
1736 /* Return the first statement in GIMPLE sequence S. */
1738 inline gimple *
1739 gimple_seq_first_stmt (gimple_seq s)
1741 gimple_seq_node n = gimple_seq_first (s);
1742 return n;
1745 /* Return the first statement in GIMPLE sequence S as a gbind *,
1746 verifying that it has code GIMPLE_BIND in a checked build. */
1748 inline gbind *
1749 gimple_seq_first_stmt_as_a_bind (gimple_seq s)
1751 gimple_seq_node n = gimple_seq_first (s);
1752 return as_a <gbind *> (n);
1756 /* Return the last node in GIMPLE sequence S. */
1758 inline gimple_seq_node
1759 gimple_seq_last (gimple_seq s)
1761 return s ? s->prev : NULL;
1765 /* Return the last statement in GIMPLE sequence S. */
1767 inline gimple *
1768 gimple_seq_last_stmt (gimple_seq s)
1770 gimple_seq_node n = gimple_seq_last (s);
1771 return n;
1775 /* Set the last node in GIMPLE sequence *PS to LAST. */
1777 inline void
1778 gimple_seq_set_last (gimple_seq *ps, gimple_seq_node last)
1780 (*ps)->prev = last;
1784 /* Set the first node in GIMPLE sequence *PS to FIRST. */
1786 inline void
1787 gimple_seq_set_first (gimple_seq *ps, gimple_seq_node first)
1789 *ps = first;
1793 /* Return true if GIMPLE sequence S is empty. */
1795 inline bool
1796 gimple_seq_empty_p (gimple_seq s)
1798 return s == NULL;
1801 /* Allocate a new sequence and initialize its first element with STMT. */
1803 inline gimple_seq
1804 gimple_seq_alloc_with_stmt (gimple *stmt)
1806 gimple_seq seq = NULL;
1807 gimple_seq_add_stmt (&seq, stmt);
1808 return seq;
1812 /* Returns the sequence of statements in BB. */
1814 inline gimple_seq
1815 bb_seq (const_basic_block bb)
1817 return (!(bb->flags & BB_RTL)) ? bb->il.gimple.seq : NULL;
1820 inline gimple_seq *
1821 bb_seq_addr (basic_block bb)
1823 return (!(bb->flags & BB_RTL)) ? &bb->il.gimple.seq : NULL;
1826 /* Sets the sequence of statements in BB to SEQ. */
1828 inline void
1829 set_bb_seq (basic_block bb, gimple_seq seq)
1831 gcc_checking_assert (!(bb->flags & BB_RTL));
1832 bb->il.gimple.seq = seq;
1836 /* Return the code for GIMPLE statement G. */
1838 inline enum gimple_code
1839 gimple_code (const gimple *g)
1841 return g->code;
1845 /* Return the GSS code used by a GIMPLE code. */
1847 inline enum gimple_statement_structure_enum
1848 gss_for_code (enum gimple_code code)
1850 gcc_gimple_checking_assert ((unsigned int)code < LAST_AND_UNUSED_GIMPLE_CODE);
1851 return gss_for_code_[code];
1855 /* Return which GSS code is used by GS. */
1857 inline enum gimple_statement_structure_enum
1858 gimple_statement_structure (gimple *gs)
1860 return gss_for_code (gimple_code (gs));
1864 /* Return true if statement G has sub-statements. This is only true for
1865 High GIMPLE statements. */
1867 inline bool
1868 gimple_has_substatements (gimple *g)
1870 switch (gimple_code (g))
1872 case GIMPLE_ASSUME:
1873 case GIMPLE_BIND:
1874 case GIMPLE_CATCH:
1875 case GIMPLE_EH_FILTER:
1876 case GIMPLE_EH_ELSE:
1877 case GIMPLE_TRY:
1878 case GIMPLE_OMP_FOR:
1879 case GIMPLE_OMP_MASTER:
1880 case GIMPLE_OMP_MASKED:
1881 case GIMPLE_OMP_TASKGROUP:
1882 case GIMPLE_OMP_ORDERED:
1883 case GIMPLE_OMP_SECTION:
1884 case GIMPLE_OMP_STRUCTURED_BLOCK:
1885 case GIMPLE_OMP_PARALLEL:
1886 case GIMPLE_OMP_TASK:
1887 case GIMPLE_OMP_SCOPE:
1888 case GIMPLE_OMP_SECTIONS:
1889 case GIMPLE_OMP_SINGLE:
1890 case GIMPLE_OMP_TARGET:
1891 case GIMPLE_OMP_TEAMS:
1892 case GIMPLE_OMP_CRITICAL:
1893 case GIMPLE_WITH_CLEANUP_EXPR:
1894 case GIMPLE_TRANSACTION:
1895 return true;
1897 default:
1898 return false;
1903 /* Return the basic block holding statement G. */
1905 inline basic_block
1906 gimple_bb (const gimple *g)
1908 return g->bb;
1912 /* Return the lexical scope block holding statement G. */
1914 inline tree
1915 gimple_block (const gimple *g)
1917 return LOCATION_BLOCK (g->location);
1920 /* Forward declare. */
1921 inline void gimple_set_location (gimple *, location_t);
1923 /* Set BLOCK to be the lexical scope block holding statement G. */
1925 inline void
1926 gimple_set_block (gimple *g, tree block)
1928 gimple_set_location (g, set_block (g->location, block));
1931 /* Return location information for statement G. */
1933 inline location_t
1934 gimple_location (const gimple *g)
1936 return g->location;
1939 /* Return location information for statement G if g is not NULL.
1940 Otherwise, UNKNOWN_LOCATION is returned. */
1942 inline location_t
1943 gimple_location_safe (const gimple *g)
1945 return g ? gimple_location (g) : UNKNOWN_LOCATION;
1948 /* Set location information for statement G. */
1950 inline void
1951 gimple_set_location (gimple *g, location_t location)
1953 /* Copy the no-warning data to the statement location. */
1954 if (g->location != UNKNOWN_LOCATION)
1955 copy_warning (location, g->location);
1956 g->location = location;
1959 /* Return address of the location information for statement G. */
1961 inline location_t *
1962 gimple_location_ptr (gimple *g)
1964 return &g->location;
1968 /* Return true if G contains location information. */
1970 inline bool
1971 gimple_has_location (const gimple *g)
1973 return LOCATION_LOCUS (gimple_location (g)) != UNKNOWN_LOCATION;
1977 /* Return non-artificial location information for statement G. */
1979 inline location_t
1980 gimple_nonartificial_location (const gimple *g)
1982 location_t *ploc = NULL;
1984 if (tree block = gimple_block (g))
1985 ploc = block_nonartificial_location (block);
1987 return ploc ? *ploc : gimple_location (g);
1991 /* Return the file name of the location of STMT. */
1993 inline const char *
1994 gimple_filename (const gimple *stmt)
1996 return LOCATION_FILE (gimple_location (stmt));
2000 /* Return the line number of the location of STMT. */
2002 inline int
2003 gimple_lineno (const gimple *stmt)
2005 return LOCATION_LINE (gimple_location (stmt));
2009 /* Determine whether SEQ is a singleton. */
2011 inline bool
2012 gimple_seq_singleton_p (gimple_seq seq)
2014 return ((gimple_seq_first (seq) != NULL)
2015 && (gimple_seq_first (seq) == gimple_seq_last (seq)));
2018 /* Return true if no warnings should be emitted for statement STMT. */
2020 inline bool
2021 gimple_no_warning_p (const gimple *stmt)
2023 return stmt->no_warning;
2026 /* Set the no_warning flag of STMT to NO_WARNING. */
2028 inline void
2029 gimple_set_no_warning (gimple *stmt, bool no_warning)
2031 stmt->no_warning = (unsigned) no_warning;
2034 /* Set the visited status on statement STMT to VISITED_P.
2036 Please note that this 'visited' property of the gimple statement is
2037 supposed to be undefined at pass boundaries. This means that a
2038 given pass should not assume it contains any useful value when the
2039 pass starts and thus can set it to any value it sees fit.
2041 You can learn more about the visited property of the gimple
2042 statement by reading the comments of the 'visited' data member of
2043 struct gimple.
2046 inline void
2047 gimple_set_visited (gimple *stmt, bool visited_p)
2049 stmt->visited = (unsigned) visited_p;
2053 /* Return the visited status for statement STMT.
2055 Please note that this 'visited' property of the gimple statement is
2056 supposed to be undefined at pass boundaries. This means that a
2057 given pass should not assume it contains any useful value when the
2058 pass starts and thus can set it to any value it sees fit.
2060 You can learn more about the visited property of the gimple
2061 statement by reading the comments of the 'visited' data member of
2062 struct gimple. */
2064 inline bool
2065 gimple_visited_p (gimple *stmt)
2067 return stmt->visited;
2071 /* Set pass local flag PLF on statement STMT to VAL_P.
2073 Please note that this PLF property of the gimple statement is
2074 supposed to be undefined at pass boundaries. This means that a
2075 given pass should not assume it contains any useful value when the
2076 pass starts and thus can set it to any value it sees fit.
2078 You can learn more about the PLF property by reading the comment of
2079 the 'plf' data member of struct gimple_statement_structure. */
2081 inline void
2082 gimple_set_plf (gimple *stmt, enum plf_mask plf, bool val_p)
2084 if (val_p)
2085 stmt->plf |= (unsigned int) plf;
2086 else
2087 stmt->plf &= ~((unsigned int) plf);
2091 /* Return the value of pass local flag PLF on statement STMT.
2093 Please note that this 'plf' property of the gimple statement is
2094 supposed to be undefined at pass boundaries. This means that a
2095 given pass should not assume it contains any useful value when the
2096 pass starts and thus can set it to any value it sees fit.
2098 You can learn more about the plf property by reading the comment of
2099 the 'plf' data member of struct gimple_statement_structure. */
2101 inline unsigned int
2102 gimple_plf (gimple *stmt, enum plf_mask plf)
2104 return stmt->plf & ((unsigned int) plf);
2108 /* Set the UID of statement.
2110 Please note that this UID property is supposed to be undefined at
2111 pass boundaries. This means that a given pass should not assume it
2112 contains any useful value when the pass starts and thus can set it
2113 to any value it sees fit. */
2115 inline void
2116 gimple_set_uid (gimple *g, unsigned uid)
2118 g->uid = uid;
2122 /* Return the UID of statement.
2124 Please note that this UID property is supposed to be undefined at
2125 pass boundaries. This means that a given pass should not assume it
2126 contains any useful value when the pass starts and thus can set it
2127 to any value it sees fit. */
2129 inline unsigned
2130 gimple_uid (const gimple *g)
2132 return g->uid;
2136 /* Make statement G a singleton sequence. */
2138 inline void
2139 gimple_init_singleton (gimple *g)
2141 g->next = NULL;
2142 g->prev = g;
2146 /* Return true if GIMPLE statement G has register or memory operands. */
2148 inline bool
2149 gimple_has_ops (const gimple *g)
2151 return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
2154 template <>
2155 template <>
2156 inline bool
2157 is_a_helper <const gimple_statement_with_ops *>::test (const gimple *gs)
2159 return gimple_has_ops (gs);
2162 template <>
2163 template <>
2164 inline bool
2165 is_a_helper <gimple_statement_with_ops *>::test (gimple *gs)
2167 return gimple_has_ops (gs);
2170 /* Return true if GIMPLE statement G has memory operands. */
2172 inline bool
2173 gimple_has_mem_ops (const gimple *g)
2175 return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
2178 template <>
2179 template <>
2180 inline bool
2181 is_a_helper <const gimple_statement_with_memory_ops *>::test (const gimple *gs)
2183 return gimple_has_mem_ops (gs);
2186 template <>
2187 template <>
2188 inline bool
2189 is_a_helper <gimple_statement_with_memory_ops *>::test (gimple *gs)
2191 return gimple_has_mem_ops (gs);
2194 /* Return the set of USE operands for statement G. */
2196 inline struct use_optype_d *
2197 gimple_use_ops (const gimple *g)
2199 const gimple_statement_with_ops *ops_stmt =
2200 dyn_cast <const gimple_statement_with_ops *> (g);
2201 if (!ops_stmt)
2202 return NULL;
2203 return ops_stmt->use_ops;
2207 /* Set USE to be the set of USE operands for statement G. */
2209 inline void
2210 gimple_set_use_ops (gimple *g, struct use_optype_d *use)
2212 gimple_statement_with_ops *ops_stmt =
2213 as_a <gimple_statement_with_ops *> (g);
2214 ops_stmt->use_ops = use;
2218 /* Return the single VUSE operand of the statement G. */
2220 inline tree
2221 gimple_vuse (const gimple *g)
2223 const gimple_statement_with_memory_ops *mem_ops_stmt =
2224 dyn_cast <const gimple_statement_with_memory_ops *> (g);
2225 if (!mem_ops_stmt)
2226 return NULL_TREE;
2227 return mem_ops_stmt->vuse;
2230 /* Return the single VDEF operand of the statement G. */
2232 inline tree
2233 gimple_vdef (const gimple *g)
2235 const gimple_statement_with_memory_ops *mem_ops_stmt =
2236 dyn_cast <const gimple_statement_with_memory_ops *> (g);
2237 if (!mem_ops_stmt)
2238 return NULL_TREE;
2239 return mem_ops_stmt->vdef;
2242 /* Return the single VUSE operand of the statement G. */
2244 inline tree *
2245 gimple_vuse_ptr (gimple *g)
2247 gimple_statement_with_memory_ops *mem_ops_stmt =
2248 dyn_cast <gimple_statement_with_memory_ops *> (g);
2249 if (!mem_ops_stmt)
2250 return NULL;
2251 return &mem_ops_stmt->vuse;
2254 /* Return the single VDEF operand of the statement G. */
2256 inline tree *
2257 gimple_vdef_ptr (gimple *g)
2259 gimple_statement_with_memory_ops *mem_ops_stmt =
2260 dyn_cast <gimple_statement_with_memory_ops *> (g);
2261 if (!mem_ops_stmt)
2262 return NULL;
2263 return &mem_ops_stmt->vdef;
2266 /* Set the single VUSE operand of the statement G. */
2268 inline void
2269 gimple_set_vuse (gimple *g, tree vuse)
2271 gimple_statement_with_memory_ops *mem_ops_stmt =
2272 as_a <gimple_statement_with_memory_ops *> (g);
2273 mem_ops_stmt->vuse = vuse;
2276 /* Set the single VDEF operand of the statement G. */
2278 inline void
2279 gimple_set_vdef (gimple *g, tree vdef)
2281 gimple_statement_with_memory_ops *mem_ops_stmt =
2282 as_a <gimple_statement_with_memory_ops *> (g);
2283 mem_ops_stmt->vdef = vdef;
2287 /* Return true if statement G has operands and the modified field has
2288 been set. */
2290 inline bool
2291 gimple_modified_p (const gimple *g)
2293 return (gimple_has_ops (g)) ? (bool) g->modified : false;
2297 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2298 a MODIFIED field. */
2300 inline void
2301 gimple_set_modified (gimple *s, bool modifiedp)
2303 if (gimple_has_ops (s))
2304 s->modified = (unsigned) modifiedp;
2308 /* Return true if statement STMT contains volatile operands. */
2310 inline bool
2311 gimple_has_volatile_ops (const gimple *stmt)
2313 if (gimple_has_mem_ops (stmt))
2314 return stmt->has_volatile_ops;
2315 else
2316 return false;
2320 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
2322 inline void
2323 gimple_set_has_volatile_ops (gimple *stmt, bool volatilep)
2325 if (gimple_has_mem_ops (stmt))
2326 stmt->has_volatile_ops = (unsigned) volatilep;
2329 /* Return true if STMT is in a transaction. */
2331 inline bool
2332 gimple_in_transaction (const gimple *stmt)
2334 return bb_in_transaction (gimple_bb (stmt));
2337 /* Return true if statement STMT may access memory. */
2339 inline bool
2340 gimple_references_memory_p (gimple *stmt)
2342 return gimple_has_mem_ops (stmt) && gimple_vuse (stmt);
2346 /* Return the subcode for OMP statement S. */
2348 inline unsigned
2349 gimple_omp_subcode (const gimple *s)
2351 gcc_gimple_checking_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
2352 && gimple_code (s) <= GIMPLE_OMP_ORDERED);
2353 return s->subcode;
2356 /* Set the subcode for OMP statement S to SUBCODE. */
2358 inline void
2359 gimple_omp_set_subcode (gimple *s, unsigned int subcode)
2361 /* We only have 16 bits for the subcode. Assert that we are not
2362 overflowing it. */
2363 gcc_gimple_checking_assert (subcode < (1 << 16));
2364 s->subcode = subcode;
2367 /* Set the nowait flag on OMP_RETURN statement S. */
2369 inline void
2370 gimple_omp_return_set_nowait (gimple *s)
2372 GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
2373 s->subcode |= GF_OMP_RETURN_NOWAIT;
2377 /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
2378 flag set. */
2380 inline bool
2381 gimple_omp_return_nowait_p (const gimple *g)
2383 GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
2384 return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
2388 /* Set the LHS of OMP return. */
2390 inline void
2391 gimple_omp_return_set_lhs (gimple *g, tree lhs)
2393 gimple_statement_omp_return *omp_return_stmt =
2394 as_a <gimple_statement_omp_return *> (g);
2395 omp_return_stmt->val = lhs;
2399 /* Get the LHS of OMP return. */
2401 inline tree
2402 gimple_omp_return_lhs (const gimple *g)
2404 const gimple_statement_omp_return *omp_return_stmt =
2405 as_a <const gimple_statement_omp_return *> (g);
2406 return omp_return_stmt->val;
2410 /* Return a pointer to the LHS of OMP return. */
2412 inline tree *
2413 gimple_omp_return_lhs_ptr (gimple *g)
2415 gimple_statement_omp_return *omp_return_stmt =
2416 as_a <gimple_statement_omp_return *> (g);
2417 return &omp_return_stmt->val;
2421 /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
2422 flag set. */
2424 inline bool
2425 gimple_omp_section_last_p (const gimple *g)
2427 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2428 return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
2432 /* Set the GF_OMP_SECTION_LAST flag on G. */
2434 inline void
2435 gimple_omp_section_set_last (gimple *g)
2437 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
2438 g->subcode |= GF_OMP_SECTION_LAST;
2442 /* Return true if OMP ordered construct is stand-alone
2443 (G has the GF_OMP_ORDERED_STANDALONE flag set). */
2445 inline bool
2446 gimple_omp_ordered_standalone_p (const gimple *g)
2448 GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2449 return (gimple_omp_subcode (g) & GF_OMP_ORDERED_STANDALONE) != 0;
2453 /* Set the GF_OMP_ORDERED_STANDALONE flag on G. */
2455 inline void
2456 gimple_omp_ordered_standalone (gimple *g)
2458 GIMPLE_CHECK (g, GIMPLE_OMP_ORDERED);
2459 g->subcode |= GF_OMP_ORDERED_STANDALONE;
2463 /* Return true if OMP parallel statement G has the
2464 GF_OMP_PARALLEL_COMBINED flag set. */
2466 inline bool
2467 gimple_omp_parallel_combined_p (const gimple *g)
2469 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2470 return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
2474 /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
2475 value of COMBINED_P. */
2477 inline void
2478 gimple_omp_parallel_set_combined_p (gimple *g, bool combined_p)
2480 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
2481 if (combined_p)
2482 g->subcode |= GF_OMP_PARALLEL_COMBINED;
2483 else
2484 g->subcode &= ~GF_OMP_PARALLEL_COMBINED;
2488 /* Return true if OMP atomic load/store statement G has the
2489 GF_OMP_ATOMIC_NEED_VALUE flag set. */
2491 inline bool
2492 gimple_omp_atomic_need_value_p (const gimple *g)
2494 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2495 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2496 return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_NEED_VALUE) != 0;
2500 /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
2502 inline void
2503 gimple_omp_atomic_set_need_value (gimple *g)
2505 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2506 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2507 g->subcode |= GF_OMP_ATOMIC_NEED_VALUE;
2511 /* Return true if OMP atomic load/store statement G has the
2512 GF_OMP_ATOMIC_WEAK flag set. */
2514 inline bool
2515 gimple_omp_atomic_weak_p (const gimple *g)
2517 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2518 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2519 return (gimple_omp_subcode (g) & GF_OMP_ATOMIC_WEAK) != 0;
2523 /* Set the GF_OMP_ATOMIC_WEAK flag on G. */
2525 inline void
2526 gimple_omp_atomic_set_weak (gimple *g)
2528 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2529 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2530 g->subcode |= GF_OMP_ATOMIC_WEAK;
2534 /* Return the memory order of the OMP atomic load/store statement G. */
2536 inline enum omp_memory_order
2537 gimple_omp_atomic_memory_order (const gimple *g)
2539 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2540 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2541 return (enum omp_memory_order)
2542 (gimple_omp_subcode (g) & GF_OMP_ATOMIC_MEMORY_ORDER);
2546 /* Set the memory order on G. */
2548 inline void
2549 gimple_omp_atomic_set_memory_order (gimple *g, enum omp_memory_order mo)
2551 if (gimple_code (g) != GIMPLE_OMP_ATOMIC_LOAD)
2552 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
2553 g->subcode = ((g->subcode & ~GF_OMP_ATOMIC_MEMORY_ORDER)
2554 | (mo & GF_OMP_ATOMIC_MEMORY_ORDER));
2558 /* Return the number of operands for statement GS. */
2560 inline unsigned
2561 gimple_num_ops (const gimple *gs)
2563 return gs->num_ops;
2567 /* Set the number of operands for statement GS. */
2569 inline void
2570 gimple_set_num_ops (gimple *gs, unsigned num_ops)
2572 gs->num_ops = num_ops;
2576 /* Return the array of operands for statement GS. */
2578 inline tree *
2579 gimple_ops (gimple *gs)
2581 size_t off;
2583 /* All the tuples have their operand vector at the very bottom
2584 of the structure. Note that those structures that do not
2585 have an operand vector have a zero offset. */
2586 off = gimple_ops_offset_[gimple_statement_structure (gs)];
2587 gcc_gimple_checking_assert (off != 0);
2589 return (tree *) ((char *) gs + off);
2593 /* Return operand I for statement GS. */
2595 inline tree
2596 gimple_op (const gimple *gs, unsigned i)
2598 if (gimple_has_ops (gs))
2600 gcc_gimple_checking_assert (i < gimple_num_ops (gs));
2601 return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
2603 else
2604 return NULL_TREE;
2607 /* Return a pointer to operand I for statement GS. */
2609 inline tree *
2610 gimple_op_ptr (gimple *gs, unsigned i)
2612 if (gimple_has_ops (gs))
2614 gcc_gimple_checking_assert (i < gimple_num_ops (gs));
2615 return gimple_ops (gs) + i;
2617 else
2618 return NULL;
2621 /* Set operand I of statement GS to OP. */
2623 inline void
2624 gimple_set_op (gimple *gs, unsigned i, tree op)
2626 gcc_gimple_checking_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
2628 /* Note. It may be tempting to assert that OP matches
2629 is_gimple_operand, but that would be wrong. Different tuples
2630 accept slightly different sets of tree operands. Each caller
2631 should perform its own validation. */
2632 gimple_ops (gs)[i] = op;
2635 /* Return true if GS is a GIMPLE_ASSIGN. */
2637 inline bool
2638 is_gimple_assign (const gimple *gs)
2640 return gimple_code (gs) == GIMPLE_ASSIGN;
2643 /* Determine if expression CODE is one of the valid expressions that can
2644 be used on the RHS of GIMPLE assignments. */
2646 inline enum gimple_rhs_class
2647 get_gimple_rhs_class (enum tree_code code)
2649 return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
2652 /* Return the LHS of assignment statement GS. */
2654 inline tree
2655 gimple_assign_lhs (const gassign *gs)
2657 return gs->op[0];
2660 inline tree
2661 gimple_assign_lhs (const gimple *gs)
2663 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2664 return gimple_assign_lhs (ass);
2668 /* Return a pointer to the LHS of assignment statement GS. */
2670 inline tree *
2671 gimple_assign_lhs_ptr (gassign *gs)
2673 return &gs->op[0];
2676 inline tree *
2677 gimple_assign_lhs_ptr (gimple *gs)
2679 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2680 return gimple_assign_lhs_ptr (ass);
2684 /* Set LHS to be the LHS operand of assignment statement GS. */
2686 inline void
2687 gimple_assign_set_lhs (gassign *gs, tree lhs)
2689 gs->op[0] = lhs;
2691 if (lhs && TREE_CODE (lhs) == SSA_NAME)
2692 SSA_NAME_DEF_STMT (lhs) = gs;
2695 inline void
2696 gimple_assign_set_lhs (gimple *gs, tree lhs)
2698 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2699 gimple_assign_set_lhs (ass, lhs);
2703 /* Return the first operand on the RHS of assignment statement GS. */
2705 inline tree
2706 gimple_assign_rhs1 (const gassign *gs)
2708 return gs->op[1];
2711 inline tree
2712 gimple_assign_rhs1 (const gimple *gs)
2714 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2715 return gimple_assign_rhs1 (ass);
2719 /* Return a pointer to the first operand on the RHS of assignment
2720 statement GS. */
2722 inline tree *
2723 gimple_assign_rhs1_ptr (gassign *gs)
2725 return &gs->op[1];
2728 inline tree *
2729 gimple_assign_rhs1_ptr (gimple *gs)
2731 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2732 return gimple_assign_rhs1_ptr (ass);
2735 /* Set RHS to be the first operand on the RHS of assignment statement GS. */
2737 inline void
2738 gimple_assign_set_rhs1 (gassign *gs, tree rhs)
2740 gs->op[1] = rhs;
2743 inline void
2744 gimple_assign_set_rhs1 (gimple *gs, tree rhs)
2746 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2747 gimple_assign_set_rhs1 (ass, rhs);
2751 /* Return the second operand on the RHS of assignment statement GS.
2752 If GS does not have two operands, NULL is returned instead. */
2754 inline tree
2755 gimple_assign_rhs2 (const gassign *gs)
2757 if (gimple_num_ops (gs) >= 3)
2758 return gs->op[2];
2759 else
2760 return NULL_TREE;
2763 inline tree
2764 gimple_assign_rhs2 (const gimple *gs)
2766 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2767 return gimple_assign_rhs2 (ass);
2771 /* Return a pointer to the second operand on the RHS of assignment
2772 statement GS. */
2774 inline tree *
2775 gimple_assign_rhs2_ptr (gassign *gs)
2777 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
2778 return &gs->op[2];
2781 inline tree *
2782 gimple_assign_rhs2_ptr (gimple *gs)
2784 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2785 return gimple_assign_rhs2_ptr (ass);
2789 /* Set RHS to be the second operand on the RHS of assignment statement GS. */
2791 inline void
2792 gimple_assign_set_rhs2 (gassign *gs, tree rhs)
2794 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 3);
2795 gs->op[2] = rhs;
2798 inline void
2799 gimple_assign_set_rhs2 (gimple *gs, tree rhs)
2801 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2802 return gimple_assign_set_rhs2 (ass, rhs);
2805 /* Return the third operand on the RHS of assignment statement GS.
2806 If GS does not have two operands, NULL is returned instead. */
2808 inline tree
2809 gimple_assign_rhs3 (const gassign *gs)
2811 if (gimple_num_ops (gs) >= 4)
2812 return gs->op[3];
2813 else
2814 return NULL_TREE;
2817 inline tree
2818 gimple_assign_rhs3 (const gimple *gs)
2820 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2821 return gimple_assign_rhs3 (ass);
2824 /* Return a pointer to the third operand on the RHS of assignment
2825 statement GS. */
2827 inline tree *
2828 gimple_assign_rhs3_ptr (gimple *gs)
2830 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2831 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
2832 return &ass->op[3];
2836 /* Set RHS to be the third operand on the RHS of assignment statement GS. */
2838 inline void
2839 gimple_assign_set_rhs3 (gassign *gs, tree rhs)
2841 gcc_gimple_checking_assert (gimple_num_ops (gs) >= 4);
2842 gs->op[3] = rhs;
2845 inline void
2846 gimple_assign_set_rhs3 (gimple *gs, tree rhs)
2848 gassign *ass = GIMPLE_CHECK2<gassign *> (gs);
2849 gimple_assign_set_rhs3 (ass, rhs);
2853 /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2854 which expect to see only two operands. */
2856 inline void
2857 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2858 tree op1, tree op2)
2860 gimple_assign_set_rhs_with_ops (gsi, code, op1, op2, NULL);
2863 /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2864 which expect to see only one operands. */
2866 inline void
2867 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
2868 tree op1)
2870 gimple_assign_set_rhs_with_ops (gsi, code, op1, NULL, NULL);
2873 /* Returns true if GS is a nontemporal move. */
2875 inline bool
2876 gimple_assign_nontemporal_move_p (const gassign *gs)
2878 return gs->nontemporal_move;
2881 /* Sets nontemporal move flag of GS to NONTEMPORAL. */
2883 inline void
2884 gimple_assign_set_nontemporal_move (gimple *gs, bool nontemporal)
2886 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
2887 gs->nontemporal_move = nontemporal;
2891 /* Return the code of the expression computed on the rhs of assignment
2892 statement GS. In case that the RHS is a single object, returns the
2893 tree code of the object. */
2895 inline enum tree_code
2896 gimple_assign_rhs_code (const gassign *gs)
2898 enum tree_code code = (enum tree_code) gs->subcode;
2899 /* While we initially set subcode to the TREE_CODE of the rhs for
2900 GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
2901 in sync when we rewrite stmts into SSA form or do SSA propagations. */
2902 if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
2903 code = TREE_CODE (gs->op[1]);
2905 return code;
2908 inline enum tree_code
2909 gimple_assign_rhs_code (const gimple *gs)
2911 const gassign *ass = GIMPLE_CHECK2<const gassign *> (gs);
2912 return gimple_assign_rhs_code (ass);
2916 /* Set CODE to be the code for the expression computed on the RHS of
2917 assignment S. */
2919 inline void
2920 gimple_assign_set_rhs_code (gimple *s, enum tree_code code)
2922 GIMPLE_CHECK (s, GIMPLE_ASSIGN);
2923 s->subcode = code;
2927 /* Return the gimple rhs class of the code of the expression computed on
2928 the rhs of assignment statement GS.
2929 This will never return GIMPLE_INVALID_RHS. */
2931 inline enum gimple_rhs_class
2932 gimple_assign_rhs_class (const gimple *gs)
2934 return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
2937 /* Return true if GS is an assignment with a singleton RHS, i.e.,
2938 there is no operator associated with the assignment itself.
2939 Unlike gimple_assign_copy_p, this predicate returns true for
2940 any RHS operand, including those that perform an operation
2941 and do not have the semantics of a copy, such as COND_EXPR. */
2943 inline bool
2944 gimple_assign_single_p (const gimple *gs)
2946 return (is_gimple_assign (gs)
2947 && gimple_assign_rhs_class (gs) == GIMPLE_SINGLE_RHS);
2950 /* Return true if GS performs a store to its lhs. */
2952 inline bool
2953 gimple_store_p (const gimple *gs)
2955 tree lhs = gimple_get_lhs (gs);
2956 return lhs && !is_gimple_reg (lhs);
2959 /* Return true if S is a type-cast assignment. */
2961 inline bool
2962 gimple_assign_cast_p (const gimple *s)
2964 if (is_gimple_assign (s))
2966 enum tree_code sc = gimple_assign_rhs_code (s);
2967 return CONVERT_EXPR_CODE_P (sc)
2968 || sc == VIEW_CONVERT_EXPR
2969 || sc == FIX_TRUNC_EXPR;
2972 return false;
2975 /* Return true if S is a clobber statement. */
2977 inline bool
2978 gimple_clobber_p (const gimple *s)
2980 return gimple_assign_single_p (s)
2981 && TREE_CLOBBER_P (gimple_assign_rhs1 (s));
2984 /* Return true if S is a clobber statement. */
2986 inline bool
2987 gimple_clobber_p (const gimple *s, enum clobber_kind kind)
2989 return gimple_clobber_p (s)
2990 && CLOBBER_KIND (gimple_assign_rhs1 (s)) == kind;
2993 /* Return true if GS is a GIMPLE_CALL. */
2995 inline bool
2996 is_gimple_call (const gimple *gs)
2998 return gimple_code (gs) == GIMPLE_CALL;
3001 /* Return the LHS of call statement GS. */
3003 inline tree
3004 gimple_call_lhs (const gcall *gs)
3006 return gs->op[0];
3009 inline tree
3010 gimple_call_lhs (const gimple *gs)
3012 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3013 return gimple_call_lhs (gc);
3017 /* Return a pointer to the LHS of call statement GS. */
3019 inline tree *
3020 gimple_call_lhs_ptr (gcall *gs)
3022 return &gs->op[0];
3025 inline tree *
3026 gimple_call_lhs_ptr (gimple *gs)
3028 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3029 return gimple_call_lhs_ptr (gc);
3033 /* Set LHS to be the LHS operand of call statement GS. */
3035 inline void
3036 gimple_call_set_lhs (gcall *gs, tree lhs)
3038 gs->op[0] = lhs;
3039 if (lhs && TREE_CODE (lhs) == SSA_NAME)
3040 SSA_NAME_DEF_STMT (lhs) = gs;
3043 inline void
3044 gimple_call_set_lhs (gimple *gs, tree lhs)
3046 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3047 gimple_call_set_lhs (gc, lhs);
3051 /* Return true if call GS calls an internal-only function, as enumerated
3052 by internal_fn. */
3054 inline bool
3055 gimple_call_internal_p (const gcall *gs)
3057 return (gs->subcode & GF_CALL_INTERNAL) != 0;
3060 inline bool
3061 gimple_call_internal_p (const gimple *gs)
3063 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3064 return gimple_call_internal_p (gc);
3067 /* Return true if call GS is marked as nocf_check. */
3069 inline bool
3070 gimple_call_nocf_check_p (const gcall *gs)
3072 return (gs->subcode & GF_CALL_NOCF_CHECK) != 0;
3075 /* Mark statement GS as nocf_check call. */
3077 inline void
3078 gimple_call_set_nocf_check (gcall *gs, bool nocf_check)
3080 if (nocf_check)
3081 gs->subcode |= GF_CALL_NOCF_CHECK;
3082 else
3083 gs->subcode &= ~GF_CALL_NOCF_CHECK;
3086 /* Return the target of internal call GS. */
3088 inline enum internal_fn
3089 gimple_call_internal_fn (const gcall *gs)
3091 gcc_gimple_checking_assert (gimple_call_internal_p (gs));
3092 return gs->u.internal_fn;
3095 inline enum internal_fn
3096 gimple_call_internal_fn (const gimple *gs)
3098 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3099 return gimple_call_internal_fn (gc);
3102 /* Return true, if this internal gimple call is unique. */
3104 inline bool
3105 gimple_call_internal_unique_p (const gcall *gs)
3107 return gimple_call_internal_fn (gs) == IFN_UNIQUE;
3110 inline bool
3111 gimple_call_internal_unique_p (const gimple *gs)
3113 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3114 return gimple_call_internal_unique_p (gc);
3117 /* Return true if GS is an internal function FN. */
3119 inline bool
3120 gimple_call_internal_p (const gimple *gs, internal_fn fn)
3122 return (is_gimple_call (gs)
3123 && gimple_call_internal_p (gs)
3124 && gimple_call_internal_fn (gs) == fn);
3127 /* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
3128 that could alter control flow. */
3130 inline void
3131 gimple_call_set_ctrl_altering (gcall *s, bool ctrl_altering_p)
3133 if (ctrl_altering_p)
3134 s->subcode |= GF_CALL_CTRL_ALTERING;
3135 else
3136 s->subcode &= ~GF_CALL_CTRL_ALTERING;
3139 inline void
3140 gimple_call_set_ctrl_altering (gimple *s, bool ctrl_altering_p)
3142 gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3143 gimple_call_set_ctrl_altering (gc, ctrl_altering_p);
3146 /* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
3147 flag is set. Such call could not be a stmt in the middle of a bb. */
3149 inline bool
3150 gimple_call_ctrl_altering_p (const gcall *gs)
3152 return (gs->subcode & GF_CALL_CTRL_ALTERING) != 0;
3155 inline bool
3156 gimple_call_ctrl_altering_p (const gimple *gs)
3158 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3159 return gimple_call_ctrl_altering_p (gc);
3163 /* Return the function type of the function called by GS. */
3165 inline tree
3166 gimple_call_fntype (const gcall *gs)
3168 if (gimple_call_internal_p (gs))
3169 return NULL_TREE;
3170 return gs->u.fntype;
3173 inline tree
3174 gimple_call_fntype (const gimple *gs)
3176 const gcall *call_stmt = GIMPLE_CHECK2<const gcall *> (gs);
3177 return gimple_call_fntype (call_stmt);
3180 /* Set the type of the function called by CALL_STMT to FNTYPE. */
3182 inline void
3183 gimple_call_set_fntype (gcall *call_stmt, tree fntype)
3185 gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt));
3186 call_stmt->u.fntype = fntype;
3190 /* Return the tree node representing the function called by call
3191 statement GS. */
3193 inline tree
3194 gimple_call_fn (const gcall *gs)
3196 return gs->op[1];
3199 inline tree
3200 gimple_call_fn (const gimple *gs)
3202 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3203 return gimple_call_fn (gc);
3206 /* Return a pointer to the tree node representing the function called by call
3207 statement GS. */
3209 inline tree *
3210 gimple_call_fn_ptr (gcall *gs)
3212 return &gs->op[1];
3215 inline tree *
3216 gimple_call_fn_ptr (gimple *gs)
3218 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3219 return gimple_call_fn_ptr (gc);
3223 /* Set FN to be the function called by call statement GS. */
3225 inline void
3226 gimple_call_set_fn (gcall *gs, tree fn)
3228 gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
3229 gs->op[1] = fn;
3233 /* Set FNDECL to be the function called by call statement GS. */
3235 inline void
3236 gimple_call_set_fndecl (gcall *gs, tree decl)
3238 gcc_gimple_checking_assert (!gimple_call_internal_p (gs));
3239 gs->op[1] = build1_loc (gimple_location (gs), ADDR_EXPR,
3240 build_pointer_type (TREE_TYPE (decl)), decl);
3243 inline void
3244 gimple_call_set_fndecl (gimple *gs, tree decl)
3246 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3247 gimple_call_set_fndecl (gc, decl);
3251 /* Set internal function FN to be the function called by call statement CALL_STMT. */
3253 inline void
3254 gimple_call_set_internal_fn (gcall *call_stmt, enum internal_fn fn)
3256 gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt));
3257 call_stmt->u.internal_fn = fn;
3261 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
3262 Otherwise return NULL. This function is analogous to
3263 get_callee_fndecl in tree land. */
3265 inline tree
3266 gimple_call_fndecl (const gcall *gs)
3268 return gimple_call_addr_fndecl (gimple_call_fn (gs));
3271 inline tree
3272 gimple_call_fndecl (const gimple *gs)
3274 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3275 return gimple_call_fndecl (gc);
3279 /* Return the type returned by call statement GS. */
3281 inline tree
3282 gimple_call_return_type (const gcall *gs)
3284 tree type = gimple_call_fntype (gs);
3286 if (type == NULL_TREE)
3287 return TREE_TYPE (gimple_call_lhs (gs));
3289 /* The type returned by a function is the type of its
3290 function type. */
3291 return TREE_TYPE (type);
3295 /* Return the static chain for call statement GS. */
3297 inline tree
3298 gimple_call_chain (const gcall *gs)
3300 return gs->op[2];
3303 inline tree
3304 gimple_call_chain (const gimple *gs)
3306 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3307 return gimple_call_chain (gc);
3311 /* Return a pointer to the static chain for call statement CALL_STMT. */
3313 inline tree *
3314 gimple_call_chain_ptr (gcall *call_stmt)
3316 return &call_stmt->op[2];
3319 /* Set CHAIN to be the static chain for call statement CALL_STMT. */
3321 inline void
3322 gimple_call_set_chain (gcall *call_stmt, tree chain)
3324 call_stmt->op[2] = chain;
3328 /* Return the number of arguments used by call statement GS. */
3330 inline unsigned
3331 gimple_call_num_args (const gcall *gs)
3333 return gimple_num_ops (gs) - 3;
3336 inline unsigned
3337 gimple_call_num_args (const gimple *gs)
3339 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3340 return gimple_call_num_args (gc);
3344 /* Return the argument at position INDEX for call statement GS. */
3346 inline tree
3347 gimple_call_arg (const gcall *gs, unsigned index)
3349 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3350 return gs->op[index + 3];
3353 inline tree
3354 gimple_call_arg (const gimple *gs, unsigned index)
3356 const gcall *gc = GIMPLE_CHECK2<const gcall *> (gs);
3357 return gimple_call_arg (gc, index);
3361 /* Return a pointer to the argument at position INDEX for call
3362 statement GS. */
3364 inline tree *
3365 gimple_call_arg_ptr (gcall *gs, unsigned index)
3367 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3368 return &gs->op[index + 3];
3371 inline tree *
3372 gimple_call_arg_ptr (gimple *gs, unsigned index)
3374 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3375 return gimple_call_arg_ptr (gc, index);
3379 /* Set ARG to be the argument at position INDEX for call statement GS. */
3381 inline void
3382 gimple_call_set_arg (gcall *gs, unsigned index, tree arg)
3384 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 3);
3385 gs->op[index + 3] = arg;
3388 inline void
3389 gimple_call_set_arg (gimple *gs, unsigned index, tree arg)
3391 gcall *gc = GIMPLE_CHECK2<gcall *> (gs);
3392 gimple_call_set_arg (gc, index, arg);
3396 /* If TAIL_P is true, mark call statement S as being a tail call
3397 (i.e., a call just before the exit of a function). These calls are
3398 candidate for tail call optimization. */
3400 inline void
3401 gimple_call_set_tail (gcall *s, bool tail_p)
3403 if (tail_p)
3404 s->subcode |= GF_CALL_TAILCALL;
3405 else
3406 s->subcode &= ~GF_CALL_TAILCALL;
3410 /* Return true if GIMPLE_CALL S is marked as a tail call. */
3412 inline bool
3413 gimple_call_tail_p (const gcall *s)
3415 return (s->subcode & GF_CALL_TAILCALL) != 0;
3418 /* Mark (or clear) call statement S as requiring tail call optimization. */
3420 inline void
3421 gimple_call_set_must_tail (gcall *s, bool must_tail_p)
3423 if (must_tail_p)
3424 s->subcode |= GF_CALL_MUST_TAIL_CALL;
3425 else
3426 s->subcode &= ~GF_CALL_MUST_TAIL_CALL;
3429 /* Return true if call statement has been marked as requiring
3430 tail call optimization. */
3432 inline bool
3433 gimple_call_must_tail_p (const gcall *s)
3435 return (s->subcode & GF_CALL_MUST_TAIL_CALL) != 0;
3438 /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
3439 slot optimization. This transformation uses the target of the call
3440 expansion as the return slot for calls that return in memory. */
3442 inline void
3443 gimple_call_set_return_slot_opt (gcall *s, bool return_slot_opt_p)
3445 if (return_slot_opt_p)
3446 s->subcode |= GF_CALL_RETURN_SLOT_OPT;
3447 else
3448 s->subcode &= ~GF_CALL_RETURN_SLOT_OPT;
3452 /* Return true if S is marked for return slot optimization. */
3454 inline bool
3455 gimple_call_return_slot_opt_p (const gcall *s)
3457 return (s->subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
3461 /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
3462 thunk to the thunked-to function. */
3464 inline void
3465 gimple_call_set_from_thunk (gcall *s, bool from_thunk_p)
3467 if (from_thunk_p)
3468 s->subcode |= GF_CALL_FROM_THUNK;
3469 else
3470 s->subcode &= ~GF_CALL_FROM_THUNK;
3474 /* Return true if GIMPLE_CALL S is a jump from a thunk. */
3476 inline bool
3477 gimple_call_from_thunk_p (gcall *s)
3479 return (s->subcode & GF_CALL_FROM_THUNK) != 0;
3483 /* If FROM_NEW_OR_DELETE_P is true, mark GIMPLE_CALL S as being a call
3484 to operator new or delete created from a new or delete expression. */
3486 inline void
3487 gimple_call_set_from_new_or_delete (gcall *s, bool from_new_or_delete_p)
3489 if (from_new_or_delete_p)
3490 s->subcode |= GF_CALL_FROM_NEW_OR_DELETE;
3491 else
3492 s->subcode &= ~GF_CALL_FROM_NEW_OR_DELETE;
3496 /* Return true if GIMPLE_CALL S is a call to operator new or delete from
3497 from a new or delete expression. */
3499 inline bool
3500 gimple_call_from_new_or_delete (const gcall *s)
3502 return (s->subcode & GF_CALL_FROM_NEW_OR_DELETE) != 0;
3506 /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
3507 argument pack in its argument list. */
3509 inline void
3510 gimple_call_set_va_arg_pack (gcall *s, bool pass_arg_pack_p)
3512 if (pass_arg_pack_p)
3513 s->subcode |= GF_CALL_VA_ARG_PACK;
3514 else
3515 s->subcode &= ~GF_CALL_VA_ARG_PACK;
3519 /* Return true if GIMPLE_CALL S is a stdarg call that needs the
3520 argument pack in its argument list. */
3522 inline bool
3523 gimple_call_va_arg_pack_p (const gcall *s)
3525 return (s->subcode & GF_CALL_VA_ARG_PACK) != 0;
3529 /* Return true if S is a noreturn call. */
3531 inline bool
3532 gimple_call_noreturn_p (const gcall *s)
3534 return (gimple_call_flags (s) & ECF_NORETURN) != 0;
3537 inline bool
3538 gimple_call_noreturn_p (const gimple *s)
3540 const gcall *gc = GIMPLE_CHECK2<const gcall *> (s);
3541 return gimple_call_noreturn_p (gc);
3545 /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
3546 even if the called function can throw in other cases. */
3548 inline void
3549 gimple_call_set_nothrow (gcall *s, bool nothrow_p)
3551 if (nothrow_p)
3552 s->subcode |= GF_CALL_NOTHROW;
3553 else
3554 s->subcode &= ~GF_CALL_NOTHROW;
3557 /* Return true if S is a nothrow call. */
3559 inline bool
3560 gimple_call_nothrow_p (gcall *s)
3562 return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
3565 /* If EXPECTED_THROW_P is true, GIMPLE_CALL S is a call that is known
3566 to be more likely to throw than to run forever, terminate the
3567 program or return by other means. */
3569 static inline void
3570 gimple_call_set_expected_throw (gcall *s, bool expected_throw_p)
3572 if (expected_throw_p)
3573 s->subcode |= GF_CALL_XTHROW;
3574 else
3575 s->subcode &= ~GF_CALL_XTHROW;
3578 /* Return true if S is a call that is more likely to end by
3579 propagating an exception than by other means. */
3581 static inline bool
3582 gimple_call_expected_throw_p (gcall *s)
3584 return (gimple_call_flags (s) & ECF_XTHROW) != 0;
3587 /* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
3588 is known to be emitted for VLA objects. Those are wrapped by
3589 stack_save/stack_restore calls and hence can't lead to unbounded
3590 stack growth even when they occur in loops. */
3592 inline void
3593 gimple_call_set_alloca_for_var (gcall *s, bool for_var)
3595 if (for_var)
3596 s->subcode |= GF_CALL_ALLOCA_FOR_VAR;
3597 else
3598 s->subcode &= ~GF_CALL_ALLOCA_FOR_VAR;
3601 /* Return true of S is a call to builtin_alloca emitted for VLA objects. */
3603 inline bool
3604 gimple_call_alloca_for_var_p (gcall *s)
3606 return (s->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3609 inline bool
3610 gimple_call_alloca_for_var_p (gimple *s)
3612 const gcall *gc = GIMPLE_CHECK2<gcall *> (s);
3613 return (gc->subcode & GF_CALL_ALLOCA_FOR_VAR) != 0;
3616 /* If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
3617 pointers to nested function are descriptors instead of trampolines. */
3619 inline void
3620 gimple_call_set_by_descriptor (gcall *s, bool by_descriptor_p)
3622 if (by_descriptor_p)
3623 s->subcode |= GF_CALL_BY_DESCRIPTOR;
3624 else
3625 s->subcode &= ~GF_CALL_BY_DESCRIPTOR;
3628 /* Return true if S is a by-descriptor call. */
3630 inline bool
3631 gimple_call_by_descriptor_p (gcall *s)
3633 return (s->subcode & GF_CALL_BY_DESCRIPTOR) != 0;
3636 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
3638 inline void
3639 gimple_call_copy_flags (gcall *dest_call, gcall *orig_call)
3641 dest_call->subcode = orig_call->subcode;
3645 /* Return a pointer to the points-to solution for the set of call-used
3646 variables of the call CALL_STMT. */
3648 inline struct pt_solution *
3649 gimple_call_use_set (gcall *call_stmt)
3651 return &call_stmt->call_used;
3654 /* As above, but const. */
3656 inline const pt_solution *
3657 gimple_call_use_set (const gcall *call_stmt)
3659 return &call_stmt->call_used;
3662 /* Return a pointer to the points-to solution for the set of call-used
3663 variables of the call CALL_STMT. */
3665 inline struct pt_solution *
3666 gimple_call_clobber_set (gcall *call_stmt)
3668 return &call_stmt->call_clobbered;
3671 /* As above, but const. */
3673 inline const pt_solution *
3674 gimple_call_clobber_set (const gcall *call_stmt)
3676 return &call_stmt->call_clobbered;
3680 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
3681 non-NULL lhs. */
3683 inline bool
3684 gimple_has_lhs (const gimple *stmt)
3686 if (is_gimple_assign (stmt))
3687 return true;
3688 if (const gcall *call = dyn_cast <const gcall *> (stmt))
3689 return gimple_call_lhs (call) != NULL_TREE;
3690 return false;
3694 /* Return the code of the predicate computed by conditional statement GS. */
3696 inline enum tree_code
3697 gimple_cond_code (const gcond *gs)
3699 return (enum tree_code) gs->subcode;
3702 inline enum tree_code
3703 gimple_cond_code (const gimple *gs)
3705 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3706 return gimple_cond_code (gc);
3710 /* Set CODE to be the predicate code for the conditional statement GS. */
3712 inline void
3713 gimple_cond_set_code (gcond *gs, enum tree_code code)
3715 gs->subcode = code;
3719 /* Return the LHS of the predicate computed by conditional statement GS. */
3721 inline tree
3722 gimple_cond_lhs (const gcond *gs)
3724 return gs->op[0];
3727 inline tree
3728 gimple_cond_lhs (const gimple *gs)
3730 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3731 return gimple_cond_lhs (gc);
3734 /* Return the pointer to the LHS of the predicate computed by conditional
3735 statement GS. */
3737 inline tree *
3738 gimple_cond_lhs_ptr (gcond *gs)
3740 return &gs->op[0];
3743 /* Set LHS to be the LHS operand of the predicate computed by
3744 conditional statement GS. */
3746 inline void
3747 gimple_cond_set_lhs (gcond *gs, tree lhs)
3749 gs->op[0] = lhs;
3753 /* Return the RHS operand of the predicate computed by conditional GS. */
3755 inline tree
3756 gimple_cond_rhs (const gcond *gs)
3758 return gs->op[1];
3761 inline tree
3762 gimple_cond_rhs (const gimple *gs)
3764 const gcond *gc = GIMPLE_CHECK2<const gcond *> (gs);
3765 return gimple_cond_rhs (gc);
3768 /* Return the pointer to the RHS operand of the predicate computed by
3769 conditional GS. */
3771 inline tree *
3772 gimple_cond_rhs_ptr (gcond *gs)
3774 return &gs->op[1];
3778 /* Set RHS to be the RHS operand of the predicate computed by
3779 conditional statement GS. */
3781 inline void
3782 gimple_cond_set_rhs (gcond *gs, tree rhs)
3784 gs->op[1] = rhs;
3788 /* Return the label used by conditional statement GS when its
3789 predicate evaluates to true. */
3791 inline tree
3792 gimple_cond_true_label (const gcond *gs)
3794 return gs->op[2];
3798 /* Set LABEL to be the label used by conditional statement GS when its
3799 predicate evaluates to true. */
3801 inline void
3802 gimple_cond_set_true_label (gcond *gs, tree label)
3804 gs->op[2] = label;
3808 /* Set LABEL to be the label used by conditional statement GS when its
3809 predicate evaluates to false. */
3811 inline void
3812 gimple_cond_set_false_label (gcond *gs, tree label)
3814 gs->op[3] = label;
3818 /* Return the label used by conditional statement GS when its
3819 predicate evaluates to false. */
3821 inline tree
3822 gimple_cond_false_label (const gcond *gs)
3824 return gs->op[3];
3828 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */
3830 inline void
3831 gimple_cond_make_false (gcond *gs)
3833 gimple_cond_set_lhs (gs, boolean_false_node);
3834 gimple_cond_set_rhs (gs, boolean_false_node);
3835 gs->subcode = NE_EXPR;
3839 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */
3841 inline void
3842 gimple_cond_make_true (gcond *gs)
3844 gimple_cond_set_lhs (gs, boolean_true_node);
3845 gimple_cond_set_rhs (gs, boolean_false_node);
3846 gs->subcode = NE_EXPR;
3849 /* Check if conditional statemente GS is of the form 'if (1 == 1)',
3850 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
3852 inline bool
3853 gimple_cond_true_p (const gcond *gs)
3855 tree lhs = gimple_cond_lhs (gs);
3856 tree rhs = gimple_cond_rhs (gs);
3857 enum tree_code code = gimple_cond_code (gs);
3859 if (lhs != boolean_true_node && lhs != boolean_false_node)
3860 return false;
3862 if (rhs != boolean_true_node && rhs != boolean_false_node)
3863 return false;
3865 if (code == NE_EXPR && lhs != rhs)
3866 return true;
3868 if (code == EQ_EXPR && lhs == rhs)
3869 return true;
3871 return false;
3874 /* Check if conditional statement GS is of the form 'if (1 != 1)',
3875 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
3877 inline bool
3878 gimple_cond_false_p (const gcond *gs)
3880 tree lhs = gimple_cond_lhs (gs);
3881 tree rhs = gimple_cond_rhs (gs);
3882 enum tree_code code = gimple_cond_code (gs);
3884 if (lhs != boolean_true_node && lhs != boolean_false_node)
3885 return false;
3887 if (rhs != boolean_true_node && rhs != boolean_false_node)
3888 return false;
3890 if (code == NE_EXPR && lhs == rhs)
3891 return true;
3893 if (code == EQ_EXPR && lhs != rhs)
3894 return true;
3896 return false;
3899 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
3901 inline void
3902 gimple_cond_set_condition (gcond *stmt, enum tree_code code, tree lhs,
3903 tree rhs)
3905 gimple_cond_set_code (stmt, code);
3906 gimple_cond_set_lhs (stmt, lhs);
3907 gimple_cond_set_rhs (stmt, rhs);
3911 /* Return the tree code for the expression computed by STMT. This is
3912 only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
3913 GIMPLE_CALL, return CALL_EXPR as the expression code for
3914 consistency. This is useful when the caller needs to deal with the
3915 three kinds of computation that GIMPLE supports. */
3917 inline enum tree_code
3918 gimple_expr_code (const gimple *stmt)
3920 if (const gassign *ass = dyn_cast<const gassign *> (stmt))
3921 return gimple_assign_rhs_code (ass);
3922 if (const gcond *cond = dyn_cast<const gcond *> (stmt))
3923 return gimple_cond_code (cond);
3924 else
3926 gcc_gimple_checking_assert (gimple_code (stmt) == GIMPLE_CALL);
3927 return CALL_EXPR;
3932 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
3934 inline tree
3935 gimple_label_label (const glabel *gs)
3937 return gs->op[0];
3941 /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
3942 GS. */
3944 inline void
3945 gimple_label_set_label (glabel *gs, tree label)
3947 gs->op[0] = label;
3951 /* Return the destination of the unconditional jump GS. */
3953 inline tree
3954 gimple_goto_dest (const gimple *gs)
3956 GIMPLE_CHECK (gs, GIMPLE_GOTO);
3957 return gimple_op (gs, 0);
3961 /* Set DEST to be the destination of the unconditonal jump GS. */
3963 inline void
3964 gimple_goto_set_dest (ggoto *gs, tree dest)
3966 gs->op[0] = dest;
3970 /* Return the variables declared in the GIMPLE_BIND statement GS. */
3972 inline tree
3973 gimple_bind_vars (const gbind *bind_stmt)
3975 return bind_stmt->vars;
3979 /* Set VARS to be the set of variables declared in the GIMPLE_BIND
3980 statement GS. */
3982 inline void
3983 gimple_bind_set_vars (gbind *bind_stmt, tree vars)
3985 bind_stmt->vars = vars;
3989 /* Append VARS to the set of variables declared in the GIMPLE_BIND
3990 statement GS. */
3992 inline void
3993 gimple_bind_append_vars (gbind *bind_stmt, tree vars)
3995 bind_stmt->vars = chainon (bind_stmt->vars, vars);
3999 inline gimple_seq *
4000 gimple_bind_body_ptr (gbind *bind_stmt)
4002 return &bind_stmt->body;
4005 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
4007 inline gimple_seq
4008 gimple_bind_body (const gbind *gs)
4010 return *gimple_bind_body_ptr (const_cast <gbind *> (gs));
4014 /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
4015 statement GS. */
4017 inline void
4018 gimple_bind_set_body (gbind *bind_stmt, gimple_seq seq)
4020 bind_stmt->body = seq;
4024 /* Append a statement to the end of a GIMPLE_BIND's body. */
4026 inline void
4027 gimple_bind_add_stmt (gbind *bind_stmt, gimple *stmt)
4029 gimple_seq_add_stmt (&bind_stmt->body, stmt);
4033 /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
4035 inline void
4036 gimple_bind_add_seq (gbind *bind_stmt, gimple_seq seq)
4038 gimple_seq_add_seq (&bind_stmt->body, seq);
4042 /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
4043 GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
4045 inline tree
4046 gimple_bind_block (const gbind *bind_stmt)
4048 return bind_stmt->block;
4052 /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
4053 statement GS. */
4055 inline void
4056 gimple_bind_set_block (gbind *bind_stmt, tree block)
4058 gcc_gimple_checking_assert (block == NULL_TREE
4059 || TREE_CODE (block) == BLOCK);
4060 bind_stmt->block = block;
4064 /* Return the number of input operands for GIMPLE_ASM ASM_STMT. */
4066 inline unsigned
4067 gimple_asm_ninputs (const gasm *asm_stmt)
4069 return asm_stmt->ni;
4073 /* Return the number of output operands for GIMPLE_ASM ASM_STMT. */
4075 inline unsigned
4076 gimple_asm_noutputs (const gasm *asm_stmt)
4078 return asm_stmt->no;
4082 /* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */
4084 inline unsigned
4085 gimple_asm_nclobbers (const gasm *asm_stmt)
4087 return asm_stmt->nc;
4090 /* Return the number of label operands for GIMPLE_ASM ASM_STMT. */
4092 inline unsigned
4093 gimple_asm_nlabels (const gasm *asm_stmt)
4095 return asm_stmt->nl;
4098 /* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */
4100 inline tree
4101 gimple_asm_input_op (const gasm *asm_stmt, unsigned index)
4103 gcc_gimple_checking_assert (index < asm_stmt->ni);
4104 return asm_stmt->op[index + asm_stmt->no];
4107 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */
4109 inline void
4110 gimple_asm_set_input_op (gasm *asm_stmt, unsigned index, tree in_op)
4112 gcc_gimple_checking_assert (index < asm_stmt->ni
4113 && TREE_CODE (in_op) == TREE_LIST);
4114 asm_stmt->op[index + asm_stmt->no] = in_op;
4118 /* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */
4120 inline tree
4121 gimple_asm_output_op (const gasm *asm_stmt, unsigned index)
4123 gcc_gimple_checking_assert (index < asm_stmt->no);
4124 return asm_stmt->op[index];
4127 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */
4129 inline void
4130 gimple_asm_set_output_op (gasm *asm_stmt, unsigned index, tree out_op)
4132 gcc_gimple_checking_assert (index < asm_stmt->no
4133 && TREE_CODE (out_op) == TREE_LIST);
4134 asm_stmt->op[index] = out_op;
4138 /* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */
4140 inline tree
4141 gimple_asm_clobber_op (const gasm *asm_stmt, unsigned index)
4143 gcc_gimple_checking_assert (index < asm_stmt->nc);
4144 return asm_stmt->op[index + asm_stmt->ni + asm_stmt->no];
4148 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */
4150 inline void
4151 gimple_asm_set_clobber_op (gasm *asm_stmt, unsigned index, tree clobber_op)
4153 gcc_gimple_checking_assert (index < asm_stmt->nc
4154 && TREE_CODE (clobber_op) == TREE_LIST);
4155 asm_stmt->op[index + asm_stmt->ni + asm_stmt->no] = clobber_op;
4158 /* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */
4160 inline tree
4161 gimple_asm_label_op (const gasm *asm_stmt, unsigned index)
4163 gcc_gimple_checking_assert (index < asm_stmt->nl);
4164 return asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc];
4167 /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */
4169 inline void
4170 gimple_asm_set_label_op (gasm *asm_stmt, unsigned index, tree label_op)
4172 gcc_gimple_checking_assert (index < asm_stmt->nl
4173 && TREE_CODE (label_op) == TREE_LIST);
4174 asm_stmt->op[index + asm_stmt->no + asm_stmt->ni + asm_stmt->nc] = label_op;
4177 /* Return the string representing the assembly instruction in
4178 GIMPLE_ASM ASM_STMT. */
4180 inline const char *
4181 gimple_asm_string (const gasm *asm_stmt)
4183 return asm_stmt->string;
4187 /* Return true if ASM_STMT is marked volatile. */
4189 inline bool
4190 gimple_asm_volatile_p (const gasm *asm_stmt)
4192 return (asm_stmt->subcode & GF_ASM_VOLATILE) != 0;
4196 /* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile. */
4198 inline void
4199 gimple_asm_set_volatile (gasm *asm_stmt, bool volatile_p)
4201 if (volatile_p)
4202 asm_stmt->subcode |= GF_ASM_VOLATILE;
4203 else
4204 asm_stmt->subcode &= ~GF_ASM_VOLATILE;
4208 /* Return true if ASM_STMT is marked inline. */
4210 inline bool
4211 gimple_asm_inline_p (const gasm *asm_stmt)
4213 return (asm_stmt->subcode & GF_ASM_INLINE) != 0;
4217 /* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
4219 inline void
4220 gimple_asm_set_inline (gasm *asm_stmt, bool inline_p)
4222 if (inline_p)
4223 asm_stmt->subcode |= GF_ASM_INLINE;
4224 else
4225 asm_stmt->subcode &= ~GF_ASM_INLINE;
4229 /* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT. */
4231 inline void
4232 gimple_asm_set_input (gasm *asm_stmt, bool input_p)
4234 if (input_p)
4235 asm_stmt->subcode |= GF_ASM_INPUT;
4236 else
4237 asm_stmt->subcode &= ~GF_ASM_INPUT;
4241 /* Return true if asm ASM_STMT is an ASM_INPUT. */
4243 inline bool
4244 gimple_asm_input_p (const gasm *asm_stmt)
4246 return (asm_stmt->subcode & GF_ASM_INPUT) != 0;
4250 /* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4252 inline tree
4253 gimple_catch_types (const gcatch *catch_stmt)
4255 return catch_stmt->types;
4259 /* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4261 inline tree *
4262 gimple_catch_types_ptr (gcatch *catch_stmt)
4264 return &catch_stmt->types;
4268 /* Return a pointer to the GIMPLE sequence representing the body of
4269 the handler of GIMPLE_CATCH statement CATCH_STMT. */
4271 inline gimple_seq *
4272 gimple_catch_handler_ptr (gcatch *catch_stmt)
4274 return &catch_stmt->handler;
4278 /* Return the GIMPLE sequence representing the body of the handler of
4279 GIMPLE_CATCH statement CATCH_STMT. */
4281 inline gimple_seq
4282 gimple_catch_handler (const gcatch *catch_stmt)
4284 return *gimple_catch_handler_ptr (const_cast <gcatch *> (catch_stmt));
4288 /* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT. */
4290 inline void
4291 gimple_catch_set_types (gcatch *catch_stmt, tree t)
4293 catch_stmt->types = t;
4297 /* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */
4299 inline void
4300 gimple_catch_set_handler (gcatch *catch_stmt, gimple_seq handler)
4302 catch_stmt->handler = handler;
4306 /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
4308 inline tree
4309 gimple_eh_filter_types (const gimple *gs)
4311 const geh_filter *eh_filter_stmt = as_a <const geh_filter *> (gs);
4312 return eh_filter_stmt->types;
4316 /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
4317 GS. */
4319 inline tree *
4320 gimple_eh_filter_types_ptr (gimple *gs)
4322 geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4323 return &eh_filter_stmt->types;
4327 /* Return a pointer to the sequence of statement to execute when
4328 GIMPLE_EH_FILTER statement fails. */
4330 inline gimple_seq *
4331 gimple_eh_filter_failure_ptr (gimple *gs)
4333 geh_filter *eh_filter_stmt = as_a <geh_filter *> (gs);
4334 return &eh_filter_stmt->failure;
4338 /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
4339 statement fails. */
4341 inline gimple_seq
4342 gimple_eh_filter_failure (const gimple *gs)
4344 return *gimple_eh_filter_failure_ptr (const_cast <gimple *> (gs));
4348 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
4349 EH_FILTER_STMT. */
4351 inline void
4352 gimple_eh_filter_set_types (geh_filter *eh_filter_stmt, tree types)
4354 eh_filter_stmt->types = types;
4358 /* Set FAILURE to be the sequence of statements to execute on failure
4359 for GIMPLE_EH_FILTER EH_FILTER_STMT. */
4361 inline void
4362 gimple_eh_filter_set_failure (geh_filter *eh_filter_stmt,
4363 gimple_seq failure)
4365 eh_filter_stmt->failure = failure;
4368 /* Get the function decl to be called by the MUST_NOT_THROW region. */
4370 inline tree
4371 gimple_eh_must_not_throw_fndecl (const geh_mnt *eh_mnt_stmt)
4373 return eh_mnt_stmt->fndecl;
4376 /* Set the function decl to be called by GS to DECL. */
4378 inline void
4379 gimple_eh_must_not_throw_set_fndecl (geh_mnt *eh_mnt_stmt,
4380 tree decl)
4382 eh_mnt_stmt->fndecl = decl;
4385 /* GIMPLE_EH_ELSE accessors. */
4387 inline gimple_seq *
4388 gimple_eh_else_n_body_ptr (geh_else *eh_else_stmt)
4390 return &eh_else_stmt->n_body;
4393 inline gimple_seq
4394 gimple_eh_else_n_body (const geh_else *eh_else_stmt)
4396 return *gimple_eh_else_n_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4399 inline gimple_seq *
4400 gimple_eh_else_e_body_ptr (geh_else *eh_else_stmt)
4402 return &eh_else_stmt->e_body;
4405 inline gimple_seq
4406 gimple_eh_else_e_body (const geh_else *eh_else_stmt)
4408 return *gimple_eh_else_e_body_ptr (const_cast <geh_else *> (eh_else_stmt));
4411 inline void
4412 gimple_eh_else_set_n_body (geh_else *eh_else_stmt, gimple_seq seq)
4414 eh_else_stmt->n_body = seq;
4417 inline void
4418 gimple_eh_else_set_e_body (geh_else *eh_else_stmt, gimple_seq seq)
4420 eh_else_stmt->e_body = seq;
4423 /* GIMPLE_TRY accessors. */
4425 /* Return the kind of try block represented by GIMPLE_TRY GS. This is
4426 either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
4428 inline enum gimple_try_flags
4429 gimple_try_kind (const gimple *gs)
4431 GIMPLE_CHECK (gs, GIMPLE_TRY);
4432 return (enum gimple_try_flags) (gs->subcode & GIMPLE_TRY_KIND);
4436 /* Set the kind of try block represented by GIMPLE_TRY GS. */
4438 inline void
4439 gimple_try_set_kind (gtry *gs, enum gimple_try_flags kind)
4441 gcc_gimple_checking_assert (kind == GIMPLE_TRY_CATCH
4442 || kind == GIMPLE_TRY_FINALLY);
4443 if (gimple_try_kind (gs) != kind)
4444 gs->subcode = (unsigned int) kind;
4448 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4450 inline bool
4451 gimple_try_catch_is_cleanup (const gimple *gs)
4453 gcc_gimple_checking_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
4454 return (gs->subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
4458 /* Return a pointer to the sequence of statements used as the
4459 body for GIMPLE_TRY GS. */
4461 inline gimple_seq *
4462 gimple_try_eval_ptr (gimple *gs)
4464 gtry *try_stmt = as_a <gtry *> (gs);
4465 return &try_stmt->eval;
4469 /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
4471 inline gimple_seq
4472 gimple_try_eval (const gimple *gs)
4474 return *gimple_try_eval_ptr (const_cast <gimple *> (gs));
4478 /* Return a pointer to the sequence of statements used as the cleanup body for
4479 GIMPLE_TRY GS. */
4481 inline gimple_seq *
4482 gimple_try_cleanup_ptr (gimple *gs)
4484 gtry *try_stmt = as_a <gtry *> (gs);
4485 return &try_stmt->cleanup;
4489 /* Return the sequence of statements used as the cleanup body for
4490 GIMPLE_TRY GS. */
4492 inline gimple_seq
4493 gimple_try_cleanup (const gimple *gs)
4495 return *gimple_try_cleanup_ptr (const_cast <gimple *> (gs));
4499 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4501 inline void
4502 gimple_try_set_catch_is_cleanup (gtry *g, bool catch_is_cleanup)
4504 gcc_gimple_checking_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
4505 if (catch_is_cleanup)
4506 g->subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
4507 else
4508 g->subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
4512 /* Set EVAL to be the sequence of statements to use as the body for
4513 GIMPLE_TRY TRY_STMT. */
4515 inline void
4516 gimple_try_set_eval (gtry *try_stmt, gimple_seq eval)
4518 try_stmt->eval = eval;
4522 /* Set CLEANUP to be the sequence of statements to use as the cleanup
4523 body for GIMPLE_TRY TRY_STMT. */
4525 inline void
4526 gimple_try_set_cleanup (gtry *try_stmt, gimple_seq cleanup)
4528 try_stmt->cleanup = cleanup;
4532 /* Return a pointer to the cleanup sequence for cleanup statement GS. */
4534 inline gimple_seq *
4535 gimple_wce_cleanup_ptr (gimple *gs)
4537 gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
4538 return &wce_stmt->cleanup;
4542 /* Return the cleanup sequence for cleanup statement GS. */
4544 inline gimple_seq
4545 gimple_wce_cleanup (gimple *gs)
4547 return *gimple_wce_cleanup_ptr (gs);
4551 /* Set CLEANUP to be the cleanup sequence for GS. */
4553 inline void
4554 gimple_wce_set_cleanup (gimple *gs, gimple_seq cleanup)
4556 gimple_statement_wce *wce_stmt = as_a <gimple_statement_wce *> (gs);
4557 wce_stmt->cleanup = cleanup;
4561 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
4563 inline bool
4564 gimple_wce_cleanup_eh_only (const gimple *gs)
4566 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4567 return gs->subcode != 0;
4571 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
4573 inline void
4574 gimple_wce_set_cleanup_eh_only (gimple *gs, bool eh_only_p)
4576 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
4577 gs->subcode = (unsigned int) eh_only_p;
4581 /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
4583 inline unsigned
4584 gimple_phi_capacity (const gimple *gs)
4586 const gphi *phi_stmt = as_a <const gphi *> (gs);
4587 return phi_stmt->capacity;
4591 /* Return the number of arguments in GIMPLE_PHI GS. This must always
4592 be exactly the number of incoming edges for the basic block holding
4593 GS. */
4595 inline unsigned
4596 gimple_phi_num_args (const gimple *gs)
4598 const gphi *phi_stmt = as_a <const gphi *> (gs);
4599 return phi_stmt->nargs;
4603 /* Return the SSA name created by GIMPLE_PHI GS. */
4605 inline tree
4606 gimple_phi_result (const gphi *gs)
4608 return gs->result;
4611 inline tree
4612 gimple_phi_result (const gimple *gs)
4614 const gphi *phi_stmt = as_a <const gphi *> (gs);
4615 return gimple_phi_result (phi_stmt);
4618 /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
4620 inline tree *
4621 gimple_phi_result_ptr (gphi *gs)
4623 return &gs->result;
4626 inline tree *
4627 gimple_phi_result_ptr (gimple *gs)
4629 gphi *phi_stmt = as_a <gphi *> (gs);
4630 return gimple_phi_result_ptr (phi_stmt);
4633 /* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */
4635 inline void
4636 gimple_phi_set_result (gphi *phi, tree result)
4638 phi->result = result;
4639 if (result && TREE_CODE (result) == SSA_NAME)
4640 SSA_NAME_DEF_STMT (result) = phi;
4644 /* Return the PHI argument corresponding to incoming edge INDEX for
4645 GIMPLE_PHI GS. */
4647 inline struct phi_arg_d *
4648 gimple_phi_arg (gphi *gs, unsigned index)
4650 gcc_gimple_checking_assert (index < gs->nargs);
4651 return &(gs->args[index]);
4654 inline const phi_arg_d *
4655 gimple_phi_arg (const gphi *gs, unsigned index)
4657 gcc_gimple_checking_assert (index < gs->nargs);
4658 return &(gs->args[index]);
4661 inline const phi_arg_d *
4662 gimple_phi_arg (const gimple *gs, unsigned index)
4664 const gphi *phi_stmt = as_a <const gphi *> (gs);
4665 return gimple_phi_arg (phi_stmt, index);
4668 inline struct phi_arg_d *
4669 gimple_phi_arg (gimple *gs, unsigned index)
4671 gphi *phi_stmt = as_a <gphi *> (gs);
4672 return gimple_phi_arg (phi_stmt, index);
4675 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
4676 for GIMPLE_PHI PHI. */
4678 inline void
4679 gimple_phi_set_arg (gphi *phi, unsigned index, struct phi_arg_d * phiarg)
4681 gcc_gimple_checking_assert (index < phi->nargs);
4682 phi->args[index] = *phiarg;
4685 /* Return the PHI nodes for basic block BB, or NULL if there are no
4686 PHI nodes. */
4688 inline gimple_seq
4689 phi_nodes (const_basic_block bb)
4691 gcc_checking_assert (!(bb->flags & BB_RTL));
4692 return bb->il.gimple.phi_nodes;
4695 /* Return a pointer to the PHI nodes for basic block BB. */
4697 inline gimple_seq *
4698 phi_nodes_ptr (basic_block bb)
4700 gcc_checking_assert (!(bb->flags & BB_RTL));
4701 return &bb->il.gimple.phi_nodes;
4704 /* Return the tree operand for argument I of PHI node GS. */
4706 inline tree
4707 gimple_phi_arg_def (const gphi *gs, size_t index)
4709 return gimple_phi_arg (gs, index)->def;
4712 inline tree
4713 gimple_phi_arg_def (const gimple *gs, size_t index)
4715 return gimple_phi_arg (gs, index)->def;
4718 /* Return the tree operand for the argument associated with
4719 edge E of PHI node GS. */
4721 inline tree
4722 gimple_phi_arg_def_from_edge (const gphi *gs, const_edge e)
4724 gcc_checking_assert (e->dest == gimple_bb (gs));
4725 return gimple_phi_arg (gs, e->dest_idx)->def;
4728 inline tree
4729 gimple_phi_arg_def_from_edge (const gimple *gs, const_edge e)
4731 gcc_checking_assert (e->dest == gimple_bb (gs));
4732 return gimple_phi_arg (gs, e->dest_idx)->def;
4735 /* Return a pointer to the tree operand for argument I of phi node PHI. */
4737 inline tree *
4738 gimple_phi_arg_def_ptr (gphi *phi, size_t index)
4740 return &gimple_phi_arg (phi, index)->def;
4743 /* Return the edge associated with argument I of phi node PHI. */
4745 inline edge
4746 gimple_phi_arg_edge (const gphi *phi, size_t i)
4748 return EDGE_PRED (gimple_bb (phi), i);
4751 /* Return the source location of gimple argument I of phi node PHI. */
4753 inline location_t
4754 gimple_phi_arg_location (const gphi *phi, size_t i)
4756 return gimple_phi_arg (phi, i)->locus;
4759 /* Return the source location of the argument on edge E of phi node PHI. */
4761 inline location_t
4762 gimple_phi_arg_location_from_edge (gphi *phi, edge e)
4764 return gimple_phi_arg (phi, e->dest_idx)->locus;
4767 /* Set the source location of gimple argument I of phi node PHI to LOC. */
4769 inline void
4770 gimple_phi_arg_set_location (gphi *phi, size_t i, location_t loc)
4772 gimple_phi_arg (phi, i)->locus = loc;
4775 /* Return address of source location of gimple argument I of phi node PHI. */
4777 inline location_t *
4778 gimple_phi_arg_location_ptr (gphi *phi, size_t i)
4780 return &gimple_phi_arg (phi, i)->locus;
4783 /* Return TRUE if argument I of phi node PHI has a location record. */
4785 inline bool
4786 gimple_phi_arg_has_location (const gphi *phi, size_t i)
4788 return gimple_phi_arg_location (phi, i) != UNKNOWN_LOCATION;
4791 /* Return the number of arguments that can be accessed by gimple_arg. */
4793 inline unsigned
4794 gimple_num_args (const gimple *gs)
4796 if (auto phi = dyn_cast<const gphi *> (gs))
4797 return gimple_phi_num_args (phi);
4798 if (auto call = dyn_cast<const gcall *> (gs))
4799 return gimple_call_num_args (call);
4800 return gimple_num_ops (as_a <const gassign *> (gs)) - 1;
4803 /* GS must be an assignment, a call, or a PHI.
4804 If it's an assignment, return rhs operand I.
4805 If it's a call, return function argument I.
4806 If it's a PHI, return the value of PHI argument I. */
4808 inline tree
4809 gimple_arg (const gimple *gs, unsigned int i)
4811 if (auto phi = dyn_cast<const gphi *> (gs))
4812 return gimple_phi_arg_def (phi, i);
4813 if (auto call = dyn_cast<const gcall *> (gs))
4814 return gimple_call_arg (call, i);
4815 return gimple_op (as_a <const gassign *> (gs), i + 1);
4818 /* Return a pointer to gimple_arg (GS, I). */
4820 inline tree *
4821 gimple_arg_ptr (gimple *gs, unsigned int i)
4823 if (auto phi = dyn_cast<gphi *> (gs))
4824 return gimple_phi_arg_def_ptr (phi, i);
4825 if (auto call = dyn_cast<gcall *> (gs))
4826 return gimple_call_arg_ptr (call, i);
4827 return gimple_op_ptr (as_a <gassign *> (gs), i + 1);
4830 /* Return the region number for GIMPLE_RESX RESX_STMT. */
4832 inline int
4833 gimple_resx_region (const gresx *resx_stmt)
4835 return resx_stmt->region;
4838 /* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */
4840 inline void
4841 gimple_resx_set_region (gresx *resx_stmt, int region)
4843 resx_stmt->region = region;
4846 /* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */
4848 inline int
4849 gimple_eh_dispatch_region (const geh_dispatch *eh_dispatch_stmt)
4851 return eh_dispatch_stmt->region;
4854 /* Set REGION to be the region number for GIMPLE_EH_DISPATCH
4855 EH_DISPATCH_STMT. */
4857 inline void
4858 gimple_eh_dispatch_set_region (geh_dispatch *eh_dispatch_stmt, int region)
4860 eh_dispatch_stmt->region = region;
4863 /* Return the number of labels associated with the switch statement GS. */
4865 inline unsigned
4866 gimple_switch_num_labels (const gswitch *gs)
4868 unsigned num_ops;
4869 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
4870 num_ops = gimple_num_ops (gs);
4871 gcc_gimple_checking_assert (num_ops > 1);
4872 return num_ops - 1;
4876 /* Set NLABELS to be the number of labels for the switch statement GS. */
4878 inline void
4879 gimple_switch_set_num_labels (gswitch *g, unsigned nlabels)
4881 GIMPLE_CHECK (g, GIMPLE_SWITCH);
4882 gimple_set_num_ops (g, nlabels + 1);
4886 /* Return the index variable used by the switch statement GS. */
4888 inline tree
4889 gimple_switch_index (const gswitch *gs)
4891 return gs->op[0];
4895 /* Return a pointer to the index variable for the switch statement GS. */
4897 inline tree *
4898 gimple_switch_index_ptr (gswitch *gs)
4900 return &gs->op[0];
4904 /* Set INDEX to be the index variable for switch statement GS. */
4906 inline void
4907 gimple_switch_set_index (gswitch *gs, tree index)
4909 gcc_gimple_checking_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
4910 gs->op[0] = index;
4914 /* Return the label numbered INDEX. The default label is 0, followed by any
4915 labels in a switch statement. */
4917 inline tree
4918 gimple_switch_label (const gswitch *gs, unsigned index)
4920 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1);
4921 return gs->op[index + 1];
4924 /* Set the label number INDEX to LABEL. 0 is always the default label. */
4926 inline void
4927 gimple_switch_set_label (gswitch *gs, unsigned index, tree label)
4929 gcc_gimple_checking_assert (gimple_num_ops (gs) > index + 1
4930 && (label == NULL_TREE
4931 || TREE_CODE (label) == CASE_LABEL_EXPR));
4932 gs->op[index + 1] = label;
4935 /* Return the default label for a switch statement. */
4937 inline tree
4938 gimple_switch_default_label (const gswitch *gs)
4940 tree label = gimple_switch_label (gs, 0);
4941 gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4942 return label;
4945 /* Set the default label for a switch statement. */
4947 inline void
4948 gimple_switch_set_default_label (gswitch *gs, tree label)
4950 gcc_checking_assert (!CASE_LOW (label) && !CASE_HIGH (label));
4951 gimple_switch_set_label (gs, 0, label);
4954 /* Return true if GS is a GIMPLE_DEBUG statement. */
4956 inline bool
4957 is_gimple_debug (const gimple *gs)
4959 return gimple_code (gs) == GIMPLE_DEBUG;
4963 /* Return the first nondebug statement in GIMPLE sequence S. */
4965 inline gimple *
4966 gimple_seq_first_nondebug_stmt (gimple_seq s)
4968 gimple_seq_node n = gimple_seq_first (s);
4969 while (n && is_gimple_debug (n))
4970 n = n->next;
4971 return n;
4975 /* Return the last nondebug statement in GIMPLE sequence S. */
4977 inline gimple *
4978 gimple_seq_last_nondebug_stmt (gimple_seq s)
4980 gimple_seq_node n;
4981 for (n = gimple_seq_last (s);
4982 n && is_gimple_debug (n);
4983 n = n->prev)
4984 if (n == s)
4985 return NULL;
4986 return n;
4990 /* Return true if S is a GIMPLE_DEBUG BIND statement. */
4992 inline bool
4993 gimple_debug_bind_p (const gimple *s)
4995 if (is_gimple_debug (s))
4996 return s->subcode == GIMPLE_DEBUG_BIND;
4998 return false;
5001 /* Return the variable bound in a GIMPLE_DEBUG bind statement. */
5003 inline tree
5004 gimple_debug_bind_get_var (const gimple *dbg)
5006 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5007 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5008 return gimple_op (dbg, 0);
5011 /* Return the value bound to the variable in a GIMPLE_DEBUG bind
5012 statement. */
5014 inline tree
5015 gimple_debug_bind_get_value (const gimple *dbg)
5017 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5018 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5019 return gimple_op (dbg, 1);
5022 /* Return a pointer to the value bound to the variable in a
5023 GIMPLE_DEBUG bind statement. */
5025 inline tree *
5026 gimple_debug_bind_get_value_ptr (gimple *dbg)
5028 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5029 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5030 return gimple_op_ptr (dbg, 1);
5033 /* Set the variable bound in a GIMPLE_DEBUG bind statement. */
5035 inline void
5036 gimple_debug_bind_set_var (gimple *dbg, tree var)
5038 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5039 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5040 gimple_set_op (dbg, 0, var);
5043 /* Set the value bound to the variable in a GIMPLE_DEBUG bind
5044 statement. */
5046 inline void
5047 gimple_debug_bind_set_value (gimple *dbg, tree value)
5049 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5050 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5051 gimple_set_op (dbg, 1, value);
5054 /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
5055 optimized away. */
5056 #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
5058 /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
5059 statement. */
5061 inline void
5062 gimple_debug_bind_reset_value (gimple *dbg)
5064 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5065 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5066 gimple_set_op (dbg, 1, GIMPLE_DEBUG_BIND_NOVALUE);
5069 /* Return true if the GIMPLE_DEBUG bind statement is bound to a
5070 value. */
5072 inline bool
5073 gimple_debug_bind_has_value_p (gimple *dbg)
5075 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5076 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg));
5077 return gimple_op (dbg, 1) != GIMPLE_DEBUG_BIND_NOVALUE;
5080 #undef GIMPLE_DEBUG_BIND_NOVALUE
5082 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
5084 inline bool
5085 gimple_debug_source_bind_p (const gimple *s)
5087 if (is_gimple_debug (s))
5088 return s->subcode == GIMPLE_DEBUG_SOURCE_BIND;
5090 return false;
5093 /* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
5095 inline tree
5096 gimple_debug_source_bind_get_var (const gimple *dbg)
5098 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5099 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5100 return gimple_op (dbg, 0);
5103 /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
5104 statement. */
5106 inline tree
5107 gimple_debug_source_bind_get_value (const gimple *dbg)
5109 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5110 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5111 return gimple_op (dbg, 1);
5114 /* Return a pointer to the value bound to the variable in a
5115 GIMPLE_DEBUG source bind statement. */
5117 inline tree *
5118 gimple_debug_source_bind_get_value_ptr (gimple *dbg)
5120 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5121 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5122 return gimple_op_ptr (dbg, 1);
5125 /* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
5127 inline void
5128 gimple_debug_source_bind_set_var (gimple *dbg, tree var)
5130 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5131 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5132 gimple_set_op (dbg, 0, var);
5135 /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
5136 statement. */
5138 inline void
5139 gimple_debug_source_bind_set_value (gimple *dbg, tree value)
5141 GIMPLE_CHECK (dbg, GIMPLE_DEBUG);
5142 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg));
5143 gimple_set_op (dbg, 1, value);
5146 /* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement. */
5148 inline bool
5149 gimple_debug_begin_stmt_p (const gimple *s)
5151 if (is_gimple_debug (s))
5152 return s->subcode == GIMPLE_DEBUG_BEGIN_STMT;
5154 return false;
5157 /* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement. */
5159 inline bool
5160 gimple_debug_inline_entry_p (const gimple *s)
5162 if (is_gimple_debug (s))
5163 return s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5165 return false;
5168 /* Return true if S is a GIMPLE_DEBUG non-binding marker statement. */
5170 inline bool
5171 gimple_debug_nonbind_marker_p (const gimple *s)
5173 if (is_gimple_debug (s))
5174 return s->subcode == GIMPLE_DEBUG_BEGIN_STMT
5175 || s->subcode == GIMPLE_DEBUG_INLINE_ENTRY;
5177 return false;
5180 /* Return the line number for EXPR, or return -1 if we have no line
5181 number information for it. */
5182 inline int
5183 get_lineno (const gimple *stmt)
5185 location_t loc;
5187 if (!stmt)
5188 return -1;
5190 loc = gimple_location (stmt);
5191 if (loc == UNKNOWN_LOCATION)
5192 return -1;
5194 return LOCATION_LINE (loc);
5197 /* Return a pointer to the body for the OMP statement GS. */
5199 inline gimple_seq *
5200 gimple_omp_body_ptr (gimple *gs)
5202 return &static_cast <gimple_statement_omp *> (gs)->body;
5205 /* Return the body for the OMP statement GS. */
5207 inline gimple_seq
5208 gimple_omp_body (const gimple *gs)
5210 return *gimple_omp_body_ptr (const_cast <gimple *> (gs));
5213 /* Set BODY to be the body for the OMP statement GS. */
5215 inline void
5216 gimple_omp_set_body (gimple *gs, gimple_seq body)
5218 static_cast <gimple_statement_omp *> (gs)->body = body;
5222 /* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */
5224 inline tree
5225 gimple_omp_critical_name (const gomp_critical *crit_stmt)
5227 return crit_stmt->name;
5231 /* Return a pointer to the name associated with OMP critical statement
5232 CRIT_STMT. */
5234 inline tree *
5235 gimple_omp_critical_name_ptr (gomp_critical *crit_stmt)
5237 return &crit_stmt->name;
5241 /* Set NAME to be the name associated with OMP critical statement
5242 CRIT_STMT. */
5244 inline void
5245 gimple_omp_critical_set_name (gomp_critical *crit_stmt, tree name)
5247 crit_stmt->name = name;
5251 /* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */
5253 inline tree
5254 gimple_omp_critical_clauses (const gomp_critical *crit_stmt)
5256 return crit_stmt->clauses;
5260 /* Return a pointer to the clauses associated with OMP critical statement
5261 CRIT_STMT. */
5263 inline tree *
5264 gimple_omp_critical_clauses_ptr (gomp_critical *crit_stmt)
5266 return &crit_stmt->clauses;
5270 /* Set CLAUSES to be the clauses associated with OMP critical statement
5271 CRIT_STMT. */
5273 inline void
5274 gimple_omp_critical_set_clauses (gomp_critical *crit_stmt, tree clauses)
5276 crit_stmt->clauses = clauses;
5280 /* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */
5282 inline tree
5283 gimple_omp_ordered_clauses (const gomp_ordered *ord_stmt)
5285 return ord_stmt->clauses;
5289 /* Return a pointer to the clauses associated with OMP ordered statement
5290 ORD_STMT. */
5292 inline tree *
5293 gimple_omp_ordered_clauses_ptr (gomp_ordered *ord_stmt)
5295 return &ord_stmt->clauses;
5299 /* Set CLAUSES to be the clauses associated with OMP ordered statement
5300 ORD_STMT. */
5302 inline void
5303 gimple_omp_ordered_set_clauses (gomp_ordered *ord_stmt, tree clauses)
5305 ord_stmt->clauses = clauses;
5309 /* Return the clauses associated with OMP_SCAN statement SCAN_STMT. */
5311 inline tree
5312 gimple_omp_scan_clauses (const gomp_scan *scan_stmt)
5314 return scan_stmt->clauses;
5318 /* Return a pointer to the clauses associated with OMP scan statement
5319 ORD_STMT. */
5321 inline tree *
5322 gimple_omp_scan_clauses_ptr (gomp_scan *scan_stmt)
5324 return &scan_stmt->clauses;
5328 /* Set CLAUSES to be the clauses associated with OMP scan statement
5329 ORD_STMT. */
5331 inline void
5332 gimple_omp_scan_set_clauses (gomp_scan *scan_stmt, tree clauses)
5334 scan_stmt->clauses = clauses;
5338 /* Return the clauses associated with OMP_TASKGROUP statement GS. */
5340 inline tree
5341 gimple_omp_taskgroup_clauses (const gimple *gs)
5343 GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5344 return
5345 static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5349 /* Return a pointer to the clauses associated with OMP taskgroup statement
5350 GS. */
5352 inline tree *
5353 gimple_omp_taskgroup_clauses_ptr (gimple *gs)
5355 GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5356 return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5360 /* Set CLAUSES to be the clauses associated with OMP taskgroup statement
5361 GS. */
5363 inline void
5364 gimple_omp_taskgroup_set_clauses (gimple *gs, tree clauses)
5366 GIMPLE_CHECK (gs, GIMPLE_OMP_TASKGROUP);
5367 static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5368 = clauses;
5372 /* Return the clauses associated with OMP_MASKED statement GS. */
5374 inline tree
5375 gimple_omp_masked_clauses (const gimple *gs)
5377 GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5378 return
5379 static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5383 /* Return a pointer to the clauses associated with OMP masked statement
5384 GS. */
5386 inline tree *
5387 gimple_omp_masked_clauses_ptr (gimple *gs)
5389 GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5390 return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5394 /* Set CLAUSES to be the clauses associated with OMP masked statement
5395 GS. */
5397 inline void
5398 gimple_omp_masked_set_clauses (gimple *gs, tree clauses)
5400 GIMPLE_CHECK (gs, GIMPLE_OMP_MASKED);
5401 static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5402 = clauses;
5406 /* Return the clauses associated with OMP_SCOPE statement GS. */
5408 inline tree
5409 gimple_omp_scope_clauses (const gimple *gs)
5411 GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5412 return
5413 static_cast <const gimple_statement_omp_single_layout *> (gs)->clauses;
5417 /* Return a pointer to the clauses associated with OMP scope statement
5418 GS. */
5420 inline tree *
5421 gimple_omp_scope_clauses_ptr (gimple *gs)
5423 GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5424 return &static_cast <gimple_statement_omp_single_layout *> (gs)->clauses;
5428 /* Set CLAUSES to be the clauses associated with OMP scope statement
5429 GS. */
5431 inline void
5432 gimple_omp_scope_set_clauses (gimple *gs, tree clauses)
5434 GIMPLE_CHECK (gs, GIMPLE_OMP_SCOPE);
5435 static_cast <gimple_statement_omp_single_layout *> (gs)->clauses
5436 = clauses;
5440 /* Return the kind of the OMP_FOR statemement G. */
5442 inline int
5443 gimple_omp_for_kind (const gimple *g)
5445 GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5446 return (gimple_omp_subcode (g) & GF_OMP_FOR_KIND_MASK);
5450 /* Set the kind of the OMP_FOR statement G. */
5452 inline void
5453 gimple_omp_for_set_kind (gomp_for *g, int kind)
5455 g->subcode = (g->subcode & ~GF_OMP_FOR_KIND_MASK)
5456 | (kind & GF_OMP_FOR_KIND_MASK);
5460 /* Return true if OMP_FOR statement G has the
5461 GF_OMP_FOR_COMBINED flag set. */
5463 inline bool
5464 gimple_omp_for_combined_p (const gimple *g)
5466 GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5467 return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED) != 0;
5471 /* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
5472 the boolean value of COMBINED_P. */
5474 inline void
5475 gimple_omp_for_set_combined_p (gomp_for *g, bool combined_p)
5477 if (combined_p)
5478 g->subcode |= GF_OMP_FOR_COMBINED;
5479 else
5480 g->subcode &= ~GF_OMP_FOR_COMBINED;
5484 /* Return true if the OMP_FOR statement G has the
5485 GF_OMP_FOR_COMBINED_INTO flag set. */
5487 inline bool
5488 gimple_omp_for_combined_into_p (const gimple *g)
5490 GIMPLE_CHECK (g, GIMPLE_OMP_FOR);
5491 return (gimple_omp_subcode (g) & GF_OMP_FOR_COMBINED_INTO) != 0;
5495 /* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
5496 on the boolean value of COMBINED_P. */
5498 inline void
5499 gimple_omp_for_set_combined_into_p (gomp_for *g, bool combined_p)
5501 if (combined_p)
5502 g->subcode |= GF_OMP_FOR_COMBINED_INTO;
5503 else
5504 g->subcode &= ~GF_OMP_FOR_COMBINED_INTO;
5508 /* Return the clauses associated with the OMP_FOR statement GS. */
5510 inline tree
5511 gimple_omp_for_clauses (const gimple *gs)
5513 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5514 return omp_for_stmt->clauses;
5518 /* Return a pointer to the clauses associated with the OMP_FOR statement
5519 GS. */
5521 inline tree *
5522 gimple_omp_for_clauses_ptr (gimple *gs)
5524 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5525 return &omp_for_stmt->clauses;
5529 /* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
5530 GS. */
5532 inline void
5533 gimple_omp_for_set_clauses (gimple *gs, tree clauses)
5535 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5536 omp_for_stmt->clauses = clauses;
5540 /* Get the collapse count of the OMP_FOR statement GS. */
5542 inline size_t
5543 gimple_omp_for_collapse (const gimple *gs)
5545 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5546 return omp_for_stmt->collapse;
5550 /* Return the condition code associated with the OMP_FOR statement GS. */
5552 inline enum tree_code
5553 gimple_omp_for_cond (const gimple *gs, size_t i)
5555 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5556 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5557 return omp_for_stmt->iter[i].cond;
5561 /* Set COND to be the condition code for the OMP_FOR statement GS. */
5563 inline void
5564 gimple_omp_for_set_cond (gimple *gs, size_t i, enum tree_code cond)
5566 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5567 gcc_gimple_checking_assert (TREE_CODE_CLASS (cond) == tcc_comparison
5568 && i < omp_for_stmt->collapse);
5569 omp_for_stmt->iter[i].cond = cond;
5573 /* Return the index variable for the OMP_FOR statement GS. */
5575 inline tree
5576 gimple_omp_for_index (const gimple *gs, size_t i)
5578 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5579 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5580 return omp_for_stmt->iter[i].index;
5584 /* Return a pointer to the index variable for the OMP_FOR statement GS. */
5586 inline tree *
5587 gimple_omp_for_index_ptr (gimple *gs, size_t i)
5589 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5590 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5591 return &omp_for_stmt->iter[i].index;
5595 /* Set INDEX to be the index variable for the OMP_FOR statement GS. */
5597 inline void
5598 gimple_omp_for_set_index (gimple *gs, size_t i, tree index)
5600 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5601 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5602 omp_for_stmt->iter[i].index = index;
5606 /* Return the initial value for the OMP_FOR statement GS. */
5608 inline tree
5609 gimple_omp_for_initial (const gimple *gs, size_t i)
5611 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5612 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5613 return omp_for_stmt->iter[i].initial;
5617 /* Return a pointer to the initial value for the OMP_FOR statement GS. */
5619 inline tree *
5620 gimple_omp_for_initial_ptr (gimple *gs, size_t i)
5622 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5623 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5624 return &omp_for_stmt->iter[i].initial;
5628 /* Set INITIAL to be the initial value for the OMP_FOR statement GS. */
5630 inline void
5631 gimple_omp_for_set_initial (gimple *gs, size_t i, tree initial)
5633 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5634 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5635 omp_for_stmt->iter[i].initial = initial;
5639 /* Return the final value for the OMP_FOR statement GS. */
5641 inline tree
5642 gimple_omp_for_final (const gimple *gs, size_t i)
5644 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5645 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5646 return omp_for_stmt->iter[i].final;
5650 /* Return a pointer to the final value for the OMP_FOR statement GS. */
5652 inline tree *
5653 gimple_omp_for_final_ptr (gimple *gs, size_t i)
5655 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5656 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5657 return &omp_for_stmt->iter[i].final;
5661 /* Set FINAL to be the final value for the OMP_FOR statement GS. */
5663 inline void
5664 gimple_omp_for_set_final (gimple *gs, size_t i, tree final)
5666 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5667 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5668 omp_for_stmt->iter[i].final = final;
5672 /* Return the increment value for the OMP_FOR statement GS. */
5674 inline tree
5675 gimple_omp_for_incr (const gimple *gs, size_t i)
5677 const gomp_for *omp_for_stmt = as_a <const gomp_for *> (gs);
5678 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5679 return omp_for_stmt->iter[i].incr;
5683 /* Return a pointer to the increment value for the OMP_FOR statement GS. */
5685 inline tree *
5686 gimple_omp_for_incr_ptr (gimple *gs, size_t i)
5688 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5689 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5690 return &omp_for_stmt->iter[i].incr;
5694 /* Set INCR to be the increment value for the OMP_FOR statement GS. */
5696 inline void
5697 gimple_omp_for_set_incr (gimple *gs, size_t i, tree incr)
5699 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5700 gcc_gimple_checking_assert (i < omp_for_stmt->collapse);
5701 omp_for_stmt->iter[i].incr = incr;
5705 /* Return a pointer to the sequence of statements to execute before the OMP_FOR
5706 statement GS starts. */
5708 inline gimple_seq *
5709 gimple_omp_for_pre_body_ptr (gimple *gs)
5711 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5712 return &omp_for_stmt->pre_body;
5716 /* Return the sequence of statements to execute before the OMP_FOR
5717 statement GS starts. */
5719 inline gimple_seq
5720 gimple_omp_for_pre_body (const gimple *gs)
5722 return *gimple_omp_for_pre_body_ptr (const_cast <gimple *> (gs));
5726 /* Set PRE_BODY to be the sequence of statements to execute before the
5727 OMP_FOR statement GS starts. */
5729 inline void
5730 gimple_omp_for_set_pre_body (gimple *gs, gimple_seq pre_body)
5732 gomp_for *omp_for_stmt = as_a <gomp_for *> (gs);
5733 omp_for_stmt->pre_body = pre_body;
5736 /* Return the clauses associated with OMP_PARALLEL GS. */
5738 inline tree
5739 gimple_omp_parallel_clauses (const gimple *gs)
5741 const gomp_parallel *omp_parallel_stmt = as_a <const gomp_parallel *> (gs);
5742 return omp_parallel_stmt->clauses;
5746 /* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */
5748 inline tree *
5749 gimple_omp_parallel_clauses_ptr (gomp_parallel *omp_parallel_stmt)
5751 return &omp_parallel_stmt->clauses;
5755 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */
5757 inline void
5758 gimple_omp_parallel_set_clauses (gomp_parallel *omp_parallel_stmt,
5759 tree clauses)
5761 omp_parallel_stmt->clauses = clauses;
5765 /* Return the child function used to hold the body of OMP_PARALLEL_STMT. */
5767 inline tree
5768 gimple_omp_parallel_child_fn (const gomp_parallel *omp_parallel_stmt)
5770 return omp_parallel_stmt->child_fn;
5773 /* Return a pointer to the child function used to hold the body of
5774 OMP_PARALLEL_STMT. */
5776 inline tree *
5777 gimple_omp_parallel_child_fn_ptr (gomp_parallel *omp_parallel_stmt)
5779 return &omp_parallel_stmt->child_fn;
5783 /* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */
5785 inline void
5786 gimple_omp_parallel_set_child_fn (gomp_parallel *omp_parallel_stmt,
5787 tree child_fn)
5789 omp_parallel_stmt->child_fn = child_fn;
5793 /* Return the artificial argument used to send variables and values
5794 from the parent to the children threads in OMP_PARALLEL_STMT. */
5796 inline tree
5797 gimple_omp_parallel_data_arg (const gomp_parallel *omp_parallel_stmt)
5799 return omp_parallel_stmt->data_arg;
5803 /* Return a pointer to the data argument for OMP_PARALLEL_STMT. */
5805 inline tree *
5806 gimple_omp_parallel_data_arg_ptr (gomp_parallel *omp_parallel_stmt)
5808 return &omp_parallel_stmt->data_arg;
5812 /* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */
5814 inline void
5815 gimple_omp_parallel_set_data_arg (gomp_parallel *omp_parallel_stmt,
5816 tree data_arg)
5818 omp_parallel_stmt->data_arg = data_arg;
5821 /* Return the clauses associated with OMP_TASK GS. */
5823 inline tree
5824 gimple_omp_task_clauses (const gimple *gs)
5826 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5827 return omp_task_stmt->clauses;
5831 /* Return a pointer to the clauses associated with OMP_TASK GS. */
5833 inline tree *
5834 gimple_omp_task_clauses_ptr (gimple *gs)
5836 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5837 return &omp_task_stmt->clauses;
5841 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5842 GS. */
5844 inline void
5845 gimple_omp_task_set_clauses (gimple *gs, tree clauses)
5847 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5848 omp_task_stmt->clauses = clauses;
5852 /* Return true if OMP task statement G has the
5853 GF_OMP_TASK_TASKLOOP flag set. */
5855 inline bool
5856 gimple_omp_task_taskloop_p (const gimple *g)
5858 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5859 return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKLOOP) != 0;
5863 /* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
5864 value of TASKLOOP_P. */
5866 inline void
5867 gimple_omp_task_set_taskloop_p (gimple *g, bool taskloop_p)
5869 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5870 if (taskloop_p)
5871 g->subcode |= GF_OMP_TASK_TASKLOOP;
5872 else
5873 g->subcode &= ~GF_OMP_TASK_TASKLOOP;
5877 /* Return true if OMP task statement G has the
5878 GF_OMP_TASK_TASKWAIT flag set. */
5880 inline bool
5881 gimple_omp_task_taskwait_p (const gimple *g)
5883 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5884 return (gimple_omp_subcode (g) & GF_OMP_TASK_TASKWAIT) != 0;
5888 /* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
5889 value of TASKWAIT_P. */
5891 inline void
5892 gimple_omp_task_set_taskwait_p (gimple *g, bool taskwait_p)
5894 GIMPLE_CHECK (g, GIMPLE_OMP_TASK);
5895 if (taskwait_p)
5896 g->subcode |= GF_OMP_TASK_TASKWAIT;
5897 else
5898 g->subcode &= ~GF_OMP_TASK_TASKWAIT;
5902 /* Return the child function used to hold the body of OMP_TASK GS. */
5904 inline tree
5905 gimple_omp_task_child_fn (const gimple *gs)
5907 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5908 return omp_task_stmt->child_fn;
5911 /* Return a pointer to the child function used to hold the body of
5912 OMP_TASK GS. */
5914 inline tree *
5915 gimple_omp_task_child_fn_ptr (gimple *gs)
5917 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5918 return &omp_task_stmt->child_fn;
5922 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
5924 inline void
5925 gimple_omp_task_set_child_fn (gimple *gs, tree child_fn)
5927 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5928 omp_task_stmt->child_fn = child_fn;
5932 /* Return the artificial argument used to send variables and values
5933 from the parent to the children threads in OMP_TASK GS. */
5935 inline tree
5936 gimple_omp_task_data_arg (const gimple *gs)
5938 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
5939 return omp_task_stmt->data_arg;
5943 /* Return a pointer to the data argument for OMP_TASK GS. */
5945 inline tree *
5946 gimple_omp_task_data_arg_ptr (gimple *gs)
5948 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5949 return &omp_task_stmt->data_arg;
5953 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
5955 inline void
5956 gimple_omp_task_set_data_arg (gimple *gs, tree data_arg)
5958 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
5959 omp_task_stmt->data_arg = data_arg;
5963 /* Return the clauses associated with OMP_TASK GS. */
5965 inline tree
5966 gimple_omp_taskreg_clauses (const gimple *gs)
5968 const gimple_statement_omp_taskreg *omp_taskreg_stmt
5969 = as_a <const gimple_statement_omp_taskreg *> (gs);
5970 return omp_taskreg_stmt->clauses;
5974 /* Return a pointer to the clauses associated with OMP_TASK GS. */
5976 inline tree *
5977 gimple_omp_taskreg_clauses_ptr (gimple *gs)
5979 gimple_statement_omp_taskreg *omp_taskreg_stmt
5980 = as_a <gimple_statement_omp_taskreg *> (gs);
5981 return &omp_taskreg_stmt->clauses;
5985 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5986 GS. */
5988 inline void
5989 gimple_omp_taskreg_set_clauses (gimple *gs, tree clauses)
5991 gimple_statement_omp_taskreg *omp_taskreg_stmt
5992 = as_a <gimple_statement_omp_taskreg *> (gs);
5993 omp_taskreg_stmt->clauses = clauses;
5997 /* Return the child function used to hold the body of OMP_TASK GS. */
5999 inline tree
6000 gimple_omp_taskreg_child_fn (const gimple *gs)
6002 const gimple_statement_omp_taskreg *omp_taskreg_stmt
6003 = as_a <const gimple_statement_omp_taskreg *> (gs);
6004 return omp_taskreg_stmt->child_fn;
6007 /* Return a pointer to the child function used to hold the body of
6008 OMP_TASK GS. */
6010 inline tree *
6011 gimple_omp_taskreg_child_fn_ptr (gimple *gs)
6013 gimple_statement_omp_taskreg *omp_taskreg_stmt
6014 = as_a <gimple_statement_omp_taskreg *> (gs);
6015 return &omp_taskreg_stmt->child_fn;
6019 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
6021 inline void
6022 gimple_omp_taskreg_set_child_fn (gimple *gs, tree child_fn)
6024 gimple_statement_omp_taskreg *omp_taskreg_stmt
6025 = as_a <gimple_statement_omp_taskreg *> (gs);
6026 omp_taskreg_stmt->child_fn = child_fn;
6030 /* Return the artificial argument used to send variables and values
6031 from the parent to the children threads in OMP_TASK GS. */
6033 inline tree
6034 gimple_omp_taskreg_data_arg (const gimple *gs)
6036 const gimple_statement_omp_taskreg *omp_taskreg_stmt
6037 = as_a <const gimple_statement_omp_taskreg *> (gs);
6038 return omp_taskreg_stmt->data_arg;
6042 /* Return a pointer to the data argument for OMP_TASK GS. */
6044 inline tree *
6045 gimple_omp_taskreg_data_arg_ptr (gimple *gs)
6047 gimple_statement_omp_taskreg *omp_taskreg_stmt
6048 = as_a <gimple_statement_omp_taskreg *> (gs);
6049 return &omp_taskreg_stmt->data_arg;
6053 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
6055 inline void
6056 gimple_omp_taskreg_set_data_arg (gimple *gs, tree data_arg)
6058 gimple_statement_omp_taskreg *omp_taskreg_stmt
6059 = as_a <gimple_statement_omp_taskreg *> (gs);
6060 omp_taskreg_stmt->data_arg = data_arg;
6064 /* Return the copy function used to hold the body of OMP_TASK GS. */
6066 inline tree
6067 gimple_omp_task_copy_fn (const gimple *gs)
6069 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6070 return omp_task_stmt->copy_fn;
6073 /* Return a pointer to the copy function used to hold the body of
6074 OMP_TASK GS. */
6076 inline tree *
6077 gimple_omp_task_copy_fn_ptr (gimple *gs)
6079 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6080 return &omp_task_stmt->copy_fn;
6084 /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
6086 inline void
6087 gimple_omp_task_set_copy_fn (gimple *gs, tree copy_fn)
6089 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6090 omp_task_stmt->copy_fn = copy_fn;
6094 /* Return size of the data block in bytes in OMP_TASK GS. */
6096 inline tree
6097 gimple_omp_task_arg_size (const gimple *gs)
6099 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6100 return omp_task_stmt->arg_size;
6104 /* Return a pointer to the data block size for OMP_TASK GS. */
6106 inline tree *
6107 gimple_omp_task_arg_size_ptr (gimple *gs)
6109 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6110 return &omp_task_stmt->arg_size;
6114 /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
6116 inline void
6117 gimple_omp_task_set_arg_size (gimple *gs, tree arg_size)
6119 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6120 omp_task_stmt->arg_size = arg_size;
6124 /* Return align of the data block in bytes in OMP_TASK GS. */
6126 inline tree
6127 gimple_omp_task_arg_align (const gimple *gs)
6129 const gomp_task *omp_task_stmt = as_a <const gomp_task *> (gs);
6130 return omp_task_stmt->arg_align;
6134 /* Return a pointer to the data block align for OMP_TASK GS. */
6136 inline tree *
6137 gimple_omp_task_arg_align_ptr (gimple *gs)
6139 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6140 return &omp_task_stmt->arg_align;
6144 /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
6146 inline void
6147 gimple_omp_task_set_arg_align (gimple *gs, tree arg_align)
6149 gomp_task *omp_task_stmt = as_a <gomp_task *> (gs);
6150 omp_task_stmt->arg_align = arg_align;
6154 /* Return the clauses associated with OMP_SINGLE GS. */
6156 inline tree
6157 gimple_omp_single_clauses (const gimple *gs)
6159 const gomp_single *omp_single_stmt = as_a <const gomp_single *> (gs);
6160 return omp_single_stmt->clauses;
6164 /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
6166 inline tree *
6167 gimple_omp_single_clauses_ptr (gimple *gs)
6169 gomp_single *omp_single_stmt = as_a <gomp_single *> (gs);
6170 return &omp_single_stmt->clauses;
6174 /* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */
6176 inline void
6177 gimple_omp_single_set_clauses (gomp_single *omp_single_stmt, tree clauses)
6179 omp_single_stmt->clauses = clauses;
6183 /* Return the clauses associated with OMP_TARGET GS. */
6185 inline tree
6186 gimple_omp_target_clauses (const gimple *gs)
6188 const gomp_target *omp_target_stmt = as_a <const gomp_target *> (gs);
6189 return omp_target_stmt->clauses;
6193 /* Return a pointer to the clauses associated with OMP_TARGET GS. */
6195 inline tree *
6196 gimple_omp_target_clauses_ptr (gimple *gs)
6198 gomp_target *omp_target_stmt = as_a <gomp_target *> (gs);
6199 return &omp_target_stmt->clauses;
6203 /* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */
6205 inline void
6206 gimple_omp_target_set_clauses (gomp_target *omp_target_stmt,
6207 tree clauses)
6209 omp_target_stmt->clauses = clauses;
6213 /* Return the kind of the OMP_TARGET G. */
6215 inline int
6216 gimple_omp_target_kind (const gimple *g)
6218 GIMPLE_CHECK (g, GIMPLE_OMP_TARGET);
6219 return (gimple_omp_subcode (g) & GF_OMP_TARGET_KIND_MASK);
6223 /* Set the kind of the OMP_TARGET G. */
6225 inline void
6226 gimple_omp_target_set_kind (gomp_target *g, int kind)
6228 g->subcode = (g->subcode & ~GF_OMP_TARGET_KIND_MASK)
6229 | (kind & GF_OMP_TARGET_KIND_MASK);
6233 /* Return the child function used to hold the body of OMP_TARGET_STMT. */
6235 inline tree
6236 gimple_omp_target_child_fn (const gomp_target *omp_target_stmt)
6238 return omp_target_stmt->child_fn;
6241 /* Return a pointer to the child function used to hold the body of
6242 OMP_TARGET_STMT. */
6244 inline tree *
6245 gimple_omp_target_child_fn_ptr (gomp_target *omp_target_stmt)
6247 return &omp_target_stmt->child_fn;
6251 /* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */
6253 inline void
6254 gimple_omp_target_set_child_fn (gomp_target *omp_target_stmt,
6255 tree child_fn)
6257 omp_target_stmt->child_fn = child_fn;
6261 /* Return the artificial argument used to send variables and values
6262 from the parent to the children threads in OMP_TARGET_STMT. */
6264 inline tree
6265 gimple_omp_target_data_arg (const gomp_target *omp_target_stmt)
6267 return omp_target_stmt->data_arg;
6271 /* Return a pointer to the data argument for OMP_TARGET GS. */
6273 inline tree *
6274 gimple_omp_target_data_arg_ptr (gomp_target *omp_target_stmt)
6276 return &omp_target_stmt->data_arg;
6280 /* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */
6282 inline void
6283 gimple_omp_target_set_data_arg (gomp_target *omp_target_stmt,
6284 tree data_arg)
6286 omp_target_stmt->data_arg = data_arg;
6290 /* Return the clauses associated with OMP_TEAMS GS. */
6292 inline tree
6293 gimple_omp_teams_clauses (const gimple *gs)
6295 const gomp_teams *omp_teams_stmt = as_a <const gomp_teams *> (gs);
6296 return omp_teams_stmt->clauses;
6300 /* Return a pointer to the clauses associated with OMP_TEAMS GS. */
6302 inline tree *
6303 gimple_omp_teams_clauses_ptr (gimple *gs)
6305 gomp_teams *omp_teams_stmt = as_a <gomp_teams *> (gs);
6306 return &omp_teams_stmt->clauses;
6310 /* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */
6312 inline void
6313 gimple_omp_teams_set_clauses (gomp_teams *omp_teams_stmt, tree clauses)
6315 omp_teams_stmt->clauses = clauses;
6318 /* Return the child function used to hold the body of OMP_TEAMS_STMT. */
6320 inline tree
6321 gimple_omp_teams_child_fn (const gomp_teams *omp_teams_stmt)
6323 return omp_teams_stmt->child_fn;
6326 /* Return a pointer to the child function used to hold the body of
6327 OMP_TEAMS_STMT. */
6329 inline tree *
6330 gimple_omp_teams_child_fn_ptr (gomp_teams *omp_teams_stmt)
6332 return &omp_teams_stmt->child_fn;
6336 /* Set CHILD_FN to be the child function for OMP_TEAMS_STMT. */
6338 inline void
6339 gimple_omp_teams_set_child_fn (gomp_teams *omp_teams_stmt, tree child_fn)
6341 omp_teams_stmt->child_fn = child_fn;
6345 /* Return the artificial argument used to send variables and values
6346 from the parent to the children threads in OMP_TEAMS_STMT. */
6348 inline tree
6349 gimple_omp_teams_data_arg (const gomp_teams *omp_teams_stmt)
6351 return omp_teams_stmt->data_arg;
6355 /* Return a pointer to the data argument for OMP_TEAMS_STMT. */
6357 inline tree *
6358 gimple_omp_teams_data_arg_ptr (gomp_teams *omp_teams_stmt)
6360 return &omp_teams_stmt->data_arg;
6364 /* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT. */
6366 inline void
6367 gimple_omp_teams_set_data_arg (gomp_teams *omp_teams_stmt, tree data_arg)
6369 omp_teams_stmt->data_arg = data_arg;
6372 /* Return the host flag of an OMP_TEAMS_STMT. */
6374 inline bool
6375 gimple_omp_teams_host (const gomp_teams *omp_teams_stmt)
6377 return (gimple_omp_subcode (omp_teams_stmt) & GF_OMP_TEAMS_HOST) != 0;
6380 /* Set host flag of an OMP_TEAMS_STMT to VALUE. */
6382 inline void
6383 gimple_omp_teams_set_host (gomp_teams *omp_teams_stmt, bool value)
6385 if (value)
6386 omp_teams_stmt->subcode |= GF_OMP_TEAMS_HOST;
6387 else
6388 omp_teams_stmt->subcode &= ~GF_OMP_TEAMS_HOST;
6391 /* Return the clauses associated with OMP_SECTIONS GS. */
6393 inline tree
6394 gimple_omp_sections_clauses (const gimple *gs)
6396 const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6397 return omp_sections_stmt->clauses;
6401 /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
6403 inline tree *
6404 gimple_omp_sections_clauses_ptr (gimple *gs)
6406 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6407 return &omp_sections_stmt->clauses;
6411 /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6412 GS. */
6414 inline void
6415 gimple_omp_sections_set_clauses (gimple *gs, tree clauses)
6417 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6418 omp_sections_stmt->clauses = clauses;
6422 /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6423 in GS. */
6425 inline tree
6426 gimple_omp_sections_control (const gimple *gs)
6428 const gomp_sections *omp_sections_stmt = as_a <const gomp_sections *> (gs);
6429 return omp_sections_stmt->control;
6433 /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6434 GS. */
6436 inline tree *
6437 gimple_omp_sections_control_ptr (gimple *gs)
6439 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6440 return &omp_sections_stmt->control;
6444 /* Set CONTROL to be the set of clauses associated with the
6445 GIMPLE_OMP_SECTIONS in GS. */
6447 inline void
6448 gimple_omp_sections_set_control (gimple *gs, tree control)
6450 gomp_sections *omp_sections_stmt = as_a <gomp_sections *> (gs);
6451 omp_sections_stmt->control = control;
6455 /* Set the value being stored in an atomic store. */
6457 inline void
6458 gimple_omp_atomic_store_set_val (gomp_atomic_store *store_stmt, tree val)
6460 store_stmt->val = val;
6464 /* Return the value being stored in an atomic store. */
6466 inline tree
6467 gimple_omp_atomic_store_val (const gomp_atomic_store *store_stmt)
6469 return store_stmt->val;
6473 /* Return a pointer to the value being stored in an atomic store. */
6475 inline tree *
6476 gimple_omp_atomic_store_val_ptr (gomp_atomic_store *store_stmt)
6478 return &store_stmt->val;
6482 /* Set the LHS of an atomic load. */
6484 inline void
6485 gimple_omp_atomic_load_set_lhs (gomp_atomic_load *load_stmt, tree lhs)
6487 load_stmt->lhs = lhs;
6491 /* Get the LHS of an atomic load. */
6493 inline tree
6494 gimple_omp_atomic_load_lhs (const gomp_atomic_load *load_stmt)
6496 return load_stmt->lhs;
6500 /* Return a pointer to the LHS of an atomic load. */
6502 inline tree *
6503 gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load *load_stmt)
6505 return &load_stmt->lhs;
6509 /* Set the RHS of an atomic load. */
6511 inline void
6512 gimple_omp_atomic_load_set_rhs (gomp_atomic_load *load_stmt, tree rhs)
6514 load_stmt->rhs = rhs;
6518 /* Get the RHS of an atomic load. */
6520 inline tree
6521 gimple_omp_atomic_load_rhs (const gomp_atomic_load *load_stmt)
6523 return load_stmt->rhs;
6527 /* Return a pointer to the RHS of an atomic load. */
6529 inline tree *
6530 gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load *load_stmt)
6532 return &load_stmt->rhs;
6536 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6538 inline tree
6539 gimple_omp_continue_control_def (const gomp_continue *cont_stmt)
6541 return cont_stmt->control_def;
6544 /* The same as above, but return the address. */
6546 inline tree *
6547 gimple_omp_continue_control_def_ptr (gomp_continue *cont_stmt)
6549 return &cont_stmt->control_def;
6552 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6554 inline void
6555 gimple_omp_continue_set_control_def (gomp_continue *cont_stmt, tree def)
6557 cont_stmt->control_def = def;
6561 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6563 inline tree
6564 gimple_omp_continue_control_use (const gomp_continue *cont_stmt)
6566 return cont_stmt->control_use;
6570 /* The same as above, but return the address. */
6572 inline tree *
6573 gimple_omp_continue_control_use_ptr (gomp_continue *cont_stmt)
6575 return &cont_stmt->control_use;
6579 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6581 inline void
6582 gimple_omp_continue_set_control_use (gomp_continue *cont_stmt, tree use)
6584 cont_stmt->control_use = use;
6587 /* Return the guard associated with the GIMPLE_ASSUME statement GS. */
6589 inline tree
6590 gimple_assume_guard (const gimple *gs)
6592 const gimple_statement_assume *assume_stmt
6593 = as_a <const gimple_statement_assume *> (gs);
6594 return assume_stmt->guard;
6597 /* Set the guard associated with the GIMPLE_ASSUME statement GS. */
6599 inline void
6600 gimple_assume_set_guard (gimple *gs, tree guard)
6602 gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6603 assume_stmt->guard = guard;
6606 inline tree *
6607 gimple_assume_guard_ptr (gimple *gs)
6609 gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6610 return &assume_stmt->guard;
6613 /* Return the address of the GIMPLE sequence contained in the GIMPLE_ASSUME
6614 statement GS. */
6616 inline gimple_seq *
6617 gimple_assume_body_ptr (gimple *gs)
6619 gimple_statement_assume *assume_stmt = as_a <gimple_statement_assume *> (gs);
6620 return &assume_stmt->body;
6623 /* Return the GIMPLE sequence contained in the GIMPLE_ASSUME statement GS. */
6625 inline gimple_seq
6626 gimple_assume_body (const gimple *gs)
6628 const gimple_statement_assume *assume_stmt
6629 = as_a <const gimple_statement_assume *> (gs);
6630 return assume_stmt->body;
6633 /* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6634 TRANSACTION_STMT. */
6636 inline gimple_seq *
6637 gimple_transaction_body_ptr (gtransaction *transaction_stmt)
6639 return &transaction_stmt->body;
6642 /* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */
6644 inline gimple_seq
6645 gimple_transaction_body (const gtransaction *transaction_stmt)
6647 return transaction_stmt->body;
6650 /* Return the label associated with a GIMPLE_TRANSACTION. */
6652 inline tree
6653 gimple_transaction_label_norm (const gtransaction *transaction_stmt)
6655 return transaction_stmt->label_norm;
6658 inline tree *
6659 gimple_transaction_label_norm_ptr (gtransaction *transaction_stmt)
6661 return &transaction_stmt->label_norm;
6664 inline tree
6665 gimple_transaction_label_uninst (const gtransaction *transaction_stmt)
6667 return transaction_stmt->label_uninst;
6670 inline tree *
6671 gimple_transaction_label_uninst_ptr (gtransaction *transaction_stmt)
6673 return &transaction_stmt->label_uninst;
6676 inline tree
6677 gimple_transaction_label_over (const gtransaction *transaction_stmt)
6679 return transaction_stmt->label_over;
6682 inline tree *
6683 gimple_transaction_label_over_ptr (gtransaction *transaction_stmt)
6685 return &transaction_stmt->label_over;
6688 /* Return the subcode associated with a GIMPLE_TRANSACTION. */
6690 inline unsigned int
6691 gimple_transaction_subcode (const gtransaction *transaction_stmt)
6693 return transaction_stmt->subcode;
6696 /* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6697 TRANSACTION_STMT. */
6699 inline void
6700 gimple_transaction_set_body (gtransaction *transaction_stmt,
6701 gimple_seq body)
6703 transaction_stmt->body = body;
6706 /* Set the label associated with a GIMPLE_TRANSACTION. */
6708 inline void
6709 gimple_transaction_set_label_norm (gtransaction *transaction_stmt, tree label)
6711 transaction_stmt->label_norm = label;
6714 inline void
6715 gimple_transaction_set_label_uninst (gtransaction *transaction_stmt, tree label)
6717 transaction_stmt->label_uninst = label;
6720 inline void
6721 gimple_transaction_set_label_over (gtransaction *transaction_stmt, tree label)
6723 transaction_stmt->label_over = label;
6726 /* Set the subcode associated with a GIMPLE_TRANSACTION. */
6728 inline void
6729 gimple_transaction_set_subcode (gtransaction *transaction_stmt,
6730 unsigned int subcode)
6732 transaction_stmt->subcode = subcode;
6735 /* Return a pointer to the return value for GIMPLE_RETURN GS. */
6737 inline tree *
6738 gimple_return_retval_ptr (greturn *gs)
6740 return &gs->op[0];
6743 /* Return the return value for GIMPLE_RETURN GS. */
6745 inline tree
6746 gimple_return_retval (const greturn *gs)
6748 return gs->op[0];
6752 /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
6754 inline void
6755 gimple_return_set_retval (greturn *gs, tree retval)
6757 gs->op[0] = retval;
6761 /* Returns true when the gimple statement STMT is any of the OMP types. */
6763 #define CASE_GIMPLE_OMP \
6764 case GIMPLE_OMP_PARALLEL: \
6765 case GIMPLE_OMP_TASK: \
6766 case GIMPLE_OMP_FOR: \
6767 case GIMPLE_OMP_SECTIONS: \
6768 case GIMPLE_OMP_SECTIONS_SWITCH: \
6769 case GIMPLE_OMP_SINGLE: \
6770 case GIMPLE_OMP_TARGET: \
6771 case GIMPLE_OMP_TEAMS: \
6772 case GIMPLE_OMP_SCOPE: \
6773 case GIMPLE_OMP_SECTION: \
6774 case GIMPLE_OMP_STRUCTURED_BLOCK: \
6775 case GIMPLE_OMP_MASTER: \
6776 case GIMPLE_OMP_MASKED: \
6777 case GIMPLE_OMP_TASKGROUP: \
6778 case GIMPLE_OMP_ORDERED: \
6779 case GIMPLE_OMP_CRITICAL: \
6780 case GIMPLE_OMP_SCAN: \
6781 case GIMPLE_OMP_RETURN: \
6782 case GIMPLE_OMP_ATOMIC_LOAD: \
6783 case GIMPLE_OMP_ATOMIC_STORE: \
6784 case GIMPLE_OMP_CONTINUE
6786 inline bool
6787 is_gimple_omp (const gimple *stmt)
6789 switch (gimple_code (stmt))
6791 CASE_GIMPLE_OMP:
6792 return true;
6793 default:
6794 return false;
6798 /* Return true if the OMP gimple statement STMT is any of the OpenACC types
6799 specifically. */
6801 inline bool
6802 is_gimple_omp_oacc (const gimple *stmt)
6804 gcc_assert (is_gimple_omp (stmt));
6805 switch (gimple_code (stmt))
6807 case GIMPLE_OMP_ATOMIC_LOAD:
6808 case GIMPLE_OMP_ATOMIC_STORE:
6809 case GIMPLE_OMP_CONTINUE:
6810 case GIMPLE_OMP_RETURN:
6811 /* Codes shared between OpenACC and OpenMP cannot be used to disambiguate
6812 the two. */
6813 gcc_unreachable ();
6815 case GIMPLE_OMP_FOR:
6816 switch (gimple_omp_for_kind (stmt))
6818 case GF_OMP_FOR_KIND_OACC_LOOP:
6819 return true;
6820 default:
6821 return false;
6823 case GIMPLE_OMP_TARGET:
6824 switch (gimple_omp_target_kind (stmt))
6826 case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6827 case GF_OMP_TARGET_KIND_OACC_KERNELS:
6828 case GF_OMP_TARGET_KIND_OACC_SERIAL:
6829 case GF_OMP_TARGET_KIND_OACC_DATA:
6830 case GF_OMP_TARGET_KIND_OACC_UPDATE:
6831 case GF_OMP_TARGET_KIND_OACC_ENTER_DATA:
6832 case GF_OMP_TARGET_KIND_OACC_EXIT_DATA:
6833 case GF_OMP_TARGET_KIND_OACC_DECLARE:
6834 case GF_OMP_TARGET_KIND_OACC_HOST_DATA:
6835 case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
6836 case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
6837 case GF_OMP_TARGET_KIND_OACC_DATA_KERNELS:
6838 return true;
6839 default:
6840 return false;
6842 default:
6843 return false;
6848 /* Return true if the OMP gimple statement STMT is offloaded. */
6850 inline bool
6851 is_gimple_omp_offloaded (const gimple *stmt)
6853 gcc_assert (is_gimple_omp (stmt));
6854 switch (gimple_code (stmt))
6856 case GIMPLE_OMP_TARGET:
6857 switch (gimple_omp_target_kind (stmt))
6859 case GF_OMP_TARGET_KIND_REGION:
6860 case GF_OMP_TARGET_KIND_OACC_PARALLEL:
6861 case GF_OMP_TARGET_KIND_OACC_KERNELS:
6862 case GF_OMP_TARGET_KIND_OACC_SERIAL:
6863 case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_PARALLELIZED:
6864 case GF_OMP_TARGET_KIND_OACC_PARALLEL_KERNELS_GANG_SINGLE:
6865 return true;
6866 default:
6867 return false;
6869 default:
6870 return false;
6875 /* Returns TRUE if statement G is a GIMPLE_NOP. */
6877 inline bool
6878 gimple_nop_p (const gimple *g)
6880 return gimple_code (g) == GIMPLE_NOP;
6884 /* Return true if GS is a GIMPLE_RESX. */
6886 inline bool
6887 is_gimple_resx (const gimple *gs)
6889 return gimple_code (gs) == GIMPLE_RESX;
6893 /* Enum and arrays used for allocation stats. Keep in sync with
6894 gimple.cc:gimple_alloc_kind_names. */
6895 enum gimple_alloc_kind
6897 gimple_alloc_kind_assign, /* Assignments. */
6898 gimple_alloc_kind_phi, /* PHI nodes. */
6899 gimple_alloc_kind_cond, /* Conditionals. */
6900 gimple_alloc_kind_rest, /* Everything else. */
6901 gimple_alloc_kind_all
6904 extern uint64_t gimple_alloc_counts[];
6905 extern uint64_t gimple_alloc_sizes[];
6907 /* Return the allocation kind for a given stmt CODE. */
6908 inline enum gimple_alloc_kind
6909 gimple_alloc_kind (enum gimple_code code)
6911 switch (code)
6913 case GIMPLE_ASSIGN:
6914 return gimple_alloc_kind_assign;
6915 case GIMPLE_PHI:
6916 return gimple_alloc_kind_phi;
6917 case GIMPLE_COND:
6918 return gimple_alloc_kind_cond;
6919 default:
6920 return gimple_alloc_kind_rest;
6924 /* Return true if a location should not be emitted for this statement
6925 by annotate_all_with_location. */
6927 inline bool
6928 gimple_do_not_emit_location_p (gimple *g)
6930 return gimple_plf (g, GF_PLF_1);
6933 /* Mark statement G so a location will not be emitted by
6934 annotate_one_with_location. */
6936 inline void
6937 gimple_set_do_not_emit_location (gimple *g)
6939 /* The PLF flags are initialized to 0 when a new tuple is created,
6940 so no need to initialize it anywhere. */
6941 gimple_set_plf (g, GF_PLF_1, true);
6944 #endif /* GCC_GIMPLE_H */