1 /* Header file for gimple iterators.
2    Copyright (C) 2013-2018 Free Software Foundation, Inc.
3 
4 This file is part of GCC.
5 
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10 
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14  for more details.
15 
16 You should have received a copy of the GNU General Public License
17 along 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 
25 struct 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.  */
39 struct gphi_iterator : public gimple_stmt_iterator
40 {
phigphi_iterator41   gphi *phi () const
42   {
43     return as_a <gphi *> (ptr);
44   }
45 };
46 
47 enum 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 
57 extern void gsi_insert_seq_before_without_update (gimple_stmt_iterator *,
58 						  gimple_seq,
59 						  enum gsi_iterator_update);
60 extern void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq,
61 				   enum gsi_iterator_update);
62 extern void gsi_insert_seq_after_without_update (gimple_stmt_iterator *,
63 						 gimple_seq,
64 						 enum gsi_iterator_update);
65 extern void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq,
66 				  enum gsi_iterator_update);
67 extern gimple_seq gsi_split_seq_after (gimple_stmt_iterator);
68 extern void gsi_set_stmt (gimple_stmt_iterator *, gimple *);
69 extern void gsi_split_seq_before (gimple_stmt_iterator *, gimple_seq *);
70 extern bool gsi_replace (gimple_stmt_iterator *, gimple *, bool);
71 extern void gsi_replace_with_seq (gimple_stmt_iterator *, gimple_seq, bool);
72 extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple *,
73 					      enum gsi_iterator_update);
74 extern void gsi_insert_before (gimple_stmt_iterator *, gimple *,
75 			       enum gsi_iterator_update);
76 extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple *,
77 					     enum gsi_iterator_update);
78 extern void gsi_insert_after (gimple_stmt_iterator *, gimple *,
79 			      enum gsi_iterator_update);
80 extern bool gsi_remove (gimple_stmt_iterator *, bool);
81 extern gimple_stmt_iterator gsi_for_stmt (gimple *);
82 extern gphi_iterator gsi_for_phi (gphi *);
83 extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
84 extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *);
85 extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block);
86 extern void gsi_insert_on_edge (edge, gimple *);
87 extern void gsi_insert_seq_on_edge (edge, gimple_seq);
88 extern basic_block gsi_insert_on_edge_immediate (edge, gimple *);
89 extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
90 extern void gsi_commit_edge_inserts (void);
91 extern void gsi_commit_one_edge_insert (edge, basic_block *);
92 extern gphi_iterator gsi_start_phis (basic_block);
93 extern void update_modified_stmts (gimple_seq);
94 
95 /* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */
96 
97 static inline gimple_stmt_iterator
gsi_start_1(gimple_seq * seq)98 gsi_start_1 (gimple_seq *seq)
99 {
100   gimple_stmt_iterator i;
101 
102   i.ptr = gimple_seq_first (*seq);
103   i.seq = seq;
104   i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
105 
106   return i;
107 }
108 
109 #define gsi_start(x) gsi_start_1 (&(x))
110 
111 static inline gimple_stmt_iterator
gsi_none(void)112 gsi_none (void)
113 {
114   gimple_stmt_iterator i;
115   i.ptr = NULL;
116   i.seq = NULL;
117   i.bb = NULL;
118   return i;
119 }
120 
121 /* Return a new iterator pointing to the first statement in basic block BB.  */
122 
123 static inline gimple_stmt_iterator
gsi_start_bb(basic_block bb)124 gsi_start_bb (basic_block bb)
125 {
126   gimple_stmt_iterator i;
127   gimple_seq *seq;
128 
129   seq = bb_seq_addr (bb);
130   i.ptr = gimple_seq_first (*seq);
131   i.seq = seq;
132   i.bb = bb;
133 
134   return i;
135 }
136 
137 gimple_stmt_iterator gsi_start_edge (edge e);
138 
139 /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement.  */
140 
141 static inline gimple_stmt_iterator
gsi_last_1(gimple_seq * seq)142 gsi_last_1 (gimple_seq *seq)
143 {
144   gimple_stmt_iterator i;
145 
146   i.ptr = gimple_seq_last (*seq);
147   i.seq = seq;
148   i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
149 
150   return i;
151 }
152 
153 #define gsi_last(x) gsi_last_1 (&(x))
154 
155 /* Return a new iterator pointing to the last statement in basic block BB.  */
156 
157 static inline gimple_stmt_iterator
gsi_last_bb(basic_block bb)158 gsi_last_bb (basic_block bb)
159 {
160   gimple_stmt_iterator i;
161   gimple_seq *seq;
162 
163   seq = bb_seq_addr (bb);
164   i.ptr = gimple_seq_last (*seq);
165   i.seq = seq;
166   i.bb = bb;
167 
168   return i;
169 }
170 
171 /* Return true if I is at the end of its sequence.  */
172 
173 static inline bool
gsi_end_p(gimple_stmt_iterator i)174 gsi_end_p (gimple_stmt_iterator i)
175 {
176   return i.ptr == NULL;
177 }
178 
179 /* Return true if I is one statement before the end of its sequence.  */
180 
181 static inline bool
gsi_one_before_end_p(gimple_stmt_iterator i)182 gsi_one_before_end_p (gimple_stmt_iterator i)
183 {
184   return i.ptr != NULL && i.ptr->next == NULL;
185 }
186 
187 /* Advance the iterator to the next gimple statement.  */
188 
189 static inline void
gsi_next(gimple_stmt_iterator * i)190 gsi_next (gimple_stmt_iterator *i)
191 {
192   i->ptr = i->ptr->next;
193 }
194 
195 /* Advance the iterator to the previous gimple statement.  */
196 
197 static inline void
gsi_prev(gimple_stmt_iterator * i)198 gsi_prev (gimple_stmt_iterator *i)
199 {
200   gimple *prev = i->ptr->prev;
201   if (prev->next)
202     i->ptr = prev;
203   else
204     i->ptr = NULL;
205 }
206 
207 /* Return the current stmt.  */
208 
209 static inline gimple *
gsi_stmt(gimple_stmt_iterator i)210 gsi_stmt (gimple_stmt_iterator i)
211 {
212   return i.ptr;
213 }
214 
215 /* Return a block statement iterator that points to the first
216    non-label statement in block BB.  */
217 
218 static inline gimple_stmt_iterator
gsi_after_labels(basic_block bb)219 gsi_after_labels (basic_block bb)
220 {
221   gimple_stmt_iterator gsi = gsi_start_bb (bb);
222 
223   for (; !gsi_end_p (gsi); )
224     {
225       if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
226 	gsi_next (&gsi);
227       else
228 	break;
229     }
230 
231   return gsi;
232 }
233 
234 /* Advance the iterator to the next non-debug gimple statement.  */
235 
236 static inline void
gsi_next_nondebug(gimple_stmt_iterator * i)237 gsi_next_nondebug (gimple_stmt_iterator *i)
238 {
239   do
240     {
241       gsi_next (i);
242     }
243   while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
244 }
245 
246 /* Advance the iterator to the previous non-debug gimple statement.  */
247 
248 static inline void
gsi_prev_nondebug(gimple_stmt_iterator * i)249 gsi_prev_nondebug (gimple_stmt_iterator *i)
250 {
251   do
252     {
253       gsi_prev (i);
254     }
255   while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
256 }
257 
258 /* Return a new iterator pointing to the first non-debug statement in
259    SEQ.  */
260 
261 static inline gimple_stmt_iterator
gsi_start_nondebug(gimple_seq seq)262 gsi_start_nondebug (gimple_seq seq)
263 {
264   gimple_stmt_iterator gsi = gsi_start (seq);
265   if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
266     gsi_next_nondebug (&gsi);
267 
268   return gsi;
269 }
270 
271 /* Return a new iterator pointing to the first non-debug statement in
272    basic block BB.  */
273 
274 static inline gimple_stmt_iterator
gsi_start_nondebug_bb(basic_block bb)275 gsi_start_nondebug_bb (basic_block bb)
276 {
277   gimple_stmt_iterator i = gsi_start_bb (bb);
278 
279   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
280     gsi_next_nondebug (&i);
281 
282   return i;
283 }
284 
285 /* Return a new iterator pointing to the first non-debug non-label statement in
286    basic block BB.  */
287 
288 static inline gimple_stmt_iterator
gsi_start_nondebug_after_labels_bb(basic_block bb)289 gsi_start_nondebug_after_labels_bb (basic_block bb)
290 {
291   gimple_stmt_iterator i = gsi_after_labels (bb);
292 
293   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
294     gsi_next_nondebug (&i);
295 
296   return i;
297 }
298 
299 /* Return a new iterator pointing to the last non-debug statement in
300    basic block BB.  */
301 
302 static inline gimple_stmt_iterator
gsi_last_nondebug_bb(basic_block bb)303 gsi_last_nondebug_bb (basic_block bb)
304 {
305   gimple_stmt_iterator i = gsi_last_bb (bb);
306 
307   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
308     gsi_prev_nondebug (&i);
309 
310   return i;
311 }
312 
313 /* Return true if I is followed only by debug statements in its
314    sequence.  */
315 
316 static inline bool
gsi_one_nondebug_before_end_p(gimple_stmt_iterator i)317 gsi_one_nondebug_before_end_p (gimple_stmt_iterator i)
318 {
319   if (gsi_one_before_end_p (i))
320     return true;
321   if (gsi_end_p (i))
322     return false;
323   gsi_next_nondebug (&i);
324   return gsi_end_p (i);
325 }
326 
327 /* Iterates I statement iterator to the next non-virtual statement.  */
328 
329 static inline void
gsi_next_nonvirtual_phi(gphi_iterator * i)330 gsi_next_nonvirtual_phi (gphi_iterator *i)
331 {
332   gphi *phi;
333 
334   if (gsi_end_p (*i))
335     return;
336 
337   phi = i->phi ();
338   gcc_assert (phi != NULL);
339 
340   while (virtual_operand_p (gimple_phi_result (phi)))
341     {
342       gsi_next (i);
343 
344       if (gsi_end_p (*i))
345 	return;
346 
347       phi = i->phi ();
348     }
349 }
350 
351 /* Return the basic block associated with this iterator.  */
352 
353 static inline basic_block
gsi_bb(gimple_stmt_iterator i)354 gsi_bb (gimple_stmt_iterator i)
355 {
356   return i.bb;
357 }
358 
359 /* Return the sequence associated with this iterator.  */
360 
361 static inline gimple_seq
gsi_seq(gimple_stmt_iterator i)362 gsi_seq (gimple_stmt_iterator i)
363 {
364   return *i.seq;
365 }
366 
367 /* Determine whether SEQ is a nondebug singleton.  */
368 
369 static inline bool
gimple_seq_nondebug_singleton_p(gimple_seq seq)370 gimple_seq_nondebug_singleton_p (gimple_seq seq)
371 {
372   gimple_stmt_iterator gsi;
373 
374   /* Find a nondebug gimple.  */
375   gsi.ptr = gimple_seq_first (seq);
376   gsi.seq = &seq;
377   gsi.bb = NULL;
378   while (!gsi_end_p (gsi)
379 	 && is_gimple_debug (gsi_stmt (gsi)))
380     gsi_next (&gsi);
381 
382   /* No nondebug gimple found, not a singleton.  */
383   if (gsi_end_p (gsi))
384     return false;
385 
386   /* Find a next nondebug gimple.  */
387   gsi_next (&gsi);
388   while (!gsi_end_p (gsi)
389 	 && is_gimple_debug (gsi_stmt (gsi)))
390     gsi_next (&gsi);
391 
392   /* Only a singleton if there's no next nondebug gimple.  */
393   return gsi_end_p (gsi);
394 }
395 
396 #endif /* GCC_GIMPLE_ITERATOR_H */
397