1/* Header file for gimple iterators.
2 Copyright (C) 2013-2026 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 gimple *operator * () const { return ptr; }
28
29 /* Sequence node holding the current statement. */
30 gimple_seq_node ptr;
31
32 /* Sequence and basic block holding the statement. These fields
33 are necessary to handle edge cases such as when statement is
34 added to an empty basic block or when the last statement of a
35 block/sequence is removed. */
36 gimple_seq *seq;
37 basic_block bb;
38};
39
40/* Iterator over GIMPLE_PHI statements. */
41struct gphi_iterator : public gimple_stmt_iterator
42{
43 gphi *operator * () const { return as_a <gphi *> (p: ptr); }
44
45 gphi *phi () const
46 {
47 return as_a <gphi *> (p: ptr);
48 }
49};
50
51enum gsi_iterator_update
52{
53 GSI_NEW_STMT = 2, /* Move the iterator to the first statement added. */
54 GSI_LAST_NEW_STMT, /* Move the iterator to the last statement added. */
55 GSI_SAME_STMT, /* Leave the iterator at the same statement. */
56 GSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable
57 for linking other statements in the same
58 direction. */
59};
60
61extern void gsi_insert_seq_before_without_update (gimple_stmt_iterator *,
62 gimple_seq,
63 enum gsi_iterator_update);
64extern void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq,
65 enum gsi_iterator_update);
66extern void gsi_insert_seq_after_without_update (gimple_stmt_iterator *,
67 gimple_seq,
68 enum gsi_iterator_update);
69extern void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq,
70 enum gsi_iterator_update);
71extern gimple_seq gsi_split_seq_after (gimple_stmt_iterator);
72extern void gsi_set_stmt (gimple_stmt_iterator *, gimple *);
73extern void gsi_split_seq_before (gimple_stmt_iterator *, gimple_seq *);
74extern bool gsi_replace (gimple_stmt_iterator *, gimple *, bool);
75extern void gsi_replace_with_seq (gimple_stmt_iterator *, gimple_seq, bool);
76extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple *,
77 enum gsi_iterator_update);
78extern void gsi_insert_before (gimple_stmt_iterator *, gimple *,
79 enum gsi_iterator_update);
80extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple *,
81 enum gsi_iterator_update);
82extern void gsi_insert_after (gimple_stmt_iterator *, gimple *,
83 enum gsi_iterator_update);
84extern bool gsi_remove (gimple_stmt_iterator *, bool);
85extern gimple_stmt_iterator gsi_for_stmt (gimple *);
86extern gimple_stmt_iterator gsi_for_stmt (gimple *, gimple_seq *);
87extern gphi_iterator gsi_for_phi (gphi *);
88extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
89extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *,
90 gsi_iterator_update = GSI_SAME_STMT);
91extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block);
92extern void gsi_insert_on_edge (edge, gimple *);
93extern void gsi_insert_seq_on_edge (edge, gimple_seq);
94extern basic_block gsi_insert_on_edge_immediate (edge, gimple *);
95extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
96extern void gsi_safe_insert_before (gimple_stmt_iterator *, gimple *);
97extern void gsi_safe_insert_seq_before (gimple_stmt_iterator *, gimple_seq);
98extern void gsi_commit_edge_inserts (void);
99extern void gsi_commit_one_edge_insert (edge, basic_block *);
100extern gphi_iterator gsi_start_phis (basic_block);
101extern void update_modified_stmts (gimple_seq);
102
103/* Return a new iterator pointing to GIMPLE_SEQ's first statement. */
104
105inline gimple_stmt_iterator
106gsi_start (gimple_seq &seq)
107{
108 gimple_stmt_iterator i;
109
110 i.ptr = gimple_seq_first (s: seq);
111 i.seq = &seq;
112 i.bb = i.ptr ? gimple_bb (g: i.ptr) : NULL;
113
114 return i;
115}
116
117inline gimple_stmt_iterator
118gsi_none (void)
119{
120 gimple_stmt_iterator i;
121 i.ptr = NULL;
122 i.seq = NULL;
123 i.bb = NULL;
124 return i;
125}
126
127/* Return a new iterator pointing to the first statement in basic block BB. */
128
129inline gimple_stmt_iterator
130gsi_start_bb (basic_block bb)
131{
132 gimple_stmt_iterator i;
133 gimple_seq *seq;
134
135 seq = bb_seq_addr (bb);
136 i.ptr = gimple_seq_first (s: *seq);
137 i.seq = seq;
138 i.bb = bb;
139
140 return i;
141}
142
143gimple_stmt_iterator gsi_start_edge (edge e);
144
145/* Return a new iterator initially pointing to GIMPLE_SEQ's last statement. */
146
147inline gimple_stmt_iterator
148gsi_last (gimple_seq &seq)
149{
150 gimple_stmt_iterator i;
151
152 i.ptr = gimple_seq_last (s: seq);
153 i.seq = &seq;
154 i.bb = i.ptr ? gimple_bb (g: i.ptr) : NULL;
155
156 return i;
157}
158
159/* Return a new iterator pointing to the last statement in basic block BB. */
160
161inline gimple_stmt_iterator
162gsi_last_bb (basic_block bb)
163{
164 gimple_stmt_iterator i;
165 gimple_seq *seq;
166
167 seq = bb_seq_addr (bb);
168 i.ptr = gimple_seq_last (s: *seq);
169 i.seq = seq;
170 i.bb = bb;
171
172 return i;
173}
174
175/* Return a new iterator pointing to before the first statement or after
176 last statement (depending on whether adding statements after it or before it)
177 in a GIMPLE_SEQ. */
178
179inline gimple_stmt_iterator
180gsi_end (gimple_seq &seq)
181{
182 gimple_stmt_iterator i;
183 gimple *g = gimple_seq_last (s: seq);
184
185 i.ptr = NULL;
186 i.seq = &seq;
187 i.bb = g ? gimple_bb (g) : NULL;
188
189 return i;
190}
191
192/* Return a new iterator pointing to before the first statement or after
193 last statement (depending on whether adding statements after it or before it)
194 in basic block BB. */
195
196inline gimple_stmt_iterator
197gsi_end_bb (basic_block bb)
198{
199 gimple_stmt_iterator i;
200 gimple_seq *seq;
201
202 seq = bb_seq_addr (bb);
203 i.ptr = NULL;
204 i.seq = seq;
205 i.bb = bb;
206
207 return i;
208}
209
210/* Return true if I is at the end of its sequence. */
211
212inline bool
213gsi_end_p (gimple_stmt_iterator i)
214{
215 return i.ptr == NULL;
216}
217
218/* Return true if I is one statement before the end of its sequence. */
219
220inline bool
221gsi_one_before_end_p (gimple_stmt_iterator i)
222{
223 return i.ptr != NULL && i.ptr->next == NULL;
224}
225
226/* Advance the iterator to the next gimple statement. */
227
228inline void
229gsi_next (gimple_stmt_iterator *i)
230{
231 i->ptr = i->ptr->next;
232}
233
234/* Advance the iterator to the previous gimple statement. */
235
236inline void
237gsi_prev (gimple_stmt_iterator *i)
238{
239 gimple *prev = i->ptr->prev;
240 if (prev->next)
241 i->ptr = prev;
242 else
243 i->ptr = NULL;
244}
245
246/* Return the current stmt. */
247
248inline gimple *
249gsi_stmt (gimple_stmt_iterator i)
250{
251 return i.ptr;
252}
253
254/* Return a block statement iterator that points to the first
255 non-label statement in block BB. */
256
257inline gimple_stmt_iterator
258gsi_after_labels (basic_block bb)
259{
260 gimple_stmt_iterator gsi = gsi_start_bb (bb);
261
262 for (; !gsi_end_p (i: gsi); )
263 {
264 if (gimple_code (g: gsi_stmt (i: gsi)) == GIMPLE_LABEL)
265 gsi_next (i: &gsi);
266 else
267 break;
268 }
269
270 return gsi;
271}
272
273/* Return a statement iterator that points to the first
274 non-label statement in sequence SEQ. */
275
276inline gimple_stmt_iterator
277gsi_after_labels (gimple_seq &seq)
278{
279 gimple_stmt_iterator gsi = gsi_start (seq);
280
281 for (; !gsi_end_p (i: gsi); )
282 {
283 if (gimple_code (g: gsi_stmt (i: gsi)) == GIMPLE_LABEL)
284 gsi_next (i: &gsi);
285 else
286 break;
287 }
288
289 return gsi;
290}
291
292/* Advance the iterator to the next non-debug gimple statement. */
293
294inline void
295gsi_next_nondebug (gimple_stmt_iterator *i)
296{
297 do
298 {
299 gsi_next (i);
300 }
301 while (!gsi_end_p (i: *i) && is_gimple_debug (gs: gsi_stmt (i: *i)));
302}
303
304/* Advance the iterator to the previous non-debug gimple statement. */
305
306inline void
307gsi_prev_nondebug (gimple_stmt_iterator *i)
308{
309 do
310 {
311 gsi_prev (i);
312 }
313 while (!gsi_end_p (i: *i) && is_gimple_debug (gs: gsi_stmt (i: *i)));
314}
315
316/* Return a new iterator pointing to the first non-debug statement in
317 SEQ. */
318
319inline gimple_stmt_iterator
320gsi_start_nondebug (gimple_seq seq)
321{
322 gimple_stmt_iterator gsi = gsi_start (seq);
323 if (!gsi_end_p (i: gsi) && is_gimple_debug (gs: gsi_stmt (i: gsi)))
324 gsi_next_nondebug (i: &gsi);
325
326 return gsi;
327}
328
329/* Return a new iterator pointing to the first non-debug statement in
330 basic block BB. */
331
332inline gimple_stmt_iterator
333gsi_start_nondebug_bb (basic_block bb)
334{
335 gimple_stmt_iterator i = gsi_start_bb (bb);
336
337 if (!gsi_end_p (i) && is_gimple_debug (gs: gsi_stmt (i)))
338 gsi_next_nondebug (i: &i);
339
340 return i;
341}
342
343/* Return a new iterator pointing to the first non-debug non-label statement in
344 basic block BB. */
345
346inline gimple_stmt_iterator
347gsi_start_nondebug_after_labels_bb (basic_block bb)
348{
349 gimple_stmt_iterator i = gsi_after_labels (bb);
350
351 if (!gsi_end_p (i) && is_gimple_debug (gs: gsi_stmt (i)))
352 gsi_next_nondebug (i: &i);
353
354 return i;
355}
356
357/* Return a new iterator pointing to the last non-debug statement in
358 basic block BB. */
359
360inline gimple_stmt_iterator
361gsi_last_nondebug_bb (basic_block bb)
362{
363 gimple_stmt_iterator i = gsi_last_bb (bb);
364
365 if (!gsi_end_p (i) && is_gimple_debug (gs: gsi_stmt (i)))
366 gsi_prev_nondebug (i: &i);
367
368 return i;
369}
370
371/* Return true if I is followed only by debug statements in its
372 sequence. */
373
374inline bool
375gsi_one_nondebug_before_end_p (gimple_stmt_iterator i)
376{
377 if (gsi_one_before_end_p (i))
378 return true;
379 if (gsi_end_p (i))
380 return false;
381 gsi_next_nondebug (i: &i);
382 return gsi_end_p (i);
383}
384
385/* Advance I statement iterator to the next non-virtual GIMPLE_PHI
386 statement. */
387
388inline void
389gsi_next_nonvirtual_phi (gphi_iterator *i)
390{
391 do
392 {
393 gsi_next (i);
394 }
395 while (!gsi_end_p (i: *i) && virtual_operand_p (op: gimple_phi_result (gs: i->phi ())));
396}
397
398/* Return a new iterator pointing to the first non-virtual phi statement in
399 basic block BB. */
400
401inline gphi_iterator
402gsi_start_nonvirtual_phis (basic_block bb)
403{
404 gphi_iterator i = gsi_start_phis (bb);
405
406 if (!gsi_end_p (i) && virtual_operand_p (op: gimple_phi_result (gs: i.phi ())))
407 gsi_next_nonvirtual_phi (i: &i);
408
409 return i;
410}
411
412/* Return the basic block associated with this iterator. */
413
414inline basic_block
415gsi_bb (gimple_stmt_iterator i)
416{
417 return i.bb;
418}
419
420/* Return the sequence associated with this iterator. */
421
422inline gimple_seq
423gsi_seq (gimple_stmt_iterator i)
424{
425 return *i.seq;
426}
427
428/* Determine whether SEQ is a nondebug singleton. */
429
430inline bool
431gimple_seq_nondebug_singleton_p (gimple_seq seq)
432{
433 gimple_stmt_iterator gsi = gsi_start_nondebug (seq);
434
435 return gsi_one_nondebug_before_end_p (i: gsi);
436}
437
438#endif /* GCC_GIMPLE_ITERATOR_H */
439

source code of gcc/gimple-iterator.h