gcc/gimple-iterator.c

   1 /* Iterator routines for GIMPLE statements.
   2    Copyright (C) 2007, 2008, 2010 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.  Assignments must only be
 362    replaced with assignments to the same LHS.  */
 363
 364 void
 365 gsi_replace (gimple_stmt_iterator *gsi, gimple stmt, bool update_eh_info)
 366 {
 367   gimple orig_stmt = gsi_stmt (*gsi);
 368
 369   if (stmt == orig_stmt)
 370     return;
 371
 372   gcc_assert (!gimple_has_lhs (orig_stmt)
 373               || gimple_get_lhs (orig_stmt) == gimple_get_lhs (stmt));
 374
 375   gimple_set_location (stmt, gimple_location (orig_stmt));
 376   gimple_set_bb (stmt, gsi_bb (*gsi));
 377
 378   /* Preserve EH region information from the original statement, if
 379      requested by the caller.  */
 380   if (update_eh_info)
 381     maybe_clean_or_replace_eh_stmt (orig_stmt, stmt);
 382
 383   gimple_duplicate_stmt_histograms (cfun, stmt, cfun, orig_stmt);
 384
 385   /* Free all the data flow information for ORIG_STMT.  */
 386   gimple_set_bb (orig_stmt, NULL);
 387   gimple_remove_stmt_histograms (cfun, orig_stmt);
 388   delink_stmt_imm_use (orig_stmt);
 389
 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_alloc_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_alloc_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   if (gimple_code (stmt) != GIMPLE_PHI)
 482     insert_debug_temps_for_defs (i);
 483
 484   /* Free all the data flow information for STMT.  */
 485   gimple_set_bb (stmt, NULL);
 486   delink_stmt_imm_use (stmt);
 487   gimple_set_modified (stmt, true);
 488
 489   if (remove_permanently)
 490     {
 491       remove_stmt_from_eh_lp (stmt);
 492       gimple_remove_stmt_histograms (cfun, stmt);
 493     }
 494
 495   /* Update the iterator and re-wire the links in I->SEQ.  */
 496   cur = i->ptr;
 497   next = cur->next;
 498   prev = cur->prev;
 499
 500   if (prev)
 501     prev->next = next;
 502   else
 503     gimple_seq_set_first (i->seq, next);
 504
 505   if (next)
 506     next->prev = prev;
 507   else
 508     gimple_seq_set_last (i->seq, prev);
 509
 510   i->ptr = next;
 511 }
 512
 513
 514 /* Finds iterator for STMT.  */
 515
 516 gimple_stmt_iterator
 517 gsi_for_stmt (gimple stmt)
 518 {
 519   gimple_stmt_iterator i;
 520   basic_block bb = gimple_bb (stmt);
 521
 522   if (gimple_code (stmt) == GIMPLE_PHI)
 523     i = gsi_start_phis (bb);
 524   else
 525     i = gsi_start_bb (bb);
 526
 527   for (; !gsi_end_p (i); gsi_next (&i))
 528     if (gsi_stmt (i) == stmt)
 529       return i;
 530
 531   gcc_unreachable ();
 532 }
 533
 534
 535 /* Move the statement at FROM so it comes right after the statement at TO.  */
 536
 537 void
 538 gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 539 {
 540   gimple stmt = gsi_stmt (*from);
 541   gsi_remove (from, false);
 542
 543   /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to
 544      move statements to an empty block.  */
 545   gsi_insert_after (to, stmt, GSI_NEW_STMT);
 546 }
 547
 548
 549 /* Move the statement at FROM so it comes right before the statement
 550    at TO.  */
 551
 552 void
 553 gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 554 {
 555   gimple stmt = gsi_stmt (*from);
 556   gsi_remove (from, false);
 557
 558   /* For consistency with gsi_move_after, it might be better to have
 559      GSI_NEW_STMT here; however, that breaks several places that expect
 560      that TO does not change.  */
 561   gsi_insert_before (to, stmt, GSI_SAME_STMT);
 562 }
 563
 564
 565 /* Move the statement at FROM to the end of basic block BB.  */
 566
 567 void
 568 gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
 569 {
 570   gimple_stmt_iterator last = gsi_last_bb (bb);
 571 #ifdef ENABLE_CHECKING
 572   gcc_assert (gsi_bb (last) == bb);
 573 #endif
 574
 575   /* Have to check gsi_end_p because it could be an empty block.  */
 576   if (!gsi_end_p (last) && is_ctrl_stmt (gsi_stmt (last)))
 577     gsi_move_before (from, &last);
 578   else
 579     gsi_move_after (from, &last);
 580 }
 581
 582
 583 /* Add STMT to the pending list of edge E.  No actual insertion is
 584    made until a call to gsi_commit_edge_inserts () is made.  */
 585
 586 void
 587 gsi_insert_on_edge (edge e, gimple stmt)
 588 {
 589   gimple_seq_add_stmt (&PENDING_STMT (e), stmt);
 590 }
 591
 592 /* Add the sequence of statements SEQ to the pending list of edge E.
 593    No actual insertion is made until a call to gsi_commit_edge_inserts
 594    is made.  */
 595
 596 void
 597 gsi_insert_seq_on_edge (edge e, gimple_seq seq)
 598 {
 599   gimple_seq_add_seq (&PENDING_STMT (e), seq);
 600 }
 601
 602
 603 /* Insert the statement pointed-to by GSI into edge E.  Every attempt
 604    is made to place the statement in an existing basic block, but
 605    sometimes that isn't possible.  When it isn't possible, the edge is
 606    split and the statement is added to the new block.
 607
 608    In all cases, the returned *GSI points to the correct location.  The
 609    return value is true if insertion should be done after the location,
 610    or false if it should be done before the location.  If a new basic block
 611    has to be created, it is stored in *NEW_BB.  */
 612
 613 static bool
 614 gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
 615                              basic_block *new_bb)
 616 {
 617   basic_block dest, src;
 618   gimple tmp;
 619
 620   dest = e->dest;
 621
 622   /* If the destination has one predecessor which has no PHI nodes,
 623      insert there.  Except for the exit block.
 624
 625      The requirement for no PHI nodes could be relaxed.  Basically we
 626      would have to examine the PHIs to prove that none of them used
 627      the value set by the statement we want to insert on E.  That
 628      hardly seems worth the effort.  */
 629  restart:
 630   if (single_pred_p (dest)
 631       && gimple_seq_empty_p (phi_nodes (dest))
 632       && dest != EXIT_BLOCK_PTR)
 633     {
 634       *gsi = gsi_start_bb (dest);
 635       if (gsi_end_p (*gsi))
 636         return true;
 637
 638       /* Make sure we insert after any leading labels.  */
 639       tmp = gsi_stmt (*gsi);
 640       while (gimple_code (tmp) == GIMPLE_LABEL)
 641         {
 642           gsi_next (gsi);
 643           if (gsi_end_p (*gsi))
 644             break;
 645           tmp = gsi_stmt (*gsi);
 646         }
 647
 648       if (gsi_end_p (*gsi))
 649         {
 650           *gsi = gsi_last_bb (dest);
 651           return true;
 652         }
 653       else
 654         return false;
 655     }
 656
 657   /* If the source has one successor, the edge is not abnormal and
 658      the last statement does not end a basic block, insert there.
 659      Except for the entry block.  */
 660   src = e->src;
 661   if ((e->flags & EDGE_ABNORMAL) == 0
 662       && single_succ_p (src)
 663       && src != ENTRY_BLOCK_PTR)
 664     {
 665       *gsi = gsi_last_bb (src);
 666       if (gsi_end_p (*gsi))
 667         return true;
 668
 669       tmp = gsi_stmt (*gsi);
 670       if (!stmt_ends_bb_p (tmp))
 671         return true;
 672
 673       switch (gimple_code (tmp))
 674         {
 675         case GIMPLE_RETURN:
 676         case GIMPLE_RESX:
 677           return false;
 678         default:
 679           break;
 680         }
 681     }
 682
 683   /* Otherwise, create a new basic block, and split this edge.  */
 684   dest = split_edge (e);
 685   if (new_bb)
 686     *new_bb = dest;
 687   e = single_pred_edge (dest);
 688   goto restart;
 689 }
 690
 691
 692 /* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts.  If a new
 693    block has to be created, it is returned.  */
 694
 695 basic_block
 696 gsi_insert_on_edge_immediate (edge e, gimple stmt)
 697 {
 698   gimple_stmt_iterator gsi;
 699   basic_block new_bb = NULL;
 700
 701   gcc_assert (!PENDING_STMT (e));
 702
 703   if (gimple_find_edge_insert_loc (e, &gsi, &new_bb))
 704     gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
 705   else
 706     gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
 707
 708   return new_bb;
 709 }
 710
 711 /* Insert STMTS on edge E.  If a new block has to be created, it
 712    is returned.  */
 713
 714 basic_block
 715 gsi_insert_seq_on_edge_immediate (edge e, gimple_seq stmts)
 716 {
 717   gimple_stmt_iterator gsi;
 718   basic_block new_bb = NULL;
 719
 720   gcc_assert (!PENDING_STMT (e));
 721
 722   if (gimple_find_edge_insert_loc (e, &gsi, &new_bb))
 723     gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
 724   else
 725     gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT);
 726
 727   return new_bb;
 728 }
 729
 730 /* This routine will commit all pending edge insertions, creating any new
 731    basic blocks which are necessary.  */
 732
 733 void
 734 gsi_commit_edge_inserts (void)
 735 {
 736   basic_block bb;
 737   edge e;
 738   edge_iterator ei;
 739
 740   gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL);
 741
 742   FOR_EACH_BB (bb)
 743     FOR_EACH_EDGE (e, ei, bb->succs)
 744       gsi_commit_one_edge_insert (e, NULL);
 745 }
 746
 747
 748 /* Commit insertions pending at edge E. If a new block is created, set NEW_BB
 749    to this block, otherwise set it to NULL.  */
 750
 751 void
 752 gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
 753 {
 754   if (new_bb)
 755     *new_bb = NULL;
 756
 757   if (PENDING_STMT (e))
 758     {
 759       gimple_stmt_iterator gsi;
 760       gimple_seq seq = PENDING_STMT (e);
 761
 762       PENDING_STMT (e) = NULL;
 763
 764       if (gimple_find_edge_insert_loc (e, &gsi, new_bb))
 765         gsi_insert_seq_after (&gsi, seq, GSI_NEW_STMT);
 766       else
 767         gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT);
 768     }
 769 }
 770
 771 /* Returns iterator at the start of the list of phi nodes of BB.  */
 772
 773 gimple_stmt_iterator
 774 gsi_start_phis (basic_block bb)
 775 {
 776   return gsi_start (phi_nodes (bb));
 777 }