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