1 /* Gimple IR definitions.
3 Copyright 2007, 2008 Free Software Foundation, Inc.
4 Contributed by Aldy Hernandez <aldyh@redhat.com>
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
25 #include "pointer-set.h"
29 #include "hard-reg-set.h"
30 #include "basic-block.h"
31 #include "tree-ssa-operands.h"
34 DEF_VEC_ALLOC_P(gimple,heap);
35 DEF_VEC_ALLOC_P(gimple,gc);
37 DEF_VEC_P(gimple_seq);
38 DEF_VEC_ALLOC_P(gimple_seq,gc);
39 DEF_VEC_ALLOC_P(gimple_seq,heap);
42 #define DEFGSCODE(SYM, STRING, STRUCT) SYM,
45 LAST_AND_UNUSED_GIMPLE_CODE
48 extern const char *const gimple_code_name[];
49 extern const unsigned char gimple_rhs_class_table[];
51 /* Error out if a gimple tuple is addressed incorrectly. */
52 #if defined ENABLE_GIMPLE_CHECKING
53 extern void gimple_check_failed (const_gimple, const char *, int, \
54 const char *, enum gimple_code, \
55 enum tree_code) ATTRIBUTE_NORETURN;
56 extern void gimple_range_check_failed (const_gimple, const char *, int, \
57 const char *, enum gimple_code, \
58 enum gimple_code) ATTRIBUTE_NORETURN;
60 #define GIMPLE_CHECK(GS, CODE) \
62 const_gimple __gs = (GS); \
63 if (gimple_code (__gs) != (CODE)) \
64 gimple_check_failed (__gs, __FILE__, __LINE__, __FUNCTION__, \
67 #else /* not ENABLE_GIMPLE_CHECKING */
68 #define GIMPLE_CHECK(GS, CODE) (void)0
71 /* Class of GIMPLE expressions suitable for the RHS of assignments. See
72 get_gimple_rhs_class. */
75 GIMPLE_INVALID_RHS, /* The expression cannot be used on the RHS. */
76 GIMPLE_BINARY_RHS, /* The expression is a binary operation. */
77 GIMPLE_UNARY_RHS, /* The expression is a unary operation. */
78 GIMPLE_SINGLE_RHS /* The expression is a single object (an SSA
79 name, a _DECL, a _REF, etc. */
82 /* Specific flags for individual GIMPLE statements. These flags are
83 always stored in gimple_statement_base.subcode and they may only be
84 defined for statement codes that do not use sub-codes.
86 Values for the masks can overlap as long as the overlapping values
87 are never used in the same statement class.
89 The maximum mask value that can be defined is 1 << 15 (i.e., each
90 statement code can hold up to 16 bitflags).
92 Keep this list sorted. */
94 GF_ASM_INPUT = 1 << 0,
95 GF_ASM_VOLATILE = 1 << 1,
96 GF_CALL_CANNOT_INLINE = 1 << 0,
97 GF_CALL_FROM_THUNK = 1 << 1,
98 GF_CALL_RETURN_SLOT_OPT = 1 << 2,
99 GF_CALL_TAILCALL = 1 << 3,
100 GF_CALL_VA_ARG_PACK = 1 << 4,
101 GF_OMP_PARALLEL_COMBINED = 1 << 0,
103 /* True on an GIMPLE_OMP_RETURN statement if the return does not require
104 a thread synchronization via some sort of barrier. The exact barrier
105 that would otherwise be emitted is dependent on the OMP statement with
106 which this return is associated. */
107 GF_OMP_RETURN_NOWAIT = 1 << 0,
109 GF_OMP_SECTION_LAST = 1 << 0,
110 GF_PREDICT_TAKEN = 1 << 15
113 /* Masks for selecting a pass local flag (PLF) to work on. These
114 masks are used by gimple_set_plf and gimple_plf. */
120 /* A node in a gimple_seq_d. */
121 struct gimple_seq_node_d GTY((chain_next ("%h.next"), chain_prev ("%h.prev")))
124 struct gimple_seq_node_d *prev;
125 struct gimple_seq_node_d *next;
128 /* A double-linked sequence of gimple statements. */
129 struct gimple_seq_d GTY ((chain_next ("%h.next_free")))
131 /* First and last statements in the sequence. */
132 gimple_seq_node first;
133 gimple_seq_node last;
135 /* Sequences are created/destroyed frequently. To minimize
136 allocation activity, deallocated sequences are kept in a pool of
137 available sequences. This is the pointer to the next free
138 sequence in the pool. */
139 gimple_seq next_free;
143 /* Return the first node in GIMPLE sequence S. */
145 static inline gimple_seq_node
146 gimple_seq_first (const_gimple_seq s)
148 return s ? s->first : NULL;
152 /* Return the first statement in GIMPLE sequence S. */
155 gimple_seq_first_stmt (const_gimple_seq s)
157 gimple_seq_node n = gimple_seq_first (s);
158 return (n) ? n->stmt : NULL;
162 /* Return the last node in GIMPLE sequence S. */
164 static inline gimple_seq_node
165 gimple_seq_last (const_gimple_seq s)
167 return s ? s->last : NULL;
171 /* Return the last statement in GIMPLE sequence S. */
174 gimple_seq_last_stmt (const_gimple_seq s)
176 gimple_seq_node n = gimple_seq_last (s);
177 return (n) ? n->stmt : NULL;
181 /* Set the last node in GIMPLE sequence S to LAST. */
184 gimple_seq_set_last (gimple_seq s, gimple_seq_node last)
190 /* Set the first node in GIMPLE sequence S to FIRST. */
193 gimple_seq_set_first (gimple_seq s, gimple_seq_node first)
199 /* Return true if GIMPLE sequence S is empty. */
202 gimple_seq_empty_p (const_gimple_seq s)
204 return s == NULL || s->first == NULL;
208 void gimple_seq_add_stmt (gimple_seq *, gimple);
210 /* Allocate a new sequence and initialize its first element with STMT. */
212 static inline gimple_seq
213 gimple_seq_alloc_with_stmt (gimple stmt)
215 gimple_seq seq = NULL;
216 gimple_seq_add_stmt (&seq, stmt);
221 /* Returns the sequence of statements in BB. */
223 static inline gimple_seq
224 bb_seq (const_basic_block bb)
226 return (!(bb->flags & BB_RTL) && bb->il.gimple) ? bb->il.gimple->seq : NULL;
230 /* Sets the sequence of statements in BB to SEQ. */
233 set_bb_seq (basic_block bb, gimple_seq seq)
235 gcc_assert (!(bb->flags & BB_RTL));
236 bb->il.gimple->seq = seq;
239 /* Iterator object for GIMPLE statement sequences. */
243 /* Sequence node holding the current statement. */
246 /* Sequence and basic block holding the statement. These fields
247 are necessary to handle edge cases such as when statement is
248 added to an empty basic block or when the last statement of a
249 block/sequence is removed. */
252 } gimple_stmt_iterator;
255 /* Data structure definitions for GIMPLE tuples. NOTE: word markers
256 are for 64 bit hosts. */
258 struct gimple_statement_base GTY(())
261 Main identifying code for a tuple. */
262 ENUM_BITFIELD(gimple_code) code : 8;
264 /* Nonzero if a warning should not be emitted on this tuple. */
265 unsigned int no_warning : 1;
267 /* Nonzero if this tuple has been visited. Passes are responsible
268 for clearing this bit before using it. */
269 unsigned int visited : 1;
271 /* Nonzero if this tuple represents a non-temporal move. */
272 unsigned int nontemporal_move : 1;
274 /* Pass local flags. These flags are free for any pass to use as
275 they see fit. Passes should not assume that these flags contain
276 any useful value when the pass starts. Any initial state that
277 the pass requires should be set on entry to the pass. See
278 gimple_set_plf and gimple_plf for usage. */
279 unsigned int plf : 2;
281 /* Nonzero if this statement has been modified and needs to have its
282 operands rescanned. */
283 unsigned modified : 1;
285 /* Nonzero if this statement contains volatile operands. */
286 unsigned has_volatile_ops : 1;
288 /* Nonzero if this statement contains memory refernces. */
289 unsigned references_memory_p : 1;
291 /* The SUBCODE field can be used for tuple-specific flags for tuples
292 that do not require subcodes. Note that SUBCODE should be at
293 least as wide as tree codes, as several tuples store tree codes
295 unsigned int subcode : 16;
297 /* UID of this statement. */
301 Locus information for debug info. */
304 /* Number of operands in this tuple. */
308 Basic block holding this statement. */
309 struct basic_block_def *bb;
312 Lexical block holding this statement. */
317 /* Base structure for tuples with operands. */
319 struct gimple_statement_with_ops_base GTY(())
322 struct gimple_statement_base gsbase;
325 Symbols whose addresses are taken by this statement (i.e., they
326 appear inside ADDR_EXPR nodes). */
327 bitmap GTY((skip (""))) addresses_taken;
330 SSA operand vectors. NOTE: It should be possible to
331 amalgamate these vectors with the operand vector OP. However,
332 the SSA operand vectors are organized differently and contain
333 more information (like immediate use chaining). */
334 struct def_optype_d GTY((skip (""))) *def_ops;
335 struct use_optype_d GTY((skip (""))) *use_ops;
339 /* Statements that take register operands. */
341 struct gimple_statement_with_ops GTY(())
344 struct gimple_statement_with_ops_base opbase;
347 Operand vector. NOTE! This must always be the last field
348 of this structure. In particular, this means that this
349 structure cannot be embedded inside another one. */
350 tree GTY((length ("%h.opbase.gsbase.num_ops"))) op[1];
354 /* Base for statements that take both memory and register operands. */
356 struct gimple_statement_with_memory_ops_base GTY(())
359 struct gimple_statement_with_ops_base opbase;
362 Vectors for virtual operands. */
363 struct voptype_d GTY((skip (""))) *vdef_ops;
364 struct voptype_d GTY((skip (""))) *vuse_ops;
367 Symbols stored/loaded by this statement. */
368 bitmap GTY((skip (""))) stores;
369 bitmap GTY((skip (""))) loads;
373 /* Statements that take both memory and register operands. */
375 struct gimple_statement_with_memory_ops GTY(())
378 struct gimple_statement_with_memory_ops_base membase;
381 Operand vector. NOTE! This must always be the last field
382 of this structure. In particular, this means that this
383 structure cannot be embedded inside another one. */
384 tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
388 /* OpenMP statements (#pragma omp). */
390 struct gimple_statement_omp GTY(())
393 struct gimple_statement_base gsbase;
402 struct gimple_statement_bind GTY(())
405 struct gimple_statement_base gsbase;
408 Variables declared in this scope. */
412 This is different than the BLOCK field in gimple_statement_base,
413 which is analogous to TREE_BLOCK (i.e., the lexical block holding
414 this statement). This field is the equivalent of BIND_EXPR_BLOCK
415 in tree land (i.e., the lexical scope defined by this bind). See
426 struct gimple_statement_catch GTY(())
429 struct gimple_statement_base gsbase;
439 /* GIMPLE_EH_FILTER */
441 struct gimple_statement_eh_filter GTY(())
444 struct gimple_statement_base gsbase;
446 /* Subcode: EH_FILTER_MUST_NOT_THROW. A boolean flag analogous to
447 the tree counterpart. */
461 struct gimple_statement_phi GTY(())
464 struct gimple_statement_base gsbase;
474 struct phi_arg_d GTY ((length ("%h.nargs"))) args[1];
480 struct gimple_statement_resx GTY(())
483 struct gimple_statement_base gsbase;
486 Exception region number. */
493 struct gimple_statement_try GTY(())
496 struct gimple_statement_base gsbase;
499 Expression to evaluate. */
503 Cleanup expression. */
507 /* Kind of GIMPLE_TRY statements. */
508 enum gimple_try_flags
511 GIMPLE_TRY_CATCH = 1 << 0,
514 GIMPLE_TRY_FINALLY = 1 << 1,
515 GIMPLE_TRY_KIND = GIMPLE_TRY_CATCH | GIMPLE_TRY_FINALLY,
517 /* Analogous to TRY_CATCH_IS_CLEANUP. */
518 GIMPLE_TRY_CATCH_IS_CLEANUP = 1 << 2
521 /* GIMPLE_WITH_CLEANUP_EXPR */
523 struct gimple_statement_wce GTY(())
526 struct gimple_statement_base gsbase;
528 /* Subcode: CLEANUP_EH_ONLY. True if the cleanup should only be
529 executed if an exception is thrown, not on normal exit of its
530 scope. This flag is analogous to the CLEANUP_EH_ONLY flag
534 Cleanup expression. */
541 struct gimple_statement_asm GTY(())
544 struct gimple_statement_with_memory_ops_base membase;
547 __asm__ statement. */
551 Number of inputs, outputs and clobbers. */
557 Operand vector. NOTE! This must always be the last field
558 of this structure. In particular, this means that this
559 structure cannot be embedded inside another one. */
560 tree GTY((length ("%h.membase.opbase.gsbase.num_ops"))) op[1];
563 /* GIMPLE_OMP_CRITICAL */
565 struct gimple_statement_omp_critical GTY(())
568 struct gimple_statement_omp omp;
571 Critical section name. */
576 struct gimple_omp_for_iter GTY(())
578 /* Condition code. */
581 /* Index variable. */
596 struct gimple_statement_omp_for GTY(())
599 struct gimple_statement_omp omp;
605 Number of elements in iter array. */
609 struct gimple_omp_for_iter * GTY((length ("%h.collapse"))) iter;
612 Pre-body evaluated before the loop body begins. */
617 /* GIMPLE_OMP_PARALLEL */
619 struct gimple_statement_omp_parallel GTY(())
622 struct gimple_statement_omp omp;
629 Child function holding the body of the parallel region. */
633 Shared data argument. */
638 /* GIMPLE_OMP_TASK */
640 struct gimple_statement_omp_task GTY(())
643 struct gimple_statement_omp_parallel par;
646 Child function holding firstprivate initialization if needed. */
650 Size and alignment in bytes of the argument data block. */
656 /* GIMPLE_OMP_SECTION */
657 /* Uses struct gimple_statement_omp. */
660 /* GIMPLE_OMP_SECTIONS */
662 struct gimple_statement_omp_sections GTY(())
665 struct gimple_statement_omp omp;
671 The control variable used for deciding which of the sections to
676 /* GIMPLE_OMP_CONTINUE.
678 Note: This does not inherit from gimple_statement_omp, because we
679 do not need the body field. */
681 struct gimple_statement_omp_continue GTY(())
684 struct gimple_statement_base gsbase;
693 /* GIMPLE_OMP_SINGLE */
695 struct gimple_statement_omp_single GTY(())
698 struct gimple_statement_omp omp;
705 /* GIMPLE_OMP_ATOMIC_LOAD.
706 Note: This is based on gimple_statement_base, not g_s_omp, because g_s_omp
707 contains a sequence, which we don't need here. */
709 struct gimple_statement_omp_atomic_load GTY(())
712 struct gimple_statement_base gsbase;
718 /* GIMPLE_OMP_ATOMIC_STORE.
719 See note on GIMPLE_OMP_ATOMIC_LOAD. */
721 struct gimple_statement_omp_atomic_store GTY(())
724 struct gimple_statement_base gsbase;
730 enum gimple_statement_structure_enum {
731 #define DEFGSSTRUCT(SYM, STRING) SYM,
732 #include "gsstruct.def"
738 /* Define the overall contents of a gimple tuple. It may be any of the
739 structures declared above for various types of tuples. */
741 union gimple_statement_d GTY ((desc ("gimple_statement_structure (&%h)")))
743 struct gimple_statement_base GTY ((tag ("GSS_BASE"))) gsbase;
744 struct gimple_statement_with_ops GTY ((tag ("GSS_WITH_OPS"))) gsops;
745 struct gimple_statement_with_memory_ops GTY ((tag ("GSS_WITH_MEM_OPS"))) gsmem;
746 struct gimple_statement_omp GTY ((tag ("GSS_OMP"))) omp;
747 struct gimple_statement_bind GTY ((tag ("GSS_BIND"))) gimple_bind;
748 struct gimple_statement_catch GTY ((tag ("GSS_CATCH"))) gimple_catch;
749 struct gimple_statement_eh_filter GTY ((tag ("GSS_EH_FILTER"))) gimple_eh_filter;
750 struct gimple_statement_phi GTY ((tag ("GSS_PHI"))) gimple_phi;
751 struct gimple_statement_resx GTY ((tag ("GSS_RESX"))) gimple_resx;
752 struct gimple_statement_try GTY ((tag ("GSS_TRY"))) gimple_try;
753 struct gimple_statement_wce GTY ((tag ("GSS_WCE"))) gimple_wce;
754 struct gimple_statement_asm GTY ((tag ("GSS_ASM"))) gimple_asm;
755 struct gimple_statement_omp_critical GTY ((tag ("GSS_OMP_CRITICAL"))) gimple_omp_critical;
756 struct gimple_statement_omp_for GTY ((tag ("GSS_OMP_FOR"))) gimple_omp_for;
757 struct gimple_statement_omp_parallel GTY ((tag ("GSS_OMP_PARALLEL"))) gimple_omp_parallel;
758 struct gimple_statement_omp_task GTY ((tag ("GSS_OMP_TASK"))) gimple_omp_task;
759 struct gimple_statement_omp_sections GTY ((tag ("GSS_OMP_SECTIONS"))) gimple_omp_sections;
760 struct gimple_statement_omp_single GTY ((tag ("GSS_OMP_SINGLE"))) gimple_omp_single;
761 struct gimple_statement_omp_continue GTY ((tag ("GSS_OMP_CONTINUE"))) gimple_omp_continue;
762 struct gimple_statement_omp_atomic_load GTY ((tag ("GSS_OMP_ATOMIC_LOAD"))) gimple_omp_atomic_load;
763 struct gimple_statement_omp_atomic_store GTY ((tag ("GSS_OMP_ATOMIC_STORE"))) gimple_omp_atomic_store;
767 gimple gimple_build_return (tree);
769 gimple gimple_build_assign_stat (tree, tree MEM_STAT_DECL);
770 #define gimple_build_assign(l,r) gimple_build_assign_stat (l, r MEM_STAT_INFO)
772 void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *);
774 gimple gimple_build_assign_with_ops_stat (enum tree_code, tree, tree,
776 #define gimple_build_assign_with_ops(c,o1,o2,o3) \
777 gimple_build_assign_with_ops_stat (c, o1, o2, o3 MEM_STAT_INFO)
779 gimple gimple_build_call_vec (tree, VEC(tree, heap) *);
780 gimple gimple_build_call (tree, unsigned, ...);
781 gimple gimple_build_call_from_tree (tree);
782 gimple gimplify_assign (tree, tree, gimple_seq *);
783 gimple gimple_build_cond (enum tree_code, tree, tree, tree, tree);
784 gimple gimple_build_label (tree label);
785 gimple gimple_build_goto (tree dest);
786 gimple gimple_build_nop (void);
787 gimple gimple_build_bind (tree, gimple_seq, tree);
788 gimple gimple_build_asm (const char *, unsigned, unsigned, unsigned, ...);
789 gimple gimple_build_asm_vec (const char *, VEC(tree,gc) *, VEC(tree,gc) *,
791 gimple gimple_build_catch (tree, gimple_seq);
792 gimple gimple_build_eh_filter (tree, gimple_seq);
793 gimple gimple_build_try (gimple_seq, gimple_seq, unsigned int);
794 gimple gimple_build_wce (gimple_seq);
795 gimple gimple_build_resx (int);
796 gimple gimple_build_switch (unsigned, tree, tree, ...);
797 gimple gimple_build_switch_vec (tree, tree, VEC(tree,heap) *);
798 gimple gimple_build_omp_parallel (gimple_seq, tree, tree, tree);
799 gimple gimple_build_omp_task (gimple_seq, tree, tree, tree, tree, tree, tree);
800 gimple gimple_build_omp_for (gimple_seq, tree, size_t, gimple_seq);
801 gimple gimple_build_omp_critical (gimple_seq, tree);
802 gimple gimple_build_omp_section (gimple_seq);
803 gimple gimple_build_omp_continue (tree, tree);
804 gimple gimple_build_omp_master (gimple_seq);
805 gimple gimple_build_omp_return (bool);
806 gimple gimple_build_omp_ordered (gimple_seq);
807 gimple gimple_build_omp_sections (gimple_seq, tree);
808 gimple gimple_build_omp_sections_switch (void);
809 gimple gimple_build_omp_single (gimple_seq, tree);
810 gimple gimple_build_cdt (tree, tree);
811 gimple gimple_build_omp_atomic_load (tree, tree);
812 gimple gimple_build_omp_atomic_store (tree);
813 gimple gimple_build_predict (enum br_predictor, enum prediction);
814 enum gimple_statement_structure_enum gimple_statement_structure (gimple);
815 enum gimple_statement_structure_enum gss_for_assign (enum tree_code);
816 void sort_case_labels (VEC(tree,heap) *);
817 void gimple_set_body (tree, gimple_seq);
818 gimple_seq gimple_body (tree);
819 gimple_seq gimple_seq_alloc (void);
820 void gimple_seq_free (gimple_seq);
821 void gimple_seq_add_seq (gimple_seq *, gimple_seq);
822 gimple_seq gimple_seq_copy (gimple_seq);
823 int gimple_call_flags (const_gimple);
824 bool gimple_assign_copy_p (gimple);
825 bool gimple_assign_ssa_name_copy_p (gimple);
826 bool gimple_assign_single_p (gimple);
827 bool gimple_assign_unary_nop_p (gimple);
828 void gimple_set_bb (gimple, struct basic_block_def *);
829 tree gimple_fold (const_gimple);
830 void gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *, tree);
831 void gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *, enum tree_code,
833 tree gimple_get_lhs (const_gimple);
834 void gimple_set_lhs (gimple, tree);
835 gimple gimple_copy (gimple);
836 bool is_gimple_operand (const_tree);
837 void gimple_set_modified (gimple, bool);
838 void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, tree *);
839 gimple gimple_build_cond_from_tree (tree, tree, tree);
840 void gimple_cond_set_condition_from_tree (gimple, tree);
841 bool gimple_has_side_effects (const_gimple);
842 bool gimple_rhs_has_side_effects (const_gimple);
843 bool gimple_could_trap_p (gimple);
844 bool gimple_assign_rhs_could_trap_p (gimple);
845 void gimple_regimplify_operands (gimple, gimple_stmt_iterator *);
846 bool empty_body_p (gimple_seq);
847 unsigned get_gimple_rhs_num_ops (enum tree_code);
849 /* Returns true iff T is a valid GIMPLE statement. */
850 extern bool is_gimple_stmt (tree);
852 /* Returns true iff TYPE is a valid type for a scalar register variable. */
853 extern bool is_gimple_reg_type (tree);
854 /* Returns true iff T is a scalar register variable. */
855 extern bool is_gimple_reg (tree);
856 /* Returns true if T is a GIMPLE temporary variable, false otherwise. */
857 extern bool is_gimple_formal_tmp_var (tree);
858 /* Returns true if T is a GIMPLE temporary register variable. */
859 extern bool is_gimple_formal_tmp_reg (tree);
860 /* Returns true iff T is any sort of variable. */
861 extern bool is_gimple_variable (tree);
862 /* Returns true iff T is any sort of symbol. */
863 extern bool is_gimple_id (tree);
864 /* Returns true iff T is a variable or an INDIRECT_REF (of a variable). */
865 extern bool is_gimple_min_lval (tree);
866 /* Returns true iff T is something whose address can be taken. */
867 extern bool is_gimple_addressable (tree);
868 /* Returns true iff T is any valid GIMPLE lvalue. */
869 extern bool is_gimple_lvalue (tree);
871 /* Returns true iff T is a GIMPLE address. */
872 bool is_gimple_address (const_tree);
873 /* Returns true iff T is a GIMPLE invariant address. */
874 bool is_gimple_invariant_address (const_tree);
875 /* Returns true iff T is a GIMPLE invariant address at interprocedural
877 bool is_gimple_ip_invariant_address (const_tree);
878 /* Returns true iff T is a valid GIMPLE constant. */
879 bool is_gimple_constant (const_tree);
880 /* Returns true iff T is a GIMPLE restricted function invariant. */
881 extern bool is_gimple_min_invariant (const_tree);
882 /* Returns true iff T is a GIMPLE restricted interprecodural invariant. */
883 extern bool is_gimple_ip_invariant (const_tree);
884 /* Returns true iff T is a GIMPLE rvalue. */
885 extern bool is_gimple_val (tree);
886 /* Returns true iff T is a GIMPLE asm statement input. */
887 extern bool is_gimple_asm_val (tree);
888 /* Returns true iff T is a valid rhs for a MODIFY_EXPR where the LHS is a
889 GIMPLE temporary, a renamed user variable, or something else,
891 extern bool is_gimple_formal_tmp_rhs (tree);
892 extern bool is_gimple_reg_rhs (tree);
893 extern bool is_gimple_mem_rhs (tree);
895 /* Returns true iff T is a valid if-statement condition. */
896 extern bool is_gimple_condexpr (tree);
898 /* Returns true iff T is a type conversion. */
899 extern bool is_gimple_cast (tree);
900 /* Returns true iff T is a variable that does not need to live in memory. */
901 extern bool is_gimple_non_addressable (tree t);
903 /* Returns true iff T is a valid call address expression. */
904 extern bool is_gimple_call_addr (tree);
905 /* If T makes a function call, returns the CALL_EXPR operand. */
906 extern tree get_call_expr_in (tree t);
908 extern void recalculate_side_effects (tree);
911 extern tree create_tmp_var_raw (tree, const char *);
912 extern tree create_tmp_var_name (const char *);
913 extern tree create_tmp_var (tree, const char *);
914 extern tree get_initialized_tmp_var (tree, gimple_seq *, gimple_seq *);
915 extern tree get_formal_tmp_var (tree, gimple_seq *);
916 extern void declare_vars (tree, gimple, bool);
917 extern void tree_annotate_all_with_location (tree *, location_t);
918 extern void annotate_all_with_location (gimple_seq, location_t);
920 /* Validation of GIMPLE expressions. Note that these predicates only check
921 the basic form of the expression, they don't recurse to make sure that
922 underlying nodes are also of the right form. */
923 typedef bool (*gimple_predicate)(tree);
926 /* FIXME we should deduce this from the predicate. */
927 typedef enum fallback_t {
928 fb_none = 0, /* Do not generate a temporary. */
930 fb_rvalue = 1, /* Generate an rvalue to hold the result of a
931 gimplified expression. */
933 fb_lvalue = 2, /* Generate an lvalue to hold the result of a
934 gimplified expression. */
936 fb_mayfail = 4, /* Gimplification may fail. Error issued
938 fb_either= fb_rvalue | fb_lvalue
941 enum gimplify_status {
942 GS_ERROR = -2, /* Something Bad Seen. */
943 GS_UNHANDLED = -1, /* A langhook result for "I dunno". */
944 GS_OK = 0, /* We did something, maybe more to do. */
945 GS_ALL_DONE = 1 /* The expression is fully gimplified. */
950 struct gimplify_ctx *prev_context;
952 VEC(gimple,heap) *bind_expr_stack;
954 gimple_seq conditional_cleanups;
958 VEC(tree,heap) *case_labels;
959 /* The formal temporary table. Should this be persistent? */
965 bool allow_rhs_cond_expr;
968 extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
969 bool (*) (tree), fallback_t);
970 extern void gimplify_type_sizes (tree, gimple_seq *);
971 extern void gimplify_one_sizepos (tree *, gimple_seq *);
972 extern bool gimplify_stmt (tree *, gimple_seq *);
973 extern gimple gimplify_body (tree *, tree, bool);
974 extern void push_gimplify_context (struct gimplify_ctx *);
975 extern void pop_gimplify_context (gimple);
976 extern void gimplify_and_add (tree, gimple_seq *);
978 /* Miscellaneous helpers. */
979 extern void gimple_add_tmp_var (tree);
980 extern gimple gimple_current_bind_expr (void);
981 extern VEC(gimple, heap) *gimple_bind_expr_stack (void);
982 extern tree voidify_wrapper_expr (tree, tree);
983 extern tree build_and_jump (tree *);
984 extern tree alloc_stmt_list (void);
985 extern void free_stmt_list (tree);
986 extern tree force_labels_r (tree *, int *, void *);
987 extern enum gimplify_status gimplify_va_arg_expr (tree *, gimple_seq *,
989 struct gimplify_omp_ctx;
990 extern void omp_firstprivatize_variable (struct gimplify_omp_ctx *, tree);
991 extern tree gimple_boolify (tree);
992 extern gimple_predicate rhs_predicate_for (tree);
993 extern tree canonicalize_cond_expr_cond (tree);
996 extern void diagnose_omp_structured_block_errors (tree);
997 extern tree omp_reduction_init (tree, tree);
999 /* In tree-nested.c. */
1000 extern void lower_nested_functions (tree);
1001 extern void insert_field_into_struct (tree, tree);
1003 /* In gimplify.c. */
1004 extern void gimplify_function_tree (tree);
1006 /* In cfgexpand.c. */
1007 extern tree gimple_assign_rhs_to_tree (gimple);
1010 extern bool validate_gimple_arglist (const_gimple, ...);
1012 /* In tree-ssa-operands.c */
1013 extern void gimple_add_to_addresses_taken (gimple, tree);
1016 extern bool tree_ssa_useless_type_conversion (tree);
1017 extern bool useless_type_conversion_p (tree, tree);
1018 extern bool types_compatible_p (tree, tree);
1020 /* Return the code for GIMPLE statement G. */
1022 static inline enum gimple_code
1023 gimple_code (const_gimple g)
1025 return g->gsbase.code;
1029 /* Return true if statement G has sub-statements. This is only true for
1030 High GIMPLE statements. */
1033 gimple_has_substatements (gimple g)
1035 switch (gimple_code (g))
1039 case GIMPLE_EH_FILTER:
1041 case GIMPLE_OMP_FOR:
1042 case GIMPLE_OMP_MASTER:
1043 case GIMPLE_OMP_ORDERED:
1044 case GIMPLE_OMP_SECTION:
1045 case GIMPLE_OMP_PARALLEL:
1046 case GIMPLE_OMP_TASK:
1047 case GIMPLE_OMP_SECTIONS:
1048 case GIMPLE_OMP_SINGLE:
1049 case GIMPLE_WITH_CLEANUP_EXPR:
1058 /* Return the basic block holding statement G. */
1060 static inline struct basic_block_def *
1061 gimple_bb (const_gimple g)
1063 return g->gsbase.bb;
1067 /* Return the lexical scope block holding statement G. */
1070 gimple_block (const_gimple g)
1072 return g->gsbase.block;
1076 /* Set BLOCK to be the lexical scope block holding statement G. */
1079 gimple_set_block (gimple g, tree block)
1081 g->gsbase.block = block;
1085 /* Return location information for statement G. */
1087 static inline location_t
1088 gimple_location (const_gimple g)
1090 return g->gsbase.location;
1093 /* Return pointer to location information for statement G. */
1095 static inline const location_t *
1096 gimple_location_ptr (const_gimple g)
1098 return &g->gsbase.location;
1102 /* Set location information for statement G. */
1105 gimple_set_location (gimple g, location_t location)
1107 g->gsbase.location = location;
1111 /* Return true if G contains location information. */
1114 gimple_has_location (const_gimple g)
1116 return gimple_location (g) != UNKNOWN_LOCATION;
1120 /* Return the file name of the location of STMT. */
1122 static inline const char *
1123 gimple_filename (const_gimple stmt)
1125 return LOCATION_FILE (gimple_location (stmt));
1129 /* Return the line number of the location of STMT. */
1132 gimple_lineno (const_gimple stmt)
1134 return LOCATION_LINE (gimple_location (stmt));
1138 /* Determine whether SEQ is a singleton. */
1141 gimple_seq_singleton_p (gimple_seq seq)
1143 return ((gimple_seq_first (seq) != NULL)
1144 && (gimple_seq_first (seq) == gimple_seq_last (seq)));
1147 /* Return true if no warnings should be emitted for statement STMT. */
1150 gimple_no_warning_p (const_gimple stmt)
1152 return stmt->gsbase.no_warning;
1155 /* Set the no_warning flag of STMT to NO_WARNING. */
1158 gimple_set_no_warning (gimple stmt, bool no_warning)
1160 stmt->gsbase.no_warning = (unsigned) no_warning;
1163 /* Set the visited status on statement STMT to VISITED_P. */
1166 gimple_set_visited (gimple stmt, bool visited_p)
1168 stmt->gsbase.visited = (unsigned) visited_p;
1172 /* Return the visited status for statement STMT. */
1175 gimple_visited_p (gimple stmt)
1177 return stmt->gsbase.visited;
1181 /* Set pass local flag PLF on statement STMT to VAL_P. */
1184 gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
1187 stmt->gsbase.plf |= (unsigned int) plf;
1189 stmt->gsbase.plf &= ~((unsigned int) plf);
1193 /* Return the value of pass local flag PLF on statement STMT. */
1195 static inline unsigned int
1196 gimple_plf (gimple stmt, enum plf_mask plf)
1198 return stmt->gsbase.plf & ((unsigned int) plf);
1202 /* Set the uid of statement */
1205 gimple_set_uid (gimple g, unsigned uid)
1207 g->gsbase.uid = uid;
1211 /* Return the uid of statement */
1213 static inline unsigned
1214 gimple_uid (const_gimple g)
1216 return g->gsbase.uid;
1220 /* Return true if GIMPLE statement G has register or memory operands. */
1223 gimple_has_ops (const_gimple g)
1225 return gimple_code (g) >= GIMPLE_COND && gimple_code (g) <= GIMPLE_RETURN;
1229 /* Return true if GIMPLE statement G has memory operands. */
1232 gimple_has_mem_ops (const_gimple g)
1234 return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
1237 /* Return the set of addresses taken by statement G. */
1239 static inline bitmap
1240 gimple_addresses_taken (const_gimple g)
1242 if (gimple_has_ops (g))
1243 return g->gsops.opbase.addresses_taken;
1249 /* Return a pointer to the set of addresses taken by statement G. */
1251 static inline bitmap *
1252 gimple_addresses_taken_ptr (gimple g)
1254 if (gimple_has_ops (g))
1255 return &g->gsops.opbase.addresses_taken;
1261 /* Set B to be the set of addresses taken by statement G. The
1262 previous set is freed. */
1265 gimple_set_addresses_taken (gimple g, bitmap b)
1267 gcc_assert (gimple_has_ops (g));
1268 BITMAP_FREE (g->gsops.opbase.addresses_taken);
1269 g->gsops.opbase.addresses_taken = b;
1273 /* Return the set of DEF operands for statement G. */
1275 static inline struct def_optype_d *
1276 gimple_def_ops (const_gimple g)
1278 if (!gimple_has_ops (g))
1280 return g->gsops.opbase.def_ops;
1284 /* Set DEF to be the set of DEF operands for statement G. */
1287 gimple_set_def_ops (gimple g, struct def_optype_d *def)
1289 gcc_assert (gimple_has_ops (g));
1290 g->gsops.opbase.def_ops = def;
1294 /* Return the set of USE operands for statement G. */
1296 static inline struct use_optype_d *
1297 gimple_use_ops (const_gimple g)
1299 if (!gimple_has_ops (g))
1301 return g->gsops.opbase.use_ops;
1305 /* Set USE to be the set of USE operands for statement G. */
1308 gimple_set_use_ops (gimple g, struct use_optype_d *use)
1310 gcc_assert (gimple_has_ops (g));
1311 g->gsops.opbase.use_ops = use;
1315 /* Return the set of VUSE operands for statement G. */
1317 static inline struct voptype_d *
1318 gimple_vuse_ops (const_gimple g)
1320 if (!gimple_has_mem_ops (g))
1322 return g->gsmem.membase.vuse_ops;
1326 /* Set OPS to be the set of VUSE operands for statement G. */
1329 gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
1331 gcc_assert (gimple_has_mem_ops (g));
1332 g->gsmem.membase.vuse_ops = ops;
1336 /* Return the set of VDEF operands for statement G. */
1338 static inline struct voptype_d *
1339 gimple_vdef_ops (const_gimple g)
1341 if (!gimple_has_mem_ops (g))
1343 return g->gsmem.membase.vdef_ops;
1347 /* Set OPS to be the set of VDEF operands for statement G. */
1350 gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
1352 gcc_assert (gimple_has_mem_ops (g));
1353 g->gsmem.membase.vdef_ops = ops;
1357 /* Return the set of symbols loaded by statement G. Each element of the
1358 set is the DECL_UID of the corresponding symbol. */
1360 static inline bitmap
1361 gimple_loaded_syms (const_gimple g)
1363 if (!gimple_has_mem_ops (g))
1365 return g->gsmem.membase.loads;
1369 /* Return the set of symbols stored by statement G. Each element of
1370 the set is the DECL_UID of the corresponding symbol. */
1372 static inline bitmap
1373 gimple_stored_syms (const_gimple g)
1375 if (!gimple_has_mem_ops (g))
1377 return g->gsmem.membase.stores;
1381 /* Return true if statement G has operands and the modified field has
1385 gimple_modified_p (const_gimple g)
1387 return (gimple_has_ops (g)) ? (bool) g->gsbase.modified : false;
1390 /* Return the type of the main expression computed by STMT. Return
1391 void_type_node if the statement computes nothing. */
1394 gimple_expr_type (const_gimple stmt)
1396 enum gimple_code code = gimple_code (stmt);
1398 if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
1400 tree type = TREE_TYPE (gimple_get_lhs (stmt));
1401 /* Integral sub-types are never the type of the expression,
1402 but they still can be the type of the result as the base
1403 type (in which expressions are computed) is trivially
1404 convertible to one of its sub-types. So always return
1405 the base type here. */
1406 if (INTEGRAL_TYPE_P (type)
1408 /* But only if they are trivially convertible. */
1409 && useless_type_conversion_p (type, TREE_TYPE (type)))
1410 type = TREE_TYPE (type);
1413 else if (code == GIMPLE_COND)
1414 return boolean_type_node;
1416 return void_type_node;
1420 /* Return the tree code for the expression computed by STMT. This is
1421 only valid for GIMPLE_COND, GIMPLE_CALL and GIMPLE_ASSIGN. For
1422 GIMPLE_CALL, return CALL_EXPR as the expression code for
1423 consistency. This is useful when the caller needs to deal with the
1424 three kinds of computation that GIMPLE supports. */
1426 static inline enum tree_code
1427 gimple_expr_code (const_gimple stmt)
1429 enum gimple_code code = gimple_code (stmt);
1430 if (code == GIMPLE_ASSIGN || code == GIMPLE_COND)
1431 return (enum tree_code) stmt->gsbase.subcode;
1432 else if (code == GIMPLE_CALL)
1439 /* Mark statement S as modified, and update it. */
1442 update_stmt (gimple s)
1444 if (gimple_has_ops (s))
1446 gimple_set_modified (s, true);
1447 update_stmt_operands (s);
1451 /* Update statement S if it has been optimized. */
1454 update_stmt_if_modified (gimple s)
1456 if (gimple_modified_p (s))
1457 update_stmt_operands (s);
1460 /* Return true if statement STMT contains volatile operands. */
1463 gimple_has_volatile_ops (const_gimple stmt)
1465 if (gimple_has_mem_ops (stmt))
1466 return stmt->gsbase.has_volatile_ops;
1472 /* Set the HAS_VOLATILE_OPS flag to VOLATILEP. */
1475 gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
1477 if (gimple_has_mem_ops (stmt))
1478 stmt->gsbase.has_volatile_ops = (unsigned) volatilep;
1482 /* Return true if statement STMT may access memory. */
1485 gimple_references_memory_p (gimple stmt)
1487 return gimple_has_mem_ops (stmt) && stmt->gsbase.references_memory_p;
1491 /* Set the REFERENCES_MEMORY_P flag for STMT to MEM_P. */
1494 gimple_set_references_memory (gimple stmt, bool mem_p)
1496 if (gimple_has_mem_ops (stmt))
1497 stmt->gsbase.references_memory_p = (unsigned) mem_p;
1500 /* Return the subcode for OMP statement S. */
1502 static inline unsigned
1503 gimple_omp_subcode (const_gimple s)
1505 gcc_assert (gimple_code (s) >= GIMPLE_OMP_ATOMIC_LOAD
1506 && gimple_code (s) <= GIMPLE_OMP_SINGLE);
1507 return s->gsbase.subcode;
1510 /* Set the subcode for OMP statement S to SUBCODE. */
1513 gimple_omp_set_subcode (gimple s, unsigned int subcode)
1515 /* We only have 16 bits for the subcode. Assert that we are not
1517 gcc_assert (subcode < (1 << 16));
1518 s->gsbase.subcode = subcode;
1521 /* Set the nowait flag on OMP_RETURN statement S. */
1524 gimple_omp_return_set_nowait (gimple s)
1526 GIMPLE_CHECK (s, GIMPLE_OMP_RETURN);
1527 s->gsbase.subcode |= GF_OMP_RETURN_NOWAIT;
1531 /* Return true if OMP return statement G has the GF_OMP_RETURN_NOWAIT
1535 gimple_omp_return_nowait_p (const_gimple g)
1537 GIMPLE_CHECK (g, GIMPLE_OMP_RETURN);
1538 return (gimple_omp_subcode (g) & GF_OMP_RETURN_NOWAIT) != 0;
1542 /* Return true if OMP section statement G has the GF_OMP_SECTION_LAST
1546 gimple_omp_section_last_p (const_gimple g)
1548 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
1549 return (gimple_omp_subcode (g) & GF_OMP_SECTION_LAST) != 0;
1553 /* Set the GF_OMP_SECTION_LAST flag on G. */
1556 gimple_omp_section_set_last (gimple g)
1558 GIMPLE_CHECK (g, GIMPLE_OMP_SECTION);
1559 g->gsbase.subcode |= GF_OMP_SECTION_LAST;
1563 /* Return true if OMP parallel statement G has the
1564 GF_OMP_PARALLEL_COMBINED flag set. */
1567 gimple_omp_parallel_combined_p (const_gimple g)
1569 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
1570 return (gimple_omp_subcode (g) & GF_OMP_PARALLEL_COMBINED) != 0;
1574 /* Set the GF_OMP_PARALLEL_COMBINED field in G depending on the boolean
1575 value of COMBINED_P. */
1578 gimple_omp_parallel_set_combined_p (gimple g, bool combined_p)
1580 GIMPLE_CHECK (g, GIMPLE_OMP_PARALLEL);
1582 g->gsbase.subcode |= GF_OMP_PARALLEL_COMBINED;
1584 g->gsbase.subcode &= ~GF_OMP_PARALLEL_COMBINED;
1588 /* Return the number of operands for statement GS. */
1590 static inline unsigned
1591 gimple_num_ops (const_gimple gs)
1593 return gs->gsbase.num_ops;
1597 /* Set the number of operands for statement GS. */
1600 gimple_set_num_ops (gimple gs, unsigned num_ops)
1602 gs->gsbase.num_ops = num_ops;
1606 /* Return the array of operands for statement GS. */
1608 static inline tree *
1609 gimple_ops (gimple gs)
1611 /* Offset in bytes to the location of the operand vector in every
1612 tuple structure. Defined in gimple.c */
1613 extern size_t const gimple_ops_offset_[];
1615 if (!gimple_has_ops (gs))
1618 /* All the tuples have their operand vector at the very bottom
1619 of the structure. */
1620 return ((tree *) ((char *) gs + gimple_ops_offset_[gimple_code (gs)]));
1624 /* Return operand I for statement GS. */
1627 gimple_op (const_gimple gs, unsigned i)
1629 if (gimple_has_ops (gs))
1631 gcc_assert (i < gimple_num_ops (gs));
1632 return gimple_ops (CONST_CAST_GIMPLE (gs))[i];
1638 /* Return a pointer to operand I for statement GS. */
1640 static inline tree *
1641 gimple_op_ptr (const_gimple gs, unsigned i)
1643 if (gimple_has_ops (gs))
1645 gcc_assert (i < gimple_num_ops (gs));
1646 return gimple_ops (CONST_CAST_GIMPLE (gs)) + i;
1652 /* Set operand I of statement GS to OP. */
1655 gimple_set_op (gimple gs, unsigned i, tree op)
1657 gcc_assert (gimple_has_ops (gs) && i < gimple_num_ops (gs));
1659 /* Note. It may be tempting to assert that OP matches
1660 is_gimple_operand, but that would be wrong. Different tuples
1661 accept slightly different sets of tree operands. Each caller
1662 should perform its own validation. */
1663 gimple_ops (gs)[i] = op;
1666 /* Return true if GS is a GIMPLE_ASSIGN. */
1669 is_gimple_assign (const_gimple gs)
1671 return gimple_code (gs) == GIMPLE_ASSIGN;
1674 /* Determine if expression CODE is one of the valid expressions that can
1675 be used on the RHS of GIMPLE assignments. */
1677 static inline enum gimple_rhs_class
1678 get_gimple_rhs_class (enum tree_code code)
1680 return (enum gimple_rhs_class) gimple_rhs_class_table[(int) code];
1683 /* Return the LHS of assignment statement GS. */
1686 gimple_assign_lhs (const_gimple gs)
1688 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1689 return gimple_op (gs, 0);
1693 /* Return a pointer to the LHS of assignment statement GS. */
1695 static inline tree *
1696 gimple_assign_lhs_ptr (const_gimple gs)
1698 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1699 return gimple_op_ptr (gs, 0);
1703 /* Set LHS to be the LHS operand of assignment statement GS. */
1706 gimple_assign_set_lhs (gimple gs, tree lhs)
1708 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1709 gcc_assert (is_gimple_operand (lhs));
1710 gimple_set_op (gs, 0, lhs);
1712 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1713 SSA_NAME_DEF_STMT (lhs) = gs;
1717 /* Return the first operand on the RHS of assignment statement GS. */
1720 gimple_assign_rhs1 (const_gimple gs)
1722 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1723 return gimple_op (gs, 1);
1727 /* Return a pointer to the first operand on the RHS of assignment
1730 static inline tree *
1731 gimple_assign_rhs1_ptr (const_gimple gs)
1733 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1734 return gimple_op_ptr (gs, 1);
1737 /* Set RHS to be the first operand on the RHS of assignment statement GS. */
1740 gimple_assign_set_rhs1 (gimple gs, tree rhs)
1742 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1744 /* If there are 3 or more operands, the 2 operands on the RHS must be
1746 if (gimple_num_ops (gs) >= 3)
1747 gcc_assert (is_gimple_val (rhs));
1749 gcc_assert (is_gimple_operand (rhs));
1751 gimple_set_op (gs, 1, rhs);
1755 /* Return the second operand on the RHS of assignment statement GS.
1756 If GS does not have two operands, NULL is returned instead. */
1759 gimple_assign_rhs2 (const_gimple gs)
1761 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1763 if (gimple_num_ops (gs) >= 3)
1764 return gimple_op (gs, 2);
1770 /* Return a pointer to the second operand on the RHS of assignment
1773 static inline tree *
1774 gimple_assign_rhs2_ptr (const_gimple gs)
1776 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1777 return gimple_op_ptr (gs, 2);
1781 /* Set RHS to be the second operand on the RHS of assignment statement GS. */
1784 gimple_assign_set_rhs2 (gimple gs, tree rhs)
1786 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1788 /* The 2 operands on the RHS must be GIMPLE values. */
1789 gcc_assert (is_gimple_val (rhs));
1791 gimple_set_op (gs, 2, rhs);
1794 /* Returns true if GS is a nontemporal move. */
1797 gimple_assign_nontemporal_move_p (const_gimple gs)
1799 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1800 return gs->gsbase.nontemporal_move;
1803 /* Sets nontemporal move flag of GS to NONTEMPORAL. */
1806 gimple_assign_set_nontemporal_move (gimple gs, bool nontemporal)
1808 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1809 gs->gsbase.nontemporal_move = nontemporal;
1813 /* Return the code of the expression computed on the rhs of assignment
1814 statement GS. In case that the RHS is a single object, returns the
1815 tree code of the object. */
1817 static inline enum tree_code
1818 gimple_assign_rhs_code (const_gimple gs)
1820 enum tree_code code;
1821 GIMPLE_CHECK (gs, GIMPLE_ASSIGN);
1823 code = gimple_expr_code (gs);
1824 if (get_gimple_rhs_class (code) == GIMPLE_SINGLE_RHS)
1825 code = TREE_CODE (gimple_assign_rhs1 (gs));
1831 /* Set CODE to be the code for the expression computed on the RHS of
1835 gimple_assign_set_rhs_code (gimple s, enum tree_code code)
1837 GIMPLE_CHECK (s, GIMPLE_ASSIGN);
1838 s->gsbase.subcode = code;
1842 /* Return the gimple rhs class of the code of the expression computed on
1843 the rhs of assignment statement GS.
1844 This will never return GIMPLE_INVALID_RHS. */
1846 static inline enum gimple_rhs_class
1847 gimple_assign_rhs_class (const_gimple gs)
1849 return get_gimple_rhs_class (gimple_assign_rhs_code (gs));
1853 /* Return true if S is a type-cast assignment. */
1856 gimple_assign_cast_p (gimple s)
1858 if (is_gimple_assign (s))
1860 enum tree_code sc = gimple_assign_rhs_code (s);
1861 return CONVERT_EXPR_CODE_P (sc)
1862 || sc == VIEW_CONVERT_EXPR
1863 || sc == FIX_TRUNC_EXPR;
1870 /* Return true if GS is a GIMPLE_CALL. */
1873 is_gimple_call (const_gimple gs)
1875 return gimple_code (gs) == GIMPLE_CALL;
1878 /* Return the LHS of call statement GS. */
1881 gimple_call_lhs (const_gimple gs)
1883 GIMPLE_CHECK (gs, GIMPLE_CALL);
1884 return gimple_op (gs, 0);
1888 /* Return a pointer to the LHS of call statement GS. */
1890 static inline tree *
1891 gimple_call_lhs_ptr (const_gimple gs)
1893 GIMPLE_CHECK (gs, GIMPLE_CALL);
1894 return gimple_op_ptr (gs, 0);
1898 /* Set LHS to be the LHS operand of call statement GS. */
1901 gimple_call_set_lhs (gimple gs, tree lhs)
1903 GIMPLE_CHECK (gs, GIMPLE_CALL);
1904 gcc_assert (!lhs || is_gimple_operand (lhs));
1905 gimple_set_op (gs, 0, lhs);
1906 if (lhs && TREE_CODE (lhs) == SSA_NAME)
1907 SSA_NAME_DEF_STMT (lhs) = gs;
1911 /* Return the tree node representing the function called by call
1915 gimple_call_fn (const_gimple gs)
1917 GIMPLE_CHECK (gs, GIMPLE_CALL);
1918 return gimple_op (gs, 1);
1922 /* Return a pointer to the tree node representing the function called by call
1925 static inline tree *
1926 gimple_call_fn_ptr (const_gimple gs)
1928 GIMPLE_CHECK (gs, GIMPLE_CALL);
1929 return gimple_op_ptr (gs, 1);
1933 /* Set FN to be the function called by call statement GS. */
1936 gimple_call_set_fn (gimple gs, tree fn)
1938 GIMPLE_CHECK (gs, GIMPLE_CALL);
1939 gcc_assert (is_gimple_operand (fn));
1940 gimple_set_op (gs, 1, fn);
1944 /* Set FNDECL to be the function called by call statement GS. */
1947 gimple_call_set_fndecl (gimple gs, tree decl)
1949 GIMPLE_CHECK (gs, GIMPLE_CALL);
1950 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
1951 gimple_set_op (gs, 1, build_fold_addr_expr (decl));
1955 /* If a given GIMPLE_CALL's callee is a FUNCTION_DECL, return it.
1956 Otherwise return NULL. This function is analogous to
1957 get_callee_fndecl in tree land. */
1960 gimple_call_fndecl (const_gimple gs)
1962 tree addr = gimple_call_fn (gs);
1963 if (TREE_CODE (addr) == ADDR_EXPR)
1965 gcc_assert (TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL);
1966 return TREE_OPERAND (addr, 0);
1972 /* Return the type returned by call statement GS. */
1975 gimple_call_return_type (const_gimple gs)
1977 tree fn = gimple_call_fn (gs);
1978 tree type = TREE_TYPE (fn);
1980 /* See through the pointer. */
1981 gcc_assert (POINTER_TYPE_P (type));
1982 type = TREE_TYPE (type);
1984 gcc_assert (TREE_CODE (type) == FUNCTION_TYPE
1985 || TREE_CODE (type) == METHOD_TYPE);
1987 /* The type returned by a FUNCTION_DECL is the type of its
1989 return TREE_TYPE (type);
1993 /* Return the static chain for call statement GS. */
1996 gimple_call_chain (const_gimple gs)
1998 GIMPLE_CHECK (gs, GIMPLE_CALL);
1999 return gimple_op (gs, 2);
2003 /* Return a pointer to the static chain for call statement GS. */
2005 static inline tree *
2006 gimple_call_chain_ptr (const_gimple gs)
2008 GIMPLE_CHECK (gs, GIMPLE_CALL);
2009 return gimple_op_ptr (gs, 2);
2012 /* Set CHAIN to be the static chain for call statement GS. */
2015 gimple_call_set_chain (gimple gs, tree chain)
2017 GIMPLE_CHECK (gs, GIMPLE_CALL);
2018 gcc_assert (chain == NULL
2019 || TREE_CODE (chain) == ADDR_EXPR
2020 || SSA_VAR_P (chain));
2021 gimple_set_op (gs, 2, chain);
2025 /* Return the number of arguments used by call statement GS. */
2027 static inline unsigned
2028 gimple_call_num_args (const_gimple gs)
2031 GIMPLE_CHECK (gs, GIMPLE_CALL);
2032 num_ops = gimple_num_ops (gs);
2033 gcc_assert (num_ops >= 3);
2038 /* Return the argument at position INDEX for call statement GS. */
2041 gimple_call_arg (const_gimple gs, unsigned index)
2043 GIMPLE_CHECK (gs, GIMPLE_CALL);
2044 return gimple_op (gs, index + 3);
2048 /* Return a pointer to the argument at position INDEX for call
2051 static inline tree *
2052 gimple_call_arg_ptr (const_gimple gs, unsigned index)
2054 GIMPLE_CHECK (gs, GIMPLE_CALL);
2055 return gimple_op_ptr (gs, index + 3);
2059 /* Set ARG to be the argument at position INDEX for call statement GS. */
2062 gimple_call_set_arg (gimple gs, unsigned index, tree arg)
2064 GIMPLE_CHECK (gs, GIMPLE_CALL);
2065 gcc_assert (is_gimple_operand (arg));
2066 gimple_set_op (gs, index + 3, arg);
2070 /* If TAIL_P is true, mark call statement S as being a tail call
2071 (i.e., a call just before the exit of a function). These calls are
2072 candidate for tail call optimization. */
2075 gimple_call_set_tail (gimple s, bool tail_p)
2077 GIMPLE_CHECK (s, GIMPLE_CALL);
2079 s->gsbase.subcode |= GF_CALL_TAILCALL;
2081 s->gsbase.subcode &= ~GF_CALL_TAILCALL;
2085 /* Return true if GIMPLE_CALL S is marked as a tail call. */
2088 gimple_call_tail_p (gimple s)
2090 GIMPLE_CHECK (s, GIMPLE_CALL);
2091 return (s->gsbase.subcode & GF_CALL_TAILCALL) != 0;
2095 /* Set the inlinable status of GIMPLE_CALL S to INLINABLE_P. */
2098 gimple_call_set_cannot_inline (gimple s, bool inlinable_p)
2100 GIMPLE_CHECK (s, GIMPLE_CALL);
2102 s->gsbase.subcode |= GF_CALL_CANNOT_INLINE;
2104 s->gsbase.subcode &= ~GF_CALL_CANNOT_INLINE;
2108 /* Return true if GIMPLE_CALL S cannot be inlined. */
2111 gimple_call_cannot_inline_p (gimple s)
2113 GIMPLE_CHECK (s, GIMPLE_CALL);
2114 return (s->gsbase.subcode & GF_CALL_CANNOT_INLINE) != 0;
2118 /* If RETURN_SLOT_OPT_P is true mark GIMPLE_CALL S as valid for return
2119 slot optimization. This transformation uses the target of the call
2120 expansion as the return slot for calls that return in memory. */
2123 gimple_call_set_return_slot_opt (gimple s, bool return_slot_opt_p)
2125 GIMPLE_CHECK (s, GIMPLE_CALL);
2126 if (return_slot_opt_p)
2127 s->gsbase.subcode |= GF_CALL_RETURN_SLOT_OPT;
2129 s->gsbase.subcode &= ~GF_CALL_RETURN_SLOT_OPT;
2133 /* Return true if S is marked for return slot optimization. */
2136 gimple_call_return_slot_opt_p (gimple s)
2138 GIMPLE_CHECK (s, GIMPLE_CALL);
2139 return (s->gsbase.subcode & GF_CALL_RETURN_SLOT_OPT) != 0;
2143 /* If FROM_THUNK_P is true, mark GIMPLE_CALL S as being the jump from a
2144 thunk to the thunked-to function. */
2147 gimple_call_set_from_thunk (gimple s, bool from_thunk_p)
2149 GIMPLE_CHECK (s, GIMPLE_CALL);
2151 s->gsbase.subcode |= GF_CALL_FROM_THUNK;
2153 s->gsbase.subcode &= ~GF_CALL_FROM_THUNK;
2157 /* Return true if GIMPLE_CALL S is a jump from a thunk. */
2160 gimple_call_from_thunk_p (gimple s)
2162 GIMPLE_CHECK (s, GIMPLE_CALL);
2163 return (s->gsbase.subcode & GF_CALL_FROM_THUNK) != 0;
2167 /* If PASS_ARG_PACK_P is true, GIMPLE_CALL S is a stdarg call that needs the
2168 argument pack in its argument list. */
2171 gimple_call_set_va_arg_pack (gimple s, bool pass_arg_pack_p)
2173 GIMPLE_CHECK (s, GIMPLE_CALL);
2174 if (pass_arg_pack_p)
2175 s->gsbase.subcode |= GF_CALL_VA_ARG_PACK;
2177 s->gsbase.subcode &= ~GF_CALL_VA_ARG_PACK;
2181 /* Return true if GIMPLE_CALL S is a stdarg call that needs the
2182 argument pack in its argument list. */
2185 gimple_call_va_arg_pack_p (gimple s)
2187 GIMPLE_CHECK (s, GIMPLE_CALL);
2188 return (s->gsbase.subcode & GF_CALL_VA_ARG_PACK) != 0;
2192 /* Return true if S is a noreturn call. */
2195 gimple_call_noreturn_p (gimple s)
2197 GIMPLE_CHECK (s, GIMPLE_CALL);
2198 return (gimple_call_flags (s) & ECF_NORETURN) != 0;
2202 /* Return true if S is a nothrow call. */
2205 gimple_call_nothrow_p (gimple s)
2207 GIMPLE_CHECK (s, GIMPLE_CALL);
2208 return (gimple_call_flags (s) & ECF_NOTHROW) != 0;
2212 /* Copy all the GF_CALL_* flags from ORIG_CALL to DEST_CALL. */
2215 gimple_call_copy_flags (gimple dest_call, gimple orig_call)
2217 GIMPLE_CHECK (dest_call, GIMPLE_CALL);
2218 GIMPLE_CHECK (orig_call, GIMPLE_CALL);
2219 dest_call->gsbase.subcode = orig_call->gsbase.subcode;
2223 /* Returns true if this is a GIMPLE_ASSIGN or a GIMPLE_CALL with a
2227 gimple_has_lhs (gimple stmt)
2229 return (is_gimple_assign (stmt)
2230 || (is_gimple_call (stmt)
2231 && gimple_call_lhs (stmt) != NULL_TREE));
2235 /* Return the code of the predicate computed by conditional statement GS. */
2237 static inline enum tree_code
2238 gimple_cond_code (const_gimple gs)
2240 GIMPLE_CHECK (gs, GIMPLE_COND);
2241 return gs->gsbase.subcode;
2245 /* Set CODE to be the predicate code for the conditional statement GS. */
2248 gimple_cond_set_code (gimple gs, enum tree_code code)
2250 GIMPLE_CHECK (gs, GIMPLE_COND);
2251 gcc_assert (TREE_CODE_CLASS (code) == tcc_comparison);
2252 gs->gsbase.subcode = code;
2256 /* Return the LHS of the predicate computed by conditional statement GS. */
2259 gimple_cond_lhs (const_gimple gs)
2261 GIMPLE_CHECK (gs, GIMPLE_COND);
2262 return gimple_op (gs, 0);
2265 /* Return the pointer to the LHS of the predicate computed by conditional
2268 static inline tree *
2269 gimple_cond_lhs_ptr (const_gimple gs)
2271 GIMPLE_CHECK (gs, GIMPLE_COND);
2272 return gimple_op_ptr (gs, 0);
2275 /* Set LHS to be the LHS operand of the predicate computed by
2276 conditional statement GS. */
2279 gimple_cond_set_lhs (gimple gs, tree lhs)
2281 GIMPLE_CHECK (gs, GIMPLE_COND);
2282 gcc_assert (is_gimple_operand (lhs));
2283 gimple_set_op (gs, 0, lhs);
2287 /* Return the RHS operand of the predicate computed by conditional GS. */
2290 gimple_cond_rhs (const_gimple gs)
2292 GIMPLE_CHECK (gs, GIMPLE_COND);
2293 return gimple_op (gs, 1);
2296 /* Return the pointer to the RHS operand of the predicate computed by
2299 static inline tree *
2300 gimple_cond_rhs_ptr (const_gimple gs)
2302 GIMPLE_CHECK (gs, GIMPLE_COND);
2303 return gimple_op_ptr (gs, 1);
2307 /* Set RHS to be the RHS operand of the predicate computed by
2308 conditional statement GS. */
2311 gimple_cond_set_rhs (gimple gs, tree rhs)
2313 GIMPLE_CHECK (gs, GIMPLE_COND);
2314 gcc_assert (is_gimple_operand (rhs));
2315 gimple_set_op (gs, 1, rhs);
2319 /* Return the label used by conditional statement GS when its
2320 predicate evaluates to true. */
2323 gimple_cond_true_label (const_gimple gs)
2325 GIMPLE_CHECK (gs, GIMPLE_COND);
2326 return gimple_op (gs, 2);
2330 /* Set LABEL to be the label used by conditional statement GS when its
2331 predicate evaluates to true. */
2334 gimple_cond_set_true_label (gimple gs, tree label)
2336 GIMPLE_CHECK (gs, GIMPLE_COND);
2337 gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
2338 gimple_set_op (gs, 2, label);
2342 /* Set LABEL to be the label used by conditional statement GS when its
2343 predicate evaluates to false. */
2346 gimple_cond_set_false_label (gimple gs, tree label)
2348 GIMPLE_CHECK (gs, GIMPLE_COND);
2349 gcc_assert (!label || TREE_CODE (label) == LABEL_DECL);
2350 gimple_set_op (gs, 3, label);
2354 /* Return the label used by conditional statement GS when its
2355 predicate evaluates to false. */
2358 gimple_cond_false_label (const_gimple gs)
2360 GIMPLE_CHECK (gs, GIMPLE_COND);
2361 return gimple_op (gs, 3);
2365 /* Set the conditional COND_STMT to be of the form 'if (1 == 0)'. */
2368 gimple_cond_make_false (gimple gs)
2370 gimple_cond_set_lhs (gs, boolean_true_node);
2371 gimple_cond_set_rhs (gs, boolean_false_node);
2372 gs->gsbase.subcode = EQ_EXPR;
2376 /* Set the conditional COND_STMT to be of the form 'if (1 == 1)'. */
2379 gimple_cond_make_true (gimple gs)
2381 gimple_cond_set_lhs (gs, boolean_true_node);
2382 gimple_cond_set_rhs (gs, boolean_true_node);
2383 gs->gsbase.subcode = EQ_EXPR;
2386 /* Check if conditional statemente GS is of the form 'if (1 == 1)',
2387 'if (0 == 0)', 'if (1 != 0)' or 'if (0 != 1)' */
2390 gimple_cond_true_p (const_gimple gs)
2392 tree lhs = gimple_cond_lhs (gs);
2393 tree rhs = gimple_cond_rhs (gs);
2394 enum tree_code code = gimple_cond_code (gs);
2396 if (lhs != boolean_true_node && lhs != boolean_false_node)
2399 if (rhs != boolean_true_node && rhs != boolean_false_node)
2402 if (code == NE_EXPR && lhs != rhs)
2405 if (code == EQ_EXPR && lhs == rhs)
2411 /* Check if conditional statement GS is of the form 'if (1 != 1)',
2412 'if (0 != 0)', 'if (1 == 0)' or 'if (0 == 1)' */
2415 gimple_cond_false_p (const_gimple gs)
2417 tree lhs = gimple_cond_lhs (gs);
2418 tree rhs = gimple_cond_rhs (gs);
2419 enum tree_code code = gimple_cond_code (gs);
2421 if (lhs != boolean_true_node && lhs != boolean_false_node)
2424 if (rhs != boolean_true_node && rhs != boolean_false_node)
2427 if (code == NE_EXPR && lhs == rhs)
2430 if (code == EQ_EXPR && lhs != rhs)
2436 /* Check if conditional statement GS is of the form 'if (var != 0)' or
2440 gimple_cond_single_var_p (gimple gs)
2442 if (gimple_cond_code (gs) == NE_EXPR
2443 && gimple_cond_rhs (gs) == boolean_false_node)
2446 if (gimple_cond_code (gs) == EQ_EXPR
2447 && gimple_cond_rhs (gs) == boolean_true_node)
2453 /* Set the code, LHS and RHS of GIMPLE_COND STMT from CODE, LHS and RHS. */
2456 gimple_cond_set_condition (gimple stmt, enum tree_code code, tree lhs, tree rhs)
2458 gimple_cond_set_code (stmt, code);
2459 gimple_cond_set_lhs (stmt, lhs);
2460 gimple_cond_set_rhs (stmt, rhs);
2463 /* Return the LABEL_DECL node used by GIMPLE_LABEL statement GS. */
2466 gimple_label_label (const_gimple gs)
2468 GIMPLE_CHECK (gs, GIMPLE_LABEL);
2469 return gimple_op (gs, 0);
2473 /* Set LABEL to be the LABEL_DECL node used by GIMPLE_LABEL statement
2477 gimple_label_set_label (gimple gs, tree label)
2479 GIMPLE_CHECK (gs, GIMPLE_LABEL);
2480 gcc_assert (TREE_CODE (label) == LABEL_DECL);
2481 gimple_set_op (gs, 0, label);
2485 /* Return the destination of the unconditional jump GS. */
2488 gimple_goto_dest (const_gimple gs)
2490 GIMPLE_CHECK (gs, GIMPLE_GOTO);
2491 return gimple_op (gs, 0);
2495 /* Set DEST to be the destination of the unconditonal jump GS. */
2498 gimple_goto_set_dest (gimple gs, tree dest)
2500 GIMPLE_CHECK (gs, GIMPLE_GOTO);
2501 gcc_assert (is_gimple_operand (dest));
2502 gimple_set_op (gs, 0, dest);
2506 /* Return the variables declared in the GIMPLE_BIND statement GS. */
2509 gimple_bind_vars (const_gimple gs)
2511 GIMPLE_CHECK (gs, GIMPLE_BIND);
2512 return gs->gimple_bind.vars;
2516 /* Set VARS to be the set of variables declared in the GIMPLE_BIND
2520 gimple_bind_set_vars (gimple gs, tree vars)
2522 GIMPLE_CHECK (gs, GIMPLE_BIND);
2523 gs->gimple_bind.vars = vars;
2527 /* Append VARS to the set of variables declared in the GIMPLE_BIND
2531 gimple_bind_append_vars (gimple gs, tree vars)
2533 GIMPLE_CHECK (gs, GIMPLE_BIND);
2534 gs->gimple_bind.vars = chainon (gs->gimple_bind.vars, vars);
2538 /* Return the GIMPLE sequence contained in the GIMPLE_BIND statement GS. */
2540 static inline gimple_seq
2541 gimple_bind_body (gimple gs)
2543 GIMPLE_CHECK (gs, GIMPLE_BIND);
2544 return gs->gimple_bind.body;
2548 /* Set SEQ to be the GIMPLE sequence contained in the GIMPLE_BIND
2552 gimple_bind_set_body (gimple gs, gimple_seq seq)
2554 GIMPLE_CHECK (gs, GIMPLE_BIND);
2555 gs->gimple_bind.body = seq;
2559 /* Append a statement to the end of a GIMPLE_BIND's body. */
2562 gimple_bind_add_stmt (gimple gs, gimple stmt)
2564 GIMPLE_CHECK (gs, GIMPLE_BIND);
2565 gimple_seq_add_stmt (&gs->gimple_bind.body, stmt);
2569 /* Append a sequence of statements to the end of a GIMPLE_BIND's body. */
2572 gimple_bind_add_seq (gimple gs, gimple_seq seq)
2574 GIMPLE_CHECK (gs, GIMPLE_BIND);
2575 gimple_seq_add_seq (&gs->gimple_bind.body, seq);
2579 /* Return the TREE_BLOCK node associated with GIMPLE_BIND statement
2580 GS. This is analogous to the BIND_EXPR_BLOCK field in trees. */
2583 gimple_bind_block (const_gimple gs)
2585 GIMPLE_CHECK (gs, GIMPLE_BIND);
2586 return gs->gimple_bind.block;
2590 /* Set BLOCK to be the TREE_BLOCK node associated with GIMPLE_BIND
2594 gimple_bind_set_block (gimple gs, tree block)
2596 GIMPLE_CHECK (gs, GIMPLE_BIND);
2597 gcc_assert (TREE_CODE (block) == BLOCK);
2598 gs->gimple_bind.block = block;
2602 /* Return the number of input operands for GIMPLE_ASM GS. */
2604 static inline unsigned
2605 gimple_asm_ninputs (const_gimple gs)
2607 GIMPLE_CHECK (gs, GIMPLE_ASM);
2608 return gs->gimple_asm.ni;
2612 /* Return the number of output operands for GIMPLE_ASM GS. */
2614 static inline unsigned
2615 gimple_asm_noutputs (const_gimple gs)
2617 GIMPLE_CHECK (gs, GIMPLE_ASM);
2618 return gs->gimple_asm.no;
2622 /* Return the number of clobber operands for GIMPLE_ASM GS. */
2624 static inline unsigned
2625 gimple_asm_nclobbers (const_gimple gs)
2627 GIMPLE_CHECK (gs, GIMPLE_ASM);
2628 return gs->gimple_asm.nc;
2632 /* Return input operand INDEX of GIMPLE_ASM GS. */
2635 gimple_asm_input_op (const_gimple gs, unsigned index)
2637 GIMPLE_CHECK (gs, GIMPLE_ASM);
2638 gcc_assert (index <= gs->gimple_asm.ni);
2639 return gimple_op (gs, index);
2642 /* Return a pointer to input operand INDEX of GIMPLE_ASM GS. */
2644 static inline tree *
2645 gimple_asm_input_op_ptr (const_gimple gs, unsigned index)
2647 GIMPLE_CHECK (gs, GIMPLE_ASM);
2648 gcc_assert (index <= gs->gimple_asm.ni);
2649 return gimple_op_ptr (gs, index);
2653 /* Set IN_OP to be input operand INDEX in GIMPLE_ASM GS. */
2656 gimple_asm_set_input_op (gimple gs, unsigned index, tree in_op)
2658 GIMPLE_CHECK (gs, GIMPLE_ASM);
2659 gcc_assert (index <= gs->gimple_asm.ni);
2660 gcc_assert (TREE_CODE (in_op) == TREE_LIST);
2661 gimple_set_op (gs, index, in_op);
2665 /* Return output operand INDEX of GIMPLE_ASM GS. */
2668 gimple_asm_output_op (const_gimple gs, unsigned index)
2670 GIMPLE_CHECK (gs, GIMPLE_ASM);
2671 gcc_assert (index <= gs->gimple_asm.no);
2672 return gimple_op (gs, index + gs->gimple_asm.ni);
2675 /* Return a pointer to output operand INDEX of GIMPLE_ASM GS. */
2677 static inline tree *
2678 gimple_asm_output_op_ptr (const_gimple gs, unsigned index)
2680 GIMPLE_CHECK (gs, GIMPLE_ASM);
2681 gcc_assert (index <= gs->gimple_asm.no);
2682 return gimple_op_ptr (gs, index + gs->gimple_asm.ni);
2686 /* Set OUT_OP to be output operand INDEX in GIMPLE_ASM GS. */
2689 gimple_asm_set_output_op (gimple gs, unsigned index, tree out_op)
2691 GIMPLE_CHECK (gs, GIMPLE_ASM);
2692 gcc_assert (index <= gs->gimple_asm.no);
2693 gcc_assert (TREE_CODE (out_op) == TREE_LIST);
2694 gimple_set_op (gs, index + gs->gimple_asm.ni, out_op);
2698 /* Return clobber operand INDEX of GIMPLE_ASM GS. */
2701 gimple_asm_clobber_op (const_gimple gs, unsigned index)
2703 GIMPLE_CHECK (gs, GIMPLE_ASM);
2704 gcc_assert (index <= gs->gimple_asm.nc);
2705 return gimple_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no);
2709 /* Set CLOBBER_OP to be clobber operand INDEX in GIMPLE_ASM GS. */
2712 gimple_asm_set_clobber_op (gimple gs, unsigned index, tree clobber_op)
2714 GIMPLE_CHECK (gs, GIMPLE_ASM);
2715 gcc_assert (index <= gs->gimple_asm.nc);
2716 gcc_assert (TREE_CODE (clobber_op) == TREE_LIST);
2717 gimple_set_op (gs, index + gs->gimple_asm.ni + gs->gimple_asm.no, clobber_op);
2721 /* Return the string representing the assembly instruction in
2724 static inline const char *
2725 gimple_asm_string (const_gimple gs)
2727 GIMPLE_CHECK (gs, GIMPLE_ASM);
2728 return gs->gimple_asm.string;
2732 /* Return true if GS is an asm statement marked volatile. */
2735 gimple_asm_volatile_p (const_gimple gs)
2737 GIMPLE_CHECK (gs, GIMPLE_ASM);
2738 return (gs->gsbase.subcode & GF_ASM_VOLATILE) != 0;
2742 /* If VOLATLE_P is true, mark asm statement GS as volatile. */
2745 gimple_asm_set_volatile (gimple gs, bool volatile_p)
2747 GIMPLE_CHECK (gs, GIMPLE_ASM);
2749 gs->gsbase.subcode |= GF_ASM_VOLATILE;
2751 gs->gsbase.subcode &= ~GF_ASM_VOLATILE;
2755 /* If INPUT_P is true, mark asm GS as an ASM_INPUT. */
2758 gimple_asm_set_input (gimple gs, bool input_p)
2760 GIMPLE_CHECK (gs, GIMPLE_ASM);
2762 gs->gsbase.subcode |= GF_ASM_INPUT;
2764 gs->gsbase.subcode &= ~GF_ASM_INPUT;
2768 /* Return true if asm GS is an ASM_INPUT. */
2771 gimple_asm_input_p (const_gimple gs)
2773 GIMPLE_CHECK (gs, GIMPLE_ASM);
2774 return (gs->gsbase.subcode & GF_ASM_INPUT) != 0;
2778 /* Return the types handled by GIMPLE_CATCH statement GS. */
2781 gimple_catch_types (const_gimple gs)
2783 GIMPLE_CHECK (gs, GIMPLE_CATCH);
2784 return gs->gimple_catch.types;
2788 /* Return a pointer to the types handled by GIMPLE_CATCH statement GS. */
2790 static inline tree *
2791 gimple_catch_types_ptr (gimple gs)
2793 GIMPLE_CHECK (gs, GIMPLE_CATCH);
2794 return &gs->gimple_catch.types;
2798 /* Return the GIMPLE sequence representing the body of the handler of
2799 GIMPLE_CATCH statement GS. */
2801 static inline gimple_seq
2802 gimple_catch_handler (gimple gs)
2804 GIMPLE_CHECK (gs, GIMPLE_CATCH);
2805 return gs->gimple_catch.handler;
2809 /* Return a pointer to the GIMPLE sequence representing the body of
2810 the handler of GIMPLE_CATCH statement GS. */
2812 static inline gimple_seq *
2813 gimple_catch_handler_ptr (gimple gs)
2815 GIMPLE_CHECK (gs, GIMPLE_CATCH);
2816 return &gs->gimple_catch.handler;
2820 /* Set T to be the set of types handled by GIMPLE_CATCH GS. */
2823 gimple_catch_set_types (gimple gs, tree t)
2825 GIMPLE_CHECK (gs, GIMPLE_CATCH);
2826 gs->gimple_catch.types = t;
2830 /* Set HANDLER to be the body of GIMPLE_CATCH GS. */
2833 gimple_catch_set_handler (gimple gs, gimple_seq handler)
2835 GIMPLE_CHECK (gs, GIMPLE_CATCH);
2836 gs->gimple_catch.handler = handler;
2840 /* Return the types handled by GIMPLE_EH_FILTER statement GS. */
2843 gimple_eh_filter_types (const_gimple gs)
2845 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2846 return gs->gimple_eh_filter.types;
2850 /* Return a pointer to the types handled by GIMPLE_EH_FILTER statement
2853 static inline tree *
2854 gimple_eh_filter_types_ptr (gimple gs)
2856 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2857 return &gs->gimple_eh_filter.types;
2861 /* Return the sequence of statement to execute when GIMPLE_EH_FILTER
2864 static inline gimple_seq
2865 gimple_eh_filter_failure (gimple gs)
2867 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2868 return gs->gimple_eh_filter.failure;
2872 /* Set TYPES to be the set of types handled by GIMPLE_EH_FILTER GS. */
2875 gimple_eh_filter_set_types (gimple gs, tree types)
2877 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2878 gs->gimple_eh_filter.types = types;
2882 /* Set FAILURE to be the sequence of statements to execute on failure
2883 for GIMPLE_EH_FILTER GS. */
2886 gimple_eh_filter_set_failure (gimple gs, gimple_seq failure)
2888 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2889 gs->gimple_eh_filter.failure = failure;
2892 /* Return the EH_FILTER_MUST_NOT_THROW flag. */
2896 gimple_eh_filter_must_not_throw (gimple gs)
2898 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2899 return gs->gsbase.subcode != 0;
2902 /* Set the EH_FILTER_MUST_NOT_THROW flag to the value MNTP. */
2905 gimple_eh_filter_set_must_not_throw (gimple gs, bool mntp)
2907 GIMPLE_CHECK (gs, GIMPLE_EH_FILTER);
2908 gs->gsbase.subcode = (unsigned int) mntp;
2912 /* GIMPLE_TRY accessors. */
2914 /* Return the kind of try block represented by GIMPLE_TRY GS. This is
2915 either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY. */
2917 static inline enum gimple_try_flags
2918 gimple_try_kind (const_gimple gs)
2920 GIMPLE_CHECK (gs, GIMPLE_TRY);
2921 return (enum gimple_try_flags) (gs->gsbase.subcode & GIMPLE_TRY_KIND);
2925 /* Set the kind of try block represented by GIMPLE_TRY GS. */
2928 gimple_try_set_kind (gimple gs, enum gimple_try_flags kind)
2930 GIMPLE_CHECK (gs, GIMPLE_TRY);
2931 gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
2932 if (gimple_try_kind (gs) != kind)
2933 gs->gsbase.subcode = (unsigned int) kind;
2937 /* Return the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
2940 gimple_try_catch_is_cleanup (const_gimple gs)
2942 gcc_assert (gimple_try_kind (gs) == GIMPLE_TRY_CATCH);
2943 return (gs->gsbase.subcode & GIMPLE_TRY_CATCH_IS_CLEANUP) != 0;
2947 /* Return the sequence of statements used as the body for GIMPLE_TRY GS. */
2949 static inline gimple_seq
2950 gimple_try_eval (gimple gs)
2952 GIMPLE_CHECK (gs, GIMPLE_TRY);
2953 return gs->gimple_try.eval;
2957 /* Return the sequence of statements used as the cleanup body for
2960 static inline gimple_seq
2961 gimple_try_cleanup (gimple gs)
2963 GIMPLE_CHECK (gs, GIMPLE_TRY);
2964 return gs->gimple_try.cleanup;
2968 /* Set the GIMPLE_TRY_CATCH_IS_CLEANUP flag. */
2971 gimple_try_set_catch_is_cleanup (gimple g, bool catch_is_cleanup)
2973 gcc_assert (gimple_try_kind (g) == GIMPLE_TRY_CATCH);
2974 if (catch_is_cleanup)
2975 g->gsbase.subcode |= GIMPLE_TRY_CATCH_IS_CLEANUP;
2977 g->gsbase.subcode &= ~GIMPLE_TRY_CATCH_IS_CLEANUP;
2981 /* Set EVAL to be the sequence of statements to use as the body for
2985 gimple_try_set_eval (gimple gs, gimple_seq eval)
2987 GIMPLE_CHECK (gs, GIMPLE_TRY);
2988 gs->gimple_try.eval = eval;
2992 /* Set CLEANUP to be the sequence of statements to use as the cleanup
2993 body for GIMPLE_TRY GS. */
2996 gimple_try_set_cleanup (gimple gs, gimple_seq cleanup)
2998 GIMPLE_CHECK (gs, GIMPLE_TRY);
2999 gs->gimple_try.cleanup = cleanup;
3003 /* Return the cleanup sequence for cleanup statement GS. */
3005 static inline gimple_seq
3006 gimple_wce_cleanup (gimple gs)
3008 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3009 return gs->gimple_wce.cleanup;
3013 /* Set CLEANUP to be the cleanup sequence for GS. */
3016 gimple_wce_set_cleanup (gimple gs, gimple_seq cleanup)
3018 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3019 gs->gimple_wce.cleanup = cleanup;
3023 /* Return the CLEANUP_EH_ONLY flag for a WCE tuple. */
3026 gimple_wce_cleanup_eh_only (const_gimple gs)
3028 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3029 return gs->gsbase.subcode != 0;
3033 /* Set the CLEANUP_EH_ONLY flag for a WCE tuple. */
3036 gimple_wce_set_cleanup_eh_only (gimple gs, bool eh_only_p)
3038 GIMPLE_CHECK (gs, GIMPLE_WITH_CLEANUP_EXPR);
3039 gs->gsbase.subcode = (unsigned int) eh_only_p;
3043 /* Return the maximum number of arguments supported by GIMPLE_PHI GS. */
3045 static inline unsigned
3046 gimple_phi_capacity (const_gimple gs)
3048 GIMPLE_CHECK (gs, GIMPLE_PHI);
3049 return gs->gimple_phi.capacity;
3053 /* Return the number of arguments in GIMPLE_PHI GS. This must always
3054 be exactly the number of incoming edges for the basic block holding
3057 static inline unsigned
3058 gimple_phi_num_args (const_gimple gs)
3060 GIMPLE_CHECK (gs, GIMPLE_PHI);
3061 return gs->gimple_phi.nargs;
3065 /* Return the SSA name created by GIMPLE_PHI GS. */
3068 gimple_phi_result (const_gimple gs)
3070 GIMPLE_CHECK (gs, GIMPLE_PHI);
3071 return gs->gimple_phi.result;
3074 /* Return a pointer to the SSA name created by GIMPLE_PHI GS. */
3076 static inline tree *
3077 gimple_phi_result_ptr (gimple gs)
3079 GIMPLE_CHECK (gs, GIMPLE_PHI);
3080 return &gs->gimple_phi.result;
3083 /* Set RESULT to be the SSA name created by GIMPLE_PHI GS. */
3086 gimple_phi_set_result (gimple gs, tree result)
3088 GIMPLE_CHECK (gs, GIMPLE_PHI);
3089 gs->gimple_phi.result = result;
3093 /* Return the PHI argument corresponding to incoming edge INDEX for
3096 static inline struct phi_arg_d *
3097 gimple_phi_arg (gimple gs, unsigned index)
3099 GIMPLE_CHECK (gs, GIMPLE_PHI);
3100 gcc_assert (index <= gs->gimple_phi.capacity);
3101 return &(gs->gimple_phi.args[index]);
3104 /* Set PHIARG to be the argument corresponding to incoming edge INDEX
3105 for GIMPLE_PHI GS. */
3108 gimple_phi_set_arg (gimple gs, unsigned index, struct phi_arg_d * phiarg)
3110 GIMPLE_CHECK (gs, GIMPLE_PHI);
3111 gcc_assert (index <= gs->gimple_phi.nargs);
3112 memcpy (gs->gimple_phi.args + index, phiarg, sizeof (struct phi_arg_d));
3115 /* Return the region number for GIMPLE_RESX GS. */
3118 gimple_resx_region (const_gimple gs)
3120 GIMPLE_CHECK (gs, GIMPLE_RESX);
3121 return gs->gimple_resx.region;
3124 /* Set REGION to be the region number for GIMPLE_RESX GS. */
3127 gimple_resx_set_region (gimple gs, int region)
3129 GIMPLE_CHECK (gs, GIMPLE_RESX);
3130 gs->gimple_resx.region = region;
3134 /* Return the number of labels associated with the switch statement GS. */
3136 static inline unsigned
3137 gimple_switch_num_labels (const_gimple gs)
3140 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3141 num_ops = gimple_num_ops (gs);
3142 gcc_assert (num_ops > 1);
3147 /* Set NLABELS to be the number of labels for the switch statement GS. */
3150 gimple_switch_set_num_labels (gimple g, unsigned nlabels)
3152 GIMPLE_CHECK (g, GIMPLE_SWITCH);
3153 gimple_set_num_ops (g, nlabels + 1);
3157 /* Return the index variable used by the switch statement GS. */
3160 gimple_switch_index (const_gimple gs)
3162 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3163 return gimple_op (gs, 0);
3167 /* Return a pointer to the index variable for the switch statement GS. */
3169 static inline tree *
3170 gimple_switch_index_ptr (const_gimple gs)
3172 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3173 return gimple_op_ptr (gs, 0);
3177 /* Set INDEX to be the index variable for switch statement GS. */
3180 gimple_switch_set_index (gimple gs, tree index)
3182 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3183 gcc_assert (SSA_VAR_P (index) || CONSTANT_CLASS_P (index));
3184 gimple_set_op (gs, 0, index);
3188 /* Return the label numbered INDEX. The default label is 0, followed by any
3189 labels in a switch statement. */
3192 gimple_switch_label (const_gimple gs, unsigned index)
3194 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3195 gcc_assert (gimple_num_ops (gs) > index + 1);
3196 return gimple_op (gs, index + 1);
3199 /* Set the label number INDEX to LABEL. 0 is always the default label. */
3202 gimple_switch_set_label (gimple gs, unsigned index, tree label)
3204 GIMPLE_CHECK (gs, GIMPLE_SWITCH);
3205 gcc_assert (gimple_num_ops (gs) > index + 1);
3206 gcc_assert (label == NULL_TREE || TREE_CODE (label) == CASE_LABEL_EXPR);
3207 gimple_set_op (gs, index + 1, label);
3210 /* Return the default label for a switch statement. */
3213 gimple_switch_default_label (const_gimple gs)
3215 return gimple_switch_label (gs, 0);
3218 /* Set the default label for a switch statement. */
3221 gimple_switch_set_default_label (gimple gs, tree label)
3223 gimple_switch_set_label (gs, 0, label);
3227 /* Return the body for the OMP statement GS. */
3229 static inline gimple_seq
3230 gimple_omp_body (gimple gs)
3232 return gs->omp.body;
3235 /* Set BODY to be the body for the OMP statement GS. */
3238 gimple_omp_set_body (gimple gs, gimple_seq body)
3240 gs->omp.body = body;
3244 /* Return the name associated with OMP_CRITICAL statement GS. */
3247 gimple_omp_critical_name (const_gimple gs)
3249 GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
3250 return gs->gimple_omp_critical.name;
3254 /* Return a pointer to the name associated with OMP critical statement GS. */
3256 static inline tree *
3257 gimple_omp_critical_name_ptr (gimple gs)
3259 GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
3260 return &gs->gimple_omp_critical.name;
3264 /* Set NAME to be the name associated with OMP critical statement GS. */
3267 gimple_omp_critical_set_name (gimple gs, tree name)
3269 GIMPLE_CHECK (gs, GIMPLE_OMP_CRITICAL);
3270 gs->gimple_omp_critical.name = name;
3274 /* Return the clauses associated with OMP_FOR GS. */
3277 gimple_omp_for_clauses (const_gimple gs)
3279 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3280 return gs->gimple_omp_for.clauses;
3284 /* Return a pointer to the OMP_FOR GS. */
3286 static inline tree *
3287 gimple_omp_for_clauses_ptr (gimple gs)
3289 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3290 return &gs->gimple_omp_for.clauses;
3294 /* Set CLAUSES to be the list of clauses associated with OMP_FOR GS. */
3297 gimple_omp_for_set_clauses (gimple gs, tree clauses)
3299 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3300 gs->gimple_omp_for.clauses = clauses;
3304 /* Get the collapse count of OMP_FOR GS. */
3306 static inline size_t
3307 gimple_omp_for_collapse (gimple gs)
3309 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3310 return gs->gimple_omp_for.collapse;
3314 /* Return the index variable for OMP_FOR GS. */
3317 gimple_omp_for_index (const_gimple gs, size_t i)
3319 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3320 gcc_assert (i < gs->gimple_omp_for.collapse);
3321 return gs->gimple_omp_for.iter[i].index;
3325 /* Return a pointer to the index variable for OMP_FOR GS. */
3327 static inline tree *
3328 gimple_omp_for_index_ptr (gimple gs, size_t i)
3330 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3331 gcc_assert (i < gs->gimple_omp_for.collapse);
3332 return &gs->gimple_omp_for.iter[i].index;
3336 /* Set INDEX to be the index variable for OMP_FOR GS. */
3339 gimple_omp_for_set_index (gimple gs, size_t i, tree index)
3341 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3342 gcc_assert (i < gs->gimple_omp_for.collapse);
3343 gs->gimple_omp_for.iter[i].index = index;
3347 /* Return the initial value for OMP_FOR GS. */
3350 gimple_omp_for_initial (const_gimple gs, size_t i)
3352 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3353 gcc_assert (i < gs->gimple_omp_for.collapse);
3354 return gs->gimple_omp_for.iter[i].initial;
3358 /* Return a pointer to the initial value for OMP_FOR GS. */
3360 static inline tree *
3361 gimple_omp_for_initial_ptr (gimple gs, size_t i)
3363 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3364 gcc_assert (i < gs->gimple_omp_for.collapse);
3365 return &gs->gimple_omp_for.iter[i].initial;
3369 /* Set INITIAL to be the initial value for OMP_FOR GS. */
3372 gimple_omp_for_set_initial (gimple gs, size_t i, tree initial)
3374 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3375 gcc_assert (i < gs->gimple_omp_for.collapse);
3376 gs->gimple_omp_for.iter[i].initial = initial;
3380 /* Return the final value for OMP_FOR GS. */
3383 gimple_omp_for_final (const_gimple gs, size_t i)
3385 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3386 gcc_assert (i < gs->gimple_omp_for.collapse);
3387 return gs->gimple_omp_for.iter[i].final;
3391 /* Return a pointer to the final value for OMP_FOR GS. */
3393 static inline tree *
3394 gimple_omp_for_final_ptr (gimple gs, size_t i)
3396 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3397 gcc_assert (i < gs->gimple_omp_for.collapse);
3398 return &gs->gimple_omp_for.iter[i].final;
3402 /* Set FINAL to be the final value for OMP_FOR GS. */
3405 gimple_omp_for_set_final (gimple gs, size_t i, tree final)
3407 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3408 gcc_assert (i < gs->gimple_omp_for.collapse);
3409 gs->gimple_omp_for.iter[i].final = final;
3413 /* Return the increment value for OMP_FOR GS. */
3416 gimple_omp_for_incr (const_gimple gs, size_t i)
3418 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3419 gcc_assert (i < gs->gimple_omp_for.collapse);
3420 return gs->gimple_omp_for.iter[i].incr;
3424 /* Return a pointer to the increment value for OMP_FOR GS. */
3426 static inline tree *
3427 gimple_omp_for_incr_ptr (gimple gs, size_t i)
3429 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3430 gcc_assert (i < gs->gimple_omp_for.collapse);
3431 return &gs->gimple_omp_for.iter[i].incr;
3435 /* Set INCR to be the increment value for OMP_FOR GS. */
3438 gimple_omp_for_set_incr (gimple gs, size_t i, tree incr)
3440 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3441 gcc_assert (i < gs->gimple_omp_for.collapse);
3442 gs->gimple_omp_for.iter[i].incr = incr;
3446 /* Return the sequence of statements to execute before the OMP_FOR
3447 statement GS starts. */
3449 static inline gimple_seq
3450 gimple_omp_for_pre_body (gimple gs)
3452 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3453 return gs->gimple_omp_for.pre_body;
3457 /* Set PRE_BODY to be the sequence of statements to execute before the
3458 OMP_FOR statement GS starts. */
3461 gimple_omp_for_set_pre_body (gimple gs, gimple_seq pre_body)
3463 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3464 gs->gimple_omp_for.pre_body = pre_body;
3468 /* Return the clauses associated with OMP_PARALLEL GS. */
3471 gimple_omp_parallel_clauses (const_gimple gs)
3473 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3474 return gs->gimple_omp_parallel.clauses;
3478 /* Return a pointer to the clauses associated with OMP_PARALLEL GS. */
3480 static inline tree *
3481 gimple_omp_parallel_clauses_ptr (gimple gs)
3483 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3484 return &gs->gimple_omp_parallel.clauses;
3488 /* Set CLAUSES to be the list of clauses associated with OMP_PARALLEL
3492 gimple_omp_parallel_set_clauses (gimple gs, tree clauses)
3494 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3495 gs->gimple_omp_parallel.clauses = clauses;
3499 /* Return the child function used to hold the body of OMP_PARALLEL GS. */
3502 gimple_omp_parallel_child_fn (const_gimple gs)
3504 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3505 return gs->gimple_omp_parallel.child_fn;
3508 /* Return a pointer to the child function used to hold the body of
3511 static inline tree *
3512 gimple_omp_parallel_child_fn_ptr (gimple gs)
3514 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3515 return &gs->gimple_omp_parallel.child_fn;
3519 /* Set CHILD_FN to be the child function for OMP_PARALLEL GS. */
3522 gimple_omp_parallel_set_child_fn (gimple gs, tree child_fn)
3524 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3525 gs->gimple_omp_parallel.child_fn = child_fn;
3529 /* Return the artificial argument used to send variables and values
3530 from the parent to the children threads in OMP_PARALLEL GS. */
3533 gimple_omp_parallel_data_arg (const_gimple gs)
3535 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3536 return gs->gimple_omp_parallel.data_arg;
3540 /* Return a pointer to the data argument for OMP_PARALLEL GS. */
3542 static inline tree *
3543 gimple_omp_parallel_data_arg_ptr (gimple gs)
3545 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3546 return &gs->gimple_omp_parallel.data_arg;
3550 /* Set DATA_ARG to be the data argument for OMP_PARALLEL GS. */
3553 gimple_omp_parallel_set_data_arg (gimple gs, tree data_arg)
3555 GIMPLE_CHECK (gs, GIMPLE_OMP_PARALLEL);
3556 gs->gimple_omp_parallel.data_arg = data_arg;
3560 /* Return the clauses associated with OMP_TASK GS. */
3563 gimple_omp_task_clauses (const_gimple gs)
3565 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3566 return gs->gimple_omp_parallel.clauses;
3570 /* Return a pointer to the clauses associated with OMP_TASK GS. */
3572 static inline tree *
3573 gimple_omp_task_clauses_ptr (gimple gs)
3575 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3576 return &gs->gimple_omp_parallel.clauses;
3580 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
3584 gimple_omp_task_set_clauses (gimple gs, tree clauses)
3586 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3587 gs->gimple_omp_parallel.clauses = clauses;
3591 /* Return the child function used to hold the body of OMP_TASK GS. */
3594 gimple_omp_task_child_fn (const_gimple gs)
3596 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3597 return gs->gimple_omp_parallel.child_fn;
3600 /* Return a pointer to the child function used to hold the body of
3603 static inline tree *
3604 gimple_omp_task_child_fn_ptr (gimple gs)
3606 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3607 return &gs->gimple_omp_parallel.child_fn;
3611 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
3614 gimple_omp_task_set_child_fn (gimple gs, tree child_fn)
3616 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3617 gs->gimple_omp_parallel.child_fn = child_fn;
3621 /* Return the artificial argument used to send variables and values
3622 from the parent to the children threads in OMP_TASK GS. */
3625 gimple_omp_task_data_arg (const_gimple gs)
3627 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3628 return gs->gimple_omp_parallel.data_arg;
3632 /* Return a pointer to the data argument for OMP_TASK GS. */
3634 static inline tree *
3635 gimple_omp_task_data_arg_ptr (gimple gs)
3637 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3638 return &gs->gimple_omp_parallel.data_arg;
3642 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
3645 gimple_omp_task_set_data_arg (gimple gs, tree data_arg)
3647 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3648 gs->gimple_omp_parallel.data_arg = data_arg;
3652 /* Return the clauses associated with OMP_TASK GS. */
3655 gimple_omp_taskreg_clauses (const_gimple gs)
3657 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3658 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3659 return gs->gimple_omp_parallel.clauses;
3663 /* Return a pointer to the clauses associated with OMP_TASK GS. */
3665 static inline tree *
3666 gimple_omp_taskreg_clauses_ptr (gimple gs)
3668 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3669 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3670 return &gs->gimple_omp_parallel.clauses;
3674 /* Set CLAUSES to be the list of clauses associated with OMP_TASK
3678 gimple_omp_taskreg_set_clauses (gimple gs, tree clauses)
3680 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3681 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3682 gs->gimple_omp_parallel.clauses = clauses;
3686 /* Return the child function used to hold the body of OMP_TASK GS. */
3689 gimple_omp_taskreg_child_fn (const_gimple gs)
3691 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3692 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3693 return gs->gimple_omp_parallel.child_fn;
3696 /* Return a pointer to the child function used to hold the body of
3699 static inline tree *
3700 gimple_omp_taskreg_child_fn_ptr (gimple gs)
3702 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3703 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3704 return &gs->gimple_omp_parallel.child_fn;
3708 /* Set CHILD_FN to be the child function for OMP_TASK GS. */
3711 gimple_omp_taskreg_set_child_fn (gimple gs, tree child_fn)
3713 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3714 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3715 gs->gimple_omp_parallel.child_fn = child_fn;
3719 /* Return the artificial argument used to send variables and values
3720 from the parent to the children threads in OMP_TASK GS. */
3723 gimple_omp_taskreg_data_arg (const_gimple gs)
3725 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3726 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3727 return gs->gimple_omp_parallel.data_arg;
3731 /* Return a pointer to the data argument for OMP_TASK GS. */
3733 static inline tree *
3734 gimple_omp_taskreg_data_arg_ptr (gimple gs)
3736 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3737 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3738 return &gs->gimple_omp_parallel.data_arg;
3742 /* Set DATA_ARG to be the data argument for OMP_TASK GS. */
3745 gimple_omp_taskreg_set_data_arg (gimple gs, tree data_arg)
3747 if (gimple_code (gs) != GIMPLE_OMP_PARALLEL)
3748 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3749 gs->gimple_omp_parallel.data_arg = data_arg;
3753 /* Return the copy function used to hold the body of OMP_TASK GS. */
3756 gimple_omp_task_copy_fn (const_gimple gs)
3758 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3759 return gs->gimple_omp_task.copy_fn;
3762 /* Return a pointer to the copy function used to hold the body of
3765 static inline tree *
3766 gimple_omp_task_copy_fn_ptr (gimple gs)
3768 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3769 return &gs->gimple_omp_task.copy_fn;
3773 /* Set CHILD_FN to be the copy function for OMP_TASK GS. */
3776 gimple_omp_task_set_copy_fn (gimple gs, tree copy_fn)
3778 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3779 gs->gimple_omp_task.copy_fn = copy_fn;
3783 /* Return size of the data block in bytes in OMP_TASK GS. */
3786 gimple_omp_task_arg_size (const_gimple gs)
3788 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3789 return gs->gimple_omp_task.arg_size;
3793 /* Return a pointer to the data block size for OMP_TASK GS. */
3795 static inline tree *
3796 gimple_omp_task_arg_size_ptr (gimple gs)
3798 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3799 return &gs->gimple_omp_task.arg_size;
3803 /* Set ARG_SIZE to be the data block size for OMP_TASK GS. */
3806 gimple_omp_task_set_arg_size (gimple gs, tree arg_size)
3808 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3809 gs->gimple_omp_task.arg_size = arg_size;
3813 /* Return align of the data block in bytes in OMP_TASK GS. */
3816 gimple_omp_task_arg_align (const_gimple gs)
3818 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3819 return gs->gimple_omp_task.arg_align;
3823 /* Return a pointer to the data block align for OMP_TASK GS. */
3825 static inline tree *
3826 gimple_omp_task_arg_align_ptr (gimple gs)
3828 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3829 return &gs->gimple_omp_task.arg_align;
3833 /* Set ARG_SIZE to be the data block align for OMP_TASK GS. */
3836 gimple_omp_task_set_arg_align (gimple gs, tree arg_align)
3838 GIMPLE_CHECK (gs, GIMPLE_OMP_TASK);
3839 gs->gimple_omp_task.arg_align = arg_align;
3843 /* Return the clauses associated with OMP_SINGLE GS. */
3846 gimple_omp_single_clauses (const_gimple gs)
3848 GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
3849 return gs->gimple_omp_single.clauses;
3853 /* Return a pointer to the clauses associated with OMP_SINGLE GS. */
3855 static inline tree *
3856 gimple_omp_single_clauses_ptr (gimple gs)
3858 GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
3859 return &gs->gimple_omp_single.clauses;
3863 /* Set CLAUSES to be the clauses associated with OMP_SINGLE GS. */
3866 gimple_omp_single_set_clauses (gimple gs, tree clauses)
3868 GIMPLE_CHECK (gs, GIMPLE_OMP_SINGLE);
3869 gs->gimple_omp_single.clauses = clauses;
3873 /* Return the clauses associated with OMP_SECTIONS GS. */
3876 gimple_omp_sections_clauses (const_gimple gs)
3878 GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
3879 return gs->gimple_omp_sections.clauses;
3883 /* Return a pointer to the clauses associated with OMP_SECTIONS GS. */
3885 static inline tree *
3886 gimple_omp_sections_clauses_ptr (gimple gs)
3888 GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
3889 return &gs->gimple_omp_sections.clauses;
3893 /* Set CLAUSES to be the set of clauses associated with OMP_SECTIONS
3897 gimple_omp_sections_set_clauses (gimple gs, tree clauses)
3899 GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
3900 gs->gimple_omp_sections.clauses = clauses;
3904 /* Return the control variable associated with the GIMPLE_OMP_SECTIONS
3908 gimple_omp_sections_control (const_gimple gs)
3910 GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
3911 return gs->gimple_omp_sections.control;
3915 /* Return a pointer to the clauses associated with the GIMPLE_OMP_SECTIONS
3918 static inline tree *
3919 gimple_omp_sections_control_ptr (gimple gs)
3921 GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
3922 return &gs->gimple_omp_sections.control;
3926 /* Set CONTROL to be the set of clauses associated with the
3927 GIMPLE_OMP_SECTIONS in GS. */
3930 gimple_omp_sections_set_control (gimple gs, tree control)
3932 GIMPLE_CHECK (gs, GIMPLE_OMP_SECTIONS);
3933 gs->gimple_omp_sections.control = control;
3937 /* Set COND to be the condition code for OMP_FOR GS. */
3940 gimple_omp_for_set_cond (gimple gs, size_t i, enum tree_code cond)
3942 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3943 gcc_assert (TREE_CODE_CLASS (cond) == tcc_comparison);
3944 gcc_assert (i < gs->gimple_omp_for.collapse);
3945 gs->gimple_omp_for.iter[i].cond = cond;
3949 /* Return the condition code associated with OMP_FOR GS. */
3951 static inline enum tree_code
3952 gimple_omp_for_cond (const_gimple gs, size_t i)
3954 GIMPLE_CHECK (gs, GIMPLE_OMP_FOR);
3955 gcc_assert (i < gs->gimple_omp_for.collapse);
3956 return gs->gimple_omp_for.iter[i].cond;
3960 /* Set the value being stored in an atomic store. */
3963 gimple_omp_atomic_store_set_val (gimple g, tree val)
3965 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
3966 g->gimple_omp_atomic_store.val = val;
3970 /* Return the value being stored in an atomic store. */
3973 gimple_omp_atomic_store_val (const_gimple g)
3975 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
3976 return g->gimple_omp_atomic_store.val;
3980 /* Return a pointer to the value being stored in an atomic store. */
3982 static inline tree *
3983 gimple_omp_atomic_store_val_ptr (gimple g)
3985 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_STORE);
3986 return &g->gimple_omp_atomic_store.val;
3990 /* Set the LHS of an atomic load. */
3993 gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
3995 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
3996 g->gimple_omp_atomic_load.lhs = lhs;
4000 /* Get the LHS of an atomic load. */
4003 gimple_omp_atomic_load_lhs (const_gimple g)
4005 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
4006 return g->gimple_omp_atomic_load.lhs;
4010 /* Return a pointer to the LHS of an atomic load. */
4012 static inline tree *
4013 gimple_omp_atomic_load_lhs_ptr (gimple g)
4015 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
4016 return &g->gimple_omp_atomic_load.lhs;
4020 /* Set the RHS of an atomic load. */
4023 gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
4025 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
4026 g->gimple_omp_atomic_load.rhs = rhs;
4030 /* Get the RHS of an atomic load. */
4033 gimple_omp_atomic_load_rhs (const_gimple g)
4035 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
4036 return g->gimple_omp_atomic_load.rhs;
4040 /* Return a pointer to the RHS of an atomic load. */
4042 static inline tree *
4043 gimple_omp_atomic_load_rhs_ptr (gimple g)
4045 GIMPLE_CHECK (g, GIMPLE_OMP_ATOMIC_LOAD);
4046 return &g->gimple_omp_atomic_load.rhs;
4050 /* Get the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
4053 gimple_omp_continue_control_def (const_gimple g)
4055 GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
4056 return g->gimple_omp_continue.control_def;
4059 /* The same as above, but return the address. */
4061 static inline tree *
4062 gimple_omp_continue_control_def_ptr (gimple g)
4064 GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
4065 return &g->gimple_omp_continue.control_def;
4068 /* Set the definition of the control variable in a GIMPLE_OMP_CONTINUE. */
4071 gimple_omp_continue_set_control_def (gimple g, tree def)
4073 GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
4074 g->gimple_omp_continue.control_def = def;
4078 /* Get the use of the control variable in a GIMPLE_OMP_CONTINUE. */
4081 gimple_omp_continue_control_use (const_gimple g)
4083 GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
4084 return g->gimple_omp_continue.control_use;
4088 /* The same as above, but return the address. */
4090 static inline tree *
4091 gimple_omp_continue_control_use_ptr (gimple g)
4093 GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
4094 return &g->gimple_omp_continue.control_use;
4098 /* Set the use of the control variable in a GIMPLE_OMP_CONTINUE. */
4101 gimple_omp_continue_set_control_use (gimple g, tree use)
4103 GIMPLE_CHECK (g, GIMPLE_OMP_CONTINUE);
4104 g->gimple_omp_continue.control_use = use;
4108 /* Return a pointer to the return value for GIMPLE_RETURN GS. */
4110 static inline tree *
4111 gimple_return_retval_ptr (const_gimple gs)
4113 GIMPLE_CHECK (gs, GIMPLE_RETURN);
4114 gcc_assert (gimple_num_ops (gs) == 1);
4115 return gimple_op_ptr (gs, 0);
4118 /* Return the return value for GIMPLE_RETURN GS. */
4121 gimple_return_retval (const_gimple gs)
4123 GIMPLE_CHECK (gs, GIMPLE_RETURN);
4124 gcc_assert (gimple_num_ops (gs) == 1);
4125 return gimple_op (gs, 0);
4129 /* Set RETVAL to be the return value for GIMPLE_RETURN GS. */
4132 gimple_return_set_retval (gimple gs, tree retval)
4134 GIMPLE_CHECK (gs, GIMPLE_RETURN);
4135 gcc_assert (gimple_num_ops (gs) == 1);
4136 gcc_assert (retval == NULL_TREE
4137 || TREE_CODE (retval) == RESULT_DECL
4138 || is_gimple_val (retval));
4139 gimple_set_op (gs, 0, retval);
4143 /* Returns true when the gimple statment STMT is any of the OpenMP types. */
4146 is_gimple_omp (const_gimple stmt)
4148 return (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
4149 || gimple_code (stmt) == GIMPLE_OMP_TASK
4150 || gimple_code (stmt) == GIMPLE_OMP_FOR
4151 || gimple_code (stmt) == GIMPLE_OMP_SECTIONS
4152 || gimple_code (stmt) == GIMPLE_OMP_SECTIONS_SWITCH
4153 || gimple_code (stmt) == GIMPLE_OMP_SINGLE
4154 || gimple_code (stmt) == GIMPLE_OMP_SECTION
4155 || gimple_code (stmt) == GIMPLE_OMP_MASTER
4156 || gimple_code (stmt) == GIMPLE_OMP_ORDERED
4157 || gimple_code (stmt) == GIMPLE_OMP_CRITICAL
4158 || gimple_code (stmt) == GIMPLE_OMP_RETURN
4159 || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_LOAD
4160 || gimple_code (stmt) == GIMPLE_OMP_ATOMIC_STORE
4161 || gimple_code (stmt) == GIMPLE_OMP_CONTINUE);
4165 /* Returns TRUE if statement G is a GIMPLE_NOP. */
4168 gimple_nop_p (const_gimple g)
4170 return gimple_code (g) == GIMPLE_NOP;
4174 /* Return the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS. */
4177 gimple_cdt_new_type (gimple gs)
4179 GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
4180 return gimple_op (gs, 1);
4183 /* Return a pointer to the new type set by GIMPLE_CHANGE_DYNAMIC_TYPE
4186 static inline tree *
4187 gimple_cdt_new_type_ptr (gimple gs)
4189 GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
4190 return gimple_op_ptr (gs, 1);
4193 /* Set NEW_TYPE to be the type returned by GIMPLE_CHANGE_DYNAMIC_TYPE
4197 gimple_cdt_set_new_type (gimple gs, tree new_type)
4199 GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
4200 gcc_assert (TREE_CODE_CLASS (TREE_CODE (new_type)) == tcc_type);
4201 gimple_set_op (gs, 1, new_type);
4205 /* Return the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE statement GS. */
4208 gimple_cdt_location (gimple gs)
4210 GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
4211 return gimple_op (gs, 0);
4215 /* Return a pointer to the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
4218 static inline tree *
4219 gimple_cdt_location_ptr (gimple gs)
4221 GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
4222 return gimple_op_ptr (gs, 0);
4226 /* Set PTR to be the location affected by GIMPLE_CHANGE_DYNAMIC_TYPE
4230 gimple_cdt_set_location (gimple gs, tree ptr)
4232 GIMPLE_CHECK (gs, GIMPLE_CHANGE_DYNAMIC_TYPE);
4233 gimple_set_op (gs, 0, ptr);
4237 /* Return the predictor of GIMPLE_PREDICT statement GS. */
4239 static inline enum br_predictor
4240 gimple_predict_predictor (gimple gs)
4242 GIMPLE_CHECK (gs, GIMPLE_PREDICT);
4243 return (enum br_predictor) (gs->gsbase.subcode & ~GF_PREDICT_TAKEN);
4247 /* Set the predictor of GIMPLE_PREDICT statement GS to PREDICT. */
4250 gimple_predict_set_predictor (gimple gs, enum br_predictor predictor)
4252 GIMPLE_CHECK (gs, GIMPLE_PREDICT);
4253 gs->gsbase.subcode = (gs->gsbase.subcode & GF_PREDICT_TAKEN)
4254 | (unsigned) predictor;
4258 /* Return the outcome of GIMPLE_PREDICT statement GS. */
4260 static inline enum prediction
4261 gimple_predict_outcome (gimple gs)
4263 GIMPLE_CHECK (gs, GIMPLE_PREDICT);
4264 return (gs->gsbase.subcode & GF_PREDICT_TAKEN) ? TAKEN : NOT_TAKEN;
4268 /* Set the outcome of GIMPLE_PREDICT statement GS to OUTCOME. */
4271 gimple_predict_set_outcome (gimple gs, enum prediction outcome)
4273 GIMPLE_CHECK (gs, GIMPLE_PREDICT);
4274 if (outcome == TAKEN)
4275 gs->gsbase.subcode |= GF_PREDICT_TAKEN;
4277 gs->gsbase.subcode &= ~GF_PREDICT_TAKEN;
4281 /* Return a new iterator pointing to GIMPLE_SEQ's first statement. */
4283 static inline gimple_stmt_iterator
4284 gsi_start (gimple_seq seq)
4286 gimple_stmt_iterator i;
4288 i.ptr = gimple_seq_first (seq);
4290 i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL;
4296 /* Return a new iterator pointing to the first statement in basic block BB. */
4298 static inline gimple_stmt_iterator
4299 gsi_start_bb (basic_block bb)
4301 gimple_stmt_iterator i;
4305 i.ptr = gimple_seq_first (seq);
4313 /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement. */
4315 static inline gimple_stmt_iterator
4316 gsi_last (gimple_seq seq)
4318 gimple_stmt_iterator i;
4320 i.ptr = gimple_seq_last (seq);
4322 i.bb = (i.ptr && i.ptr->stmt) ? gimple_bb (i.ptr->stmt) : NULL;
4328 /* Return a new iterator pointing to the last statement in basic block BB. */
4330 static inline gimple_stmt_iterator
4331 gsi_last_bb (basic_block bb)
4333 gimple_stmt_iterator i;
4337 i.ptr = gimple_seq_last (seq);
4345 /* Return true if I is at the end of its sequence. */
4348 gsi_end_p (gimple_stmt_iterator i)
4350 return i.ptr == NULL;
4354 /* Return true if I is one statement before the end of its sequence. */
4357 gsi_one_before_end_p (gimple_stmt_iterator i)
4359 return i.ptr != NULL && i.ptr->next == NULL;
4363 /* Advance the iterator to the next gimple statement. */
4366 gsi_next (gimple_stmt_iterator *i)
4368 i->ptr = i->ptr->next;
4371 /* Advance the iterator to the previous gimple statement. */
4374 gsi_prev (gimple_stmt_iterator *i)
4376 i->ptr = i->ptr->prev;
4379 /* Return the current stmt. */
4381 static inline gimple
4382 gsi_stmt (gimple_stmt_iterator i)
4387 /* Return a block statement iterator that points to the first non-label
4388 statement in block BB. */
4390 static inline gimple_stmt_iterator
4391 gsi_after_labels (basic_block bb)
4393 gimple_stmt_iterator gsi = gsi_start_bb (bb);
4395 while (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
4401 /* Return a pointer to the current stmt.
4403 NOTE: You may want to use gsi_replace on the iterator itself,
4404 as this performs additional bookkeeping that will not be done
4405 if you simply assign through a pointer returned by gsi_stmt_ptr. */
4407 static inline gimple *
4408 gsi_stmt_ptr (gimple_stmt_iterator *i)
4410 return &i->ptr->stmt;
4414 /* Return the basic block associated with this iterator. */
4416 static inline basic_block
4417 gsi_bb (gimple_stmt_iterator i)
4423 /* Return the sequence associated with this iterator. */
4425 static inline gimple_seq
4426 gsi_seq (gimple_stmt_iterator i)
4432 enum gsi_iterator_update
4434 GSI_NEW_STMT, /* Only valid when single statement is added, move
4436 GSI_SAME_STMT, /* Leave the iterator at the same statement. */
4437 GSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable
4438 for linking other statements in the same
4442 /* In gimple-iterator.c */
4443 gimple_stmt_iterator gsi_start_phis (basic_block);
4444 gimple_seq gsi_split_seq_after (gimple_stmt_iterator);
4445 gimple_seq gsi_split_seq_before (gimple_stmt_iterator *);
4446 void gsi_replace (gimple_stmt_iterator *, gimple, bool);
4447 void gsi_insert_before (gimple_stmt_iterator *, gimple,
4448 enum gsi_iterator_update);
4449 void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple,
4450 enum gsi_iterator_update);
4451 void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq,
4452 enum gsi_iterator_update);
4453 void gsi_insert_seq_before_without_update (gimple_stmt_iterator *, gimple_seq,
4454 enum gsi_iterator_update);
4455 void gsi_insert_after (gimple_stmt_iterator *, gimple,
4456 enum gsi_iterator_update);
4457 void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple,
4458 enum gsi_iterator_update);
4459 void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq,
4460 enum gsi_iterator_update);
4461 void gsi_insert_seq_after_without_update (gimple_stmt_iterator *, gimple_seq,
4462 enum gsi_iterator_update);
4463 void gsi_remove (gimple_stmt_iterator *, bool);
4464 gimple_stmt_iterator gsi_for_stmt (gimple);
4465 void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
4466 void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *);
4467 void gsi_move_to_bb_end (gimple_stmt_iterator *, struct basic_block_def *);
4468 void gsi_insert_on_edge (edge, gimple);
4469 void gsi_insert_seq_on_edge (edge, gimple_seq);
4470 basic_block gsi_insert_on_edge_immediate (edge, gimple);
4471 basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
4472 void gsi_commit_one_edge_insert (edge, basic_block *);
4473 void gsi_commit_edge_inserts (void);
4476 /* Convenience routines to walk all statements of a gimple function.
4477 Note that this is useful exclusively before the code is converted
4478 into SSA form. Once the program is in SSA form, the standard
4479 operand interface should be used to analyze/modify statements. */
4480 struct walk_stmt_info
4482 /* Points to the current statement being walked. */
4483 gimple_stmt_iterator gsi;
4485 /* Additional data that the callback functions may want to carry
4486 through the recursion. */
4489 /* Pointer map used to mark visited tree nodes when calling
4490 walk_tree on each operand. If set to NULL, duplicate tree nodes
4491 will be visited more than once. */
4492 struct pointer_set_t *pset;
4494 /* Indicates whether the operand being examined may be replaced
4495 with something that matches is_gimple_val (if true) or something
4496 slightly more complicated (if false). "Something" technically
4497 means the common subset of is_gimple_lvalue and is_gimple_rhs,
4498 but we never try to form anything more complicated than that, so
4499 we don't bother checking.
4501 Also note that CALLBACK should update this flag while walking the
4502 sub-expressions of a statement. For instance, when walking the
4503 statement 'foo (&var)', the flag VAL_ONLY will initially be set
4504 to true, however, when walking &var, the operand of that
4505 ADDR_EXPR does not need to be a GIMPLE value. */
4508 /* True if we are currently walking the LHS of an assignment. */
4511 /* Optional. Set to true by the callback functions if they made any
4515 /* True if we're interested in location information. */
4516 bool want_locations;
4518 /* Operand returned by the callbacks. This is set when calling
4519 walk_gimple_seq. If the walk_stmt_fn or walk_tree_fn callback
4520 returns non-NULL, this field will contain the tree returned by
4521 the last callback. */
4522 tree callback_result;
4525 /* Callback for walk_gimple_stmt. Called for every statement found
4526 during traversal. The first argument points to the statement to
4527 walk. The second argument is a flag that the callback sets to
4528 'true' if it the callback handled all the operands and
4529 sub-statements of the statement (the default value of this flag is
4530 'false'). The third argument is an anonymous pointer to data
4531 to be used by the callback. */
4532 typedef tree (*walk_stmt_fn) (gimple_stmt_iterator *, bool *,
4533 struct walk_stmt_info *);
4535 gimple walk_gimple_seq (gimple_seq, walk_stmt_fn, walk_tree_fn,
4536 struct walk_stmt_info *);
4537 tree walk_gimple_stmt (gimple_stmt_iterator *, walk_stmt_fn, walk_tree_fn,
4538 struct walk_stmt_info *);
4539 tree walk_gimple_op (gimple, walk_tree_fn, struct walk_stmt_info *);
4541 #ifdef GATHER_STATISTICS
4542 /* Enum and arrays used for allocation stats. Keep in sync with
4543 gimple.c:gimple_alloc_kind_names. */
4544 enum gimple_alloc_kind
4546 gimple_alloc_kind_assign, /* Assignments. */
4547 gimple_alloc_kind_phi, /* PHI nodes. */
4548 gimple_alloc_kind_cond, /* Conditionals. */
4549 gimple_alloc_kind_seq, /* Sequences. */
4550 gimple_alloc_kind_rest, /* Everything else. */
4551 gimple_alloc_kind_all
4554 extern int gimple_alloc_counts[];
4555 extern int gimple_alloc_sizes[];
4557 /* Return the allocation kind for a given stmt CODE. */
4558 static inline enum gimple_alloc_kind
4559 gimple_alloc_kind (enum gimple_code code)
4564 return gimple_alloc_kind_assign;
4566 return gimple_alloc_kind_phi;
4568 return gimple_alloc_kind_cond;
4570 return gimple_alloc_kind_rest;
4573 #endif /* GATHER_STATISTICS */
4575 extern void dump_gimple_statistics (void);
4577 #endif /* GCC_GIMPLE_H */