1 /* Gimple IR definitions.
3 Copyright (C) 2007-2013 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 typedef gimple gimple_seq_node
;
27 /* For each block, the PHI nodes that need to be rewritten are stored into
29 typedef vec
<gimple
> gimple_vec
;
32 #define DEFGSCODE(SYM, STRING, STRUCT) SYM,
35 LAST_AND_UNUSED_GIMPLE_CODE
38 extern const char *const gimple_code_name
[];
39 extern const unsigned char gimple_rhs_class_table
[];
41 /* Error out if a gimple tuple is addressed incorrectly. */
42 #if defined ENABLE_GIMPLE_CHECKING
43 #define gcc_gimple_checking_assert(EXPR) gcc_assert (EXPR)
44 extern void gimple_check_failed (const_gimple
, const char *, int, \
45 const char *, enum gimple_code
, \
46 enum tree_code
) ATTRIBUTE_NORETURN
;
48 #define GIMPLE_CHECK(GS, CODE) \
50 const_gimple __gs = (GS); \
51 if (gimple_code (__gs) != (CODE)) \
52 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \
53 (CODE), ERROR_MARK); \
55 #else /* not ENABLE_GIMPLE_CHECKING */
56 #define gcc_gimple_checking_assert(EXPR) ((void)(0 && (EXPR)))
57 #define GIMPLE_CHECK(GS, CODE) (void)0
60 /* Class of GIMPLE expressions suitable for the RHS of assignments. See
61 get_gimple_rhs_class. */
64 GIMPLE_INVALID_RHS
, /* The expression cannot be used on the RHS. */
65 GIMPLE_TERNARY_RHS
, /* The expression is a ternary operation. */
66 GIMPLE_BINARY_RHS
, /* The expression is a binary operation. */
67 GIMPLE_UNARY_RHS
, /* The expression is a unary operation. */
68 GIMPLE_SINGLE_RHS
/* The expression is a single object (an SSA
69 name, a _DECL, a _REF, etc. */
72 /* Specific flags for individual GIMPLE statements. These flags are
73 always stored in gimple_statement_base.subcode and they may only be
74 defined for statement codes that do not use subcodes.
76 Values for the masks can overlap as long as the overlapping values
77 are never used in the same statement class.
79 The maximum mask value that can be defined is 1 << 15 (i.e., each
80 statement code can hold up to 16 bitflags).
82 Keep this list sorted. */
84 GF_ASM_INPUT
= 1 << 0,
85 GF_ASM_VOLATILE
= 1 << 1,
86 GF_CALL_FROM_THUNK
= 1 << 0,
87 GF_CALL_RETURN_SLOT_OPT
= 1 << 1,
88 GF_CALL_TAILCALL
= 1 << 2,
89 GF_CALL_VA_ARG_PACK
= 1 << 3,
90 GF_CALL_NOTHROW
= 1 << 4,
91 GF_CALL_ALLOCA_FOR_VAR
= 1 << 5,
92 GF_CALL_INTERNAL
= 1 << 6,
93 GF_CALL_WITH_BOUNDS
= 1 << 7,
94 GF_OMP_PARALLEL_COMBINED
= 1 << 0,
95 GF_OMP_FOR_KIND_MASK
= 3 << 0,
96 GF_OMP_FOR_KIND_FOR
= 0 << 0,
97 GF_OMP_FOR_KIND_DISTRIBUTE
= 1 << 0,
98 GF_OMP_FOR_KIND_SIMD
= 2 << 0,
99 GF_OMP_FOR_KIND_CILKSIMD
= 3 << 0,
100 GF_OMP_FOR_COMBINED
= 1 << 2,
101 GF_OMP_FOR_COMBINED_INTO
= 1 << 3,
102 GF_OMP_TARGET_KIND_MASK
= 3 << 0,
103 GF_OMP_TARGET_KIND_REGION
= 0 << 0,
104 GF_OMP_TARGET_KIND_DATA
= 1 << 0,
105 GF_OMP_TARGET_KIND_UPDATE
= 2 << 0,
107 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
108 a thread synchronization via some sort of barrier. The exact barrier
109 that would otherwise be emitted is dependent on the OMP statement with
110 which this return is associated. */
111 GF_OMP_RETURN_NOWAIT
= 1 << 0,
113 GF_OMP_SECTION_LAST
= 1 << 0,
114 GF_OMP_ATOMIC_NEED_VALUE
= 1 << 0,
115 GF_OMP_ATOMIC_SEQ_CST
= 1 << 1,
116 GF_PREDICT_TAKEN
= 1 << 15
119 /* Currently, there are only two types of gimple debug stmt. Others are
120 envisioned, for example, to enable the generation of is_stmt notes
121 in line number information, to mark sequence points, etc. This
122 subcode is to be used to tell them apart. */
123 enum gimple_debug_subcode
{
124 GIMPLE_DEBUG_BIND
= 0,
125 GIMPLE_DEBUG_SOURCE_BIND
= 1
128 /* Masks for selecting a pass local flag (PLF) to work on. These
129 masks are used by gimple_set_plf and gimple_plf. */
135 /* Data structure definitions for GIMPLE tuples. NOTE: word markers
136 are for 64 bit hosts. */
138 struct GTY((desc ("gimple_statement_structure (&%h)"), tag ("GSS_BASE"),
139 chain_next ("%h.next"), variable_size
))
140 gimple_statement_base
143 Main identifying code for a tuple. */
144 ENUM_BITFIELD(gimple_code
) code
: 8;
146 /* Nonzero if a warning should not be emitted on this tuple. */
147 unsigned int no_warning
: 1;
149 /* Nonzero if this tuple has been visited. Passes are responsible
150 for clearing this bit before using it. */
151 unsigned int visited
: 1;
153 /* Nonzero if this tuple represents a non-temporal move. */
154 unsigned int nontemporal_move
: 1;
156 /* Pass local flags. These flags are free for any pass to use as
157 they see fit. Passes should not assume that these flags contain
158 any useful value when the pass starts. Any initial state that
159 the pass requires should be set on entry to the pass. See
160 gimple_set_plf and gimple_plf for usage. */
161 unsigned int plf
: 2;
163 /* Nonzero if this statement has been modified and needs to have its
164 operands rescanned. */
165 unsigned modified
: 1;
167 /* Nonzero if this statement contains volatile operands. */
168 unsigned has_volatile_ops
: 1;
170 /* The SUBCODE field can be used for tuple-specific flags for tuples
171 that do not require subcodes. Note that SUBCODE should be at
172 least as wide as tree codes, as several tuples store tree codes
174 unsigned int subcode
: 16;
176 /* UID of this statement. This is used by passes that want to
177 assign IDs to statements. It must be assigned and used by each
178 pass. By default it should be assumed to contain garbage. */
182 Locus information for debug info. */
185 /* Number of operands in this tuple. */
189 Basic block holding this statement. */
193 Linked lists of gimple statements. The next pointers form
194 a NULL terminated list, the prev pointers are a cyclic list.
195 A gimple statement is hence also a double-ended list of
196 statements, with the pointer itself being the first element,
197 and the prev pointer being the last. */
199 gimple
GTY((skip
)) prev
;
203 /* Base structure for tuples with operands. */
205 /* This gimple subclass has no tag value. */
207 gimple_statement_with_ops_base
: public gimple_statement_base
209 /* [ WORD 1-6 ] : base class */
212 SSA operand vectors. NOTE: It should be possible to
213 amalgamate these vectors with the operand vector OP. However,
214 the SSA operand vectors are organized differently and contain
215 more information (like immediate use chaining). */
216 struct use_optype_d
GTY((skip (""))) *use_ops
;
220 /* Statements that take register operands. */
222 struct GTY((tag("GSS_WITH_OPS")))
223 gimple_statement_with_ops
: public gimple_statement_with_ops_base
225 /* [ WORD 1-7 ] : base class */
228 Operand vector. NOTE! This must always be the last field
229 of this structure. In particular, this means that this
230 structure cannot be embedded inside another one. */
231 tree
GTY((length ("%h.num_ops"))) op
[1];
235 /* Base for statements that take both memory and register operands. */
237 struct GTY((tag("GSS_WITH_MEM_OPS_BASE")))
238 gimple_statement_with_memory_ops_base
: public gimple_statement_with_ops_base
240 /* [ WORD 1-7 ] : base class */
243 Virtual operands for this statement. The GC will pick them
244 up via the ssa_names array. */
245 tree
GTY((skip (""))) vdef
;
246 tree
GTY((skip (""))) vuse
;
250 /* Statements that take both memory and register operands. */
252 struct GTY((tag("GSS_WITH_MEM_OPS")))
253 gimple_statement_with_memory_ops
:
254 public gimple_statement_with_memory_ops_base
256 /* [ WORD 1-9 ] : base class */
259 Operand vector. NOTE! This must always be the last field
260 of this structure. In particular, this means that this
261 structure cannot be embedded inside another one. */
262 tree
GTY((length ("%h.num_ops"))) op
[1];
266 /* Call statements that take both memory and register operands. */
268 struct GTY((tag("GSS_CALL")))
269 gimple_statement_call
: public gimple_statement_with_memory_ops_base
271 /* [ WORD 1-9 ] : base class */
274 struct pt_solution call_used
;
275 struct pt_solution call_clobbered
;
278 union GTY ((desc ("%1.subcode & GF_CALL_INTERNAL"))) {
279 tree
GTY ((tag ("0"))) fntype
;
280 enum internal_fn
GTY ((tag ("GF_CALL_INTERNAL"))) internal_fn
;
284 Operand vector. NOTE! This must always be the last field
285 of this structure. In particular, this means that this
286 structure cannot be embedded inside another one. */
287 tree
GTY((length ("%h.num_ops"))) op
[1];
291 /* OpenMP statements (#pragma omp). */
293 struct GTY((tag("GSS_OMP")))
294 gimple_statement_omp
: public gimple_statement_base
296 /* [ WORD 1-6 ] : base class */
305 struct GTY((tag("GSS_BIND")))
306 gimple_statement_bind
: public gimple_statement_base
308 /* [ WORD 1-6 ] : base class */
311 Variables declared in this scope. */
315 This is different than the BLOCK field in gimple_statement_base,
316 which is analogous to TREE_BLOCK (i.e., the lexical block holding
317 this statement). This field is the equivalent of BIND_EXPR_BLOCK
318 in tree land (i.e., the lexical scope defined by this bind). See
329 struct GTY((tag("GSS_CATCH")))
330 gimple_statement_catch
: public gimple_statement_base
332 /* [ WORD 1-6 ] : base class */
342 /* GIMPLE_EH_FILTER */
344 struct GTY((tag("GSS_EH_FILTER")))
345 gimple_statement_eh_filter
: public gimple_statement_base
347 /* [ WORD 1-6 ] : base class */
360 struct GTY((tag("GSS_EH_ELSE")))
361 gimple_statement_eh_else
: public gimple_statement_base
363 /* [ WORD 1-6 ] : base class */
366 gimple_seq n_body
, e_body
;
369 /* GIMPLE_EH_MUST_NOT_THROW */
371 struct GTY((tag("GSS_EH_MNT")))
372 gimple_statement_eh_mnt
: public gimple_statement_base
374 /* [ WORD 1-6 ] : base class */
376 /* [ WORD 7 ] Abort function decl. */
382 struct GTY((tag("GSS_PHI")))
383 gimple_statement_phi
: public gimple_statement_base
385 /* [ WORD 1-6 ] : base class */
395 struct phi_arg_d
GTY ((length ("%h.nargs"))) args
[1];
399 /* GIMPLE_RESX, GIMPLE_EH_DISPATCH */
401 struct GTY((tag("GSS_EH_CTRL")))
402 gimple_statement_eh_ctrl
: public gimple_statement_base
404 /* [ WORD 1-6 ] : base class */
407 Exception region number. */
414 struct GTY((tag("GSS_TRY")))
415 gimple_statement_try
: public gimple_statement_base
417 /* [ WORD 1-6 ] : base class */
420 Expression to evaluate. */
424 Cleanup expression. */
428 /* Kind of GIMPLE_TRY statements. */
429 enum gimple_try_flags
432 GIMPLE_TRY_CATCH
= 1 << 0,
435 GIMPLE_TRY_FINALLY
= 1 << 1,
436 GIMPLE_TRY_KIND
= GIMPLE_TRY_CATCH
| GIMPLE_TRY_FINALLY
,
438 /* Analogous to TRY_CATCH_IS_CLEANUP. */
439 GIMPLE_TRY_CATCH_IS_CLEANUP
= 1 << 2
442 /* GIMPLE_WITH_CLEANUP_EXPR */
444 struct GTY((tag("GSS_WCE")))
445 gimple_statement_wce
: public gimple_statement_base
447 /* [ WORD 1-6 ] : base class */
449 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
450 executed if an exception is thrown, not on normal exit of its
451 scope. This flag is analogous to the CLEANUP_EH_ONLY flag
455 Cleanup expression. */
462 struct GTY((tag("GSS_ASM")))
463 gimple_statement_asm
: public gimple_statement_with_memory_ops_base
465 /* [ WORD 1-9 ] : base class */
468 __asm__ statement. */
472 Number of inputs, outputs, clobbers, labels. */
479 Operand vector. NOTE! This must always be the last field
480 of this structure. In particular, this means that this
481 structure cannot be embedded inside another one. */
482 tree
GTY((length ("%h.num_ops"))) op
[1];
485 /* GIMPLE_OMP_CRITICAL */
487 struct GTY((tag("GSS_OMP_CRITICAL")))
488 gimple_statement_omp_critical
: public gimple_statement_omp
490 /* [ WORD 1-7 ] : base class */
493 Critical section name. */
498 struct GTY(()) gimple_omp_for_iter
{
499 /* Condition code. */
502 /* Index variable. */
517 struct GTY((tag("GSS_OMP_FOR")))
518 gimple_statement_omp_for
: public gimple_statement_omp
520 /* [ WORD 1-7 ] : base class */
526 Number of elements in iter array. */
530 struct gimple_omp_for_iter
* GTY((length ("%h.collapse"))) iter
;
533 Pre-body evaluated before the loop body begins. */
538 /* GIMPLE_OMP_PARALLEL */
540 struct GTY((tag("GSS_OMP_PARALLEL")))
541 gimple_statement_omp_parallel
: public gimple_statement_omp
543 /* [ WORD 1-7 ] : base class */
550 Child function holding the body of the parallel region. */
554 Shared data argument. */
559 /* GIMPLE_OMP_TASK */
561 struct GTY((tag("GSS_OMP_TASK")))
562 gimple_statement_omp_task
: public gimple_statement_omp_parallel
564 /* [ WORD 1-10 ] : base class */
567 Child function holding firstprivate initialization if needed. */
571 Size and alignment in bytes of the argument data block. */
577 /* GIMPLE_OMP_SECTION */
578 /* Uses struct gimple_statement_omp. */
581 /* GIMPLE_OMP_SECTIONS */
583 struct GTY((tag("GSS_OMP_SECTIONS")))
584 gimple_statement_omp_sections
: public gimple_statement_omp
586 /* [ WORD 1-7 ] : base class */
592 The control variable used for deciding which of the sections to
597 /* GIMPLE_OMP_CONTINUE.
599 Note: This does not inherit from gimple_statement_omp, because we
600 do not need the body field. */
602 struct GTY((tag("GSS_OMP_CONTINUE")))
603 gimple_statement_omp_continue
: public gimple_statement_base
605 /* [ WORD 1-6 ] : base class */
614 /* GIMPLE_OMP_SINGLE, GIMPLE_OMP_TARGET, GIMPLE_OMP_TEAMS */
616 struct GTY((tag("GSS_OMP_SINGLE")))
617 gimple_statement_omp_single
: public gimple_statement_omp
619 /* [ WORD 1-7 ] : base class */
626 /* GIMPLE_OMP_ATOMIC_LOAD.
627 Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
628 contains a sequence, which we don't need here. */
630 struct GTY((tag("GSS_OMP_ATOMIC_LOAD")))
631 gimple_statement_omp_atomic_load
: public gimple_statement_base
633 /* [ WORD 1-6 ] : base class */
639 /* GIMPLE_OMP_ATOMIC_STORE.
640 See note on GIMPLE_OMP_ATOMIC_LOAD. */
642 struct GTY((tag("GSS_OMP_ATOMIC_STORE")))
643 gimple_statement_omp_atomic_store
: public gimple_statement_base
645 /* [ WORD 1-6 ] : base class */
651 /* GIMPLE_TRANSACTION. */
653 /* Bits to be stored in the GIMPLE_TRANSACTION subcode. */
655 /* The __transaction_atomic was declared [[outer]] or it is
656 __transaction_relaxed. */
657 #define GTMA_IS_OUTER (1u << 0)
658 #define GTMA_IS_RELAXED (1u << 1)
659 #define GTMA_DECLARATION_MASK (GTMA_IS_OUTER | GTMA_IS_RELAXED)
661 /* The transaction is seen to not have an abort. */
662 #define GTMA_HAVE_ABORT (1u << 2)
663 /* The transaction is seen to have loads or stores. */
664 #define GTMA_HAVE_LOAD (1u << 3)
665 #define GTMA_HAVE_STORE (1u << 4)
666 /* The transaction MAY enter serial irrevocable mode in its dynamic scope. */
667 #define GTMA_MAY_ENTER_IRREVOCABLE (1u << 5)
668 /* The transaction WILL enter serial irrevocable mode.
669 An irrevocable block post-dominates the entire transaction, such
670 that all invocations of the transaction will go serial-irrevocable.
671 In such case, we don't bother instrumenting the transaction, and
672 tell the runtime that it should begin the transaction in
673 serial-irrevocable mode. */
674 #define GTMA_DOES_GO_IRREVOCABLE (1u << 6)
675 /* The transaction contains no instrumentation code whatsover, most
676 likely because it is guaranteed to go irrevocable upon entry. */
677 #define GTMA_HAS_NO_INSTRUMENTATION (1u << 7)
679 struct GTY((tag("GSS_TRANSACTION")))
680 gimple_statement_transaction
: public gimple_statement_with_memory_ops_base
682 /* [ WORD 1-9 ] : base class */
691 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) SYM,
692 enum gimple_statement_structure_enum
{
693 #include "gsstruct.def"
701 is_a_helper
<gimple_statement_asm
>::test (gimple gs
)
703 return gs
->code
== GIMPLE_ASM
;
709 is_a_helper
<gimple_statement_bind
>::test (gimple gs
)
711 return gs
->code
== GIMPLE_BIND
;
717 is_a_helper
<gimple_statement_call
>::test (gimple gs
)
719 return gs
->code
== GIMPLE_CALL
;
725 is_a_helper
<gimple_statement_catch
>::test (gimple gs
)
727 return gs
->code
== GIMPLE_CATCH
;
733 is_a_helper
<gimple_statement_eh_ctrl
>::test (gimple gs
)
735 return gs
->code
== GIMPLE_RESX
|| gs
->code
== GIMPLE_EH_DISPATCH
;
741 is_a_helper
<gimple_statement_eh_else
>::test (gimple gs
)
743 return gs
->code
== GIMPLE_EH_ELSE
;
749 is_a_helper
<gimple_statement_eh_filter
>::test (gimple gs
)
751 return gs
->code
== GIMPLE_EH_FILTER
;
757 is_a_helper
<gimple_statement_eh_mnt
>::test (gimple gs
)
759 return gs
->code
== GIMPLE_EH_MUST_NOT_THROW
;
765 is_a_helper
<gimple_statement_omp_atomic_load
>::test (gimple gs
)
767 return gs
->code
== GIMPLE_OMP_ATOMIC_LOAD
;
773 is_a_helper
<gimple_statement_omp_atomic_store
>::test (gimple gs
)
775 return gs
->code
== GIMPLE_OMP_ATOMIC_STORE
|| gs
->code
== GIMPLE_OMP_RETURN
;
781 is_a_helper
<gimple_statement_omp_continue
>::test (gimple gs
)
783 return gs
->code
== GIMPLE_OMP_CONTINUE
;
789 is_a_helper
<gimple_statement_omp_critical
>::test (gimple gs
)
791 return gs
->code
== GIMPLE_OMP_CRITICAL
;
797 is_a_helper
<gimple_statement_omp_for
>::test (gimple gs
)
799 return gs
->code
== GIMPLE_OMP_FOR
;
805 is_a_helper
<gimple_statement_omp_parallel
>::test (gimple gs
)
807 return gs
->code
== GIMPLE_OMP_PARALLEL
|| gs
->code
== GIMPLE_OMP_TASK
|| gs
->code
== GIMPLE_OMP_TARGET
;
813 is_a_helper
<gimple_statement_omp_sections
>::test (gimple gs
)
815 return gs
->code
== GIMPLE_OMP_SECTIONS
;
821 is_a_helper
<gimple_statement_omp_single
>::test (gimple gs
)
823 return gs
->code
== GIMPLE_OMP_SINGLE
|| gs
->code
== GIMPLE_OMP_TEAMS
;
829 is_a_helper
<gimple_statement_omp_task
>::test (gimple gs
)
831 return gs
->code
== GIMPLE_OMP_TASK
;
837 is_a_helper
<gimple_statement_phi
>::test (gimple gs
)
839 return gs
->code
== GIMPLE_PHI
;
845 is_a_helper
<gimple_statement_transaction
>::test (gimple gs
)
847 return gs
->code
== GIMPLE_TRANSACTION
;
853 is_a_helper
<gimple_statement_try
>::test (gimple gs
)
855 return gs
->code
== GIMPLE_TRY
;
861 is_a_helper
<gimple_statement_wce
>::test (gimple gs
)
863 return gs
->code
== GIMPLE_WITH_CLEANUP_EXPR
;
869 is_a_helper
<const gimple_statement_asm
>::test (const_gimple gs
)
871 return gs
->code
== GIMPLE_ASM
;
877 is_a_helper
<const gimple_statement_bind
>::test (const_gimple gs
)
879 return gs
->code
== GIMPLE_BIND
;
885 is_a_helper
<const gimple_statement_call
>::test (const_gimple gs
)
887 return gs
->code
== GIMPLE_CALL
;
893 is_a_helper
<const gimple_statement_catch
>::test (const_gimple gs
)
895 return gs
->code
== GIMPLE_CATCH
;
901 is_a_helper
<const gimple_statement_eh_ctrl
>::test (const_gimple gs
)
903 return gs
->code
== GIMPLE_RESX
|| gs
->code
== GIMPLE_EH_DISPATCH
;
909 is_a_helper
<const gimple_statement_eh_filter
>::test (const_gimple gs
)
911 return gs
->code
== GIMPLE_EH_FILTER
;
917 is_a_helper
<const gimple_statement_omp_atomic_load
>::test (const_gimple gs
)
919 return gs
->code
== GIMPLE_OMP_ATOMIC_LOAD
;
925 is_a_helper
<const gimple_statement_omp_atomic_store
>::test (const_gimple gs
)
927 return gs
->code
== GIMPLE_OMP_ATOMIC_STORE
|| gs
->code
== GIMPLE_OMP_RETURN
;
933 is_a_helper
<const gimple_statement_omp_continue
>::test (const_gimple gs
)
935 return gs
->code
== GIMPLE_OMP_CONTINUE
;
941 is_a_helper
<const gimple_statement_omp_critical
>::test (const_gimple gs
)
943 return gs
->code
== GIMPLE_OMP_CRITICAL
;
949 is_a_helper
<const gimple_statement_omp_for
>::test (const_gimple gs
)
951 return gs
->code
== GIMPLE_OMP_FOR
;
957 is_a_helper
<const gimple_statement_omp_parallel
>::test (const_gimple gs
)
959 return gs
->code
== GIMPLE_OMP_PARALLEL
|| gs
->code
== GIMPLE_OMP_TASK
|| gs
->code
== GIMPLE_OMP_TARGET
;
965 is_a_helper
<const gimple_statement_omp_sections
>::test (const_gimple gs
)
967 return gs
->code
== GIMPLE_OMP_SECTIONS
;
973 is_a_helper
<const gimple_statement_omp_single
>::test (const_gimple gs
)
975 return gs
->code
== GIMPLE_OMP_SINGLE
|| gs
->code
== GIMPLE_OMP_TEAMS
;
981 is_a_helper
<const gimple_statement_omp_task
>::test (const_gimple gs
)
983 return gs
->code
== GIMPLE_OMP_TASK
;
989 is_a_helper
<const gimple_statement_phi
>::test (const_gimple gs
)
991 return gs
->code
== GIMPLE_PHI
;
997 is_a_helper
<const gimple_statement_transaction
>::test (const_gimple gs
)
999 return gs
->code
== GIMPLE_TRANSACTION
;
1002 /* Offset in bytes to the location of the operand vector.
1003 Zero if there is no operand vector for this tuple structure. */
1004 extern size_t const gimple_ops_offset_
[];
1006 /* Map GIMPLE codes to GSS codes. */
1007 extern enum gimple_statement_structure_enum
const gss_for_code_
[];
1009 /* This variable holds the currently expanded gimple statement for purposes
1010 of comminucating the profile info to the builtin expanders. */
1011 extern gimple currently_expanding_gimple_stmt
;
1013 #define gimple_alloc(c, n) gimple_alloc_stat (c, n MEM_STAT_INFO)
1014 gimple
gimple_alloc_stat (enum gimple_code
, unsigned MEM_STAT_DECL
);
1015 gimple
gimple_build_return (tree
);
1016 void gimple_call_reset_alias_info (gimple
);
1017 gimple
gimple_build_call_vec (tree
, vec
<tree
> );
1018 gimple
gimple_build_call (tree
, unsigned, ...);
1019 gimple
gimple_build_call_valist (tree
, unsigned, va_list);
1020 gimple
gimple_build_call_internal (enum internal_fn
, unsigned, ...);
1021 gimple
gimple_build_call_internal_vec (enum internal_fn
, vec
<tree
> );
1022 gimple
gimple_build_call_from_tree (tree
);
1023 gimple
gimple_build_assign_stat (tree
, tree MEM_STAT_DECL
);
1024 #define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO)
1025 gimple
gimple_build_assign_with_ops (enum tree_code
, tree
,
1026 tree
, tree
, tree CXX_MEM_STAT_INFO
);
1027 gimple
gimple_build_assign_with_ops (enum tree_code
, tree
,
1028 tree
, tree CXX_MEM_STAT_INFO
);
1029 gimple
gimple_build_cond (enum tree_code
, tree
, tree
, tree
, tree
);
1030 gimple
gimple_build_cond_from_tree (tree
, tree
, tree
);
1031 void gimple_cond_set_condition_from_tree (gimple
, tree
);
1032 gimple
gimple_build_label (tree label
);
1033 gimple
gimple_build_goto (tree dest
);
1034 gimple
gimple_build_nop (void);
1035 gimple
gimple_build_bind (tree
, gimple_seq
, tree
);
1036 gimple
gimple_build_asm_vec (const char *, vec
<tree
, va_gc
> *,
1037 vec
<tree
, va_gc
> *, vec
<tree
, va_gc
> *,
1038 vec
<tree
, va_gc
> *);
1039 gimple
gimple_build_catch (tree
, gimple_seq
);
1040 gimple
gimple_build_eh_filter (tree
, gimple_seq
);
1041 gimple
gimple_build_eh_must_not_throw (tree
);
1042 gimple
gimple_build_eh_else (gimple_seq
, gimple_seq
);
1043 gimple_statement_try
*gimple_build_try (gimple_seq
, gimple_seq
,
1044 enum gimple_try_flags
);
1045 gimple
gimple_build_wce (gimple_seq
);
1046 gimple
gimple_build_resx (int);
1047 gimple
gimple_build_switch_nlabels (unsigned, tree
, tree
);
1048 gimple
gimple_build_switch (tree
, tree
, vec
<tree
> );
1049 gimple
gimple_build_eh_dispatch (int);
1050 gimple
gimple_build_debug_bind_stat (tree
, tree
, gimple MEM_STAT_DECL
);
1051 #define gimple_build_debug_bind(var,val,stmt) \
1052 gimple_build_debug_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
1053 gimple
gimple_build_debug_source_bind_stat (tree
, tree
, gimple MEM_STAT_DECL
);
1054 #define gimple_build_debug_source_bind(var,val,stmt) \
1055 gimple_build_debug_source_bind_stat ((var), (val), (stmt) MEM_STAT_INFO)
1056 gimple
gimple_build_omp_critical (gimple_seq
, tree
);
1057 gimple
gimple_build_omp_for (gimple_seq
, int, tree
, size_t, gimple_seq
);
1058 gimple
gimple_build_omp_parallel (gimple_seq
, tree
, tree
, tree
);
1059 gimple
gimple_build_omp_task (gimple_seq
, tree
, tree
, tree
, tree
, tree
, tree
);
1060 gimple
gimple_build_omp_section (gimple_seq
);
1061 gimple
gimple_build_omp_master (gimple_seq
);
1062 gimple
gimple_build_omp_taskgroup (gimple_seq
);
1063 gimple
gimple_build_omp_continue (tree
, tree
);
1064 gimple
gimple_build_omp_ordered (gimple_seq
);
1065 gimple
gimple_build_omp_return (bool);
1066 gimple
gimple_build_omp_sections (gimple_seq
, tree
);
1067 gimple
gimple_build_omp_sections_switch (void);
1068 gimple
gimple_build_omp_single (gimple_seq
, tree
);
1069 gimple
gimple_build_omp_target (gimple_seq
, int, tree
);
1070 gimple
gimple_build_omp_teams (gimple_seq
, tree
);
1071 gimple
gimple_build_omp_atomic_load (tree
, tree
);
1072 gimple
gimple_build_omp_atomic_store (tree
);
1073 gimple
gimple_build_transaction (gimple_seq
, tree
);
1074 gimple
gimple_build_predict (enum br_predictor
, enum prediction
);
1075 extern void gimple_seq_add_stmt (gimple_seq
*, gimple
);
1076 extern void gimple_seq_add_stmt_without_update (gimple_seq
*, gimple
);
1077 void gimple_seq_add_seq (gimple_seq
*, gimple_seq
);
1078 extern void annotate_all_with_location_after (gimple_seq
, gimple_stmt_iterator
,
1080 extern void annotate_all_with_location (gimple_seq
, location_t
);
1081 bool empty_body_p (gimple_seq
);
1082 gimple_seq
gimple_seq_copy (gimple_seq
);
1083 bool gimple_call_same_target_p (const_gimple
, const_gimple
);
1084 int gimple_call_flags (const_gimple
);
1085 int gimple_call_arg_flags (const_gimple
, unsigned);
1086 int gimple_call_return_flags (const_gimple
);
1087 bool gimple_assign_copy_p (gimple
);
1088 bool gimple_assign_ssa_name_copy_p (gimple
);
1089 bool gimple_assign_unary_nop_p (gimple
);
1090 void gimple_set_bb (gimple
, basic_block
);
1091 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator
*, tree
);
1092 void gimple_assign_set_rhs_with_ops_1 (gimple_stmt_iterator
*, enum tree_code
,
1094 tree
gimple_get_lhs (const_gimple
);
1095 void gimple_set_lhs (gimple
, tree
);
1096 gimple
gimple_copy (gimple
);
1097 bool gimple_has_side_effects (const_gimple
);
1098 bool gimple_could_trap_p_1 (gimple
, bool, bool);
1099 bool gimple_could_trap_p (gimple
);
1100 bool gimple_assign_rhs_could_trap_p (gimple
);
1101 extern void dump_gimple_statistics (void);
1102 unsigned get_gimple_rhs_num_ops (enum tree_code
);
1103 extern tree
canonicalize_cond_expr_cond (tree
);
1104 gimple
gimple_call_copy_skip_args (gimple
, bitmap
);
1105 extern bool gimple_compare_field_offset (tree
, tree
);
1106 extern tree
gimple_unsigned_type (tree
);
1107 extern tree
gimple_signed_type (tree
);
1108 extern alias_set_type
gimple_get_alias_set (tree
);
1109 extern bool gimple_ior_addresses_taken (bitmap
, gimple
);
1110 extern bool is_gimple_builtin_call (gimple stmt
);
1111 extern bool gimple_call_builtin_p (gimple
, enum built_in_class
);
1112 extern bool gimple_call_builtin_p (gimple
, enum built_in_function
);
1113 extern bool gimple_asm_clobbers_memory_p (const_gimple
);
1114 extern void dump_decl_set (FILE *, bitmap
);
1115 extern bool nonfreeing_call_p (gimple
);
1116 extern bool infer_nonnull_range (gimple
, tree
);
1117 extern void sort_case_labels (vec
<tree
> );
1118 extern void preprocess_case_label_vec_for_gimple (vec
<tree
> , tree
, tree
*);
1119 extern void gimple_seq_set_location (gimple_seq
, location_t
);
1121 /* Formal (expression) temporary table handling: multiple occurrences of
1122 the same scalar expression are evaluated into the same temporary. */
1124 typedef struct gimple_temp_hash_elt
1127 tree temp
; /* Value */
1130 /* Get the number of the next statement uid to be allocated. */
1131 static inline unsigned int
1132 gimple_stmt_max_uid (struct function
*fn
)
1134 return fn
->last_stmt_uid
;
1137 /* Set the number of the next statement uid to be allocated. */
1139 set_gimple_stmt_max_uid (struct function
*fn
, unsigned int maxid
)
1141 fn
->last_stmt_uid
= maxid
;
1144 /* Set the number of the next statement uid to be allocated. */
1145 static inline unsigned int
1146 inc_gimple_stmt_max_uid (struct function
*fn
)
1148 return fn
->last_stmt_uid
++;
1151 /* Return the first node in GIMPLE sequence S. */
1153 static inline gimple_seq_node
1154 gimple_seq_first (gimple_seq s
)
1160 /* Return the first statement in GIMPLE sequence S. */
1162 static inline gimple
1163 gimple_seq_first_stmt (gimple_seq s
)
1165 gimple_seq_node n
= gimple_seq_first (s
);
1170 /* Return the last node in GIMPLE sequence S. */
1172 static inline gimple_seq_node
1173 gimple_seq_last (gimple_seq s
)
1175 return s
? s
->prev
: NULL
;
1179 /* Return the last statement in GIMPLE sequence S. */
1181 static inline gimple
1182 gimple_seq_last_stmt (gimple_seq s
)
1184 gimple_seq_node n
= gimple_seq_last (s
);
1189 /* Set the last node in GIMPLE sequence *PS to LAST. */
1192 gimple_seq_set_last (gimple_seq
*ps
, gimple_seq_node last
)
1198 /* Set the first node in GIMPLE sequence *PS to FIRST. */
1201 gimple_seq_set_first (gimple_seq
*ps
, gimple_seq_node first
)
1207 /* Return true if GIMPLE sequence S is empty. */
1210 gimple_seq_empty_p (gimple_seq s
)
1215 /* Allocate a new sequence and initialize its first element with STMT. */
1217 static inline gimple_seq
1218 gimple_seq_alloc_with_stmt (gimple stmt
)
1220 gimple_seq seq
= NULL
;
1221 gimple_seq_add_stmt (&seq
, stmt
);
1226 /* Returns the sequence of statements in BB. */
1228 static inline gimple_seq
1229 bb_seq (const_basic_block bb
)
1231 return (!(bb
->flags
& BB_RTL
)) ? bb
->il
.gimple
.seq
: NULL
;
1234 static inline gimple_seq
*
1235 bb_seq_addr (basic_block bb
)
1237 return (!(bb
->flags
& BB_RTL
)) ? &bb
->il
.gimple
.seq
: NULL
;
1240 /* Sets the sequence of statements in BB to SEQ. */
1243 set_bb_seq (basic_block bb
, gimple_seq seq
)
1245 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
1246 bb
->il
.gimple
.seq
= seq
;
1250 /* Return the code for GIMPLE statement G. */
1252 static inline enum gimple_code
1253 gimple_code (const_gimple g
)
1259 /* Return the GSS code used by a GIMPLE code. */
1261 static inline enum gimple_statement_structure_enum
1262 gss_for_code (enum gimple_code code
)
1264 gcc_gimple_checking_assert ((unsigned int)code
< LAST_AND_UNUSED_GIMPLE_CODE
);
1265 return gss_for_code_
[code
];
1269 /* Return which GSS code is used by GS. */
1271 static inline enum gimple_statement_structure_enum
1272 gimple_statement_structure (gimple gs
)
1274 return gss_for_code (gimple_code (gs
));
1278 /* Return true if statement G has sub-statements. This is only true for
1279 High GIMPLE statements. */
1282 gimple_has_substatements (gimple g
)
1284 switch (gimple_code (g
))
1288 case GIMPLE_EH_FILTER
:
1289 case GIMPLE_EH_ELSE
:
1291 case GIMPLE_OMP_FOR
:
1292 case GIMPLE_OMP_MASTER
:
1293 case GIMPLE_OMP_TASKGROUP
:
1294 case GIMPLE_OMP_ORDERED
:
1295 case GIMPLE_OMP_SECTION
:
1296 case GIMPLE_OMP_PARALLEL
:
1297 case GIMPLE_OMP_TASK
:
1298 case GIMPLE_OMP_SECTIONS
:
1299 case GIMPLE_OMP_SINGLE
:
1300 case GIMPLE_OMP_TARGET
:
1301 case GIMPLE_OMP_TEAMS
:
1302 case GIMPLE_OMP_CRITICAL
:
1303 case GIMPLE_WITH_CLEANUP_EXPR
:
1304 case GIMPLE_TRANSACTION
:
1313 /* Return the basic block holding statement G. */
1315 static inline basic_block
1316 gimple_bb (const_gimple g
)
1322 /* Return the lexical scope block holding statement G. */
1325 gimple_block (const_gimple g
)
1327 return LOCATION_BLOCK (g
->location
);
1331 /* Set BLOCK to be the lexical scope block holding statement G. */
1334 gimple_set_block (gimple g
, tree block
)
1338 COMBINE_LOCATION_DATA (line_table
, g
->location
, block
);
1340 g
->location
= LOCATION_LOCUS (g
->location
);
1344 /* Return location information for statement G. */
1346 static inline location_t
1347 gimple_location (const_gimple g
)
1352 /* Return pointer to location information for statement G. */
1354 static inline const location_t
*
1355 gimple_location_ptr (const_gimple g
)
1357 return &g
->location
;
1361 /* Set location information for statement G. */
1364 gimple_set_location (gimple g
, location_t location
)
1366 g
->location
= location
;
1370 /* Return true if G contains location information. */
1373 gimple_has_location (const_gimple g
)
1375 return LOCATION_LOCUS (gimple_location (g
)) != UNKNOWN_LOCATION
;
1379 /* Return the file name of the location of STMT. */
1381 static inline const char *
1382 gimple_filename (const_gimple stmt
)
1384 return LOCATION_FILE (gimple_location (stmt
));
1388 /* Return the line number of the location of STMT. */
1391 gimple_lineno (const_gimple stmt
)
1393 return LOCATION_LINE (gimple_location (stmt
));
1397 /* Determine whether SEQ is a singleton. */
1400 gimple_seq_singleton_p (gimple_seq seq
)
1402 return ((gimple_seq_first (seq
) != NULL
)
1403 && (gimple_seq_first (seq
) == gimple_seq_last (seq
)));
1406 /* Return true if no warnings should be emitted for statement STMT. */
1409 gimple_no_warning_p (const_gimple stmt
)
1411 return stmt
->no_warning
;
1414 /* Set the no_warning flag of STMT to NO_WARNING. */
1417 gimple_set_no_warning (gimple stmt
, bool no_warning
)
1419 stmt
->no_warning
= (unsigned) no_warning
;
1422 /* Set the visited status on statement STMT to VISITED_P. */
1425 gimple_set_visited (gimple stmt
, bool visited_p
)
1427 stmt
->visited
= (unsigned) visited_p
;
1431 /* Return the visited status for statement STMT. */
1434 gimple_visited_p (gimple stmt
)
1436 return stmt
->visited
;
1440 /* Set pass local flag PLF on statement STMT to VAL_P. */
1443 gimple_set_plf (gimple stmt
, enum plf_mask plf
, bool val_p
)
1446 stmt
->plf
|= (unsigned int) plf
;
1448 stmt
->plf
&= ~((unsigned int) plf
);
1452 /* Return the value of pass local flag PLF on statement STMT. */
1454 static inline unsigned int
1455 gimple_plf (gimple stmt
, enum plf_mask plf
)
1457 return stmt
->plf
& ((unsigned int) plf
);
1461 /* Set the UID of statement. */
1464 gimple_set_uid (gimple g
, unsigned uid
)
1470 /* Return the UID of statement. */
1472 static inline unsigned
1473 gimple_uid (const_gimple g
)
1479 /* Make statement G a singleton sequence. */
1482 gimple_init_singleton (gimple g
)
1489 /* Return true if GIMPLE statement G has register or memory operands. */
1492 gimple_has_ops (const_gimple g
)
1494 return gimple_code (g
) >= GIMPLE_COND
&& gimple_code (g
) <= GIMPLE_RETURN
;
1500 is_a_helper
<const gimple_statement_with_ops
>::test (const_gimple gs
)
1502 return gimple_has_ops (gs
);
1508 is_a_helper
<gimple_statement_with_ops
>::test (gimple gs
)
1510 return gimple_has_ops (gs
);
1513 /* Return true if GIMPLE statement G has memory operands. */
1516 gimple_has_mem_ops (const_gimple g
)
1518 return gimple_code (g
) >= GIMPLE_ASSIGN
&& gimple_code (g
) <= GIMPLE_RETURN
;
1524 is_a_helper
<const gimple_statement_with_memory_ops
>::test (const_gimple gs
)
1526 return gimple_has_mem_ops (gs
);
1532 is_a_helper
<gimple_statement_with_memory_ops
>::test (gimple gs
)
1534 return gimple_has_mem_ops (gs
);
1537 /* Return the set of USE operands for statement G. */
1539 static inline struct use_optype_d
*
1540 gimple_use_ops (const_gimple g
)
1542 const gimple_statement_with_ops
*ops_stmt
=
1543 dyn_cast
<const gimple_statement_with_ops
> (g
);
1546 return ops_stmt
->use_ops
;
1550 /* Set USE to be the set of USE operands for statement G. */
1553 gimple_set_use_ops (gimple g
, struct use_optype_d
*use
)
1555 gimple_statement_with_ops
*ops_stmt
=
1556 as_a
<gimple_statement_with_ops
> (g
);
1557 ops_stmt
->use_ops
= use
;
1561 /* Return the single VUSE operand of the statement G. */
1564 gimple_vuse (const_gimple g
)
1566 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
1567 dyn_cast
<const gimple_statement_with_memory_ops
> (g
);
1570 return mem_ops_stmt
->vuse
;
1573 /* Return the single VDEF operand of the statement G. */
1576 gimple_vdef (const_gimple g
)
1578 const gimple_statement_with_memory_ops
*mem_ops_stmt
=
1579 dyn_cast
<const gimple_statement_with_memory_ops
> (g
);
1582 return mem_ops_stmt
->vdef
;
1585 /* Return the single VUSE operand of the statement G. */
1587 static inline tree
*
1588 gimple_vuse_ptr (gimple g
)
1590 gimple_statement_with_memory_ops
*mem_ops_stmt
=
1591 dyn_cast
<gimple_statement_with_memory_ops
> (g
);
1594 return &mem_ops_stmt
->vuse
;
1597 /* Return the single VDEF operand of the statement G. */
1599 static inline tree
*
1600 gimple_vdef_ptr (gimple g
)
1602 gimple_statement_with_memory_ops
*mem_ops_stmt
=
1603 dyn_cast
<gimple_statement_with_memory_ops
> (g
);
1606 return &mem_ops_stmt
->vdef
;
1609 /* Set the single VUSE operand of the statement G. */
1612 gimple_set_vuse (gimple g
, tree vuse
)
1614 gimple_statement_with_memory_ops
*mem_ops_stmt
=
1615 as_a
<gimple_statement_with_memory_ops
> (g
);
1616 mem_ops_stmt
->vuse
= vuse
;
1619 /* Set the single VDEF operand of the statement G. */
1622 gimple_set_vdef (gimple g
, tree vdef
)
1624 gimple_statement_with_memory_ops
*mem_ops_stmt
=
1625 as_a
<gimple_statement_with_memory_ops
> (g
);
1626 mem_ops_stmt
->vdef
= vdef
;
1630 /* Return true if statement G has operands and the modified field has
1634 gimple_modified_p (const_gimple g
)
1636 return (gimple_has_ops (g
)) ? (bool) g
->modified
: false;
1640 /* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
1641 a MODIFIED field. */
1644 gimple_set_modified (gimple s
, bool modifiedp
)
1646 if (gimple_has_ops (s
))
1647 s
->modified
= (unsigned) modifiedp
;
1651 /* Return the tree code for the expression computed by STMT. This is
1652 only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
1653 GIMPLE_CALL, return CALL_EXPR as the expression code for
1654 consistency. This is useful when the caller needs to deal with the
1655 three kinds of computation that GIMPLE supports. */
1657 static inline enum tree_code
1658 gimple_expr_code (const_gimple stmt
)
1660 enum gimple_code code
= gimple_code (stmt
);
1661 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_COND
)
1662 return (enum tree_code
) stmt
->subcode
;
1665 gcc_gimple_checking_assert (code
== GIMPLE_CALL
);
1671 /* Return true if statement STMT contains volatile operands. */
1674 gimple_has_volatile_ops (const_gimple stmt
)
1676 if (gimple_has_mem_ops (stmt
))
1677 return stmt
->has_volatile_ops
;
1683 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
1686 gimple_set_has_volatile_ops (gimple stmt
, bool volatilep
)
1688 if (gimple_has_mem_ops (stmt
))
1689 stmt
->has_volatile_ops
= (unsigned) volatilep
;
1692 /* Return true if STMT is in a transaction. */
1695 gimple_in_transaction (gimple stmt
)
1697 return bb_in_transaction (gimple_bb (stmt
));
1700 /* Return true if statement STMT may access memory. */
1703 gimple_references_memory_p (gimple stmt
)
1705 return gimple_has_mem_ops (stmt
) && gimple_vuse (stmt
);
1709 /* Return the subcode for OMP statement S. */
1711 static inline unsigned
1712 gimple_omp_subcode (const_gimple s
)
1714 gcc_gimple_checking_assert (gimple_code (s
) >= GIMPLE_OMP_ATOMIC_LOAD
1715 && gimple_code (s
) <= GIMPLE_OMP_TEAMS
);
1719 /* Set the subcode for OMP statement S to SUBCODE. */
1722 gimple_omp_set_subcode (gimple s
, unsigned int subcode
)
1724 /* We only have 16 bits for the subcode. Assert that we are not
1726 gcc_gimple_checking_assert (subcode
< (1 << 16));
1727 s
->subcode
= subcode
;
1730 /* Set the nowait flag on OMP_RETURN statement S. */
1733 gimple_omp_return_set_nowait (gimple s
)
1735 GIMPLE_CHECK (s
, GIMPLE_OMP_RETURN
);
1736 s
->subcode
|= GF_OMP_RETURN_NOWAIT
;
1740 /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
1744 gimple_omp_return_nowait_p (const_gimple g
)
1746 GIMPLE_CHECK (g
, GIMPLE_OMP_RETURN
);
1747 return (gimple_omp_subcode (g
) & GF_OMP_RETURN_NOWAIT
) != 0;
1751 /* Set the LHS of OMP return. */
1754 gimple_omp_return_set_lhs (gimple g
, tree lhs
)
1756 gimple_statement_omp_atomic_store
*omp_atomic_store_stmt
=
1757 as_a
<gimple_statement_omp_atomic_store
> (g
);
1758 omp_atomic_store_stmt
->val
= lhs
;
1762 /* Get the LHS of OMP return. */
1765 gimple_omp_return_lhs (const_gimple g
)
1767 const gimple_statement_omp_atomic_store
*omp_atomic_store_stmt
=
1768 as_a
<const gimple_statement_omp_atomic_store
> (g
);
1769 return omp_atomic_store_stmt
->val
;
1773 /* Return a pointer to the LHS of OMP return. */
1775 static inline tree
*
1776 gimple_omp_return_lhs_ptr (gimple g
)
1778 gimple_statement_omp_atomic_store
*omp_atomic_store_stmt
=
1779 as_a
<gimple_statement_omp_atomic_store
> (g
);
1780 return &omp_atomic_store_stmt
->val
;
1784 /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
1788 gimple_omp_section_last_p (const_gimple g
)
1790 GIMPLE_CHECK (g
, GIMPLE_OMP_SECTION
);
1791 return (gimple_omp_subcode (g
) & GF_OMP_SECTION_LAST
) != 0;
1795 /* Set the GF_OMP_SECTION_LAST flag on G. */
1798 gimple_omp_section_set_last (gimple g
)
1800 GIMPLE_CHECK (g
, GIMPLE_OMP_SECTION
);
1801 g
->subcode
|= GF_OMP_SECTION_LAST
;
1805 /* Return true if OMP parallel statement G has the
1806 GF_OMP_PARALLEL_COMBINED flag set. */
1809 gimple_omp_parallel_combined_p (const_gimple g
)
1811 GIMPLE_CHECK (g
, GIMPLE_OMP_PARALLEL
);
1812 return (gimple_omp_subcode (g
) & GF_OMP_PARALLEL_COMBINED
) != 0;
1816 /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
1817 value of COMBINED_P. */
1820 gimple_omp_parallel_set_combined_p (gimple g
, bool combined_p
)
1822 GIMPLE_CHECK (g
, GIMPLE_OMP_PARALLEL
);
1824 g
->subcode
|= GF_OMP_PARALLEL_COMBINED
;
1826 g
->subcode
&= ~GF_OMP_PARALLEL_COMBINED
;
1830 /* Return true if OMP atomic load/store statement G has the
1831 GF_OMP_ATOMIC_NEED_VALUE flag set. */
1834 gimple_omp_atomic_need_value_p (const_gimple g
)
1836 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
1837 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
1838 return (gimple_omp_subcode (g
) & GF_OMP_ATOMIC_NEED_VALUE
) != 0;
1842 /* Set the GF_OMP_ATOMIC_NEED_VALUE flag on G. */
1845 gimple_omp_atomic_set_need_value (gimple g
)
1847 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
1848 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
1849 g
->subcode
|= GF_OMP_ATOMIC_NEED_VALUE
;
1853 /* Return true if OMP atomic load/store statement G has the
1854 GF_OMP_ATOMIC_SEQ_CST flag set. */
1857 gimple_omp_atomic_seq_cst_p (const_gimple g
)
1859 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
1860 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
1861 return (gimple_omp_subcode (g
) & GF_OMP_ATOMIC_SEQ_CST
) != 0;
1865 /* Set the GF_OMP_ATOMIC_SEQ_CST flag on G. */
1868 gimple_omp_atomic_set_seq_cst (gimple g
)
1870 if (gimple_code (g
) != GIMPLE_OMP_ATOMIC_LOAD
)
1871 GIMPLE_CHECK (g
, GIMPLE_OMP_ATOMIC_STORE
);
1872 g
->subcode
|= GF_OMP_ATOMIC_SEQ_CST
;
1876 /* Return the number of operands for statement GS. */
1878 static inline unsigned
1879 gimple_num_ops (const_gimple gs
)
1885 /* Set the number of operands for statement GS. */
1888 gimple_set_num_ops (gimple gs
, unsigned num_ops
)
1890 gs
->num_ops
= num_ops
;
1894 /* Return the array of operands for statement GS. */
1896 static inline tree
*
1897 gimple_ops (gimple gs
)
1901 /* All the tuples have their operand vector at the very bottom
1902 of the structure. Note that those structures that do not
1903 have an operand vector have a zero offset. */
1904 off
= gimple_ops_offset_
[gimple_statement_structure (gs
)];
1905 gcc_gimple_checking_assert (off
!= 0);
1907 return (tree
*) ((char *) gs
+ off
);
1911 /* Return operand I for statement GS. */
1914 gimple_op (const_gimple gs
, unsigned i
)
1916 if (gimple_has_ops (gs
))
1918 gcc_gimple_checking_assert (i
< gimple_num_ops (gs
));
1919 return gimple_ops (CONST_CAST_GIMPLE (gs
))[i
];
1925 /* Return a pointer to operand I for statement GS. */
1927 static inline tree
*
1928 gimple_op_ptr (const_gimple gs
, unsigned i
)
1930 if (gimple_has_ops (gs
))
1932 gcc_gimple_checking_assert (i
< gimple_num_ops (gs
));
1933 return gimple_ops (CONST_CAST_GIMPLE (gs
)) + i
;
1939 /* Set operand I of statement GS to OP. */
1942 gimple_set_op (gimple gs
, unsigned i
, tree op
)
1944 gcc_gimple_checking_assert (gimple_has_ops (gs
) && i
< gimple_num_ops (gs
));
1946 /* Note. It may be tempting to assert that OP matches
1947 is_gimple_operand, but that would be wrong. Different tuples
1948 accept slightly different sets of tree operands. Each caller
1949 should perform its own validation. */
1950 gimple_ops (gs
)[i
] = op
;
1953 /* Return true if GS is a GIMPLE_ASSIGN. */
1956 is_gimple_assign (const_gimple gs
)
1958 return gimple_code (gs
) == GIMPLE_ASSIGN
;
1961 /* Determine if expression CODE is one of the valid expressions that can
1962 be used on the RHS of GIMPLE assignments. */
1964 static inline enum gimple_rhs_class
1965 get_gimple_rhs_class (enum tree_code code
)
1967 return (enum gimple_rhs_class
) gimple_rhs_class_table
[(int) code
];
1970 /* Return the LHS of assignment statement GS. */
1973 gimple_assign_lhs (const_gimple gs
)
1975 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
1976 return gimple_op (gs
, 0);
1980 /* Return a pointer to the LHS of assignment statement GS. */
1982 static inline tree
*
1983 gimple_assign_lhs_ptr (const_gimple gs
)
1985 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
1986 return gimple_op_ptr (gs
, 0);
1990 /* Set LHS to be the LHS operand of assignment statement GS. */
1993 gimple_assign_set_lhs (gimple gs
, tree lhs
)
1995 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
1996 gimple_set_op (gs
, 0, lhs
);
1998 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
1999 SSA_NAME_DEF_STMT (lhs
) = gs
;
2003 /* Return the first operand on the RHS of assignment statement GS. */
2006 gimple_assign_rhs1 (const_gimple gs
)
2008 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2009 return gimple_op (gs
, 1);
2013 /* Return a pointer to the first operand on the RHS of assignment
2016 static inline tree
*
2017 gimple_assign_rhs1_ptr (const_gimple gs
)
2019 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2020 return gimple_op_ptr (gs
, 1);
2023 /* Set RHS to be the first operand on the RHS of assignment statement GS. */
2026 gimple_assign_set_rhs1 (gimple gs
, tree rhs
)
2028 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2030 gimple_set_op (gs
, 1, rhs
);
2034 /* Return the second operand on the RHS of assignment statement GS.
2035 If GS does not have two operands, NULL is returned instead. */
2038 gimple_assign_rhs2 (const_gimple gs
)
2040 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2042 if (gimple_num_ops (gs
) >= 3)
2043 return gimple_op (gs
, 2);
2049 /* Return a pointer to the second operand on the RHS of assignment
2052 static inline tree
*
2053 gimple_assign_rhs2_ptr (const_gimple gs
)
2055 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2056 return gimple_op_ptr (gs
, 2);
2060 /* Set RHS to be the second operand on the RHS of assignment statement GS. */
2063 gimple_assign_set_rhs2 (gimple gs
, tree rhs
)
2065 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2067 gimple_set_op (gs
, 2, rhs
);
2070 /* Return the third operand on the RHS of assignment statement GS.
2071 If GS does not have two operands, NULL is returned instead. */
2074 gimple_assign_rhs3 (const_gimple gs
)
2076 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2078 if (gimple_num_ops (gs
) >= 4)
2079 return gimple_op (gs
, 3);
2084 /* Return a pointer to the third operand on the RHS of assignment
2087 static inline tree
*
2088 gimple_assign_rhs3_ptr (const_gimple gs
)
2090 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2091 return gimple_op_ptr (gs
, 3);
2095 /* Set RHS to be the third operand on the RHS of assignment statement GS. */
2098 gimple_assign_set_rhs3 (gimple gs
, tree rhs
)
2100 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2102 gimple_set_op (gs
, 3, rhs
);
2105 /* A wrapper around gimple_assign_set_rhs_with_ops_1, for callers which expect
2106 to see only a maximum of two operands. */
2109 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator
*gsi
, enum tree_code code
,
2112 gimple_assign_set_rhs_with_ops_1 (gsi
, code
, op1
, op2
, NULL
);
2115 /* Returns true if GS is a nontemporal move. */
2118 gimple_assign_nontemporal_move_p (const_gimple gs
)
2120 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2121 return gs
->nontemporal_move
;
2124 /* Sets nontemporal move flag of GS to NONTEMPORAL. */
2127 gimple_assign_set_nontemporal_move (gimple gs
, bool nontemporal
)
2129 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2130 gs
->nontemporal_move
= nontemporal
;
2134 /* Return the code of the expression computed on the rhs of assignment
2135 statement GS. In case that the RHS is a single object, returns the
2136 tree code of the object. */
2138 static inline enum tree_code
2139 gimple_assign_rhs_code (const_gimple gs
)
2141 enum tree_code code
;
2142 GIMPLE_CHECK (gs
, GIMPLE_ASSIGN
);
2144 code
= (enum tree_code
) gs
->subcode
;
2145 /* While we initially set subcode to the TREE_CODE of the rhs for
2146 GIMPLE_SINGLE_RHS assigns we do not update that subcode to stay
2147 in sync when we rewrite stmts into SSA form or do SSA propagations. */
2148 if (get_gimple_rhs_class (code
) == GIMPLE_SINGLE_RHS
)
2149 code
= TREE_CODE (gimple_assign_rhs1 (gs
));
2155 /* Set CODE to be the code for the expression computed on the RHS of
2159 gimple_assign_set_rhs_code (gimple s
, enum tree_code code
)
2161 GIMPLE_CHECK (s
, GIMPLE_ASSIGN
);
2166 /* Return the gimple rhs class of the code of the expression computed on
2167 the rhs of assignment statement GS.
2168 This will never return GIMPLE_INVALID_RHS. */
2170 static inline enum gimple_rhs_class
2171 gimple_assign_rhs_class (const_gimple gs
)
2173 return get_gimple_rhs_class (gimple_assign_rhs_code (gs
));
2176 /* Return true if GS is an assignment with a singleton RHS, i.e.,
2177 there is no operator associated with the assignment itself.
2178 Unlike gimple_assign_copy_p, this predicate returns true for
2179 any RHS operand, including those that perform an operation
2180 and do not have the semantics of a copy, such as COND_EXPR. */
2183 gimple_assign_single_p (gimple gs
)
2185 return (is_gimple_assign (gs
)
2186 && gimple_assign_rhs_class (gs
) == GIMPLE_SINGLE_RHS
);
2189 /* Return true if GS performs a store to its lhs. */
2192 gimple_store_p (gimple gs
)
2194 tree lhs
= gimple_get_lhs (gs
);
2195 return lhs
&& !is_gimple_reg (lhs
);
2198 /* Return true if GS is an assignment that loads from its rhs1. */
2201 gimple_assign_load_p (gimple gs
)
2204 if (!gimple_assign_single_p (gs
))
2206 rhs
= gimple_assign_rhs1 (gs
);
2207 if (TREE_CODE (rhs
) == WITH_SIZE_EXPR
)
2209 rhs
= get_base_address (rhs
);
2210 return (DECL_P (rhs
)
2211 || TREE_CODE (rhs
) == MEM_REF
|| TREE_CODE (rhs
) == TARGET_MEM_REF
);
2215 /* Return true if S is a type-cast assignment. */
2218 gimple_assign_cast_p (gimple s
)
2220 if (is_gimple_assign (s
))
2222 enum tree_code sc
= gimple_assign_rhs_code (s
);
2223 return CONVERT_EXPR_CODE_P (sc
)
2224 || sc
== VIEW_CONVERT_EXPR
2225 || sc
== FIX_TRUNC_EXPR
;
2231 /* Return true if S is a clobber statement. */
2234 gimple_clobber_p (gimple s
)
2236 return gimple_assign_single_p (s
)
2237 && TREE_CLOBBER_P (gimple_assign_rhs1 (s
));
2240 /* Return true if GS is a GIMPLE_CALL. */
2243 is_gimple_call (const_gimple gs
)
2245 return gimple_code (gs
) == GIMPLE_CALL
;
2248 /* Return the LHS of call statement GS. */
2251 gimple_call_lhs (const_gimple gs
)
2253 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2254 return gimple_op (gs
, 0);
2258 /* Return a pointer to the LHS of call statement GS. */
2260 static inline tree
*
2261 gimple_call_lhs_ptr (const_gimple gs
)
2263 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2264 return gimple_op_ptr (gs
, 0);
2268 /* Set LHS to be the LHS operand of call statement GS. */
2271 gimple_call_set_lhs (gimple gs
, tree lhs
)
2273 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2274 gimple_set_op (gs
, 0, lhs
);
2275 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
2276 SSA_NAME_DEF_STMT (lhs
) = gs
;
2280 /* Return true if call GS calls an internal-only function, as enumerated
2284 gimple_call_internal_p (const_gimple gs
)
2286 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2287 return (gs
->subcode
& GF_CALL_INTERNAL
) != 0;
2291 /* Return true if call GS is marked as instrumented by
2292 Pointer Bounds Checker. */
2295 gimple_call_with_bounds_p (const_gimple gs
)
2297 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2298 return (gs
->subcode
& GF_CALL_WITH_BOUNDS
) != 0;
2302 /* If INSTRUMENTED_P is true, marm statement GS as instrumented by
2303 Pointer Bounds Checker. */
2306 gimple_call_set_with_bounds (gimple gs
, bool with_bounds
)
2308 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2310 gs
->subcode
|= GF_CALL_WITH_BOUNDS
;
2312 gs
->subcode
&= ~GF_CALL_WITH_BOUNDS
;
2316 /* Return the target of internal call GS. */
2318 static inline enum internal_fn
2319 gimple_call_internal_fn (const_gimple gs
)
2321 gcc_gimple_checking_assert (gimple_call_internal_p (gs
));
2322 return static_cast <const gimple_statement_call
*> (gs
)->u
.internal_fn
;
2326 /* Return the function type of the function called by GS. */
2329 gimple_call_fntype (const_gimple gs
)
2331 const gimple_statement_call
*call_stmt
=
2332 as_a
<const gimple_statement_call
> (gs
);
2333 if (gimple_call_internal_p (gs
))
2335 return call_stmt
->u
.fntype
;
2338 /* Set the type of the function called by GS to FNTYPE. */
2341 gimple_call_set_fntype (gimple gs
, tree fntype
)
2343 gimple_statement_call
*call_stmt
= as_a
<gimple_statement_call
> (gs
);
2344 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
2345 call_stmt
->u
.fntype
= fntype
;
2349 /* Return the tree node representing the function called by call
2353 gimple_call_fn (const_gimple gs
)
2355 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2356 return gimple_op (gs
, 1);
2359 /* Return a pointer to the tree node representing the function called by call
2362 static inline tree
*
2363 gimple_call_fn_ptr (const_gimple gs
)
2365 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2366 return gimple_op_ptr (gs
, 1);
2370 /* Set FN to be the function called by call statement GS. */
2373 gimple_call_set_fn (gimple gs
, tree fn
)
2375 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2376 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
2377 gimple_set_op (gs
, 1, fn
);
2381 /* Set FNDECL to be the function called by call statement GS. */
2384 gimple_call_set_fndecl (gimple gs
, tree decl
)
2386 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2387 gcc_gimple_checking_assert (!gimple_call_internal_p (gs
));
2388 gimple_set_op (gs
, 1, build_fold_addr_expr_loc (gimple_location (gs
), decl
));
2392 /* Set internal function FN to be the function called by call statement GS. */
2395 gimple_call_set_internal_fn (gimple gs
, enum internal_fn fn
)
2397 gimple_statement_call
*call_stmt
= as_a
<gimple_statement_call
> (gs
);
2398 gcc_gimple_checking_assert (gimple_call_internal_p (gs
));
2399 call_stmt
->u
.internal_fn
= fn
;
2403 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
2404 Otherwise return NULL. This function is analogous to
2405 get_callee_fndecl in tree land. */
2408 gimple_call_fndecl (const_gimple gs
)
2410 return gimple_call_addr_fndecl (gimple_call_fn (gs
));
2414 /* Return the type returned by call statement GS. */
2417 gimple_call_return_type (const_gimple gs
)
2419 tree type
= gimple_call_fntype (gs
);
2421 if (type
== NULL_TREE
)
2422 return TREE_TYPE (gimple_call_lhs (gs
));
2424 /* The type returned by a function is the type of its
2426 return TREE_TYPE (type
);
2430 /* Return the static chain for call statement GS. */
2433 gimple_call_chain (const_gimple gs
)
2435 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2436 return gimple_op (gs
, 2);
2440 /* Return a pointer to the static chain for call statement GS. */
2442 static inline tree
*
2443 gimple_call_chain_ptr (const_gimple gs
)
2445 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2446 return gimple_op_ptr (gs
, 2);
2449 /* Set CHAIN to be the static chain for call statement GS. */
2452 gimple_call_set_chain (gimple gs
, tree chain
)
2454 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2456 gimple_set_op (gs
, 2, chain
);
2460 /* Return the number of arguments used by call statement GS. */
2462 static inline unsigned
2463 gimple_call_num_args (const_gimple gs
)
2466 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2467 num_ops
= gimple_num_ops (gs
);
2472 /* Return the argument at position INDEX for call statement GS. */
2475 gimple_call_arg (const_gimple gs
, unsigned index
)
2477 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2478 return gimple_op (gs
, index
+ 3);
2482 /* Return a pointer to the argument at position INDEX for call
2485 static inline tree
*
2486 gimple_call_arg_ptr (const_gimple gs
, unsigned index
)
2488 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2489 return gimple_op_ptr (gs
, index
+ 3);
2493 /* Set ARG to be the argument at position INDEX for call statement GS. */
2496 gimple_call_set_arg (gimple gs
, unsigned index
, tree arg
)
2498 GIMPLE_CHECK (gs
, GIMPLE_CALL
);
2499 gimple_set_op (gs
, index
+ 3, arg
);
2503 /* If TAIL_P is true, mark call statement S as being a tail call
2504 (i.e., a call just before the exit of a function). These calls are
2505 candidate for tail call optimization. */
2508 gimple_call_set_tail (gimple s
, bool tail_p
)
2510 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2512 s
->subcode
|= GF_CALL_TAILCALL
;
2514 s
->subcode
&= ~GF_CALL_TAILCALL
;
2518 /* Return true if GIMPLE_CALL S is marked as a tail call. */
2521 gimple_call_tail_p (gimple s
)
2523 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2524 return (s
->subcode
& GF_CALL_TAILCALL
) != 0;
2528 /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
2529 slot optimization. This transformation uses the target of the call
2530 expansion as the return slot for calls that return in memory. */
2533 gimple_call_set_return_slot_opt (gimple s
, bool return_slot_opt_p
)
2535 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2536 if (return_slot_opt_p
)
2537 s
->subcode
|= GF_CALL_RETURN_SLOT_OPT
;
2539 s
->subcode
&= ~GF_CALL_RETURN_SLOT_OPT
;
2543 /* Return true if S is marked for return slot optimization. */
2546 gimple_call_return_slot_opt_p (gimple s
)
2548 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2549 return (s
->subcode
& GF_CALL_RETURN_SLOT_OPT
) != 0;
2553 /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
2554 thunk to the thunked-to function. */
2557 gimple_call_set_from_thunk (gimple s
, bool from_thunk_p
)
2559 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2561 s
->subcode
|= GF_CALL_FROM_THUNK
;
2563 s
->subcode
&= ~GF_CALL_FROM_THUNK
;
2567 /* Return true if GIMPLE_CALL S is a jump from a thunk. */
2570 gimple_call_from_thunk_p (gimple s
)
2572 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2573 return (s
->subcode
& GF_CALL_FROM_THUNK
) != 0;
2577 /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
2578 argument pack in its argument list. */
2581 gimple_call_set_va_arg_pack (gimple s
, bool pass_arg_pack_p
)
2583 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2584 if (pass_arg_pack_p
)
2585 s
->subcode
|= GF_CALL_VA_ARG_PACK
;
2587 s
->subcode
&= ~GF_CALL_VA_ARG_PACK
;
2591 /* Return true if GIMPLE_CALL S is a stdarg call that needs the
2592 argument pack in its argument list. */
2595 gimple_call_va_arg_pack_p (gimple s
)
2597 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2598 return (s
->subcode
& GF_CALL_VA_ARG_PACK
) != 0;
2602 /* Return true if S is a noreturn call. */
2605 gimple_call_noreturn_p (gimple s
)
2607 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2608 return (gimple_call_flags (s
) & ECF_NORETURN
) != 0;
2612 /* If NOTHROW_P is true, GIMPLE_CALL S is a call that is known to not throw
2613 even if the called function can throw in other cases. */
2616 gimple_call_set_nothrow (gimple s
, bool nothrow_p
)
2618 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2620 s
->subcode
|= GF_CALL_NOTHROW
;
2622 s
->subcode
&= ~GF_CALL_NOTHROW
;
2625 /* Return true if S is a nothrow call. */
2628 gimple_call_nothrow_p (gimple s
)
2630 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2631 return (gimple_call_flags (s
) & ECF_NOTHROW
) != 0;
2634 /* If FOR_VAR is true, GIMPLE_CALL S is a call to builtin_alloca that
2635 is known to be emitted for VLA objects. Those are wrapped by
2636 stack_save/stack_restore calls and hence can't lead to unbounded
2637 stack growth even when they occur in loops. */
2640 gimple_call_set_alloca_for_var (gimple s
, bool for_var
)
2642 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2644 s
->subcode
|= GF_CALL_ALLOCA_FOR_VAR
;
2646 s
->subcode
&= ~GF_CALL_ALLOCA_FOR_VAR
;
2649 /* Return true of S is a call to builtin_alloca emitted for VLA objects. */
2652 gimple_call_alloca_for_var_p (gimple s
)
2654 GIMPLE_CHECK (s
, GIMPLE_CALL
);
2655 return (s
->subcode
& GF_CALL_ALLOCA_FOR_VAR
) != 0;
2658 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
2661 gimple_call_copy_flags (gimple dest_call
, gimple orig_call
)
2663 GIMPLE_CHECK (dest_call
, GIMPLE_CALL
);
2664 GIMPLE_CHECK (orig_call
, GIMPLE_CALL
);
2665 dest_call
->subcode
= orig_call
->subcode
;
2669 /* Return a pointer to the points-to solution for the set of call-used
2670 variables of the call CALL. */
2672 static inline struct pt_solution
*
2673 gimple_call_use_set (gimple call
)
2675 gimple_statement_call
*call_stmt
= as_a
<gimple_statement_call
> (call
);
2676 return &call_stmt
->call_used
;
2680 /* Return a pointer to the points-to solution for the set of call-used
2681 variables of the call CALL. */
2683 static inline struct pt_solution
*
2684 gimple_call_clobber_set (gimple call
)
2686 gimple_statement_call
*call_stmt
= as_a
<gimple_statement_call
> (call
);
2687 return &call_stmt
->call_clobbered
;
2691 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
2695 gimple_has_lhs (gimple stmt
)
2697 return (is_gimple_assign (stmt
)
2698 || (is_gimple_call (stmt
)
2699 && gimple_call_lhs (stmt
) != NULL_TREE
));
2703 /* Return the code of the predicate computed by conditional statement GS. */
2705 static inline enum tree_code
2706 gimple_cond_code (const_gimple gs
)
2708 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2709 return (enum tree_code
) gs
->subcode
;
2713 /* Set CODE to be the predicate code for the conditional statement GS. */
2716 gimple_cond_set_code (gimple gs
, enum tree_code code
)
2718 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2723 /* Return the LHS of the predicate computed by conditional statement GS. */
2726 gimple_cond_lhs (const_gimple gs
)
2728 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2729 return gimple_op (gs
, 0);
2732 /* Return the pointer to the LHS of the predicate computed by conditional
2735 static inline tree
*
2736 gimple_cond_lhs_ptr (const_gimple gs
)
2738 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2739 return gimple_op_ptr (gs
, 0);
2742 /* Set LHS to be the LHS operand of the predicate computed by
2743 conditional statement GS. */
2746 gimple_cond_set_lhs (gimple gs
, tree lhs
)
2748 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2749 gimple_set_op (gs
, 0, lhs
);
2753 /* Return the RHS operand of the predicate computed by conditional GS. */
2756 gimple_cond_rhs (const_gimple gs
)
2758 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2759 return gimple_op (gs
, 1);
2762 /* Return the pointer to the RHS operand of the predicate computed by
2765 static inline tree
*
2766 gimple_cond_rhs_ptr (const_gimple gs
)
2768 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2769 return gimple_op_ptr (gs
, 1);
2773 /* Set RHS to be the RHS operand of the predicate computed by
2774 conditional statement GS. */
2777 gimple_cond_set_rhs (gimple gs
, tree rhs
)
2779 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2780 gimple_set_op (gs
, 1, rhs
);
2784 /* Return the label used by conditional statement GS when its
2785 predicate evaluates to true. */
2788 gimple_cond_true_label (const_gimple gs
)
2790 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2791 return gimple_op (gs
, 2);
2795 /* Set LABEL to be the label used by conditional statement GS when its
2796 predicate evaluates to true. */
2799 gimple_cond_set_true_label (gimple gs
, tree label
)
2801 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2802 gimple_set_op (gs
, 2, label
);
2806 /* Set LABEL to be the label used by conditional statement GS when its
2807 predicate evaluates to false. */
2810 gimple_cond_set_false_label (gimple gs
, tree label
)
2812 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2813 gimple_set_op (gs
, 3, label
);
2817 /* Return the label used by conditional statement GS when its
2818 predicate evaluates to false. */
2821 gimple_cond_false_label (const_gimple gs
)
2823 GIMPLE_CHECK (gs
, GIMPLE_COND
);
2824 return gimple_op (gs
, 3);
2828 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */
2831 gimple_cond_make_false (gimple gs
)
2833 gimple_cond_set_lhs (gs
, boolean_true_node
);
2834 gimple_cond_set_rhs (gs
, boolean_false_node
);
2835 gs
->subcode
= EQ_EXPR
;
2839 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */
2842 gimple_cond_make_true (gimple gs
)
2844 gimple_cond_set_lhs (gs
, boolean_true_node
);
2845 gimple_cond_set_rhs (gs
, boolean_true_node
);
2846 gs
->subcode
= EQ_EXPR
;
2849 /* Check if conditional statemente GS is of the form 'if (1 == 1)',
2850 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
2853 gimple_cond_true_p (const_gimple gs
)
2855 tree lhs
= gimple_cond_lhs (gs
);
2856 tree rhs
= gimple_cond_rhs (gs
);
2857 enum tree_code code
= gimple_cond_code (gs
);
2859 if (lhs
!= boolean_true_node
&& lhs
!= boolean_false_node
)
2862 if (rhs
!= boolean_true_node
&& rhs
!= boolean_false_node
)
2865 if (code
== NE_EXPR
&& lhs
!= rhs
)
2868 if (code
== EQ_EXPR
&& lhs
== rhs
)
2874 /* Check if conditional statement GS is of the form 'if (1 != 1)',
2875 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
2878 gimple_cond_false_p (const_gimple gs
)
2880 tree lhs
= gimple_cond_lhs (gs
);
2881 tree rhs
= gimple_cond_rhs (gs
);
2882 enum tree_code code
= gimple_cond_code (gs
);
2884 if (lhs
!= boolean_true_node
&& lhs
!= boolean_false_node
)
2887 if (rhs
!= boolean_true_node
&& rhs
!= boolean_false_node
)
2890 if (code
== NE_EXPR
&& lhs
== rhs
)
2893 if (code
== EQ_EXPR
&& lhs
!= rhs
)
2899 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
2902 gimple_cond_set_condition (gimple stmt
, enum tree_code code
, tree lhs
, tree rhs
)
2904 gimple_cond_set_code (stmt
, code
);
2905 gimple_cond_set_lhs (stmt
, lhs
);
2906 gimple_cond_set_rhs (stmt
, rhs
);
2909 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
2912 gimple_label_label (const_gimple gs
)
2914 GIMPLE_CHECK (gs
, GIMPLE_LABEL
);
2915 return gimple_op (gs
, 0);
2919 /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
2923 gimple_label_set_label (gimple gs
, tree label
)
2925 GIMPLE_CHECK (gs
, GIMPLE_LABEL
);
2926 gimple_set_op (gs
, 0, label
);
2930 /* Return the destination of the unconditional jump GS. */
2933 gimple_goto_dest (const_gimple gs
)
2935 GIMPLE_CHECK (gs
, GIMPLE_GOTO
);
2936 return gimple_op (gs
, 0);
2940 /* Set DEST to be the destination of the unconditonal jump GS. */
2943 gimple_goto_set_dest (gimple gs
, tree dest
)
2945 GIMPLE_CHECK (gs
, GIMPLE_GOTO
);
2946 gimple_set_op (gs
, 0, dest
);
2950 /* Return the variables declared in the GIMPLE_BIND statement GS. */
2953 gimple_bind_vars (const_gimple gs
)
2955 const gimple_statement_bind
*bind_stmt
=
2956 as_a
<const gimple_statement_bind
> (gs
);
2957 return bind_stmt
->vars
;
2961 /* Set VARS to be the set of variables declared in the GIMPLE_BIND
2965 gimple_bind_set_vars (gimple gs
, tree vars
)
2967 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
2968 bind_stmt
->vars
= vars
;
2972 /* Append VARS to the set of variables declared in the GIMPLE_BIND
2976 gimple_bind_append_vars (gimple gs
, tree vars
)
2978 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
2979 bind_stmt
->vars
= chainon (bind_stmt
->vars
, vars
);
2983 static inline gimple_seq
*
2984 gimple_bind_body_ptr (gimple gs
)
2986 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
2987 return &bind_stmt
->body
;
2990 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
2992 static inline gimple_seq
2993 gimple_bind_body (gimple gs
)
2995 return *gimple_bind_body_ptr (gs
);
2999 /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
3003 gimple_bind_set_body (gimple gs
, gimple_seq seq
)
3005 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
3006 bind_stmt
->body
= seq
;
3010 /* Append a statement to the end of a GIMPLE_BIND's body. */
3013 gimple_bind_add_stmt (gimple gs
, gimple stmt
)
3015 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
3016 gimple_seq_add_stmt (&bind_stmt
->body
, stmt
);
3020 /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
3023 gimple_bind_add_seq (gimple gs
, gimple_seq seq
)
3025 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
3026 gimple_seq_add_seq (&bind_stmt
->body
, seq
);
3030 /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
3031 GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
3034 gimple_bind_block (const_gimple gs
)
3036 const gimple_statement_bind
*bind_stmt
=
3037 as_a
<const gimple_statement_bind
> (gs
);
3038 return bind_stmt
->block
;
3042 /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
3046 gimple_bind_set_block (gimple gs
, tree block
)
3048 gimple_statement_bind
*bind_stmt
= as_a
<gimple_statement_bind
> (gs
);
3049 gcc_gimple_checking_assert (block
== NULL_TREE
3050 || TREE_CODE (block
) == BLOCK
);
3051 bind_stmt
->block
= block
;
3055 /* Return the number of input operands for GIMPLE_ASM GS. */
3057 static inline unsigned
3058 gimple_asm_ninputs (const_gimple gs
)
3060 const gimple_statement_asm
*asm_stmt
=
3061 as_a
<const gimple_statement_asm
> (gs
);
3062 return asm_stmt
->ni
;
3066 /* Return the number of output operands for GIMPLE_ASM GS. */
3068 static inline unsigned
3069 gimple_asm_noutputs (const_gimple gs
)
3071 const gimple_statement_asm
*asm_stmt
=
3072 as_a
<const gimple_statement_asm
> (gs
);
3073 return asm_stmt
->no
;
3077 /* Return the number of clobber operands for GIMPLE_ASM GS. */
3079 static inline unsigned
3080 gimple_asm_nclobbers (const_gimple gs
)
3082 const gimple_statement_asm
*asm_stmt
=
3083 as_a
<const gimple_statement_asm
> (gs
);
3084 return asm_stmt
->nc
;
3087 /* Return the number of label operands for GIMPLE_ASM GS. */
3089 static inline unsigned
3090 gimple_asm_nlabels (const_gimple gs
)
3092 const gimple_statement_asm
*asm_stmt
=
3093 as_a
<const gimple_statement_asm
> (gs
);
3094 return asm_stmt
->nl
;
3097 /* Return input operand INDEX of GIMPLE_ASM GS. */
3100 gimple_asm_input_op (const_gimple gs
, unsigned index
)
3102 const gimple_statement_asm
*asm_stmt
=
3103 as_a
<const gimple_statement_asm
> (gs
);
3104 gcc_gimple_checking_assert (index
< asm_stmt
->ni
);
3105 return gimple_op (gs
, index
+ asm_stmt
->no
);
3108 /* Return a pointer to input operand INDEX of GIMPLE_ASM GS. */
3110 static inline tree
*
3111 gimple_asm_input_op_ptr (const_gimple gs
, unsigned index
)
3113 const gimple_statement_asm
*asm_stmt
=
3114 as_a
<const gimple_statement_asm
> (gs
);
3115 gcc_gimple_checking_assert (index
< asm_stmt
->ni
);
3116 return gimple_op_ptr (gs
, index
+ asm_stmt
->no
);
3120 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS. */
3123 gimple_asm_set_input_op (gimple gs
, unsigned index
, tree in_op
)
3125 gimple_statement_asm
*asm_stmt
= as_a
<gimple_statement_asm
> (gs
);
3126 gcc_gimple_checking_assert (index
< asm_stmt
->ni
3127 && TREE_CODE (in_op
) == TREE_LIST
);
3128 gimple_set_op (gs
, index
+ asm_stmt
->no
, in_op
);
3132 /* Return output operand INDEX of GIMPLE_ASM GS. */
3135 gimple_asm_output_op (const_gimple gs
, unsigned index
)
3137 const gimple_statement_asm
*asm_stmt
=
3138 as_a
<const gimple_statement_asm
> (gs
);
3139 gcc_gimple_checking_assert (index
< asm_stmt
->no
);
3140 return gimple_op (gs
, index
);
3143 /* Return a pointer to output operand INDEX of GIMPLE_ASM GS. */
3145 static inline tree
*
3146 gimple_asm_output_op_ptr (const_gimple gs
, unsigned index
)
3148 const gimple_statement_asm
*asm_stmt
=
3149 as_a
<const gimple_statement_asm
> (gs
);
3150 gcc_gimple_checking_assert (index
< asm_stmt
->no
);
3151 return gimple_op_ptr (gs
, index
);
3155 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS. */
3158 gimple_asm_set_output_op (gimple gs
, unsigned index
, tree out_op
)
3160 gimple_statement_asm
*asm_stmt
= as_a
<gimple_statement_asm
> (gs
);
3161 gcc_gimple_checking_assert (index
< asm_stmt
->no
3162 && TREE_CODE (out_op
) == TREE_LIST
);
3163 gimple_set_op (gs
, index
, out_op
);
3167 /* Return clobber operand INDEX of GIMPLE_ASM GS. */
3170 gimple_asm_clobber_op (const_gimple gs
, unsigned index
)
3172 const gimple_statement_asm
*asm_stmt
=
3173 as_a
<const gimple_statement_asm
> (gs
);
3174 gcc_gimple_checking_assert (index
< asm_stmt
->nc
);
3175 return gimple_op (gs
, index
+ asm_stmt
->ni
+ asm_stmt
->no
);
3179 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS. */
3182 gimple_asm_set_clobber_op (gimple gs
, unsigned index
, tree clobber_op
)
3184 gimple_statement_asm
*asm_stmt
= as_a
<gimple_statement_asm
> (gs
);
3185 gcc_gimple_checking_assert (index
< asm_stmt
->nc
3186 && TREE_CODE (clobber_op
) == TREE_LIST
);
3187 gimple_set_op (gs
, index
+ asm_stmt
->ni
+ asm_stmt
->no
, clobber_op
);
3190 /* Return label operand INDEX of GIMPLE_ASM GS. */
3193 gimple_asm_label_op (const_gimple gs
, unsigned index
)
3195 const gimple_statement_asm
*asm_stmt
=
3196 as_a
<const gimple_statement_asm
> (gs
);
3197 gcc_gimple_checking_assert (index
< asm_stmt
->nl
);
3198 return gimple_op (gs
, index
+ asm_stmt
->ni
+ asm_stmt
->nc
);
3201 /* Set LABEL_OP to be label operand INDEX in GIMPLE_ASM GS. */
3204 gimple_asm_set_label_op (gimple gs
, unsigned index
, tree label_op
)
3206 gimple_statement_asm
*asm_stmt
= as_a
<gimple_statement_asm
> (gs
);
3207 gcc_gimple_checking_assert (index
< asm_stmt
->nl
3208 && TREE_CODE (label_op
) == TREE_LIST
);
3209 gimple_set_op (gs
, index
+ asm_stmt
->ni
+ asm_stmt
->nc
, label_op
);
3212 /* Return the string representing the assembly instruction in
3215 static inline const char *
3216 gimple_asm_string (const_gimple gs
)
3218 const gimple_statement_asm
*asm_stmt
=
3219 as_a
<const gimple_statement_asm
> (gs
);
3220 return asm_stmt
->string
;
3224 /* Return true if GS is an asm statement marked volatile. */
3227 gimple_asm_volatile_p (const_gimple gs
)
3229 GIMPLE_CHECK (gs
, GIMPLE_ASM
);
3230 return (gs
->subcode
& GF_ASM_VOLATILE
) != 0;
3234 /* If VOLATLE_P is true, mark asm statement GS as volatile. */
3237 gimple_asm_set_volatile (gimple gs
, bool volatile_p
)
3239 GIMPLE_CHECK (gs
, GIMPLE_ASM
);
3241 gs
->subcode
|= GF_ASM_VOLATILE
;
3243 gs
->subcode
&= ~GF_ASM_VOLATILE
;
3247 /* If INPUT_P is true, mark asm GS as an ASM_INPUT. */
3250 gimple_asm_set_input (gimple gs
, bool input_p
)
3252 GIMPLE_CHECK (gs
, GIMPLE_ASM
);
3254 gs
->subcode
|= GF_ASM_INPUT
;
3256 gs
->subcode
&= ~GF_ASM_INPUT
;
3260 /* Return true if asm GS is an ASM_INPUT. */
3263 gimple_asm_input_p (const_gimple gs
)
3265 GIMPLE_CHECK (gs
, GIMPLE_ASM
);
3266 return (gs
->subcode
& GF_ASM_INPUT
) != 0;
3270 /* Return the types handled by GIMPLE_CATCH statement GS. */
3273 gimple_catch_types (const_gimple gs
)
3275 const gimple_statement_catch
*catch_stmt
=
3276 as_a
<const gimple_statement_catch
> (gs
);
3277 return catch_stmt
->types
;
3281 /* Return a pointer to the types handled by GIMPLE_CATCH statement GS. */
3283 static inline tree
*
3284 gimple_catch_types_ptr (gimple gs
)
3286 gimple_statement_catch
*catch_stmt
= as_a
<gimple_statement_catch
> (gs
);
3287 return &catch_stmt
->types
;
3291 /* Return a pointer to the GIMPLE sequence representing the body of
3292 the handler of GIMPLE_CATCH statement GS. */
3294 static inline gimple_seq
*
3295 gimple_catch_handler_ptr (gimple gs
)
3297 gimple_statement_catch
*catch_stmt
= as_a
<gimple_statement_catch
> (gs
);
3298 return &catch_stmt
->handler
;
3302 /* Return the GIMPLE sequence representing the body of the handler of
3303 GIMPLE_CATCH statement GS. */
3305 static inline gimple_seq
3306 gimple_catch_handler (gimple gs
)
3308 return *gimple_catch_handler_ptr (gs
);
3312 /* Set T to be the set of types handled by GIMPLE_CATCH GS. */
3315 gimple_catch_set_types (gimple gs
, tree t
)
3317 gimple_statement_catch
*catch_stmt
= as_a
<gimple_statement_catch
> (gs
);
3318 catch_stmt
->types
= t
;
3322 /* Set HANDLER to be the body of GIMPLE_CATCH GS. */
3325 gimple_catch_set_handler (gimple gs
, gimple_seq handler
)
3327 gimple_statement_catch
*catch_stmt
= as_a
<gimple_statement_catch
> (gs
);
3328 catch_stmt
->handler
= handler
;
3332 /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
3335 gimple_eh_filter_types (const_gimple gs
)
3337 const gimple_statement_eh_filter
*eh_filter_stmt
=
3338 as_a
<const gimple_statement_eh_filter
> (gs
);
3339 return eh_filter_stmt
->types
;
3343 /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
3346 static inline tree
*
3347 gimple_eh_filter_types_ptr (gimple gs
)
3349 gimple_statement_eh_filter
*eh_filter_stmt
=
3350 as_a
<gimple_statement_eh_filter
> (gs
);
3351 return &eh_filter_stmt
->types
;
3355 /* Return a pointer to the sequence of statement to execute when
3356 GIMPLE_EH_FILTER statement fails. */
3358 static inline gimple_seq
*
3359 gimple_eh_filter_failure_ptr (gimple gs
)
3361 gimple_statement_eh_filter
*eh_filter_stmt
=
3362 as_a
<gimple_statement_eh_filter
> (gs
);
3363 return &eh_filter_stmt
->failure
;
3367 /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
3370 static inline gimple_seq
3371 gimple_eh_filter_failure (gimple gs
)
3373 return *gimple_eh_filter_failure_ptr (gs
);
3377 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS. */
3380 gimple_eh_filter_set_types (gimple gs
, tree types
)
3382 gimple_statement_eh_filter
*eh_filter_stmt
=
3383 as_a
<gimple_statement_eh_filter
> (gs
);
3384 eh_filter_stmt
->types
= types
;
3388 /* Set FAILURE to be the sequence of statements to execute on failure
3389 for GIMPLE_EH_FILTER GS. */
3392 gimple_eh_filter_set_failure (gimple gs
, gimple_seq failure
)
3394 gimple_statement_eh_filter
*eh_filter_stmt
=
3395 as_a
<gimple_statement_eh_filter
> (gs
);
3396 eh_filter_stmt
->failure
= failure
;
3399 /* Get the function decl to be called by the MUST_NOT_THROW region. */
3402 gimple_eh_must_not_throw_fndecl (gimple gs
)
3404 gimple_statement_eh_mnt
*eh_mnt_stmt
= as_a
<gimple_statement_eh_mnt
> (gs
);
3405 return eh_mnt_stmt
->fndecl
;
3408 /* Set the function decl to be called by GS to DECL. */
3411 gimple_eh_must_not_throw_set_fndecl (gimple gs
, tree decl
)
3413 gimple_statement_eh_mnt
*eh_mnt_stmt
= as_a
<gimple_statement_eh_mnt
> (gs
);
3414 eh_mnt_stmt
->fndecl
= decl
;
3417 /* GIMPLE_EH_ELSE accessors. */
3419 static inline gimple_seq
*
3420 gimple_eh_else_n_body_ptr (gimple gs
)
3422 gimple_statement_eh_else
*eh_else_stmt
=
3423 as_a
<gimple_statement_eh_else
> (gs
);
3424 return &eh_else_stmt
->n_body
;
3427 static inline gimple_seq
3428 gimple_eh_else_n_body (gimple gs
)
3430 return *gimple_eh_else_n_body_ptr (gs
);
3433 static inline gimple_seq
*
3434 gimple_eh_else_e_body_ptr (gimple gs
)
3436 gimple_statement_eh_else
*eh_else_stmt
=
3437 as_a
<gimple_statement_eh_else
> (gs
);
3438 return &eh_else_stmt
->e_body
;
3441 static inline gimple_seq
3442 gimple_eh_else_e_body (gimple gs
)
3444 return *gimple_eh_else_e_body_ptr (gs
);
3448 gimple_eh_else_set_n_body (gimple gs
, gimple_seq seq
)
3450 gimple_statement_eh_else
*eh_else_stmt
=
3451 as_a
<gimple_statement_eh_else
> (gs
);
3452 eh_else_stmt
->n_body
= seq
;
3456 gimple_eh_else_set_e_body (gimple gs
, gimple_seq seq
)
3458 gimple_statement_eh_else
*eh_else_stmt
=
3459 as_a
<gimple_statement_eh_else
> (gs
);
3460 eh_else_stmt
->e_body
= seq
;
3463 /* GIMPLE_TRY accessors. */
3465 /* Return the kind of try block represented by GIMPLE_TRY GS. This is
3466 either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
3468 static inline enum gimple_try_flags
3469 gimple_try_kind (const_gimple gs
)
3471 GIMPLE_CHECK (gs
, GIMPLE_TRY
);
3472 return (enum gimple_try_flags
) (gs
->subcode
& GIMPLE_TRY_KIND
);
3476 /* Set the kind of try block represented by GIMPLE_TRY GS. */
3479 gimple_try_set_kind (gimple gs
, enum gimple_try_flags kind
)
3481 GIMPLE_CHECK (gs
, GIMPLE_TRY
);
3482 gcc_gimple_checking_assert (kind
== GIMPLE_TRY_CATCH
3483 || kind
== GIMPLE_TRY_FINALLY
);
3484 if (gimple_try_kind (gs
) != kind
)
3485 gs
->subcode
= (unsigned int) kind
;
3489 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
3492 gimple_try_catch_is_cleanup (const_gimple gs
)
3494 gcc_gimple_checking_assert (gimple_try_kind (gs
) == GIMPLE_TRY_CATCH
);
3495 return (gs
->subcode
& GIMPLE_TRY_CATCH_IS_CLEANUP
) != 0;
3499 /* Return a pointer to the sequence of statements used as the
3500 body for GIMPLE_TRY GS. */
3502 static inline gimple_seq
*
3503 gimple_try_eval_ptr (gimple gs
)
3505 gimple_statement_try
*try_stmt
= as_a
<gimple_statement_try
> (gs
);
3506 return &try_stmt
->eval
;
3510 /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
3512 static inline gimple_seq
3513 gimple_try_eval (gimple gs
)
3515 return *gimple_try_eval_ptr (gs
);
3519 /* Return a pointer to the sequence of statements used as the cleanup body for
3522 static inline gimple_seq
*
3523 gimple_try_cleanup_ptr (gimple gs
)
3525 gimple_statement_try
*try_stmt
= as_a
<gimple_statement_try
> (gs
);
3526 return &try_stmt
->cleanup
;
3530 /* Return the sequence of statements used as the cleanup body for
3533 static inline gimple_seq
3534 gimple_try_cleanup (gimple gs
)
3536 return *gimple_try_cleanup_ptr (gs
);
3540 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
3543 gimple_try_set_catch_is_cleanup (gimple g
, bool catch_is_cleanup
)
3545 gcc_gimple_checking_assert (gimple_try_kind (g
) == GIMPLE_TRY_CATCH
);
3546 if (catch_is_cleanup
)
3547 g
->subcode
|= GIMPLE_TRY_CATCH_IS_CLEANUP
;
3549 g
->subcode
&= ~GIMPLE_TRY_CATCH_IS_CLEANUP
;
3553 /* Set EVAL to be the sequence of statements to use as the body for
3557 gimple_try_set_eval (gimple gs
, gimple_seq eval
)
3559 gimple_statement_try
*try_stmt
= as_a
<gimple_statement_try
> (gs
);
3560 try_stmt
->eval
= eval
;
3564 /* Set CLEANUP to be the sequence of statements to use as the cleanup
3565 body for GIMPLE_TRY GS. */
3568 gimple_try_set_cleanup (gimple gs
, gimple_seq cleanup
)
3570 gimple_statement_try
*try_stmt
= as_a
<gimple_statement_try
> (gs
);
3571 try_stmt
->cleanup
= cleanup
;
3575 /* Return a pointer to the cleanup sequence for cleanup statement GS. */
3577 static inline gimple_seq
*
3578 gimple_wce_cleanup_ptr (gimple gs
)
3580 gimple_statement_wce
*wce_stmt
= as_a
<gimple_statement_wce
> (gs
);
3581 return &wce_stmt
->cleanup
;
3585 /* Return the cleanup sequence for cleanup statement GS. */
3587 static inline gimple_seq
3588 gimple_wce_cleanup (gimple gs
)
3590 return *gimple_wce_cleanup_ptr (gs
);
3594 /* Set CLEANUP to be the cleanup sequence for GS. */
3597 gimple_wce_set_cleanup (gimple gs
, gimple_seq cleanup
)
3599 gimple_statement_wce
*wce_stmt
= as_a
<gimple_statement_wce
> (gs
);
3600 wce_stmt
->cleanup
= cleanup
;
3604 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
3607 gimple_wce_cleanup_eh_only (const_gimple gs
)
3609 GIMPLE_CHECK (gs
, GIMPLE_WITH_CLEANUP_EXPR
);
3610 return gs
->subcode
!= 0;
3614 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
3617 gimple_wce_set_cleanup_eh_only (gimple gs
, bool eh_only_p
)
3619 GIMPLE_CHECK (gs
, GIMPLE_WITH_CLEANUP_EXPR
);
3620 gs
->subcode
= (unsigned int) eh_only_p
;
3624 /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
3626 static inline unsigned
3627 gimple_phi_capacity (const_gimple gs
)
3629 const gimple_statement_phi
*phi_stmt
=
3630 as_a
<const gimple_statement_phi
> (gs
);
3631 return phi_stmt
->capacity
;
3635 /* Return the number of arguments in GIMPLE_PHI GS. This must always
3636 be exactly the number of incoming edges for the basic block holding
3639 static inline unsigned
3640 gimple_phi_num_args (const_gimple gs
)
3642 const gimple_statement_phi
*phi_stmt
=
3643 as_a
<const gimple_statement_phi
> (gs
);
3644 return phi_stmt
->nargs
;
3648 /* Return the SSA name created by GIMPLE_PHI GS. */
3651 gimple_phi_result (const_gimple gs
)
3653 const gimple_statement_phi
*phi_stmt
=
3654 as_a
<const gimple_statement_phi
> (gs
);
3655 return phi_stmt
->result
;
3658 /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
3660 static inline tree
*
3661 gimple_phi_result_ptr (gimple gs
)
3663 gimple_statement_phi
*phi_stmt
= as_a
<gimple_statement_phi
> (gs
);
3664 return &phi_stmt
->result
;
3667 /* Set RESULT to be the SSA name created by GIMPLE_PHI GS. */
3670 gimple_phi_set_result (gimple gs
, tree result
)
3672 gimple_statement_phi
*phi_stmt
= as_a
<gimple_statement_phi
> (gs
);
3673 phi_stmt
->result
= result
;
3674 if (result
&& TREE_CODE (result
) == SSA_NAME
)
3675 SSA_NAME_DEF_STMT (result
) = gs
;
3679 /* Return the PHI argument corresponding to incoming edge INDEX for
3682 static inline struct phi_arg_d
*
3683 gimple_phi_arg (gimple gs
, unsigned index
)
3685 gimple_statement_phi
*phi_stmt
= as_a
<gimple_statement_phi
> (gs
);
3686 gcc_gimple_checking_assert (index
<= phi_stmt
->capacity
);
3687 return &(phi_stmt
->args
[index
]);
3690 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
3691 for GIMPLE_PHI GS. */
3694 gimple_phi_set_arg (gimple gs
, unsigned index
, struct phi_arg_d
* phiarg
)
3696 gimple_statement_phi
*phi_stmt
= as_a
<gimple_statement_phi
> (gs
);
3697 gcc_gimple_checking_assert (index
<= phi_stmt
->nargs
);
3698 phi_stmt
->args
[index
] = *phiarg
;
3701 /* Return the PHI nodes for basic block BB, or NULL if there are no
3704 static inline gimple_seq
3705 phi_nodes (const_basic_block bb
)
3707 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
3708 return bb
->il
.gimple
.phi_nodes
;
3711 /* Return a pointer to the PHI nodes for basic block BB. */
3713 static inline gimple_seq
*
3714 phi_nodes_ptr (basic_block bb
)
3716 gcc_checking_assert (!(bb
->flags
& BB_RTL
));
3717 return &bb
->il
.gimple
.phi_nodes
;
3720 /* Return the tree operand for argument I of PHI node GS. */
3723 gimple_phi_arg_def (gimple gs
, size_t index
)
3725 return gimple_phi_arg (gs
, index
)->def
;
3729 /* Return a pointer to the tree operand for argument I of PHI node GS. */
3731 static inline tree
*
3732 gimple_phi_arg_def_ptr (gimple gs
, size_t index
)
3734 return &gimple_phi_arg (gs
, index
)->def
;
3737 /* Return the edge associated with argument I of phi node GS. */
3740 gimple_phi_arg_edge (gimple gs
, size_t i
)
3742 return EDGE_PRED (gimple_bb (gs
), i
);
3745 /* Return the source location of gimple argument I of phi node GS. */
3747 static inline source_location
3748 gimple_phi_arg_location (gimple gs
, size_t i
)
3750 return gimple_phi_arg (gs
, i
)->locus
;
3753 /* Return the source location of the argument on edge E of phi node GS. */
3755 static inline source_location
3756 gimple_phi_arg_location_from_edge (gimple gs
, edge e
)
3758 return gimple_phi_arg (gs
, e
->dest_idx
)->locus
;
3761 /* Set the source location of gimple argument I of phi node GS to LOC. */
3764 gimple_phi_arg_set_location (gimple gs
, size_t i
, source_location loc
)
3766 gimple_phi_arg (gs
, i
)->locus
= loc
;
3769 /* Return TRUE if argument I of phi node GS has a location record. */
3772 gimple_phi_arg_has_location (gimple gs
, size_t i
)
3774 return gimple_phi_arg_location (gs
, i
) != UNKNOWN_LOCATION
;
3778 /* Return the region number for GIMPLE_RESX GS. */
3781 gimple_resx_region (const_gimple gs
)
3783 const gimple_statement_eh_ctrl
*eh_ctrl_stmt
=
3784 as_a
<const gimple_statement_eh_ctrl
> (gs
);
3785 return eh_ctrl_stmt
->region
;
3788 /* Set REGION to be the region number for GIMPLE_RESX GS. */
3791 gimple_resx_set_region (gimple gs
, int region
)
3793 gimple_statement_eh_ctrl
*eh_ctrl_stmt
=
3794 as_a
<gimple_statement_eh_ctrl
> (gs
);
3795 eh_ctrl_stmt
->region
= region
;
3798 /* Return the region number for GIMPLE_EH_DISPATCH GS. */
3801 gimple_eh_dispatch_region (const_gimple gs
)
3803 const gimple_statement_eh_ctrl
*eh_ctrl_stmt
=
3804 as_a
<const gimple_statement_eh_ctrl
> (gs
);
3805 return eh_ctrl_stmt
->region
;
3808 /* Set REGION to be the region number for GIMPLE_EH_DISPATCH GS. */
3811 gimple_eh_dispatch_set_region (gimple gs
, int region
)
3813 gimple_statement_eh_ctrl
*eh_ctrl_stmt
=
3814 as_a
<gimple_statement_eh_ctrl
> (gs
);
3815 eh_ctrl_stmt
->region
= region
;
3818 /* Return the number of labels associated with the switch statement GS. */
3820 static inline unsigned
3821 gimple_switch_num_labels (const_gimple gs
)
3824 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
3825 num_ops
= gimple_num_ops (gs
);
3826 gcc_gimple_checking_assert (num_ops
> 1);
3831 /* Set NLABELS to be the number of labels for the switch statement GS. */
3834 gimple_switch_set_num_labels (gimple g
, unsigned nlabels
)
3836 GIMPLE_CHECK (g
, GIMPLE_SWITCH
);
3837 gimple_set_num_ops (g
, nlabels
+ 1);
3841 /* Return the index variable used by the switch statement GS. */
3844 gimple_switch_index (const_gimple gs
)
3846 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
3847 return gimple_op (gs
, 0);
3851 /* Return a pointer to the index variable for the switch statement GS. */
3853 static inline tree
*
3854 gimple_switch_index_ptr (const_gimple gs
)
3856 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
3857 return gimple_op_ptr (gs
, 0);
3861 /* Set INDEX to be the index variable for switch statement GS. */
3864 gimple_switch_set_index (gimple gs
, tree index
)
3866 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
3867 gcc_gimple_checking_assert (SSA_VAR_P (index
) || CONSTANT_CLASS_P (index
));
3868 gimple_set_op (gs
, 0, index
);
3872 /* Return the label numbered INDEX. The default label is 0, followed by any
3873 labels in a switch statement. */
3876 gimple_switch_label (const_gimple gs
, unsigned index
)
3878 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
3879 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 1);
3880 return gimple_op (gs
, index
+ 1);
3883 /* Set the label number INDEX to LABEL. 0 is always the default label. */
3886 gimple_switch_set_label (gimple gs
, unsigned index
, tree label
)
3888 GIMPLE_CHECK (gs
, GIMPLE_SWITCH
);
3889 gcc_gimple_checking_assert (gimple_num_ops (gs
) > index
+ 1
3890 && (label
== NULL_TREE
3891 || TREE_CODE (label
) == CASE_LABEL_EXPR
));
3892 gimple_set_op (gs
, index
+ 1, label
);
3895 /* Return the default label for a switch statement. */
3898 gimple_switch_default_label (const_gimple gs
)
3900 tree label
= gimple_switch_label (gs
, 0);
3901 gcc_checking_assert (!CASE_LOW (label
) && !CASE_HIGH (label
));
3905 /* Set the default label for a switch statement. */
3908 gimple_switch_set_default_label (gimple gs
, tree label
)
3910 gcc_checking_assert (!CASE_LOW (label
) && !CASE_HIGH (label
));
3911 gimple_switch_set_label (gs
, 0, label
);
3914 /* Return true if GS is a GIMPLE_DEBUG statement. */
3917 is_gimple_debug (const_gimple gs
)
3919 return gimple_code (gs
) == GIMPLE_DEBUG
;
3922 /* Return true if S is a GIMPLE_DEBUG BIND statement. */
3925 gimple_debug_bind_p (const_gimple s
)
3927 if (is_gimple_debug (s
))
3928 return s
->subcode
== GIMPLE_DEBUG_BIND
;
3933 /* Return the variable bound in a GIMPLE_DEBUG bind statement. */
3936 gimple_debug_bind_get_var (gimple dbg
)
3938 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
3939 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
3940 return gimple_op (dbg
, 0);
3943 /* Return the value bound to the variable in a GIMPLE_DEBUG bind
3947 gimple_debug_bind_get_value (gimple dbg
)
3949 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
3950 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
3951 return gimple_op (dbg
, 1);
3954 /* Return a pointer to the value bound to the variable in a
3955 GIMPLE_DEBUG bind statement. */
3957 static inline tree
*
3958 gimple_debug_bind_get_value_ptr (gimple dbg
)
3960 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
3961 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
3962 return gimple_op_ptr (dbg
, 1);
3965 /* Set the variable bound in a GIMPLE_DEBUG bind statement. */
3968 gimple_debug_bind_set_var (gimple dbg
, tree var
)
3970 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
3971 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
3972 gimple_set_op (dbg
, 0, var
);
3975 /* Set the value bound to the variable in a GIMPLE_DEBUG bind
3979 gimple_debug_bind_set_value (gimple dbg
, tree value
)
3981 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
3982 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
3983 gimple_set_op (dbg
, 1, value
);
3986 /* The second operand of a GIMPLE_DEBUG_BIND, when the value was
3988 #define GIMPLE_DEBUG_BIND_NOVALUE NULL_TREE /* error_mark_node */
3990 /* Remove the value bound to the variable in a GIMPLE_DEBUG bind
3994 gimple_debug_bind_reset_value (gimple dbg
)
3996 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
3997 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
3998 gimple_set_op (dbg
, 1, GIMPLE_DEBUG_BIND_NOVALUE
);
4001 /* Return true if the GIMPLE_DEBUG bind statement is bound to a
4005 gimple_debug_bind_has_value_p (gimple dbg
)
4007 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4008 gcc_gimple_checking_assert (gimple_debug_bind_p (dbg
));
4009 return gimple_op (dbg
, 1) != GIMPLE_DEBUG_BIND_NOVALUE
;
4012 #undef GIMPLE_DEBUG_BIND_NOVALUE
4014 /* Return true if S is a GIMPLE_DEBUG SOURCE BIND statement. */
4017 gimple_debug_source_bind_p (const_gimple s
)
4019 if (is_gimple_debug (s
))
4020 return s
->subcode
== GIMPLE_DEBUG_SOURCE_BIND
;
4025 /* Return the variable bound in a GIMPLE_DEBUG source bind statement. */
4028 gimple_debug_source_bind_get_var (gimple dbg
)
4030 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4031 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4032 return gimple_op (dbg
, 0);
4035 /* Return the value bound to the variable in a GIMPLE_DEBUG source bind
4039 gimple_debug_source_bind_get_value (gimple dbg
)
4041 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4042 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4043 return gimple_op (dbg
, 1);
4046 /* Return a pointer to the value bound to the variable in a
4047 GIMPLE_DEBUG source bind statement. */
4049 static inline tree
*
4050 gimple_debug_source_bind_get_value_ptr (gimple dbg
)
4052 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4053 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4054 return gimple_op_ptr (dbg
, 1);
4057 /* Set the variable bound in a GIMPLE_DEBUG source bind statement. */
4060 gimple_debug_source_bind_set_var (gimple dbg
, tree var
)
4062 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4063 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4064 gimple_set_op (dbg
, 0, var
);
4067 /* Set the value bound to the variable in a GIMPLE_DEBUG source bind
4071 gimple_debug_source_bind_set_value (gimple dbg
, tree value
)
4073 GIMPLE_CHECK (dbg
, GIMPLE_DEBUG
);
4074 gcc_gimple_checking_assert (gimple_debug_source_bind_p (dbg
));
4075 gimple_set_op (dbg
, 1, value
);
4078 /* Return the line number for EXPR, or return -1 if we have no line
4079 number information for it. */
4081 get_lineno (const_gimple stmt
)
4088 loc
= gimple_location (stmt
);
4089 if (loc
== UNKNOWN_LOCATION
)
4092 return LOCATION_LINE (loc
);
4095 /* Return a pointer to the body for the OMP statement GS. */
4097 static inline gimple_seq
*
4098 gimple_omp_body_ptr (gimple gs
)
4100 return &static_cast <gimple_statement_omp
*> (gs
)->body
;
4103 /* Return the body for the OMP statement GS. */
4105 static inline gimple_seq
4106 gimple_omp_body (gimple gs
)
4108 return *gimple_omp_body_ptr (gs
);
4111 /* Set BODY to be the body for the OMP statement GS. */
4114 gimple_omp_set_body (gimple gs
, gimple_seq body
)
4116 static_cast <gimple_statement_omp
*> (gs
)->body
= body
;
4120 /* Return the name associated with OMP_CRITICAL statement GS. */
4123 gimple_omp_critical_name (const_gimple gs
)
4125 const gimple_statement_omp_critical
*omp_critical_stmt
=
4126 as_a
<const gimple_statement_omp_critical
> (gs
);
4127 return omp_critical_stmt
->name
;
4131 /* Return a pointer to the name associated with OMP critical statement GS. */
4133 static inline tree
*
4134 gimple_omp_critical_name_ptr (gimple gs
)
4136 gimple_statement_omp_critical
*omp_critical_stmt
=
4137 as_a
<gimple_statement_omp_critical
> (gs
);
4138 return &omp_critical_stmt
->name
;
4142 /* Set NAME to be the name associated with OMP critical statement GS. */
4145 gimple_omp_critical_set_name (gimple gs
, tree name
)
4147 gimple_statement_omp_critical
*omp_critical_stmt
=
4148 as_a
<gimple_statement_omp_critical
> (gs
);
4149 omp_critical_stmt
->name
= name
;
4153 /* Return the kind of OMP for statemement. */
4156 gimple_omp_for_kind (const_gimple g
)
4158 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4159 return (gimple_omp_subcode (g
) & GF_OMP_FOR_KIND_MASK
);
4163 /* Set the OMP for kind. */
4166 gimple_omp_for_set_kind (gimple g
, int kind
)
4168 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4169 g
->subcode
= (g
->subcode
& ~GF_OMP_FOR_KIND_MASK
)
4170 | (kind
& GF_OMP_FOR_KIND_MASK
);
4174 /* Return true if OMP for statement G has the
4175 GF_OMP_FOR_COMBINED flag set. */
4178 gimple_omp_for_combined_p (const_gimple g
)
4180 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4181 return (gimple_omp_subcode (g
) & GF_OMP_FOR_COMBINED
) != 0;
4185 /* Set the GF_OMP_FOR_COMBINED field in G depending on the boolean
4186 value of COMBINED_P. */
4189 gimple_omp_for_set_combined_p (gimple g
, bool combined_p
)
4191 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4193 g
->subcode
|= GF_OMP_FOR_COMBINED
;
4195 g
->subcode
&= ~GF_OMP_FOR_COMBINED
;
4199 /* Return true if OMP for statement G has the
4200 GF_OMP_FOR_COMBINED_INTO flag set. */
4203 gimple_omp_for_combined_into_p (const_gimple g
)
4205 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4206 return (gimple_omp_subcode (g
) & GF_OMP_FOR_COMBINED_INTO
) != 0;
4210 /* Set the GF_OMP_FOR_COMBINED_INTO field in G depending on the boolean
4211 value of COMBINED_P. */
4214 gimple_omp_for_set_combined_into_p (gimple g
, bool combined_p
)
4216 GIMPLE_CHECK (g
, GIMPLE_OMP_FOR
);
4218 g
->subcode
|= GF_OMP_FOR_COMBINED_INTO
;
4220 g
->subcode
&= ~GF_OMP_FOR_COMBINED_INTO
;
4224 /* Return the clauses associated with OMP_FOR GS. */
4227 gimple_omp_for_clauses (const_gimple gs
)
4229 const gimple_statement_omp_for
*omp_for_stmt
=
4230 as_a
<const gimple_statement_omp_for
> (gs
);
4231 return omp_for_stmt
->clauses
;
4235 /* Return a pointer to the OMP_FOR GS. */
4237 static inline tree
*
4238 gimple_omp_for_clauses_ptr (gimple gs
)
4240 gimple_statement_omp_for
*omp_for_stmt
=
4241 as_a
<gimple_statement_omp_for
> (gs
);
4242 return &omp_for_stmt
->clauses
;
4246 /* Set CLAUSES to be the list of clauses associated with OMP_FOR GS. */
4249 gimple_omp_for_set_clauses (gimple gs
, tree clauses
)
4251 gimple_statement_omp_for
*omp_for_stmt
=
4252 as_a
<gimple_statement_omp_for
> (gs
);
4253 omp_for_stmt
->clauses
= clauses
;
4257 /* Get the collapse count of OMP_FOR GS. */
4259 static inline size_t
4260 gimple_omp_for_collapse (gimple gs
)
4262 gimple_statement_omp_for
*omp_for_stmt
=
4263 as_a
<gimple_statement_omp_for
> (gs
);
4264 return omp_for_stmt
->collapse
;
4268 /* Return the index variable for OMP_FOR GS. */
4271 gimple_omp_for_index (const_gimple gs
, size_t i
)
4273 const gimple_statement_omp_for
*omp_for_stmt
=
4274 as_a
<const gimple_statement_omp_for
> (gs
);
4275 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4276 return omp_for_stmt
->iter
[i
].index
;
4280 /* Return a pointer to the index variable for OMP_FOR GS. */
4282 static inline tree
*
4283 gimple_omp_for_index_ptr (gimple gs
, size_t i
)
4285 gimple_statement_omp_for
*omp_for_stmt
=
4286 as_a
<gimple_statement_omp_for
> (gs
);
4287 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4288 return &omp_for_stmt
->iter
[i
].index
;
4292 /* Set INDEX to be the index variable for OMP_FOR GS. */
4295 gimple_omp_for_set_index (gimple gs
, size_t i
, tree index
)
4297 gimple_statement_omp_for
*omp_for_stmt
=
4298 as_a
<gimple_statement_omp_for
> (gs
);
4299 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4300 omp_for_stmt
->iter
[i
].index
= index
;
4304 /* Return the initial value for OMP_FOR GS. */
4307 gimple_omp_for_initial (const_gimple gs
, size_t i
)
4309 const gimple_statement_omp_for
*omp_for_stmt
=
4310 as_a
<const gimple_statement_omp_for
> (gs
);
4311 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4312 return omp_for_stmt
->iter
[i
].initial
;
4316 /* Return a pointer to the initial value for OMP_FOR GS. */
4318 static inline tree
*
4319 gimple_omp_for_initial_ptr (gimple gs
, size_t i
)
4321 gimple_statement_omp_for
*omp_for_stmt
=
4322 as_a
<gimple_statement_omp_for
> (gs
);
4323 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4324 return &omp_for_stmt
->iter
[i
].initial
;
4328 /* Set INITIAL to be the initial value for OMP_FOR GS. */
4331 gimple_omp_for_set_initial (gimple gs
, size_t i
, tree initial
)
4333 gimple_statement_omp_for
*omp_for_stmt
=
4334 as_a
<gimple_statement_omp_for
> (gs
);
4335 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4336 omp_for_stmt
->iter
[i
].initial
= initial
;
4340 /* Return the final value for OMP_FOR GS. */
4343 gimple_omp_for_final (const_gimple gs
, size_t i
)
4345 const gimple_statement_omp_for
*omp_for_stmt
=
4346 as_a
<const gimple_statement_omp_for
> (gs
);
4347 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4348 return omp_for_stmt
->iter
[i
].final
;
4352 /* Return a pointer to the final value for OMP_FOR GS. */
4354 static inline tree
*
4355 gimple_omp_for_final_ptr (gimple gs
, size_t i
)
4357 gimple_statement_omp_for
*omp_for_stmt
=
4358 as_a
<gimple_statement_omp_for
> (gs
);
4359 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4360 return &omp_for_stmt
->iter
[i
].final
;
4364 /* Set FINAL to be the final value for OMP_FOR GS. */
4367 gimple_omp_for_set_final (gimple gs
, size_t i
, tree final
)
4369 gimple_statement_omp_for
*omp_for_stmt
=
4370 as_a
<gimple_statement_omp_for
> (gs
);
4371 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4372 omp_for_stmt
->iter
[i
].final
= final
;
4376 /* Return the increment value for OMP_FOR GS. */
4379 gimple_omp_for_incr (const_gimple gs
, size_t i
)
4381 const gimple_statement_omp_for
*omp_for_stmt
=
4382 as_a
<const gimple_statement_omp_for
> (gs
);
4383 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4384 return omp_for_stmt
->iter
[i
].incr
;
4388 /* Return a pointer to the increment value for OMP_FOR GS. */
4390 static inline tree
*
4391 gimple_omp_for_incr_ptr (gimple gs
, size_t i
)
4393 gimple_statement_omp_for
*omp_for_stmt
=
4394 as_a
<gimple_statement_omp_for
> (gs
);
4395 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4396 return &omp_for_stmt
->iter
[i
].incr
;
4400 /* Set INCR to be the increment value for OMP_FOR GS. */
4403 gimple_omp_for_set_incr (gimple gs
, size_t i
, tree incr
)
4405 gimple_statement_omp_for
*omp_for_stmt
=
4406 as_a
<gimple_statement_omp_for
> (gs
);
4407 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
4408 omp_for_stmt
->iter
[i
].incr
= incr
;
4412 /* Return a pointer to the sequence of statements to execute before the OMP_FOR
4413 statement GS starts. */
4415 static inline gimple_seq
*
4416 gimple_omp_for_pre_body_ptr (gimple gs
)
4418 gimple_statement_omp_for
*omp_for_stmt
=
4419 as_a
<gimple_statement_omp_for
> (gs
);
4420 return &omp_for_stmt
->pre_body
;
4424 /* Return the sequence of statements to execute before the OMP_FOR
4425 statement GS starts. */
4427 static inline gimple_seq
4428 gimple_omp_for_pre_body (gimple gs
)
4430 return *gimple_omp_for_pre_body_ptr (gs
);
4434 /* Set PRE_BODY to be the sequence of statements to execute before the
4435 OMP_FOR statement GS starts. */
4438 gimple_omp_for_set_pre_body (gimple gs
, gimple_seq pre_body
)
4440 gimple_statement_omp_for
*omp_for_stmt
=
4441 as_a
<gimple_statement_omp_for
> (gs
);
4442 omp_for_stmt
->pre_body
= pre_body
;
4446 /* Return the clauses associated with OMP_PARALLEL GS. */
4449 gimple_omp_parallel_clauses (const_gimple gs
)
4451 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4452 as_a
<const gimple_statement_omp_parallel
> (gs
);
4453 return omp_parallel_stmt
->clauses
;
4457 /* Return a pointer to the clauses associated with OMP_PARALLEL GS. */
4459 static inline tree
*
4460 gimple_omp_parallel_clauses_ptr (gimple gs
)
4462 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4463 as_a
<gimple_statement_omp_parallel
> (gs
);
4464 return &omp_parallel_stmt
->clauses
;
4468 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL
4472 gimple_omp_parallel_set_clauses (gimple gs
, tree clauses
)
4474 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4475 as_a
<gimple_statement_omp_parallel
> (gs
);
4476 omp_parallel_stmt
->clauses
= clauses
;
4480 /* Return the child function used to hold the body of OMP_PARALLEL GS. */
4483 gimple_omp_parallel_child_fn (const_gimple gs
)
4485 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4486 as_a
<const gimple_statement_omp_parallel
> (gs
);
4487 return omp_parallel_stmt
->child_fn
;
4490 /* Return a pointer to the child function used to hold the body of
4493 static inline tree
*
4494 gimple_omp_parallel_child_fn_ptr (gimple gs
)
4496 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4497 as_a
<gimple_statement_omp_parallel
> (gs
);
4498 return &omp_parallel_stmt
->child_fn
;
4502 /* Set CHILD_FN to be the child function for OMP_PARALLEL GS. */
4505 gimple_omp_parallel_set_child_fn (gimple gs
, tree child_fn
)
4507 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4508 as_a
<gimple_statement_omp_parallel
> (gs
);
4509 omp_parallel_stmt
->child_fn
= child_fn
;
4513 /* Return the artificial argument used to send variables and values
4514 from the parent to the children threads in OMP_PARALLEL GS. */
4517 gimple_omp_parallel_data_arg (const_gimple gs
)
4519 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4520 as_a
<const gimple_statement_omp_parallel
> (gs
);
4521 return omp_parallel_stmt
->data_arg
;
4525 /* Return a pointer to the data argument for OMP_PARALLEL GS. */
4527 static inline tree
*
4528 gimple_omp_parallel_data_arg_ptr (gimple gs
)
4530 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4531 as_a
<gimple_statement_omp_parallel
> (gs
);
4532 return &omp_parallel_stmt
->data_arg
;
4536 /* Set DATA_ARG to be the data argument for OMP_PARALLEL GS. */
4539 gimple_omp_parallel_set_data_arg (gimple gs
, tree data_arg
)
4541 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4542 as_a
<gimple_statement_omp_parallel
> (gs
);
4543 omp_parallel_stmt
->data_arg
= data_arg
;
4547 /* Return the clauses associated with OMP_TASK GS. */
4550 gimple_omp_task_clauses (const_gimple gs
)
4552 const gimple_statement_omp_task
*omp_task_stmt
=
4553 as_a
<const gimple_statement_omp_task
> (gs
);
4554 return omp_task_stmt
->clauses
;
4558 /* Return a pointer to the clauses associated with OMP_TASK GS. */
4560 static inline tree
*
4561 gimple_omp_task_clauses_ptr (gimple gs
)
4563 gimple_statement_omp_task
*omp_task_stmt
=
4564 as_a
<gimple_statement_omp_task
> (gs
);
4565 return &omp_task_stmt
->clauses
;
4569 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
4573 gimple_omp_task_set_clauses (gimple gs
, tree clauses
)
4575 gimple_statement_omp_task
*omp_task_stmt
=
4576 as_a
<gimple_statement_omp_task
> (gs
);
4577 omp_task_stmt
->clauses
= clauses
;
4581 /* Return the child function used to hold the body of OMP_TASK GS. */
4584 gimple_omp_task_child_fn (const_gimple gs
)
4586 const gimple_statement_omp_task
*omp_task_stmt
=
4587 as_a
<const gimple_statement_omp_task
> (gs
);
4588 return omp_task_stmt
->child_fn
;
4591 /* Return a pointer to the child function used to hold the body of
4594 static inline tree
*
4595 gimple_omp_task_child_fn_ptr (gimple gs
)
4597 gimple_statement_omp_task
*omp_task_stmt
=
4598 as_a
<gimple_statement_omp_task
> (gs
);
4599 return &omp_task_stmt
->child_fn
;
4603 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
4606 gimple_omp_task_set_child_fn (gimple gs
, tree child_fn
)
4608 gimple_statement_omp_task
*omp_task_stmt
=
4609 as_a
<gimple_statement_omp_task
> (gs
);
4610 omp_task_stmt
->child_fn
= child_fn
;
4614 /* Return the artificial argument used to send variables and values
4615 from the parent to the children threads in OMP_TASK GS. */
4618 gimple_omp_task_data_arg (const_gimple gs
)
4620 const gimple_statement_omp_task
*omp_task_stmt
=
4621 as_a
<const gimple_statement_omp_task
> (gs
);
4622 return omp_task_stmt
->data_arg
;
4626 /* Return a pointer to the data argument for OMP_TASK GS. */
4628 static inline tree
*
4629 gimple_omp_task_data_arg_ptr (gimple gs
)
4631 gimple_statement_omp_task
*omp_task_stmt
=
4632 as_a
<gimple_statement_omp_task
> (gs
);
4633 return &omp_task_stmt
->data_arg
;
4637 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
4640 gimple_omp_task_set_data_arg (gimple gs
, tree data_arg
)
4642 gimple_statement_omp_task
*omp_task_stmt
=
4643 as_a
<gimple_statement_omp_task
> (gs
);
4644 omp_task_stmt
->data_arg
= data_arg
;
4648 /* Return the clauses associated with OMP_TASK GS. */
4651 gimple_omp_taskreg_clauses (const_gimple gs
)
4653 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4654 as_a
<const gimple_statement_omp_parallel
> (gs
);
4655 return omp_parallel_stmt
->clauses
;
4659 /* Return a pointer to the clauses associated with OMP_TASK GS. */
4661 static inline tree
*
4662 gimple_omp_taskreg_clauses_ptr (gimple gs
)
4664 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4665 as_a
<gimple_statement_omp_parallel
> (gs
);
4666 return &omp_parallel_stmt
->clauses
;
4670 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
4674 gimple_omp_taskreg_set_clauses (gimple gs
, tree clauses
)
4676 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4677 as_a
<gimple_statement_omp_parallel
> (gs
);
4678 omp_parallel_stmt
->clauses
= clauses
;
4682 /* Return the child function used to hold the body of OMP_TASK GS. */
4685 gimple_omp_taskreg_child_fn (const_gimple gs
)
4687 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4688 as_a
<const gimple_statement_omp_parallel
> (gs
);
4689 return omp_parallel_stmt
->child_fn
;
4692 /* Return a pointer to the child function used to hold the body of
4695 static inline tree
*
4696 gimple_omp_taskreg_child_fn_ptr (gimple gs
)
4698 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4699 as_a
<gimple_statement_omp_parallel
> (gs
);
4700 return &omp_parallel_stmt
->child_fn
;
4704 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
4707 gimple_omp_taskreg_set_child_fn (gimple gs
, tree child_fn
)
4709 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4710 as_a
<gimple_statement_omp_parallel
> (gs
);
4711 omp_parallel_stmt
->child_fn
= child_fn
;
4715 /* Return the artificial argument used to send variables and values
4716 from the parent to the children threads in OMP_TASK GS. */
4719 gimple_omp_taskreg_data_arg (const_gimple gs
)
4721 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4722 as_a
<const gimple_statement_omp_parallel
> (gs
);
4723 return omp_parallel_stmt
->data_arg
;
4727 /* Return a pointer to the data argument for OMP_TASK GS. */
4729 static inline tree
*
4730 gimple_omp_taskreg_data_arg_ptr (gimple gs
)
4732 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4733 as_a
<gimple_statement_omp_parallel
> (gs
);
4734 return &omp_parallel_stmt
->data_arg
;
4738 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
4741 gimple_omp_taskreg_set_data_arg (gimple gs
, tree data_arg
)
4743 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4744 as_a
<gimple_statement_omp_parallel
> (gs
);
4745 omp_parallel_stmt
->data_arg
= data_arg
;
4749 /* Return the copy function used to hold the body of OMP_TASK GS. */
4752 gimple_omp_task_copy_fn (const_gimple gs
)
4754 const gimple_statement_omp_task
*omp_task_stmt
=
4755 as_a
<const gimple_statement_omp_task
> (gs
);
4756 return omp_task_stmt
->copy_fn
;
4759 /* Return a pointer to the copy function used to hold the body of
4762 static inline tree
*
4763 gimple_omp_task_copy_fn_ptr (gimple gs
)
4765 gimple_statement_omp_task
*omp_task_stmt
=
4766 as_a
<gimple_statement_omp_task
> (gs
);
4767 return &omp_task_stmt
->copy_fn
;
4771 /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
4774 gimple_omp_task_set_copy_fn (gimple gs
, tree copy_fn
)
4776 gimple_statement_omp_task
*omp_task_stmt
=
4777 as_a
<gimple_statement_omp_task
> (gs
);
4778 omp_task_stmt
->copy_fn
= copy_fn
;
4782 /* Return size of the data block in bytes in OMP_TASK GS. */
4785 gimple_omp_task_arg_size (const_gimple gs
)
4787 const gimple_statement_omp_task
*omp_task_stmt
=
4788 as_a
<const gimple_statement_omp_task
> (gs
);
4789 return omp_task_stmt
->arg_size
;
4793 /* Return a pointer to the data block size for OMP_TASK GS. */
4795 static inline tree
*
4796 gimple_omp_task_arg_size_ptr (gimple gs
)
4798 gimple_statement_omp_task
*omp_task_stmt
=
4799 as_a
<gimple_statement_omp_task
> (gs
);
4800 return &omp_task_stmt
->arg_size
;
4804 /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
4807 gimple_omp_task_set_arg_size (gimple gs
, tree arg_size
)
4809 gimple_statement_omp_task
*omp_task_stmt
=
4810 as_a
<gimple_statement_omp_task
> (gs
);
4811 omp_task_stmt
->arg_size
= arg_size
;
4815 /* Return align of the data block in bytes in OMP_TASK GS. */
4818 gimple_omp_task_arg_align (const_gimple gs
)
4820 const gimple_statement_omp_task
*omp_task_stmt
=
4821 as_a
<const gimple_statement_omp_task
> (gs
);
4822 return omp_task_stmt
->arg_align
;
4826 /* Return a pointer to the data block align for OMP_TASK GS. */
4828 static inline tree
*
4829 gimple_omp_task_arg_align_ptr (gimple gs
)
4831 gimple_statement_omp_task
*omp_task_stmt
=
4832 as_a
<gimple_statement_omp_task
> (gs
);
4833 return &omp_task_stmt
->arg_align
;
4837 /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
4840 gimple_omp_task_set_arg_align (gimple gs
, tree arg_align
)
4842 gimple_statement_omp_task
*omp_task_stmt
=
4843 as_a
<gimple_statement_omp_task
> (gs
);
4844 omp_task_stmt
->arg_align
= arg_align
;
4848 /* Return the clauses associated with OMP_SINGLE GS. */
4851 gimple_omp_single_clauses (const_gimple gs
)
4853 const gimple_statement_omp_single
*omp_single_stmt
=
4854 as_a
<const gimple_statement_omp_single
> (gs
);
4855 return omp_single_stmt
->clauses
;
4859 /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
4861 static inline tree
*
4862 gimple_omp_single_clauses_ptr (gimple gs
)
4864 gimple_statement_omp_single
*omp_single_stmt
=
4865 as_a
<gimple_statement_omp_single
> (gs
);
4866 return &omp_single_stmt
->clauses
;
4870 /* Set CLAUSES to be the clauses associated with OMP_SINGLE GS. */
4873 gimple_omp_single_set_clauses (gimple gs
, tree clauses
)
4875 gimple_statement_omp_single
*omp_single_stmt
=
4876 as_a
<gimple_statement_omp_single
> (gs
);
4877 omp_single_stmt
->clauses
= clauses
;
4881 /* Return the clauses associated with OMP_TARGET GS. */
4884 gimple_omp_target_clauses (const_gimple gs
)
4886 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4887 as_a
<const gimple_statement_omp_parallel
> (gs
);
4888 return omp_parallel_stmt
->clauses
;
4892 /* Return a pointer to the clauses associated with OMP_TARGET GS. */
4894 static inline tree
*
4895 gimple_omp_target_clauses_ptr (gimple gs
)
4897 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4898 as_a
<gimple_statement_omp_parallel
> (gs
);
4899 return &omp_parallel_stmt
->clauses
;
4903 /* Set CLAUSES to be the clauses associated with OMP_TARGET GS. */
4906 gimple_omp_target_set_clauses (gimple gs
, tree clauses
)
4908 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4909 as_a
<gimple_statement_omp_parallel
> (gs
);
4910 omp_parallel_stmt
->clauses
= clauses
;
4914 /* Return the kind of OMP target statemement. */
4917 gimple_omp_target_kind (const_gimple g
)
4919 GIMPLE_CHECK (g
, GIMPLE_OMP_TARGET
);
4920 return (gimple_omp_subcode (g
) & GF_OMP_TARGET_KIND_MASK
);
4924 /* Set the OMP target kind. */
4927 gimple_omp_target_set_kind (gimple g
, int kind
)
4929 GIMPLE_CHECK (g
, GIMPLE_OMP_TARGET
);
4930 g
->subcode
= (g
->subcode
& ~GF_OMP_TARGET_KIND_MASK
)
4931 | (kind
& GF_OMP_TARGET_KIND_MASK
);
4935 /* Return the child function used to hold the body of OMP_TARGET GS. */
4938 gimple_omp_target_child_fn (const_gimple gs
)
4940 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4941 as_a
<const gimple_statement_omp_parallel
> (gs
);
4942 return omp_parallel_stmt
->child_fn
;
4945 /* Return a pointer to the child function used to hold the body of
4948 static inline tree
*
4949 gimple_omp_target_child_fn_ptr (gimple gs
)
4951 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4952 as_a
<gimple_statement_omp_parallel
> (gs
);
4953 return &omp_parallel_stmt
->child_fn
;
4957 /* Set CHILD_FN to be the child function for OMP_TARGET GS. */
4960 gimple_omp_target_set_child_fn (gimple gs
, tree child_fn
)
4962 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4963 as_a
<gimple_statement_omp_parallel
> (gs
);
4964 omp_parallel_stmt
->child_fn
= child_fn
;
4968 /* Return the artificial argument used to send variables and values
4969 from the parent to the children threads in OMP_TARGET GS. */
4972 gimple_omp_target_data_arg (const_gimple gs
)
4974 const gimple_statement_omp_parallel
*omp_parallel_stmt
=
4975 as_a
<const gimple_statement_omp_parallel
> (gs
);
4976 return omp_parallel_stmt
->data_arg
;
4980 /* Return a pointer to the data argument for OMP_TARGET GS. */
4982 static inline tree
*
4983 gimple_omp_target_data_arg_ptr (gimple gs
)
4985 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4986 as_a
<gimple_statement_omp_parallel
> (gs
);
4987 return &omp_parallel_stmt
->data_arg
;
4991 /* Set DATA_ARG to be the data argument for OMP_TARGET GS. */
4994 gimple_omp_target_set_data_arg (gimple gs
, tree data_arg
)
4996 gimple_statement_omp_parallel
*omp_parallel_stmt
=
4997 as_a
<gimple_statement_omp_parallel
> (gs
);
4998 omp_parallel_stmt
->data_arg
= data_arg
;
5002 /* Return the clauses associated with OMP_TEAMS GS. */
5005 gimple_omp_teams_clauses (const_gimple gs
)
5007 const gimple_statement_omp_single
*omp_single_stmt
=
5008 as_a
<const gimple_statement_omp_single
> (gs
);
5009 return omp_single_stmt
->clauses
;
5013 /* Return a pointer to the clauses associated with OMP_TEAMS GS. */
5015 static inline tree
*
5016 gimple_omp_teams_clauses_ptr (gimple gs
)
5018 gimple_statement_omp_single
*omp_single_stmt
=
5019 as_a
<gimple_statement_omp_single
> (gs
);
5020 return &omp_single_stmt
->clauses
;
5024 /* Set CLAUSES to be the clauses associated with OMP_TEAMS GS. */
5027 gimple_omp_teams_set_clauses (gimple gs
, tree clauses
)
5029 gimple_statement_omp_single
*omp_single_stmt
=
5030 as_a
<gimple_statement_omp_single
> (gs
);
5031 omp_single_stmt
->clauses
= clauses
;
5035 /* Return the clauses associated with OMP_SECTIONS GS. */
5038 gimple_omp_sections_clauses (const_gimple gs
)
5040 const gimple_statement_omp_sections
*omp_sections_stmt
=
5041 as_a
<const gimple_statement_omp_sections
> (gs
);
5042 return omp_sections_stmt
->clauses
;
5046 /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
5048 static inline tree
*
5049 gimple_omp_sections_clauses_ptr (gimple gs
)
5051 gimple_statement_omp_sections
*omp_sections_stmt
=
5052 as_a
<gimple_statement_omp_sections
> (gs
);
5053 return &omp_sections_stmt
->clauses
;
5057 /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
5061 gimple_omp_sections_set_clauses (gimple gs
, tree clauses
)
5063 gimple_statement_omp_sections
*omp_sections_stmt
=
5064 as_a
<gimple_statement_omp_sections
> (gs
);
5065 omp_sections_stmt
->clauses
= clauses
;
5069 /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
5073 gimple_omp_sections_control (const_gimple gs
)
5075 const gimple_statement_omp_sections
*omp_sections_stmt
=
5076 as_a
<const gimple_statement_omp_sections
> (gs
);
5077 return omp_sections_stmt
->control
;
5081 /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
5084 static inline tree
*
5085 gimple_omp_sections_control_ptr (gimple gs
)
5087 gimple_statement_omp_sections
*omp_sections_stmt
=
5088 as_a
<gimple_statement_omp_sections
> (gs
);
5089 return &omp_sections_stmt
->control
;
5093 /* Set CONTROL to be the set of clauses associated with the
5094 GIMPLE_OMP_SECTIONS in GS. */
5097 gimple_omp_sections_set_control (gimple gs
, tree control
)
5099 gimple_statement_omp_sections
*omp_sections_stmt
=
5100 as_a
<gimple_statement_omp_sections
> (gs
);
5101 omp_sections_stmt
->control
= control
;
5105 /* Set COND to be the condition code for OMP_FOR GS. */
5108 gimple_omp_for_set_cond (gimple gs
, size_t i
, enum tree_code cond
)
5110 gimple_statement_omp_for
*omp_for_stmt
=
5111 as_a
<gimple_statement_omp_for
> (gs
);
5112 gcc_gimple_checking_assert (TREE_CODE_CLASS (cond
) == tcc_comparison
5113 && i
< omp_for_stmt
->collapse
);
5114 omp_for_stmt
->iter
[i
].cond
= cond
;
5118 /* Return the condition code associated with OMP_FOR GS. */
5120 static inline enum tree_code
5121 gimple_omp_for_cond (const_gimple gs
, size_t i
)
5123 const gimple_statement_omp_for
*omp_for_stmt
=
5124 as_a
<const gimple_statement_omp_for
> (gs
);
5125 gcc_gimple_checking_assert (i
< omp_for_stmt
->collapse
);
5126 return omp_for_stmt
->iter
[i
].cond
;
5130 /* Set the value being stored in an atomic store. */
5133 gimple_omp_atomic_store_set_val (gimple g
, tree val
)
5135 gimple_statement_omp_atomic_store
*omp_atomic_store_stmt
=
5136 as_a
<gimple_statement_omp_atomic_store
> (g
);
5137 omp_atomic_store_stmt
->val
= val
;
5141 /* Return the value being stored in an atomic store. */
5144 gimple_omp_atomic_store_val (const_gimple g
)
5146 const gimple_statement_omp_atomic_store
*omp_atomic_store_stmt
=
5147 as_a
<const gimple_statement_omp_atomic_store
> (g
);
5148 return omp_atomic_store_stmt
->val
;
5152 /* Return a pointer to the value being stored in an atomic store. */
5154 static inline tree
*
5155 gimple_omp_atomic_store_val_ptr (gimple g
)
5157 gimple_statement_omp_atomic_store
*omp_atomic_store_stmt
=
5158 as_a
<gimple_statement_omp_atomic_store
> (g
);
5159 return &omp_atomic_store_stmt
->val
;
5163 /* Set the LHS of an atomic load. */
5166 gimple_omp_atomic_load_set_lhs (gimple g
, tree lhs
)
5168 gimple_statement_omp_atomic_load
*omp_atomic_load_stmt
=
5169 as_a
<gimple_statement_omp_atomic_load
> (g
);
5170 omp_atomic_load_stmt
->lhs
= lhs
;
5174 /* Get the LHS of an atomic load. */
5177 gimple_omp_atomic_load_lhs (const_gimple g
)
5179 const gimple_statement_omp_atomic_load
*omp_atomic_load_stmt
=
5180 as_a
<const gimple_statement_omp_atomic_load
> (g
);
5181 return omp_atomic_load_stmt
->lhs
;
5185 /* Return a pointer to the LHS of an atomic load. */
5187 static inline tree
*
5188 gimple_omp_atomic_load_lhs_ptr (gimple g
)
5190 gimple_statement_omp_atomic_load
*omp_atomic_load_stmt
=
5191 as_a
<gimple_statement_omp_atomic_load
> (g
);
5192 return &omp_atomic_load_stmt
->lhs
;
5196 /* Set the RHS of an atomic load. */
5199 gimple_omp_atomic_load_set_rhs (gimple g
, tree rhs
)
5201 gimple_statement_omp_atomic_load
*omp_atomic_load_stmt
=
5202 as_a
<gimple_statement_omp_atomic_load
> (g
);
5203 omp_atomic_load_stmt
->rhs
= rhs
;
5207 /* Get the RHS of an atomic load. */
5210 gimple_omp_atomic_load_rhs (const_gimple g
)
5212 const gimple_statement_omp_atomic_load
*omp_atomic_load_stmt
=
5213 as_a
<const gimple_statement_omp_atomic_load
> (g
);
5214 return omp_atomic_load_stmt
->rhs
;
5218 /* Return a pointer to the RHS of an atomic load. */
5220 static inline tree
*
5221 gimple_omp_atomic_load_rhs_ptr (gimple g
)
5223 gimple_statement_omp_atomic_load
*omp_atomic_load_stmt
=
5224 as_a
<gimple_statement_omp_atomic_load
> (g
);
5225 return &omp_atomic_load_stmt
->rhs
;
5229 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
5232 gimple_omp_continue_control_def (const_gimple g
)
5234 const gimple_statement_omp_continue
*omp_continue_stmt
=
5235 as_a
<const gimple_statement_omp_continue
> (g
);
5236 return omp_continue_stmt
->control_def
;
5239 /* The same as above, but return the address. */
5241 static inline tree
*
5242 gimple_omp_continue_control_def_ptr (gimple g
)
5244 gimple_statement_omp_continue
*omp_continue_stmt
=
5245 as_a
<gimple_statement_omp_continue
> (g
);
5246 return &omp_continue_stmt
->control_def
;
5249 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
5252 gimple_omp_continue_set_control_def (gimple g
, tree def
)
5254 gimple_statement_omp_continue
*omp_continue_stmt
=
5255 as_a
<gimple_statement_omp_continue
> (g
);
5256 omp_continue_stmt
->control_def
= def
;
5260 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
5263 gimple_omp_continue_control_use (const_gimple g
)
5265 const gimple_statement_omp_continue
*omp_continue_stmt
=
5266 as_a
<const gimple_statement_omp_continue
> (g
);
5267 return omp_continue_stmt
->control_use
;
5271 /* The same as above, but return the address. */
5273 static inline tree
*
5274 gimple_omp_continue_control_use_ptr (gimple g
)
5276 gimple_statement_omp_continue
*omp_continue_stmt
=
5277 as_a
<gimple_statement_omp_continue
> (g
);
5278 return &omp_continue_stmt
->control_use
;
5282 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
5285 gimple_omp_continue_set_control_use (gimple g
, tree use
)
5287 gimple_statement_omp_continue
*omp_continue_stmt
=
5288 as_a
<gimple_statement_omp_continue
> (g
);
5289 omp_continue_stmt
->control_use
= use
;
5292 /* Return a pointer to the body for the GIMPLE_TRANSACTION statement GS. */
5294 static inline gimple_seq
*
5295 gimple_transaction_body_ptr (gimple gs
)
5297 gimple_statement_transaction
*transaction_stmt
=
5298 as_a
<gimple_statement_transaction
> (gs
);
5299 return &transaction_stmt
->body
;
5302 /* Return the body for the GIMPLE_TRANSACTION statement GS. */
5304 static inline gimple_seq
5305 gimple_transaction_body (gimple gs
)
5307 return *gimple_transaction_body_ptr (gs
);
5310 /* Return the label associated with a GIMPLE_TRANSACTION. */
5313 gimple_transaction_label (const_gimple gs
)
5315 const gimple_statement_transaction
*transaction_stmt
=
5316 as_a
<const gimple_statement_transaction
> (gs
);
5317 return transaction_stmt
->label
;
5320 static inline tree
*
5321 gimple_transaction_label_ptr (gimple gs
)
5323 gimple_statement_transaction
*transaction_stmt
=
5324 as_a
<gimple_statement_transaction
> (gs
);
5325 return &transaction_stmt
->label
;
5328 /* Return the subcode associated with a GIMPLE_TRANSACTION. */
5330 static inline unsigned int
5331 gimple_transaction_subcode (const_gimple gs
)
5333 GIMPLE_CHECK (gs
, GIMPLE_TRANSACTION
);
5337 /* Set BODY to be the body for the GIMPLE_TRANSACTION statement GS. */
5340 gimple_transaction_set_body (gimple gs
, gimple_seq body
)
5342 gimple_statement_transaction
*transaction_stmt
=
5343 as_a
<gimple_statement_transaction
> (gs
);
5344 transaction_stmt
->body
= body
;
5347 /* Set the label associated with a GIMPLE_TRANSACTION. */
5350 gimple_transaction_set_label (gimple gs
, tree label
)
5352 gimple_statement_transaction
*transaction_stmt
=
5353 as_a
<gimple_statement_transaction
> (gs
);
5354 transaction_stmt
->label
= label
;
5357 /* Set the subcode associated with a GIMPLE_TRANSACTION. */
5360 gimple_transaction_set_subcode (gimple gs
, unsigned int subcode
)
5362 GIMPLE_CHECK (gs
, GIMPLE_TRANSACTION
);
5363 gs
->subcode
= subcode
;
5367 /* Return a pointer to the return value for GIMPLE_RETURN GS. */
5369 static inline tree
*
5370 gimple_return_retval_ptr (const_gimple gs
)
5372 GIMPLE_CHECK (gs
, GIMPLE_RETURN
);
5373 return gimple_op_ptr (gs
, 0);
5376 /* Return the return value for GIMPLE_RETURN GS. */
5379 gimple_return_retval (const_gimple gs
)
5381 GIMPLE_CHECK (gs
, GIMPLE_RETURN
);
5382 return gimple_op (gs
, 0);
5386 /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
5389 gimple_return_set_retval (gimple gs
, tree retval
)
5391 GIMPLE_CHECK (gs
, GIMPLE_RETURN
);
5392 gimple_set_op (gs
, 0, retval
);
5396 /* Return the return bounds for GIMPLE_RETURN GS. */
5399 gimple_return_retbnd (const_gimple gs
)
5401 GIMPLE_CHECK (gs
, GIMPLE_RETURN
);
5402 return gimple_op (gs
, 1);
5406 /* Set RETVAL to be the return bounds for GIMPLE_RETURN GS. */
5409 gimple_return_set_retbnd (gimple gs
, tree retval
)
5411 GIMPLE_CHECK (gs
, GIMPLE_RETURN
);
5412 gimple_set_op (gs
, 1, retval
);
5416 /* Returns true when the gimple statement STMT is any of the OpenMP types. */
5418 #define CASE_GIMPLE_OMP \
5419 case GIMPLE_OMP_PARALLEL: \
5420 case GIMPLE_OMP_TASK: \
5421 case GIMPLE_OMP_FOR: \
5422 case GIMPLE_OMP_SECTIONS: \
5423 case GIMPLE_OMP_SECTIONS_SWITCH: \
5424 case GIMPLE_OMP_SINGLE: \
5425 case GIMPLE_OMP_TARGET: \
5426 case GIMPLE_OMP_TEAMS: \
5427 case GIMPLE_OMP_SECTION: \
5428 case GIMPLE_OMP_MASTER: \
5429 case GIMPLE_OMP_TASKGROUP: \
5430 case GIMPLE_OMP_ORDERED: \
5431 case GIMPLE_OMP_CRITICAL: \
5432 case GIMPLE_OMP_RETURN: \
5433 case GIMPLE_OMP_ATOMIC_LOAD: \
5434 case GIMPLE_OMP_ATOMIC_STORE: \
5435 case GIMPLE_OMP_CONTINUE
5438 is_gimple_omp (const_gimple stmt
)
5440 switch (gimple_code (stmt
))
5450 /* Returns TRUE if statement G is a GIMPLE_NOP. */
5453 gimple_nop_p (const_gimple g
)
5455 return gimple_code (g
) == GIMPLE_NOP
;
5459 /* Return true if GS is a GIMPLE_RESX. */
5462 is_gimple_resx (const_gimple gs
)
5464 return gimple_code (gs
) == GIMPLE_RESX
;
5467 /* Return the predictor of GIMPLE_PREDICT statement GS. */
5469 static inline enum br_predictor
5470 gimple_predict_predictor (gimple gs
)
5472 GIMPLE_CHECK (gs
, GIMPLE_PREDICT
);
5473 return (enum br_predictor
) (gs
->subcode
& ~GF_PREDICT_TAKEN
);
5477 /* Set the predictor of GIMPLE_PREDICT statement GS to PREDICT. */
5480 gimple_predict_set_predictor (gimple gs
, enum br_predictor predictor
)
5482 GIMPLE_CHECK (gs
, GIMPLE_PREDICT
);
5483 gs
->subcode
= (gs
->subcode
& GF_PREDICT_TAKEN
)
5484 | (unsigned) predictor
;
5488 /* Return the outcome of GIMPLE_PREDICT statement GS. */
5490 static inline enum prediction
5491 gimple_predict_outcome (gimple gs
)
5493 GIMPLE_CHECK (gs
, GIMPLE_PREDICT
);
5494 return (gs
->subcode
& GF_PREDICT_TAKEN
) ? TAKEN
: NOT_TAKEN
;
5498 /* Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME. */
5501 gimple_predict_set_outcome (gimple gs
, enum prediction outcome
)
5503 GIMPLE_CHECK (gs
, GIMPLE_PREDICT
);
5504 if (outcome
== TAKEN
)
5505 gs
->subcode
|= GF_PREDICT_TAKEN
;
5507 gs
->subcode
&= ~GF_PREDICT_TAKEN
;
5511 /* Return the type of the main expression computed by STMT. Return
5512 void_type_node if the statement computes nothing. */
5515 gimple_expr_type (const_gimple stmt
)
5517 enum gimple_code code
= gimple_code (stmt
);
5519 if (code
== GIMPLE_ASSIGN
|| code
== GIMPLE_CALL
)
5522 /* In general we want to pass out a type that can be substituted
5523 for both the RHS and the LHS types if there is a possibly
5524 useless conversion involved. That means returning the
5525 original RHS type as far as we can reconstruct it. */
5526 if (code
== GIMPLE_CALL
)
5527 type
= gimple_call_return_type (stmt
);
5529 switch (gimple_assign_rhs_code (stmt
))
5531 case POINTER_PLUS_EXPR
:
5532 type
= TREE_TYPE (gimple_assign_rhs1 (stmt
));
5536 /* As fallback use the type of the LHS. */
5537 type
= TREE_TYPE (gimple_get_lhs (stmt
));
5542 else if (code
== GIMPLE_COND
)
5543 return boolean_type_node
;
5545 return void_type_node
;
5548 /* Enum and arrays used for allocation stats. Keep in sync with
5549 gimple.c:gimple_alloc_kind_names. */
5550 enum gimple_alloc_kind
5552 gimple_alloc_kind_assign
, /* Assignments. */
5553 gimple_alloc_kind_phi
, /* PHI nodes. */
5554 gimple_alloc_kind_cond
, /* Conditionals. */
5555 gimple_alloc_kind_rest
, /* Everything else. */
5556 gimple_alloc_kind_all
5559 extern int gimple_alloc_counts
[];
5560 extern int gimple_alloc_sizes
[];
5562 /* Return the allocation kind for a given stmt CODE. */
5563 static inline enum gimple_alloc_kind
5564 gimple_alloc_kind (enum gimple_code code
)
5569 return gimple_alloc_kind_assign
;
5571 return gimple_alloc_kind_phi
;
5573 return gimple_alloc_kind_cond
;
5575 return gimple_alloc_kind_rest
;
5579 /* Return true if a location should not be emitted for this statement
5580 by annotate_all_with_location. */
5583 gimple_do_not_emit_location_p (gimple g
)
5585 return gimple_plf (g
, GF_PLF_1
);
5588 /* Mark statement G so a location will not be emitted by
5589 annotate_one_with_location. */
5592 gimple_set_do_not_emit_location (gimple g
)
5594 /* The PLF flags are initialized to 0 when a new tuple is created,
5595 so no need to initialize it anywhere. */
5596 gimple_set_plf (g
, GF_PLF_1
, true);
5600 /* Macros for showing usage statistics. */
5601 #define SCALE(x) ((unsigned long) ((x) < 1024*10 \
5603 : ((x) < 1024*1024*10 \
5605 : (x) / (1024*1024))))
5607 #define LABEL(x) ((x) < 1024*10 ? 'b' : ((x) < 1024*1024*10 ? 'k' : 'M'))
5609 #endif /* GCC_GIMPLE_H */