|
0
|
1 /* Iterator routines for GIMPLE statements.
|
|
|
2 Copyright (C) 2007, 2008 Free Software Foundation, Inc.
|
|
|
3 Contributed by Aldy Hernandez <aldy@quesejoda.com>
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "tm.h"
|
|
|
25 #include "tree.h"
|
|
|
26 #include "gimple.h"
|
|
|
27 #include "tree-flow.h"
|
|
|
28 #include "value-prof.h"
|
|
|
29
|
|
|
30
|
|
|
31 /* Mark the statement STMT as modified, and update it. */
|
|
|
32
|
|
|
33 static inline void
|
|
|
34 update_modified_stmt (gimple stmt)
|
|
|
35 {
|
|
|
36 if (!ssa_operands_active ())
|
|
|
37 return;
|
|
|
38 update_stmt_if_modified (stmt);
|
|
|
39 }
|
|
|
40
|
|
|
41
|
|
|
42 /* Mark the statements in SEQ as modified, and update them. */
|
|
|
43
|
|
|
44 static void
|
|
|
45 update_modified_stmts (gimple_seq seq)
|
|
|
46 {
|
|
|
47 gimple_stmt_iterator gsi;
|
|
|
48
|
|
|
49 if (!ssa_operands_active ())
|
|
|
50 return;
|
|
|
51 for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
|
|
|
52 update_stmt_if_modified (gsi_stmt (gsi));
|
|
|
53 }
|
|
|
54
|
|
|
55
|
|
|
56 /* Set BB to be the basic block for all the statements in the list
|
|
|
57 starting at FIRST and LAST. */
|
|
|
58
|
|
|
59 static void
|
|
|
60 update_bb_for_stmts (gimple_seq_node first, basic_block bb)
|
|
|
61 {
|
|
|
62 gimple_seq_node n;
|
|
|
63
|
|
|
64 for (n = first; n; n = n->next)
|
|
|
65 gimple_set_bb (n->stmt, bb);
|
|
|
66 }
|
|
|
67
|
|
|
68
|
|
|
69 /* Insert the sequence delimited by nodes FIRST and LAST before
|
|
|
70 iterator I. M specifies how to update iterator I after insertion
|
|
|
71 (see enum gsi_iterator_update).
|
|
|
72
|
|
|
73 This routine assumes that there is a forward and backward path
|
|
|
74 between FIRST and LAST (i.e., they are linked in a doubly-linked
|
|
|
75 list). Additionally, if FIRST == LAST, this routine will properly
|
|
|
76 insert a single node. */
|
|
|
77
|
|
|
78 static void
|
|
|
79 gsi_insert_seq_nodes_before (gimple_stmt_iterator *i,
|
|
|
80 gimple_seq_node first,
|
|
|
81 gimple_seq_node last,
|
|
|
82 enum gsi_iterator_update mode)
|
|
|
83 {
|
|
|
84 basic_block bb;
|
|
|
85 gimple_seq_node cur = i->ptr;
|
|
|
86
|
|
|
87 if ((bb = gsi_bb (*i)) != NULL)
|
|
|
88 update_bb_for_stmts (first, bb);
|
|
|
89
|
|
|
90 /* Link SEQ before CUR in the sequence. */
|
|
|
91 if (cur)
|
|
|
92 {
|
|
|
93 first->prev = cur->prev;
|
|
|
94 if (first->prev)
|
|
|
95 first->prev->next = first;
|
|
|
96 else
|
|
|
97 gimple_seq_set_first (i->seq, first);
|
|
|
98 last->next = cur;
|
|
|
99 cur->prev = last;
|
|
|
100 }
|
|
|
101 else
|
|
|
102 {
|
|
|
103 gimple_seq_node itlast = gimple_seq_last (i->seq);
|
|
|
104
|
|
|
105 /* If CUR is NULL, we link at the end of the sequence (this case happens
|
|
|
106 when gsi_after_labels is called for a basic block that contains only
|
|
|
107 labels, so it returns an iterator after the end of the block, and
|
|
|
108 we need to insert before it; it might be cleaner to add a flag to the
|
|
|
109 iterator saying whether we are at the start or end of the list). */
|
|
|
110 first->prev = itlast;
|
|
|
111 if (itlast)
|
|
|
112 itlast->next = first;
|
|
|
113 else
|
|
|
114 gimple_seq_set_first (i->seq, first);
|
|
|
115 gimple_seq_set_last (i->seq, last);
|
|
|
116 }
|
|
|
117
|
|
|
118 /* Update the iterator, if requested. */
|
|
|
119 switch (mode)
|
|
|
120 {
|
|
|
121 case GSI_NEW_STMT:
|
|
|
122 case GSI_CONTINUE_LINKING:
|
|
|
123 i->ptr = first;
|
|
|
124 break;
|
|
|
125 case GSI_SAME_STMT:
|
|
|
126 break;
|
|
|
127 default:
|
|
|
128 gcc_unreachable ();
|
|
|
129 }
|
|
|
130 }
|
|
|
131
|
|
|
132
|
|
|
133 /* Inserts the sequence of statements SEQ before the statement pointed
|
|
|
134 by iterator I. MODE indicates what to do with the iterator after
|
|
|
135 insertion (see enum gsi_iterator_update).
|
|
|
136
|
|
|
137 This function does not scan for new operands. It is provided for
|
|
|
138 the use of the gimplifier, which manipulates statements for which
|
|
|
139 def/use information has not yet been constructed. Most callers
|
|
|
140 should use gsi_insert_seq_before. */
|
|
|
141
|
|
|
142 void
|
|
|
143 gsi_insert_seq_before_without_update (gimple_stmt_iterator *i, gimple_seq seq,
|
|
|
144 enum gsi_iterator_update mode)
|
|
|
145 {
|
|
|
146 gimple_seq_node first, last;
|
|
|
147
|
|
|
148 if (seq == NULL)
|
|
|
149 return;
|
|
|
150
|
|
|
151 /* Don't allow inserting a sequence into itself. */
|
|
|
152 gcc_assert (seq != i->seq);
|
|
|
153
|
|
|
154 first = gimple_seq_first (seq);
|
|
|
155 last = gimple_seq_last (seq);
|
|
|
156
|
|
|
157 gimple_seq_set_first (seq, NULL);
|
|
|
158 gimple_seq_set_last (seq, NULL);
|
|
|
159 gimple_seq_free (seq);
|
|
|
160
|
|
|
161 /* Empty sequences need no work. */
|
|
|
162 if (!first || !last)
|
|
|
163 {
|
|
|
164 gcc_assert (first == last);
|
|
|
165 return;
|
|
|
166 }
|
|
|
167
|
|
|
168 gsi_insert_seq_nodes_before (i, first, last, mode);
|
|
|
169 }
|
|
|
170
|
|
|
171
|
|
|
172 /* Inserts the sequence of statements SEQ before the statement pointed
|
|
|
173 by iterator I. MODE indicates what to do with the iterator after
|
|
|
174 insertion (see enum gsi_iterator_update). Scan the statements in SEQ
|
|
|
175 for new operands. */
|
|
|
176
|
|
|
177 void
|
|
|
178 gsi_insert_seq_before (gimple_stmt_iterator *i, gimple_seq seq,
|
|
|
179 enum gsi_iterator_update mode)
|
|
|
180 {
|
|
|
181 update_modified_stmts (seq);
|
|
|
182 gsi_insert_seq_before_without_update (i, seq, mode);
|
|
|
183 }
|
|
|
184
|
|
|
185
|
|
|
186 /* Insert the sequence delimited by nodes FIRST and LAST after
|
|
|
187 iterator I. M specifies how to update iterator I after insertion
|
|
|
188 (see enum gsi_iterator_update).
|
|
|
189
|
|
|
190 This routine assumes that there is a forward and backward path
|
|
|
191 between FIRST and LAST (i.e., they are linked in a doubly-linked
|
|
|
192 list). Additionally, if FIRST == LAST, this routine will properly
|
|
|
193 insert a single node. */
|
|
|
194
|
|
|
195 static void
|
|
|
196 gsi_insert_seq_nodes_after (gimple_stmt_iterator *i,
|
|
|
197 gimple_seq_node first,
|
|
|
198 gimple_seq_node last,
|
|
|
199 enum gsi_iterator_update m)
|
|
|
200 {
|
|
|
201 basic_block bb;
|
|
|
202 gimple_seq_node cur = i->ptr;
|
|
|
203
|
|
|
204 /* If the iterator is inside a basic block, we need to update the
|
|
|
205 basic block information for all the nodes between FIRST and LAST. */
|
|
|
206 if ((bb = gsi_bb (*i)) != NULL)
|
|
|
207 update_bb_for_stmts (first, bb);
|
|
|
208
|
|
|
209 /* Link SEQ after CUR. */
|
|
|
210 if (cur)
|
|
|
211 {
|
|
|
212 last->next = cur->next;
|
|
|
213 if (last->next)
|
|
|
214 last->next->prev = last;
|
|
|
215 else
|
|
|
216 gimple_seq_set_last (i->seq, last);
|
|
|
217 first->prev = cur;
|
|
|
218 cur->next = first;
|
|
|
219 }
|
|
|
220 else
|
|
|
221 {
|
|
|
222 gcc_assert (!gimple_seq_last (i->seq));
|
|
|
223 gimple_seq_set_first (i->seq, first);
|
|
|
224 gimple_seq_set_last (i->seq, last);
|
|
|
225 }
|
|
|
226
|
|
|
227 /* Update the iterator, if requested. */
|
|
|
228 switch (m)
|
|
|
229 {
|
|
|
230 case GSI_NEW_STMT:
|
|
|
231 i->ptr = first;
|
|
|
232 break;
|
|
|
233 case GSI_CONTINUE_LINKING:
|
|
|
234 i->ptr = last;
|
|
|
235 break;
|
|
|
236 case GSI_SAME_STMT:
|
|
|
237 gcc_assert (cur);
|
|
|
238 break;
|
|
|
239 default:
|
|
|
240 gcc_unreachable ();
|
|
|
241 }
|
|
|
242 }
|
|
|
243
|
|
|
244
|
|
|
245 /* Links sequence SEQ after the statement pointed-to by iterator I.
|
|
|
246 MODE is as in gsi_insert_after.
|
|
|
247
|
|
|
248 This function does not scan for new operands. It is provided for
|
|
|
249 the use of the gimplifier, which manipulates statements for which
|
|
|
250 def/use information has not yet been constructed. Most callers
|
|
|
251 should use gsi_insert_seq_after. */
|
|
|
252
|
|
|
253 void
|
|
|
254 gsi_insert_seq_after_without_update (gimple_stmt_iterator *i, gimple_seq seq,
|
|
|
255 enum gsi_iterator_update mode)
|
|
|
256 {
|
|
|
257 gimple_seq_node first, last;
|
|
|
258
|
|
|
259 if (seq == NULL)
|
|
|
260 return;
|
|
|
261
|
|
|
262 /* Don't allow inserting a sequence into itself. */
|
|
|
263 gcc_assert (seq != i->seq);
|
|
|
264
|
|
|
265 first = gimple_seq_first (seq);
|
|
|
266 last = gimple_seq_last (seq);
|
|
|
267
|
|
|
268 gimple_seq_set_first (seq, NULL);
|
|
|
269 gimple_seq_set_last (seq, NULL);
|
|
|
270 gimple_seq_free (seq);
|
|
|
271
|
|
|
272 /* Empty sequences need no work. */
|
|
|
273 if (!first || !last)
|
|
|
274 {
|
|
|
275 gcc_assert (first == last);
|
|
|
276 return;
|
|
|
277 }
|
|
|
278
|
|
|
279 gsi_insert_seq_nodes_after (i, first, last, mode);
|
|
|
280 }
|
|
|
281
|
|
|
282
|
|
|
283 /* Links sequence SEQ after the statement pointed-to by iterator I.
|
|
|
284 MODE is as in gsi_insert_after. Scan the statements in SEQ
|
|
|
285 for new operands. */
|
|
|
286
|
|
|
287 void
|
|
|
288 gsi_insert_seq_after (gimple_stmt_iterator *i, gimple_seq seq,
|
|
|
289 enum gsi_iterator_update mode)
|
|
|
290 {
|
|
|
291 update_modified_stmts (seq);
|
|
|
292 gsi_insert_seq_after_without_update (i, seq, mode);
|
|
|
293 }
|
|
|
294
|
|
|
295
|
|
|
296 /* Move all statements in the sequence after I to a new sequence.
|
|
|
297 Return this new sequence. */
|
|
|
298
|
|
|
299 gimple_seq
|
|
|
300 gsi_split_seq_after (gimple_stmt_iterator i)
|
|
|
301 {
|
|
|
302 gimple_seq_node cur, next;
|
|
|
303 gimple_seq old_seq, new_seq;
|
|
|
304
|
|
|
305 cur = i.ptr;
|
|
|
306
|
|
|
307 /* How can we possibly split after the end, or before the beginning? */
|
|
|
308 gcc_assert (cur && cur->next);
|
|
|
309 next = cur->next;
|
|
|
310
|
|
|
311 old_seq = i.seq;
|
|
|
312 new_seq = gimple_seq_alloc ();
|
|
|
313
|
|
|
314 gimple_seq_set_first (new_seq, next);
|
|
|
315 gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
|
|
|
316 gimple_seq_set_last (old_seq, cur);
|
|
|
317 cur->next = NULL;
|
|
|
318 next->prev = NULL;
|
|
|
319
|
|
|
320 return new_seq;
|
|
|
321 }
|
|
|
322
|
|
|
323
|
|
|
324 /* Move all statements in the sequence before I to a new sequence.
|
|
|
325 Return this new sequence. I is set to the head of the new list. */
|
|
|
326
|
|
|
327 gimple_seq
|
|
|
328 gsi_split_seq_before (gimple_stmt_iterator *i)
|
|
|
329 {
|
|
|
330 gimple_seq_node cur, prev;
|
|
|
331 gimple_seq old_seq, new_seq;
|
|
|
332
|
|
|
333 cur = i->ptr;
|
|
|
334
|
|
|
335 /* How can we possibly split after the end? */
|
|
|
336 gcc_assert (cur);
|
|
|
337 prev = cur->prev;
|
|
|
338
|
|
|
339 old_seq = i->seq;
|
|
|
340 new_seq = gimple_seq_alloc ();
|
|
|
341 i->seq = new_seq;
|
|
|
342
|
|
|
343 /* Set the limits on NEW_SEQ. */
|
|
|
344 gimple_seq_set_first (new_seq, cur);
|
|
|
345 gimple_seq_set_last (new_seq, gimple_seq_last (old_seq));
|
|
|
346
|
|
|
347 /* Cut OLD_SEQ before I. */
|
|
|
348 gimple_seq_set_last (old_seq, prev);
|
|
|
349 cur->prev = NULL;
|
|
|
350 if (prev)
|
|
|
351 prev->next = NULL;
|
|
|
352 else
|
|
|
353 gimple_seq_set_first (old_seq, NULL);
|
|
|
354
|
|
|
355 return new_seq;
|
|
|
356 }
|
|
|
357
|
|
|
358
|
|
|
359 /* Replace the statement pointed-to by GSI to STMT. If UPDATE_EH_INFO
|
|
|
360 is true, the exception handling information of the original
|
|
|
361 statement is moved to the new statement. */
|
|
|
362
|
|
|
363 void
|
|
|
364 gsi_replace (gimple_stmt_iterator *gsi, gimple stmt, bool update_eh_info)
|
|
|
365 {
|
|
|
366 int eh_region;
|
|
|
367 gimple orig_stmt = gsi_stmt (*gsi);
|
|
|
368
|
|
|
369 if (stmt == orig_stmt)
|
|
|
370 return;
|
|
|
371
|
|
|
372 gimple_set_location (stmt, gimple_location (orig_stmt));
|
|
|
373 gimple_set_bb (stmt, gsi_bb (*gsi));
|
|
|
374
|
|
|
375 /* Preserve EH region information from the original statement, if
|
|
|
376 requested by the caller. */
|
|
|
377 if (update_eh_info)
|
|
|
378 {
|
|
|
379 eh_region = lookup_stmt_eh_region (orig_stmt);
|
|
|
380 if (eh_region >= 0)
|
|
|
381 {
|
|
|
382 remove_stmt_from_eh_region (orig_stmt);
|
|
|
383 add_stmt_to_eh_region (stmt, eh_region);
|
|
|
384 }
|
|
|
385 }
|
|
|
386
|
|
|
387 gimple_duplicate_stmt_histograms (cfun, stmt, cfun, orig_stmt);
|
|
|
388 gimple_remove_stmt_histograms (cfun, orig_stmt);
|
|
|
389 delink_stmt_imm_use (orig_stmt);
|
|
|
390 *gsi_stmt_ptr (gsi) = stmt;
|
|
|
391 gimple_set_modified (stmt, true);
|
|
|
392 update_modified_stmt (stmt);
|
|
|
393 }
|
|
|
394
|
|
|
395
|
|
|
396 /* Insert statement STMT before the statement pointed-to by iterator I.
|
|
|
397 M specifies how to update iterator I after insertion (see enum
|
|
|
398 gsi_iterator_update).
|
|
|
399
|
|
|
400 This function does not scan for new operands. It is provided for
|
|
|
401 the use of the gimplifier, which manipulates statements for which
|
|
|
402 def/use information has not yet been constructed. Most callers
|
|
|
403 should use gsi_insert_before. */
|
|
|
404
|
|
|
405 void
|
|
|
406 gsi_insert_before_without_update (gimple_stmt_iterator *i, gimple stmt,
|
|
|
407 enum gsi_iterator_update m)
|
|
|
408 {
|
|
|
409 gimple_seq_node n;
|
|
|
410
|
|
|
411 n = GGC_NEW (struct gimple_seq_node_d);
|
|
|
412 n->prev = n->next = NULL;
|
|
|
413 n->stmt = stmt;
|
|
|
414 gsi_insert_seq_nodes_before (i, n, n, m);
|
|
|
415 }
|
|
|
416
|
|
|
417 /* Insert statement STMT before the statement pointed-to by iterator I.
|
|
|
418 Update STMT's basic block and scan it for new operands. M
|
|
|
419 specifies how to update iterator I after insertion (see enum
|
|
|
420 gsi_iterator_update). */
|
|
|
421
|
|
|
422 void
|
|
|
423 gsi_insert_before (gimple_stmt_iterator *i, gimple stmt,
|
|
|
424 enum gsi_iterator_update m)
|
|
|
425 {
|
|
|
426 update_modified_stmt (stmt);
|
|
|
427 gsi_insert_before_without_update (i, stmt, m);
|
|
|
428 }
|
|
|
429
|
|
|
430
|
|
|
431 /* Insert statement STMT after the statement pointed-to by iterator I.
|
|
|
432 M specifies how to update iterator I after insertion (see enum
|
|
|
433 gsi_iterator_update).
|
|
|
434
|
|
|
435 This function does not scan for new operands. It is provided for
|
|
|
436 the use of the gimplifier, which manipulates statements for which
|
|
|
437 def/use information has not yet been constructed. Most callers
|
|
|
438 should use gsi_insert_after. */
|
|
|
439
|
|
|
440 void
|
|
|
441 gsi_insert_after_without_update (gimple_stmt_iterator *i, gimple stmt,
|
|
|
442 enum gsi_iterator_update m)
|
|
|
443 {
|
|
|
444 gimple_seq_node n;
|
|
|
445
|
|
|
446 n = GGC_NEW (struct gimple_seq_node_d);
|
|
|
447 n->prev = n->next = NULL;
|
|
|
448 n->stmt = stmt;
|
|
|
449 gsi_insert_seq_nodes_after (i, n, n, m);
|
|
|
450 }
|
|
|
451
|
|
|
452
|
|
|
453 /* Insert statement STMT after the statement pointed-to by iterator I.
|
|
|
454 Update STMT's basic block and scan it for new operands. M
|
|
|
455 specifies how to update iterator I after insertion (see enum
|
|
|
456 gsi_iterator_update). */
|
|
|
457
|
|
|
458 void
|
|
|
459 gsi_insert_after (gimple_stmt_iterator *i, gimple stmt,
|
|
|
460 enum gsi_iterator_update m)
|
|
|
461 {
|
|
|
462 update_modified_stmt (stmt);
|
|
|
463 gsi_insert_after_without_update (i, stmt, m);
|
|
|
464 }
|
|
|
465
|
|
|
466
|
|
|
467 /* Remove the current stmt from the sequence. The iterator is updated
|
|
|
468 to point to the next statement.
|
|
|
469
|
|
|
470 REMOVE_PERMANENTLY is true when the statement is going to be removed
|
|
|
471 from the IL and not reinserted elsewhere. In that case we remove the
|
|
|
472 statement pointed to by iterator I from the EH tables, and free its
|
|
|
473 operand caches. Otherwise we do not modify this information. */
|
|
|
474
|
|
|
475 void
|
|
|
476 gsi_remove (gimple_stmt_iterator *i, bool remove_permanently)
|
|
|
477 {
|
|
|
478 gimple_seq_node cur, next, prev;
|
|
|
479 gimple stmt = gsi_stmt (*i);
|
|
|
480
|
|
|
481 /* Free all the data flow information for STMT. */
|
|
|
482 gimple_set_bb (stmt, NULL);
|
|
|
483 delink_stmt_imm_use (stmt);
|
|
|
484 gimple_set_modified (stmt, true);
|
|
|
485
|
|
|
486 if (remove_permanently)
|
|
|
487 {
|
|
|
488 remove_stmt_from_eh_region (stmt);
|
|
|
489 gimple_remove_stmt_histograms (cfun, stmt);
|
|
|
490 }
|
|
|
491
|
|
|
492 /* Update the iterator and re-wire the links in I->SEQ. */
|
|
|
493 cur = i->ptr;
|
|
|
494 next = cur->next;
|
|
|
495 prev = cur->prev;
|
|
|
496
|
|
|
497 if (prev)
|
|
|
498 prev->next = next;
|
|
|
499 else
|
|
|
500 gimple_seq_set_first (i->seq, next);
|
|
|
501
|
|
|
502 if (next)
|
|
|
503 next->prev = prev;
|
|
|
504 else
|
|
|
505 gimple_seq_set_last (i->seq, prev);
|
|
|
506
|
|
|
507 i->ptr = next;
|
|
|
508 }
|
|
|
509
|
|
|
510
|
|
|
511 /* Finds iterator for STMT. */
|
|
|
512
|
|
|
513 gimple_stmt_iterator
|
|
|
514 gsi_for_stmt (gimple stmt)
|
|
|
515 {
|
|
|
516 gimple_stmt_iterator i;
|
|
|
517 basic_block bb = gimple_bb (stmt);
|
|
|
518
|
|
|
519 if (gimple_code (stmt) == GIMPLE_PHI)
|
|
|
520 i = gsi_start_phis (bb);
|
|
|
521 else
|
|
|
522 i = gsi_start_bb (bb);
|
|
|
523
|
|
|
524 for (; !gsi_end_p (i); gsi_next (&i))
|
|
|
525 if (gsi_stmt (i) == stmt)
|
|
|
526 return i;
|
|
|
527
|
|
|
528 gcc_unreachable ();
|
|
|
529 }
|
|
|
530
|
|
|
531
|
|
|
532 /* Move the statement at FROM so it comes right after the statement at TO. */
|
|
|
533
|
|
|
534 void
|
|
|
535 gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
|
|
|
536 {
|
|
|
537 gimple stmt = gsi_stmt (*from);
|
|
|
538 gsi_remove (from, false);
|
|
|
539
|
|
|
540 /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to
|
|
|
541 move statements to an empty block. */
|
|
|
542 gsi_insert_after (to, stmt, GSI_NEW_STMT);
|
|
|
543 }
|
|
|
544
|
|
|
545
|
|
|
546 /* Move the statement at FROM so it comes right before the statement
|
|
|
547 at TO. */
|
|
|
548
|
|
|
549 void
|
|
|
550 gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
|
|
|
551 {
|
|
|
552 gimple stmt = gsi_stmt (*from);
|
|
|
553 gsi_remove (from, false);
|
|
|
554
|
|
|
555 /* For consistency with gsi_move_after, it might be better to have
|
|
|
556 GSI_NEW_STMT here; however, that breaks several places that expect
|
|
|
557 that TO does not change. */
|
|
|
558 gsi_insert_before (to, stmt, GSI_SAME_STMT);
|
|
|
559 }
|
|
|
560
|
|
|
561
|
|
|
562 /* Move the statement at FROM to the end of basic block BB. */
|
|
|
563
|
|
|
564 void
|
|
|
565 gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
|
|
|
566 {
|
|
|
567 gimple_stmt_iterator last = gsi_last_bb (bb);
|
|
|
568 #ifdef ENABLE_CHECKING
|
|
|
569 gcc_assert (gsi_bb (last) == bb);
|
|
|
570 #endif
|
|
|
571
|
|
|
572 /* Have to check gsi_end_p because it could be an empty block. */
|
|
|
573 if (!gsi_end_p (last) && is_ctrl_stmt (gsi_stmt (last)))
|
|
|
574 gsi_move_before (from, &last);
|
|
|
575 else
|
|
|
576 gsi_move_after (from, &last);
|
|
|
577 }
|
|
|
578
|
|
|
579
|
|
|
580 /* Add STMT to the pending list of edge E. No actual insertion is
|
|
|
581 made until a call to gsi_commit_edge_inserts () is made. */
|
|
|
582
|
|
|
583 void
|
|
|
584 gsi_insert_on_edge (edge e, gimple stmt)
|
|
|
585 {
|
|
|
586 gimple_seq_add_stmt (&PENDING_STMT (e), stmt);
|
|
|
587 }
|
|
|
588
|
|
|
589 /* Add the sequence of statements SEQ to the pending list of edge E.
|
|
|
590 No actual insertion is made until a call to gsi_commit_edge_inserts
|
|
|
591 is made. */
|
|
|
592
|
|
|
593 void
|
|
|
594 gsi_insert_seq_on_edge (edge e, gimple_seq seq)
|
|
|
595 {
|
|
|
596 gimple_seq_add_seq (&PENDING_STMT (e), seq);
|
|
|
597 }
|
|
|
598
|
|
|
599
|
|
|
600 /* Insert the statement pointed-to by GSI into edge E. Every attempt
|
|
|
601 is made to place the statement in an existing basic block, but
|
|
|
602 sometimes that isn't possible. When it isn't possible, the edge is
|
|
|
603 split and the statement is added to the new block.
|
|
|
604
|
|
|
605 In all cases, the returned *GSI points to the correct location. The
|
|
|
606 return value is true if insertion should be done after the location,
|
|
|
607 or false if it should be done before the location. If new basic block
|
|
|
608 has to be created, it is stored in *NEW_BB. */
|
|
|
609
|
|
|
610 static bool
|
|
|
611 gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
|
|
|
612 basic_block *new_bb)
|
|
|
613 {
|
|
|
614 basic_block dest, src;
|
|
|
615 gimple tmp;
|
|
|
616
|
|
|
617 dest = e->dest;
|
|
|
618
|
|
|
619 /* If the destination has one predecessor which has no PHI nodes,
|
|
|
620 insert there. Except for the exit block.
|
|
|
621
|
|
|
622 The requirement for no PHI nodes could be relaxed. Basically we
|
|
|
623 would have to examine the PHIs to prove that none of them used
|
|
|
624 the value set by the statement we want to insert on E. That
|
|
|
625 hardly seems worth the effort. */
|
|
|
626 restart:
|
|
|
627 if (single_pred_p (dest)
|
|
|
628 && ! phi_nodes (dest)
|
|
|
629 && dest != EXIT_BLOCK_PTR)
|
|
|
630 {
|
|
|
631 *gsi = gsi_start_bb (dest);
|
|
|
632 if (gsi_end_p (*gsi))
|
|
|
633 return true;
|
|
|
634
|
|
|
635 /* Make sure we insert after any leading labels. */
|
|
|
636 tmp = gsi_stmt (*gsi);
|
|
|
637 while (gimple_code (tmp) == GIMPLE_LABEL)
|
|
|
638 {
|
|
|
639 gsi_next (gsi);
|
|
|
640 if (gsi_end_p (*gsi))
|
|
|
641 break;
|
|
|
642 tmp = gsi_stmt (*gsi);
|
|
|
643 }
|
|
|
644
|
|
|
645 if (gsi_end_p (*gsi))
|
|
|
646 {
|
|
|
647 *gsi = gsi_last_bb (dest);
|
|
|
648 return true;
|
|
|
649 }
|
|
|
650 else
|
|
|
651 return false;
|
|
|
652 }
|
|
|
653
|
|
|
654 /* If the source has one successor, the edge is not abnormal and
|
|
|
655 the last statement does not end a basic block, insert there.
|
|
|
656 Except for the entry block. */
|
|
|
657 src = e->src;
|
|
|
658 if ((e->flags & EDGE_ABNORMAL) == 0
|
|
|
659 && single_succ_p (src)
|
|
|
660 && src != ENTRY_BLOCK_PTR)
|
|
|
661 {
|
|
|
662 *gsi = gsi_last_bb (src);
|
|
|
663 if (gsi_end_p (*gsi))
|
|
|
664 return true;
|
|
|
665
|
|
|
666 tmp = gsi_stmt (*gsi);
|
|
|
667 if (!stmt_ends_bb_p (tmp))
|
|
|
668 return true;
|
|
|
669
|
|
|
670 if (gimple_code (tmp) == GIMPLE_RETURN)
|
|
|
671 {
|
|
|
672 gsi_prev (gsi);
|
|
|
673 return true;
|
|
|
674 }
|
|
|
675 }
|
|
|
676
|
|
|
677 /* Otherwise, create a new basic block, and split this edge. */
|
|
|
678 dest = split_edge (e);
|
|
|
679 if (new_bb)
|
|
|
680 *new_bb = dest;
|
|
|
681 e = single_pred_edge (dest);
|
|
|
682 goto restart;
|
|
|
683 }
|
|
|
684
|
|
|
685
|
|
|
686 /* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts. If a new
|
|
|
687 block has to be created, it is returned. */
|
|
|
688
|
|
|
689 basic_block
|
|
|
690 gsi_insert_on_edge_immediate (edge e, gimple stmt)
|
|
|
691 {
|
|
|
692 gimple_stmt_iterator gsi;
|
|
|
693 basic_block new_bb = NULL;
|
|
|
694
|
|
|
695 gcc_assert (!PENDING_STMT (e));
|
|
|
696
|
|
|
697 if (gimple_find_edge_insert_loc (e, &gsi, &new_bb))
|
|
|
698 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
|
|
|
699 else
|
|
|
700 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
|
|
|
701
|
|
|
702 return new_bb;
|
|
|
703 }
|
|
|
704
|
|
|
705 /* Insert STMTS on edge E. If a new block has to be created, it
|
|
|
706 is returned. */
|
|
|
707
|
|
|
708 basic_block
|
|
|
709 gsi_insert_seq_on_edge_immediate (edge e, gimple_seq stmts)
|
|
|
710 {
|
|
|
711 gimple_stmt_iterator gsi;
|
|
|
712 basic_block new_bb = NULL;
|
|
|
713
|
|
|
714 gcc_assert (!PENDING_STMT (e));
|
|
|
715
|
|
|
716 if (gimple_find_edge_insert_loc (e, &gsi, &new_bb))
|
|
|
717 gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
|
|
|
718 else
|
|
|
719 gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT);
|
|
|
720
|
|
|
721 return new_bb;
|
|
|
722 }
|
|
|
723
|
|
|
724 /* This routine will commit all pending edge insertions, creating any new
|
|
|
725 basic blocks which are necessary. */
|
|
|
726
|
|
|
727 void
|
|
|
728 gsi_commit_edge_inserts (void)
|
|
|
729 {
|
|
|
730 basic_block bb;
|
|
|
731 edge e;
|
|
|
732 edge_iterator ei;
|
|
|
733
|
|
|
734 gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL);
|
|
|
735
|
|
|
736 FOR_EACH_BB (bb)
|
|
|
737 FOR_EACH_EDGE (e, ei, bb->succs)
|
|
|
738 gsi_commit_one_edge_insert (e, NULL);
|
|
|
739 }
|
|
|
740
|
|
|
741
|
|
|
742 /* Commit insertions pending at edge E. If a new block is created, set NEW_BB
|
|
|
743 to this block, otherwise set it to NULL. */
|
|
|
744
|
|
|
745 void
|
|
|
746 gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
|
|
|
747 {
|
|
|
748 if (new_bb)
|
|
|
749 *new_bb = NULL;
|
|
|
750
|
|
|
751 if (PENDING_STMT (e))
|
|
|
752 {
|
|
|
753 gimple_stmt_iterator gsi;
|
|
|
754 gimple_seq seq = PENDING_STMT (e);
|
|
|
755
|
|
|
756 PENDING_STMT (e) = NULL;
|
|
|
757
|
|
|
758 if (gimple_find_edge_insert_loc (e, &gsi, new_bb))
|
|
|
759 gsi_insert_seq_after (&gsi, seq, GSI_NEW_STMT);
|
|
|
760 else
|
|
|
761 gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT);
|
|
|
762 }
|
|
|
763 }
|
|
|
764
|
|
|
765 /* Returns iterator at the start of the list of phi nodes of BB. */
|
|
|
766
|
|
|
767 gimple_stmt_iterator
|
|
|
768 gsi_start_phis (basic_block bb)
|
|
|
769 {
|
|
|
770 return gsi_start (phi_nodes (bb));
|
|
|
771 }
|
