1 /* Gimple IR definitions.
3 Copyright (C) 2007-2019 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
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
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/>. */
25 #include "tree-ssa-alias.h"
26 #include "gimple-expr.h"
28 typedef gimple
*gimple_seq_node
;
31 #define DEFGSCODE(SYM, STRING, STRUCT) SYM,
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 \
52 #define GIMPLE_CHECK(GS, CODE) \
54 const gimple *__gs = (GS); \
55 if (gimple_code (__gs) != (CODE)) \
56 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \
57 (CODE), ERROR_MARK); \
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 ())
67 const char *file
= __FILE__
,
69 const char *fun
= NULL
)
72 T ret
= dyn_cast
<T
> (gs
);
74 gimple_check_failed (gs
, file
, line
, fun
,
75 remove_pointer
<T
>::type::code_
, ERROR_MARK
);
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 ())
86 const char *file
= __FILE__
,
88 const char *fun
= NULL
)
91 T ret
= dyn_cast
<T
> (gs
);
93 gimple_check_failed (gs
, file
, line
, fun
,
94 remove_pointer
<T
>::type::code_
, ERROR_MARK
);
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
>
102 GIMPLE_CHECK2(gimple
*gs
)
104 return as_a
<T
> (gs
);
106 template <typename T
>
108 GIMPLE_CHECK2(const gimple
*gs
)
110 return as_a
<T
> (gs
);
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. */
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_OMP_PARALLEL_COMBINED
= 1 << 0,
153 GF_OMP_PARALLEL_GRID_PHONY
= 1 << 1,
154 GF_OMP_TASK_TASKLOOP
= 1 << 0,
155 GF_OMP_TASK_TASKWAIT
= 1 << 1,
156 GF_OMP_FOR_KIND_MASK
= (1 << 4) - 1,
157 GF_OMP_FOR_KIND_FOR
= 0,
158 GF_OMP_FOR_KIND_DISTRIBUTE
= 1,
159 GF_OMP_FOR_KIND_TASKLOOP
= 2,
160 GF_OMP_FOR_KIND_OACC_LOOP
= 4,
161 GF_OMP_FOR_KIND_GRID_LOOP
= 5,
162 /* Flag for SIMD variants of OMP_FOR kinds. */
163 GF_OMP_FOR_SIMD
= 1 << 3,
164 GF_OMP_FOR_KIND_SIMD
= GF_OMP_FOR_SIMD
| 0,
165 GF_OMP_FOR_COMBINED
= 1 << 4,
166 GF_OMP_FOR_COMBINED_INTO
= 1 << 5,
167 /* The following flag must not be used on GF_OMP_FOR_KIND_GRID_LOOP loop
169 GF_OMP_FOR_GRID_PHONY
= 1 << 6,
170 /* The following two flags should only be set on GF_OMP_FOR_KIND_GRID_LOOP
172 GF_OMP_FOR_GRID_INTRA_GROUP
= 1 << 6,
173 GF_OMP_FOR_GRID_GROUP_ITER
= 1 << 7,
174 GF_OMP_TARGET_KIND_MASK
= (1 << 4) - 1,
175 GF_OMP_TARGET_KIND_REGION
= 0,
176 GF_OMP_TARGET_KIND_DATA
= 1,
177 GF_OMP_TARGET_KIND_UPDATE
= 2,
178 GF_OMP_TARGET_KIND_ENTER_DATA
= 3,
179 GF_OMP_TARGET_KIND_EXIT_DATA
= 4,
180 GF_OMP_TARGET_KIND_OACC_PARALLEL
= 5,
181 GF_OMP_TARGET_KIND_OACC_KERNELS
= 6,
182 GF_OMP_TARGET_KIND_OACC_DATA
= 7,
183 GF_OMP_TARGET_KIND_OACC_UPDATE
= 8,
184 GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
= 9,
185 GF_OMP_TARGET_KIND_OACC_DECLARE
= 10,
186 GF_OMP_TARGET_KIND_OACC_HOST_DATA
= 11,
187 GF_OMP_TEAMS_GRID_PHONY
= 1 << 0,
188 GF_OMP_TEAMS_HOST
= 1 << 1,
190 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
191 a thread synchronization via some sort of barrier. The exact barrier
192 that would otherwise be emitted is dependent on the OMP statement with
193 which this return is associated. */
194 GF_OMP_RETURN_NOWAIT
= 1 << 0,
196 GF_OMP_SECTION_LAST
= 1 << 0,
197 GF_OMP_ATOMIC_MEMORY_ORDER
= (1 << 3) - 1,
198 GF_OMP_ATOMIC_NEED_VALUE
= 1 << 3,
199 GF_PREDICT_TAKEN
= 1 << 15
202 /* This subcode tells apart different kinds of stmts that are not used
203 for codegen, but rather to retain debug information. */
204 enum gimple_debug_subcode
{
205 GIMPLE_DEBUG_BIND
= 0,
206 GIMPLE_DEBUG_SOURCE_BIND
= 1,
207 GIMPLE_DEBUG_BEGIN_STMT
= 2,
208 GIMPLE_DEBUG_INLINE_ENTRY
= 3
211 /* Masks for selecting a pass local flag (PLF) to work on. These
212 masks are used by gimple_set_plf and gimple_plf. */
218 /* Data structure definitions for GIMPLE tuples. NOTE: word markers
219 are for 64 bit hosts. */
221 struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
222 chain_next ("%h.next"), variable_size
))
226 Main identifying code for a tuple. */
227 ENUM_BITFIELD(gimple_code
) code
: 8;
229 /* Nonzero if a warning should not be emitted on this tuple. */
230 unsigned int no_warning
: 1;
232 /* Nonzero if this tuple has been visited. Passes are responsible
233 for clearing this bit before using it. */
234 unsigned int visited
: 1;
236 /* Nonzero if this tuple represents a non-temporal move. */
237 unsigned int nontemporal_move
: 1;
239 /* Pass local flags. These flags are free for any pass to use as
240 they see fit. Passes should not assume that these flags contain
241 any useful value when the pass starts. Any initial state that
242 the pass requires should be set on entry to the pass. See
243 gimple_set_plf and gimple_plf for usage. */
244 unsigned int plf
: 2;
246 /* Nonzero if this statement has been modified and needs to have its
247 operands rescanned. */
248 unsigned modified
: 1;
250 /* Nonzero if this statement contains volatile operands. */
251 unsigned has_volatile_ops
: 1;
253 /* Padding to get subcode to 16 bit alignment. */
256 /* The SUBCODE field can be used for tuple-specific flags for tuples
257 that do not require subcodes. Note that SUBCODE should be at
258 least as wide as tree codes, as several tuples store tree codes
260 unsigned int subcode
: 16;
262 /* UID of this statement. This is used by passes that want to
263 assign IDs to statements. It must be assigned and used by each
264 pass. By default it should be assumed to contain garbage. */
268 Locus information for debug info. */
271 /* Number of operands in this tuple. */
275 Basic block holding this statement. */
279 Linked lists of gimple statements. The next pointers form
280 a NULL terminated list, the prev pointers are a cyclic list.
281 A gimple statement is hence also a double-ended list of
282 statements, with the pointer itself being the first element,
283 and the prev pointer being the last. */
285 gimple
*GTY((skip
)) prev
;
289 /* Base structure for tuples with operands. */
291 /* This gimple subclass has no tag value. */
293 gimple_statement_with_ops_base
: public gimple
295 /* [ WORD 1-6 ] : base class */
298 SSA operand vectors. NOTE: It should be possible to
299 amalgamate these vectors with the operand vector OP. However,
300 the SSA operand vectors are organized differently and contain
301 more information (like immediate use chaining). */
302 struct use_optype_d
GTY((skip (""))) *use_ops
;
306 /* Statements that take register operands. */
308 struct GTY((tag("GSS_WITH_OPS")))
309 gimple_statement_with_ops
: public gimple_statement_with_ops_base
311 /* [ WORD 1-7 ] : base class */
314 Operand vector. NOTE! This must always be the last field
315 of this structure. In particular, this means that this
316 structure cannot be embedded inside another one. */
317 tree
GTY((length ("%h.num_ops"))) op
[1];
321 /* Base for statements that take both memory and register operands. */
323 struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
324 gimple_statement_with_memory_ops_base
: public gimple_statement_with_ops_base
326 /* [ WORD 1-7 ] : base class */
329 Virtual operands for this statement. The GC will pick them
330 up via the ssa_names array. */
331 tree
GTY((skip (""))) vdef
;
332 tree
GTY((skip (""))) vuse
;
336 /* Statements that take both memory and register operands. */
338 struct GTY((tag("GSS_WITH_MEM_OPS")))
339 gimple_statement_with_memory_ops
:
340 public gimple_statement_with_memory_ops_base
342 /* [ WORD 1-9 ] : base class */
345 Operand vector. NOTE! This must always be the last field
346 of this structure. In particular, this means that this
347 structure cannot be embedded inside another one. */
348 tree
GTY((length ("%h.num_ops"))) op
[1];
352 /* Call statements that take both memory and register operands. */
354 struct GTY((tag("GSS_CALL")))
355 gcall
: public gimple_statement_with_memory_ops_base
357 /* [ WORD 1-9 ] : base class */
360 struct pt_solution call_used
;
361 struct pt_solution call_clobbered
;
364 union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
365 tree
GTY ((tag ("0"))) fntype
;
366 enum internal_fn
GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn
;
370 Operand vector. NOTE! This must always be the last field
371 of this structure. In particular, this means that this
372 structure cannot be embedded inside another one. */
373 tree
GTY((length ("%h.num_ops"))) op
[1];
375 static const enum gimple_code code_
= GIMPLE_CALL
;
379 /* OMP statements. */
381 struct GTY((tag("GSS_OMP")))
382 gimple_statement_omp
: public gimple
384 /* [ WORD 1-6 ] : base class */
393 struct GTY((tag("GSS_BIND")))
394 gbind
: public gimple
396 /* [ WORD 1-6 ] : base class */
399 Variables declared in this scope. */
403 This is different than the BLOCK field in gimple,
404 which is analogous to TREE_BLOCK (i.e., the lexical block holding
405 this statement). This field is the equivalent of BIND_EXPR_BLOCK
406 in tree land (i.e., the lexical scope defined by this bind). See
417 struct GTY((tag("GSS_CATCH")))
418 gcatch
: public gimple
420 /* [ WORD 1-6 ] : base class */
430 /* GIMPLE_EH_FILTER */
432 struct GTY((tag("GSS_EH_FILTER")))
433 geh_filter
: public gimple
435 /* [ WORD 1-6 ] : base class */
448 struct GTY((tag("GSS_EH_ELSE")))
449 geh_else
: public gimple
451 /* [ WORD 1-6 ] : base class */
454 gimple_seq n_body
, e_body
;
457 /* GIMPLE_EH_MUST_NOT_THROW */
459 struct GTY((tag("GSS_EH_MNT")))
460 geh_mnt
: public gimple
462 /* [ WORD 1-6 ] : base class */
464 /* [ WORD 7 ] Abort function decl. */
470 struct GTY((tag("GSS_PHI")))
473 /* [ WORD 1-6 ] : base class */
483 struct phi_arg_d
GTY ((length ("%h.nargs"))) args
[1];
487 /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
489 struct GTY((tag("GSS_EH_CTRL")))
490 gimple_statement_eh_ctrl
: public gimple
492 /* [ WORD 1-6 ] : base class */
495 Exception region number. */
499 struct GTY((tag("GSS_EH_CTRL")))
500 gresx
: public gimple_statement_eh_ctrl
502 /* No extra fields; adds invariant:
503 stmt->code == GIMPLE_RESX. */
506 struct GTY((tag("GSS_EH_CTRL")))
507 geh_dispatch
: public gimple_statement_eh_ctrl
509 /* No extra fields; adds invariant:
510 stmt->code == GIMPLE_EH_DISPATH. */
516 struct GTY((tag("GSS_TRY")))
519 /* [ WORD 1-6 ] : base class */
522 Expression to evaluate. */
526 Cleanup expression. */
530 /* Kind of GIMPLE_TRY statements. */
531 enum gimple_try_flags
534 GIMPLE_TRY_CATCH
= 1 << 0,
537 GIMPLE_TRY_FINALLY
= 1 << 1,
538 GIMPLE_TRY_KIND
= GIMPLE_TRY_CATCH
| GIMPLE_TRY_FINALLY
,
540 /* Analogous to TRY_CATCH_IS_CLEANUP. */
541 GIMPLE_TRY_CATCH_IS_CLEANUP
= 1 << 2
544 /* GIMPLE_WITH_CLEANUP_EXPR */
546 struct GTY((tag("GSS_WCE")))
547 gimple_statement_wce
: public gimple
549 /* [ WORD 1-6 ] : base class */
551 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
552 executed if an exception is thrown, not on normal exit of its
553 scope. This flag is analogous to the CLEANUP_EH_ONLY flag
557 Cleanup expression. */
564 struct GTY((tag("GSS_ASM")))
565 gasm
: public gimple_statement_with_memory_ops_base
567 /* [ WORD 1-9 ] : base class */
570 __asm__ statement. */
574 Number of inputs, outputs, clobbers, labels. */
581 Operand vector. NOTE! This must always be the last field
582 of this structure. In particular, this means that this
583 structure cannot be embedded inside another one. */
584 tree
GTY((length ("%h.num_ops"))) op
[1];
587 /* GIMPLE_OMP_CRITICAL */
589 struct GTY((tag("GSS_OMP_CRITICAL")))
590 gomp_critical
: public gimple_statement_omp
592 /* [ WORD 1-7 ] : base class */
598 Critical section name. */
603 struct GTY(()) gimple_omp_for_iter
{
604 /* Condition code. */
607 /* Index variable. */
622 struct GTY((tag("GSS_OMP_FOR")))
623 gomp_for
: public gimple_statement_omp
625 /* [ WORD 1-7 ] : base class */
631 Number of elements in iter array. */
635 struct gimple_omp_for_iter
* GTY((length ("%h.collapse"))) iter
;
638 Pre-body evaluated before the loop body begins. */
643 /* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
645 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
646 gimple_statement_omp_parallel_layout
: public gimple_statement_omp
648 /* [ WORD 1-7 ] : base class */
655 Child function holding the body of the parallel region. */
659 Shared data argument. */
663 /* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
664 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
665 gimple_statement_omp_taskreg
: public gimple_statement_omp_parallel_layout
667 /* No extra fields; adds invariant:
668 stmt->code == GIMPLE_OMP_PARALLEL
669 || stmt->code == GIMPLE_OMP_TASK
670 || stmt->code == GIMPLE_OMP_TEAMS. */
673 /* GIMPLE_OMP_PARALLEL */
674 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
675 gomp_parallel
: public gimple_statement_omp_taskreg
677 /* No extra fields; adds invariant:
678 stmt->code == GIMPLE_OMP_PARALLEL. */
681 /* GIMPLE_OMP_TARGET */
682 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
683 gomp_target
: public gimple_statement_omp_parallel_layout
685 /* No extra fields; adds invariant:
686 stmt->code == GIMPLE_OMP_TARGET. */
689 /* GIMPLE_OMP_TASK */
691 struct GTY((tag("GSS_OMP_TASK")))
692 gomp_task
: public gimple_statement_omp_taskreg
694 /* [ WORD 1-10 ] : base class */
697 Child function holding firstprivate initialization if needed. */
701 Size and alignment in bytes of the argument data block. */
707 /* GIMPLE_OMP_SECTION */
708 /* Uses struct gimple_statement_omp. */
711 /* GIMPLE_OMP_SECTIONS */
713 struct GTY((tag("GSS_OMP_SECTIONS")))
714 gomp_sections
: public gimple_statement_omp
716 /* [ WORD 1-7 ] : base class */
722 The control variable used for deciding which of the sections to
727 /* GIMPLE_OMP_CONTINUE.
729 Note: This does not inherit from gimple_statement_omp, because we
730 do not need the body field. */
732 struct GTY((tag("GSS_OMP_CONTINUE")))
733 gomp_continue
: public gimple
735 /* [ WORD 1-6 ] : base class */
744 /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP. */
746 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
747 gimple_statement_omp_single_layout
: public gimple_statement_omp
749 /* [ WORD 1-7 ] : base class */
755 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
756 gomp_single
: public gimple_statement_omp_single_layout
758 /* No extra fields; adds invariant:
759 stmt->code == GIMPLE_OMP_SINGLE. */
762 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
763 gomp_teams
: public gimple_statement_omp_taskreg
765 /* No extra fields; adds invariant:
766 stmt->code == GIMPLE_OMP_TEAMS. */
769 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
770 gomp_ordered
: public gimple_statement_omp_single_layout
772 /* No extra fields; adds invariant:
773 stmt->code == GIMPLE_OMP_ORDERED. */
777 /* GIMPLE_OMP_ATOMIC_LOAD.
778 Note: This is based on gimple, not g_s_omp, because g_s_omp
779 contains a sequence, which we don't need here. */
781 struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
782 gomp_atomic_load
: public gimple
784 /* [ WORD 1-6 ] : base class */
790 /* GIMPLE_OMP_ATOMIC_STORE.
791 See note on GIMPLE_OMP_ATOMIC_LOAD. */
793 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
794 gimple_statement_omp_atomic_store_layout
: public gimple
796 /* [ WORD 1-6 ] : base class */
802 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
804 public gimple_statement_omp_atomic_store_layout
806 /* No extra fields; adds invariant:
807 stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
810 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
811 gimple_statement_omp_return
:
812 public gimple_statement_omp_atomic_store_layout
814 /* No extra fields; adds invariant:
815 stmt->code == GIMPLE_OMP_RETURN. */
818 /* GIMPLE_TRANSACTION. */
820 /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
822 /* The __transaction_atomic was declared [[outer]] or it is
823 __transaction_relaxed. */
824 #define GTMA_IS_OUTER (1u << 0)
825 #define GTMA_IS_RELAXED (1u << 1)
826 #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)
828 /* The transaction is seen to not have an abort. */
829 #define GTMA_HAVE_ABORT (1u << 2)
830 /* The transaction is seen to have loads or stores. */
831 #define GTMA_HAVE_LOAD (1u << 3)
832 #define GTMA_HAVE_STORE (1u << 4)
833 /* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
834 #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)
835 /* The transaction WILL enter serial irrevocable mode.
836 An irrevocable block post-dominates the entire transaction, such
837 that all invocations of the transaction will go serial-irrevocable.
838 In such case, we don't bother instrumenting the transaction, and
839 tell the runtime that it should begin the transaction in
840 serial-irrevocable mode. */
841 #define GTMA_DOES_GO_IRREVOCABLE (1u << 6)
842 /* The transaction contains no instrumentation code whatsover, most
843 likely because it is guaranteed to go irrevocable upon entry. */
844 #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
846 struct GTY((tag("GSS_TRANSACTION")))
847 gtransaction
: public gimple_statement_with_memory_ops_base
849 /* [ WORD 1-9 ] : base class */
860 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
861 enum gimple_statement_structure_enum
{
862 #include "gsstruct.def"
867 /* A statement with the invariant that
868 stmt->code == GIMPLE_COND
869 i.e. a conditional jump statement. */
871 struct GTY((tag("GSS_WITH_OPS")))
872 gcond
: public gimple_statement_with_ops
874 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
875 static const enum gimple_code code_
= GIMPLE_COND
;
878 /* A statement with the invariant that
879 stmt->code == GIMPLE_DEBUG
880 i.e. a debug statement. */
882 struct GTY((tag("GSS_WITH_OPS")))
883 gdebug
: public gimple_statement_with_ops
885 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
888 /* A statement with the invariant that
889 stmt->code == GIMPLE_GOTO
890 i.e. a goto statement. */
892 struct GTY((tag("GSS_WITH_OPS")))
893 ggoto
: public gimple_statement_with_ops
895 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
898 /* A statement with the invariant that
899 stmt->code == GIMPLE_LABEL
900 i.e. a label statement. */
902 struct GTY((tag("GSS_WITH_OPS")))
903 glabel
: public gimple_statement_with_ops
905 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
908 /* A statement with the invariant that
909 stmt->code == GIMPLE_SWITCH
910 i.e. a switch statement. */
912 struct GTY((tag("GSS_WITH_OPS")))
913 gswitch
: public gimple_statement_with_ops
915 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
918 /* A statement with the invariant that
919 stmt->code == GIMPLE_ASSIGN
920 i.e. an assignment statement. */
922 struct GTY((tag("GSS_WITH_MEM_OPS")))
923 gassign
: public gimple_statement_with_memory_ops
925 static const enum gimple_code code_
= GIMPLE_ASSIGN
;
926 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
929 /* A statement with the invariant that
930 stmt->code == GIMPLE_RETURN
931 i.e. a return statement. */
933 struct GTY((tag("GSS_WITH_MEM_OPS")))
934 greturn
: public gimple_statement_with_memory_ops
936 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
942 is_a_helper
<gasm
*>::test (gimple
*gs
)
944 return gs
->code
== GIMPLE_ASM
;
950 is_a_helper
<gassign
*>::test (gimple
*gs
)
952 return gs
->code
== GIMPLE_ASSIGN
;
958 is_a_helper
<const gassign
*>::test (const gimple
*gs
)
960 return gs
->code
== GIMPLE_ASSIGN
;
966 is_a_helper
<gbind
*>::test (gimple
*gs
)
968 return gs
->code
== GIMPLE_BIND
;
974 is_a_helper
<gcall
*>::test (gimple
*gs
)
976 return gs
->code
== GIMPLE_CALL
;
982 is_a_helper
<gcatch
*>::test (gimple
*gs
)
984 return gs
->code
== GIMPLE_CATCH
;
990 is_a_helper
<gcond
*>::test (gimple
*gs
)
992 return gs
->code
== GIMPLE_COND
;
998 is_a_helper
<const gcond
*>::test (const gimple
*gs
)
1000 return gs
->code
== GIMPLE_COND
;
1006 is_a_helper
<gdebug
*>::test (gimple
*gs
)
1008 return gs
->code
== GIMPLE_DEBUG
;
1014 is_a_helper
<ggoto
*>::test (gimple
*gs
)
1016 return gs
->code
== GIMPLE_GOTO
;
1022 is_a_helper
<glabel
*>::test (gimple
*gs
)
1024 return gs
->code
== GIMPLE_LABEL
;
1030 is_a_helper
<gresx
*>::test (gimple
*gs
)
1032 return gs
->code
== GIMPLE_RESX
;
1038 is_a_helper
<geh_dispatch
*>::test (gimple
*gs
)
1040 return gs
->code
== GIMPLE_EH_DISPATCH
;
1046 is_a_helper
<geh_else
*>::test (gimple
*gs
)
1048 return gs
->code
== GIMPLE_EH_ELSE
;
1054 is_a_helper
<geh_filter
*>::test (gimple
*gs
)
1056 return gs
->code
== GIMPLE_EH_FILTER
;
1062 is_a_helper
<geh_mnt
*>::test (gimple
*gs
)
1064 return gs
->code
== GIMPLE_EH_MUST_NOT_THROW
;
1070 is_a_helper
<gomp_atomic_load
*>::test (gimple
*gs
)
1072 return gs
->code
== GIMPLE_OMP_ATOMIC_LOAD
;
1078 is_a_helper
<gomp_atomic_store
*>::test (gimple
*gs
)
1080 return gs
->code
== GIMPLE_OMP_ATOMIC_STORE
;
1086 is_a_helper
<gimple_statement_omp_return
*>::test (gimple
*gs
)
1088 return gs
->code
== GIMPLE_OMP_RETURN
;
1094 is_a_helper
<gomp_continue
*>::test (gimple
*gs
)
1096 return gs
->code
== GIMPLE_OMP_CONTINUE
;
1102 is_a_helper
<gomp_critical
*>::test (gimple
*gs
)
1104 return gs
->code
== GIMPLE_OMP_CRITICAL
;
1110 is_a_helper
<gomp_ordered
*>::test (gimple
*gs
)
1112 return gs
->code
== GIMPLE_OMP_ORDERED
;
1118 is_a_helper
<gomp_for
*>::test (gimple
*gs
)
1120 return gs
->code
== GIMPLE_OMP_FOR
;
1126 is_a_helper
<gimple_statement_omp_taskreg
*>::test (gimple
*gs
)
1128 return (gs
->code
== GIMPLE_OMP_PARALLEL
1129 || gs
->code
== GIMPLE_OMP_TASK
1130 || gs
->code
== GIMPLE_OMP_TEAMS
);
1136 is_a_helper
<gomp_parallel
*>::test (gimple
*gs
)
1138 return gs
->code
== GIMPLE_OMP_PARALLEL
;
1144 is_a_helper
<gomp_target
*>::test (gimple
*gs
)
1146 return gs
->code
== GIMPLE_OMP_TARGET
;
1152 is_a_helper
<gomp_sections
*>::test (gimple
*gs
)
1154 return gs
->code
== GIMPLE_OMP_SECTIONS
;
1160 is_a_helper
<gomp_single
*>::test (gimple
*gs
)
1162 return gs
->code
== GIMPLE_OMP_SINGLE
;
1168 is_a_helper
<gomp_teams
*>::test (gimple
*gs
)
1170 return gs
->code
== GIMPLE_OMP_TEAMS
;
1176 is_a_helper
<gomp_task
*>::test (gimple
*gs
)
1178 return gs
->code
== GIMPLE_OMP_TASK
;
1184 is_a_helper
<gphi
*>::test (gimple
*gs
)
1186 return gs
->code
== GIMPLE_PHI
;
1192 is_a_helper
<greturn
*>::test (gimple
*gs
)
1194 return gs
->code
== GIMPLE_RETURN
;
1200 is_a_helper
<gswitch
*>::test (gimple
*gs
)
1202 return gs
->code
== GIMPLE_SWITCH
;
1208 is_a_helper
<gtransaction
*>::test (gimple
*gs
)
1210 return gs
->code
== GIMPLE_TRANSACTION
;
1216 is_a_helper
<gtry
*>::test (gimple
*gs
)
1218 return gs
->code
== GIMPLE_TRY
;
1224 is_a_helper
<gimple_statement_wce
*>::test (gimple
*gs
)
1226 return gs
->code
== GIMPLE_WITH_CLEANUP_EXPR
;
1232 is_a_helper
<const gasm
*>::test (const gimple
*gs
)
1234 return gs
->code
== GIMPLE_ASM
;
1240 is_a_helper
<const gbind
*>::test (const gimple
*gs
)
1242 return gs
->code
== GIMPLE_BIND
;
1248 is_a_helper
<const gcall
*>::test (const gimple
*gs
)
1250 return gs
->code
== GIMPLE_CALL
;
1256 is_a_helper
<const gcatch
*>::test (const gimple
*gs
)
1258 return gs
->code
== GIMPLE_CATCH
;
1264 is_a_helper
<const gresx
*>::test (const gimple
*gs
)
1266 return gs
->code
== GIMPLE_RESX
;
1272 is_a_helper
<const geh_dispatch
*>::test (const gimple
*gs
)
1274 return gs
->code
== GIMPLE_EH_DISPATCH
;
1280 is_a_helper
<const geh_filter
*>::test (const gimple
*gs
)
1282 return gs
->code
== GIMPLE_EH_FILTER
;
1288 is_a_helper
<const gomp_atomic_load
*>::test (const gimple
*gs
)
1290 return gs
->code
== GIMPLE_OMP_ATOMIC_LOAD
;
1296 is_a_helper
<const gomp_atomic_store
*>::test (const gimple
*gs
)
1298 return gs
->code
== GIMPLE_OMP_ATOMIC_STORE
;
1304 is_a_helper
<const gimple_statement_omp_return
*>::test (const gimple
*gs
)
1306 return gs
->code
== GIMPLE_OMP_RETURN
;
1312 is_a_helper
<const gomp_continue
*>::test (const gimple
*gs
)
1314 return gs
->code
== GIMPLE_OMP_CONTINUE
;
1320 is_a_helper
<const gomp_critical
*>::test (const gimple
*gs
)
1322 return gs
->code
== GIMPLE_OMP_CRITICAL
;
1328 is_a_helper
<const gomp_ordered
*>::test (const gimple
*gs
)
1330 return gs
->code
== GIMPLE_OMP_ORDERED
;
1336 is_a_helper
<const gomp_for
*>::test (const gimple
*gs
)
1338 return gs
->code
== GIMPLE_OMP_FOR
;
1344 is_a_helper
<const gimple_statement_omp_taskreg
*>::test (const gimple
*gs
)
1346 return (gs
->code
== GIMPLE_OMP_PARALLEL
1347 || gs
->code
== GIMPLE_OMP_TASK
1348 || gs
->code
== GIMPLE_OMP_TEAMS
);
1354 is_a_helper
<const gomp_parallel
*>::test (const gimple
*gs
)
1356 return gs
->code
== GIMPLE_OMP_PARALLEL
;
1362 is_a_helper
<const gomp_target
*>::test (const gimple
*gs
)
1364 return gs
->code
== GIMPLE_OMP_TARGET
;
1370 is_a_helper
<const gomp_sections
*>::test (const gimple
*gs
)
1372 return gs
->code
== GIMPLE_OMP_SECTIONS
;
1378 is_a_helper
<const gomp_single
*>::test (const gimple
*gs
)
1380 return gs
->code
== GIMPLE_OMP_SINGLE
;
1386 is_a_helper
<const gomp_teams
*>::test (const gimple
*gs
)
1388 return gs
->code
== GIMPLE_OMP_TEAMS
;
1394 is_a_helper
<const gomp_task
*>::test (const gimple
*gs
)
1396 return gs
->code
== GIMPLE_OMP_TASK
;
1402 is_a_helper
<const gphi
*>::test (const gimple
*gs
)
1404 return gs
->code
== GIMPLE_PHI
;
1410 is_a_helper
<const gtransaction
*>::test (const gimple
*gs
)
1412 return gs
->code
== GIMPLE_TRANSACTION
;
1415 /* Offset in bytes to the location of the operand vector.
1416 Zero if there is no operand vector for this tuple structure. */
1417 extern size_t const gimple_ops_offset_
[];
1419 /* Map GIMPLE codes to GSS codes. */
1420 extern enum gimple_statement_structure_enum
const gss_for_code_
[];
1422 /* This variable holds the currently expanded gimple statement for purposes
1423 of comminucating the profile info to the builtin expanders. */
1424 extern gimple
*currently_expanding_gimple_stmt
;
1426 gimple
*gimple_alloc (enum gimple_code
, unsigned CXX_MEM_STAT_INFO
);
1427 greturn
*gimple_build_return (tree
);
1428 void gimple_call_reset_alias_info (gcall
*);
1429 gcall
*gimple_build_call_vec (tree
, vec
<tree
> );
1430 gcall
*gimple_build_call (tree
, unsigned, ...);
1431 gcall
*gimple_build_call_valist (tree
, unsigned, va_list);
1432 gcall
*gimple_build_call_internal (enum internal_fn
, unsigned, ...);
1433 gcall
*gimple_build_call_internal_vec (enum internal_fn
, vec
<tree
> );
1434 gcall
*gimple_build_call_from_tree (tree
, tree
);
1435 gassign
*gimple_build_assign (tree
, tree CXX_MEM_STAT_INFO
);
1436 gassign
*gimple_build_assign (tree
, enum tree_code
,
1437 tree
, tree
, tree CXX_MEM_STAT_INFO
);
1438 gassign
*gimple_build_assign (tree
, enum tree_code
,
1439 tree
, tree CXX_MEM_STAT_INFO
);
1440 gassign
*gimple_build_assign (tree
, enum tree_code
, tree CXX_MEM_STAT_INFO
);
1441 gcond
*gimple_build_cond (enum tree_code
, tree
, tree
, tree
, tree
);
1442 gcond
*gimple_build_cond_from_tree (tree
, tree
, tree
);
1443 void gimple_cond_set_condition_from_tree (gcond
*, tree
);
1444 glabel
*gimple_build_label (tree label
);
1445 ggoto
*gimple_build_goto (tree dest
);
1446 gimple
*gimple_build_nop (void);
1447 gbind
*gimple_build_bind (tree
, gimple_seq
, tree
);
1448 gasm
*gimple_build_asm_vec (const char *, vec
<tree
, va_gc
> *,
1449 vec
<tree
, va_gc
> *, vec
<tree
, va_gc
> *,
1450 vec
<tree
, va_gc
> *);
1451 gcatch
*gimple_build_catch (tree
, gimple_seq
);
1452 geh_filter
*gimple_build_eh_filter (tree
, gimple_seq
);
1453 geh_mnt
*gimple_build_eh_must_not_throw (tree
);
1454 geh_else
*gimple_build_eh_else (gimple_seq
, gimple_seq
);
1455 gtry
*gimple_build_try (gimple_seq
, gimple_seq
,
1456 enum gimple_try_flags
);
1457 gimple
*gimple_build_wce (gimple_seq
);
1458 gresx
*gimple_build_resx (int);
1459 gswitch
*gimple_build_switch_nlabels (unsigned, tree
, tree
);
1460 gswitch
*gimple_build_switch (tree
, tree
, vec
<tree
> );
1461 geh_dispatch
*gimple_build_eh_dispatch (int);
1462 gdebug
*gimple_build_debug_bind (tree
, tree
, gimple
* CXX_MEM_STAT_INFO
);
1463 gdebug
*gimple_build_debug_source_bind (tree
, tree
, gimple
* CXX_MEM_STAT_INFO
);
1464 gdebug
*gimple_build_debug_begin_stmt (tree
, location_t CXX_MEM_STAT_INFO
);
1465 gdebug
*gimple_build_debug_inline_entry (tree
, location_t CXX_MEM_STAT_INFO
);
1466 gomp_critical
*gimple_build_omp_critical (gimple_seq
, tree
, tree
);
1467 gomp_for
*gimple_build_omp_for (gimple_seq
, int, tree
, size_t, gimple_seq
);
1468 gomp_parallel
*gimple_build_omp_parallel (gimple_seq
, tree
, tree
, tree
);
1469 gomp_task
*gimple_build_omp_task (gimple_seq
, tree
, tree
, tree
, tree
,
1471 gimple
*gimple_build_omp_section (gimple_seq
);
1472 gimple
*gimple_build_omp_master (gimple_seq
);
1473 gimple
*gimple_build_omp_grid_body (gimple_seq
);
1474 gimple
*gimple_build_omp_taskgroup (gimple_seq
, tree
);
1475 gomp_continue
*gimple_build_omp_continue (tree
, tree
);
1476 gomp_ordered
*gimple_build_omp_ordered (gimple_seq
, tree
);
1477 gimple
*gimple_build_omp_return (bool);
1478 gomp_sections
*gimple_build_omp_sections (gimple_seq
, tree
);
1479 gimple
*gimple_build_omp_sections_switch (void);
1480 gomp_single
*gimple_build_omp_single (gimple_seq
, tree
);
1481 gomp_target
*gimple_build_omp_target (gimple_seq
, int, tree
);
1482 gomp_teams
*gimple_build_omp_teams (gimple_seq
, tree
);
1483 gomp_atomic_load
*gimple_build_omp_atomic_load (tree
, tree
,
1484 enum omp_memory_order
);
1485 gomp_atomic_store
*gimple_build_omp_atomic_store (tree
, enum omp_memory_order
);
1486 gtransaction
*gimple_build_transaction (gimple_seq
);
1487 extern void gimple_seq_add_stmt (gimple_seq
*, gimple
*);
1488 extern void gimple_seq_add_stmt_without_update (gimple_seq
*, gimple
*);
1489 void gimple_seq_add_seq (gimple_seq
*, gimple_seq
);
1490 void gimple_seq_add_seq_without_update (gimple_seq
*, gimple_seq
);
1491 extern void annotate_all_with_location_after (gimple_seq
, gimple_stmt_iterator
,
1493 extern void annotate_all_with_location (gimple_seq
, location_t
);
1494 bool empty_body_p (gimple_seq
);
1495 gimple_seq
gimple_seq_copy (gimple_seq
);
1496 bool gimple_call_same_target_p (const gimple
*, const gimple
*);
1497 int gimple_call_flags (const gimple
*);
1498 int gimple_call_arg_flags (const gcall
*, unsigned);
1499 int gimple_call_return_flags (const gcall
*);
1500 bool gimple_call_nonnull_result_p (gcall
*);
1501 tree
gimple_call_nonnull_arg (gcall
*);
1502 bool gimple_assign_copy_p (gimple
*);
1503 bool gimple_assign_ssa_name_copy_p (gimple
*);
1504 bool gimple_assign_unary_nop_p (gimple
*);
1505 void gimple_set_bb (gimple
*, basic_block
);
1506 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*, tree
);
1507 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*, enum tree_code
,
1509 tree
gimple_get_lhs (const gimple
*);
1510 void gimple_set_lhs (gimple
*, tree
);
1511 gimple
*gimple_copy (gimple
*);
1512 bool gimple_has_side_effects (const gimple
*);
1513 bool gimple_could_trap_p_1 (gimple
*, bool, bool);
1514 bool gimple_could_trap_p (gimple
*);
1515 bool gimple_assign_rhs_could_trap_p (gimple
*);
1516 extern void dump_gimple_statistics (void);
1517 unsigned get_gimple_rhs_num_ops (enum tree_code
);
1518 extern tree
canonicalize_cond_expr_cond (tree
);
1519 gcall
*gimple_call_copy_skip_args (gcall
*, bitmap
);
1520 extern bool gimple_compare_field_offset (tree
, tree
);
1521 extern tree
gimple_unsigned_type (tree
);
1522 extern tree
gimple_signed_type (tree
);
1523 extern alias_set_type
gimple_get_alias_set (tree
);
1524 extern bool gimple_ior_addresses_taken (bitmap
, gimple
*);
1525 extern bool gimple_builtin_call_types_compatible_p (const gimple
*, tree
);
1526 extern combined_fn
gimple_call_combined_fn (const gimple
*);
1527 extern bool gimple_call_builtin_p (const gimple
*);
1528 extern bool gimple_call_builtin_p (const gimple
*, enum built_in_class
);
1529 extern bool gimple_call_builtin_p (const gimple
*, enum built_in_function
);
1530 extern bool gimple_asm_clobbers_memory_p (const gasm
*);
1531 extern void dump_decl_set (FILE *, bitmap
);
1532 extern bool nonfreeing_call_p (gimple
*);
1533 extern bool nonbarrier_call_p (gimple
*);
1534 extern bool infer_nonnull_range (gimple
*, tree
);
1535 extern bool infer_nonnull_range_by_dereference (gimple
*, tree
);
1536 extern bool infer_nonnull_range_by_attribute (gimple
*, tree
);
1537 extern void sort_case_labels (vec
<tree
>);
1538 extern void preprocess_case_label_vec_for_gimple (vec
<tree
>, tree
, tree
*);
1539 extern void gimple_seq_set_location (gimple_seq
, location_t
);
1540 extern void gimple_seq_discard (gimple_seq
);
1541 extern void maybe_remove_unused_call_args (struct function
*, gimple
*);
1542 extern bool gimple_inexpensive_call_p (gcall
*);
1543 extern bool stmt_can_terminate_bb_p (gimple
*);
1545 /* Formal (expression) temporary table handling: multiple occurrences of
1546 the same scalar expression are evaluated into the same temporary. */
1548 typedef struct gimple_temp_hash_elt
1551 tree temp
; /* Value */
1554 /* Get the number of the next statement uid to be allocated. */
1555 static inline unsigned int
1556 gimple_stmt_max_uid (struct function
*fn
)
1558 return fn
->last_stmt_uid
;
1561 /* Set the number of the next statement uid to be allocated. */
1563 set_gimple_stmt_max_uid (struct function
*fn
, unsigned int maxid
)
1565 fn
->last_stmt_uid
= maxid
;
1568 /* Set the number of the next statement uid to be allocated. */
1569 static inline unsigned int
1570 inc_gimple_stmt_max_uid (struct function
*fn
)
1572 return fn
->last_stmt_uid
++;
1575 /* Return the first node in GIMPLE sequence S. */
1577 static inline gimple_seq_node
1578 gimple_seq_first (gimple_seq s
)
1584 /* Return the first statement in GIMPLE sequence S. */
1586 static inline gimple
*
1587 gimple_seq_first_stmt (gimple_seq s
)
1589 gimple_seq_node n
= gimple_seq_first (s
);
1593 /* Return the first statement in GIMPLE sequence S as a gbind *,
1594 verifying that it has code GIMPLE_BIND in a checked build. */
1596 static inline gbind
*
1597 gimple_seq_first_stmt_as_a_bind (gimple_seq s
)
1599 gimple_seq_node n
= gimple_seq_first (s
);
1600 return as_a
<gbind
*> (n
);
1604 /* Return the last node in GIMPLE sequence S. */
1606 static inline gimple_seq_node
1607 gimple_seq_last (gimple_seq s
)
1609 return s
? s
->prev
: NULL
;
1613 /* Return the last statement in GIMPLE sequence S. */
1615 static inline gimple
*
1616 gimple_seq_last_stmt (gimple_seq s
)
1618 gimple_seq_node n
= gimple_seq_last (s
);
1623 /* Set the last node in GIMPLE sequence *PS to LAST. */
1626 gimple_seq_set_last (gimple_seq
*ps
, gimple_seq_node last
)
1632 /* Set the first node in GIMPLE sequence *PS to FIRST. */
1635 gimple_seq_set_first (gimple_seq
*ps
, gimple_seq_node first
)
1641 /* Return true if GIMPLE sequence S is empty. */
1644 gimple_seq_empty_p (gimple_seq s
)
1649 /* Allocate a new sequence and initialize its first element with STMT. */
1651 static inline gimple_seq
1652 gimple_seq_alloc_with_stmt (gimple
*stmt
)
1654 gimple_seq seq
= NULL
;
1655 gimple_seq_add_stmt (&seq
, stmt
);
1660 /* Returns the sequence of statements in BB. */
1662 static inline gimple_seq
1663 bb_seq (const_basic_block bb
)
1665 return (!(bb
->flags
& BB_RTL
)) ? bb
->il
.gimple
.seq
: NULL
;
1668 static inline gimple_seq
*
1669 bb_seq_addr (basic_block bb
)
1671 return (!(bb
->flags
& BB_RTL
)) ? &bb
->il
.gimple
.seq
: NULL
;
1674 /* Sets the sequence of statements in BB to SEQ. */
1677 set_bb_seq (basic_block bb
, gimple_seq seq
)
1679 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
1680 bb
->il
.gimple
.seq
= seq
;
1684 /* Return the code for GIMPLE statement G. */
1686 static inline enum gimple_code
1687 gimple_code (const gimple
*g
)
1693 /* Return the GSS code used by a GIMPLE code. */
1695 static inline enum gimple_statement_structure_enum
1696 gss_for_code (enum gimple_code code
)
1698 gcc_gimple_checking_assert ((unsigned int)code
< LAST_AND_UNUSED_GIMPLE_CODE
);
1699 return gss_for_code_
[code
];
1703 /* Return which GSS code is used by GS. */
1705 static inline enum gimple_statement_structure_enum
1706 gimple_statement_structure (gimple
*gs
)
1708 return gss_for_code (gimple_code (gs
));
1712 /* Return true if statement G has sub-statements. This is only true for
1713 High GIMPLE statements. */
1716 gimple_has_substatements (gimple
*g
)
1718 switch (gimple_code (g
))
1722 case GIMPLE_EH_FILTER
:
1723 case GIMPLE_EH_ELSE
:
1725 case GIMPLE_OMP_FOR
:
1726 case GIMPLE_OMP_MASTER
:
1727 case GIMPLE_OMP_TASKGROUP
:
1728 case GIMPLE_OMP_ORDERED
:
1729 case GIMPLE_OMP_SECTION
:
1730 case GIMPLE_OMP_PARALLEL
:
1731 case GIMPLE_OMP_TASK
:
1732 case GIMPLE_OMP_SECTIONS
:
1733 case GIMPLE_OMP_SINGLE
:
1734 case GIMPLE_OMP_TARGET
:
1735 case GIMPLE_OMP_TEAMS
:
1736 case GIMPLE_OMP_CRITICAL
:
1737 case GIMPLE_WITH_CLEANUP_EXPR
:
1738 case GIMPLE_TRANSACTION
:
1739 case GIMPLE_OMP_GRID_BODY
:
1748 /* Return the basic block holding statement G. */
1750 static inline basic_block
1751 gimple_bb (const gimple
*g
)
1757 /* Return the lexical scope block holding statement G. */
1760 gimple_block (const gimple
*g
)
1762 return LOCATION_BLOCK (g
->location
);
1766 /* Set BLOCK to be the lexical scope block holding statement G. */
1769 gimple_set_block (gimple
*g
, tree block
)
1771 g
->location
= set_block (g
->location
, block
);
1775 /* Return location information for statement G. */
1777 static inline location_t
1778 gimple_location (const gimple
*g
)
1783 /* Return location information for statement G if g is not NULL.
1784 Otherwise, UNKNOWN_LOCATION is returned. */
1786 static inline location_t
1787 gimple_location_safe (const gimple
*g
)
1789 return g
? gimple_location (g
) : UNKNOWN_LOCATION
;
1792 /* Set location information for statement G. */
1795 gimple_set_location (gimple
*g
, location_t location
)
1797 g
->location
= location
;
1801 /* Return true if G contains location information. */
1804 gimple_has_location (const gimple
*g
)
1806 return LOCATION_LOCUS (gimple_location (g
)) != UNKNOWN_LOCATION
;
1810 /* Return non-artificial location information for statement G. */
1812 static inline location_t
1813 gimple_nonartificial_location (const gimple
*g
)
1815 location_t
*ploc
= NULL
;
1817 if (tree block
= gimple_block (g
))
1818 ploc
= block_nonartificial_location (block
);
1820 return ploc
? *ploc
: gimple_location (g
);
1824 /* Return the file name of the location of STMT. */
1826 static inline const char *
1827 gimple_filename (const gimple
*stmt
)
1829 return LOCATION_FILE (gimple_location (stmt
));
1833 /* Return the line number of the location of STMT. */
1836 gimple_lineno (const gimple
*stmt
)
1838 return LOCATION_LINE (gimple_location (stmt
));
1842 /* Determine whether SEQ is a singleton. */
1845 gimple_seq_singleton_p (gimple_seq seq
)
1847 return ((gimple_seq_first (seq
) != NULL
)
1848 && (gimple_seq_first (seq
) == gimple_seq_last (seq
)));
1851 /* Return true if no warnings should be emitted for statement STMT. */
1854 gimple_no_warning_p (const gimple
*stmt
)
1856 return stmt
->no_warning
;
1859 /* Set the no_warning flag of STMT to NO_WARNING. */
1862 gimple_set_no_warning (gimple
*stmt
, bool no_warning
)
1864 stmt
->no_warning
= (unsigned) no_warning
;
1867 /* Set the visited status on statement STMT to VISITED_P.
1869 Please note that this 'visited' property of the gimple statement is
1870 supposed to be undefined at pass boundaries. This means that a
1871 given pass should not assume it contains any useful value when the
1872 pass starts and thus can set it to any value it sees fit.
1874 You can learn more about the visited property of the gimple
1875 statement by reading the comments of the 'visited' data member of
1880 gimple_set_visited (gimple
*stmt
, bool visited_p
)
1882 stmt
->visited
= (unsigned) visited_p
;
1886 /* Return the visited status for statement STMT.
1888 Please note that this 'visited' property of the gimple statement is
1889 supposed to be undefined at pass boundaries. This means that a
1890 given pass should not assume it contains any useful value when the
1891 pass starts and thus can set it to any value it sees fit.
1893 You can learn more about the visited property of the gimple
1894 statement by reading the comments of the 'visited' data member of
1898 gimple_visited_p (gimple
*stmt
)
1900 return stmt
->visited
;
1904 /* Set pass local flag PLF on statement STMT to VAL_P.
1906 Please note that this PLF property of the gimple statement is
1907 supposed to be undefined at pass boundaries. This means that a
1908 given pass should not assume it contains any useful value when the
1909 pass starts and thus can set it to any value it sees fit.
1911 You can learn more about the PLF property by reading the comment of
1912 the 'plf' data member of struct gimple_statement_structure. */
1915 gimple_set_plf (gimple
*stmt
, enum plf_mask plf
, bool val_p
)
1918 stmt
->plf
|= (unsigned int) plf
;
1920 stmt
->plf
&= ~((unsigned int) plf
);
1924 /* Return the value of pass local flag PLF on statement STMT.
1926 Please note that this 'plf' property of the gimple statement is
1927 supposed to be undefined at pass boundaries. This means that a
1928 given pass should not assume it contains any useful value when the
1929 pass starts and thus can set it to any value it sees fit.
1931 You can learn more about the plf property by reading the comment of
1932 the 'plf' data member of struct gimple_statement_structure. */
1934 static inline unsigned int
1935 gimple_plf (gimple
*stmt
, enum plf_mask plf
)
1937 return stmt
->plf
& ((unsigned int) plf
);
1941 /* Set the UID of statement.
1943 Please note that this UID property is supposed to be undefined at
1944 pass boundaries. This means that a given pass should not assume it
1945 contains any useful value when the pass starts and thus can set it
1946 to any value it sees fit. */
1949 gimple_set_uid (gimple
*g
, unsigned uid
)
1955 /* Return the UID of statement.
1957 Please note that this UID property is supposed to be undefined at
1958 pass boundaries. This means that a given pass should not assume it
1959 contains any useful value when the pass starts and thus can set it
1960 to any value it sees fit. */
1962 static inline unsigned
1963 gimple_uid (const gimple
*g
)
1969 /* Make statement G a singleton sequence. */
1972 gimple_init_singleton (gimple
*g
)
1979 /* Return true if GIMPLE statement G has register or memory operands. */
1982 gimple_has_ops (const gimple
*g
)
1984 return gimple_code (g
) >= GIMPLE_COND
&& gimple_code (g
) <= GIMPLE_RETURN
;
1990 is_a_helper
<const gimple_statement_with_ops
*>::test (const gimple
*gs
)
1992 return gimple_has_ops (gs
);
1998 is_a_helper
<gimple_statement_with_ops
*>::test (gimple
*gs
)
2000 return gimple_has_ops (gs
);
2003 /* Return true if GIMPLE statement G has memory operands. */
2006 gimple_has_mem_ops (const gimple
*g
)
2008 return gimple_code (g
) >= GIMPLE_ASSIGN
&& gimple_code (g
) <= GIMPLE_RETURN
;
2014 is_a_helper
<const gimple_statement_with_memory_ops
*>::test (const gimple
*gs
)
2016 return gimple_has_mem_ops (gs
);
2022 is_a_helper
<gimple_statement_with_memory_ops
*>::test (gimple
*gs
)
2024 return gimple_has_mem_ops (gs
);
2027 /* Return the set of USE operands for statement G. */
2029 static inline struct use_optype_d
*
2030 gimple_use_ops (const gimple
*g
)
2032 const gimple_statement_with_ops
*ops_stmt
=
2033 dyn_cast
<const gimple_statement_with_ops
*> (g
);
2036 return ops_stmt
->use_ops
;
2040 /* Set USE to be the set of USE operands for statement G. */
2043 gimple_set_use_ops (gimple
*g
, struct use_optype_d
*use
)
2045 gimple_statement_with_ops
*ops_stmt
=
2046 as_a
<gimple_statement_with_ops
*> (g
);
2047 ops_stmt
->use_ops
= use
;
2051 /* Return the single VUSE operand of the statement G. */
2054 gimple_vuse (const gimple
*g
)
2056 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
2057 dyn_cast
<const gimple_statement_with_memory_ops
*> (g
);
2060 return mem_ops_stmt
->vuse
;
2063 /* Return the single VDEF operand of the statement G. */
2066 gimple_vdef (const gimple
*g
)
2068 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
2069 dyn_cast
<const gimple_statement_with_memory_ops
*> (g
);
2072 return mem_ops_stmt
->vdef
;
2075 /* Return the single VUSE operand of the statement G. */
2077 static inline tree
*
2078 gimple_vuse_ptr (gimple
*g
)
2080 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2081 dyn_cast
<gimple_statement_with_memory_ops
*> (g
);
2084 return &mem_ops_stmt
->vuse
;
2087 /* Return the single VDEF operand of the statement G. */
2089 static inline tree
*
2090 gimple_vdef_ptr (gimple
*g
)
2092 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2093 dyn_cast
<gimple_statement_with_memory_ops
*> (g
);
2096 return &mem_ops_stmt
->vdef
;
2099 /* Set the single VUSE operand of the statement G. */
2102 gimple_set_vuse (gimple
*g
, tree vuse
)
2104 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2105 as_a
<gimple_statement_with_memory_ops
*> (g
);
2106 mem_ops_stmt
->vuse
= vuse
;
2109 /* Set the single VDEF operand of the statement G. */
2112 gimple_set_vdef (gimple
*g
, tree vdef
)
2114 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2115 as_a
<gimple_statement_with_memory_ops
*> (g
);
2116 mem_ops_stmt
->vdef
= vdef
;
2120 /* Return true if statement G has operands and the modified field has
2124 gimple_modified_p (const gimple
*g
)
2126 return (gimple_has_ops (g
)) ? (bool) g
->modified
: false;
2130 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2131 a MODIFIED field. */
2134 gimple_set_modified (gimple
*s
, bool modifiedp
)
2136 if (gimple_has_ops (s
))
2137 s
->modified
= (unsigned) modifiedp
;
2141 /* Return the tree code for the expression computed by STMT. This is
2142 only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
2143 GIMPLE_CALL, return CALL_EXPR as the expression code for
2144 consistency. This is useful when the caller needs to deal with the
2145 three kinds of computation that GIMPLE supports. */
2147 static inline enum tree_code
2148 gimple_expr_code (const gimple
*stmt
)
2150 enum gimple_code code
= gimple_code (stmt
);
2151 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_COND
)
2152 return (enum tree_code
) stmt
->subcode
;
2155 gcc_gimple_checking_assert (code
== GIMPLE_CALL
);
2161 /* Return true if statement STMT contains volatile operands. */
2164 gimple_has_volatile_ops (const gimple
*stmt
)
2166 if (gimple_has_mem_ops (stmt
))
2167 return stmt
->has_volatile_ops
;
2173 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
2176 gimple_set_has_volatile_ops (gimple
*stmt
, bool volatilep
)
2178 if (gimple_has_mem_ops (stmt
))
2179 stmt
->has_volatile_ops
= (unsigned) volatilep
;
2182 /* Return true if STMT is in a transaction. */
2185 gimple_in_transaction (const gimple
*stmt
)
2187 return bb_in_transaction (gimple_bb (stmt
));
2190 /* Return true if statement STMT may access memory. */
2193 gimple_references_memory_p (gimple
*stmt
)
2195 return gimple_has_mem_ops (stmt
) && gimple_vuse (stmt
);
2199 /* Return the subcode for OMP statement S. */
2201 static inline unsigned
2202 gimple_omp_subcode (const gimple
*s
)
2204 gcc_gimple_checking_assert (gimple_code (s
) >= GIMPLE_OMP_ATOMIC_LOAD
2205 && gimple_code (s
) <= GIMPLE_OMP_TEAMS
);
2209 /* Set the subcode for OMP statement S to SUBCODE. */
2212 gimple_omp_set_subcode (gimple
*s
, unsigned int subcode
)
2214 /* We only have 16 bits for the subcode. Assert that we are not
2216 gcc_gimple_checking_assert (subcode
< (1 << 16));
2217 s
->subcode
= subcode
;
2220 /* Set the nowait flag on OMP_RETURN statement S. */
2223 gimple_omp_return_set_nowait (gimple
*s
)
2225 GIMPLE_CHECK (s
, GIMPLE_OMP_RETURN
);
2226 s
->subcode
|= GF_OMP_RETURN_NOWAIT
;
2230 /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
2234 gimple_omp_return_nowait_p (const gimple
*g
)
2236 GIMPLE_CHECK (g
, GIMPLE_OMP_RETURN
);
2237 return (gimple_omp_subcode (g
) & GF_OMP_RETURN_NOWAIT
) != 0;
2241 /* Set the LHS of OMP return. */
2244 gimple_omp_return_set_lhs (gimple
*g
, tree lhs
)
2246 gimple_statement_omp_return
*omp_return_stmt
=
2247 as_a
<gimple_statement_omp_return
*> (g
);
2248 omp_return_stmt
->val
= lhs
;
2252 /* Get the LHS of OMP return. */
2255 gimple_omp_return_lhs (const gimple
*g
)
2257 const gimple_statement_omp_return
*omp_return_stmt
=
2258 as_a
<const gimple_statement_omp_return
*> (g
);
2259 return omp_return_stmt
->val
;
2263 /* Return a pointer to the LHS of OMP return. */
2265 static inline tree
*
2266 gimple_omp_return_lhs_ptr (gimple
*g
)
2268 gimple_statement_omp_return
*omp_return_stmt
=
2269 as_a
<gimple_statement_omp_return
*> (g
);
2270 return &omp_return_stmt
->val
;
2274 /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
2278 gimple_omp_section_last_p (const gimple
*g
)
2280 GIMPLE_CHECK (g
, GIMPLE_OMP_SECTION
);
2281 return (gimple_omp_subcode (g
) & GF_OMP_SECTION_LAST
) != 0;
2285 /* Set the GF_OMP_SECTION_LAST flag on G. */
2288 gimple_omp_section_set_last (gimple
*g
)
2290 GIMPLE_CHECK (g
, GIMPLE_OMP_SECTION
);
2291 g
->subcode
|= GF_OMP_SECTION_LAST
;
2295 /* Return true if OMP parallel statement G has the
2296 GF_OMP_PARALLEL_COMBINED flag set. */
2299 gimple_omp_parallel_combined_p (const gimple
*g
)
2301 GIMPLE_CHECK (g
, GIMPLE_OMP_PARALLEL
);
2302 return (gimple_omp_subcode (g
) & GF_OMP_PARALLEL_COMBINED
) != 0;
2306 /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
2307 value of COMBINED_P. */
2310 gimple_omp_parallel_set_combined_p (gimple
*g
, bool combined_p
)
2312 GIMPLE_CHECK (g
, GIMPLE_OMP_PARALLEL
);
2314 g
->subcode
|= GF_OMP_PARALLEL_COMBINED
;
2316 g
->subcode
&= ~GF_OMP_PARALLEL_COMBINED
;
2320 /* Return true if OMP atomic load/store statement G has the
2321 GF_OMP_ATOMIC_NEED_VALUE flag set. */
2324 gimple_omp_atomic_need_value_p (const gimple
*g
)
2326 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2327 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2328 return (gimple_omp_subcode (g
) & GF_OMP_ATOMIC_NEED_VALUE
) != 0;
2332 /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
2335 gimple_omp_atomic_set_need_value (gimple
*g
)
2337 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2338 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2339 g
->subcode
|= GF_OMP_ATOMIC_NEED_VALUE
;
2343 /* Return the memory order of the OMP atomic load/store statement G. */
2345 static inline enum omp_memory_order
2346 gimple_omp_atomic_memory_order (const gimple
*g
)
2348 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2349 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2350 return (enum omp_memory_order
)
2351 (gimple_omp_subcode (g
) & GF_OMP_ATOMIC_MEMORY_ORDER
);
2355 /* Set the memory order on G. */
2358 gimple_omp_atomic_set_memory_order (gimple
*g
, enum omp_memory_order mo
)
2360 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2361 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2362 g
->subcode
= ((g
->subcode
& ~GF_OMP_ATOMIC_MEMORY_ORDER
)
2363 | (mo
& GF_OMP_ATOMIC_MEMORY_ORDER
));
2367 /* Return the number of operands for statement GS. */
2369 static inline unsigned
2370 gimple_num_ops (const gimple
*gs
)
2376 /* Set the number of operands for statement GS. */
2379 gimple_set_num_ops (gimple
*gs
, unsigned num_ops
)
2381 gs
->num_ops
= num_ops
;
2385 /* Return the array of operands for statement GS. */
2387 static inline tree
*
2388 gimple_ops (gimple
*gs
)
2392 /* All the tuples have their operand vector at the very bottom
2393 of the structure. Note that those structures that do not
2394 have an operand vector have a zero offset. */
2395 off
= gimple_ops_offset_
[gimple_statement_structure (gs
)];
2396 gcc_gimple_checking_assert (off
!= 0);
2398 return (tree
*) ((char *) gs
+ off
);
2402 /* Return operand I for statement GS. */
2405 gimple_op (const gimple
*gs
, unsigned i
)
2407 if (gimple_has_ops (gs
))
2409 gcc_gimple_checking_assert (i
< gimple_num_ops (gs
));
2410 return gimple_ops (CONST_CAST_GIMPLE (gs
))[i
];
2416 /* Return a pointer to operand I for statement GS. */
2418 static inline tree
*
2419 gimple_op_ptr (gimple
*gs
, unsigned i
)
2421 if (gimple_has_ops (gs
))
2423 gcc_gimple_checking_assert (i
< gimple_num_ops (gs
));
2424 return gimple_ops (gs
) + i
;
2430 /* Set operand I of statement GS to OP. */
2433 gimple_set_op (gimple
*gs
, unsigned i
, tree op
)
2435 gcc_gimple_checking_assert (gimple_has_ops (gs
) && i
< gimple_num_ops (gs
));
2437 /* Note. It may be tempting to assert that OP matches
2438 is_gimple_operand, but that would be wrong. Different tuples
2439 accept slightly different sets of tree operands. Each caller
2440 should perform its own validation. */
2441 gimple_ops (gs
)[i
] = op
;
2444 /* Return true if GS is a GIMPLE_ASSIGN. */
2447 is_gimple_assign (const gimple
*gs
)
2449 return gimple_code (gs
) == GIMPLE_ASSIGN
;
2452 /* Determine if expression CODE is one of the valid expressions that can
2453 be used on the RHS of GIMPLE assignments. */
2455 static inline enum gimple_rhs_class
2456 get_gimple_rhs_class (enum tree_code code
)
2458 return (enum gimple_rhs_class
) gimple_rhs_class_table
[(int) code
];
2461 /* Return the LHS of assignment statement GS. */
2464 gimple_assign_lhs (const gassign
*gs
)
2470 gimple_assign_lhs (const gimple
*gs
)
2472 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2473 return gimple_assign_lhs (ass
);
2477 /* Return a pointer to the LHS of assignment statement GS. */
2479 static inline tree
*
2480 gimple_assign_lhs_ptr (gassign
*gs
)
2485 static inline tree
*
2486 gimple_assign_lhs_ptr (gimple
*gs
)
2488 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2489 return gimple_assign_lhs_ptr (ass
);
2493 /* Set LHS to be the LHS operand of assignment statement GS. */
2496 gimple_assign_set_lhs (gassign
*gs
, tree lhs
)
2500 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
2501 SSA_NAME_DEF_STMT (lhs
) = gs
;
2505 gimple_assign_set_lhs (gimple
*gs
, tree lhs
)
2507 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2508 gimple_assign_set_lhs (ass
, lhs
);
2512 /* Return the first operand on the RHS of assignment statement GS. */
2515 gimple_assign_rhs1 (const gassign
*gs
)
2521 gimple_assign_rhs1 (const gimple
*gs
)
2523 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2524 return gimple_assign_rhs1 (ass
);
2528 /* Return a pointer to the first operand on the RHS of assignment
2531 static inline tree
*
2532 gimple_assign_rhs1_ptr (gassign
*gs
)
2537 static inline tree
*
2538 gimple_assign_rhs1_ptr (gimple
*gs
)
2540 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2541 return gimple_assign_rhs1_ptr (ass
);
2544 /* Set RHS to be the first operand on the RHS of assignment statement GS. */
2547 gimple_assign_set_rhs1 (gassign
*gs
, tree rhs
)
2553 gimple_assign_set_rhs1 (gimple
*gs
, tree rhs
)
2555 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2556 gimple_assign_set_rhs1 (ass
, rhs
);
2560 /* Return the second operand on the RHS of assignment statement GS.
2561 If GS does not have two operands, NULL is returned instead. */
2564 gimple_assign_rhs2 (const gassign
*gs
)
2566 if (gimple_num_ops (gs
) >= 3)
2573 gimple_assign_rhs2 (const gimple
*gs
)
2575 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2576 return gimple_assign_rhs2 (ass
);
2580 /* Return a pointer to the second operand on the RHS of assignment
2583 static inline tree
*
2584 gimple_assign_rhs2_ptr (gassign
*gs
)
2586 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 3);
2590 static inline tree
*
2591 gimple_assign_rhs2_ptr (gimple
*gs
)
2593 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2594 return gimple_assign_rhs2_ptr (ass
);
2598 /* Set RHS to be the second operand on the RHS of assignment statement GS. */
2601 gimple_assign_set_rhs2 (gassign
*gs
, tree rhs
)
2603 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 3);
2608 gimple_assign_set_rhs2 (gimple
*gs
, tree rhs
)
2610 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2611 return gimple_assign_set_rhs2 (ass
, rhs
);
2614 /* Return the third operand on the RHS of assignment statement GS.
2615 If GS does not have two operands, NULL is returned instead. */
2618 gimple_assign_rhs3 (const gassign
*gs
)
2620 if (gimple_num_ops (gs
) >= 4)
2627 gimple_assign_rhs3 (const gimple
*gs
)
2629 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2630 return gimple_assign_rhs3 (ass
);
2633 /* Return a pointer to the third operand on the RHS of assignment
2636 static inline tree
*
2637 gimple_assign_rhs3_ptr (gimple
*gs
)
2639 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2640 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 4);
2645 /* Set RHS to be the third operand on the RHS of assignment statement GS. */
2648 gimple_assign_set_rhs3 (gassign
*gs
, tree rhs
)
2650 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 4);
2655 gimple_assign_set_rhs3 (gimple
*gs
, tree rhs
)
2657 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2658 gimple_assign_set_rhs3 (ass
, rhs
);
2662 /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2663 which expect to see only two operands. */
2666 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
2669 gimple_assign_set_rhs_with_ops (gsi
, code
, op1
, op2
, NULL
);
2672 /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2673 which expect to see only one operands. */
2676 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
2679 gimple_assign_set_rhs_with_ops (gsi
, code
, op1
, NULL
, NULL
);
2682 /* Returns true if GS is a nontemporal move. */
2685 gimple_assign_nontemporal_move_p (const gassign
*gs
)
2687 return gs
->nontemporal_move
;
2690 /* Sets nontemporal move flag of GS to NONTEMPORAL. */
2693 gimple_assign_set_nontemporal_move (gimple
*gs
, bool nontemporal
)
2695 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2696 gs
->nontemporal_move
= nontemporal
;
2700 /* Return the code of the expression computed on the rhs of assignment
2701 statement GS. In case that the RHS is a single object, returns the
2702 tree code of the object. */
2704 static inline enum tree_code
2705 gimple_assign_rhs_code (const gassign
*gs
)
2707 enum tree_code code
= (enum tree_code
) gs
->subcode
;
2708 /* While we initially set subcode to the TREE_CODE of the rhs for
2709 GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
2710 in sync when we rewrite stmts into SSA form or do SSA propagations. */
2711 if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
)
2712 code
= TREE_CODE (gs
->op
[1]);
2717 static inline enum tree_code
2718 gimple_assign_rhs_code (const gimple
*gs
)
2720 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2721 return gimple_assign_rhs_code (ass
);
2725 /* Set CODE to be the code for the expression computed on the RHS of
2729 gimple_assign_set_rhs_code (gimple
*s
, enum tree_code code
)
2731 GIMPLE_CHECK (s
, GIMPLE_ASSIGN
);
2736 /* Return the gimple rhs class of the code of the expression computed on
2737 the rhs of assignment statement GS.
2738 This will never return GIMPLE_INVALID_RHS. */
2740 static inline enum gimple_rhs_class
2741 gimple_assign_rhs_class (const gimple
*gs
)
2743 return get_gimple_rhs_class (gimple_assign_rhs_code (gs
));
2746 /* Return true if GS is an assignment with a singleton RHS, i.e.,
2747 there is no operator associated with the assignment itself.
2748 Unlike gimple_assign_copy_p, this predicate returns true for
2749 any RHS operand, including those that perform an operation
2750 and do not have the semantics of a copy, such as COND_EXPR. */
2753 gimple_assign_single_p (const gimple
*gs
)
2755 return (is_gimple_assign (gs
)
2756 && gimple_assign_rhs_class (gs
) == GIMPLE_SINGLE_RHS
);
2759 /* Return true if GS performs a store to its lhs. */
2762 gimple_store_p (const gimple
*gs
)
2764 tree lhs
= gimple_get_lhs (gs
);
2765 return lhs
&& !is_gimple_reg (lhs
);
2768 /* Return true if GS is an assignment that loads from its rhs1. */
2771 gimple_assign_load_p (const gimple
*gs
)
2774 if (!gimple_assign_single_p (gs
))
2776 rhs
= gimple_assign_rhs1 (gs
);
2777 if (TREE_CODE (rhs
) == WITH_SIZE_EXPR
)
2779 rhs
= get_base_address (rhs
);
2780 return (DECL_P (rhs
)
2781 || TREE_CODE (rhs
) == MEM_REF
|| TREE_CODE (rhs
) == TARGET_MEM_REF
);
2785 /* Return true if S is a type-cast assignment. */
2788 gimple_assign_cast_p (const gimple
*s
)
2790 if (is_gimple_assign (s
))
2792 enum tree_code sc
= gimple_assign_rhs_code (s
);
2793 return CONVERT_EXPR_CODE_P (sc
)
2794 || sc
== VIEW_CONVERT_EXPR
2795 || sc
== FIX_TRUNC_EXPR
;
2801 /* Return true if S is a clobber statement. */
2804 gimple_clobber_p (const gimple
*s
)
2806 return gimple_assign_single_p (s
)
2807 && TREE_CLOBBER_P (gimple_assign_rhs1 (s
));
2810 /* Return true if GS is a GIMPLE_CALL. */
2813 is_gimple_call (const gimple
*gs
)
2815 return gimple_code (gs
) == GIMPLE_CALL
;
2818 /* Return the LHS of call statement GS. */
2821 gimple_call_lhs (const gcall
*gs
)
2827 gimple_call_lhs (const gimple
*gs
)
2829 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2830 return gimple_call_lhs (gc
);
2834 /* Return a pointer to the LHS of call statement GS. */
2836 static inline tree
*
2837 gimple_call_lhs_ptr (gcall
*gs
)
2842 static inline tree
*
2843 gimple_call_lhs_ptr (gimple
*gs
)
2845 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
2846 return gimple_call_lhs_ptr (gc
);
2850 /* Set LHS to be the LHS operand of call statement GS. */
2853 gimple_call_set_lhs (gcall
*gs
, tree lhs
)
2856 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
2857 SSA_NAME_DEF_STMT (lhs
) = gs
;
2861 gimple_call_set_lhs (gimple
*gs
, tree lhs
)
2863 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
2864 gimple_call_set_lhs (gc
, lhs
);
2868 /* Return true if call GS calls an internal-only function, as enumerated
2872 gimple_call_internal_p (const gcall
*gs
)
2874 return (gs
->subcode
& GF_CALL_INTERNAL
) != 0;
2878 gimple_call_internal_p (const gimple
*gs
)
2880 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2881 return gimple_call_internal_p (gc
);
2884 /* Return true if call GS is marked as nocf_check. */
2887 gimple_call_nocf_check_p (const gcall
*gs
)
2889 return (gs
->subcode
& GF_CALL_NOCF_CHECK
) != 0;
2892 /* Mark statement GS as nocf_check call. */
2895 gimple_call_set_nocf_check (gcall
*gs
, bool nocf_check
)
2898 gs
->subcode
|= GF_CALL_NOCF_CHECK
;
2900 gs
->subcode
&= ~GF_CALL_NOCF_CHECK
;
2903 /* Return the target of internal call GS. */
2905 static inline enum internal_fn
2906 gimple_call_internal_fn (const gcall
*gs
)
2908 gcc_gimple_checking_assert (gimple_call_internal_p (gs
));
2909 return gs
->u
.internal_fn
;
2912 static inline enum internal_fn
2913 gimple_call_internal_fn (const gimple
*gs
)
2915 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2916 return gimple_call_internal_fn (gc
);
2919 /* Return true, if this internal gimple call is unique. */
2922 gimple_call_internal_unique_p (const gcall
*gs
)
2924 return gimple_call_internal_fn (gs
) == IFN_UNIQUE
;
2928 gimple_call_internal_unique_p (const gimple
*gs
)
2930 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2931 return gimple_call_internal_unique_p (gc
);
2934 /* Return true if GS is an internal function FN. */
2937 gimple_call_internal_p (const gimple
*gs
, internal_fn fn
)
2939 return (is_gimple_call (gs
)
2940 && gimple_call_internal_p (gs
)
2941 && gimple_call_internal_fn (gs
) == fn
);
2944 /* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
2945 that could alter control flow. */
2948 gimple_call_set_ctrl_altering (gcall
*s
, bool ctrl_altering_p
)
2950 if (ctrl_altering_p
)
2951 s
->subcode
|= GF_CALL_CTRL_ALTERING
;
2953 s
->subcode
&= ~GF_CALL_CTRL_ALTERING
;
2957 gimple_call_set_ctrl_altering (gimple
*s
, bool ctrl_altering_p
)
2959 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (s
);
2960 gimple_call_set_ctrl_altering (gc
, ctrl_altering_p
);
2963 /* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
2964 flag is set. Such call could not be a stmt in the middle of a bb. */
2967 gimple_call_ctrl_altering_p (const gcall
*gs
)
2969 return (gs
->subcode
& GF_CALL_CTRL_ALTERING
) != 0;
2973 gimple_call_ctrl_altering_p (const gimple
*gs
)
2975 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2976 return gimple_call_ctrl_altering_p (gc
);
2980 /* Return the function type of the function called by GS. */
2983 gimple_call_fntype (const gcall
*gs
)
2985 if (gimple_call_internal_p (gs
))
2987 return gs
->u
.fntype
;
2991 gimple_call_fntype (const gimple
*gs
)
2993 const gcall
*call_stmt
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2994 return gimple_call_fntype (call_stmt
);
2997 /* Set the type of the function called by CALL_STMT to FNTYPE. */
3000 gimple_call_set_fntype (gcall
*call_stmt
, tree fntype
)
3002 gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt
));
3003 call_stmt
->u
.fntype
= fntype
;
3007 /* Return the tree node representing the function called by call
3011 gimple_call_fn (const gcall
*gs
)
3017 gimple_call_fn (const gimple
*gs
)
3019 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3020 return gimple_call_fn (gc
);
3023 /* Return a pointer to the tree node representing the function called by call
3026 static inline tree
*
3027 gimple_call_fn_ptr (gcall
*gs
)
3032 static inline tree
*
3033 gimple_call_fn_ptr (gimple
*gs
)
3035 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3036 return gimple_call_fn_ptr (gc
);
3040 /* Set FN to be the function called by call statement GS. */
3043 gimple_call_set_fn (gcall
*gs
, tree fn
)
3045 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
3050 /* Set FNDECL to be the function called by call statement GS. */
3053 gimple_call_set_fndecl (gcall
*gs
, tree decl
)
3055 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
3056 gs
->op
[1] = build1_loc (gimple_location (gs
), ADDR_EXPR
,
3057 build_pointer_type (TREE_TYPE (decl
)), decl
);
3061 gimple_call_set_fndecl (gimple
*gs
, tree decl
)
3063 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3064 gimple_call_set_fndecl (gc
, decl
);
3068 /* Set internal function FN to be the function called by call statement CALL_STMT. */
3071 gimple_call_set_internal_fn (gcall
*call_stmt
, enum internal_fn fn
)
3073 gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt
));
3074 call_stmt
->u
.internal_fn
= fn
;
3078 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
3079 Otherwise return NULL. This function is analogous to
3080 get_callee_fndecl in tree land. */
3083 gimple_call_fndecl (const gcall
*gs
)
3085 return gimple_call_addr_fndecl (gimple_call_fn (gs
));
3089 gimple_call_fndecl (const gimple
*gs
)
3091 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3092 return gimple_call_fndecl (gc
);
3096 /* Return the type returned by call statement GS. */
3099 gimple_call_return_type (const gcall
*gs
)
3101 tree type
= gimple_call_fntype (gs
);
3103 if (type
== NULL_TREE
)
3104 return TREE_TYPE (gimple_call_lhs (gs
));
3106 /* The type returned by a function is the type of its
3108 return TREE_TYPE (type
);
3112 /* Return the static chain for call statement GS. */
3115 gimple_call_chain (const gcall
*gs
)
3121 gimple_call_chain (const gimple
*gs
)
3123 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3124 return gimple_call_chain (gc
);
3128 /* Return a pointer to the static chain for call statement CALL_STMT. */
3130 static inline tree
*
3131 gimple_call_chain_ptr (gcall
*call_stmt
)
3133 return &call_stmt
->op
[2];
3136 /* Set CHAIN to be the static chain for call statement CALL_STMT. */
3139 gimple_call_set_chain (gcall
*call_stmt
, tree chain
)
3141 call_stmt
->op
[2] = chain
;
3145 /* Return the number of arguments used by call statement GS. */
3147 static inline unsigned
3148 gimple_call_num_args (const gcall
*gs
)
3150 return gimple_num_ops (gs
) - 3;
3153 static inline unsigned
3154 gimple_call_num_args (const gimple
*gs
)
3156 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3157 return gimple_call_num_args (gc
);
3161 /* Return the argument at position INDEX for call statement GS. */
3164 gimple_call_arg (const gcall
*gs
, unsigned index
)
3166 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 3);
3167 return gs
->op
[index
+ 3];
3171 gimple_call_arg (const gimple
*gs
, unsigned index
)
3173 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3174 return gimple_call_arg (gc
, index
);
3178 /* Return a pointer to the argument at position INDEX for call
3181 static inline tree
*
3182 gimple_call_arg_ptr (gcall
*gs
, unsigned index
)
3184 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 3);
3185 return &gs
->op
[index
+ 3];
3188 static inline tree
*
3189 gimple_call_arg_ptr (gimple
*gs
, unsigned index
)
3191 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3192 return gimple_call_arg_ptr (gc
, index
);
3196 /* Set ARG to be the argument at position INDEX for call statement GS. */
3199 gimple_call_set_arg (gcall
*gs
, unsigned index
, tree arg
)
3201 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 3);
3202 gs
->op
[index
+ 3] = arg
;
3206 gimple_call_set_arg (gimple
*gs
, unsigned index
, tree arg
)
3208 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3209 gimple_call_set_arg (gc
, index
, arg
);
3213 /* If TAIL_P is true, mark call statement S as being a tail call
3214 (i.e., a call just before the exit of a function). These calls are
3215 candidate for tail call optimization. */
3218 gimple_call_set_tail (gcall
*s
, bool tail_p
)
3221 s
->subcode
|= GF_CALL_TAILCALL
;
3223 s
->subcode
&= ~GF_CALL_TAILCALL
;
3227 /* Return true if GIMPLE_CALL S is marked as a tail call. */
3230 gimple_call_tail_p (gcall
*s
)
3232 return (s
->subcode
& GF_CALL_TAILCALL
) != 0;
3235 /* Mark (or clear) call statement S as requiring tail call optimization. */
3238 gimple_call_set_must_tail (gcall
*s
, bool must_tail_p
)
3241 s
->subcode
|= GF_CALL_MUST_TAIL_CALL
;
3243 s
->subcode
&= ~GF_CALL_MUST_TAIL_CALL
;
3246 /* Return true if call statement has been marked as requiring
3247 tail call optimization. */
3250 gimple_call_must_tail_p (const gcall
*s
)
3252 return (s
->subcode
& GF_CALL_MUST_TAIL_CALL
) != 0;
3255 /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
3256 slot optimization. This transformation uses the target of the call
3257 expansion as the return slot for calls that return in memory. */
3260 gimple_call_set_return_slot_opt (gcall
*s
, bool return_slot_opt_p
)
3262 if (return_slot_opt_p
)
3263 s
->subcode
|= GF_CALL_RETURN_SLOT_OPT
;
3265 s
->subcode
&= ~GF_CALL_RETURN_SLOT_OPT
;
3269 /* Return true if S is marked for return slot optimization. */
3272 gimple_call_return_slot_opt_p (gcall
*s
)
3274 return (s
->subcode
& GF_CALL_RETURN_SLOT_OPT
) != 0;
3278 /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
3279 thunk to the thunked-to function. */
3282 gimple_call_set_from_thunk (gcall
*s
, bool from_thunk_p
)
3285 s
->subcode
|= GF_CALL_FROM_THUNK
;
3287 s
->subcode
&= ~GF_CALL_FROM_THUNK
;
3291 /* Return true if GIMPLE_CALL S is a jump from a thunk. */
3294 gimple_call_from_thunk_p (gcall
*s
)
3296 return (s
->subcode
& GF_CALL_FROM_THUNK
) != 0;
3300 /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
3301 argument pack in its argument list. */
3304 gimple_call_set_va_arg_pack (gcall
*s
, bool pass_arg_pack_p
)
3306 if (pass_arg_pack_p
)
3307 s
->subcode
|= GF_CALL_VA_ARG_PACK
;
3309 s
->subcode
&= ~GF_CALL_VA_ARG_PACK
;
3313 /* Return true if GIMPLE_CALL S is a stdarg call that needs the
3314 argument pack in its argument list. */
3317 gimple_call_va_arg_pack_p (gcall
*s
)
3319 return (s
->subcode
& GF_CALL_VA_ARG_PACK
) != 0;
3323 /* Return true if S is a noreturn call. */
3326 gimple_call_noreturn_p (const gcall
*s
)
3328 return (gimple_call_flags (s
) & ECF_NORETURN
) != 0;
3332 gimple_call_noreturn_p (const gimple
*s
)
3334 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (s
);
3335 return gimple_call_noreturn_p (gc
);
3339 /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
3340 even if the called function can throw in other cases. */
3343 gimple_call_set_nothrow (gcall
*s
, bool nothrow_p
)
3346 s
->subcode
|= GF_CALL_NOTHROW
;
3348 s
->subcode
&= ~GF_CALL_NOTHROW
;
3351 /* Return true if S is a nothrow call. */
3354 gimple_call_nothrow_p (gcall
*s
)
3356 return (gimple_call_flags (s
) & ECF_NOTHROW
) != 0;
3359 /* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
3360 is known to be emitted for VLA objects. Those are wrapped by
3361 stack_save/stack_restore calls and hence can't lead to unbounded
3362 stack growth even when they occur in loops. */
3365 gimple_call_set_alloca_for_var (gcall
*s
, bool for_var
)
3368 s
->subcode
|= GF_CALL_ALLOCA_FOR_VAR
;
3370 s
->subcode
&= ~GF_CALL_ALLOCA_FOR_VAR
;
3373 /* Return true of S is a call to builtin_alloca emitted for VLA objects. */
3376 gimple_call_alloca_for_var_p (gcall
*s
)
3378 return (s
->subcode
& GF_CALL_ALLOCA_FOR_VAR
) != 0;
3381 /* If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
3382 pointers to nested function are descriptors instead of trampolines. */
3385 gimple_call_set_by_descriptor (gcall
*s
, bool by_descriptor_p
)
3387 if (by_descriptor_p
)
3388 s
->subcode
|= GF_CALL_BY_DESCRIPTOR
;
3390 s
->subcode
&= ~GF_CALL_BY_DESCRIPTOR
;
3393 /* Return true if S is a by-descriptor call. */
3396 gimple_call_by_descriptor_p (gcall
*s
)
3398 return (s
->subcode
& GF_CALL_BY_DESCRIPTOR
) != 0;
3401 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
3404 gimple_call_copy_flags (gcall
*dest_call
, gcall
*orig_call
)
3406 dest_call
->subcode
= orig_call
->subcode
;
3410 /* Return a pointer to the points-to solution for the set of call-used
3411 variables of the call CALL_STMT. */
3413 static inline struct pt_solution
*
3414 gimple_call_use_set (gcall
*call_stmt
)
3416 return &call_stmt
->call_used
;
3420 /* Return a pointer to the points-to solution for the set of call-used
3421 variables of the call CALL_STMT. */
3423 static inline struct pt_solution
*
3424 gimple_call_clobber_set (gcall
*call_stmt
)
3426 return &call_stmt
->call_clobbered
;
3430 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
3434 gimple_has_lhs (gimple
*stmt
)
3436 if (is_gimple_assign (stmt
))
3438 if (gcall
*call
= dyn_cast
<gcall
*> (stmt
))
3439 return gimple_call_lhs (call
) != NULL_TREE
;
3444 /* Return the code of the predicate computed by conditional statement GS. */
3446 static inline enum tree_code
3447 gimple_cond_code (const gcond
*gs
)
3449 return (enum tree_code
) gs
->subcode
;
3452 static inline enum tree_code
3453 gimple_cond_code (const gimple
*gs
)
3455 const gcond
*gc
= GIMPLE_CHECK2
<const gcond
*> (gs
);
3456 return gimple_cond_code (gc
);
3460 /* Set CODE to be the predicate code for the conditional statement GS. */
3463 gimple_cond_set_code (gcond
*gs
, enum tree_code code
)
3469 /* Return the LHS of the predicate computed by conditional statement GS. */
3472 gimple_cond_lhs (const gcond
*gs
)
3478 gimple_cond_lhs (const gimple
*gs
)
3480 const gcond
*gc
= GIMPLE_CHECK2
<const gcond
*> (gs
);
3481 return gimple_cond_lhs (gc
);
3484 /* Return the pointer to the LHS of the predicate computed by conditional
3487 static inline tree
*
3488 gimple_cond_lhs_ptr (gcond
*gs
)
3493 /* Set LHS to be the LHS operand of the predicate computed by
3494 conditional statement GS. */
3497 gimple_cond_set_lhs (gcond
*gs
, tree lhs
)
3503 /* Return the RHS operand of the predicate computed by conditional GS. */
3506 gimple_cond_rhs (const gcond
*gs
)
3512 gimple_cond_rhs (const gimple
*gs
)
3514 const gcond
*gc
= GIMPLE_CHECK2
<const gcond
*> (gs
);
3515 return gimple_cond_rhs (gc
);
3518 /* Return the pointer to the RHS operand of the predicate computed by
3521 static inline tree
*
3522 gimple_cond_rhs_ptr (gcond
*gs
)
3528 /* Set RHS to be the RHS operand of the predicate computed by
3529 conditional statement GS. */
3532 gimple_cond_set_rhs (gcond
*gs
, tree rhs
)
3538 /* Return the label used by conditional statement GS when its
3539 predicate evaluates to true. */
3542 gimple_cond_true_label (const gcond
*gs
)
3548 /* Set LABEL to be the label used by conditional statement GS when its
3549 predicate evaluates to true. */
3552 gimple_cond_set_true_label (gcond
*gs
, tree label
)
3558 /* Set LABEL to be the label used by conditional statement GS when its
3559 predicate evaluates to false. */
3562 gimple_cond_set_false_label (gcond
*gs
, tree label
)
3568 /* Return the label used by conditional statement GS when its
3569 predicate evaluates to false. */
3572 gimple_cond_false_label (const gcond
*gs
)
3578 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */
3581 gimple_cond_make_false (gcond
*gs
)
3583 gimple_cond_set_lhs (gs
, boolean_false_node
);
3584 gimple_cond_set_rhs (gs
, boolean_false_node
);
3585 gs
->subcode
= NE_EXPR
;
3589 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */
3592 gimple_cond_make_true (gcond
*gs
)
3594 gimple_cond_set_lhs (gs
, boolean_true_node
);
3595 gimple_cond_set_rhs (gs
, boolean_false_node
);
3596 gs
->subcode
= NE_EXPR
;
3599 /* Check if conditional statemente GS is of the form 'if (1 == 1)',
3600 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
3603 gimple_cond_true_p (const gcond
*gs
)
3605 tree lhs
= gimple_cond_lhs (gs
);
3606 tree rhs
= gimple_cond_rhs (gs
);
3607 enum tree_code code
= gimple_cond_code (gs
);
3609 if (lhs
!= boolean_true_node
&& lhs
!= boolean_false_node
)
3612 if (rhs
!= boolean_true_node
&& rhs
!= boolean_false_node
)
3615 if (code
== NE_EXPR
&& lhs
!= rhs
)
3618 if (code
== EQ_EXPR
&& lhs
== rhs
)
3624 /* Check if conditional statement GS is of the form 'if (1 != 1)',
3625 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
3628 gimple_cond_false_p (const gcond
*gs
)
3630 tree lhs
= gimple_cond_lhs (gs
);
3631 tree rhs
= gimple_cond_rhs (gs
);
3632 enum tree_code code
= gimple_cond_code (gs
);
3634 if (lhs
!= boolean_true_node
&& lhs
!= boolean_false_node
)
3637 if (rhs
!= boolean_true_node
&& rhs
!= boolean_false_node
)
3640 if (code
== NE_EXPR
&& lhs
== rhs
)
3643 if (code
== EQ_EXPR
&& lhs
!= rhs
)
3649 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
3652 gimple_cond_set_condition (gcond
*stmt
, enum tree_code code
, tree lhs
,
3655 gimple_cond_set_code (stmt
, code
);
3656 gimple_cond_set_lhs (stmt
, lhs
);
3657 gimple_cond_set_rhs (stmt
, rhs
);
3660 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
3663 gimple_label_label (const glabel
*gs
)
3669 /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
3673 gimple_label_set_label (glabel
*gs
, tree label
)
3679 /* Return the destination of the unconditional jump GS. */
3682 gimple_goto_dest (const gimple
*gs
)
3684 GIMPLE_CHECK (gs
, GIMPLE_GOTO
);
3685 return gimple_op (gs
, 0);
3689 /* Set DEST to be the destination of the unconditonal jump GS. */
3692 gimple_goto_set_dest (ggoto
*gs
, tree dest
)
3698 /* Return the variables declared in the GIMPLE_BIND statement GS. */
3701 gimple_bind_vars (const gbind
*bind_stmt
)
3703 return bind_stmt
->vars
;
3707 /* Set VARS to be the set of variables declared in the GIMPLE_BIND
3711 gimple_bind_set_vars (gbind
*bind_stmt
, tree vars
)
3713 bind_stmt
->vars
= vars
;
3717 /* Append VARS to the set of variables declared in the GIMPLE_BIND
3721 gimple_bind_append_vars (gbind
*bind_stmt
, tree vars
)
3723 bind_stmt
->vars
= chainon (bind_stmt
->vars
, vars
);
3727 static inline gimple_seq
*
3728 gimple_bind_body_ptr (gbind
*bind_stmt
)
3730 return &bind_stmt
->body
;
3733 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
3735 static inline gimple_seq
3736 gimple_bind_body (gbind
*gs
)
3738 return *gimple_bind_body_ptr (gs
);
3742 /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
3746 gimple_bind_set_body (gbind
*bind_stmt
, gimple_seq seq
)
3748 bind_stmt
->body
= seq
;
3752 /* Append a statement to the end of a GIMPLE_BIND's body. */
3755 gimple_bind_add_stmt (gbind
*bind_stmt
, gimple
*stmt
)
3757 gimple_seq_add_stmt (&bind_stmt
->body
, stmt
);
3761 /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
3764 gimple_bind_add_seq (gbind
*bind_stmt
, gimple_seq seq
)
3766 gimple_seq_add_seq (&bind_stmt
->body
, seq
);
3770 /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
3771 GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
3774 gimple_bind_block (const gbind
*bind_stmt
)
3776 return bind_stmt
->block
;
3780 /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
3784 gimple_bind_set_block (gbind
*bind_stmt
, tree block
)
3786 gcc_gimple_checking_assert (block
== NULL_TREE
3787 || TREE_CODE (block
) == BLOCK
);
3788 bind_stmt
->block
= block
;
3792 /* Return the number of input operands for GIMPLE_ASM ASM_STMT. */
3794 static inline unsigned
3795 gimple_asm_ninputs (const gasm
*asm_stmt
)
3797 return asm_stmt
->ni
;
3801 /* Return the number of output operands for GIMPLE_ASM ASM_STMT. */
3803 static inline unsigned
3804 gimple_asm_noutputs (const gasm
*asm_stmt
)
3806 return asm_stmt
->no
;
3810 /* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */
3812 static inline unsigned
3813 gimple_asm_nclobbers (const gasm
*asm_stmt
)
3815 return asm_stmt
->nc
;
3818 /* Return the number of label operands for GIMPLE_ASM ASM_STMT. */
3820 static inline unsigned
3821 gimple_asm_nlabels (const gasm
*asm_stmt
)
3823 return asm_stmt
->nl
;
3826 /* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */
3829 gimple_asm_input_op (const gasm
*asm_stmt
, unsigned index
)
3831 gcc_gimple_checking_assert (index
< asm_stmt
->ni
);
3832 return asm_stmt
->op
[index
+ asm_stmt
->no
];
3835 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */
3838 gimple_asm_set_input_op (gasm
*asm_stmt
, unsigned index
, tree in_op
)
3840 gcc_gimple_checking_assert (index
< asm_stmt
->ni
3841 && TREE_CODE (in_op
) == TREE_LIST
);
3842 asm_stmt
->op
[index
+ asm_stmt
->no
] = in_op
;
3846 /* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */
3849 gimple_asm_output_op (const gasm
*asm_stmt
, unsigned index
)
3851 gcc_gimple_checking_assert (index
< asm_stmt
->no
);
3852 return asm_stmt
->op
[index
];
3855 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */
3858 gimple_asm_set_output_op (gasm
*asm_stmt
, unsigned index
, tree out_op
)
3860 gcc_gimple_checking_assert (index
< asm_stmt
->no
3861 && TREE_CODE (out_op
) == TREE_LIST
);
3862 asm_stmt
->op
[index
] = out_op
;
3866 /* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */
3869 gimple_asm_clobber_op (const gasm
*asm_stmt
, unsigned index
)
3871 gcc_gimple_checking_assert (index
< asm_stmt
->nc
);
3872 return asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->no
];
3876 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */
3879 gimple_asm_set_clobber_op (gasm
*asm_stmt
, unsigned index
, tree clobber_op
)
3881 gcc_gimple_checking_assert (index
< asm_stmt
->nc
3882 && TREE_CODE (clobber_op
) == TREE_LIST
);
3883 asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->no
] = clobber_op
;
3886 /* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */
3889 gimple_asm_label_op (const gasm
*asm_stmt
, unsigned index
)
3891 gcc_gimple_checking_assert (index
< asm_stmt
->nl
);
3892 return asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->nc
];
3895 /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */
3898 gimple_asm_set_label_op (gasm
*asm_stmt
, unsigned index
, tree label_op
)
3900 gcc_gimple_checking_assert (index
< asm_stmt
->nl
3901 && TREE_CODE (label_op
) == TREE_LIST
);
3902 asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->nc
] = label_op
;
3905 /* Return the string representing the assembly instruction in
3906 GIMPLE_ASM ASM_STMT. */
3908 static inline const char *
3909 gimple_asm_string (const gasm
*asm_stmt
)
3911 return asm_stmt
->string
;
3915 /* Return true if ASM_STMT is marked volatile. */
3918 gimple_asm_volatile_p (const gasm
*asm_stmt
)
3920 return (asm_stmt
->subcode
& GF_ASM_VOLATILE
) != 0;
3924 /* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile. */
3927 gimple_asm_set_volatile (gasm
*asm_stmt
, bool volatile_p
)
3930 asm_stmt
->subcode
|= GF_ASM_VOLATILE
;
3932 asm_stmt
->subcode
&= ~GF_ASM_VOLATILE
;
3936 /* Return true if ASM_STMT is marked inline. */
3939 gimple_asm_inline_p (const gasm
*asm_stmt
)
3941 return (asm_stmt
->subcode
& GF_ASM_INLINE
) != 0;
3945 /* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
3948 gimple_asm_set_inline (gasm
*asm_stmt
, bool inline_p
)
3951 asm_stmt
->subcode
|= GF_ASM_INLINE
;
3953 asm_stmt
->subcode
&= ~GF_ASM_INLINE
;
3957 /* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT. */
3960 gimple_asm_set_input (gasm
*asm_stmt
, bool input_p
)
3963 asm_stmt
->subcode
|= GF_ASM_INPUT
;
3965 asm_stmt
->subcode
&= ~GF_ASM_INPUT
;
3969 /* Return true if asm ASM_STMT is an ASM_INPUT. */
3972 gimple_asm_input_p (const gasm
*asm_stmt
)
3974 return (asm_stmt
->subcode
& GF_ASM_INPUT
) != 0;
3978 /* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */
3981 gimple_catch_types (const gcatch
*catch_stmt
)
3983 return catch_stmt
->types
;
3987 /* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */
3989 static inline tree
*
3990 gimple_catch_types_ptr (gcatch
*catch_stmt
)
3992 return &catch_stmt
->types
;
3996 /* Return a pointer to the GIMPLE sequence representing the body of
3997 the handler of GIMPLE_CATCH statement CATCH_STMT. */
3999 static inline gimple_seq
*
4000 gimple_catch_handler_ptr (gcatch
*catch_stmt
)
4002 return &catch_stmt
->handler
;
4006 /* Return the GIMPLE sequence representing the body of the handler of
4007 GIMPLE_CATCH statement CATCH_STMT. */
4009 static inline gimple_seq
4010 gimple_catch_handler (gcatch
*catch_stmt
)
4012 return *gimple_catch_handler_ptr (catch_stmt
);
4016 /* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT. */
4019 gimple_catch_set_types (gcatch
*catch_stmt
, tree t
)
4021 catch_stmt
->types
= t
;
4025 /* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */
4028 gimple_catch_set_handler (gcatch
*catch_stmt
, gimple_seq handler
)
4030 catch_stmt
->handler
= handler
;
4034 /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
4037 gimple_eh_filter_types (const gimple
*gs
)
4039 const geh_filter
*eh_filter_stmt
= as_a
<const geh_filter
*> (gs
);
4040 return eh_filter_stmt
->types
;
4044 /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
4047 static inline tree
*
4048 gimple_eh_filter_types_ptr (gimple
*gs
)
4050 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (gs
);
4051 return &eh_filter_stmt
->types
;
4055 /* Return a pointer to the sequence of statement to execute when
4056 GIMPLE_EH_FILTER statement fails. */
4058 static inline gimple_seq
*
4059 gimple_eh_filter_failure_ptr (gimple
*gs
)
4061 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (gs
);
4062 return &eh_filter_stmt
->failure
;
4066 /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
4069 static inline gimple_seq
4070 gimple_eh_filter_failure (gimple
*gs
)
4072 return *gimple_eh_filter_failure_ptr (gs
);
4076 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
4080 gimple_eh_filter_set_types (geh_filter
*eh_filter_stmt
, tree types
)
4082 eh_filter_stmt
->types
= types
;
4086 /* Set FAILURE to be the sequence of statements to execute on failure
4087 for GIMPLE_EH_FILTER EH_FILTER_STMT. */
4090 gimple_eh_filter_set_failure (geh_filter
*eh_filter_stmt
,
4093 eh_filter_stmt
->failure
= failure
;
4096 /* Get the function decl to be called by the MUST_NOT_THROW region. */
4099 gimple_eh_must_not_throw_fndecl (geh_mnt
*eh_mnt_stmt
)
4101 return eh_mnt_stmt
->fndecl
;
4104 /* Set the function decl to be called by GS to DECL. */
4107 gimple_eh_must_not_throw_set_fndecl (geh_mnt
*eh_mnt_stmt
,
4110 eh_mnt_stmt
->fndecl
= decl
;
4113 /* GIMPLE_EH_ELSE accessors. */
4115 static inline gimple_seq
*
4116 gimple_eh_else_n_body_ptr (geh_else
*eh_else_stmt
)
4118 return &eh_else_stmt
->n_body
;
4121 static inline gimple_seq
4122 gimple_eh_else_n_body (geh_else
*eh_else_stmt
)
4124 return *gimple_eh_else_n_body_ptr (eh_else_stmt
);
4127 static inline gimple_seq
*
4128 gimple_eh_else_e_body_ptr (geh_else
*eh_else_stmt
)
4130 return &eh_else_stmt
->e_body
;
4133 static inline gimple_seq
4134 gimple_eh_else_e_body (geh_else
*eh_else_stmt
)
4136 return *gimple_eh_else_e_body_ptr (eh_else_stmt
);
4140 gimple_eh_else_set_n_body (geh_else
*eh_else_stmt
, gimple_seq seq
)
4142 eh_else_stmt
->n_body
= seq
;
4146 gimple_eh_else_set_e_body (geh_else
*eh_else_stmt
, gimple_seq seq
)
4148 eh_else_stmt
->e_body
= seq
;
4151 /* GIMPLE_TRY accessors. */
4153 /* Return the kind of try block represented by GIMPLE_TRY GS. This is
4154 either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
4156 static inline enum gimple_try_flags
4157 gimple_try_kind (const gimple
*gs
)
4159 GIMPLE_CHECK (gs
, GIMPLE_TRY
);
4160 return (enum gimple_try_flags
) (gs
->subcode
& GIMPLE_TRY_KIND
);
4164 /* Set the kind of try block represented by GIMPLE_TRY GS. */
4167 gimple_try_set_kind (gtry
*gs
, enum gimple_try_flags kind
)
4169 gcc_gimple_checking_assert (kind
== GIMPLE_TRY_CATCH
4170 || kind
== GIMPLE_TRY_FINALLY
);
4171 if (gimple_try_kind (gs
) != kind
)
4172 gs
->subcode
= (unsigned int) kind
;
4176 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4179 gimple_try_catch_is_cleanup (const gimple
*gs
)
4181 gcc_gimple_checking_assert (gimple_try_kind (gs
) == GIMPLE_TRY_CATCH
);
4182 return (gs
->subcode
& GIMPLE_TRY_CATCH_IS_CLEANUP
) != 0;
4186 /* Return a pointer to the sequence of statements used as the
4187 body for GIMPLE_TRY GS. */
4189 static inline gimple_seq
*
4190 gimple_try_eval_ptr (gimple
*gs
)
4192 gtry
*try_stmt
= as_a
<gtry
*> (gs
);
4193 return &try_stmt
->eval
;
4197 /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
4199 static inline gimple_seq
4200 gimple_try_eval (gimple
*gs
)
4202 return *gimple_try_eval_ptr (gs
);
4206 /* Return a pointer to the sequence of statements used as the cleanup body for
4209 static inline gimple_seq
*
4210 gimple_try_cleanup_ptr (gimple
*gs
)
4212 gtry
*try_stmt
= as_a
<gtry
*> (gs
);
4213 return &try_stmt
->cleanup
;
4217 /* Return the sequence of statements used as the cleanup body for
4220 static inline gimple_seq
4221 gimple_try_cleanup (gimple
*gs
)
4223 return *gimple_try_cleanup_ptr (gs
);
4227 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4230 gimple_try_set_catch_is_cleanup (gtry
*g
, bool catch_is_cleanup
)
4232 gcc_gimple_checking_assert (gimple_try_kind (g
) == GIMPLE_TRY_CATCH
);
4233 if (catch_is_cleanup
)
4234 g
->subcode
|= GIMPLE_TRY_CATCH_IS_CLEANUP
;
4236 g
->subcode
&= ~GIMPLE_TRY_CATCH_IS_CLEANUP
;
4240 /* Set EVAL to be the sequence of statements to use as the body for
4241 GIMPLE_TRY TRY_STMT. */
4244 gimple_try_set_eval (gtry
*try_stmt
, gimple_seq eval
)
4246 try_stmt
->eval
= eval
;
4250 /* Set CLEANUP to be the sequence of statements to use as the cleanup
4251 body for GIMPLE_TRY TRY_STMT. */
4254 gimple_try_set_cleanup (gtry
*try_stmt
, gimple_seq cleanup
)
4256 try_stmt
->cleanup
= cleanup
;
4260 /* Return a pointer to the cleanup sequence for cleanup statement GS. */
4262 static inline gimple_seq
*
4263 gimple_wce_cleanup_ptr (gimple
*gs
)
4265 gimple_statement_wce
*wce_stmt
= as_a
<gimple_statement_wce
*> (gs
);
4266 return &wce_stmt
->cleanup
;
4270 /* Return the cleanup sequence for cleanup statement GS. */
4272 static inline gimple_seq
4273 gimple_wce_cleanup (gimple
*gs
)
4275 return *gimple_wce_cleanup_ptr (gs
);
4279 /* Set CLEANUP to be the cleanup sequence for GS. */
4282 gimple_wce_set_cleanup (gimple
*gs
, gimple_seq cleanup
)
4284 gimple_statement_wce
*wce_stmt
= as_a
<gimple_statement_wce
*> (gs
);
4285 wce_stmt
->cleanup
= cleanup
;
4289 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
4292 gimple_wce_cleanup_eh_only (const gimple
*gs
)
4294 GIMPLE_CHECK (gs
, GIMPLE_WITH_CLEANUP_EXPR
);
4295 return gs
->subcode
!= 0;
4299 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
4302 gimple_wce_set_cleanup_eh_only (gimple
*gs
, bool eh_only_p
)
4304 GIMPLE_CHECK (gs
, GIMPLE_WITH_CLEANUP_EXPR
);
4305 gs
->subcode
= (unsigned int) eh_only_p
;
4309 /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
4311 static inline unsigned
4312 gimple_phi_capacity (const gimple
*gs
)
4314 const gphi
*phi_stmt
= as_a
<const gphi
*> (gs
);
4315 return phi_stmt
->capacity
;
4319 /* Return the number of arguments in GIMPLE_PHI GS. This must always
4320 be exactly the number of incoming edges for the basic block holding
4323 static inline unsigned
4324 gimple_phi_num_args (const gimple
*gs
)
4326 const gphi
*phi_stmt
= as_a
<const gphi
*> (gs
);
4327 return phi_stmt
->nargs
;
4331 /* Return the SSA name created by GIMPLE_PHI GS. */
4334 gimple_phi_result (const gphi
*gs
)
4340 gimple_phi_result (const gimple
*gs
)
4342 const gphi
*phi_stmt
= as_a
<const gphi
*> (gs
);
4343 return gimple_phi_result (phi_stmt
);
4346 /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
4348 static inline tree
*
4349 gimple_phi_result_ptr (gphi
*gs
)
4354 static inline tree
*
4355 gimple_phi_result_ptr (gimple
*gs
)
4357 gphi
*phi_stmt
= as_a
<gphi
*> (gs
);
4358 return gimple_phi_result_ptr (phi_stmt
);
4361 /* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */
4364 gimple_phi_set_result (gphi
*phi
, tree result
)
4366 phi
->result
= result
;
4367 if (result
&& TREE_CODE (result
) == SSA_NAME
)
4368 SSA_NAME_DEF_STMT (result
) = phi
;
4372 /* Return the PHI argument corresponding to incoming edge INDEX for
4375 static inline struct phi_arg_d
*
4376 gimple_phi_arg (gphi
*gs
, unsigned index
)
4378 gcc_gimple_checking_assert (index
< gs
->nargs
);
4379 return &(gs
->args
[index
]);
4382 static inline struct phi_arg_d
*
4383 gimple_phi_arg (gimple
*gs
, unsigned index
)
4385 gphi
*phi_stmt
= as_a
<gphi
*> (gs
);
4386 return gimple_phi_arg (phi_stmt
, index
);
4389 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
4390 for GIMPLE_PHI PHI. */
4393 gimple_phi_set_arg (gphi
*phi
, unsigned index
, struct phi_arg_d
* phiarg
)
4395 gcc_gimple_checking_assert (index
< phi
->nargs
);
4396 phi
->args
[index
] = *phiarg
;
4399 /* Return the PHI nodes for basic block BB, or NULL if there are no
4402 static inline gimple_seq
4403 phi_nodes (const_basic_block bb
)
4405 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
4406 return bb
->il
.gimple
.phi_nodes
;
4409 /* Return a pointer to the PHI nodes for basic block BB. */
4411 static inline gimple_seq
*
4412 phi_nodes_ptr (basic_block bb
)
4414 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
4415 return &bb
->il
.gimple
.phi_nodes
;
4418 /* Return the tree operand for argument I of PHI node GS. */
4421 gimple_phi_arg_def (gphi
*gs
, size_t index
)
4423 return gimple_phi_arg (gs
, index
)->def
;
4427 gimple_phi_arg_def (gimple
*gs
, size_t index
)
4429 return gimple_phi_arg (gs
, index
)->def
;
4433 /* Return a pointer to the tree operand for argument I of phi node PHI. */
4435 static inline tree
*
4436 gimple_phi_arg_def_ptr (gphi
*phi
, size_t index
)
4438 return &gimple_phi_arg (phi
, index
)->def
;
4441 /* Return the edge associated with argument I of phi node PHI. */
4444 gimple_phi_arg_edge (gphi
*phi
, size_t i
)
4446 return EDGE_PRED (gimple_bb (phi
), i
);
4449 /* Return the source location of gimple argument I of phi node PHI. */
4451 static inline location_t
4452 gimple_phi_arg_location (gphi
*phi
, size_t i
)
4454 return gimple_phi_arg (phi
, i
)->locus
;
4457 /* Return the source location of the argument on edge E of phi node PHI. */
4459 static inline location_t
4460 gimple_phi_arg_location_from_edge (gphi
*phi
, edge e
)
4462 return gimple_phi_arg (phi
, e
->dest_idx
)->locus
;
4465 /* Set the source location of gimple argument I of phi node PHI to LOC. */
4468 gimple_phi_arg_set_location (gphi
*phi
, size_t i
, location_t loc
)
4470 gimple_phi_arg (phi
, i
)->locus
= loc
;
4473 /* Return TRUE if argument I of phi node PHI has a location record. */
4476 gimple_phi_arg_has_location (gphi
*phi
, size_t i
)
4478 return gimple_phi_arg_location (phi
, i
) != UNKNOWN_LOCATION
;
4482 /* Return the region number for GIMPLE_RESX RESX_STMT. */
4485 gimple_resx_region (const gresx
*resx_stmt
)
4487 return resx_stmt
->region
;
4490 /* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */
4493 gimple_resx_set_region (gresx
*resx_stmt
, int region
)
4495 resx_stmt
->region
= region
;
4498 /* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */
4501 gimple_eh_dispatch_region (const geh_dispatch
*eh_dispatch_stmt
)
4503 return eh_dispatch_stmt
->region
;
4506 /* Set REGION to be the region number for GIMPLE_EH_DISPATCH
4507 EH_DISPATCH_STMT. */
4510 gimple_eh_dispatch_set_region (geh_dispatch
*eh_dispatch_stmt
, int region
)
4512 eh_dispatch_stmt
->region
= region
;
4515 /* Return the number of labels associated with the switch statement GS. */
4517 static inline unsigned
4518 gimple_switch_num_labels (const gswitch
*gs
)
4521 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
4522 num_ops
= gimple_num_ops (gs
);
4523 gcc_gimple_checking_assert (num_ops
> 1);
4528 /* Set NLABELS to be the number of labels for the switch statement GS. */
4531 gimple_switch_set_num_labels (gswitch
*g
, unsigned nlabels
)
4533 GIMPLE_CHECK (g
, GIMPLE_SWITCH
);
4534 gimple_set_num_ops (g
, nlabels
+ 1);
4538 /* Return the index variable used by the switch statement GS. */
4541 gimple_switch_index (const gswitch
*gs
)
4547 /* Return a pointer to the index variable for the switch statement GS. */
4549 static inline tree
*
4550 gimple_switch_index_ptr (gswitch
*gs
)
4556 /* Set INDEX to be the index variable for switch statement GS. */
4559 gimple_switch_set_index (gswitch
*gs
, tree index
)
4561 gcc_gimple_checking_assert (SSA_VAR_P (index
) || CONSTANT_CLASS_P (index
));
4566 /* Return the label numbered INDEX. The default label is 0, followed by any
4567 labels in a switch statement. */
4570 gimple_switch_label (const gswitch
*gs
, unsigned index
)
4572 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 1);
4573 return gs
->op
[index
+ 1];
4576 /* Set the label number INDEX to LABEL. 0 is always the default label. */
4579 gimple_switch_set_label (gswitch
*gs
, unsigned index
, tree label
)
4581 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 1
4582 && (label
== NULL_TREE
4583 || TREE_CODE (label
) == CASE_LABEL_EXPR
));
4584 gs
->op
[index
+ 1] = label
;
4587 /* Return the default label for a switch statement. */
4590 gimple_switch_default_label (const gswitch
*gs
)
4592 tree label
= gimple_switch_label (gs
, 0);
4593 gcc_checking_assert (!CASE_LOW (label
) && !CASE_HIGH (label
));
4597 /* Set the default label for a switch statement. */
4600 gimple_switch_set_default_label (gswitch
*gs
, tree label
)
4602 gcc_checking_assert (!CASE_LOW (label
) && !CASE_HIGH (label
));
4603 gimple_switch_set_label (gs
, 0, label
);
4606 /* Return true if GS is a GIMPLE_DEBUG statement. */
4609 is_gimple_debug (const gimple
*gs
)
4611 return gimple_code (gs
) == GIMPLE_DEBUG
;
4615 /* Return the last nondebug statement in GIMPLE sequence S. */
4617 static inline gimple
*
4618 gimple_seq_last_nondebug_stmt (gimple_seq s
)
4621 for (n
= gimple_seq_last (s
);
4622 n
&& is_gimple_debug (n
);
4630 /* Return true if S is a GIMPLE_DEBUG BIND statement. */
4633 gimple_debug_bind_p (const gimple
*s
)
4635 if (is_gimple_debug (s
))
4636 return s
->subcode
== GIMPLE_DEBUG_BIND
;
4641 /* Return the variable bound in a GIMPLE_DEBUG bind statement. */
4644 gimple_debug_bind_get_var (gimple
*dbg
)
4646 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4647 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4648 return gimple_op (dbg
, 0);
4651 /* Return the value bound to the variable in a GIMPLE_DEBUG bind
4655 gimple_debug_bind_get_value (gimple
*dbg
)
4657 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4658 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4659 return gimple_op (dbg
, 1);
4662 /* Return a pointer to the value bound to the variable in a
4663 GIMPLE_DEBUG bind statement. */
4665 static inline tree
*
4666 gimple_debug_bind_get_value_ptr (gimple
*dbg
)
4668 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4669 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4670 return gimple_op_ptr (dbg
, 1);
4673 /* Set the variable bound in a GIMPLE_DEBUG bind statement. */
4676 gimple_debug_bind_set_var (gimple
*dbg
, tree var
)
4678 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4679 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4680 gimple_set_op (dbg
, 0, var
);
4683 /* Set the value bound to the variable in a GIMPLE_DEBUG bind
4687 gimple_debug_bind_set_value (gimple
*dbg
, tree value
)
4689 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4690 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4691 gimple_set_op (dbg
, 1, value
);
4694 /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
4696 #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
4698 /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
4702 gimple_debug_bind_reset_value (gimple
*dbg
)
4704 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4705 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4706 gimple_set_op (dbg
, 1, GIMPLE_DEBUG_BIND_NOVALUE
);
4709 /* Return true if the GIMPLE_DEBUG bind statement is bound to a
4713 gimple_debug_bind_has_value_p (gimple
*dbg
)
4715 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4716 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4717 return gimple_op (dbg
, 1) != GIMPLE_DEBUG_BIND_NOVALUE
;
4720 #undef GIMPLE_DEBUG_BIND_NOVALUE
4722 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
4725 gimple_debug_source_bind_p (const gimple
*s
)
4727 if (is_gimple_debug (s
))
4728 return s
->subcode
== GIMPLE_DEBUG_SOURCE_BIND
;
4733 /* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
4736 gimple_debug_source_bind_get_var (gimple
*dbg
)
4738 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4739 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4740 return gimple_op (dbg
, 0);
4743 /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
4747 gimple_debug_source_bind_get_value (gimple
*dbg
)
4749 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4750 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4751 return gimple_op (dbg
, 1);
4754 /* Return a pointer to the value bound to the variable in a
4755 GIMPLE_DEBUG source bind statement. */
4757 static inline tree
*
4758 gimple_debug_source_bind_get_value_ptr (gimple
*dbg
)
4760 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4761 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4762 return gimple_op_ptr (dbg
, 1);
4765 /* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
4768 gimple_debug_source_bind_set_var (gimple
*dbg
, tree var
)
4770 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4771 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4772 gimple_set_op (dbg
, 0, var
);
4775 /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
4779 gimple_debug_source_bind_set_value (gimple
*dbg
, tree value
)
4781 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4782 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4783 gimple_set_op (dbg
, 1, value
);
4786 /* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement. */
4789 gimple_debug_begin_stmt_p (const gimple
*s
)
4791 if (is_gimple_debug (s
))
4792 return s
->subcode
== GIMPLE_DEBUG_BEGIN_STMT
;
4797 /* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement. */
4800 gimple_debug_inline_entry_p (const gimple
*s
)
4802 if (is_gimple_debug (s
))
4803 return s
->subcode
== GIMPLE_DEBUG_INLINE_ENTRY
;
4808 /* Return true if S is a GIMPLE_DEBUG non-binding marker statement. */
4811 gimple_debug_nonbind_marker_p (const gimple
*s
)
4813 if (is_gimple_debug (s
))
4814 return s
->subcode
== GIMPLE_DEBUG_BEGIN_STMT
4815 || s
->subcode
== GIMPLE_DEBUG_INLINE_ENTRY
;
4820 /* Return the line number for EXPR, or return -1 if we have no line
4821 number information for it. */
4823 get_lineno (const gimple
*stmt
)
4830 loc
= gimple_location (stmt
);
4831 if (loc
== UNKNOWN_LOCATION
)
4834 return LOCATION_LINE (loc
);
4837 /* Return a pointer to the body for the OMP statement GS. */
4839 static inline gimple_seq
*
4840 gimple_omp_body_ptr (gimple
*gs
)
4842 return &static_cast <gimple_statement_omp
*> (gs
)->body
;
4845 /* Return the body for the OMP statement GS. */
4847 static inline gimple_seq
4848 gimple_omp_body (gimple
*gs
)
4850 return *gimple_omp_body_ptr (gs
);
4853 /* Set BODY to be the body for the OMP statement GS. */
4856 gimple_omp_set_body (gimple
*gs
, gimple_seq body
)
4858 static_cast <gimple_statement_omp
*> (gs
)->body
= body
;
4862 /* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */
4865 gimple_omp_critical_name (const gomp_critical
*crit_stmt
)
4867 return crit_stmt
->name
;
4871 /* Return a pointer to the name associated with OMP critical statement
4874 static inline tree
*
4875 gimple_omp_critical_name_ptr (gomp_critical
*crit_stmt
)
4877 return &crit_stmt
->name
;
4881 /* Set NAME to be the name associated with OMP critical statement
4885 gimple_omp_critical_set_name (gomp_critical
*crit_stmt
, tree name
)
4887 crit_stmt
->name
= name
;
4891 /* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */
4894 gimple_omp_critical_clauses (const gomp_critical
*crit_stmt
)
4896 return crit_stmt
->clauses
;
4900 /* Return a pointer to the clauses associated with OMP critical statement
4903 static inline tree
*
4904 gimple_omp_critical_clauses_ptr (gomp_critical
*crit_stmt
)
4906 return &crit_stmt
->clauses
;
4910 /* Set CLAUSES to be the clauses associated with OMP critical statement
4914 gimple_omp_critical_set_clauses (gomp_critical
*crit_stmt
, tree clauses
)
4916 crit_stmt
->clauses
= clauses
;
4920 /* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */
4923 gimple_omp_ordered_clauses (const gomp_ordered
*ord_stmt
)
4925 return ord_stmt
->clauses
;
4929 /* Return a pointer to the clauses associated with OMP ordered statement
4932 static inline tree
*
4933 gimple_omp_ordered_clauses_ptr (gomp_ordered
*ord_stmt
)
4935 return &ord_stmt
->clauses
;
4939 /* Set CLAUSES to be the clauses associated with OMP ordered statement
4943 gimple_omp_ordered_set_clauses (gomp_ordered
*ord_stmt
, tree clauses
)
4945 ord_stmt
->clauses
= clauses
;
4949 /* Return the clauses associated with OMP_TASKGROUP statement GS. */
4952 gimple_omp_taskgroup_clauses (const gimple
*gs
)
4954 GIMPLE_CHECK (gs
, GIMPLE_OMP_TASKGROUP
);
4956 static_cast <const gimple_statement_omp_single_layout
*> (gs
)->clauses
;
4960 /* Return a pointer to the clauses associated with OMP taskgroup statement
4963 static inline tree
*
4964 gimple_omp_taskgroup_clauses_ptr (gimple
*gs
)
4966 GIMPLE_CHECK (gs
, GIMPLE_OMP_TASKGROUP
);
4967 return &static_cast <gimple_statement_omp_single_layout
*> (gs
)->clauses
;
4971 /* Set CLAUSES to be the clauses associated with OMP taskgroup statement
4975 gimple_omp_taskgroup_set_clauses (gimple
*gs
, tree clauses
)
4977 GIMPLE_CHECK (gs
, GIMPLE_OMP_TASKGROUP
);
4978 static_cast <gimple_statement_omp_single_layout
*> (gs
)->clauses
4983 /* Return the kind of the OMP_FOR statemement G. */
4986 gimple_omp_for_kind (const gimple
*g
)
4988 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4989 return (gimple_omp_subcode (g
) & GF_OMP_FOR_KIND_MASK
);
4993 /* Set the kind of the OMP_FOR statement G. */
4996 gimple_omp_for_set_kind (gomp_for
*g
, int kind
)
4998 g
->subcode
= (g
->subcode
& ~GF_OMP_FOR_KIND_MASK
)
4999 | (kind
& GF_OMP_FOR_KIND_MASK
);
5003 /* Return true if OMP_FOR statement G has the
5004 GF_OMP_FOR_COMBINED flag set. */
5007 gimple_omp_for_combined_p (const gimple
*g
)
5009 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
5010 return (gimple_omp_subcode (g
) & GF_OMP_FOR_COMBINED
) != 0;
5014 /* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
5015 the boolean value of COMBINED_P. */
5018 gimple_omp_for_set_combined_p (gomp_for
*g
, bool combined_p
)
5021 g
->subcode
|= GF_OMP_FOR_COMBINED
;
5023 g
->subcode
&= ~GF_OMP_FOR_COMBINED
;
5027 /* Return true if the OMP_FOR statement G has the
5028 GF_OMP_FOR_COMBINED_INTO flag set. */
5031 gimple_omp_for_combined_into_p (const gimple
*g
)
5033 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
5034 return (gimple_omp_subcode (g
) & GF_OMP_FOR_COMBINED_INTO
) != 0;
5038 /* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
5039 on the boolean value of COMBINED_P. */
5042 gimple_omp_for_set_combined_into_p (gomp_for
*g
, bool combined_p
)
5045 g
->subcode
|= GF_OMP_FOR_COMBINED_INTO
;
5047 g
->subcode
&= ~GF_OMP_FOR_COMBINED_INTO
;
5051 /* Return the clauses associated with the OMP_FOR statement GS. */
5054 gimple_omp_for_clauses (const gimple
*gs
)
5056 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5057 return omp_for_stmt
->clauses
;
5061 /* Return a pointer to the clauses associated with the OMP_FOR statement
5064 static inline tree
*
5065 gimple_omp_for_clauses_ptr (gimple
*gs
)
5067 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5068 return &omp_for_stmt
->clauses
;
5072 /* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
5076 gimple_omp_for_set_clauses (gimple
*gs
, tree clauses
)
5078 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5079 omp_for_stmt
->clauses
= clauses
;
5083 /* Get the collapse count of the OMP_FOR statement GS. */
5085 static inline size_t
5086 gimple_omp_for_collapse (gimple
*gs
)
5088 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5089 return omp_for_stmt
->collapse
;
5093 /* Return the condition code associated with the OMP_FOR statement GS. */
5095 static inline enum tree_code
5096 gimple_omp_for_cond (const gimple
*gs
, size_t i
)
5098 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5099 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5100 return omp_for_stmt
->iter
[i
].cond
;
5104 /* Set COND to be the condition code for the OMP_FOR statement GS. */
5107 gimple_omp_for_set_cond (gimple
*gs
, size_t i
, enum tree_code cond
)
5109 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5110 gcc_gimple_checking_assert (TREE_CODE_CLASS (cond
) == tcc_comparison
5111 && i
< omp_for_stmt
->collapse
);
5112 omp_for_stmt
->iter
[i
].cond
= cond
;
5116 /* Return the index variable for the OMP_FOR statement GS. */
5119 gimple_omp_for_index (const gimple
*gs
, size_t i
)
5121 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5122 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5123 return omp_for_stmt
->iter
[i
].index
;
5127 /* Return a pointer to the index variable for the OMP_FOR statement GS. */
5129 static inline tree
*
5130 gimple_omp_for_index_ptr (gimple
*gs
, size_t i
)
5132 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5133 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5134 return &omp_for_stmt
->iter
[i
].index
;
5138 /* Set INDEX to be the index variable for the OMP_FOR statement GS. */
5141 gimple_omp_for_set_index (gimple
*gs
, size_t i
, tree index
)
5143 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5144 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5145 omp_for_stmt
->iter
[i
].index
= index
;
5149 /* Return the initial value for the OMP_FOR statement GS. */
5152 gimple_omp_for_initial (const gimple
*gs
, size_t i
)
5154 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5155 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5156 return omp_for_stmt
->iter
[i
].initial
;
5160 /* Return a pointer to the initial value for the OMP_FOR statement GS. */
5162 static inline tree
*
5163 gimple_omp_for_initial_ptr (gimple
*gs
, size_t i
)
5165 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5166 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5167 return &omp_for_stmt
->iter
[i
].initial
;
5171 /* Set INITIAL to be the initial value for the OMP_FOR statement GS. */
5174 gimple_omp_for_set_initial (gimple
*gs
, size_t i
, tree initial
)
5176 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5177 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5178 omp_for_stmt
->iter
[i
].initial
= initial
;
5182 /* Return the final value for the OMP_FOR statement GS. */
5185 gimple_omp_for_final (const gimple
*gs
, size_t i
)
5187 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5188 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5189 return omp_for_stmt
->iter
[i
].final
;
5193 /* Return a pointer to the final value for the OMP_FOR statement GS. */
5195 static inline tree
*
5196 gimple_omp_for_final_ptr (gimple
*gs
, size_t i
)
5198 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5199 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5200 return &omp_for_stmt
->iter
[i
].final
;
5204 /* Set FINAL to be the final value for the OMP_FOR statement GS. */
5207 gimple_omp_for_set_final (gimple
*gs
, size_t i
, tree final
)
5209 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5210 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5211 omp_for_stmt
->iter
[i
].final
= final
;
5215 /* Return the increment value for the OMP_FOR statement GS. */
5218 gimple_omp_for_incr (const gimple
*gs
, size_t i
)
5220 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5221 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5222 return omp_for_stmt
->iter
[i
].incr
;
5226 /* Return a pointer to the increment value for the OMP_FOR statement GS. */
5228 static inline tree
*
5229 gimple_omp_for_incr_ptr (gimple
*gs
, size_t i
)
5231 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5232 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5233 return &omp_for_stmt
->iter
[i
].incr
;
5237 /* Set INCR to be the increment value for the OMP_FOR statement GS. */
5240 gimple_omp_for_set_incr (gimple
*gs
, size_t i
, tree incr
)
5242 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5243 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5244 omp_for_stmt
->iter
[i
].incr
= incr
;
5248 /* Return a pointer to the sequence of statements to execute before the OMP_FOR
5249 statement GS starts. */
5251 static inline gimple_seq
*
5252 gimple_omp_for_pre_body_ptr (gimple
*gs
)
5254 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5255 return &omp_for_stmt
->pre_body
;
5259 /* Return the sequence of statements to execute before the OMP_FOR
5260 statement GS starts. */
5262 static inline gimple_seq
5263 gimple_omp_for_pre_body (gimple
*gs
)
5265 return *gimple_omp_for_pre_body_ptr (gs
);
5269 /* Set PRE_BODY to be the sequence of statements to execute before the
5270 OMP_FOR statement GS starts. */
5273 gimple_omp_for_set_pre_body (gimple
*gs
, gimple_seq pre_body
)
5275 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5276 omp_for_stmt
->pre_body
= pre_body
;
5279 /* Return the kernel_phony of OMP_FOR statement. */
5282 gimple_omp_for_grid_phony (const gomp_for
*omp_for
)
5284 gcc_checking_assert (gimple_omp_for_kind (omp_for
)
5285 != GF_OMP_FOR_KIND_GRID_LOOP
);
5286 return (gimple_omp_subcode (omp_for
) & GF_OMP_FOR_GRID_PHONY
) != 0;
5289 /* Set kernel_phony flag of OMP_FOR to VALUE. */
5292 gimple_omp_for_set_grid_phony (gomp_for
*omp_for
, bool value
)
5294 gcc_checking_assert (gimple_omp_for_kind (omp_for
)
5295 != GF_OMP_FOR_KIND_GRID_LOOP
);
5297 omp_for
->subcode
|= GF_OMP_FOR_GRID_PHONY
;
5299 omp_for
->subcode
&= ~GF_OMP_FOR_GRID_PHONY
;
5302 /* Return the kernel_intra_group of a GRID_LOOP OMP_FOR statement. */
5305 gimple_omp_for_grid_intra_group (const gomp_for
*omp_for
)
5307 gcc_checking_assert (gimple_omp_for_kind (omp_for
)
5308 == GF_OMP_FOR_KIND_GRID_LOOP
);
5309 return (gimple_omp_subcode (omp_for
) & GF_OMP_FOR_GRID_INTRA_GROUP
) != 0;
5312 /* Set kernel_intra_group flag of OMP_FOR to VALUE. */
5315 gimple_omp_for_set_grid_intra_group (gomp_for
*omp_for
, bool value
)
5317 gcc_checking_assert (gimple_omp_for_kind (omp_for
)
5318 == GF_OMP_FOR_KIND_GRID_LOOP
);
5320 omp_for
->subcode
|= GF_OMP_FOR_GRID_INTRA_GROUP
;
5322 omp_for
->subcode
&= ~GF_OMP_FOR_GRID_INTRA_GROUP
;
5325 /* Return true if iterations of a grid OMP_FOR statement correspond to HSA
5329 gimple_omp_for_grid_group_iter (const gomp_for
*omp_for
)
5331 gcc_checking_assert (gimple_omp_for_kind (omp_for
)
5332 == GF_OMP_FOR_KIND_GRID_LOOP
);
5333 return (gimple_omp_subcode (omp_for
) & GF_OMP_FOR_GRID_GROUP_ITER
) != 0;
5336 /* Set group_iter flag of OMP_FOR to VALUE. */
5339 gimple_omp_for_set_grid_group_iter (gomp_for
*omp_for
, bool value
)
5341 gcc_checking_assert (gimple_omp_for_kind (omp_for
)
5342 == GF_OMP_FOR_KIND_GRID_LOOP
);
5344 omp_for
->subcode
|= GF_OMP_FOR_GRID_GROUP_ITER
;
5346 omp_for
->subcode
&= ~GF_OMP_FOR_GRID_GROUP_ITER
;
5349 /* Return the clauses associated with OMP_PARALLEL GS. */
5352 gimple_omp_parallel_clauses (const gimple
*gs
)
5354 const gomp_parallel
*omp_parallel_stmt
= as_a
<const gomp_parallel
*> (gs
);
5355 return omp_parallel_stmt
->clauses
;
5359 /* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */
5361 static inline tree
*
5362 gimple_omp_parallel_clauses_ptr (gomp_parallel
*omp_parallel_stmt
)
5364 return &omp_parallel_stmt
->clauses
;
5368 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */
5371 gimple_omp_parallel_set_clauses (gomp_parallel
*omp_parallel_stmt
,
5374 omp_parallel_stmt
->clauses
= clauses
;
5378 /* Return the child function used to hold the body of OMP_PARALLEL_STMT. */
5381 gimple_omp_parallel_child_fn (const gomp_parallel
*omp_parallel_stmt
)
5383 return omp_parallel_stmt
->child_fn
;
5386 /* Return a pointer to the child function used to hold the body of
5387 OMP_PARALLEL_STMT. */
5389 static inline tree
*
5390 gimple_omp_parallel_child_fn_ptr (gomp_parallel
*omp_parallel_stmt
)
5392 return &omp_parallel_stmt
->child_fn
;
5396 /* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */
5399 gimple_omp_parallel_set_child_fn (gomp_parallel
*omp_parallel_stmt
,
5402 omp_parallel_stmt
->child_fn
= child_fn
;
5406 /* Return the artificial argument used to send variables and values
5407 from the parent to the children threads in OMP_PARALLEL_STMT. */
5410 gimple_omp_parallel_data_arg (const gomp_parallel
*omp_parallel_stmt
)
5412 return omp_parallel_stmt
->data_arg
;
5416 /* Return a pointer to the data argument for OMP_PARALLEL_STMT. */
5418 static inline tree
*
5419 gimple_omp_parallel_data_arg_ptr (gomp_parallel
*omp_parallel_stmt
)
5421 return &omp_parallel_stmt
->data_arg
;
5425 /* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */
5428 gimple_omp_parallel_set_data_arg (gomp_parallel
*omp_parallel_stmt
,
5431 omp_parallel_stmt
->data_arg
= data_arg
;
5434 /* Return the kernel_phony flag of OMP_PARALLEL_STMT. */
5437 gimple_omp_parallel_grid_phony (const gomp_parallel
*stmt
)
5439 return (gimple_omp_subcode (stmt
) & GF_OMP_PARALLEL_GRID_PHONY
) != 0;
5442 /* Set kernel_phony flag of OMP_PARALLEL_STMT to VALUE. */
5445 gimple_omp_parallel_set_grid_phony (gomp_parallel
*stmt
, bool value
)
5448 stmt
->subcode
|= GF_OMP_PARALLEL_GRID_PHONY
;
5450 stmt
->subcode
&= ~GF_OMP_PARALLEL_GRID_PHONY
;
5453 /* Return the clauses associated with OMP_TASK GS. */
5456 gimple_omp_task_clauses (const gimple
*gs
)
5458 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5459 return omp_task_stmt
->clauses
;
5463 /* Return a pointer to the clauses associated with OMP_TASK GS. */
5465 static inline tree
*
5466 gimple_omp_task_clauses_ptr (gimple
*gs
)
5468 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5469 return &omp_task_stmt
->clauses
;
5473 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5477 gimple_omp_task_set_clauses (gimple
*gs
, tree clauses
)
5479 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5480 omp_task_stmt
->clauses
= clauses
;
5484 /* Return true if OMP task statement G has the
5485 GF_OMP_TASK_TASKLOOP flag set. */
5488 gimple_omp_task_taskloop_p (const gimple
*g
)
5490 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5491 return (gimple_omp_subcode (g
) & GF_OMP_TASK_TASKLOOP
) != 0;
5495 /* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
5496 value of TASKLOOP_P. */
5499 gimple_omp_task_set_taskloop_p (gimple
*g
, bool taskloop_p
)
5501 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5503 g
->subcode
|= GF_OMP_TASK_TASKLOOP
;
5505 g
->subcode
&= ~GF_OMP_TASK_TASKLOOP
;
5509 /* Return true if OMP task statement G has the
5510 GF_OMP_TASK_TASKWAIT flag set. */
5513 gimple_omp_task_taskwait_p (const gimple
*g
)
5515 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5516 return (gimple_omp_subcode (g
) & GF_OMP_TASK_TASKWAIT
) != 0;
5520 /* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
5521 value of TASKWAIT_P. */
5524 gimple_omp_task_set_taskwait_p (gimple
*g
, bool taskwait_p
)
5526 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5528 g
->subcode
|= GF_OMP_TASK_TASKWAIT
;
5530 g
->subcode
&= ~GF_OMP_TASK_TASKWAIT
;
5534 /* Return the child function used to hold the body of OMP_TASK GS. */
5537 gimple_omp_task_child_fn (const gimple
*gs
)
5539 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5540 return omp_task_stmt
->child_fn
;
5543 /* Return a pointer to the child function used to hold the body of
5546 static inline tree
*
5547 gimple_omp_task_child_fn_ptr (gimple
*gs
)
5549 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5550 return &omp_task_stmt
->child_fn
;
5554 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
5557 gimple_omp_task_set_child_fn (gimple
*gs
, tree child_fn
)
5559 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5560 omp_task_stmt
->child_fn
= child_fn
;
5564 /* Return the artificial argument used to send variables and values
5565 from the parent to the children threads in OMP_TASK GS. */
5568 gimple_omp_task_data_arg (const gimple
*gs
)
5570 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5571 return omp_task_stmt
->data_arg
;
5575 /* Return a pointer to the data argument for OMP_TASK GS. */
5577 static inline tree
*
5578 gimple_omp_task_data_arg_ptr (gimple
*gs
)
5580 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5581 return &omp_task_stmt
->data_arg
;
5585 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
5588 gimple_omp_task_set_data_arg (gimple
*gs
, tree data_arg
)
5590 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5591 omp_task_stmt
->data_arg
= data_arg
;
5595 /* Return the clauses associated with OMP_TASK GS. */
5598 gimple_omp_taskreg_clauses (const gimple
*gs
)
5600 const gimple_statement_omp_taskreg
*omp_taskreg_stmt
5601 = as_a
<const gimple_statement_omp_taskreg
*> (gs
);
5602 return omp_taskreg_stmt
->clauses
;
5606 /* Return a pointer to the clauses associated with OMP_TASK GS. */
5608 static inline tree
*
5609 gimple_omp_taskreg_clauses_ptr (gimple
*gs
)
5611 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5612 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5613 return &omp_taskreg_stmt
->clauses
;
5617 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5621 gimple_omp_taskreg_set_clauses (gimple
*gs
, tree clauses
)
5623 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5624 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5625 omp_taskreg_stmt
->clauses
= clauses
;
5629 /* Return the child function used to hold the body of OMP_TASK GS. */
5632 gimple_omp_taskreg_child_fn (const gimple
*gs
)
5634 const gimple_statement_omp_taskreg
*omp_taskreg_stmt
5635 = as_a
<const gimple_statement_omp_taskreg
*> (gs
);
5636 return omp_taskreg_stmt
->child_fn
;
5639 /* Return a pointer to the child function used to hold the body of
5642 static inline tree
*
5643 gimple_omp_taskreg_child_fn_ptr (gimple
*gs
)
5645 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5646 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5647 return &omp_taskreg_stmt
->child_fn
;
5651 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
5654 gimple_omp_taskreg_set_child_fn (gimple
*gs
, tree child_fn
)
5656 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5657 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5658 omp_taskreg_stmt
->child_fn
= child_fn
;
5662 /* Return the artificial argument used to send variables and values
5663 from the parent to the children threads in OMP_TASK GS. */
5666 gimple_omp_taskreg_data_arg (const gimple
*gs
)
5668 const gimple_statement_omp_taskreg
*omp_taskreg_stmt
5669 = as_a
<const gimple_statement_omp_taskreg
*> (gs
);
5670 return omp_taskreg_stmt
->data_arg
;
5674 /* Return a pointer to the data argument for OMP_TASK GS. */
5676 static inline tree
*
5677 gimple_omp_taskreg_data_arg_ptr (gimple
*gs
)
5679 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5680 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5681 return &omp_taskreg_stmt
->data_arg
;
5685 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
5688 gimple_omp_taskreg_set_data_arg (gimple
*gs
, tree data_arg
)
5690 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5691 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5692 omp_taskreg_stmt
->data_arg
= data_arg
;
5696 /* Return the copy function used to hold the body of OMP_TASK GS. */
5699 gimple_omp_task_copy_fn (const gimple
*gs
)
5701 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5702 return omp_task_stmt
->copy_fn
;
5705 /* Return a pointer to the copy function used to hold the body of
5708 static inline tree
*
5709 gimple_omp_task_copy_fn_ptr (gimple
*gs
)
5711 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5712 return &omp_task_stmt
->copy_fn
;
5716 /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
5719 gimple_omp_task_set_copy_fn (gimple
*gs
, tree copy_fn
)
5721 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5722 omp_task_stmt
->copy_fn
= copy_fn
;
5726 /* Return size of the data block in bytes in OMP_TASK GS. */
5729 gimple_omp_task_arg_size (const gimple
*gs
)
5731 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5732 return omp_task_stmt
->arg_size
;
5736 /* Return a pointer to the data block size for OMP_TASK GS. */
5738 static inline tree
*
5739 gimple_omp_task_arg_size_ptr (gimple
*gs
)
5741 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5742 return &omp_task_stmt
->arg_size
;
5746 /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
5749 gimple_omp_task_set_arg_size (gimple
*gs
, tree arg_size
)
5751 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5752 omp_task_stmt
->arg_size
= arg_size
;
5756 /* Return align of the data block in bytes in OMP_TASK GS. */
5759 gimple_omp_task_arg_align (const gimple
*gs
)
5761 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5762 return omp_task_stmt
->arg_align
;
5766 /* Return a pointer to the data block align for OMP_TASK GS. */
5768 static inline tree
*
5769 gimple_omp_task_arg_align_ptr (gimple
*gs
)
5771 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5772 return &omp_task_stmt
->arg_align
;
5776 /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
5779 gimple_omp_task_set_arg_align (gimple
*gs
, tree arg_align
)
5781 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5782 omp_task_stmt
->arg_align
= arg_align
;
5786 /* Return the clauses associated with OMP_SINGLE GS. */
5789 gimple_omp_single_clauses (const gimple
*gs
)
5791 const gomp_single
*omp_single_stmt
= as_a
<const gomp_single
*> (gs
);
5792 return omp_single_stmt
->clauses
;
5796 /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
5798 static inline tree
*
5799 gimple_omp_single_clauses_ptr (gimple
*gs
)
5801 gomp_single
*omp_single_stmt
= as_a
<gomp_single
*> (gs
);
5802 return &omp_single_stmt
->clauses
;
5806 /* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */
5809 gimple_omp_single_set_clauses (gomp_single
*omp_single_stmt
, tree clauses
)
5811 omp_single_stmt
->clauses
= clauses
;
5815 /* Return the clauses associated with OMP_TARGET GS. */
5818 gimple_omp_target_clauses (const gimple
*gs
)
5820 const gomp_target
*omp_target_stmt
= as_a
<const gomp_target
*> (gs
);
5821 return omp_target_stmt
->clauses
;
5825 /* Return a pointer to the clauses associated with OMP_TARGET GS. */
5827 static inline tree
*
5828 gimple_omp_target_clauses_ptr (gimple
*gs
)
5830 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (gs
);
5831 return &omp_target_stmt
->clauses
;
5835 /* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */
5838 gimple_omp_target_set_clauses (gomp_target
*omp_target_stmt
,
5841 omp_target_stmt
->clauses
= clauses
;
5845 /* Return the kind of the OMP_TARGET G. */
5848 gimple_omp_target_kind (const gimple
*g
)
5850 GIMPLE_CHECK (g
, GIMPLE_OMP_TARGET
);
5851 return (gimple_omp_subcode (g
) & GF_OMP_TARGET_KIND_MASK
);
5855 /* Set the kind of the OMP_TARGET G. */
5858 gimple_omp_target_set_kind (gomp_target
*g
, int kind
)
5860 g
->subcode
= (g
->subcode
& ~GF_OMP_TARGET_KIND_MASK
)
5861 | (kind
& GF_OMP_TARGET_KIND_MASK
);
5865 /* Return the child function used to hold the body of OMP_TARGET_STMT. */
5868 gimple_omp_target_child_fn (const gomp_target
*omp_target_stmt
)
5870 return omp_target_stmt
->child_fn
;
5873 /* Return a pointer to the child function used to hold the body of
5876 static inline tree
*
5877 gimple_omp_target_child_fn_ptr (gomp_target
*omp_target_stmt
)
5879 return &omp_target_stmt
->child_fn
;
5883 /* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */
5886 gimple_omp_target_set_child_fn (gomp_target
*omp_target_stmt
,
5889 omp_target_stmt
->child_fn
= child_fn
;
5893 /* Return the artificial argument used to send variables and values
5894 from the parent to the children threads in OMP_TARGET_STMT. */
5897 gimple_omp_target_data_arg (const gomp_target
*omp_target_stmt
)
5899 return omp_target_stmt
->data_arg
;
5903 /* Return a pointer to the data argument for OMP_TARGET GS. */
5905 static inline tree
*
5906 gimple_omp_target_data_arg_ptr (gomp_target
*omp_target_stmt
)
5908 return &omp_target_stmt
->data_arg
;
5912 /* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */
5915 gimple_omp_target_set_data_arg (gomp_target
*omp_target_stmt
,
5918 omp_target_stmt
->data_arg
= data_arg
;
5922 /* Return the clauses associated with OMP_TEAMS GS. */
5925 gimple_omp_teams_clauses (const gimple
*gs
)
5927 const gomp_teams
*omp_teams_stmt
= as_a
<const gomp_teams
*> (gs
);
5928 return omp_teams_stmt
->clauses
;
5932 /* Return a pointer to the clauses associated with OMP_TEAMS GS. */
5934 static inline tree
*
5935 gimple_omp_teams_clauses_ptr (gimple
*gs
)
5937 gomp_teams
*omp_teams_stmt
= as_a
<gomp_teams
*> (gs
);
5938 return &omp_teams_stmt
->clauses
;
5942 /* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */
5945 gimple_omp_teams_set_clauses (gomp_teams
*omp_teams_stmt
, tree clauses
)
5947 omp_teams_stmt
->clauses
= clauses
;
5950 /* Return the child function used to hold the body of OMP_TEAMS_STMT. */
5953 gimple_omp_teams_child_fn (const gomp_teams
*omp_teams_stmt
)
5955 return omp_teams_stmt
->child_fn
;
5958 /* Return a pointer to the child function used to hold the body of
5961 static inline tree
*
5962 gimple_omp_teams_child_fn_ptr (gomp_teams
*omp_teams_stmt
)
5964 return &omp_teams_stmt
->child_fn
;
5968 /* Set CHILD_FN to be the child function for OMP_TEAMS_STMT. */
5971 gimple_omp_teams_set_child_fn (gomp_teams
*omp_teams_stmt
, tree child_fn
)
5973 omp_teams_stmt
->child_fn
= child_fn
;
5977 /* Return the artificial argument used to send variables and values
5978 from the parent to the children threads in OMP_TEAMS_STMT. */
5981 gimple_omp_teams_data_arg (const gomp_teams
*omp_teams_stmt
)
5983 return omp_teams_stmt
->data_arg
;
5987 /* Return a pointer to the data argument for OMP_TEAMS_STMT. */
5989 static inline tree
*
5990 gimple_omp_teams_data_arg_ptr (gomp_teams
*omp_teams_stmt
)
5992 return &omp_teams_stmt
->data_arg
;
5996 /* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT. */
5999 gimple_omp_teams_set_data_arg (gomp_teams
*omp_teams_stmt
, tree data_arg
)
6001 omp_teams_stmt
->data_arg
= data_arg
;
6004 /* Return the kernel_phony flag of an OMP_TEAMS_STMT. */
6007 gimple_omp_teams_grid_phony (const gomp_teams
*omp_teams_stmt
)
6009 return (gimple_omp_subcode (omp_teams_stmt
) & GF_OMP_TEAMS_GRID_PHONY
) != 0;
6012 /* Set kernel_phony flag of an OMP_TEAMS_STMT to VALUE. */
6015 gimple_omp_teams_set_grid_phony (gomp_teams
*omp_teams_stmt
, bool value
)
6018 omp_teams_stmt
->subcode
|= GF_OMP_TEAMS_GRID_PHONY
;
6020 omp_teams_stmt
->subcode
&= ~GF_OMP_TEAMS_GRID_PHONY
;
6023 /* Return the host flag of an OMP_TEAMS_STMT. */
6026 gimple_omp_teams_host (const gomp_teams
*omp_teams_stmt
)
6028 return (gimple_omp_subcode (omp_teams_stmt
) & GF_OMP_TEAMS_HOST
) != 0;
6031 /* Set host flag of an OMP_TEAMS_STMT to VALUE. */
6034 gimple_omp_teams_set_host (gomp_teams
*omp_teams_stmt
, bool value
)
6037 omp_teams_stmt
->subcode
|= GF_OMP_TEAMS_HOST
;
6039 omp_teams_stmt
->subcode
&= ~GF_OMP_TEAMS_HOST
;
6042 /* Return the clauses associated with OMP_SECTIONS GS. */
6045 gimple_omp_sections_clauses (const gimple
*gs
)
6047 const gomp_sections
*omp_sections_stmt
= as_a
<const gomp_sections
*> (gs
);
6048 return omp_sections_stmt
->clauses
;
6052 /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
6054 static inline tree
*
6055 gimple_omp_sections_clauses_ptr (gimple
*gs
)
6057 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6058 return &omp_sections_stmt
->clauses
;
6062 /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6066 gimple_omp_sections_set_clauses (gimple
*gs
, tree clauses
)
6068 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6069 omp_sections_stmt
->clauses
= clauses
;
6073 /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6077 gimple_omp_sections_control (const gimple
*gs
)
6079 const gomp_sections
*omp_sections_stmt
= as_a
<const gomp_sections
*> (gs
);
6080 return omp_sections_stmt
->control
;
6084 /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6087 static inline tree
*
6088 gimple_omp_sections_control_ptr (gimple
*gs
)
6090 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6091 return &omp_sections_stmt
->control
;
6095 /* Set CONTROL to be the set of clauses associated with the
6096 GIMPLE_OMP_SECTIONS in GS. */
6099 gimple_omp_sections_set_control (gimple
*gs
, tree control
)
6101 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6102 omp_sections_stmt
->control
= control
;
6106 /* Set the value being stored in an atomic store. */
6109 gimple_omp_atomic_store_set_val (gomp_atomic_store
*store_stmt
, tree val
)
6111 store_stmt
->val
= val
;
6115 /* Return the value being stored in an atomic store. */
6118 gimple_omp_atomic_store_val (const gomp_atomic_store
*store_stmt
)
6120 return store_stmt
->val
;
6124 /* Return a pointer to the value being stored in an atomic store. */
6126 static inline tree
*
6127 gimple_omp_atomic_store_val_ptr (gomp_atomic_store
*store_stmt
)
6129 return &store_stmt
->val
;
6133 /* Set the LHS of an atomic load. */
6136 gimple_omp_atomic_load_set_lhs (gomp_atomic_load
*load_stmt
, tree lhs
)
6138 load_stmt
->lhs
= lhs
;
6142 /* Get the LHS of an atomic load. */
6145 gimple_omp_atomic_load_lhs (const gomp_atomic_load
*load_stmt
)
6147 return load_stmt
->lhs
;
6151 /* Return a pointer to the LHS of an atomic load. */
6153 static inline tree
*
6154 gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load
*load_stmt
)
6156 return &load_stmt
->lhs
;
6160 /* Set the RHS of an atomic load. */
6163 gimple_omp_atomic_load_set_rhs (gomp_atomic_load
*load_stmt
, tree rhs
)
6165 load_stmt
->rhs
= rhs
;
6169 /* Get the RHS of an atomic load. */
6172 gimple_omp_atomic_load_rhs (const gomp_atomic_load
*load_stmt
)
6174 return load_stmt
->rhs
;
6178 /* Return a pointer to the RHS of an atomic load. */
6180 static inline tree
*
6181 gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load
*load_stmt
)
6183 return &load_stmt
->rhs
;
6187 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6190 gimple_omp_continue_control_def (const gomp_continue
*cont_stmt
)
6192 return cont_stmt
->control_def
;
6195 /* The same as above, but return the address. */
6197 static inline tree
*
6198 gimple_omp_continue_control_def_ptr (gomp_continue
*cont_stmt
)
6200 return &cont_stmt
->control_def
;
6203 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6206 gimple_omp_continue_set_control_def (gomp_continue
*cont_stmt
, tree def
)
6208 cont_stmt
->control_def
= def
;
6212 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6215 gimple_omp_continue_control_use (const gomp_continue
*cont_stmt
)
6217 return cont_stmt
->control_use
;
6221 /* The same as above, but return the address. */
6223 static inline tree
*
6224 gimple_omp_continue_control_use_ptr (gomp_continue
*cont_stmt
)
6226 return &cont_stmt
->control_use
;
6230 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6233 gimple_omp_continue_set_control_use (gomp_continue
*cont_stmt
, tree use
)
6235 cont_stmt
->control_use
= use
;
6238 /* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6239 TRANSACTION_STMT. */
6241 static inline gimple_seq
*
6242 gimple_transaction_body_ptr (gtransaction
*transaction_stmt
)
6244 return &transaction_stmt
->body
;
6247 /* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */
6249 static inline gimple_seq
6250 gimple_transaction_body (gtransaction
*transaction_stmt
)
6252 return transaction_stmt
->body
;
6255 /* Return the label associated with a GIMPLE_TRANSACTION. */
6258 gimple_transaction_label_norm (const gtransaction
*transaction_stmt
)
6260 return transaction_stmt
->label_norm
;
6263 static inline tree
*
6264 gimple_transaction_label_norm_ptr (gtransaction
*transaction_stmt
)
6266 return &transaction_stmt
->label_norm
;
6270 gimple_transaction_label_uninst (const gtransaction
*transaction_stmt
)
6272 return transaction_stmt
->label_uninst
;
6275 static inline tree
*
6276 gimple_transaction_label_uninst_ptr (gtransaction
*transaction_stmt
)
6278 return &transaction_stmt
->label_uninst
;
6282 gimple_transaction_label_over (const gtransaction
*transaction_stmt
)
6284 return transaction_stmt
->label_over
;
6287 static inline tree
*
6288 gimple_transaction_label_over_ptr (gtransaction
*transaction_stmt
)
6290 return &transaction_stmt
->label_over
;
6293 /* Return the subcode associated with a GIMPLE_TRANSACTION. */
6295 static inline unsigned int
6296 gimple_transaction_subcode (const gtransaction
*transaction_stmt
)
6298 return transaction_stmt
->subcode
;
6301 /* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6302 TRANSACTION_STMT. */
6305 gimple_transaction_set_body (gtransaction
*transaction_stmt
,
6308 transaction_stmt
->body
= body
;
6311 /* Set the label associated with a GIMPLE_TRANSACTION. */
6314 gimple_transaction_set_label_norm (gtransaction
*transaction_stmt
, tree label
)
6316 transaction_stmt
->label_norm
= label
;
6320 gimple_transaction_set_label_uninst (gtransaction
*transaction_stmt
, tree label
)
6322 transaction_stmt
->label_uninst
= label
;
6326 gimple_transaction_set_label_over (gtransaction
*transaction_stmt
, tree label
)
6328 transaction_stmt
->label_over
= label
;
6331 /* Set the subcode associated with a GIMPLE_TRANSACTION. */
6334 gimple_transaction_set_subcode (gtransaction
*transaction_stmt
,
6335 unsigned int subcode
)
6337 transaction_stmt
->subcode
= subcode
;
6340 /* Return a pointer to the return value for GIMPLE_RETURN GS. */
6342 static inline tree
*
6343 gimple_return_retval_ptr (greturn
*gs
)
6348 /* Return the return value for GIMPLE_RETURN GS. */
6351 gimple_return_retval (const greturn
*gs
)
6357 /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
6360 gimple_return_set_retval (greturn
*gs
, tree retval
)
6366 /* Returns true when the gimple statement STMT is any of the OMP types. */
6368 #define CASE_GIMPLE_OMP \
6369 case GIMPLE_OMP_PARALLEL: \
6370 case GIMPLE_OMP_TASK: \
6371 case GIMPLE_OMP_FOR: \
6372 case GIMPLE_OMP_SECTIONS: \
6373 case GIMPLE_OMP_SECTIONS_SWITCH: \
6374 case GIMPLE_OMP_SINGLE: \
6375 case GIMPLE_OMP_TARGET: \
6376 case GIMPLE_OMP_TEAMS: \
6377 case GIMPLE_OMP_SECTION: \
6378 case GIMPLE_OMP_MASTER: \
6379 case GIMPLE_OMP_TASKGROUP: \
6380 case GIMPLE_OMP_ORDERED: \
6381 case GIMPLE_OMP_CRITICAL: \
6382 case GIMPLE_OMP_RETURN: \
6383 case GIMPLE_OMP_ATOMIC_LOAD: \
6384 case GIMPLE_OMP_ATOMIC_STORE: \
6385 case GIMPLE_OMP_CONTINUE: \
6386 case GIMPLE_OMP_GRID_BODY
6389 is_gimple_omp (const gimple
*stmt
)
6391 switch (gimple_code (stmt
))
6400 /* Return true if the OMP gimple statement STMT is any of the OpenACC types
6404 is_gimple_omp_oacc (const gimple
*stmt
)
6406 gcc_assert (is_gimple_omp (stmt
));
6407 switch (gimple_code (stmt
))
6409 case GIMPLE_OMP_FOR
:
6410 switch (gimple_omp_for_kind (stmt
))
6412 case GF_OMP_FOR_KIND_OACC_LOOP
:
6417 case GIMPLE_OMP_TARGET
:
6418 switch (gimple_omp_target_kind (stmt
))
6420 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
6421 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
6422 case GF_OMP_TARGET_KIND_OACC_DATA
:
6423 case GF_OMP_TARGET_KIND_OACC_UPDATE
:
6424 case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
:
6425 case GF_OMP_TARGET_KIND_OACC_DECLARE
:
6426 case GF_OMP_TARGET_KIND_OACC_HOST_DATA
:
6437 /* Return true if the OMP gimple statement STMT is offloaded. */
6440 is_gimple_omp_offloaded (const gimple
*stmt
)
6442 gcc_assert (is_gimple_omp (stmt
));
6443 switch (gimple_code (stmt
))
6445 case GIMPLE_OMP_TARGET
:
6446 switch (gimple_omp_target_kind (stmt
))
6448 case GF_OMP_TARGET_KIND_REGION
:
6449 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
6450 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
6461 /* Returns TRUE if statement G is a GIMPLE_NOP. */
6464 gimple_nop_p (const gimple
*g
)
6466 return gimple_code (g
) == GIMPLE_NOP
;
6470 /* Return true if GS is a GIMPLE_RESX. */
6473 is_gimple_resx (const gimple
*gs
)
6475 return gimple_code (gs
) == GIMPLE_RESX
;
6478 /* Return the type of the main expression computed by STMT. Return
6479 void_type_node if the statement computes nothing. */
6482 gimple_expr_type (const gimple
*stmt
)
6484 enum gimple_code code
= gimple_code (stmt
);
6485 /* In general we want to pass out a type that can be substituted
6486 for both the RHS and the LHS types if there is a possibly
6487 useless conversion involved. That means returning the
6488 original RHS type as far as we can reconstruct it. */
6489 if (code
== GIMPLE_CALL
)
6491 const gcall
*call_stmt
= as_a
<const gcall
*> (stmt
);
6492 if (gimple_call_internal_p (call_stmt
))
6493 switch (gimple_call_internal_fn (call_stmt
))
6495 case IFN_MASK_STORE
:
6496 case IFN_SCATTER_STORE
:
6497 return TREE_TYPE (gimple_call_arg (call_stmt
, 3));
6498 case IFN_MASK_SCATTER_STORE
:
6499 return TREE_TYPE (gimple_call_arg (call_stmt
, 4));
6503 return gimple_call_return_type (call_stmt
);
6505 else if (code
== GIMPLE_ASSIGN
)
6507 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
6508 return TREE_TYPE (gimple_assign_rhs1 (stmt
));
6510 /* As fallback use the type of the LHS. */
6511 return TREE_TYPE (gimple_get_lhs (stmt
));
6513 else if (code
== GIMPLE_COND
)
6514 return boolean_type_node
;
6516 return void_type_node
;
6519 /* Enum and arrays used for allocation stats. Keep in sync with
6520 gimple.c:gimple_alloc_kind_names. */
6521 enum gimple_alloc_kind
6523 gimple_alloc_kind_assign
, /* Assignments. */
6524 gimple_alloc_kind_phi
, /* PHI nodes. */
6525 gimple_alloc_kind_cond
, /* Conditionals. */
6526 gimple_alloc_kind_rest
, /* Everything else. */
6527 gimple_alloc_kind_all
6530 extern uint64_t gimple_alloc_counts
[];
6531 extern uint64_t gimple_alloc_sizes
[];
6533 /* Return the allocation kind for a given stmt CODE. */
6534 static inline enum gimple_alloc_kind
6535 gimple_alloc_kind (enum gimple_code code
)
6540 return gimple_alloc_kind_assign
;
6542 return gimple_alloc_kind_phi
;
6544 return gimple_alloc_kind_cond
;
6546 return gimple_alloc_kind_rest
;
6550 /* Return true if a location should not be emitted for this statement
6551 by annotate_all_with_location. */
6554 gimple_do_not_emit_location_p (gimple
*g
)
6556 return gimple_plf (g
, GF_PLF_1
);
6559 /* Mark statement G so a location will not be emitted by
6560 annotate_one_with_location. */
6563 gimple_set_do_not_emit_location (gimple
*g
)
6565 /* The PLF flags are initialized to 0 when a new tuple is created,
6566 so no need to initialize it anywhere. */
6567 gimple_set_plf (g
, GF_PLF_1
, true);
6570 #endif /* GCC_GIMPLE_H */