1 /* Gimple IR definitions.
3 Copyright (C) 2007-2020 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_TASK_TASKLOOP
= 1 << 0,
154 GF_OMP_TASK_TASKWAIT
= 1 << 1,
155 GF_OMP_FOR_KIND_MASK
= (1 << 3) - 1,
156 GF_OMP_FOR_KIND_FOR
= 0,
157 GF_OMP_FOR_KIND_DISTRIBUTE
= 1,
158 GF_OMP_FOR_KIND_TASKLOOP
= 2,
159 GF_OMP_FOR_KIND_OACC_LOOP
= 4,
160 GF_OMP_FOR_KIND_SIMD
= 5,
161 GF_OMP_FOR_COMBINED
= 1 << 3,
162 GF_OMP_FOR_COMBINED_INTO
= 1 << 4,
163 GF_OMP_TARGET_KIND_MASK
= (1 << 4) - 1,
164 GF_OMP_TARGET_KIND_REGION
= 0,
165 GF_OMP_TARGET_KIND_DATA
= 1,
166 GF_OMP_TARGET_KIND_UPDATE
= 2,
167 GF_OMP_TARGET_KIND_ENTER_DATA
= 3,
168 GF_OMP_TARGET_KIND_EXIT_DATA
= 4,
169 GF_OMP_TARGET_KIND_OACC_PARALLEL
= 5,
170 GF_OMP_TARGET_KIND_OACC_KERNELS
= 6,
171 GF_OMP_TARGET_KIND_OACC_SERIAL
= 7,
172 GF_OMP_TARGET_KIND_OACC_DATA
= 8,
173 GF_OMP_TARGET_KIND_OACC_UPDATE
= 9,
174 GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
= 10,
175 GF_OMP_TARGET_KIND_OACC_DECLARE
= 11,
176 GF_OMP_TARGET_KIND_OACC_HOST_DATA
= 12,
177 GF_OMP_TEAMS_HOST
= 1 << 0,
179 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
180 a thread synchronization via some sort of barrier. The exact barrier
181 that would otherwise be emitted is dependent on the OMP statement with
182 which this return is associated. */
183 GF_OMP_RETURN_NOWAIT
= 1 << 0,
185 GF_OMP_SECTION_LAST
= 1 << 0,
186 GF_OMP_ATOMIC_MEMORY_ORDER
= (1 << 3) - 1,
187 GF_OMP_ATOMIC_NEED_VALUE
= 1 << 3,
188 GF_PREDICT_TAKEN
= 1 << 15
191 /* This subcode tells apart different kinds of stmts that are not used
192 for codegen, but rather to retain debug information. */
193 enum gimple_debug_subcode
{
194 GIMPLE_DEBUG_BIND
= 0,
195 GIMPLE_DEBUG_SOURCE_BIND
= 1,
196 GIMPLE_DEBUG_BEGIN_STMT
= 2,
197 GIMPLE_DEBUG_INLINE_ENTRY
= 3
200 /* Masks for selecting a pass local flag (PLF) to work on. These
201 masks are used by gimple_set_plf and gimple_plf. */
207 /* Data structure definitions for GIMPLE tuples. NOTE: word markers
208 are for 64 bit hosts. */
210 struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
211 chain_next ("%h.next"), variable_size
))
215 Main identifying code for a tuple. */
216 ENUM_BITFIELD(gimple_code
) code
: 8;
218 /* Nonzero if a warning should not be emitted on this tuple. */
219 unsigned int no_warning
: 1;
221 /* Nonzero if this tuple has been visited. Passes are responsible
222 for clearing this bit before using it. */
223 unsigned int visited
: 1;
225 /* Nonzero if this tuple represents a non-temporal move. */
226 unsigned int nontemporal_move
: 1;
228 /* Pass local flags. These flags are free for any pass to use as
229 they see fit. Passes should not assume that these flags contain
230 any useful value when the pass starts. Any initial state that
231 the pass requires should be set on entry to the pass. See
232 gimple_set_plf and gimple_plf for usage. */
233 unsigned int plf
: 2;
235 /* Nonzero if this statement has been modified and needs to have its
236 operands rescanned. */
237 unsigned modified
: 1;
239 /* Nonzero if this statement contains volatile operands. */
240 unsigned has_volatile_ops
: 1;
242 /* Padding to get subcode to 16 bit alignment. */
245 /* The SUBCODE field can be used for tuple-specific flags for tuples
246 that do not require subcodes. Note that SUBCODE should be at
247 least as wide as tree codes, as several tuples store tree codes
249 unsigned int subcode
: 16;
251 /* UID of this statement. This is used by passes that want to
252 assign IDs to statements. It must be assigned and used by each
253 pass. By default it should be assumed to contain garbage. */
257 Locus information for debug info. */
260 /* Number of operands in this tuple. */
264 Basic block holding this statement. */
268 Linked lists of gimple statements. The next pointers form
269 a NULL terminated list, the prev pointers are a cyclic list.
270 A gimple statement is hence also a double-ended list of
271 statements, with the pointer itself being the first element,
272 and the prev pointer being the last. */
274 gimple
*GTY((skip
)) prev
;
278 /* Base structure for tuples with operands. */
280 /* This gimple subclass has no tag value. */
282 gimple_statement_with_ops_base
: public gimple
284 /* [ WORD 1-6 ] : base class */
287 SSA operand vectors. NOTE: It should be possible to
288 amalgamate these vectors with the operand vector OP. However,
289 the SSA operand vectors are organized differently and contain
290 more information (like immediate use chaining). */
291 struct use_optype_d
GTY((skip (""))) *use_ops
;
295 /* Statements that take register operands. */
297 struct GTY((tag("GSS_WITH_OPS")))
298 gimple_statement_with_ops
: public gimple_statement_with_ops_base
300 /* [ WORD 1-7 ] : base class */
303 Operand vector. NOTE! This must always be the last field
304 of this structure. In particular, this means that this
305 structure cannot be embedded inside another one. */
306 tree
GTY((length ("%h.num_ops"))) op
[1];
310 /* Base for statements that take both memory and register operands. */
312 struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
313 gimple_statement_with_memory_ops_base
: public gimple_statement_with_ops_base
315 /* [ WORD 1-7 ] : base class */
318 Virtual operands for this statement. The GC will pick them
319 up via the ssa_names array. */
320 tree
GTY((skip (""))) vdef
;
321 tree
GTY((skip (""))) vuse
;
325 /* Statements that take both memory and register operands. */
327 struct GTY((tag("GSS_WITH_MEM_OPS")))
328 gimple_statement_with_memory_ops
:
329 public gimple_statement_with_memory_ops_base
331 /* [ WORD 1-9 ] : base class */
334 Operand vector. NOTE! This must always be the last field
335 of this structure. In particular, this means that this
336 structure cannot be embedded inside another one. */
337 tree
GTY((length ("%h.num_ops"))) op
[1];
341 /* Call statements that take both memory and register operands. */
343 struct GTY((tag("GSS_CALL")))
344 gcall
: public gimple_statement_with_memory_ops_base
346 /* [ WORD 1-9 ] : base class */
349 struct pt_solution call_used
;
350 struct pt_solution call_clobbered
;
353 union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
354 tree
GTY ((tag ("0"))) fntype
;
355 enum internal_fn
GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn
;
359 Operand vector. NOTE! This must always be the last field
360 of this structure. In particular, this means that this
361 structure cannot be embedded inside another one. */
362 tree
GTY((length ("%h.num_ops"))) op
[1];
364 static const enum gimple_code code_
= GIMPLE_CALL
;
368 /* OMP statements. */
370 struct GTY((tag("GSS_OMP")))
371 gimple_statement_omp
: public gimple
373 /* [ WORD 1-6 ] : base class */
382 struct GTY((tag("GSS_BIND")))
383 gbind
: public gimple
385 /* [ WORD 1-6 ] : base class */
388 Variables declared in this scope. */
392 This is different than the BLOCK field in gimple,
393 which is analogous to TREE_BLOCK (i.e., the lexical block holding
394 this statement). This field is the equivalent of BIND_EXPR_BLOCK
395 in tree land (i.e., the lexical scope defined by this bind). See
406 struct GTY((tag("GSS_CATCH")))
407 gcatch
: public gimple
409 /* [ WORD 1-6 ] : base class */
419 /* GIMPLE_EH_FILTER */
421 struct GTY((tag("GSS_EH_FILTER")))
422 geh_filter
: public gimple
424 /* [ WORD 1-6 ] : base class */
437 struct GTY((tag("GSS_EH_ELSE")))
438 geh_else
: public gimple
440 /* [ WORD 1-6 ] : base class */
443 gimple_seq n_body
, e_body
;
446 /* GIMPLE_EH_MUST_NOT_THROW */
448 struct GTY((tag("GSS_EH_MNT")))
449 geh_mnt
: public gimple
451 /* [ WORD 1-6 ] : base class */
453 /* [ WORD 7 ] Abort function decl. */
459 struct GTY((tag("GSS_PHI")))
462 /* [ WORD 1-6 ] : base class */
472 struct phi_arg_d
GTY ((length ("%h.nargs"))) args
[1];
476 /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
478 struct GTY((tag("GSS_EH_CTRL")))
479 gimple_statement_eh_ctrl
: public gimple
481 /* [ WORD 1-6 ] : base class */
484 Exception region number. */
488 struct GTY((tag("GSS_EH_CTRL")))
489 gresx
: public gimple_statement_eh_ctrl
491 /* No extra fields; adds invariant:
492 stmt->code == GIMPLE_RESX. */
495 struct GTY((tag("GSS_EH_CTRL")))
496 geh_dispatch
: public gimple_statement_eh_ctrl
498 /* No extra fields; adds invariant:
499 stmt->code == GIMPLE_EH_DISPATH. */
505 struct GTY((tag("GSS_TRY")))
508 /* [ WORD 1-6 ] : base class */
511 Expression to evaluate. */
515 Cleanup expression. */
519 /* Kind of GIMPLE_TRY statements. */
520 enum gimple_try_flags
523 GIMPLE_TRY_CATCH
= 1 << 0,
526 GIMPLE_TRY_FINALLY
= 1 << 1,
527 GIMPLE_TRY_KIND
= GIMPLE_TRY_CATCH
| GIMPLE_TRY_FINALLY
,
529 /* Analogous to TRY_CATCH_IS_CLEANUP. */
530 GIMPLE_TRY_CATCH_IS_CLEANUP
= 1 << 2
533 /* GIMPLE_WITH_CLEANUP_EXPR */
535 struct GTY((tag("GSS_WCE")))
536 gimple_statement_wce
: public gimple
538 /* [ WORD 1-6 ] : base class */
540 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
541 executed if an exception is thrown, not on normal exit of its
542 scope. This flag is analogous to the CLEANUP_EH_ONLY flag
546 Cleanup expression. */
553 struct GTY((tag("GSS_ASM")))
554 gasm
: public gimple_statement_with_memory_ops_base
556 /* [ WORD 1-9 ] : base class */
559 __asm__ statement. */
563 Number of inputs, outputs, clobbers, labels. */
570 Operand vector. NOTE! This must always be the last field
571 of this structure. In particular, this means that this
572 structure cannot be embedded inside another one. */
573 tree
GTY((length ("%h.num_ops"))) op
[1];
576 /* GIMPLE_OMP_CRITICAL */
578 struct GTY((tag("GSS_OMP_CRITICAL")))
579 gomp_critical
: public gimple_statement_omp
581 /* [ WORD 1-7 ] : base class */
587 Critical section name. */
592 struct GTY(()) gimple_omp_for_iter
{
593 /* Condition code. */
596 /* Index variable. */
611 struct GTY((tag("GSS_OMP_FOR")))
612 gomp_for
: public gimple_statement_omp
614 /* [ WORD 1-7 ] : base class */
620 Number of elements in iter array. */
624 struct gimple_omp_for_iter
* GTY((length ("%h.collapse"))) iter
;
627 Pre-body evaluated before the loop body begins. */
632 /* GIMPLE_OMP_PARALLEL, GIMPLE_OMP_TARGET, GIMPLE_OMP_TASK, GIMPLE_OMP_TEAMS */
634 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
635 gimple_statement_omp_parallel_layout
: public gimple_statement_omp
637 /* [ WORD 1-7 ] : base class */
644 Child function holding the body of the parallel region. */
648 Shared data argument. */
652 /* GIMPLE_OMP_PARALLEL or GIMPLE_TASK */
653 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
654 gimple_statement_omp_taskreg
: public gimple_statement_omp_parallel_layout
656 /* No extra fields; adds invariant:
657 stmt->code == GIMPLE_OMP_PARALLEL
658 || stmt->code == GIMPLE_OMP_TASK
659 || stmt->code == GIMPLE_OMP_TEAMS. */
662 /* GIMPLE_OMP_PARALLEL */
663 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
664 gomp_parallel
: public gimple_statement_omp_taskreg
666 /* No extra fields; adds invariant:
667 stmt->code == GIMPLE_OMP_PARALLEL. */
670 /* GIMPLE_OMP_TARGET */
671 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
672 gomp_target
: public gimple_statement_omp_parallel_layout
674 /* No extra fields; adds invariant:
675 stmt->code == GIMPLE_OMP_TARGET. */
678 /* GIMPLE_OMP_TASK */
680 struct GTY((tag("GSS_OMP_TASK")))
681 gomp_task
: public gimple_statement_omp_taskreg
683 /* [ WORD 1-10 ] : base class */
686 Child function holding firstprivate initialization if needed. */
690 Size and alignment in bytes of the argument data block. */
696 /* GIMPLE_OMP_SECTION */
697 /* Uses struct gimple_statement_omp. */
700 /* GIMPLE_OMP_SECTIONS */
702 struct GTY((tag("GSS_OMP_SECTIONS")))
703 gomp_sections
: public gimple_statement_omp
705 /* [ WORD 1-7 ] : base class */
711 The control variable used for deciding which of the sections to
716 /* GIMPLE_OMP_CONTINUE.
718 Note: This does not inherit from gimple_statement_omp, because we
719 do not need the body field. */
721 struct GTY((tag("GSS_OMP_CONTINUE")))
722 gomp_continue
: public gimple
724 /* [ WORD 1-6 ] : base class */
733 /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_ORDERED, GIMPLE_OMP_TASKGROUP,
736 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
737 gimple_statement_omp_single_layout
: public gimple_statement_omp
739 /* [ WORD 1-7 ] : base class */
745 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
746 gomp_single
: public gimple_statement_omp_single_layout
748 /* No extra fields; adds invariant:
749 stmt->code == GIMPLE_OMP_SINGLE. */
752 struct GTY((tag("GSS_OMP_PARALLEL_LAYOUT")))
753 gomp_teams
: public gimple_statement_omp_taskreg
755 /* No extra fields; adds invariant:
756 stmt->code == GIMPLE_OMP_TEAMS. */
759 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
760 gomp_ordered
: public gimple_statement_omp_single_layout
762 /* No extra fields; adds invariant:
763 stmt->code == GIMPLE_OMP_ORDERED. */
766 struct GTY((tag("GSS_OMP_SINGLE_LAYOUT")))
767 gomp_scan
: public gimple_statement_omp_single_layout
769 /* No extra fields; adds invariant:
770 stmt->code == GIMPLE_OMP_SCAN. */
774 /* GIMPLE_OMP_ATOMIC_LOAD.
775 Note: This is based on gimple, not g_s_omp, because g_s_omp
776 contains a sequence, which we don't need here. */
778 struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
779 gomp_atomic_load
: public gimple
781 /* [ WORD 1-6 ] : base class */
787 /* GIMPLE_OMP_ATOMIC_STORE.
788 See note on GIMPLE_OMP_ATOMIC_LOAD. */
790 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
791 gimple_statement_omp_atomic_store_layout
: public gimple
793 /* [ WORD 1-6 ] : base class */
799 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
801 public gimple_statement_omp_atomic_store_layout
803 /* No extra fields; adds invariant:
804 stmt->code == GIMPLE_OMP_ATOMIC_STORE. */
807 struct GTY((tag("GSS_OMP_ATOMIC_STORE_LAYOUT")))
808 gimple_statement_omp_return
:
809 public gimple_statement_omp_atomic_store_layout
811 /* No extra fields; adds invariant:
812 stmt->code == GIMPLE_OMP_RETURN. */
815 /* GIMPLE_TRANSACTION. */
817 /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
819 /* The __transaction_atomic was declared [[outer]] or it is
820 __transaction_relaxed. */
821 #define GTMA_IS_OUTER (1u << 0)
822 #define GTMA_IS_RELAXED (1u << 1)
823 #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)
825 /* The transaction is seen to not have an abort. */
826 #define GTMA_HAVE_ABORT (1u << 2)
827 /* The transaction is seen to have loads or stores. */
828 #define GTMA_HAVE_LOAD (1u << 3)
829 #define GTMA_HAVE_STORE (1u << 4)
830 /* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
831 #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)
832 /* The transaction WILL enter serial irrevocable mode.
833 An irrevocable block post-dominates the entire transaction, such
834 that all invocations of the transaction will go serial-irrevocable.
835 In such case, we don't bother instrumenting the transaction, and
836 tell the runtime that it should begin the transaction in
837 serial-irrevocable mode. */
838 #define GTMA_DOES_GO_IRREVOCABLE (1u << 6)
839 /* The transaction contains no instrumentation code whatsover, most
840 likely because it is guaranteed to go irrevocable upon entry. */
841 #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
843 struct GTY((tag("GSS_TRANSACTION")))
844 gtransaction
: public gimple_statement_with_memory_ops_base
846 /* [ WORD 1-9 ] : base class */
857 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
858 enum gimple_statement_structure_enum
{
859 #include "gsstruct.def"
864 /* A statement with the invariant that
865 stmt->code == GIMPLE_COND
866 i.e. a conditional jump statement. */
868 struct GTY((tag("GSS_WITH_OPS")))
869 gcond
: public gimple_statement_with_ops
871 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
872 static const enum gimple_code code_
= GIMPLE_COND
;
875 /* A statement with the invariant that
876 stmt->code == GIMPLE_DEBUG
877 i.e. a debug statement. */
879 struct GTY((tag("GSS_WITH_OPS")))
880 gdebug
: public gimple_statement_with_ops
882 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
885 /* A statement with the invariant that
886 stmt->code == GIMPLE_GOTO
887 i.e. a goto statement. */
889 struct GTY((tag("GSS_WITH_OPS")))
890 ggoto
: public gimple_statement_with_ops
892 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
895 /* A statement with the invariant that
896 stmt->code == GIMPLE_LABEL
897 i.e. a label statement. */
899 struct GTY((tag("GSS_WITH_OPS")))
900 glabel
: public gimple_statement_with_ops
902 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
905 /* A statement with the invariant that
906 stmt->code == GIMPLE_SWITCH
907 i.e. a switch statement. */
909 struct GTY((tag("GSS_WITH_OPS")))
910 gswitch
: public gimple_statement_with_ops
912 /* no additional fields; this uses the layout for GSS_WITH_OPS. */
915 /* A statement with the invariant that
916 stmt->code == GIMPLE_ASSIGN
917 i.e. an assignment statement. */
919 struct GTY((tag("GSS_WITH_MEM_OPS")))
920 gassign
: public gimple_statement_with_memory_ops
922 static const enum gimple_code code_
= GIMPLE_ASSIGN
;
923 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
926 /* A statement with the invariant that
927 stmt->code == GIMPLE_RETURN
928 i.e. a return statement. */
930 struct GTY((tag("GSS_WITH_MEM_OPS")))
931 greturn
: public gimple_statement_with_memory_ops
933 /* no additional fields; this uses the layout for GSS_WITH_MEM_OPS. */
939 is_a_helper
<gasm
*>::test (gimple
*gs
)
941 return gs
->code
== GIMPLE_ASM
;
947 is_a_helper
<gassign
*>::test (gimple
*gs
)
949 return gs
->code
== GIMPLE_ASSIGN
;
955 is_a_helper
<const gassign
*>::test (const gimple
*gs
)
957 return gs
->code
== GIMPLE_ASSIGN
;
963 is_a_helper
<gbind
*>::test (gimple
*gs
)
965 return gs
->code
== GIMPLE_BIND
;
971 is_a_helper
<gcall
*>::test (gimple
*gs
)
973 return gs
->code
== GIMPLE_CALL
;
979 is_a_helper
<gcatch
*>::test (gimple
*gs
)
981 return gs
->code
== GIMPLE_CATCH
;
987 is_a_helper
<gcond
*>::test (gimple
*gs
)
989 return gs
->code
== GIMPLE_COND
;
995 is_a_helper
<const gcond
*>::test (const gimple
*gs
)
997 return gs
->code
== GIMPLE_COND
;
1003 is_a_helper
<gdebug
*>::test (gimple
*gs
)
1005 return gs
->code
== GIMPLE_DEBUG
;
1011 is_a_helper
<const gdebug
*>::test (const gimple
*gs
)
1013 return gs
->code
== GIMPLE_DEBUG
;
1019 is_a_helper
<ggoto
*>::test (gimple
*gs
)
1021 return gs
->code
== GIMPLE_GOTO
;
1027 is_a_helper
<const ggoto
*>::test (const gimple
*gs
)
1029 return gs
->code
== GIMPLE_GOTO
;
1035 is_a_helper
<glabel
*>::test (gimple
*gs
)
1037 return gs
->code
== GIMPLE_LABEL
;
1043 is_a_helper
<const glabel
*>::test (const gimple
*gs
)
1045 return gs
->code
== GIMPLE_LABEL
;
1051 is_a_helper
<gresx
*>::test (gimple
*gs
)
1053 return gs
->code
== GIMPLE_RESX
;
1059 is_a_helper
<geh_dispatch
*>::test (gimple
*gs
)
1061 return gs
->code
== GIMPLE_EH_DISPATCH
;
1067 is_a_helper
<geh_else
*>::test (gimple
*gs
)
1069 return gs
->code
== GIMPLE_EH_ELSE
;
1075 is_a_helper
<const geh_else
*>::test (const gimple
*gs
)
1077 return gs
->code
== GIMPLE_EH_ELSE
;
1083 is_a_helper
<geh_filter
*>::test (gimple
*gs
)
1085 return gs
->code
== GIMPLE_EH_FILTER
;
1091 is_a_helper
<geh_mnt
*>::test (gimple
*gs
)
1093 return gs
->code
== GIMPLE_EH_MUST_NOT_THROW
;
1099 is_a_helper
<const geh_mnt
*>::test (const gimple
*gs
)
1101 return gs
->code
== GIMPLE_EH_MUST_NOT_THROW
;
1107 is_a_helper
<gomp_atomic_load
*>::test (gimple
*gs
)
1109 return gs
->code
== GIMPLE_OMP_ATOMIC_LOAD
;
1115 is_a_helper
<gomp_atomic_store
*>::test (gimple
*gs
)
1117 return gs
->code
== GIMPLE_OMP_ATOMIC_STORE
;
1123 is_a_helper
<gimple_statement_omp_return
*>::test (gimple
*gs
)
1125 return gs
->code
== GIMPLE_OMP_RETURN
;
1131 is_a_helper
<gomp_continue
*>::test (gimple
*gs
)
1133 return gs
->code
== GIMPLE_OMP_CONTINUE
;
1139 is_a_helper
<gomp_critical
*>::test (gimple
*gs
)
1141 return gs
->code
== GIMPLE_OMP_CRITICAL
;
1147 is_a_helper
<gomp_ordered
*>::test (gimple
*gs
)
1149 return gs
->code
== GIMPLE_OMP_ORDERED
;
1155 is_a_helper
<gomp_scan
*>::test (gimple
*gs
)
1157 return gs
->code
== GIMPLE_OMP_SCAN
;
1163 is_a_helper
<gomp_for
*>::test (gimple
*gs
)
1165 return gs
->code
== GIMPLE_OMP_FOR
;
1171 is_a_helper
<gimple_statement_omp_taskreg
*>::test (gimple
*gs
)
1173 return (gs
->code
== GIMPLE_OMP_PARALLEL
1174 || gs
->code
== GIMPLE_OMP_TASK
1175 || gs
->code
== GIMPLE_OMP_TEAMS
);
1181 is_a_helper
<gomp_parallel
*>::test (gimple
*gs
)
1183 return gs
->code
== GIMPLE_OMP_PARALLEL
;
1189 is_a_helper
<gomp_target
*>::test (gimple
*gs
)
1191 return gs
->code
== GIMPLE_OMP_TARGET
;
1197 is_a_helper
<gomp_sections
*>::test (gimple
*gs
)
1199 return gs
->code
== GIMPLE_OMP_SECTIONS
;
1205 is_a_helper
<gomp_single
*>::test (gimple
*gs
)
1207 return gs
->code
== GIMPLE_OMP_SINGLE
;
1213 is_a_helper
<gomp_teams
*>::test (gimple
*gs
)
1215 return gs
->code
== GIMPLE_OMP_TEAMS
;
1221 is_a_helper
<gomp_task
*>::test (gimple
*gs
)
1223 return gs
->code
== GIMPLE_OMP_TASK
;
1229 is_a_helper
<gphi
*>::test (gimple
*gs
)
1231 return gs
->code
== GIMPLE_PHI
;
1237 is_a_helper
<greturn
*>::test (gimple
*gs
)
1239 return gs
->code
== GIMPLE_RETURN
;
1245 is_a_helper
<gswitch
*>::test (gimple
*gs
)
1247 return gs
->code
== GIMPLE_SWITCH
;
1253 is_a_helper
<const gswitch
*>::test (const gimple
*gs
)
1255 return gs
->code
== GIMPLE_SWITCH
;
1261 is_a_helper
<gtransaction
*>::test (gimple
*gs
)
1263 return gs
->code
== GIMPLE_TRANSACTION
;
1269 is_a_helper
<gtry
*>::test (gimple
*gs
)
1271 return gs
->code
== GIMPLE_TRY
;
1277 is_a_helper
<const gtry
*>::test (const gimple
*gs
)
1279 return gs
->code
== GIMPLE_TRY
;
1285 is_a_helper
<gimple_statement_wce
*>::test (gimple
*gs
)
1287 return gs
->code
== GIMPLE_WITH_CLEANUP_EXPR
;
1293 is_a_helper
<const gasm
*>::test (const gimple
*gs
)
1295 return gs
->code
== GIMPLE_ASM
;
1301 is_a_helper
<const gbind
*>::test (const gimple
*gs
)
1303 return gs
->code
== GIMPLE_BIND
;
1309 is_a_helper
<const gcall
*>::test (const gimple
*gs
)
1311 return gs
->code
== GIMPLE_CALL
;
1317 is_a_helper
<const gcatch
*>::test (const gimple
*gs
)
1319 return gs
->code
== GIMPLE_CATCH
;
1325 is_a_helper
<const gresx
*>::test (const gimple
*gs
)
1327 return gs
->code
== GIMPLE_RESX
;
1333 is_a_helper
<const geh_dispatch
*>::test (const gimple
*gs
)
1335 return gs
->code
== GIMPLE_EH_DISPATCH
;
1341 is_a_helper
<const geh_filter
*>::test (const gimple
*gs
)
1343 return gs
->code
== GIMPLE_EH_FILTER
;
1349 is_a_helper
<const gomp_atomic_load
*>::test (const gimple
*gs
)
1351 return gs
->code
== GIMPLE_OMP_ATOMIC_LOAD
;
1357 is_a_helper
<const gomp_atomic_store
*>::test (const gimple
*gs
)
1359 return gs
->code
== GIMPLE_OMP_ATOMIC_STORE
;
1365 is_a_helper
<const gimple_statement_omp_return
*>::test (const gimple
*gs
)
1367 return gs
->code
== GIMPLE_OMP_RETURN
;
1373 is_a_helper
<const gomp_continue
*>::test (const gimple
*gs
)
1375 return gs
->code
== GIMPLE_OMP_CONTINUE
;
1381 is_a_helper
<const gomp_critical
*>::test (const gimple
*gs
)
1383 return gs
->code
== GIMPLE_OMP_CRITICAL
;
1389 is_a_helper
<const gomp_ordered
*>::test (const gimple
*gs
)
1391 return gs
->code
== GIMPLE_OMP_ORDERED
;
1397 is_a_helper
<const gomp_scan
*>::test (const gimple
*gs
)
1399 return gs
->code
== GIMPLE_OMP_SCAN
;
1405 is_a_helper
<const gomp_for
*>::test (const gimple
*gs
)
1407 return gs
->code
== GIMPLE_OMP_FOR
;
1413 is_a_helper
<const gimple_statement_omp_taskreg
*>::test (const gimple
*gs
)
1415 return (gs
->code
== GIMPLE_OMP_PARALLEL
1416 || gs
->code
== GIMPLE_OMP_TASK
1417 || gs
->code
== GIMPLE_OMP_TEAMS
);
1423 is_a_helper
<const gomp_parallel
*>::test (const gimple
*gs
)
1425 return gs
->code
== GIMPLE_OMP_PARALLEL
;
1431 is_a_helper
<const gomp_target
*>::test (const gimple
*gs
)
1433 return gs
->code
== GIMPLE_OMP_TARGET
;
1439 is_a_helper
<const gomp_sections
*>::test (const gimple
*gs
)
1441 return gs
->code
== GIMPLE_OMP_SECTIONS
;
1447 is_a_helper
<const gomp_single
*>::test (const gimple
*gs
)
1449 return gs
->code
== GIMPLE_OMP_SINGLE
;
1455 is_a_helper
<const gomp_teams
*>::test (const gimple
*gs
)
1457 return gs
->code
== GIMPLE_OMP_TEAMS
;
1463 is_a_helper
<const gomp_task
*>::test (const gimple
*gs
)
1465 return gs
->code
== GIMPLE_OMP_TASK
;
1471 is_a_helper
<const gphi
*>::test (const gimple
*gs
)
1473 return gs
->code
== GIMPLE_PHI
;
1479 is_a_helper
<const greturn
*>::test (const gimple
*gs
)
1481 return gs
->code
== GIMPLE_RETURN
;
1487 is_a_helper
<const gtransaction
*>::test (const gimple
*gs
)
1489 return gs
->code
== GIMPLE_TRANSACTION
;
1492 /* Offset in bytes to the location of the operand vector.
1493 Zero if there is no operand vector for this tuple structure. */
1494 extern size_t const gimple_ops_offset_
[];
1496 /* Map GIMPLE codes to GSS codes. */
1497 extern enum gimple_statement_structure_enum
const gss_for_code_
[];
1499 /* This variable holds the currently expanded gimple statement for purposes
1500 of comminucating the profile info to the builtin expanders. */
1501 extern gimple
*currently_expanding_gimple_stmt
;
1503 size_t gimple_size (enum gimple_code code
, unsigned num_ops
= 0);
1504 void gimple_init (gimple
*g
, enum gimple_code code
, unsigned num_ops
);
1505 gimple
*gimple_alloc (enum gimple_code
, unsigned CXX_MEM_STAT_INFO
);
1506 greturn
*gimple_build_return (tree
);
1507 void gimple_call_reset_alias_info (gcall
*);
1508 gcall
*gimple_build_call_vec (tree
, vec
<tree
> );
1509 gcall
*gimple_build_call (tree
, unsigned, ...);
1510 gcall
*gimple_build_call_valist (tree
, unsigned, va_list);
1511 gcall
*gimple_build_call_internal (enum internal_fn
, unsigned, ...);
1512 gcall
*gimple_build_call_internal_vec (enum internal_fn
, vec
<tree
> );
1513 gcall
*gimple_build_call_from_tree (tree
, tree
);
1514 gassign
*gimple_build_assign (tree
, tree CXX_MEM_STAT_INFO
);
1515 gassign
*gimple_build_assign (tree
, enum tree_code
,
1516 tree
, tree
, tree CXX_MEM_STAT_INFO
);
1517 gassign
*gimple_build_assign (tree
, enum tree_code
,
1518 tree
, tree CXX_MEM_STAT_INFO
);
1519 gassign
*gimple_build_assign (tree
, enum tree_code
, tree CXX_MEM_STAT_INFO
);
1520 gcond
*gimple_build_cond (enum tree_code
, tree
, tree
, tree
, tree
);
1521 gcond
*gimple_build_cond_from_tree (tree
, tree
, tree
);
1522 void gimple_cond_set_condition_from_tree (gcond
*, tree
);
1523 glabel
*gimple_build_label (tree label
);
1524 ggoto
*gimple_build_goto (tree dest
);
1525 gimple
*gimple_build_nop (void);
1526 gbind
*gimple_build_bind (tree
, gimple_seq
, tree
);
1527 gasm
*gimple_build_asm_vec (const char *, vec
<tree
, va_gc
> *,
1528 vec
<tree
, va_gc
> *, vec
<tree
, va_gc
> *,
1529 vec
<tree
, va_gc
> *);
1530 gcatch
*gimple_build_catch (tree
, gimple_seq
);
1531 geh_filter
*gimple_build_eh_filter (tree
, gimple_seq
);
1532 geh_mnt
*gimple_build_eh_must_not_throw (tree
);
1533 geh_else
*gimple_build_eh_else (gimple_seq
, gimple_seq
);
1534 gtry
*gimple_build_try (gimple_seq
, gimple_seq
,
1535 enum gimple_try_flags
);
1536 gimple
*gimple_build_wce (gimple_seq
);
1537 gresx
*gimple_build_resx (int);
1538 gswitch
*gimple_build_switch_nlabels (unsigned, tree
, tree
);
1539 gswitch
*gimple_build_switch (tree
, tree
, vec
<tree
> );
1540 geh_dispatch
*gimple_build_eh_dispatch (int);
1541 gdebug
*gimple_build_debug_bind (tree
, tree
, gimple
* CXX_MEM_STAT_INFO
);
1542 gdebug
*gimple_build_debug_source_bind (tree
, tree
, gimple
* CXX_MEM_STAT_INFO
);
1543 gdebug
*gimple_build_debug_begin_stmt (tree
, location_t CXX_MEM_STAT_INFO
);
1544 gdebug
*gimple_build_debug_inline_entry (tree
, location_t CXX_MEM_STAT_INFO
);
1545 gomp_critical
*gimple_build_omp_critical (gimple_seq
, tree
, tree
);
1546 gomp_for
*gimple_build_omp_for (gimple_seq
, int, tree
, size_t, gimple_seq
);
1547 gomp_parallel
*gimple_build_omp_parallel (gimple_seq
, tree
, tree
, tree
);
1548 gomp_task
*gimple_build_omp_task (gimple_seq
, tree
, tree
, tree
, tree
,
1550 gimple
*gimple_build_omp_section (gimple_seq
);
1551 gimple
*gimple_build_omp_master (gimple_seq
);
1552 gimple
*gimple_build_omp_taskgroup (gimple_seq
, tree
);
1553 gomp_continue
*gimple_build_omp_continue (tree
, tree
);
1554 gomp_ordered
*gimple_build_omp_ordered (gimple_seq
, tree
);
1555 gimple
*gimple_build_omp_return (bool);
1556 gomp_scan
*gimple_build_omp_scan (gimple_seq
, tree
);
1557 gomp_sections
*gimple_build_omp_sections (gimple_seq
, tree
);
1558 gimple
*gimple_build_omp_sections_switch (void);
1559 gomp_single
*gimple_build_omp_single (gimple_seq
, tree
);
1560 gomp_target
*gimple_build_omp_target (gimple_seq
, int, tree
);
1561 gomp_teams
*gimple_build_omp_teams (gimple_seq
, tree
);
1562 gomp_atomic_load
*gimple_build_omp_atomic_load (tree
, tree
,
1563 enum omp_memory_order
);
1564 gomp_atomic_store
*gimple_build_omp_atomic_store (tree
, enum omp_memory_order
);
1565 gtransaction
*gimple_build_transaction (gimple_seq
);
1566 extern void gimple_seq_add_stmt (gimple_seq
*, gimple
*);
1567 extern void gimple_seq_add_stmt_without_update (gimple_seq
*, gimple
*);
1568 void gimple_seq_add_seq (gimple_seq
*, gimple_seq
);
1569 void gimple_seq_add_seq_without_update (gimple_seq
*, gimple_seq
);
1570 extern void annotate_all_with_location_after (gimple_seq
, gimple_stmt_iterator
,
1572 extern void annotate_all_with_location (gimple_seq
, location_t
);
1573 bool empty_body_p (gimple_seq
);
1574 gimple_seq
gimple_seq_copy (gimple_seq
);
1575 bool gimple_call_same_target_p (const gimple
*, const gimple
*);
1576 int gimple_call_flags (const gimple
*);
1577 int gimple_call_arg_flags (const gcall
*, unsigned);
1578 int gimple_call_return_flags (const gcall
*);
1579 bool gimple_call_nonnull_result_p (gcall
*);
1580 tree
gimple_call_nonnull_arg (gcall
*);
1581 bool gimple_assign_copy_p (gimple
*);
1582 bool gimple_assign_ssa_name_copy_p (gimple
*);
1583 bool gimple_assign_unary_nop_p (gimple
*);
1584 void gimple_set_bb (gimple
*, basic_block
);
1585 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*, tree
);
1586 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*, enum tree_code
,
1588 tree
gimple_get_lhs (const gimple
*);
1589 void gimple_set_lhs (gimple
*, tree
);
1590 gimple
*gimple_copy (gimple
*);
1591 void gimple_move_vops (gimple
*, gimple
*);
1592 bool gimple_has_side_effects (const gimple
*);
1593 bool gimple_could_trap_p_1 (gimple
*, bool, bool);
1594 bool gimple_could_trap_p (gimple
*);
1595 bool gimple_assign_rhs_could_trap_p (gimple
*);
1596 extern void dump_gimple_statistics (void);
1597 unsigned get_gimple_rhs_num_ops (enum tree_code
);
1598 extern tree
canonicalize_cond_expr_cond (tree
);
1599 gcall
*gimple_call_copy_skip_args (gcall
*, bitmap
);
1600 extern bool gimple_compare_field_offset (tree
, tree
);
1601 extern tree
gimple_unsigned_type (tree
);
1602 extern tree
gimple_signed_type (tree
);
1603 extern alias_set_type
gimple_get_alias_set (tree
);
1604 extern bool gimple_ior_addresses_taken (bitmap
, gimple
*);
1605 extern bool gimple_builtin_call_types_compatible_p (const gimple
*, tree
);
1606 extern combined_fn
gimple_call_combined_fn (const gimple
*);
1607 extern bool gimple_call_replaceable_operator_delete_p (const gcall
*);
1608 extern bool gimple_call_builtin_p (const gimple
*);
1609 extern bool gimple_call_builtin_p (const gimple
*, enum built_in_class
);
1610 extern bool gimple_call_builtin_p (const gimple
*, enum built_in_function
);
1611 extern bool gimple_asm_clobbers_memory_p (const gasm
*);
1612 extern void dump_decl_set (FILE *, bitmap
);
1613 extern bool nonfreeing_call_p (gimple
*);
1614 extern bool nonbarrier_call_p (gimple
*);
1615 extern bool infer_nonnull_range (gimple
*, tree
);
1616 extern bool infer_nonnull_range_by_dereference (gimple
*, tree
);
1617 extern bool infer_nonnull_range_by_attribute (gimple
*, tree
);
1618 extern void sort_case_labels (vec
<tree
>);
1619 extern void preprocess_case_label_vec_for_gimple (vec
<tree
>, tree
, tree
*);
1620 extern void gimple_seq_set_location (gimple_seq
, location_t
);
1621 extern void gimple_seq_discard (gimple_seq
);
1622 extern void maybe_remove_unused_call_args (struct function
*, gimple
*);
1623 extern bool gimple_inexpensive_call_p (gcall
*);
1624 extern bool stmt_can_terminate_bb_p (gimple
*);
1625 extern location_t
gimple_or_expr_nonartificial_location (gimple
*, tree
);
1628 /* Formal (expression) temporary table handling: multiple occurrences of
1629 the same scalar expression are evaluated into the same temporary. */
1631 typedef struct gimple_temp_hash_elt
1634 tree temp
; /* Value */
1637 /* Get the number of the next statement uid to be allocated. */
1638 static inline unsigned int
1639 gimple_stmt_max_uid (struct function
*fn
)
1641 return fn
->last_stmt_uid
;
1644 /* Set the number of the next statement uid to be allocated. */
1646 set_gimple_stmt_max_uid (struct function
*fn
, unsigned int maxid
)
1648 fn
->last_stmt_uid
= maxid
;
1651 /* Set the number of the next statement uid to be allocated. */
1652 static inline unsigned int
1653 inc_gimple_stmt_max_uid (struct function
*fn
)
1655 return fn
->last_stmt_uid
++;
1658 /* Return the first node in GIMPLE sequence S. */
1660 static inline gimple_seq_node
1661 gimple_seq_first (gimple_seq s
)
1667 /* Return the first statement in GIMPLE sequence S. */
1669 static inline gimple
*
1670 gimple_seq_first_stmt (gimple_seq s
)
1672 gimple_seq_node n
= gimple_seq_first (s
);
1676 /* Return the first statement in GIMPLE sequence S as a gbind *,
1677 verifying that it has code GIMPLE_BIND in a checked build. */
1679 static inline gbind
*
1680 gimple_seq_first_stmt_as_a_bind (gimple_seq s
)
1682 gimple_seq_node n
= gimple_seq_first (s
);
1683 return as_a
<gbind
*> (n
);
1687 /* Return the last node in GIMPLE sequence S. */
1689 static inline gimple_seq_node
1690 gimple_seq_last (gimple_seq s
)
1692 return s
? s
->prev
: NULL
;
1696 /* Return the last statement in GIMPLE sequence S. */
1698 static inline gimple
*
1699 gimple_seq_last_stmt (gimple_seq s
)
1701 gimple_seq_node n
= gimple_seq_last (s
);
1706 /* Set the last node in GIMPLE sequence *PS to LAST. */
1709 gimple_seq_set_last (gimple_seq
*ps
, gimple_seq_node last
)
1715 /* Set the first node in GIMPLE sequence *PS to FIRST. */
1718 gimple_seq_set_first (gimple_seq
*ps
, gimple_seq_node first
)
1724 /* Return true if GIMPLE sequence S is empty. */
1727 gimple_seq_empty_p (gimple_seq s
)
1732 /* Allocate a new sequence and initialize its first element with STMT. */
1734 static inline gimple_seq
1735 gimple_seq_alloc_with_stmt (gimple
*stmt
)
1737 gimple_seq seq
= NULL
;
1738 gimple_seq_add_stmt (&seq
, stmt
);
1743 /* Returns the sequence of statements in BB. */
1745 static inline gimple_seq
1746 bb_seq (const_basic_block bb
)
1748 return (!(bb
->flags
& BB_RTL
)) ? bb
->il
.gimple
.seq
: NULL
;
1751 static inline gimple_seq
*
1752 bb_seq_addr (basic_block bb
)
1754 return (!(bb
->flags
& BB_RTL
)) ? &bb
->il
.gimple
.seq
: NULL
;
1757 /* Sets the sequence of statements in BB to SEQ. */
1760 set_bb_seq (basic_block bb
, gimple_seq seq
)
1762 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
1763 bb
->il
.gimple
.seq
= seq
;
1767 /* Return the code for GIMPLE statement G. */
1769 static inline enum gimple_code
1770 gimple_code (const gimple
*g
)
1776 /* Return the GSS code used by a GIMPLE code. */
1778 static inline enum gimple_statement_structure_enum
1779 gss_for_code (enum gimple_code code
)
1781 gcc_gimple_checking_assert ((unsigned int)code
< LAST_AND_UNUSED_GIMPLE_CODE
);
1782 return gss_for_code_
[code
];
1786 /* Return which GSS code is used by GS. */
1788 static inline enum gimple_statement_structure_enum
1789 gimple_statement_structure (gimple
*gs
)
1791 return gss_for_code (gimple_code (gs
));
1795 /* Return true if statement G has sub-statements. This is only true for
1796 High GIMPLE statements. */
1799 gimple_has_substatements (gimple
*g
)
1801 switch (gimple_code (g
))
1805 case GIMPLE_EH_FILTER
:
1806 case GIMPLE_EH_ELSE
:
1808 case GIMPLE_OMP_FOR
:
1809 case GIMPLE_OMP_MASTER
:
1810 case GIMPLE_OMP_TASKGROUP
:
1811 case GIMPLE_OMP_ORDERED
:
1812 case GIMPLE_OMP_SECTION
:
1813 case GIMPLE_OMP_PARALLEL
:
1814 case GIMPLE_OMP_TASK
:
1815 case GIMPLE_OMP_SECTIONS
:
1816 case GIMPLE_OMP_SINGLE
:
1817 case GIMPLE_OMP_TARGET
:
1818 case GIMPLE_OMP_TEAMS
:
1819 case GIMPLE_OMP_CRITICAL
:
1820 case GIMPLE_WITH_CLEANUP_EXPR
:
1821 case GIMPLE_TRANSACTION
:
1830 /* Return the basic block holding statement G. */
1832 static inline basic_block
1833 gimple_bb (const gimple
*g
)
1839 /* Return the lexical scope block holding statement G. */
1842 gimple_block (const gimple
*g
)
1844 return LOCATION_BLOCK (g
->location
);
1848 /* Set BLOCK to be the lexical scope block holding statement G. */
1851 gimple_set_block (gimple
*g
, tree block
)
1853 g
->location
= set_block (g
->location
, block
);
1857 /* Return location information for statement G. */
1859 static inline location_t
1860 gimple_location (const gimple
*g
)
1865 /* Return location information for statement G if g is not NULL.
1866 Otherwise, UNKNOWN_LOCATION is returned. */
1868 static inline location_t
1869 gimple_location_safe (const gimple
*g
)
1871 return g
? gimple_location (g
) : UNKNOWN_LOCATION
;
1874 /* Set location information for statement G. */
1877 gimple_set_location (gimple
*g
, location_t location
)
1879 g
->location
= location
;
1882 /* Return address of the location information for statement G. */
1884 static inline location_t
*
1885 gimple_location_ptr (gimple
*g
)
1887 return &g
->location
;
1891 /* Return true if G contains location information. */
1894 gimple_has_location (const gimple
*g
)
1896 return LOCATION_LOCUS (gimple_location (g
)) != UNKNOWN_LOCATION
;
1900 /* Return non-artificial location information for statement G. */
1902 static inline location_t
1903 gimple_nonartificial_location (const gimple
*g
)
1905 location_t
*ploc
= NULL
;
1907 if (tree block
= gimple_block (g
))
1908 ploc
= block_nonartificial_location (block
);
1910 return ploc
? *ploc
: gimple_location (g
);
1914 /* Return the file name of the location of STMT. */
1916 static inline const char *
1917 gimple_filename (const gimple
*stmt
)
1919 return LOCATION_FILE (gimple_location (stmt
));
1923 /* Return the line number of the location of STMT. */
1926 gimple_lineno (const gimple
*stmt
)
1928 return LOCATION_LINE (gimple_location (stmt
));
1932 /* Determine whether SEQ is a singleton. */
1935 gimple_seq_singleton_p (gimple_seq seq
)
1937 return ((gimple_seq_first (seq
) != NULL
)
1938 && (gimple_seq_first (seq
) == gimple_seq_last (seq
)));
1941 /* Return true if no warnings should be emitted for statement STMT. */
1944 gimple_no_warning_p (const gimple
*stmt
)
1946 return stmt
->no_warning
;
1949 /* Set the no_warning flag of STMT to NO_WARNING. */
1952 gimple_set_no_warning (gimple
*stmt
, bool no_warning
)
1954 stmt
->no_warning
= (unsigned) no_warning
;
1957 /* Set the visited status on statement STMT to VISITED_P.
1959 Please note that this 'visited' property of the gimple statement is
1960 supposed to be undefined at pass boundaries. This means that a
1961 given pass should not assume it contains any useful value when the
1962 pass starts and thus can set it to any value it sees fit.
1964 You can learn more about the visited property of the gimple
1965 statement by reading the comments of the 'visited' data member of
1970 gimple_set_visited (gimple
*stmt
, bool visited_p
)
1972 stmt
->visited
= (unsigned) visited_p
;
1976 /* Return the visited status for statement STMT.
1978 Please note that this 'visited' property of the gimple statement is
1979 supposed to be undefined at pass boundaries. This means that a
1980 given pass should not assume it contains any useful value when the
1981 pass starts and thus can set it to any value it sees fit.
1983 You can learn more about the visited property of the gimple
1984 statement by reading the comments of the 'visited' data member of
1988 gimple_visited_p (gimple
*stmt
)
1990 return stmt
->visited
;
1994 /* Set pass local flag PLF on statement STMT to VAL_P.
1996 Please note that this PLF property of the gimple statement is
1997 supposed to be undefined at pass boundaries. This means that a
1998 given pass should not assume it contains any useful value when the
1999 pass starts and thus can set it to any value it sees fit.
2001 You can learn more about the PLF property by reading the comment of
2002 the 'plf' data member of struct gimple_statement_structure. */
2005 gimple_set_plf (gimple
*stmt
, enum plf_mask plf
, bool val_p
)
2008 stmt
->plf
|= (unsigned int) plf
;
2010 stmt
->plf
&= ~((unsigned int) plf
);
2014 /* Return the value of pass local flag PLF on statement STMT.
2016 Please note that this 'plf' property of the gimple statement is
2017 supposed to be undefined at pass boundaries. This means that a
2018 given pass should not assume it contains any useful value when the
2019 pass starts and thus can set it to any value it sees fit.
2021 You can learn more about the plf property by reading the comment of
2022 the 'plf' data member of struct gimple_statement_structure. */
2024 static inline unsigned int
2025 gimple_plf (gimple
*stmt
, enum plf_mask plf
)
2027 return stmt
->plf
& ((unsigned int) plf
);
2031 /* Set the UID of statement.
2033 Please note that this UID property is supposed to be undefined at
2034 pass boundaries. This means that a given pass should not assume it
2035 contains any useful value when the pass starts and thus can set it
2036 to any value it sees fit. */
2039 gimple_set_uid (gimple
*g
, unsigned uid
)
2045 /* Return the UID of statement.
2047 Please note that this UID property is supposed to be undefined at
2048 pass boundaries. This means that a given pass should not assume it
2049 contains any useful value when the pass starts and thus can set it
2050 to any value it sees fit. */
2052 static inline unsigned
2053 gimple_uid (const gimple
*g
)
2059 /* Make statement G a singleton sequence. */
2062 gimple_init_singleton (gimple
*g
)
2069 /* Return true if GIMPLE statement G has register or memory operands. */
2072 gimple_has_ops (const gimple
*g
)
2074 return gimple_code (g
) >= GIMPLE_COND
&& gimple_code (g
) <= GIMPLE_RETURN
;
2080 is_a_helper
<const gimple_statement_with_ops
*>::test (const gimple
*gs
)
2082 return gimple_has_ops (gs
);
2088 is_a_helper
<gimple_statement_with_ops
*>::test (gimple
*gs
)
2090 return gimple_has_ops (gs
);
2093 /* Return true if GIMPLE statement G has memory operands. */
2096 gimple_has_mem_ops (const gimple
*g
)
2098 return gimple_code (g
) >= GIMPLE_ASSIGN
&& gimple_code (g
) <= GIMPLE_RETURN
;
2104 is_a_helper
<const gimple_statement_with_memory_ops
*>::test (const gimple
*gs
)
2106 return gimple_has_mem_ops (gs
);
2112 is_a_helper
<gimple_statement_with_memory_ops
*>::test (gimple
*gs
)
2114 return gimple_has_mem_ops (gs
);
2117 /* Return the set of USE operands for statement G. */
2119 static inline struct use_optype_d
*
2120 gimple_use_ops (const gimple
*g
)
2122 const gimple_statement_with_ops
*ops_stmt
=
2123 dyn_cast
<const gimple_statement_with_ops
*> (g
);
2126 return ops_stmt
->use_ops
;
2130 /* Set USE to be the set of USE operands for statement G. */
2133 gimple_set_use_ops (gimple
*g
, struct use_optype_d
*use
)
2135 gimple_statement_with_ops
*ops_stmt
=
2136 as_a
<gimple_statement_with_ops
*> (g
);
2137 ops_stmt
->use_ops
= use
;
2141 /* Return the single VUSE operand of the statement G. */
2144 gimple_vuse (const gimple
*g
)
2146 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
2147 dyn_cast
<const gimple_statement_with_memory_ops
*> (g
);
2150 return mem_ops_stmt
->vuse
;
2153 /* Return the single VDEF operand of the statement G. */
2156 gimple_vdef (const gimple
*g
)
2158 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
2159 dyn_cast
<const gimple_statement_with_memory_ops
*> (g
);
2162 return mem_ops_stmt
->vdef
;
2165 /* Return the single VUSE operand of the statement G. */
2167 static inline tree
*
2168 gimple_vuse_ptr (gimple
*g
)
2170 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2171 dyn_cast
<gimple_statement_with_memory_ops
*> (g
);
2174 return &mem_ops_stmt
->vuse
;
2177 /* Return the single VDEF operand of the statement G. */
2179 static inline tree
*
2180 gimple_vdef_ptr (gimple
*g
)
2182 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2183 dyn_cast
<gimple_statement_with_memory_ops
*> (g
);
2186 return &mem_ops_stmt
->vdef
;
2189 /* Set the single VUSE operand of the statement G. */
2192 gimple_set_vuse (gimple
*g
, tree vuse
)
2194 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2195 as_a
<gimple_statement_with_memory_ops
*> (g
);
2196 mem_ops_stmt
->vuse
= vuse
;
2199 /* Set the single VDEF operand of the statement G. */
2202 gimple_set_vdef (gimple
*g
, tree vdef
)
2204 gimple_statement_with_memory_ops
*mem_ops_stmt
=
2205 as_a
<gimple_statement_with_memory_ops
*> (g
);
2206 mem_ops_stmt
->vdef
= vdef
;
2210 /* Return true if statement G has operands and the modified field has
2214 gimple_modified_p (const gimple
*g
)
2216 return (gimple_has_ops (g
)) ? (bool) g
->modified
: false;
2220 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
2221 a MODIFIED field. */
2224 gimple_set_modified (gimple
*s
, bool modifiedp
)
2226 if (gimple_has_ops (s
))
2227 s
->modified
= (unsigned) modifiedp
;
2231 /* Return the tree code for the expression computed by STMT. This is
2232 only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
2233 GIMPLE_CALL, return CALL_EXPR as the expression code for
2234 consistency. This is useful when the caller needs to deal with the
2235 three kinds of computation that GIMPLE supports. */
2237 static inline enum tree_code
2238 gimple_expr_code (const gimple
*stmt
)
2240 enum gimple_code code
= gimple_code (stmt
);
2241 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_COND
)
2242 return (enum tree_code
) stmt
->subcode
;
2245 gcc_gimple_checking_assert (code
== GIMPLE_CALL
);
2251 /* Return true if statement STMT contains volatile operands. */
2254 gimple_has_volatile_ops (const gimple
*stmt
)
2256 if (gimple_has_mem_ops (stmt
))
2257 return stmt
->has_volatile_ops
;
2263 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
2266 gimple_set_has_volatile_ops (gimple
*stmt
, bool volatilep
)
2268 if (gimple_has_mem_ops (stmt
))
2269 stmt
->has_volatile_ops
= (unsigned) volatilep
;
2272 /* Return true if STMT is in a transaction. */
2275 gimple_in_transaction (const gimple
*stmt
)
2277 return bb_in_transaction (gimple_bb (stmt
));
2280 /* Return true if statement STMT may access memory. */
2283 gimple_references_memory_p (gimple
*stmt
)
2285 return gimple_has_mem_ops (stmt
) && gimple_vuse (stmt
);
2289 /* Return the subcode for OMP statement S. */
2291 static inline unsigned
2292 gimple_omp_subcode (const gimple
*s
)
2294 gcc_gimple_checking_assert (gimple_code (s
) >= GIMPLE_OMP_ATOMIC_LOAD
2295 && gimple_code (s
) <= GIMPLE_OMP_TEAMS
);
2299 /* Set the subcode for OMP statement S to SUBCODE. */
2302 gimple_omp_set_subcode (gimple
*s
, unsigned int subcode
)
2304 /* We only have 16 bits for the subcode. Assert that we are not
2306 gcc_gimple_checking_assert (subcode
< (1 << 16));
2307 s
->subcode
= subcode
;
2310 /* Set the nowait flag on OMP_RETURN statement S. */
2313 gimple_omp_return_set_nowait (gimple
*s
)
2315 GIMPLE_CHECK (s
, GIMPLE_OMP_RETURN
);
2316 s
->subcode
|= GF_OMP_RETURN_NOWAIT
;
2320 /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
2324 gimple_omp_return_nowait_p (const gimple
*g
)
2326 GIMPLE_CHECK (g
, GIMPLE_OMP_RETURN
);
2327 return (gimple_omp_subcode (g
) & GF_OMP_RETURN_NOWAIT
) != 0;
2331 /* Set the LHS of OMP return. */
2334 gimple_omp_return_set_lhs (gimple
*g
, tree lhs
)
2336 gimple_statement_omp_return
*omp_return_stmt
=
2337 as_a
<gimple_statement_omp_return
*> (g
);
2338 omp_return_stmt
->val
= lhs
;
2342 /* Get the LHS of OMP return. */
2345 gimple_omp_return_lhs (const gimple
*g
)
2347 const gimple_statement_omp_return
*omp_return_stmt
=
2348 as_a
<const gimple_statement_omp_return
*> (g
);
2349 return omp_return_stmt
->val
;
2353 /* Return a pointer to the LHS of OMP return. */
2355 static inline tree
*
2356 gimple_omp_return_lhs_ptr (gimple
*g
)
2358 gimple_statement_omp_return
*omp_return_stmt
=
2359 as_a
<gimple_statement_omp_return
*> (g
);
2360 return &omp_return_stmt
->val
;
2364 /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
2368 gimple_omp_section_last_p (const gimple
*g
)
2370 GIMPLE_CHECK (g
, GIMPLE_OMP_SECTION
);
2371 return (gimple_omp_subcode (g
) & GF_OMP_SECTION_LAST
) != 0;
2375 /* Set the GF_OMP_SECTION_LAST flag on G. */
2378 gimple_omp_section_set_last (gimple
*g
)
2380 GIMPLE_CHECK (g
, GIMPLE_OMP_SECTION
);
2381 g
->subcode
|= GF_OMP_SECTION_LAST
;
2385 /* Return true if OMP parallel statement G has the
2386 GF_OMP_PARALLEL_COMBINED flag set. */
2389 gimple_omp_parallel_combined_p (const gimple
*g
)
2391 GIMPLE_CHECK (g
, GIMPLE_OMP_PARALLEL
);
2392 return (gimple_omp_subcode (g
) & GF_OMP_PARALLEL_COMBINED
) != 0;
2396 /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
2397 value of COMBINED_P. */
2400 gimple_omp_parallel_set_combined_p (gimple
*g
, bool combined_p
)
2402 GIMPLE_CHECK (g
, GIMPLE_OMP_PARALLEL
);
2404 g
->subcode
|= GF_OMP_PARALLEL_COMBINED
;
2406 g
->subcode
&= ~GF_OMP_PARALLEL_COMBINED
;
2410 /* Return true if OMP atomic load/store statement G has the
2411 GF_OMP_ATOMIC_NEED_VALUE flag set. */
2414 gimple_omp_atomic_need_value_p (const gimple
*g
)
2416 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2417 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2418 return (gimple_omp_subcode (g
) & GF_OMP_ATOMIC_NEED_VALUE
) != 0;
2422 /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
2425 gimple_omp_atomic_set_need_value (gimple
*g
)
2427 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2428 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2429 g
->subcode
|= GF_OMP_ATOMIC_NEED_VALUE
;
2433 /* Return the memory order of the OMP atomic load/store statement G. */
2435 static inline enum omp_memory_order
2436 gimple_omp_atomic_memory_order (const gimple
*g
)
2438 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2439 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2440 return (enum omp_memory_order
)
2441 (gimple_omp_subcode (g
) & GF_OMP_ATOMIC_MEMORY_ORDER
);
2445 /* Set the memory order on G. */
2448 gimple_omp_atomic_set_memory_order (gimple
*g
, enum omp_memory_order mo
)
2450 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
2451 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
2452 g
->subcode
= ((g
->subcode
& ~GF_OMP_ATOMIC_MEMORY_ORDER
)
2453 | (mo
& GF_OMP_ATOMIC_MEMORY_ORDER
));
2457 /* Return the number of operands for statement GS. */
2459 static inline unsigned
2460 gimple_num_ops (const gimple
*gs
)
2466 /* Set the number of operands for statement GS. */
2469 gimple_set_num_ops (gimple
*gs
, unsigned num_ops
)
2471 gs
->num_ops
= num_ops
;
2475 /* Return the array of operands for statement GS. */
2477 static inline tree
*
2478 gimple_ops (gimple
*gs
)
2482 /* All the tuples have their operand vector at the very bottom
2483 of the structure. Note that those structures that do not
2484 have an operand vector have a zero offset. */
2485 off
= gimple_ops_offset_
[gimple_statement_structure (gs
)];
2486 gcc_gimple_checking_assert (off
!= 0);
2488 return (tree
*) ((char *) gs
+ off
);
2492 /* Return operand I for statement GS. */
2495 gimple_op (const gimple
*gs
, unsigned i
)
2497 if (gimple_has_ops (gs
))
2499 gcc_gimple_checking_assert (i
< gimple_num_ops (gs
));
2500 return gimple_ops (CONST_CAST_GIMPLE (gs
))[i
];
2506 /* Return a pointer to operand I for statement GS. */
2508 static inline tree
*
2509 gimple_op_ptr (gimple
*gs
, unsigned i
)
2511 if (gimple_has_ops (gs
))
2513 gcc_gimple_checking_assert (i
< gimple_num_ops (gs
));
2514 return gimple_ops (gs
) + i
;
2520 /* Set operand I of statement GS to OP. */
2523 gimple_set_op (gimple
*gs
, unsigned i
, tree op
)
2525 gcc_gimple_checking_assert (gimple_has_ops (gs
) && i
< gimple_num_ops (gs
));
2527 /* Note. It may be tempting to assert that OP matches
2528 is_gimple_operand, but that would be wrong. Different tuples
2529 accept slightly different sets of tree operands. Each caller
2530 should perform its own validation. */
2531 gimple_ops (gs
)[i
] = op
;
2534 /* Return true if GS is a GIMPLE_ASSIGN. */
2537 is_gimple_assign (const gimple
*gs
)
2539 return gimple_code (gs
) == GIMPLE_ASSIGN
;
2542 /* Determine if expression CODE is one of the valid expressions that can
2543 be used on the RHS of GIMPLE assignments. */
2545 static inline enum gimple_rhs_class
2546 get_gimple_rhs_class (enum tree_code code
)
2548 return (enum gimple_rhs_class
) gimple_rhs_class_table
[(int) code
];
2551 /* Return the LHS of assignment statement GS. */
2554 gimple_assign_lhs (const gassign
*gs
)
2560 gimple_assign_lhs (const gimple
*gs
)
2562 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2563 return gimple_assign_lhs (ass
);
2567 /* Return a pointer to the LHS of assignment statement GS. */
2569 static inline tree
*
2570 gimple_assign_lhs_ptr (gassign
*gs
)
2575 static inline tree
*
2576 gimple_assign_lhs_ptr (gimple
*gs
)
2578 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2579 return gimple_assign_lhs_ptr (ass
);
2583 /* Set LHS to be the LHS operand of assignment statement GS. */
2586 gimple_assign_set_lhs (gassign
*gs
, tree lhs
)
2590 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
2591 SSA_NAME_DEF_STMT (lhs
) = gs
;
2595 gimple_assign_set_lhs (gimple
*gs
, tree lhs
)
2597 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2598 gimple_assign_set_lhs (ass
, lhs
);
2602 /* Return the first operand on the RHS of assignment statement GS. */
2605 gimple_assign_rhs1 (const gassign
*gs
)
2611 gimple_assign_rhs1 (const gimple
*gs
)
2613 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2614 return gimple_assign_rhs1 (ass
);
2618 /* Return a pointer to the first operand on the RHS of assignment
2621 static inline tree
*
2622 gimple_assign_rhs1_ptr (gassign
*gs
)
2627 static inline tree
*
2628 gimple_assign_rhs1_ptr (gimple
*gs
)
2630 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2631 return gimple_assign_rhs1_ptr (ass
);
2634 /* Set RHS to be the first operand on the RHS of assignment statement GS. */
2637 gimple_assign_set_rhs1 (gassign
*gs
, tree rhs
)
2643 gimple_assign_set_rhs1 (gimple
*gs
, tree rhs
)
2645 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2646 gimple_assign_set_rhs1 (ass
, rhs
);
2650 /* Return the second operand on the RHS of assignment statement GS.
2651 If GS does not have two operands, NULL is returned instead. */
2654 gimple_assign_rhs2 (const gassign
*gs
)
2656 if (gimple_num_ops (gs
) >= 3)
2663 gimple_assign_rhs2 (const gimple
*gs
)
2665 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2666 return gimple_assign_rhs2 (ass
);
2670 /* Return a pointer to the second operand on the RHS of assignment
2673 static inline tree
*
2674 gimple_assign_rhs2_ptr (gassign
*gs
)
2676 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 3);
2680 static inline tree
*
2681 gimple_assign_rhs2_ptr (gimple
*gs
)
2683 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2684 return gimple_assign_rhs2_ptr (ass
);
2688 /* Set RHS to be the second operand on the RHS of assignment statement GS. */
2691 gimple_assign_set_rhs2 (gassign
*gs
, tree rhs
)
2693 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 3);
2698 gimple_assign_set_rhs2 (gimple
*gs
, tree rhs
)
2700 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2701 return gimple_assign_set_rhs2 (ass
, rhs
);
2704 /* Return the third operand on the RHS of assignment statement GS.
2705 If GS does not have two operands, NULL is returned instead. */
2708 gimple_assign_rhs3 (const gassign
*gs
)
2710 if (gimple_num_ops (gs
) >= 4)
2717 gimple_assign_rhs3 (const gimple
*gs
)
2719 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2720 return gimple_assign_rhs3 (ass
);
2723 /* Return a pointer to the third operand on the RHS of assignment
2726 static inline tree
*
2727 gimple_assign_rhs3_ptr (gimple
*gs
)
2729 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2730 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 4);
2735 /* Set RHS to be the third operand on the RHS of assignment statement GS. */
2738 gimple_assign_set_rhs3 (gassign
*gs
, tree rhs
)
2740 gcc_gimple_checking_assert (gimple_num_ops (gs
) >= 4);
2745 gimple_assign_set_rhs3 (gimple
*gs
, tree rhs
)
2747 gassign
*ass
= GIMPLE_CHECK2
<gassign
*> (gs
);
2748 gimple_assign_set_rhs3 (ass
, rhs
);
2752 /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2753 which expect to see only two operands. */
2756 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
2759 gimple_assign_set_rhs_with_ops (gsi
, code
, op1
, op2
, NULL
);
2762 /* A wrapper around 3 operand gimple_assign_set_rhs_with_ops, for callers
2763 which expect to see only one operands. */
2766 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
2769 gimple_assign_set_rhs_with_ops (gsi
, code
, op1
, NULL
, NULL
);
2772 /* Returns true if GS is a nontemporal move. */
2775 gimple_assign_nontemporal_move_p (const gassign
*gs
)
2777 return gs
->nontemporal_move
;
2780 /* Sets nontemporal move flag of GS to NONTEMPORAL. */
2783 gimple_assign_set_nontemporal_move (gimple
*gs
, bool nontemporal
)
2785 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2786 gs
->nontemporal_move
= nontemporal
;
2790 /* Return the code of the expression computed on the rhs of assignment
2791 statement GS. In case that the RHS is a single object, returns the
2792 tree code of the object. */
2794 static inline enum tree_code
2795 gimple_assign_rhs_code (const gassign
*gs
)
2797 enum tree_code code
= (enum tree_code
) gs
->subcode
;
2798 /* While we initially set subcode to the TREE_CODE of the rhs for
2799 GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
2800 in sync when we rewrite stmts into SSA form or do SSA propagations. */
2801 if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
)
2802 code
= TREE_CODE (gs
->op
[1]);
2807 static inline enum tree_code
2808 gimple_assign_rhs_code (const gimple
*gs
)
2810 const gassign
*ass
= GIMPLE_CHECK2
<const gassign
*> (gs
);
2811 return gimple_assign_rhs_code (ass
);
2815 /* Set CODE to be the code for the expression computed on the RHS of
2819 gimple_assign_set_rhs_code (gimple
*s
, enum tree_code code
)
2821 GIMPLE_CHECK (s
, GIMPLE_ASSIGN
);
2826 /* Return the gimple rhs class of the code of the expression computed on
2827 the rhs of assignment statement GS.
2828 This will never return GIMPLE_INVALID_RHS. */
2830 static inline enum gimple_rhs_class
2831 gimple_assign_rhs_class (const gimple
*gs
)
2833 return get_gimple_rhs_class (gimple_assign_rhs_code (gs
));
2836 /* Return true if GS is an assignment with a singleton RHS, i.e.,
2837 there is no operator associated with the assignment itself.
2838 Unlike gimple_assign_copy_p, this predicate returns true for
2839 any RHS operand, including those that perform an operation
2840 and do not have the semantics of a copy, such as COND_EXPR. */
2843 gimple_assign_single_p (const gimple
*gs
)
2845 return (is_gimple_assign (gs
)
2846 && gimple_assign_rhs_class (gs
) == GIMPLE_SINGLE_RHS
);
2849 /* Return true if GS performs a store to its lhs. */
2852 gimple_store_p (const gimple
*gs
)
2854 tree lhs
= gimple_get_lhs (gs
);
2855 return lhs
&& !is_gimple_reg (lhs
);
2858 /* Return true if GS is an assignment that loads from its rhs1. */
2861 gimple_assign_load_p (const gimple
*gs
)
2864 if (!gimple_assign_single_p (gs
))
2866 rhs
= gimple_assign_rhs1 (gs
);
2867 if (TREE_CODE (rhs
) == WITH_SIZE_EXPR
)
2869 rhs
= get_base_address (rhs
);
2870 return (DECL_P (rhs
)
2871 || TREE_CODE (rhs
) == MEM_REF
|| TREE_CODE (rhs
) == TARGET_MEM_REF
);
2875 /* Return true if S is a type-cast assignment. */
2878 gimple_assign_cast_p (const gimple
*s
)
2880 if (is_gimple_assign (s
))
2882 enum tree_code sc
= gimple_assign_rhs_code (s
);
2883 return CONVERT_EXPR_CODE_P (sc
)
2884 || sc
== VIEW_CONVERT_EXPR
2885 || sc
== FIX_TRUNC_EXPR
;
2891 /* Return true if S is a clobber statement. */
2894 gimple_clobber_p (const gimple
*s
)
2896 return gimple_assign_single_p (s
)
2897 && TREE_CLOBBER_P (gimple_assign_rhs1 (s
));
2900 /* Return true if GS is a GIMPLE_CALL. */
2903 is_gimple_call (const gimple
*gs
)
2905 return gimple_code (gs
) == GIMPLE_CALL
;
2908 /* Return the LHS of call statement GS. */
2911 gimple_call_lhs (const gcall
*gs
)
2917 gimple_call_lhs (const gimple
*gs
)
2919 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2920 return gimple_call_lhs (gc
);
2924 /* Return a pointer to the LHS of call statement GS. */
2926 static inline tree
*
2927 gimple_call_lhs_ptr (gcall
*gs
)
2932 static inline tree
*
2933 gimple_call_lhs_ptr (gimple
*gs
)
2935 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
2936 return gimple_call_lhs_ptr (gc
);
2940 /* Set LHS to be the LHS operand of call statement GS. */
2943 gimple_call_set_lhs (gcall
*gs
, tree lhs
)
2946 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
2947 SSA_NAME_DEF_STMT (lhs
) = gs
;
2951 gimple_call_set_lhs (gimple
*gs
, tree lhs
)
2953 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
2954 gimple_call_set_lhs (gc
, lhs
);
2958 /* Return true if call GS calls an internal-only function, as enumerated
2962 gimple_call_internal_p (const gcall
*gs
)
2964 return (gs
->subcode
& GF_CALL_INTERNAL
) != 0;
2968 gimple_call_internal_p (const gimple
*gs
)
2970 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
2971 return gimple_call_internal_p (gc
);
2974 /* Return true if call GS is marked as nocf_check. */
2977 gimple_call_nocf_check_p (const gcall
*gs
)
2979 return (gs
->subcode
& GF_CALL_NOCF_CHECK
) != 0;
2982 /* Mark statement GS as nocf_check call. */
2985 gimple_call_set_nocf_check (gcall
*gs
, bool nocf_check
)
2988 gs
->subcode
|= GF_CALL_NOCF_CHECK
;
2990 gs
->subcode
&= ~GF_CALL_NOCF_CHECK
;
2993 /* Return the target of internal call GS. */
2995 static inline enum internal_fn
2996 gimple_call_internal_fn (const gcall
*gs
)
2998 gcc_gimple_checking_assert (gimple_call_internal_p (gs
));
2999 return gs
->u
.internal_fn
;
3002 static inline enum internal_fn
3003 gimple_call_internal_fn (const gimple
*gs
)
3005 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3006 return gimple_call_internal_fn (gc
);
3009 /* Return true, if this internal gimple call is unique. */
3012 gimple_call_internal_unique_p (const gcall
*gs
)
3014 return gimple_call_internal_fn (gs
) == IFN_UNIQUE
;
3018 gimple_call_internal_unique_p (const gimple
*gs
)
3020 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3021 return gimple_call_internal_unique_p (gc
);
3024 /* Return true if GS is an internal function FN. */
3027 gimple_call_internal_p (const gimple
*gs
, internal_fn fn
)
3029 return (is_gimple_call (gs
)
3030 && gimple_call_internal_p (gs
)
3031 && gimple_call_internal_fn (gs
) == fn
);
3034 /* If CTRL_ALTERING_P is true, mark GIMPLE_CALL S to be a stmt
3035 that could alter control flow. */
3038 gimple_call_set_ctrl_altering (gcall
*s
, bool ctrl_altering_p
)
3040 if (ctrl_altering_p
)
3041 s
->subcode
|= GF_CALL_CTRL_ALTERING
;
3043 s
->subcode
&= ~GF_CALL_CTRL_ALTERING
;
3047 gimple_call_set_ctrl_altering (gimple
*s
, bool ctrl_altering_p
)
3049 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (s
);
3050 gimple_call_set_ctrl_altering (gc
, ctrl_altering_p
);
3053 /* Return true if call GS calls an func whose GF_CALL_CTRL_ALTERING
3054 flag is set. Such call could not be a stmt in the middle of a bb. */
3057 gimple_call_ctrl_altering_p (const gcall
*gs
)
3059 return (gs
->subcode
& GF_CALL_CTRL_ALTERING
) != 0;
3063 gimple_call_ctrl_altering_p (const gimple
*gs
)
3065 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3066 return gimple_call_ctrl_altering_p (gc
);
3070 /* Return the function type of the function called by GS. */
3073 gimple_call_fntype (const gcall
*gs
)
3075 if (gimple_call_internal_p (gs
))
3077 return gs
->u
.fntype
;
3081 gimple_call_fntype (const gimple
*gs
)
3083 const gcall
*call_stmt
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3084 return gimple_call_fntype (call_stmt
);
3087 /* Set the type of the function called by CALL_STMT to FNTYPE. */
3090 gimple_call_set_fntype (gcall
*call_stmt
, tree fntype
)
3092 gcc_gimple_checking_assert (!gimple_call_internal_p (call_stmt
));
3093 call_stmt
->u
.fntype
= fntype
;
3097 /* Return the tree node representing the function called by call
3101 gimple_call_fn (const gcall
*gs
)
3107 gimple_call_fn (const gimple
*gs
)
3109 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3110 return gimple_call_fn (gc
);
3113 /* Return a pointer to the tree node representing the function called by call
3116 static inline tree
*
3117 gimple_call_fn_ptr (gcall
*gs
)
3122 static inline tree
*
3123 gimple_call_fn_ptr (gimple
*gs
)
3125 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3126 return gimple_call_fn_ptr (gc
);
3130 /* Set FN to be the function called by call statement GS. */
3133 gimple_call_set_fn (gcall
*gs
, tree fn
)
3135 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
3140 /* Set FNDECL to be the function called by call statement GS. */
3143 gimple_call_set_fndecl (gcall
*gs
, tree decl
)
3145 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
3146 gs
->op
[1] = build1_loc (gimple_location (gs
), ADDR_EXPR
,
3147 build_pointer_type (TREE_TYPE (decl
)), decl
);
3151 gimple_call_set_fndecl (gimple
*gs
, tree decl
)
3153 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3154 gimple_call_set_fndecl (gc
, decl
);
3158 /* Set internal function FN to be the function called by call statement CALL_STMT. */
3161 gimple_call_set_internal_fn (gcall
*call_stmt
, enum internal_fn fn
)
3163 gcc_gimple_checking_assert (gimple_call_internal_p (call_stmt
));
3164 call_stmt
->u
.internal_fn
= fn
;
3168 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
3169 Otherwise return NULL. This function is analogous to
3170 get_callee_fndecl in tree land. */
3173 gimple_call_fndecl (const gcall
*gs
)
3175 return gimple_call_addr_fndecl (gimple_call_fn (gs
));
3179 gimple_call_fndecl (const gimple
*gs
)
3181 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3182 return gimple_call_fndecl (gc
);
3186 /* Return the type returned by call statement GS. */
3189 gimple_call_return_type (const gcall
*gs
)
3191 tree type
= gimple_call_fntype (gs
);
3193 if (type
== NULL_TREE
)
3194 return TREE_TYPE (gimple_call_lhs (gs
));
3196 /* The type returned by a function is the type of its
3198 return TREE_TYPE (type
);
3202 /* Return the static chain for call statement GS. */
3205 gimple_call_chain (const gcall
*gs
)
3211 gimple_call_chain (const gimple
*gs
)
3213 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3214 return gimple_call_chain (gc
);
3218 /* Return a pointer to the static chain for call statement CALL_STMT. */
3220 static inline tree
*
3221 gimple_call_chain_ptr (gcall
*call_stmt
)
3223 return &call_stmt
->op
[2];
3226 /* Set CHAIN to be the static chain for call statement CALL_STMT. */
3229 gimple_call_set_chain (gcall
*call_stmt
, tree chain
)
3231 call_stmt
->op
[2] = chain
;
3235 /* Return the number of arguments used by call statement GS. */
3237 static inline unsigned
3238 gimple_call_num_args (const gcall
*gs
)
3240 return gimple_num_ops (gs
) - 3;
3243 static inline unsigned
3244 gimple_call_num_args (const gimple
*gs
)
3246 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3247 return gimple_call_num_args (gc
);
3251 /* Return the argument at position INDEX for call statement GS. */
3254 gimple_call_arg (const gcall
*gs
, unsigned index
)
3256 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 3);
3257 return gs
->op
[index
+ 3];
3261 gimple_call_arg (const gimple
*gs
, unsigned index
)
3263 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (gs
);
3264 return gimple_call_arg (gc
, index
);
3268 /* Return a pointer to the argument at position INDEX for call
3271 static inline tree
*
3272 gimple_call_arg_ptr (gcall
*gs
, unsigned index
)
3274 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 3);
3275 return &gs
->op
[index
+ 3];
3278 static inline tree
*
3279 gimple_call_arg_ptr (gimple
*gs
, unsigned index
)
3281 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3282 return gimple_call_arg_ptr (gc
, index
);
3286 /* Set ARG to be the argument at position INDEX for call statement GS. */
3289 gimple_call_set_arg (gcall
*gs
, unsigned index
, tree arg
)
3291 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 3);
3292 gs
->op
[index
+ 3] = arg
;
3296 gimple_call_set_arg (gimple
*gs
, unsigned index
, tree arg
)
3298 gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (gs
);
3299 gimple_call_set_arg (gc
, index
, arg
);
3303 /* If TAIL_P is true, mark call statement S as being a tail call
3304 (i.e., a call just before the exit of a function). These calls are
3305 candidate for tail call optimization. */
3308 gimple_call_set_tail (gcall
*s
, bool tail_p
)
3311 s
->subcode
|= GF_CALL_TAILCALL
;
3313 s
->subcode
&= ~GF_CALL_TAILCALL
;
3317 /* Return true if GIMPLE_CALL S is marked as a tail call. */
3320 gimple_call_tail_p (const gcall
*s
)
3322 return (s
->subcode
& GF_CALL_TAILCALL
) != 0;
3325 /* Mark (or clear) call statement S as requiring tail call optimization. */
3328 gimple_call_set_must_tail (gcall
*s
, bool must_tail_p
)
3331 s
->subcode
|= GF_CALL_MUST_TAIL_CALL
;
3333 s
->subcode
&= ~GF_CALL_MUST_TAIL_CALL
;
3336 /* Return true if call statement has been marked as requiring
3337 tail call optimization. */
3340 gimple_call_must_tail_p (const gcall
*s
)
3342 return (s
->subcode
& GF_CALL_MUST_TAIL_CALL
) != 0;
3345 /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
3346 slot optimization. This transformation uses the target of the call
3347 expansion as the return slot for calls that return in memory. */
3350 gimple_call_set_return_slot_opt (gcall
*s
, bool return_slot_opt_p
)
3352 if (return_slot_opt_p
)
3353 s
->subcode
|= GF_CALL_RETURN_SLOT_OPT
;
3355 s
->subcode
&= ~GF_CALL_RETURN_SLOT_OPT
;
3359 /* Return true if S is marked for return slot optimization. */
3362 gimple_call_return_slot_opt_p (const gcall
*s
)
3364 return (s
->subcode
& GF_CALL_RETURN_SLOT_OPT
) != 0;
3368 /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
3369 thunk to the thunked-to function. */
3372 gimple_call_set_from_thunk (gcall
*s
, bool from_thunk_p
)
3375 s
->subcode
|= GF_CALL_FROM_THUNK
;
3377 s
->subcode
&= ~GF_CALL_FROM_THUNK
;
3381 /* Return true if GIMPLE_CALL S is a jump from a thunk. */
3384 gimple_call_from_thunk_p (gcall
*s
)
3386 return (s
->subcode
& GF_CALL_FROM_THUNK
) != 0;
3390 /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
3391 argument pack in its argument list. */
3394 gimple_call_set_va_arg_pack (gcall
*s
, bool pass_arg_pack_p
)
3396 if (pass_arg_pack_p
)
3397 s
->subcode
|= GF_CALL_VA_ARG_PACK
;
3399 s
->subcode
&= ~GF_CALL_VA_ARG_PACK
;
3403 /* Return true if GIMPLE_CALL S is a stdarg call that needs the
3404 argument pack in its argument list. */
3407 gimple_call_va_arg_pack_p (const gcall
*s
)
3409 return (s
->subcode
& GF_CALL_VA_ARG_PACK
) != 0;
3413 /* Return true if S is a noreturn call. */
3416 gimple_call_noreturn_p (const gcall
*s
)
3418 return (gimple_call_flags (s
) & ECF_NORETURN
) != 0;
3422 gimple_call_noreturn_p (const gimple
*s
)
3424 const gcall
*gc
= GIMPLE_CHECK2
<const gcall
*> (s
);
3425 return gimple_call_noreturn_p (gc
);
3429 /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
3430 even if the called function can throw in other cases. */
3433 gimple_call_set_nothrow (gcall
*s
, bool nothrow_p
)
3436 s
->subcode
|= GF_CALL_NOTHROW
;
3438 s
->subcode
&= ~GF_CALL_NOTHROW
;
3441 /* Return true if S is a nothrow call. */
3444 gimple_call_nothrow_p (gcall
*s
)
3446 return (gimple_call_flags (s
) & ECF_NOTHROW
) != 0;
3449 /* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
3450 is known to be emitted for VLA objects. Those are wrapped by
3451 stack_save/stack_restore calls and hence can't lead to unbounded
3452 stack growth even when they occur in loops. */
3455 gimple_call_set_alloca_for_var (gcall
*s
, bool for_var
)
3458 s
->subcode
|= GF_CALL_ALLOCA_FOR_VAR
;
3460 s
->subcode
&= ~GF_CALL_ALLOCA_FOR_VAR
;
3463 /* Return true of S is a call to builtin_alloca emitted for VLA objects. */
3466 gimple_call_alloca_for_var_p (gcall
*s
)
3468 return (s
->subcode
& GF_CALL_ALLOCA_FOR_VAR
) != 0;
3472 gimple_call_alloca_for_var_p (gimple
*s
)
3474 const gcall
*gc
= GIMPLE_CHECK2
<gcall
*> (s
);
3475 return (gc
->subcode
& GF_CALL_ALLOCA_FOR_VAR
) != 0;
3478 /* If BY_DESCRIPTOR_P is true, GIMPLE_CALL S is an indirect call for which
3479 pointers to nested function are descriptors instead of trampolines. */
3482 gimple_call_set_by_descriptor (gcall
*s
, bool by_descriptor_p
)
3484 if (by_descriptor_p
)
3485 s
->subcode
|= GF_CALL_BY_DESCRIPTOR
;
3487 s
->subcode
&= ~GF_CALL_BY_DESCRIPTOR
;
3490 /* Return true if S is a by-descriptor call. */
3493 gimple_call_by_descriptor_p (gcall
*s
)
3495 return (s
->subcode
& GF_CALL_BY_DESCRIPTOR
) != 0;
3498 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
3501 gimple_call_copy_flags (gcall
*dest_call
, gcall
*orig_call
)
3503 dest_call
->subcode
= orig_call
->subcode
;
3507 /* Return a pointer to the points-to solution for the set of call-used
3508 variables of the call CALL_STMT. */
3510 static inline struct pt_solution
*
3511 gimple_call_use_set (gcall
*call_stmt
)
3513 return &call_stmt
->call_used
;
3516 /* As above, but const. */
3518 static inline const pt_solution
*
3519 gimple_call_use_set (const gcall
*call_stmt
)
3521 return &call_stmt
->call_used
;
3524 /* Return a pointer to the points-to solution for the set of call-used
3525 variables of the call CALL_STMT. */
3527 static inline struct pt_solution
*
3528 gimple_call_clobber_set (gcall
*call_stmt
)
3530 return &call_stmt
->call_clobbered
;
3533 /* As above, but const. */
3535 static inline const pt_solution
*
3536 gimple_call_clobber_set (const gcall
*call_stmt
)
3538 return &call_stmt
->call_clobbered
;
3542 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
3546 gimple_has_lhs (const gimple
*stmt
)
3548 if (is_gimple_assign (stmt
))
3550 if (const gcall
*call
= dyn_cast
<const gcall
*> (stmt
))
3551 return gimple_call_lhs (call
) != NULL_TREE
;
3556 /* Return the code of the predicate computed by conditional statement GS. */
3558 static inline enum tree_code
3559 gimple_cond_code (const gcond
*gs
)
3561 return (enum tree_code
) gs
->subcode
;
3564 static inline enum tree_code
3565 gimple_cond_code (const gimple
*gs
)
3567 const gcond
*gc
= GIMPLE_CHECK2
<const gcond
*> (gs
);
3568 return gimple_cond_code (gc
);
3572 /* Set CODE to be the predicate code for the conditional statement GS. */
3575 gimple_cond_set_code (gcond
*gs
, enum tree_code code
)
3581 /* Return the LHS of the predicate computed by conditional statement GS. */
3584 gimple_cond_lhs (const gcond
*gs
)
3590 gimple_cond_lhs (const gimple
*gs
)
3592 const gcond
*gc
= GIMPLE_CHECK2
<const gcond
*> (gs
);
3593 return gimple_cond_lhs (gc
);
3596 /* Return the pointer to the LHS of the predicate computed by conditional
3599 static inline tree
*
3600 gimple_cond_lhs_ptr (gcond
*gs
)
3605 /* Set LHS to be the LHS operand of the predicate computed by
3606 conditional statement GS. */
3609 gimple_cond_set_lhs (gcond
*gs
, tree lhs
)
3615 /* Return the RHS operand of the predicate computed by conditional GS. */
3618 gimple_cond_rhs (const gcond
*gs
)
3624 gimple_cond_rhs (const gimple
*gs
)
3626 const gcond
*gc
= GIMPLE_CHECK2
<const gcond
*> (gs
);
3627 return gimple_cond_rhs (gc
);
3630 /* Return the pointer to the RHS operand of the predicate computed by
3633 static inline tree
*
3634 gimple_cond_rhs_ptr (gcond
*gs
)
3640 /* Set RHS to be the RHS operand of the predicate computed by
3641 conditional statement GS. */
3644 gimple_cond_set_rhs (gcond
*gs
, tree rhs
)
3650 /* Return the label used by conditional statement GS when its
3651 predicate evaluates to true. */
3654 gimple_cond_true_label (const gcond
*gs
)
3660 /* Set LABEL to be the label used by conditional statement GS when its
3661 predicate evaluates to true. */
3664 gimple_cond_set_true_label (gcond
*gs
, tree label
)
3670 /* Set LABEL to be the label used by conditional statement GS when its
3671 predicate evaluates to false. */
3674 gimple_cond_set_false_label (gcond
*gs
, tree label
)
3680 /* Return the label used by conditional statement GS when its
3681 predicate evaluates to false. */
3684 gimple_cond_false_label (const gcond
*gs
)
3690 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */
3693 gimple_cond_make_false (gcond
*gs
)
3695 gimple_cond_set_lhs (gs
, boolean_false_node
);
3696 gimple_cond_set_rhs (gs
, boolean_false_node
);
3697 gs
->subcode
= NE_EXPR
;
3701 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */
3704 gimple_cond_make_true (gcond
*gs
)
3706 gimple_cond_set_lhs (gs
, boolean_true_node
);
3707 gimple_cond_set_rhs (gs
, boolean_false_node
);
3708 gs
->subcode
= NE_EXPR
;
3711 /* Check if conditional statemente GS is of the form 'if (1 == 1)',
3712 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
3715 gimple_cond_true_p (const gcond
*gs
)
3717 tree lhs
= gimple_cond_lhs (gs
);
3718 tree rhs
= gimple_cond_rhs (gs
);
3719 enum tree_code code
= gimple_cond_code (gs
);
3721 if (lhs
!= boolean_true_node
&& lhs
!= boolean_false_node
)
3724 if (rhs
!= boolean_true_node
&& rhs
!= boolean_false_node
)
3727 if (code
== NE_EXPR
&& lhs
!= rhs
)
3730 if (code
== EQ_EXPR
&& lhs
== rhs
)
3736 /* Check if conditional statement GS is of the form 'if (1 != 1)',
3737 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
3740 gimple_cond_false_p (const gcond
*gs
)
3742 tree lhs
= gimple_cond_lhs (gs
);
3743 tree rhs
= gimple_cond_rhs (gs
);
3744 enum tree_code code
= gimple_cond_code (gs
);
3746 if (lhs
!= boolean_true_node
&& lhs
!= boolean_false_node
)
3749 if (rhs
!= boolean_true_node
&& rhs
!= boolean_false_node
)
3752 if (code
== NE_EXPR
&& lhs
== rhs
)
3755 if (code
== EQ_EXPR
&& lhs
!= rhs
)
3761 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
3764 gimple_cond_set_condition (gcond
*stmt
, enum tree_code code
, tree lhs
,
3767 gimple_cond_set_code (stmt
, code
);
3768 gimple_cond_set_lhs (stmt
, lhs
);
3769 gimple_cond_set_rhs (stmt
, rhs
);
3772 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
3775 gimple_label_label (const glabel
*gs
)
3781 /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
3785 gimple_label_set_label (glabel
*gs
, tree label
)
3791 /* Return the destination of the unconditional jump GS. */
3794 gimple_goto_dest (const gimple
*gs
)
3796 GIMPLE_CHECK (gs
, GIMPLE_GOTO
);
3797 return gimple_op (gs
, 0);
3801 /* Set DEST to be the destination of the unconditonal jump GS. */
3804 gimple_goto_set_dest (ggoto
*gs
, tree dest
)
3810 /* Return the variables declared in the GIMPLE_BIND statement GS. */
3813 gimple_bind_vars (const gbind
*bind_stmt
)
3815 return bind_stmt
->vars
;
3819 /* Set VARS to be the set of variables declared in the GIMPLE_BIND
3823 gimple_bind_set_vars (gbind
*bind_stmt
, tree vars
)
3825 bind_stmt
->vars
= vars
;
3829 /* Append VARS to the set of variables declared in the GIMPLE_BIND
3833 gimple_bind_append_vars (gbind
*bind_stmt
, tree vars
)
3835 bind_stmt
->vars
= chainon (bind_stmt
->vars
, vars
);
3839 static inline gimple_seq
*
3840 gimple_bind_body_ptr (gbind
*bind_stmt
)
3842 return &bind_stmt
->body
;
3845 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
3847 static inline gimple_seq
3848 gimple_bind_body (const gbind
*gs
)
3850 return *gimple_bind_body_ptr (const_cast <gbind
*> (gs
));
3854 /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
3858 gimple_bind_set_body (gbind
*bind_stmt
, gimple_seq seq
)
3860 bind_stmt
->body
= seq
;
3864 /* Append a statement to the end of a GIMPLE_BIND's body. */
3867 gimple_bind_add_stmt (gbind
*bind_stmt
, gimple
*stmt
)
3869 gimple_seq_add_stmt (&bind_stmt
->body
, stmt
);
3873 /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
3876 gimple_bind_add_seq (gbind
*bind_stmt
, gimple_seq seq
)
3878 gimple_seq_add_seq (&bind_stmt
->body
, seq
);
3882 /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
3883 GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
3886 gimple_bind_block (const gbind
*bind_stmt
)
3888 return bind_stmt
->block
;
3892 /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
3896 gimple_bind_set_block (gbind
*bind_stmt
, tree block
)
3898 gcc_gimple_checking_assert (block
== NULL_TREE
3899 || TREE_CODE (block
) == BLOCK
);
3900 bind_stmt
->block
= block
;
3904 /* Return the number of input operands for GIMPLE_ASM ASM_STMT. */
3906 static inline unsigned
3907 gimple_asm_ninputs (const gasm
*asm_stmt
)
3909 return asm_stmt
->ni
;
3913 /* Return the number of output operands for GIMPLE_ASM ASM_STMT. */
3915 static inline unsigned
3916 gimple_asm_noutputs (const gasm
*asm_stmt
)
3918 return asm_stmt
->no
;
3922 /* Return the number of clobber operands for GIMPLE_ASM ASM_STMT. */
3924 static inline unsigned
3925 gimple_asm_nclobbers (const gasm
*asm_stmt
)
3927 return asm_stmt
->nc
;
3930 /* Return the number of label operands for GIMPLE_ASM ASM_STMT. */
3932 static inline unsigned
3933 gimple_asm_nlabels (const gasm
*asm_stmt
)
3935 return asm_stmt
->nl
;
3938 /* Return input operand INDEX of GIMPLE_ASM ASM_STMT. */
3941 gimple_asm_input_op (const gasm
*asm_stmt
, unsigned index
)
3943 gcc_gimple_checking_assert (index
< asm_stmt
->ni
);
3944 return asm_stmt
->op
[index
+ asm_stmt
->no
];
3947 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM ASM_STMT. */
3950 gimple_asm_set_input_op (gasm
*asm_stmt
, unsigned index
, tree in_op
)
3952 gcc_gimple_checking_assert (index
< asm_stmt
->ni
3953 && TREE_CODE (in_op
) == TREE_LIST
);
3954 asm_stmt
->op
[index
+ asm_stmt
->no
] = in_op
;
3958 /* Return output operand INDEX of GIMPLE_ASM ASM_STMT. */
3961 gimple_asm_output_op (const gasm
*asm_stmt
, unsigned index
)
3963 gcc_gimple_checking_assert (index
< asm_stmt
->no
);
3964 return asm_stmt
->op
[index
];
3967 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM ASM_STMT. */
3970 gimple_asm_set_output_op (gasm
*asm_stmt
, unsigned index
, tree out_op
)
3972 gcc_gimple_checking_assert (index
< asm_stmt
->no
3973 && TREE_CODE (out_op
) == TREE_LIST
);
3974 asm_stmt
->op
[index
] = out_op
;
3978 /* Return clobber operand INDEX of GIMPLE_ASM ASM_STMT. */
3981 gimple_asm_clobber_op (const gasm
*asm_stmt
, unsigned index
)
3983 gcc_gimple_checking_assert (index
< asm_stmt
->nc
);
3984 return asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->no
];
3988 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM ASM_STMT. */
3991 gimple_asm_set_clobber_op (gasm
*asm_stmt
, unsigned index
, tree clobber_op
)
3993 gcc_gimple_checking_assert (index
< asm_stmt
->nc
3994 && TREE_CODE (clobber_op
) == TREE_LIST
);
3995 asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->no
] = clobber_op
;
3998 /* Return label operand INDEX of GIMPLE_ASM ASM_STMT. */
4001 gimple_asm_label_op (const gasm
*asm_stmt
, unsigned index
)
4003 gcc_gimple_checking_assert (index
< asm_stmt
->nl
);
4004 return asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->nc
];
4007 /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM ASM_STMT. */
4010 gimple_asm_set_label_op (gasm
*asm_stmt
, unsigned index
, tree label_op
)
4012 gcc_gimple_checking_assert (index
< asm_stmt
->nl
4013 && TREE_CODE (label_op
) == TREE_LIST
);
4014 asm_stmt
->op
[index
+ asm_stmt
->ni
+ asm_stmt
->nc
] = label_op
;
4017 /* Return the string representing the assembly instruction in
4018 GIMPLE_ASM ASM_STMT. */
4020 static inline const char *
4021 gimple_asm_string (const gasm
*asm_stmt
)
4023 return asm_stmt
->string
;
4027 /* Return true if ASM_STMT is marked volatile. */
4030 gimple_asm_volatile_p (const gasm
*asm_stmt
)
4032 return (asm_stmt
->subcode
& GF_ASM_VOLATILE
) != 0;
4036 /* If VOLATILE_P is true, mark asm statement ASM_STMT as volatile. */
4039 gimple_asm_set_volatile (gasm
*asm_stmt
, bool volatile_p
)
4042 asm_stmt
->subcode
|= GF_ASM_VOLATILE
;
4044 asm_stmt
->subcode
&= ~GF_ASM_VOLATILE
;
4048 /* Return true if ASM_STMT is marked inline. */
4051 gimple_asm_inline_p (const gasm
*asm_stmt
)
4053 return (asm_stmt
->subcode
& GF_ASM_INLINE
) != 0;
4057 /* If INLINE_P is true, mark asm statement ASM_STMT as inline. */
4060 gimple_asm_set_inline (gasm
*asm_stmt
, bool inline_p
)
4063 asm_stmt
->subcode
|= GF_ASM_INLINE
;
4065 asm_stmt
->subcode
&= ~GF_ASM_INLINE
;
4069 /* If INPUT_P is true, mark asm ASM_STMT as an ASM_INPUT. */
4072 gimple_asm_set_input (gasm
*asm_stmt
, bool input_p
)
4075 asm_stmt
->subcode
|= GF_ASM_INPUT
;
4077 asm_stmt
->subcode
&= ~GF_ASM_INPUT
;
4081 /* Return true if asm ASM_STMT is an ASM_INPUT. */
4084 gimple_asm_input_p (const gasm
*asm_stmt
)
4086 return (asm_stmt
->subcode
& GF_ASM_INPUT
) != 0;
4090 /* Return the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4093 gimple_catch_types (const gcatch
*catch_stmt
)
4095 return catch_stmt
->types
;
4099 /* Return a pointer to the types handled by GIMPLE_CATCH statement CATCH_STMT. */
4101 static inline tree
*
4102 gimple_catch_types_ptr (gcatch
*catch_stmt
)
4104 return &catch_stmt
->types
;
4108 /* Return a pointer to the GIMPLE sequence representing the body of
4109 the handler of GIMPLE_CATCH statement CATCH_STMT. */
4111 static inline gimple_seq
*
4112 gimple_catch_handler_ptr (gcatch
*catch_stmt
)
4114 return &catch_stmt
->handler
;
4118 /* Return the GIMPLE sequence representing the body of the handler of
4119 GIMPLE_CATCH statement CATCH_STMT. */
4121 static inline gimple_seq
4122 gimple_catch_handler (const gcatch
*catch_stmt
)
4124 return *gimple_catch_handler_ptr (const_cast <gcatch
*> (catch_stmt
));
4128 /* Set T to be the set of types handled by GIMPLE_CATCH CATCH_STMT. */
4131 gimple_catch_set_types (gcatch
*catch_stmt
, tree t
)
4133 catch_stmt
->types
= t
;
4137 /* Set HANDLER to be the body of GIMPLE_CATCH CATCH_STMT. */
4140 gimple_catch_set_handler (gcatch
*catch_stmt
, gimple_seq handler
)
4142 catch_stmt
->handler
= handler
;
4146 /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
4149 gimple_eh_filter_types (const gimple
*gs
)
4151 const geh_filter
*eh_filter_stmt
= as_a
<const geh_filter
*> (gs
);
4152 return eh_filter_stmt
->types
;
4156 /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
4159 static inline tree
*
4160 gimple_eh_filter_types_ptr (gimple
*gs
)
4162 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (gs
);
4163 return &eh_filter_stmt
->types
;
4167 /* Return a pointer to the sequence of statement to execute when
4168 GIMPLE_EH_FILTER statement fails. */
4170 static inline gimple_seq
*
4171 gimple_eh_filter_failure_ptr (gimple
*gs
)
4173 geh_filter
*eh_filter_stmt
= as_a
<geh_filter
*> (gs
);
4174 return &eh_filter_stmt
->failure
;
4178 /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
4181 static inline gimple_seq
4182 gimple_eh_filter_failure (const gimple
*gs
)
4184 return *gimple_eh_filter_failure_ptr (const_cast <gimple
*> (gs
));
4188 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER
4192 gimple_eh_filter_set_types (geh_filter
*eh_filter_stmt
, tree types
)
4194 eh_filter_stmt
->types
= types
;
4198 /* Set FAILURE to be the sequence of statements to execute on failure
4199 for GIMPLE_EH_FILTER EH_FILTER_STMT. */
4202 gimple_eh_filter_set_failure (geh_filter
*eh_filter_stmt
,
4205 eh_filter_stmt
->failure
= failure
;
4208 /* Get the function decl to be called by the MUST_NOT_THROW region. */
4211 gimple_eh_must_not_throw_fndecl (const geh_mnt
*eh_mnt_stmt
)
4213 return eh_mnt_stmt
->fndecl
;
4216 /* Set the function decl to be called by GS to DECL. */
4219 gimple_eh_must_not_throw_set_fndecl (geh_mnt
*eh_mnt_stmt
,
4222 eh_mnt_stmt
->fndecl
= decl
;
4225 /* GIMPLE_EH_ELSE accessors. */
4227 static inline gimple_seq
*
4228 gimple_eh_else_n_body_ptr (geh_else
*eh_else_stmt
)
4230 return &eh_else_stmt
->n_body
;
4233 static inline gimple_seq
4234 gimple_eh_else_n_body (const geh_else
*eh_else_stmt
)
4236 return *gimple_eh_else_n_body_ptr (const_cast <geh_else
*> (eh_else_stmt
));
4239 static inline gimple_seq
*
4240 gimple_eh_else_e_body_ptr (geh_else
*eh_else_stmt
)
4242 return &eh_else_stmt
->e_body
;
4245 static inline gimple_seq
4246 gimple_eh_else_e_body (const geh_else
*eh_else_stmt
)
4248 return *gimple_eh_else_e_body_ptr (const_cast <geh_else
*> (eh_else_stmt
));
4252 gimple_eh_else_set_n_body (geh_else
*eh_else_stmt
, gimple_seq seq
)
4254 eh_else_stmt
->n_body
= seq
;
4258 gimple_eh_else_set_e_body (geh_else
*eh_else_stmt
, gimple_seq seq
)
4260 eh_else_stmt
->e_body
= seq
;
4263 /* GIMPLE_TRY accessors. */
4265 /* Return the kind of try block represented by GIMPLE_TRY GS. This is
4266 either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
4268 static inline enum gimple_try_flags
4269 gimple_try_kind (const gimple
*gs
)
4271 GIMPLE_CHECK (gs
, GIMPLE_TRY
);
4272 return (enum gimple_try_flags
) (gs
->subcode
& GIMPLE_TRY_KIND
);
4276 /* Set the kind of try block represented by GIMPLE_TRY GS. */
4279 gimple_try_set_kind (gtry
*gs
, enum gimple_try_flags kind
)
4281 gcc_gimple_checking_assert (kind
== GIMPLE_TRY_CATCH
4282 || kind
== GIMPLE_TRY_FINALLY
);
4283 if (gimple_try_kind (gs
) != kind
)
4284 gs
->subcode
= (unsigned int) kind
;
4288 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4291 gimple_try_catch_is_cleanup (const gimple
*gs
)
4293 gcc_gimple_checking_assert (gimple_try_kind (gs
) == GIMPLE_TRY_CATCH
);
4294 return (gs
->subcode
& GIMPLE_TRY_CATCH_IS_CLEANUP
) != 0;
4298 /* Return a pointer to the sequence of statements used as the
4299 body for GIMPLE_TRY GS. */
4301 static inline gimple_seq
*
4302 gimple_try_eval_ptr (gimple
*gs
)
4304 gtry
*try_stmt
= as_a
<gtry
*> (gs
);
4305 return &try_stmt
->eval
;
4309 /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
4311 static inline gimple_seq
4312 gimple_try_eval (const gimple
*gs
)
4314 return *gimple_try_eval_ptr (const_cast <gimple
*> (gs
));
4318 /* Return a pointer to the sequence of statements used as the cleanup body for
4321 static inline gimple_seq
*
4322 gimple_try_cleanup_ptr (gimple
*gs
)
4324 gtry
*try_stmt
= as_a
<gtry
*> (gs
);
4325 return &try_stmt
->cleanup
;
4329 /* Return the sequence of statements used as the cleanup body for
4332 static inline gimple_seq
4333 gimple_try_cleanup (const gimple
*gs
)
4335 return *gimple_try_cleanup_ptr (const_cast <gimple
*> (gs
));
4339 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
4342 gimple_try_set_catch_is_cleanup (gtry
*g
, bool catch_is_cleanup
)
4344 gcc_gimple_checking_assert (gimple_try_kind (g
) == GIMPLE_TRY_CATCH
);
4345 if (catch_is_cleanup
)
4346 g
->subcode
|= GIMPLE_TRY_CATCH_IS_CLEANUP
;
4348 g
->subcode
&= ~GIMPLE_TRY_CATCH_IS_CLEANUP
;
4352 /* Set EVAL to be the sequence of statements to use as the body for
4353 GIMPLE_TRY TRY_STMT. */
4356 gimple_try_set_eval (gtry
*try_stmt
, gimple_seq eval
)
4358 try_stmt
->eval
= eval
;
4362 /* Set CLEANUP to be the sequence of statements to use as the cleanup
4363 body for GIMPLE_TRY TRY_STMT. */
4366 gimple_try_set_cleanup (gtry
*try_stmt
, gimple_seq cleanup
)
4368 try_stmt
->cleanup
= cleanup
;
4372 /* Return a pointer to the cleanup sequence for cleanup statement GS. */
4374 static inline gimple_seq
*
4375 gimple_wce_cleanup_ptr (gimple
*gs
)
4377 gimple_statement_wce
*wce_stmt
= as_a
<gimple_statement_wce
*> (gs
);
4378 return &wce_stmt
->cleanup
;
4382 /* Return the cleanup sequence for cleanup statement GS. */
4384 static inline gimple_seq
4385 gimple_wce_cleanup (gimple
*gs
)
4387 return *gimple_wce_cleanup_ptr (gs
);
4391 /* Set CLEANUP to be the cleanup sequence for GS. */
4394 gimple_wce_set_cleanup (gimple
*gs
, gimple_seq cleanup
)
4396 gimple_statement_wce
*wce_stmt
= as_a
<gimple_statement_wce
*> (gs
);
4397 wce_stmt
->cleanup
= cleanup
;
4401 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
4404 gimple_wce_cleanup_eh_only (const gimple
*gs
)
4406 GIMPLE_CHECK (gs
, GIMPLE_WITH_CLEANUP_EXPR
);
4407 return gs
->subcode
!= 0;
4411 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
4414 gimple_wce_set_cleanup_eh_only (gimple
*gs
, bool eh_only_p
)
4416 GIMPLE_CHECK (gs
, GIMPLE_WITH_CLEANUP_EXPR
);
4417 gs
->subcode
= (unsigned int) eh_only_p
;
4421 /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
4423 static inline unsigned
4424 gimple_phi_capacity (const gimple
*gs
)
4426 const gphi
*phi_stmt
= as_a
<const gphi
*> (gs
);
4427 return phi_stmt
->capacity
;
4431 /* Return the number of arguments in GIMPLE_PHI GS. This must always
4432 be exactly the number of incoming edges for the basic block holding
4435 static inline unsigned
4436 gimple_phi_num_args (const gimple
*gs
)
4438 const gphi
*phi_stmt
= as_a
<const gphi
*> (gs
);
4439 return phi_stmt
->nargs
;
4443 /* Return the SSA name created by GIMPLE_PHI GS. */
4446 gimple_phi_result (const gphi
*gs
)
4452 gimple_phi_result (const gimple
*gs
)
4454 const gphi
*phi_stmt
= as_a
<const gphi
*> (gs
);
4455 return gimple_phi_result (phi_stmt
);
4458 /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
4460 static inline tree
*
4461 gimple_phi_result_ptr (gphi
*gs
)
4466 static inline tree
*
4467 gimple_phi_result_ptr (gimple
*gs
)
4469 gphi
*phi_stmt
= as_a
<gphi
*> (gs
);
4470 return gimple_phi_result_ptr (phi_stmt
);
4473 /* Set RESULT to be the SSA name created by GIMPLE_PHI PHI. */
4476 gimple_phi_set_result (gphi
*phi
, tree result
)
4478 phi
->result
= result
;
4479 if (result
&& TREE_CODE (result
) == SSA_NAME
)
4480 SSA_NAME_DEF_STMT (result
) = phi
;
4484 /* Return the PHI argument corresponding to incoming edge INDEX for
4487 static inline struct phi_arg_d
*
4488 gimple_phi_arg (gphi
*gs
, unsigned index
)
4490 gcc_gimple_checking_assert (index
< gs
->nargs
);
4491 return &(gs
->args
[index
]);
4494 static inline const phi_arg_d
*
4495 gimple_phi_arg (const gphi
*gs
, unsigned index
)
4497 gcc_gimple_checking_assert (index
< gs
->nargs
);
4498 return &(gs
->args
[index
]);
4501 static inline struct phi_arg_d
*
4502 gimple_phi_arg (gimple
*gs
, unsigned index
)
4504 gphi
*phi_stmt
= as_a
<gphi
*> (gs
);
4505 return gimple_phi_arg (phi_stmt
, index
);
4508 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
4509 for GIMPLE_PHI PHI. */
4512 gimple_phi_set_arg (gphi
*phi
, unsigned index
, struct phi_arg_d
* phiarg
)
4514 gcc_gimple_checking_assert (index
< phi
->nargs
);
4515 phi
->args
[index
] = *phiarg
;
4518 /* Return the PHI nodes for basic block BB, or NULL if there are no
4521 static inline gimple_seq
4522 phi_nodes (const_basic_block bb
)
4524 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
4525 return bb
->il
.gimple
.phi_nodes
;
4528 /* Return a pointer to the PHI nodes for basic block BB. */
4530 static inline gimple_seq
*
4531 phi_nodes_ptr (basic_block bb
)
4533 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
4534 return &bb
->il
.gimple
.phi_nodes
;
4537 /* Return the tree operand for argument I of PHI node GS. */
4540 gimple_phi_arg_def (const gphi
*gs
, size_t index
)
4542 return gimple_phi_arg (gs
, index
)->def
;
4546 gimple_phi_arg_def (gimple
*gs
, size_t index
)
4548 return gimple_phi_arg (gs
, index
)->def
;
4552 /* Return a pointer to the tree operand for argument I of phi node PHI. */
4554 static inline tree
*
4555 gimple_phi_arg_def_ptr (gphi
*phi
, size_t index
)
4557 return &gimple_phi_arg (phi
, index
)->def
;
4560 /* Return the edge associated with argument I of phi node PHI. */
4563 gimple_phi_arg_edge (const gphi
*phi
, size_t i
)
4565 return EDGE_PRED (gimple_bb (phi
), i
);
4568 /* Return the source location of gimple argument I of phi node PHI. */
4570 static inline location_t
4571 gimple_phi_arg_location (const gphi
*phi
, size_t i
)
4573 return gimple_phi_arg (phi
, i
)->locus
;
4576 /* Return the source location of the argument on edge E of phi node PHI. */
4578 static inline location_t
4579 gimple_phi_arg_location_from_edge (gphi
*phi
, edge e
)
4581 return gimple_phi_arg (phi
, e
->dest_idx
)->locus
;
4584 /* Set the source location of gimple argument I of phi node PHI to LOC. */
4587 gimple_phi_arg_set_location (gphi
*phi
, size_t i
, location_t loc
)
4589 gimple_phi_arg (phi
, i
)->locus
= loc
;
4592 /* Return address of source location of gimple argument I of phi node PHI. */
4594 static inline location_t
*
4595 gimple_phi_arg_location_ptr (gphi
*phi
, size_t i
)
4597 return &gimple_phi_arg (phi
, i
)->locus
;
4600 /* Return TRUE if argument I of phi node PHI has a location record. */
4603 gimple_phi_arg_has_location (const gphi
*phi
, size_t i
)
4605 return gimple_phi_arg_location (phi
, i
) != UNKNOWN_LOCATION
;
4609 /* Return the region number for GIMPLE_RESX RESX_STMT. */
4612 gimple_resx_region (const gresx
*resx_stmt
)
4614 return resx_stmt
->region
;
4617 /* Set REGION to be the region number for GIMPLE_RESX RESX_STMT. */
4620 gimple_resx_set_region (gresx
*resx_stmt
, int region
)
4622 resx_stmt
->region
= region
;
4625 /* Return the region number for GIMPLE_EH_DISPATCH EH_DISPATCH_STMT. */
4628 gimple_eh_dispatch_region (const geh_dispatch
*eh_dispatch_stmt
)
4630 return eh_dispatch_stmt
->region
;
4633 /* Set REGION to be the region number for GIMPLE_EH_DISPATCH
4634 EH_DISPATCH_STMT. */
4637 gimple_eh_dispatch_set_region (geh_dispatch
*eh_dispatch_stmt
, int region
)
4639 eh_dispatch_stmt
->region
= region
;
4642 /* Return the number of labels associated with the switch statement GS. */
4644 static inline unsigned
4645 gimple_switch_num_labels (const gswitch
*gs
)
4648 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
4649 num_ops
= gimple_num_ops (gs
);
4650 gcc_gimple_checking_assert (num_ops
> 1);
4655 /* Set NLABELS to be the number of labels for the switch statement GS. */
4658 gimple_switch_set_num_labels (gswitch
*g
, unsigned nlabels
)
4660 GIMPLE_CHECK (g
, GIMPLE_SWITCH
);
4661 gimple_set_num_ops (g
, nlabels
+ 1);
4665 /* Return the index variable used by the switch statement GS. */
4668 gimple_switch_index (const gswitch
*gs
)
4674 /* Return a pointer to the index variable for the switch statement GS. */
4676 static inline tree
*
4677 gimple_switch_index_ptr (gswitch
*gs
)
4683 /* Set INDEX to be the index variable for switch statement GS. */
4686 gimple_switch_set_index (gswitch
*gs
, tree index
)
4688 gcc_gimple_checking_assert (SSA_VAR_P (index
) || CONSTANT_CLASS_P (index
));
4693 /* Return the label numbered INDEX. The default label is 0, followed by any
4694 labels in a switch statement. */
4697 gimple_switch_label (const gswitch
*gs
, unsigned index
)
4699 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 1);
4700 return gs
->op
[index
+ 1];
4703 /* Set the label number INDEX to LABEL. 0 is always the default label. */
4706 gimple_switch_set_label (gswitch
*gs
, unsigned index
, tree label
)
4708 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 1
4709 && (label
== NULL_TREE
4710 || TREE_CODE (label
) == CASE_LABEL_EXPR
));
4711 gs
->op
[index
+ 1] = label
;
4714 /* Return the default label for a switch statement. */
4717 gimple_switch_default_label (const gswitch
*gs
)
4719 tree label
= gimple_switch_label (gs
, 0);
4720 gcc_checking_assert (!CASE_LOW (label
) && !CASE_HIGH (label
));
4724 /* Set the default label for a switch statement. */
4727 gimple_switch_set_default_label (gswitch
*gs
, tree label
)
4729 gcc_checking_assert (!CASE_LOW (label
) && !CASE_HIGH (label
));
4730 gimple_switch_set_label (gs
, 0, label
);
4733 /* Return true if GS is a GIMPLE_DEBUG statement. */
4736 is_gimple_debug (const gimple
*gs
)
4738 return gimple_code (gs
) == GIMPLE_DEBUG
;
4742 /* Return the first nondebug statement in GIMPLE sequence S. */
4744 static inline gimple
*
4745 gimple_seq_first_nondebug_stmt (gimple_seq s
)
4747 gimple_seq_node n
= gimple_seq_first (s
);
4748 while (n
&& is_gimple_debug (n
))
4754 /* Return the last nondebug statement in GIMPLE sequence S. */
4756 static inline gimple
*
4757 gimple_seq_last_nondebug_stmt (gimple_seq s
)
4760 for (n
= gimple_seq_last (s
);
4761 n
&& is_gimple_debug (n
);
4769 /* Return true if S is a GIMPLE_DEBUG BIND statement. */
4772 gimple_debug_bind_p (const gimple
*s
)
4774 if (is_gimple_debug (s
))
4775 return s
->subcode
== GIMPLE_DEBUG_BIND
;
4780 /* Return the variable bound in a GIMPLE_DEBUG bind statement. */
4783 gimple_debug_bind_get_var (const gimple
*dbg
)
4785 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4786 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4787 return gimple_op (dbg
, 0);
4790 /* Return the value bound to the variable in a GIMPLE_DEBUG bind
4794 gimple_debug_bind_get_value (const gimple
*dbg
)
4796 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4797 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4798 return gimple_op (dbg
, 1);
4801 /* Return a pointer to the value bound to the variable in a
4802 GIMPLE_DEBUG bind statement. */
4804 static inline tree
*
4805 gimple_debug_bind_get_value_ptr (gimple
*dbg
)
4807 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4808 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4809 return gimple_op_ptr (dbg
, 1);
4812 /* Set the variable bound in a GIMPLE_DEBUG bind statement. */
4815 gimple_debug_bind_set_var (gimple
*dbg
, tree var
)
4817 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4818 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4819 gimple_set_op (dbg
, 0, var
);
4822 /* Set the value bound to the variable in a GIMPLE_DEBUG bind
4826 gimple_debug_bind_set_value (gimple
*dbg
, tree value
)
4828 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4829 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4830 gimple_set_op (dbg
, 1, value
);
4833 /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
4835 #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
4837 /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
4841 gimple_debug_bind_reset_value (gimple
*dbg
)
4843 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4844 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4845 gimple_set_op (dbg
, 1, GIMPLE_DEBUG_BIND_NOVALUE
);
4848 /* Return true if the GIMPLE_DEBUG bind statement is bound to a
4852 gimple_debug_bind_has_value_p (gimple
*dbg
)
4854 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4855 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4856 return gimple_op (dbg
, 1) != GIMPLE_DEBUG_BIND_NOVALUE
;
4859 #undef GIMPLE_DEBUG_BIND_NOVALUE
4861 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
4864 gimple_debug_source_bind_p (const gimple
*s
)
4866 if (is_gimple_debug (s
))
4867 return s
->subcode
== GIMPLE_DEBUG_SOURCE_BIND
;
4872 /* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
4875 gimple_debug_source_bind_get_var (const gimple
*dbg
)
4877 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4878 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4879 return gimple_op (dbg
, 0);
4882 /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
4886 gimple_debug_source_bind_get_value (const gimple
*dbg
)
4888 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4889 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4890 return gimple_op (dbg
, 1);
4893 /* Return a pointer to the value bound to the variable in a
4894 GIMPLE_DEBUG source bind statement. */
4896 static inline tree
*
4897 gimple_debug_source_bind_get_value_ptr (gimple
*dbg
)
4899 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4900 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4901 return gimple_op_ptr (dbg
, 1);
4904 /* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
4907 gimple_debug_source_bind_set_var (gimple
*dbg
, tree var
)
4909 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4910 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4911 gimple_set_op (dbg
, 0, var
);
4914 /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
4918 gimple_debug_source_bind_set_value (gimple
*dbg
, tree value
)
4920 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4921 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4922 gimple_set_op (dbg
, 1, value
);
4925 /* Return true if S is a GIMPLE_DEBUG BEGIN_STMT statement. */
4928 gimple_debug_begin_stmt_p (const gimple
*s
)
4930 if (is_gimple_debug (s
))
4931 return s
->subcode
== GIMPLE_DEBUG_BEGIN_STMT
;
4936 /* Return true if S is a GIMPLE_DEBUG INLINE_ENTRY statement. */
4939 gimple_debug_inline_entry_p (const gimple
*s
)
4941 if (is_gimple_debug (s
))
4942 return s
->subcode
== GIMPLE_DEBUG_INLINE_ENTRY
;
4947 /* Return true if S is a GIMPLE_DEBUG non-binding marker statement. */
4950 gimple_debug_nonbind_marker_p (const gimple
*s
)
4952 if (is_gimple_debug (s
))
4953 return s
->subcode
== GIMPLE_DEBUG_BEGIN_STMT
4954 || s
->subcode
== GIMPLE_DEBUG_INLINE_ENTRY
;
4959 /* Return the line number for EXPR, or return -1 if we have no line
4960 number information for it. */
4962 get_lineno (const gimple
*stmt
)
4969 loc
= gimple_location (stmt
);
4970 if (loc
== UNKNOWN_LOCATION
)
4973 return LOCATION_LINE (loc
);
4976 /* Return a pointer to the body for the OMP statement GS. */
4978 static inline gimple_seq
*
4979 gimple_omp_body_ptr (gimple
*gs
)
4981 return &static_cast <gimple_statement_omp
*> (gs
)->body
;
4984 /* Return the body for the OMP statement GS. */
4986 static inline gimple_seq
4987 gimple_omp_body (const gimple
*gs
)
4989 return *gimple_omp_body_ptr (const_cast <gimple
*> (gs
));
4992 /* Set BODY to be the body for the OMP statement GS. */
4995 gimple_omp_set_body (gimple
*gs
, gimple_seq body
)
4997 static_cast <gimple_statement_omp
*> (gs
)->body
= body
;
5001 /* Return the name associated with OMP_CRITICAL statement CRIT_STMT. */
5004 gimple_omp_critical_name (const gomp_critical
*crit_stmt
)
5006 return crit_stmt
->name
;
5010 /* Return a pointer to the name associated with OMP critical statement
5013 static inline tree
*
5014 gimple_omp_critical_name_ptr (gomp_critical
*crit_stmt
)
5016 return &crit_stmt
->name
;
5020 /* Set NAME to be the name associated with OMP critical statement
5024 gimple_omp_critical_set_name (gomp_critical
*crit_stmt
, tree name
)
5026 crit_stmt
->name
= name
;
5030 /* Return the clauses associated with OMP_CRITICAL statement CRIT_STMT. */
5033 gimple_omp_critical_clauses (const gomp_critical
*crit_stmt
)
5035 return crit_stmt
->clauses
;
5039 /* Return a pointer to the clauses associated with OMP critical statement
5042 static inline tree
*
5043 gimple_omp_critical_clauses_ptr (gomp_critical
*crit_stmt
)
5045 return &crit_stmt
->clauses
;
5049 /* Set CLAUSES to be the clauses associated with OMP critical statement
5053 gimple_omp_critical_set_clauses (gomp_critical
*crit_stmt
, tree clauses
)
5055 crit_stmt
->clauses
= clauses
;
5059 /* Return the clauses associated with OMP_ORDERED statement ORD_STMT. */
5062 gimple_omp_ordered_clauses (const gomp_ordered
*ord_stmt
)
5064 return ord_stmt
->clauses
;
5068 /* Return a pointer to the clauses associated with OMP ordered statement
5071 static inline tree
*
5072 gimple_omp_ordered_clauses_ptr (gomp_ordered
*ord_stmt
)
5074 return &ord_stmt
->clauses
;
5078 /* Set CLAUSES to be the clauses associated with OMP ordered statement
5082 gimple_omp_ordered_set_clauses (gomp_ordered
*ord_stmt
, tree clauses
)
5084 ord_stmt
->clauses
= clauses
;
5088 /* Return the clauses associated with OMP_SCAN statement SCAN_STMT. */
5091 gimple_omp_scan_clauses (const gomp_scan
*scan_stmt
)
5093 return scan_stmt
->clauses
;
5097 /* Return a pointer to the clauses associated with OMP scan statement
5100 static inline tree
*
5101 gimple_omp_scan_clauses_ptr (gomp_scan
*scan_stmt
)
5103 return &scan_stmt
->clauses
;
5107 /* Set CLAUSES to be the clauses associated with OMP scan statement
5111 gimple_omp_scan_set_clauses (gomp_scan
*scan_stmt
, tree clauses
)
5113 scan_stmt
->clauses
= clauses
;
5117 /* Return the clauses associated with OMP_TASKGROUP statement GS. */
5120 gimple_omp_taskgroup_clauses (const gimple
*gs
)
5122 GIMPLE_CHECK (gs
, GIMPLE_OMP_TASKGROUP
);
5124 static_cast <const gimple_statement_omp_single_layout
*> (gs
)->clauses
;
5128 /* Return a pointer to the clauses associated with OMP taskgroup statement
5131 static inline tree
*
5132 gimple_omp_taskgroup_clauses_ptr (gimple
*gs
)
5134 GIMPLE_CHECK (gs
, GIMPLE_OMP_TASKGROUP
);
5135 return &static_cast <gimple_statement_omp_single_layout
*> (gs
)->clauses
;
5139 /* Set CLAUSES to be the clauses associated with OMP taskgroup statement
5143 gimple_omp_taskgroup_set_clauses (gimple
*gs
, tree clauses
)
5145 GIMPLE_CHECK (gs
, GIMPLE_OMP_TASKGROUP
);
5146 static_cast <gimple_statement_omp_single_layout
*> (gs
)->clauses
5151 /* Return the kind of the OMP_FOR statemement G. */
5154 gimple_omp_for_kind (const gimple
*g
)
5156 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
5157 return (gimple_omp_subcode (g
) & GF_OMP_FOR_KIND_MASK
);
5161 /* Set the kind of the OMP_FOR statement G. */
5164 gimple_omp_for_set_kind (gomp_for
*g
, int kind
)
5166 g
->subcode
= (g
->subcode
& ~GF_OMP_FOR_KIND_MASK
)
5167 | (kind
& GF_OMP_FOR_KIND_MASK
);
5171 /* Return true if OMP_FOR statement G has the
5172 GF_OMP_FOR_COMBINED flag set. */
5175 gimple_omp_for_combined_p (const gimple
*g
)
5177 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
5178 return (gimple_omp_subcode (g
) & GF_OMP_FOR_COMBINED
) != 0;
5182 /* Set the GF_OMP_FOR_COMBINED field in the OMP_FOR statement G depending on
5183 the boolean value of COMBINED_P. */
5186 gimple_omp_for_set_combined_p (gomp_for
*g
, bool combined_p
)
5189 g
->subcode
|= GF_OMP_FOR_COMBINED
;
5191 g
->subcode
&= ~GF_OMP_FOR_COMBINED
;
5195 /* Return true if the OMP_FOR statement G has the
5196 GF_OMP_FOR_COMBINED_INTO flag set. */
5199 gimple_omp_for_combined_into_p (const gimple
*g
)
5201 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
5202 return (gimple_omp_subcode (g
) & GF_OMP_FOR_COMBINED_INTO
) != 0;
5206 /* Set the GF_OMP_FOR_COMBINED_INTO field in the OMP_FOR statement G depending
5207 on the boolean value of COMBINED_P. */
5210 gimple_omp_for_set_combined_into_p (gomp_for
*g
, bool combined_p
)
5213 g
->subcode
|= GF_OMP_FOR_COMBINED_INTO
;
5215 g
->subcode
&= ~GF_OMP_FOR_COMBINED_INTO
;
5219 /* Return the clauses associated with the OMP_FOR statement GS. */
5222 gimple_omp_for_clauses (const gimple
*gs
)
5224 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5225 return omp_for_stmt
->clauses
;
5229 /* Return a pointer to the clauses associated with the OMP_FOR statement
5232 static inline tree
*
5233 gimple_omp_for_clauses_ptr (gimple
*gs
)
5235 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5236 return &omp_for_stmt
->clauses
;
5240 /* Set CLAUSES to be the list of clauses associated with the OMP_FOR statement
5244 gimple_omp_for_set_clauses (gimple
*gs
, tree clauses
)
5246 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5247 omp_for_stmt
->clauses
= clauses
;
5251 /* Get the collapse count of the OMP_FOR statement GS. */
5253 static inline size_t
5254 gimple_omp_for_collapse (const gimple
*gs
)
5256 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5257 return omp_for_stmt
->collapse
;
5261 /* Return the condition code associated with the OMP_FOR statement GS. */
5263 static inline enum tree_code
5264 gimple_omp_for_cond (const gimple
*gs
, size_t i
)
5266 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5267 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5268 return omp_for_stmt
->iter
[i
].cond
;
5272 /* Set COND to be the condition code for the OMP_FOR statement GS. */
5275 gimple_omp_for_set_cond (gimple
*gs
, size_t i
, enum tree_code cond
)
5277 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5278 gcc_gimple_checking_assert (TREE_CODE_CLASS (cond
) == tcc_comparison
5279 && i
< omp_for_stmt
->collapse
);
5280 omp_for_stmt
->iter
[i
].cond
= cond
;
5284 /* Return the index variable for the OMP_FOR statement GS. */
5287 gimple_omp_for_index (const gimple
*gs
, size_t i
)
5289 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5290 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5291 return omp_for_stmt
->iter
[i
].index
;
5295 /* Return a pointer to the index variable for the OMP_FOR statement GS. */
5297 static inline tree
*
5298 gimple_omp_for_index_ptr (gimple
*gs
, size_t i
)
5300 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5301 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5302 return &omp_for_stmt
->iter
[i
].index
;
5306 /* Set INDEX to be the index variable for the OMP_FOR statement GS. */
5309 gimple_omp_for_set_index (gimple
*gs
, size_t i
, tree index
)
5311 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5312 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5313 omp_for_stmt
->iter
[i
].index
= index
;
5317 /* Return the initial value for the OMP_FOR statement GS. */
5320 gimple_omp_for_initial (const gimple
*gs
, size_t i
)
5322 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5323 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5324 return omp_for_stmt
->iter
[i
].initial
;
5328 /* Return a pointer to the initial value for the OMP_FOR statement GS. */
5330 static inline tree
*
5331 gimple_omp_for_initial_ptr (gimple
*gs
, size_t i
)
5333 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5334 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5335 return &omp_for_stmt
->iter
[i
].initial
;
5339 /* Set INITIAL to be the initial value for the OMP_FOR statement GS. */
5342 gimple_omp_for_set_initial (gimple
*gs
, size_t i
, tree initial
)
5344 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5345 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5346 omp_for_stmt
->iter
[i
].initial
= initial
;
5350 /* Return the final value for the OMP_FOR statement GS. */
5353 gimple_omp_for_final (const gimple
*gs
, size_t i
)
5355 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5356 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5357 return omp_for_stmt
->iter
[i
].final
;
5361 /* Return a pointer to the final value for the OMP_FOR statement GS. */
5363 static inline tree
*
5364 gimple_omp_for_final_ptr (gimple
*gs
, size_t i
)
5366 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5367 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5368 return &omp_for_stmt
->iter
[i
].final
;
5372 /* Set FINAL to be the final value for the OMP_FOR statement GS. */
5375 gimple_omp_for_set_final (gimple
*gs
, size_t i
, tree final
)
5377 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5378 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5379 omp_for_stmt
->iter
[i
].final
= final
;
5383 /* Return the increment value for the OMP_FOR statement GS. */
5386 gimple_omp_for_incr (const gimple
*gs
, size_t i
)
5388 const gomp_for
*omp_for_stmt
= as_a
<const gomp_for
*> (gs
);
5389 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5390 return omp_for_stmt
->iter
[i
].incr
;
5394 /* Return a pointer to the increment value for the OMP_FOR statement GS. */
5396 static inline tree
*
5397 gimple_omp_for_incr_ptr (gimple
*gs
, size_t i
)
5399 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5400 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5401 return &omp_for_stmt
->iter
[i
].incr
;
5405 /* Set INCR to be the increment value for the OMP_FOR statement GS. */
5408 gimple_omp_for_set_incr (gimple
*gs
, size_t i
, tree incr
)
5410 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5411 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5412 omp_for_stmt
->iter
[i
].incr
= incr
;
5416 /* Return a pointer to the sequence of statements to execute before the OMP_FOR
5417 statement GS starts. */
5419 static inline gimple_seq
*
5420 gimple_omp_for_pre_body_ptr (gimple
*gs
)
5422 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5423 return &omp_for_stmt
->pre_body
;
5427 /* Return the sequence of statements to execute before the OMP_FOR
5428 statement GS starts. */
5430 static inline gimple_seq
5431 gimple_omp_for_pre_body (const gimple
*gs
)
5433 return *gimple_omp_for_pre_body_ptr (const_cast <gimple
*> (gs
));
5437 /* Set PRE_BODY to be the sequence of statements to execute before the
5438 OMP_FOR statement GS starts. */
5441 gimple_omp_for_set_pre_body (gimple
*gs
, gimple_seq pre_body
)
5443 gomp_for
*omp_for_stmt
= as_a
<gomp_for
*> (gs
);
5444 omp_for_stmt
->pre_body
= pre_body
;
5447 /* Return the clauses associated with OMP_PARALLEL GS. */
5450 gimple_omp_parallel_clauses (const gimple
*gs
)
5452 const gomp_parallel
*omp_parallel_stmt
= as_a
<const gomp_parallel
*> (gs
);
5453 return omp_parallel_stmt
->clauses
;
5457 /* Return a pointer to the clauses associated with OMP_PARALLEL_STMT. */
5459 static inline tree
*
5460 gimple_omp_parallel_clauses_ptr (gomp_parallel
*omp_parallel_stmt
)
5462 return &omp_parallel_stmt
->clauses
;
5466 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL_STMT. */
5469 gimple_omp_parallel_set_clauses (gomp_parallel
*omp_parallel_stmt
,
5472 omp_parallel_stmt
->clauses
= clauses
;
5476 /* Return the child function used to hold the body of OMP_PARALLEL_STMT. */
5479 gimple_omp_parallel_child_fn (const gomp_parallel
*omp_parallel_stmt
)
5481 return omp_parallel_stmt
->child_fn
;
5484 /* Return a pointer to the child function used to hold the body of
5485 OMP_PARALLEL_STMT. */
5487 static inline tree
*
5488 gimple_omp_parallel_child_fn_ptr (gomp_parallel
*omp_parallel_stmt
)
5490 return &omp_parallel_stmt
->child_fn
;
5494 /* Set CHILD_FN to be the child function for OMP_PARALLEL_STMT. */
5497 gimple_omp_parallel_set_child_fn (gomp_parallel
*omp_parallel_stmt
,
5500 omp_parallel_stmt
->child_fn
= child_fn
;
5504 /* Return the artificial argument used to send variables and values
5505 from the parent to the children threads in OMP_PARALLEL_STMT. */
5508 gimple_omp_parallel_data_arg (const gomp_parallel
*omp_parallel_stmt
)
5510 return omp_parallel_stmt
->data_arg
;
5514 /* Return a pointer to the data argument for OMP_PARALLEL_STMT. */
5516 static inline tree
*
5517 gimple_omp_parallel_data_arg_ptr (gomp_parallel
*omp_parallel_stmt
)
5519 return &omp_parallel_stmt
->data_arg
;
5523 /* Set DATA_ARG to be the data argument for OMP_PARALLEL_STMT. */
5526 gimple_omp_parallel_set_data_arg (gomp_parallel
*omp_parallel_stmt
,
5529 omp_parallel_stmt
->data_arg
= data_arg
;
5532 /* Return the clauses associated with OMP_TASK GS. */
5535 gimple_omp_task_clauses (const gimple
*gs
)
5537 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5538 return omp_task_stmt
->clauses
;
5542 /* Return a pointer to the clauses associated with OMP_TASK GS. */
5544 static inline tree
*
5545 gimple_omp_task_clauses_ptr (gimple
*gs
)
5547 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5548 return &omp_task_stmt
->clauses
;
5552 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5556 gimple_omp_task_set_clauses (gimple
*gs
, tree clauses
)
5558 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5559 omp_task_stmt
->clauses
= clauses
;
5563 /* Return true if OMP task statement G has the
5564 GF_OMP_TASK_TASKLOOP flag set. */
5567 gimple_omp_task_taskloop_p (const gimple
*g
)
5569 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5570 return (gimple_omp_subcode (g
) & GF_OMP_TASK_TASKLOOP
) != 0;
5574 /* Set the GF_OMP_TASK_TASKLOOP field in G depending on the boolean
5575 value of TASKLOOP_P. */
5578 gimple_omp_task_set_taskloop_p (gimple
*g
, bool taskloop_p
)
5580 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5582 g
->subcode
|= GF_OMP_TASK_TASKLOOP
;
5584 g
->subcode
&= ~GF_OMP_TASK_TASKLOOP
;
5588 /* Return true if OMP task statement G has the
5589 GF_OMP_TASK_TASKWAIT flag set. */
5592 gimple_omp_task_taskwait_p (const gimple
*g
)
5594 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5595 return (gimple_omp_subcode (g
) & GF_OMP_TASK_TASKWAIT
) != 0;
5599 /* Set the GF_OMP_TASK_TASKWAIT field in G depending on the boolean
5600 value of TASKWAIT_P. */
5603 gimple_omp_task_set_taskwait_p (gimple
*g
, bool taskwait_p
)
5605 GIMPLE_CHECK (g
, GIMPLE_OMP_TASK
);
5607 g
->subcode
|= GF_OMP_TASK_TASKWAIT
;
5609 g
->subcode
&= ~GF_OMP_TASK_TASKWAIT
;
5613 /* Return the child function used to hold the body of OMP_TASK GS. */
5616 gimple_omp_task_child_fn (const gimple
*gs
)
5618 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5619 return omp_task_stmt
->child_fn
;
5622 /* Return a pointer to the child function used to hold the body of
5625 static inline tree
*
5626 gimple_omp_task_child_fn_ptr (gimple
*gs
)
5628 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5629 return &omp_task_stmt
->child_fn
;
5633 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
5636 gimple_omp_task_set_child_fn (gimple
*gs
, tree child_fn
)
5638 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5639 omp_task_stmt
->child_fn
= child_fn
;
5643 /* Return the artificial argument used to send variables and values
5644 from the parent to the children threads in OMP_TASK GS. */
5647 gimple_omp_task_data_arg (const gimple
*gs
)
5649 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5650 return omp_task_stmt
->data_arg
;
5654 /* Return a pointer to the data argument for OMP_TASK GS. */
5656 static inline tree
*
5657 gimple_omp_task_data_arg_ptr (gimple
*gs
)
5659 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5660 return &omp_task_stmt
->data_arg
;
5664 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
5667 gimple_omp_task_set_data_arg (gimple
*gs
, tree data_arg
)
5669 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5670 omp_task_stmt
->data_arg
= data_arg
;
5674 /* Return the clauses associated with OMP_TASK GS. */
5677 gimple_omp_taskreg_clauses (const gimple
*gs
)
5679 const gimple_statement_omp_taskreg
*omp_taskreg_stmt
5680 = as_a
<const gimple_statement_omp_taskreg
*> (gs
);
5681 return omp_taskreg_stmt
->clauses
;
5685 /* Return a pointer to the clauses associated with OMP_TASK GS. */
5687 static inline tree
*
5688 gimple_omp_taskreg_clauses_ptr (gimple
*gs
)
5690 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5691 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5692 return &omp_taskreg_stmt
->clauses
;
5696 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
5700 gimple_omp_taskreg_set_clauses (gimple
*gs
, tree clauses
)
5702 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5703 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5704 omp_taskreg_stmt
->clauses
= clauses
;
5708 /* Return the child function used to hold the body of OMP_TASK GS. */
5711 gimple_omp_taskreg_child_fn (const gimple
*gs
)
5713 const gimple_statement_omp_taskreg
*omp_taskreg_stmt
5714 = as_a
<const gimple_statement_omp_taskreg
*> (gs
);
5715 return omp_taskreg_stmt
->child_fn
;
5718 /* Return a pointer to the child function used to hold the body of
5721 static inline tree
*
5722 gimple_omp_taskreg_child_fn_ptr (gimple
*gs
)
5724 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5725 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5726 return &omp_taskreg_stmt
->child_fn
;
5730 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
5733 gimple_omp_taskreg_set_child_fn (gimple
*gs
, tree child_fn
)
5735 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5736 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5737 omp_taskreg_stmt
->child_fn
= child_fn
;
5741 /* Return the artificial argument used to send variables and values
5742 from the parent to the children threads in OMP_TASK GS. */
5745 gimple_omp_taskreg_data_arg (const gimple
*gs
)
5747 const gimple_statement_omp_taskreg
*omp_taskreg_stmt
5748 = as_a
<const gimple_statement_omp_taskreg
*> (gs
);
5749 return omp_taskreg_stmt
->data_arg
;
5753 /* Return a pointer to the data argument for OMP_TASK GS. */
5755 static inline tree
*
5756 gimple_omp_taskreg_data_arg_ptr (gimple
*gs
)
5758 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5759 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5760 return &omp_taskreg_stmt
->data_arg
;
5764 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
5767 gimple_omp_taskreg_set_data_arg (gimple
*gs
, tree data_arg
)
5769 gimple_statement_omp_taskreg
*omp_taskreg_stmt
5770 = as_a
<gimple_statement_omp_taskreg
*> (gs
);
5771 omp_taskreg_stmt
->data_arg
= data_arg
;
5775 /* Return the copy function used to hold the body of OMP_TASK GS. */
5778 gimple_omp_task_copy_fn (const gimple
*gs
)
5780 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5781 return omp_task_stmt
->copy_fn
;
5784 /* Return a pointer to the copy function used to hold the body of
5787 static inline tree
*
5788 gimple_omp_task_copy_fn_ptr (gimple
*gs
)
5790 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5791 return &omp_task_stmt
->copy_fn
;
5795 /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
5798 gimple_omp_task_set_copy_fn (gimple
*gs
, tree copy_fn
)
5800 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5801 omp_task_stmt
->copy_fn
= copy_fn
;
5805 /* Return size of the data block in bytes in OMP_TASK GS. */
5808 gimple_omp_task_arg_size (const gimple
*gs
)
5810 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5811 return omp_task_stmt
->arg_size
;
5815 /* Return a pointer to the data block size for OMP_TASK GS. */
5817 static inline tree
*
5818 gimple_omp_task_arg_size_ptr (gimple
*gs
)
5820 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5821 return &omp_task_stmt
->arg_size
;
5825 /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
5828 gimple_omp_task_set_arg_size (gimple
*gs
, tree arg_size
)
5830 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5831 omp_task_stmt
->arg_size
= arg_size
;
5835 /* Return align of the data block in bytes in OMP_TASK GS. */
5838 gimple_omp_task_arg_align (const gimple
*gs
)
5840 const gomp_task
*omp_task_stmt
= as_a
<const gomp_task
*> (gs
);
5841 return omp_task_stmt
->arg_align
;
5845 /* Return a pointer to the data block align for OMP_TASK GS. */
5847 static inline tree
*
5848 gimple_omp_task_arg_align_ptr (gimple
*gs
)
5850 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5851 return &omp_task_stmt
->arg_align
;
5855 /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
5858 gimple_omp_task_set_arg_align (gimple
*gs
, tree arg_align
)
5860 gomp_task
*omp_task_stmt
= as_a
<gomp_task
*> (gs
);
5861 omp_task_stmt
->arg_align
= arg_align
;
5865 /* Return the clauses associated with OMP_SINGLE GS. */
5868 gimple_omp_single_clauses (const gimple
*gs
)
5870 const gomp_single
*omp_single_stmt
= as_a
<const gomp_single
*> (gs
);
5871 return omp_single_stmt
->clauses
;
5875 /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
5877 static inline tree
*
5878 gimple_omp_single_clauses_ptr (gimple
*gs
)
5880 gomp_single
*omp_single_stmt
= as_a
<gomp_single
*> (gs
);
5881 return &omp_single_stmt
->clauses
;
5885 /* Set CLAUSES to be the clauses associated with OMP_SINGLE_STMT. */
5888 gimple_omp_single_set_clauses (gomp_single
*omp_single_stmt
, tree clauses
)
5890 omp_single_stmt
->clauses
= clauses
;
5894 /* Return the clauses associated with OMP_TARGET GS. */
5897 gimple_omp_target_clauses (const gimple
*gs
)
5899 const gomp_target
*omp_target_stmt
= as_a
<const gomp_target
*> (gs
);
5900 return omp_target_stmt
->clauses
;
5904 /* Return a pointer to the clauses associated with OMP_TARGET GS. */
5906 static inline tree
*
5907 gimple_omp_target_clauses_ptr (gimple
*gs
)
5909 gomp_target
*omp_target_stmt
= as_a
<gomp_target
*> (gs
);
5910 return &omp_target_stmt
->clauses
;
5914 /* Set CLAUSES to be the clauses associated with OMP_TARGET_STMT. */
5917 gimple_omp_target_set_clauses (gomp_target
*omp_target_stmt
,
5920 omp_target_stmt
->clauses
= clauses
;
5924 /* Return the kind of the OMP_TARGET G. */
5927 gimple_omp_target_kind (const gimple
*g
)
5929 GIMPLE_CHECK (g
, GIMPLE_OMP_TARGET
);
5930 return (gimple_omp_subcode (g
) & GF_OMP_TARGET_KIND_MASK
);
5934 /* Set the kind of the OMP_TARGET G. */
5937 gimple_omp_target_set_kind (gomp_target
*g
, int kind
)
5939 g
->subcode
= (g
->subcode
& ~GF_OMP_TARGET_KIND_MASK
)
5940 | (kind
& GF_OMP_TARGET_KIND_MASK
);
5944 /* Return the child function used to hold the body of OMP_TARGET_STMT. */
5947 gimple_omp_target_child_fn (const gomp_target
*omp_target_stmt
)
5949 return omp_target_stmt
->child_fn
;
5952 /* Return a pointer to the child function used to hold the body of
5955 static inline tree
*
5956 gimple_omp_target_child_fn_ptr (gomp_target
*omp_target_stmt
)
5958 return &omp_target_stmt
->child_fn
;
5962 /* Set CHILD_FN to be the child function for OMP_TARGET_STMT. */
5965 gimple_omp_target_set_child_fn (gomp_target
*omp_target_stmt
,
5968 omp_target_stmt
->child_fn
= child_fn
;
5972 /* Return the artificial argument used to send variables and values
5973 from the parent to the children threads in OMP_TARGET_STMT. */
5976 gimple_omp_target_data_arg (const gomp_target
*omp_target_stmt
)
5978 return omp_target_stmt
->data_arg
;
5982 /* Return a pointer to the data argument for OMP_TARGET GS. */
5984 static inline tree
*
5985 gimple_omp_target_data_arg_ptr (gomp_target
*omp_target_stmt
)
5987 return &omp_target_stmt
->data_arg
;
5991 /* Set DATA_ARG to be the data argument for OMP_TARGET_STMT. */
5994 gimple_omp_target_set_data_arg (gomp_target
*omp_target_stmt
,
5997 omp_target_stmt
->data_arg
= data_arg
;
6001 /* Return the clauses associated with OMP_TEAMS GS. */
6004 gimple_omp_teams_clauses (const gimple
*gs
)
6006 const gomp_teams
*omp_teams_stmt
= as_a
<const gomp_teams
*> (gs
);
6007 return omp_teams_stmt
->clauses
;
6011 /* Return a pointer to the clauses associated with OMP_TEAMS GS. */
6013 static inline tree
*
6014 gimple_omp_teams_clauses_ptr (gimple
*gs
)
6016 gomp_teams
*omp_teams_stmt
= as_a
<gomp_teams
*> (gs
);
6017 return &omp_teams_stmt
->clauses
;
6021 /* Set CLAUSES to be the clauses associated with OMP_TEAMS_STMT. */
6024 gimple_omp_teams_set_clauses (gomp_teams
*omp_teams_stmt
, tree clauses
)
6026 omp_teams_stmt
->clauses
= clauses
;
6029 /* Return the child function used to hold the body of OMP_TEAMS_STMT. */
6032 gimple_omp_teams_child_fn (const gomp_teams
*omp_teams_stmt
)
6034 return omp_teams_stmt
->child_fn
;
6037 /* Return a pointer to the child function used to hold the body of
6040 static inline tree
*
6041 gimple_omp_teams_child_fn_ptr (gomp_teams
*omp_teams_stmt
)
6043 return &omp_teams_stmt
->child_fn
;
6047 /* Set CHILD_FN to be the child function for OMP_TEAMS_STMT. */
6050 gimple_omp_teams_set_child_fn (gomp_teams
*omp_teams_stmt
, tree child_fn
)
6052 omp_teams_stmt
->child_fn
= child_fn
;
6056 /* Return the artificial argument used to send variables and values
6057 from the parent to the children threads in OMP_TEAMS_STMT. */
6060 gimple_omp_teams_data_arg (const gomp_teams
*omp_teams_stmt
)
6062 return omp_teams_stmt
->data_arg
;
6066 /* Return a pointer to the data argument for OMP_TEAMS_STMT. */
6068 static inline tree
*
6069 gimple_omp_teams_data_arg_ptr (gomp_teams
*omp_teams_stmt
)
6071 return &omp_teams_stmt
->data_arg
;
6075 /* Set DATA_ARG to be the data argument for OMP_TEAMS_STMT. */
6078 gimple_omp_teams_set_data_arg (gomp_teams
*omp_teams_stmt
, tree data_arg
)
6080 omp_teams_stmt
->data_arg
= data_arg
;
6083 /* Return the host flag of an OMP_TEAMS_STMT. */
6086 gimple_omp_teams_host (const gomp_teams
*omp_teams_stmt
)
6088 return (gimple_omp_subcode (omp_teams_stmt
) & GF_OMP_TEAMS_HOST
) != 0;
6091 /* Set host flag of an OMP_TEAMS_STMT to VALUE. */
6094 gimple_omp_teams_set_host (gomp_teams
*omp_teams_stmt
, bool value
)
6097 omp_teams_stmt
->subcode
|= GF_OMP_TEAMS_HOST
;
6099 omp_teams_stmt
->subcode
&= ~GF_OMP_TEAMS_HOST
;
6102 /* Return the clauses associated with OMP_SECTIONS GS. */
6105 gimple_omp_sections_clauses (const gimple
*gs
)
6107 const gomp_sections
*omp_sections_stmt
= as_a
<const gomp_sections
*> (gs
);
6108 return omp_sections_stmt
->clauses
;
6112 /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
6114 static inline tree
*
6115 gimple_omp_sections_clauses_ptr (gimple
*gs
)
6117 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6118 return &omp_sections_stmt
->clauses
;
6122 /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
6126 gimple_omp_sections_set_clauses (gimple
*gs
, tree clauses
)
6128 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6129 omp_sections_stmt
->clauses
= clauses
;
6133 /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
6137 gimple_omp_sections_control (const gimple
*gs
)
6139 const gomp_sections
*omp_sections_stmt
= as_a
<const gomp_sections
*> (gs
);
6140 return omp_sections_stmt
->control
;
6144 /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
6147 static inline tree
*
6148 gimple_omp_sections_control_ptr (gimple
*gs
)
6150 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6151 return &omp_sections_stmt
->control
;
6155 /* Set CONTROL to be the set of clauses associated with the
6156 GIMPLE_OMP_SECTIONS in GS. */
6159 gimple_omp_sections_set_control (gimple
*gs
, tree control
)
6161 gomp_sections
*omp_sections_stmt
= as_a
<gomp_sections
*> (gs
);
6162 omp_sections_stmt
->control
= control
;
6166 /* Set the value being stored in an atomic store. */
6169 gimple_omp_atomic_store_set_val (gomp_atomic_store
*store_stmt
, tree val
)
6171 store_stmt
->val
= val
;
6175 /* Return the value being stored in an atomic store. */
6178 gimple_omp_atomic_store_val (const gomp_atomic_store
*store_stmt
)
6180 return store_stmt
->val
;
6184 /* Return a pointer to the value being stored in an atomic store. */
6186 static inline tree
*
6187 gimple_omp_atomic_store_val_ptr (gomp_atomic_store
*store_stmt
)
6189 return &store_stmt
->val
;
6193 /* Set the LHS of an atomic load. */
6196 gimple_omp_atomic_load_set_lhs (gomp_atomic_load
*load_stmt
, tree lhs
)
6198 load_stmt
->lhs
= lhs
;
6202 /* Get the LHS of an atomic load. */
6205 gimple_omp_atomic_load_lhs (const gomp_atomic_load
*load_stmt
)
6207 return load_stmt
->lhs
;
6211 /* Return a pointer to the LHS of an atomic load. */
6213 static inline tree
*
6214 gimple_omp_atomic_load_lhs_ptr (gomp_atomic_load
*load_stmt
)
6216 return &load_stmt
->lhs
;
6220 /* Set the RHS of an atomic load. */
6223 gimple_omp_atomic_load_set_rhs (gomp_atomic_load
*load_stmt
, tree rhs
)
6225 load_stmt
->rhs
= rhs
;
6229 /* Get the RHS of an atomic load. */
6232 gimple_omp_atomic_load_rhs (const gomp_atomic_load
*load_stmt
)
6234 return load_stmt
->rhs
;
6238 /* Return a pointer to the RHS of an atomic load. */
6240 static inline tree
*
6241 gimple_omp_atomic_load_rhs_ptr (gomp_atomic_load
*load_stmt
)
6243 return &load_stmt
->rhs
;
6247 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6250 gimple_omp_continue_control_def (const gomp_continue
*cont_stmt
)
6252 return cont_stmt
->control_def
;
6255 /* The same as above, but return the address. */
6257 static inline tree
*
6258 gimple_omp_continue_control_def_ptr (gomp_continue
*cont_stmt
)
6260 return &cont_stmt
->control_def
;
6263 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
6266 gimple_omp_continue_set_control_def (gomp_continue
*cont_stmt
, tree def
)
6268 cont_stmt
->control_def
= def
;
6272 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6275 gimple_omp_continue_control_use (const gomp_continue
*cont_stmt
)
6277 return cont_stmt
->control_use
;
6281 /* The same as above, but return the address. */
6283 static inline tree
*
6284 gimple_omp_continue_control_use_ptr (gomp_continue
*cont_stmt
)
6286 return &cont_stmt
->control_use
;
6290 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
6293 gimple_omp_continue_set_control_use (gomp_continue
*cont_stmt
, tree use
)
6295 cont_stmt
->control_use
= use
;
6298 /* Return a pointer to the body for the GIMPLE_TRANSACTION statement
6299 TRANSACTION_STMT. */
6301 static inline gimple_seq
*
6302 gimple_transaction_body_ptr (gtransaction
*transaction_stmt
)
6304 return &transaction_stmt
->body
;
6307 /* Return the body for the GIMPLE_TRANSACTION statement TRANSACTION_STMT. */
6309 static inline gimple_seq
6310 gimple_transaction_body (const gtransaction
*transaction_stmt
)
6312 return transaction_stmt
->body
;
6315 /* Return the label associated with a GIMPLE_TRANSACTION. */
6318 gimple_transaction_label_norm (const gtransaction
*transaction_stmt
)
6320 return transaction_stmt
->label_norm
;
6323 static inline tree
*
6324 gimple_transaction_label_norm_ptr (gtransaction
*transaction_stmt
)
6326 return &transaction_stmt
->label_norm
;
6330 gimple_transaction_label_uninst (const gtransaction
*transaction_stmt
)
6332 return transaction_stmt
->label_uninst
;
6335 static inline tree
*
6336 gimple_transaction_label_uninst_ptr (gtransaction
*transaction_stmt
)
6338 return &transaction_stmt
->label_uninst
;
6342 gimple_transaction_label_over (const gtransaction
*transaction_stmt
)
6344 return transaction_stmt
->label_over
;
6347 static inline tree
*
6348 gimple_transaction_label_over_ptr (gtransaction
*transaction_stmt
)
6350 return &transaction_stmt
->label_over
;
6353 /* Return the subcode associated with a GIMPLE_TRANSACTION. */
6355 static inline unsigned int
6356 gimple_transaction_subcode (const gtransaction
*transaction_stmt
)
6358 return transaction_stmt
->subcode
;
6361 /* Set BODY to be the body for the GIMPLE_TRANSACTION statement
6362 TRANSACTION_STMT. */
6365 gimple_transaction_set_body (gtransaction
*transaction_stmt
,
6368 transaction_stmt
->body
= body
;
6371 /* Set the label associated with a GIMPLE_TRANSACTION. */
6374 gimple_transaction_set_label_norm (gtransaction
*transaction_stmt
, tree label
)
6376 transaction_stmt
->label_norm
= label
;
6380 gimple_transaction_set_label_uninst (gtransaction
*transaction_stmt
, tree label
)
6382 transaction_stmt
->label_uninst
= label
;
6386 gimple_transaction_set_label_over (gtransaction
*transaction_stmt
, tree label
)
6388 transaction_stmt
->label_over
= label
;
6391 /* Set the subcode associated with a GIMPLE_TRANSACTION. */
6394 gimple_transaction_set_subcode (gtransaction
*transaction_stmt
,
6395 unsigned int subcode
)
6397 transaction_stmt
->subcode
= subcode
;
6400 /* Return a pointer to the return value for GIMPLE_RETURN GS. */
6402 static inline tree
*
6403 gimple_return_retval_ptr (greturn
*gs
)
6408 /* Return the return value for GIMPLE_RETURN GS. */
6411 gimple_return_retval (const greturn
*gs
)
6417 /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
6420 gimple_return_set_retval (greturn
*gs
, tree retval
)
6426 /* Returns true when the gimple statement STMT is any of the OMP types. */
6428 #define CASE_GIMPLE_OMP \
6429 case GIMPLE_OMP_PARALLEL: \
6430 case GIMPLE_OMP_TASK: \
6431 case GIMPLE_OMP_FOR: \
6432 case GIMPLE_OMP_SECTIONS: \
6433 case GIMPLE_OMP_SECTIONS_SWITCH: \
6434 case GIMPLE_OMP_SINGLE: \
6435 case GIMPLE_OMP_TARGET: \
6436 case GIMPLE_OMP_TEAMS: \
6437 case GIMPLE_OMP_SECTION: \
6438 case GIMPLE_OMP_MASTER: \
6439 case GIMPLE_OMP_TASKGROUP: \
6440 case GIMPLE_OMP_ORDERED: \
6441 case GIMPLE_OMP_CRITICAL: \
6442 case GIMPLE_OMP_SCAN: \
6443 case GIMPLE_OMP_RETURN: \
6444 case GIMPLE_OMP_ATOMIC_LOAD: \
6445 case GIMPLE_OMP_ATOMIC_STORE: \
6446 case GIMPLE_OMP_CONTINUE
6449 is_gimple_omp (const gimple
*stmt
)
6451 switch (gimple_code (stmt
))
6460 /* Return true if the OMP gimple statement STMT is any of the OpenACC types
6464 is_gimple_omp_oacc (const gimple
*stmt
)
6466 gcc_assert (is_gimple_omp (stmt
));
6467 switch (gimple_code (stmt
))
6469 case GIMPLE_OMP_FOR
:
6470 switch (gimple_omp_for_kind (stmt
))
6472 case GF_OMP_FOR_KIND_OACC_LOOP
:
6477 case GIMPLE_OMP_TARGET
:
6478 switch (gimple_omp_target_kind (stmt
))
6480 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
6481 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
6482 case GF_OMP_TARGET_KIND_OACC_SERIAL
:
6483 case GF_OMP_TARGET_KIND_OACC_DATA
:
6484 case GF_OMP_TARGET_KIND_OACC_UPDATE
:
6485 case GF_OMP_TARGET_KIND_OACC_ENTER_EXIT_DATA
:
6486 case GF_OMP_TARGET_KIND_OACC_DECLARE
:
6487 case GF_OMP_TARGET_KIND_OACC_HOST_DATA
:
6498 /* Return true if the OMP gimple statement STMT is offloaded. */
6501 is_gimple_omp_offloaded (const gimple
*stmt
)
6503 gcc_assert (is_gimple_omp (stmt
));
6504 switch (gimple_code (stmt
))
6506 case GIMPLE_OMP_TARGET
:
6507 switch (gimple_omp_target_kind (stmt
))
6509 case GF_OMP_TARGET_KIND_REGION
:
6510 case GF_OMP_TARGET_KIND_OACC_PARALLEL
:
6511 case GF_OMP_TARGET_KIND_OACC_KERNELS
:
6512 case GF_OMP_TARGET_KIND_OACC_SERIAL
:
6523 /* Returns TRUE if statement G is a GIMPLE_NOP. */
6526 gimple_nop_p (const gimple
*g
)
6528 return gimple_code (g
) == GIMPLE_NOP
;
6532 /* Return true if GS is a GIMPLE_RESX. */
6535 is_gimple_resx (const gimple
*gs
)
6537 return gimple_code (gs
) == GIMPLE_RESX
;
6540 /* Return the type of the main expression computed by STMT. Return
6541 void_type_node if the statement computes nothing. */
6544 gimple_expr_type (const gimple
*stmt
)
6546 enum gimple_code code
= gimple_code (stmt
);
6547 /* In general we want to pass out a type that can be substituted
6548 for both the RHS and the LHS types if there is a possibly
6549 useless conversion involved. That means returning the
6550 original RHS type as far as we can reconstruct it. */
6551 if (code
== GIMPLE_CALL
)
6553 const gcall
*call_stmt
= as_a
<const gcall
*> (stmt
);
6554 if (gimple_call_internal_p (call_stmt
))
6555 switch (gimple_call_internal_fn (call_stmt
))
6557 case IFN_MASK_STORE
:
6558 case IFN_SCATTER_STORE
:
6559 return TREE_TYPE (gimple_call_arg (call_stmt
, 3));
6560 case IFN_MASK_SCATTER_STORE
:
6561 return TREE_TYPE (gimple_call_arg (call_stmt
, 4));
6565 return gimple_call_return_type (call_stmt
);
6567 else if (code
== GIMPLE_ASSIGN
)
6569 if (gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
)
6570 return TREE_TYPE (gimple_assign_rhs1 (stmt
));
6572 /* As fallback use the type of the LHS. */
6573 return TREE_TYPE (gimple_get_lhs (stmt
));
6575 else if (code
== GIMPLE_COND
)
6576 return boolean_type_node
;
6578 return void_type_node
;
6581 /* Enum and arrays used for allocation stats. Keep in sync with
6582 gimple.c:gimple_alloc_kind_names. */
6583 enum gimple_alloc_kind
6585 gimple_alloc_kind_assign
, /* Assignments. */
6586 gimple_alloc_kind_phi
, /* PHI nodes. */
6587 gimple_alloc_kind_cond
, /* Conditionals. */
6588 gimple_alloc_kind_rest
, /* Everything else. */
6589 gimple_alloc_kind_all
6592 extern uint64_t gimple_alloc_counts
[];
6593 extern uint64_t gimple_alloc_sizes
[];
6595 /* Return the allocation kind for a given stmt CODE. */
6596 static inline enum gimple_alloc_kind
6597 gimple_alloc_kind (enum gimple_code code
)
6602 return gimple_alloc_kind_assign
;
6604 return gimple_alloc_kind_phi
;
6606 return gimple_alloc_kind_cond
;
6608 return gimple_alloc_kind_rest
;
6612 /* Return true if a location should not be emitted for this statement
6613 by annotate_all_with_location. */
6616 gimple_do_not_emit_location_p (gimple
*g
)
6618 return gimple_plf (g
, GF_PLF_1
);
6621 /* Mark statement G so a location will not be emitted by
6622 annotate_one_with_location. */
6625 gimple_set_do_not_emit_location (gimple
*g
)
6627 /* The PLF flags are initialized to 0 when a new tuple is created,
6628 so no need to initialize it anywhere. */
6629 gimple_set_plf (g
, GF_PLF_1
, true);
6632 #endif /* GCC_GIMPLE_H */