Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple-iterator.h @ 111:04ced10e8804

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents
children 84e7813d76e9
comparison
equal deleted inserted replaced
68:561a7518be6b 111:04ced10e8804
1 /* Header file for gimple iterators.
2 Copyright (C) 2013-2017 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 {
41 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
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
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
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
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
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
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
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
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
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 *
210 gsi_stmt (gimple_stmt_iterator i)
211 {
212 return i.ptr;
213 }
214
215 /* Return a new iterator pointing to the first non-debug statement
216 in basic block BB. */
217
218 static inline gimple_stmt_iterator
219 gsi_start_bb_nondebug (basic_block bb)
220 {
221 gimple_stmt_iterator gsi = gsi_start_bb (bb);
222 while (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
223 gsi_next (&gsi);
224
225 return gsi;
226 }
227
228 /* Return a block statement iterator that points to the first non-label
229 statement in block BB. */
230
231 static inline gimple_stmt_iterator
232 gsi_after_labels (basic_block bb)
233 {
234 gimple_stmt_iterator gsi = gsi_start_bb (bb);
235
236 while (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
237 gsi_next (&gsi);
238
239 return gsi;
240 }
241
242 /* Advance the iterator to the next non-debug gimple statement. */
243
244 static inline void
245 gsi_next_nondebug (gimple_stmt_iterator *i)
246 {
247 do
248 {
249 gsi_next (i);
250 }
251 while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
252 }
253
254 /* Advance the iterator to the previous non-debug gimple statement. */
255
256 static inline void
257 gsi_prev_nondebug (gimple_stmt_iterator *i)
258 {
259 do
260 {
261 gsi_prev (i);
262 }
263 while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
264 }
265
266 /* Return a new iterator pointing to the first non-debug statement in
267 basic block BB. */
268
269 static inline gimple_stmt_iterator
270 gsi_start_nondebug_bb (basic_block bb)
271 {
272 gimple_stmt_iterator i = gsi_start_bb (bb);
273
274 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
275 gsi_next_nondebug (&i);
276
277 return i;
278 }
279
280 /* Return a new iterator pointing to the first non-debug non-label statement in
281 basic block BB. */
282
283 static inline gimple_stmt_iterator
284 gsi_start_nondebug_after_labels_bb (basic_block bb)
285 {
286 gimple_stmt_iterator i = gsi_after_labels (bb);
287
288 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
289 gsi_next_nondebug (&i);
290
291 return i;
292 }
293
294 /* Return a new iterator pointing to the last non-debug statement in
295 basic block BB. */
296
297 static inline gimple_stmt_iterator
298 gsi_last_nondebug_bb (basic_block bb)
299 {
300 gimple_stmt_iterator i = gsi_last_bb (bb);
301
302 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
303 gsi_prev_nondebug (&i);
304
305 return i;
306 }
307
308 /* Return true if I is followed only by debug statements in its
309 sequence. */
310
311 static inline bool
312 gsi_one_nondebug_before_end_p (gimple_stmt_iterator i)
313 {
314 if (gsi_one_before_end_p (i))
315 return true;
316 if (gsi_end_p (i))
317 return false;
318 gsi_next_nondebug (&i);
319 return gsi_end_p (i);
320 }
321
322 /* Iterates I statement iterator to the next non-virtual statement. */
323
324 static inline void
325 gsi_next_nonvirtual_phi (gphi_iterator *i)
326 {
327 gphi *phi;
328
329 if (gsi_end_p (*i))
330 return;
331
332 phi = i->phi ();
333 gcc_assert (phi != NULL);
334
335 while (virtual_operand_p (gimple_phi_result (phi)))
336 {
337 gsi_next (i);
338
339 if (gsi_end_p (*i))
340 return;
341
342 phi = i->phi ();
343 }
344 }
345
346 /* Return the basic block associated with this iterator. */
347
348 static inline basic_block
349 gsi_bb (gimple_stmt_iterator i)
350 {
351 return i.bb;
352 }
353
354 /* Return the sequence associated with this iterator. */
355
356 static inline gimple_seq
357 gsi_seq (gimple_stmt_iterator i)
358 {
359 return *i.seq;
360 }
361
362 /* Determine whether SEQ is a nondebug singleton. */
363
364 static inline bool
365 gimple_seq_nondebug_singleton_p (gimple_seq seq)
366 {
367 gimple_stmt_iterator gsi;
368
369 /* Find a nondebug gimple. */
370 gsi.ptr = gimple_seq_first (seq);
371 gsi.seq = &seq;
372 gsi.bb = NULL;
373 while (!gsi_end_p (gsi)
374 && is_gimple_debug (gsi_stmt (gsi)))
375 gsi_next (&gsi);
376
377 /* No nondebug gimple found, not a singleton. */
378 if (gsi_end_p (gsi))
379 return false;
380
381 /* Find a next nondebug gimple. */
382 gsi_next (&gsi);
383 while (!gsi_end_p (gsi)
384 && is_gimple_debug (gsi_stmt (gsi)))
385 gsi_next (&gsi);
386
387 /* Only a singleton if there's no next nondebug gimple. */
388 return gsi_end_p (gsi);
389 }
390
391 #endif /* GCC_GIMPLE_ITERATOR_H */