1/* Header file for gimple iterators.
2   Copyright (C) 2013-2015 Free Software Foundation, Inc.
3
4This file is part of GCC.
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16You should have received a copy of the GNU General Public License
17along with GCC; see the file COPYING3.  If not see
18<http://www.gnu.org/licenses/>.  */
19
20#ifndef GCC_GIMPLE_ITERATOR_H
21#define GCC_GIMPLE_ITERATOR_H
22
23/* Iterator object for GIMPLE statement sequences.  */
24
25struct gimple_stmt_iterator
26{
27  /* Sequence node holding the current statement.  */
28  gimple_seq_node ptr;
29
30  /* Sequence and basic block holding the statement.  These fields
31     are necessary to handle edge cases such as when statement is
32     added to an empty basic block or when the last statement of a
33     block/sequence is removed.  */
34  gimple_seq *seq;
35  basic_block bb;
36};
37
38/* Iterator over GIMPLE_PHI statements.  */
39struct gphi_iterator : public gimple_stmt_iterator
40{
41  gphi *phi () const
42  {
43    return as_a <gphi *> (ptr);
44  }
45};
46
47enum gsi_iterator_update
48{
49  GSI_NEW_STMT,		/* Only valid when single statement is added, move
50			   iterator to it.  */
51  GSI_SAME_STMT,	/* Leave the iterator at the same statement.  */
52  GSI_CONTINUE_LINKING	/* Move iterator to whatever position is suitable
53			   for linking other statements in the same
54			   direction.  */
55};
56
57extern void gsi_insert_seq_before_without_update (gimple_stmt_iterator *,
58						  gimple_seq,
59						  enum gsi_iterator_update);
60extern void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq,
61				   enum gsi_iterator_update);
62extern void gsi_insert_seq_after_without_update (gimple_stmt_iterator *,
63						 gimple_seq,
64						 enum gsi_iterator_update);
65extern void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq,
66				  enum gsi_iterator_update);
67extern gimple_seq gsi_split_seq_after (gimple_stmt_iterator);
68extern void gsi_set_stmt (gimple_stmt_iterator *, gimple);
69extern void gsi_split_seq_before (gimple_stmt_iterator *, gimple_seq *);
70extern bool gsi_replace (gimple_stmt_iterator *, gimple, bool);
71extern void gsi_replace_with_seq (gimple_stmt_iterator *, gimple_seq, bool);
72extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple,
73					      enum gsi_iterator_update);
74extern void gsi_insert_before (gimple_stmt_iterator *, gimple,
75			       enum gsi_iterator_update);
76extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple,
77					     enum gsi_iterator_update);
78extern void gsi_insert_after (gimple_stmt_iterator *, gimple,
79			      enum gsi_iterator_update);
80extern bool gsi_remove (gimple_stmt_iterator *, bool);
81extern gimple_stmt_iterator gsi_for_stmt (gimple);
82extern gphi_iterator gsi_for_phi (gphi *);
83extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
84extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *);
85extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block);
86extern void gsi_insert_on_edge (edge, gimple);
87extern void gsi_insert_seq_on_edge (edge, gimple_seq);
88extern basic_block gsi_insert_on_edge_immediate (edge, gimple);
89extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
90extern void gsi_commit_edge_inserts (void);
91extern void gsi_commit_one_edge_insert (edge, basic_block *);
92extern gphi_iterator gsi_start_phis (basic_block);
93
94/* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */
95
96static inline gimple_stmt_iterator
97gsi_start_1 (gimple_seq *seq)
98{
99  gimple_stmt_iterator i;
100
101  i.ptr = gimple_seq_first (*seq);
102  i.seq = seq;
103  i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
104
105  return i;
106}
107
108#define gsi_start(x) gsi_start_1 (&(x))
109
110static inline gimple_stmt_iterator
111gsi_none (void)
112{
113  gimple_stmt_iterator i;
114  i.ptr = NULL;
115  i.seq = NULL;
116  i.bb = NULL;
117  return i;
118}
119
120/* Return a new iterator pointing to the first statement in basic block BB.  */
121
122static inline gimple_stmt_iterator
123gsi_start_bb (basic_block bb)
124{
125  gimple_stmt_iterator i;
126  gimple_seq *seq;
127
128  seq = bb_seq_addr (bb);
129  i.ptr = gimple_seq_first (*seq);
130  i.seq = seq;
131  i.bb = bb;
132
133  return i;
134}
135
136gimple_stmt_iterator gsi_start_edge (edge e);
137
138/* Return a new iterator initially pointing to GIMPLE_SEQ's last statement.  */
139
140static inline gimple_stmt_iterator
141gsi_last_1 (gimple_seq *seq)
142{
143  gimple_stmt_iterator i;
144
145  i.ptr = gimple_seq_last (*seq);
146  i.seq = seq;
147  i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
148
149  return i;
150}
151
152#define gsi_last(x) gsi_last_1 (&(x))
153
154/* Return a new iterator pointing to the last statement in basic block BB.  */
155
156static inline gimple_stmt_iterator
157gsi_last_bb (basic_block bb)
158{
159  gimple_stmt_iterator i;
160  gimple_seq *seq;
161
162  seq = bb_seq_addr (bb);
163  i.ptr = gimple_seq_last (*seq);
164  i.seq = seq;
165  i.bb = bb;
166
167  return i;
168}
169
170/* Return true if I is at the end of its sequence.  */
171
172static inline bool
173gsi_end_p (gimple_stmt_iterator i)
174{
175  return i.ptr == NULL;
176}
177
178/* Return true if I is one statement before the end of its sequence.  */
179
180static inline bool
181gsi_one_before_end_p (gimple_stmt_iterator i)
182{
183  return i.ptr != NULL && i.ptr->next == NULL;
184}
185
186/* Advance the iterator to the next gimple statement.  */
187
188static inline void
189gsi_next (gimple_stmt_iterator *i)
190{
191  i->ptr = i->ptr->next;
192}
193
194/* Advance the iterator to the previous gimple statement.  */
195
196static inline void
197gsi_prev (gimple_stmt_iterator *i)
198{
199  gimple prev = i->ptr->prev;
200  if (prev->next)
201    i->ptr = prev;
202  else
203    i->ptr = NULL;
204}
205
206/* Return the current stmt.  */
207
208static inline gimple
209gsi_stmt (gimple_stmt_iterator i)
210{
211  return i.ptr;
212}
213
214/* Return a new iterator pointing to the first non-debug statement
215   in basic block BB.  */
216
217static inline gimple_stmt_iterator
218gsi_start_bb_nondebug (basic_block bb)
219{
220  gimple_stmt_iterator gsi = gsi_start_bb (bb);
221  while (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
222    gsi_next (&gsi);
223
224  return gsi;
225}
226
227/* Return a block statement iterator that points to the first non-label
228   statement in block BB.  */
229
230static inline gimple_stmt_iterator
231gsi_after_labels (basic_block bb)
232{
233  gimple_stmt_iterator gsi = gsi_start_bb (bb);
234
235  while (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
236    gsi_next (&gsi);
237
238  return gsi;
239}
240
241/* Advance the iterator to the next non-debug gimple statement.  */
242
243static inline void
244gsi_next_nondebug (gimple_stmt_iterator *i)
245{
246  do
247    {
248      gsi_next (i);
249    }
250  while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
251}
252
253/* Advance the iterator to the previous non-debug gimple statement.  */
254
255static inline void
256gsi_prev_nondebug (gimple_stmt_iterator *i)
257{
258  do
259    {
260      gsi_prev (i);
261    }
262  while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
263}
264
265/* Return a new iterator pointing to the first non-debug statement in
266   basic block BB.  */
267
268static inline gimple_stmt_iterator
269gsi_start_nondebug_bb (basic_block bb)
270{
271  gimple_stmt_iterator i = gsi_start_bb (bb);
272
273  if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
274    gsi_next_nondebug (&i);
275
276  return i;
277}
278
279/* Return a new iterator pointing to the first non-debug non-label statement in
280   basic block BB.  */
281
282static inline gimple_stmt_iterator
283gsi_start_nondebug_after_labels_bb (basic_block bb)
284{
285  gimple_stmt_iterator i = gsi_after_labels (bb);
286
287  if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
288    gsi_next_nondebug (&i);
289
290  return i;
291}
292
293/* Return a new iterator pointing to the last non-debug statement in
294   basic block BB.  */
295
296static inline gimple_stmt_iterator
297gsi_last_nondebug_bb (basic_block bb)
298{
299  gimple_stmt_iterator i = gsi_last_bb (bb);
300
301  if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
302    gsi_prev_nondebug (&i);
303
304  return i;
305}
306
307/* Iterates I statement iterator to the next non-virtual statement.  */
308
309static inline void
310gsi_next_nonvirtual_phi (gphi_iterator *i)
311{
312  gphi *phi;
313
314  if (gsi_end_p (*i))
315    return;
316
317  phi = i->phi ();
318  gcc_assert (phi != NULL);
319
320  while (virtual_operand_p (gimple_phi_result (phi)))
321    {
322      gsi_next (i);
323
324      if (gsi_end_p (*i))
325	return;
326
327      phi = i->phi ();
328    }
329}
330
331/* Return the basic block associated with this iterator.  */
332
333static inline basic_block
334gsi_bb (gimple_stmt_iterator i)
335{
336  return i.bb;
337}
338
339/* Return the sequence associated with this iterator.  */
340
341static inline gimple_seq
342gsi_seq (gimple_stmt_iterator i)
343{
344  return *i.seq;
345}
346
347#endif /* GCC_GIMPLE_ITERATOR_H */
348