1 /* Iterator routines for GIMPLE statements.
2 Copyright (C) 2007-2021 Free Software Foundation, Inc.
3 Contributed by Aldy Hernandez <aldy@quesejoda.com>
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
31 #include "gimple-iterator.h"
34 #include "value-prof.h"
37 /* Mark the statement STMT as modified, and update it. */
40 update_modified_stmt (gimple
*stmt
)
42 if (!ssa_operands_active (cfun
))
44 update_stmt_if_modified (stmt
);
48 /* Mark the statements in SEQ as modified, and update them. */
51 update_modified_stmts (gimple_seq seq
)
53 gimple_stmt_iterator gsi
;
55 if (!ssa_operands_active (cfun
))
57 for (gsi
= gsi_start (seq
); !gsi_end_p (gsi
); gsi_next (&gsi
))
58 update_stmt_if_modified (gsi_stmt (gsi
));
62 /* Set BB to be the basic block for all the statements in the list
63 starting at FIRST and LAST. */
66 update_bb_for_stmts (gimple_seq_node first
, gimple_seq_node last
,
71 for (n
= first
; n
; n
= n
->next
)
73 gimple_set_bb (n
, bb
);
79 /* Set the frequencies for the cgraph_edges for each of the calls
80 starting at FIRST for their new position within BB. */
83 update_call_edge_frequencies (gimple_seq_node first
, basic_block bb
)
85 struct cgraph_node
*cfun_node
= NULL
;
88 for (n
= first
; n
; n
= n
->next
)
89 if (is_gimple_call (n
))
91 struct cgraph_edge
*e
;
93 /* These function calls are expensive enough that we want
94 to avoid calling them if we never see any calls. */
95 if (cfun_node
== NULL
)
96 cfun_node
= cgraph_node::get (current_function_decl
);
98 e
= cfun_node
->get_edge (n
);
100 e
->count
= bb
->count
;
104 /* Insert the sequence delimited by nodes FIRST and LAST before
105 iterator I. M specifies how to update iterator I after insertion
106 (see enum gsi_iterator_update).
108 This routine assumes that there is a forward and backward path
109 between FIRST and LAST (i.e., they are linked in a doubly-linked
110 list). Additionally, if FIRST == LAST, this routine will properly
111 insert a single node. */
114 gsi_insert_seq_nodes_before (gimple_stmt_iterator
*i
,
115 gimple_seq_node first
,
116 gimple_seq_node last
,
117 enum gsi_iterator_update mode
)
120 gimple_seq_node cur
= i
->ptr
;
122 gcc_assert (!cur
|| cur
->prev
);
124 if ((bb
= gsi_bb (*i
)) != NULL
)
125 update_bb_for_stmts (first
, last
, bb
);
127 /* Link SEQ before CUR in the sequence. */
130 first
->prev
= cur
->prev
;
131 if (first
->prev
->next
)
132 first
->prev
->next
= first
;
134 gimple_seq_set_first (i
->seq
, first
);
140 gimple_seq_node itlast
= gimple_seq_last (*i
->seq
);
142 /* If CUR is NULL, we link at the end of the sequence (this case happens
143 when gsi_after_labels is called for a basic block that contains only
144 labels, so it returns an iterator after the end of the block, and
145 we need to insert before it; it might be cleaner to add a flag to the
146 iterator saying whether we are at the start or end of the list). */
150 first
->prev
= itlast
;
151 itlast
->next
= first
;
154 gimple_seq_set_first (i
->seq
, first
);
155 gimple_seq_set_last (i
->seq
, last
);
158 /* Update the iterator, if requested. */
162 case GSI_CONTINUE_LINKING
:
173 /* Inserts the sequence of statements SEQ before the statement pointed
174 by iterator I. MODE indicates what to do with the iterator after
175 insertion (see enum gsi_iterator_update).
177 This function does not scan for new operands. It is provided for
178 the use of the gimplifier, which manipulates statements for which
179 def/use information has not yet been constructed. Most callers
180 should use gsi_insert_seq_before. */
183 gsi_insert_seq_before_without_update (gimple_stmt_iterator
*i
, gimple_seq seq
,
184 enum gsi_iterator_update mode
)
186 gimple_seq_node first
, last
;
191 /* Don't allow inserting a sequence into itself. */
192 gcc_assert (seq
!= *i
->seq
);
194 first
= gimple_seq_first (seq
);
195 last
= gimple_seq_last (seq
);
197 /* Empty sequences need no work. */
200 gcc_assert (first
== last
);
204 gsi_insert_seq_nodes_before (i
, first
, last
, mode
);
208 /* Inserts the sequence of statements SEQ before the statement pointed
209 by iterator I. MODE indicates what to do with the iterator after
210 insertion (see enum gsi_iterator_update). Scan the statements in SEQ
214 gsi_insert_seq_before (gimple_stmt_iterator
*i
, gimple_seq seq
,
215 enum gsi_iterator_update mode
)
217 update_modified_stmts (seq
);
218 gsi_insert_seq_before_without_update (i
, seq
, mode
);
222 /* Insert the sequence delimited by nodes FIRST and LAST after
223 iterator I. M specifies how to update iterator I after insertion
224 (see enum gsi_iterator_update).
226 This routine assumes that there is a forward and backward path
227 between FIRST and LAST (i.e., they are linked in a doubly-linked
228 list). Additionally, if FIRST == LAST, this routine will properly
229 insert a single node. */
232 gsi_insert_seq_nodes_after (gimple_stmt_iterator
*i
,
233 gimple_seq_node first
,
234 gimple_seq_node last
,
235 enum gsi_iterator_update m
)
238 gimple_seq_node cur
= i
->ptr
;
240 gcc_assert (!cur
|| cur
->prev
);
242 /* If the iterator is inside a basic block, we need to update the
243 basic block information for all the nodes between FIRST and LAST. */
244 if ((bb
= gsi_bb (*i
)) != NULL
)
245 update_bb_for_stmts (first
, last
, bb
);
247 /* Link SEQ after CUR. */
250 last
->next
= cur
->next
;
253 last
->next
->prev
= last
;
256 gimple_seq_set_last (i
->seq
, last
);
262 gcc_assert (!gimple_seq_last (*i
->seq
));
264 gimple_seq_set_first (i
->seq
, first
);
265 gimple_seq_set_last (i
->seq
, last
);
268 /* Update the iterator, if requested. */
274 case GSI_CONTINUE_LINKING
:
286 /* Links sequence SEQ after the statement pointed-to by iterator I.
287 MODE is as in gsi_insert_after.
289 This function does not scan for new operands. It is provided for
290 the use of the gimplifier, which manipulates statements for which
291 def/use information has not yet been constructed. Most callers
292 should use gsi_insert_seq_after. */
295 gsi_insert_seq_after_without_update (gimple_stmt_iterator
*i
, gimple_seq seq
,
296 enum gsi_iterator_update mode
)
298 gimple_seq_node first
, last
;
303 /* Don't allow inserting a sequence into itself. */
304 gcc_assert (seq
!= *i
->seq
);
306 first
= gimple_seq_first (seq
);
307 last
= gimple_seq_last (seq
);
309 /* Empty sequences need no work. */
312 gcc_assert (first
== last
);
316 gsi_insert_seq_nodes_after (i
, first
, last
, mode
);
320 /* Links sequence SEQ after the statement pointed-to by iterator I.
321 MODE is as in gsi_insert_after. Scan the statements in SEQ
325 gsi_insert_seq_after (gimple_stmt_iterator
*i
, gimple_seq seq
,
326 enum gsi_iterator_update mode
)
328 update_modified_stmts (seq
);
329 gsi_insert_seq_after_without_update (i
, seq
, mode
);
333 /* Move all statements in the sequence after I to a new sequence.
334 Return this new sequence. */
337 gsi_split_seq_after (gimple_stmt_iterator i
)
339 gimple_seq_node cur
, next
;
340 gimple_seq
*pold_seq
, new_seq
;
344 /* How can we possibly split after the end, or before the beginning? */
345 gcc_assert (cur
&& cur
->next
);
350 gimple_seq_set_first (&new_seq
, next
);
351 gimple_seq_set_last (&new_seq
, gimple_seq_last (*pold_seq
));
352 gimple_seq_set_last (pold_seq
, cur
);
359 /* Set the statement to which GSI points to STMT. This only updates
360 the iterator and the gimple sequence, it doesn't do the bookkeeping
364 gsi_set_stmt (gimple_stmt_iterator
*gsi
, gimple
*stmt
)
366 gimple
*orig_stmt
= gsi_stmt (*gsi
);
369 stmt
->next
= next
= orig_stmt
->next
;
370 stmt
->prev
= prev
= orig_stmt
->prev
;
371 /* Note how we don't clear next/prev of orig_stmt. This is so that
372 copies of *GSI our callers might still hold (to orig_stmt)
373 can be advanced as if they too were replaced. */
377 gimple_seq_set_first (gsi
->seq
, stmt
);
381 gimple_seq_set_last (gsi
->seq
, stmt
);
387 /* Move all statements in the sequence before I to a new sequence.
388 Return this new sequence. I is set to the head of the new list. */
391 gsi_split_seq_before (gimple_stmt_iterator
*i
, gimple_seq
*pnew_seq
)
393 gimple_seq_node cur
, prev
;
398 /* How can we possibly split after the end? */
407 /* Set the limits on NEW_SEQ. */
408 gimple_seq_set_first (pnew_seq
, cur
);
409 gimple_seq_set_last (pnew_seq
, gimple_seq_last (old_seq
));
411 /* Cut OLD_SEQ before I. */
412 gimple_seq_set_last (&old_seq
, prev
);
418 /* Replace the statement pointed-to by GSI to STMT. If UPDATE_EH_INFO
419 is true, the exception handling information of the original
420 statement is moved to the new statement. Assignments must only be
421 replaced with assignments to the same LHS. Returns whether EH edge
422 cleanup is required. */
425 gsi_replace (gimple_stmt_iterator
*gsi
, gimple
*stmt
, bool update_eh_info
)
427 gimple
*orig_stmt
= gsi_stmt (*gsi
);
428 bool require_eh_edge_purge
= false;
430 if (stmt
== orig_stmt
)
433 gcc_assert (!gimple_has_lhs (orig_stmt
) || !gimple_has_lhs (stmt
)
434 || gimple_get_lhs (orig_stmt
) == gimple_get_lhs (stmt
));
436 gimple_set_location (stmt
, gimple_location (orig_stmt
));
437 gimple_set_bb (stmt
, gsi_bb (*gsi
));
439 /* Preserve EH region information from the original statement, if
440 requested by the caller. */
442 require_eh_edge_purge
= maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
);
444 gimple_duplicate_stmt_histograms (cfun
, stmt
, cfun
, orig_stmt
);
446 /* Free all the data flow information for ORIG_STMT. */
447 gimple_set_bb (orig_stmt
, NULL
);
448 gimple_remove_stmt_histograms (cfun
, orig_stmt
);
449 delink_stmt_imm_use (orig_stmt
);
451 gsi_set_stmt (gsi
, stmt
);
452 gimple_set_modified (stmt
, true);
453 update_modified_stmt (stmt
);
454 return require_eh_edge_purge
;
458 /* Replace the statement pointed-to by GSI with the sequence SEQ.
459 If UPDATE_EH_INFO is true, the exception handling information of
460 the original statement is moved to the last statement of the new
461 sequence. If the old statement is an assignment, then so must
462 be the last statement of the new sequence, and they must have the
466 gsi_replace_with_seq (gimple_stmt_iterator
*gsi
, gimple_seq seq
,
469 gimple_stmt_iterator seqi
;
471 if (gimple_seq_empty_p (seq
))
473 gsi_remove (gsi
, true);
476 seqi
= gsi_last (seq
);
477 last
= gsi_stmt (seqi
);
478 gsi_remove (&seqi
, false);
479 gsi_insert_seq_before (gsi
, seq
, GSI_SAME_STMT
);
480 gsi_replace (gsi
, last
, update_eh_info
);
484 /* Insert statement STMT before the statement pointed-to by iterator I.
485 M specifies how to update iterator I after insertion (see enum
486 gsi_iterator_update).
488 This function does not scan for new operands. It is provided for
489 the use of the gimplifier, which manipulates statements for which
490 def/use information has not yet been constructed. Most callers
491 should use gsi_insert_before. */
494 gsi_insert_before_without_update (gimple_stmt_iterator
*i
, gimple
*stmt
,
495 enum gsi_iterator_update m
)
497 gsi_insert_seq_nodes_before (i
, stmt
, stmt
, m
);
500 /* Insert statement STMT before the statement pointed-to by iterator I.
501 Update STMT's basic block and scan it for new operands. M
502 specifies how to update iterator I after insertion (see enum
503 gsi_iterator_update). */
506 gsi_insert_before (gimple_stmt_iterator
*i
, gimple
*stmt
,
507 enum gsi_iterator_update m
)
509 update_modified_stmt (stmt
);
510 gsi_insert_before_without_update (i
, stmt
, m
);
514 /* Insert statement STMT after the statement pointed-to by iterator I.
515 M specifies how to update iterator I after insertion (see enum
516 gsi_iterator_update).
518 This function does not scan for new operands. It is provided for
519 the use of the gimplifier, which manipulates statements for which
520 def/use information has not yet been constructed. Most callers
521 should use gsi_insert_after. */
524 gsi_insert_after_without_update (gimple_stmt_iterator
*i
, gimple
*stmt
,
525 enum gsi_iterator_update m
)
527 gsi_insert_seq_nodes_after (i
, stmt
, stmt
, m
);
531 /* Insert statement STMT after the statement pointed-to by iterator I.
532 Update STMT's basic block and scan it for new operands. M
533 specifies how to update iterator I after insertion (see enum
534 gsi_iterator_update). */
537 gsi_insert_after (gimple_stmt_iterator
*i
, gimple
*stmt
,
538 enum gsi_iterator_update m
)
540 update_modified_stmt (stmt
);
541 gsi_insert_after_without_update (i
, stmt
, m
);
545 /* Remove the current stmt from the sequence. The iterator is updated
546 to point to the next statement.
548 REMOVE_PERMANENTLY is true when the statement is going to be removed
549 from the IL and not reinserted elsewhere. In that case we remove the
550 statement pointed to by iterator I from the EH tables, and free its
551 operand caches. Otherwise we do not modify this information. Returns
552 true whether EH edge cleanup is required. */
555 gsi_remove (gimple_stmt_iterator
*i
, bool remove_permanently
)
557 gimple_seq_node cur
, next
, prev
;
558 gimple
*stmt
= gsi_stmt (*i
);
559 bool require_eh_edge_purge
= false;
561 /* ??? Do we want to do this for non-permanent operation? */
562 if (gimple_code (stmt
) != GIMPLE_PHI
)
563 insert_debug_temps_for_defs (i
);
565 gimple_set_bb (stmt
, NULL
);
567 if (remove_permanently
)
569 /* Free all the data flow information for STMT. */
570 delink_stmt_imm_use (stmt
);
571 gimple_set_modified (stmt
, true);
573 if (gimple_debug_nonbind_marker_p (stmt
))
574 /* We don't need this to be exact, but try to keep it at least
576 cfun
->debug_marker_count
--;
577 require_eh_edge_purge
= remove_stmt_from_eh_lp (stmt
);
578 gimple_remove_stmt_histograms (cfun
, stmt
);
581 /* Update the iterator and re-wire the links in I->SEQ. */
585 /* See gsi_set_stmt for why we don't reset prev/next of STMT. */
588 /* Cur is not last. */
591 /* Cur is last but not first. */
592 gimple_seq_set_last (i
->seq
, prev
);
595 /* Cur is not first. */
603 return require_eh_edge_purge
;
607 /* Finds iterator for STMT. */
610 gsi_for_stmt (gimple
*stmt
)
612 gimple_stmt_iterator i
;
613 basic_block bb
= gimple_bb (stmt
);
615 if (gimple_code (stmt
) == GIMPLE_PHI
)
616 i
= gsi_start_phis (bb
);
618 i
= gsi_start_bb (bb
);
624 /* Get an iterator for STMT, which is known to belong to SEQ. This is
625 equivalent to starting at the beginning of SEQ and searching forward
626 until STMT is found. */
629 gsi_for_stmt (gimple
*stmt
, gimple_seq
*seq
)
631 gimple_stmt_iterator i
= gsi_start_1 (seq
);
636 /* Finds iterator for PHI. */
639 gsi_for_phi (gphi
*phi
)
642 basic_block bb
= gimple_bb (phi
);
644 i
= gsi_start_phis (bb
);
650 /* Move the statement at FROM so it comes right after the statement at TO. */
653 gsi_move_after (gimple_stmt_iterator
*from
, gimple_stmt_iterator
*to
)
655 gimple
*stmt
= gsi_stmt (*from
);
656 gsi_remove (from
, false);
658 /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to
659 move statements to an empty block. */
660 gsi_insert_after (to
, stmt
, GSI_NEW_STMT
);
664 /* Move the statement at FROM so it comes right before the statement
668 gsi_move_before (gimple_stmt_iterator
*from
, gimple_stmt_iterator
*to
)
670 gimple
*stmt
= gsi_stmt (*from
);
671 gsi_remove (from
, false);
673 /* For consistency with gsi_move_after, it might be better to have
674 GSI_NEW_STMT here; however, that breaks several places that expect
675 that TO does not change. */
676 gsi_insert_before (to
, stmt
, GSI_SAME_STMT
);
680 /* Move the statement at FROM to the end of basic block BB. */
683 gsi_move_to_bb_end (gimple_stmt_iterator
*from
, basic_block bb
)
685 gimple_stmt_iterator last
= gsi_last_bb (bb
);
686 gcc_checking_assert (gsi_bb (last
) == bb
);
688 /* Have to check gsi_end_p because it could be an empty block. */
689 if (!gsi_end_p (last
) && is_ctrl_stmt (gsi_stmt (last
)))
690 gsi_move_before (from
, &last
);
692 gsi_move_after (from
, &last
);
696 /* Add STMT to the pending list of edge E. No actual insertion is
697 made until a call to gsi_commit_edge_inserts () is made. */
700 gsi_insert_on_edge (edge e
, gimple
*stmt
)
702 gimple_seq_add_stmt (&PENDING_STMT (e
), stmt
);
705 /* Add the sequence of statements SEQ to the pending list of edge E.
706 No actual insertion is made until a call to gsi_commit_edge_inserts
710 gsi_insert_seq_on_edge (edge e
, gimple_seq seq
)
712 gimple_seq_add_seq (&PENDING_STMT (e
), seq
);
715 /* Return a new iterator pointing to the first statement in sequence of
716 statements on edge E. Such statements need to be subsequently moved into a
717 basic block by calling gsi_commit_edge_inserts. */
720 gsi_start_edge (edge e
)
722 return gsi_start (PENDING_STMT (e
));
725 /* Insert the statement pointed-to by GSI into edge E. Every attempt
726 is made to place the statement in an existing basic block, but
727 sometimes that isn't possible. When it isn't possible, the edge is
728 split and the statement is added to the new block.
730 In all cases, the returned *GSI points to the correct location. The
731 return value is true if insertion should be done after the location,
732 or false if it should be done before the location. If a new basic block
733 has to be created, it is stored in *NEW_BB. */
736 gimple_find_edge_insert_loc (edge e
, gimple_stmt_iterator
*gsi
,
739 basic_block dest
, src
;
744 /* If the destination has one predecessor which has no PHI nodes,
745 insert there. Except for the exit block.
747 The requirement for no PHI nodes could be relaxed. Basically we
748 would have to examine the PHIs to prove that none of them used
749 the value set by the statement we want to insert on E. That
750 hardly seems worth the effort. */
752 if (single_pred_p (dest
)
753 && gimple_seq_empty_p (phi_nodes (dest
))
754 && dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
756 *gsi
= gsi_start_bb (dest
);
757 if (gsi_end_p (*gsi
))
760 /* Make sure we insert after any leading labels. */
761 tmp
= gsi_stmt (*gsi
);
762 while (gimple_code (tmp
) == GIMPLE_LABEL
)
765 if (gsi_end_p (*gsi
))
767 tmp
= gsi_stmt (*gsi
);
770 if (gsi_end_p (*gsi
))
772 *gsi
= gsi_last_bb (dest
);
779 /* If the source has one successor, the edge is not abnormal and
780 the last statement does not end a basic block, insert there.
781 Except for the entry block. */
783 if ((e
->flags
& EDGE_ABNORMAL
) == 0
784 && (single_succ_p (src
)
785 /* Do not count a fake edge as successor as added to infinite
786 loops by connect_infinite_loops_to_exit. */
787 || (EDGE_COUNT (src
->succs
) == 2
788 && (EDGE_SUCC (src
, 0)->flags
& EDGE_FAKE
789 || EDGE_SUCC (src
, 1)->flags
& EDGE_FAKE
)))
790 && src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
792 *gsi
= gsi_last_bb (src
);
793 if (gsi_end_p (*gsi
))
796 tmp
= gsi_stmt (*gsi
);
797 if (is_gimple_debug (tmp
))
799 gimple_stmt_iterator si
= *gsi
;
800 gsi_prev_nondebug (&si
);
803 /* If we don't have a BB-ending nondebug stmt, we want to
804 insert after the trailing debug stmts. Otherwise, we may
805 insert before the BB-ending nondebug stmt, or split the
807 if (!stmt_ends_bb_p (tmp
))
811 else if (!stmt_ends_bb_p (tmp
))
814 switch (gimple_code (tmp
))
824 /* Otherwise, create a new basic block, and split this edge. */
825 dest
= split_edge (e
);
828 e
= single_pred_edge (dest
);
833 /* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts. If a new
834 block has to be created, it is returned. */
837 gsi_insert_on_edge_immediate (edge e
, gimple
*stmt
)
839 gimple_stmt_iterator gsi
;
840 basic_block new_bb
= NULL
;
843 gcc_assert (!PENDING_STMT (e
));
845 ins_after
= gimple_find_edge_insert_loc (e
, &gsi
, &new_bb
);
847 update_call_edge_frequencies (stmt
, gsi
.bb
);
850 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
852 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
857 /* Insert STMTS on edge E. If a new block has to be created, it
861 gsi_insert_seq_on_edge_immediate (edge e
, gimple_seq stmts
)
863 gimple_stmt_iterator gsi
;
864 basic_block new_bb
= NULL
;
867 gcc_assert (!PENDING_STMT (e
));
869 ins_after
= gimple_find_edge_insert_loc (e
, &gsi
, &new_bb
);
870 update_call_edge_frequencies (gimple_seq_first (stmts
), gsi
.bb
);
873 gsi_insert_seq_after (&gsi
, stmts
, GSI_NEW_STMT
);
875 gsi_insert_seq_before (&gsi
, stmts
, GSI_NEW_STMT
);
880 /* This routine will commit all pending edge insertions, creating any new
881 basic blocks which are necessary. */
884 gsi_commit_edge_inserts (void)
890 gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
)),
893 FOR_EACH_BB_FN (bb
, cfun
)
894 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
895 gsi_commit_one_edge_insert (e
, NULL
);
899 /* Commit insertions pending at edge E. If a new block is created, set NEW_BB
900 to this block, otherwise set it to NULL. */
903 gsi_commit_one_edge_insert (edge e
, basic_block
*new_bb
)
908 if (PENDING_STMT (e
))
910 gimple_stmt_iterator gsi
;
911 gimple_seq seq
= PENDING_STMT (e
);
914 PENDING_STMT (e
) = NULL
;
916 ins_after
= gimple_find_edge_insert_loc (e
, &gsi
, new_bb
);
917 update_call_edge_frequencies (gimple_seq_first (seq
), gsi
.bb
);
920 gsi_insert_seq_after (&gsi
, seq
, GSI_NEW_STMT
);
922 gsi_insert_seq_before (&gsi
, seq
, GSI_NEW_STMT
);
926 /* Returns iterator at the start of the list of phi nodes of BB. */
929 gsi_start_phis (basic_block bb
)
931 gimple_seq
*pseq
= phi_nodes_ptr (bb
);
933 /* Adapted from gsi_start_1. */
936 i
.ptr
= gimple_seq_first (*pseq
);
938 i
.bb
= i
.ptr
? gimple_bb (i
.ptr
) : NULL
;