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   gcc_checking_assert (gsi_bb (last) == bb);
 601
 602   /* Have to check gsi_end_p because it could be an empty block.  */
 603   if (!gsi_end_p (last) && is_ctrl_stmt (gsi_stmt (last)))
 604     gsi_move_before (from, &last);
 605   else
 606     gsi_move_after (from, &last);
 607 }
 608
 609
 610 /* Add STMT to the pending list of edge E.  No actual insertion is
 611    made until a call to gsi_commit_edge_inserts () is made.  */
 612
 613 void
 614 gsi_insert_on_edge (edge e, gimple stmt)
 615 {
 616   gimple_seq_add_stmt (&PENDING_STMT (e), stmt);
 617 }
 618
 619 /* Add the sequence of statements SEQ to the pending list of edge E.
 620    No actual insertion is made until a call to gsi_commit_edge_inserts
 621    is made.  */
 622
 623 void
 624 gsi_insert_seq_on_edge (edge e, gimple_seq seq)
 625 {
 626   gimple_seq_add_seq (&PENDING_STMT (e), seq);
 627 }
 628
 629
 630 /* Insert the statement pointed-to by GSI into edge E.  Every attempt
 631    is made to place the statement in an existing basic block, but
 632    sometimes that isn't possible.  When it isn't possible, the edge is
 633    split and the statement is added to the new block.
 634
 635    In all cases, the returned *GSI points to the correct location.  The
 636    return value is true if insertion should be done after the location,
 637    or false if it should be done before the location.  If a new basic block
 638    has to be created, it is stored in *NEW_BB.  */
 639
 640 static bool
 641 gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
 642                              basic_block *new_bb)
 643 {
 644   basic_block dest, src;
 645   gimple tmp;
 646
 647   dest = e->dest;
 648
 649   /* If the destination has one predecessor which has no PHI nodes,
 650      insert there.  Except for the exit block.
 651
 652      The requirement for no PHI nodes could be relaxed.  Basically we
 653      would have to examine the PHIs to prove that none of them used
 654      the value set by the statement we want to insert on E.  That
 655      hardly seems worth the effort.  */
 656  restart:
 657   if (single_pred_p (dest)
 658       && gimple_seq_empty_p (phi_nodes (dest))
 659       && dest != EXIT_BLOCK_PTR)
 660     {
 661       *gsi = gsi_start_bb (dest);
 662       if (gsi_end_p (*gsi))
 663         return true;
 664
 665       /* Make sure we insert after any leading labels.  */
 666       tmp = gsi_stmt (*gsi);
 667       while (gimple_code (tmp) == GIMPLE_LABEL)
 668         {
 669           gsi_next (gsi);
 670           if (gsi_end_p (*gsi))
 671             break;
 672           tmp = gsi_stmt (*gsi);
 673         }
 674
 675       if (gsi_end_p (*gsi))
 676         {
 677           *gsi = gsi_last_bb (dest);
 678           return true;
 679         }
 680       else
 681         return false;
 682     }
 683
 684   /* If the source has one successor, the edge is not abnormal and
 685      the last statement does not end a basic block, insert there.
 686      Except for the entry block.  */
 687   src = e->src;
 688   if ((e->flags & EDGE_ABNORMAL) == 0
 689       && single_succ_p (src)
 690       && src != ENTRY_BLOCK_PTR)
 691     {
 692       *gsi = gsi_last_bb (src);
 693       if (gsi_end_p (*gsi))
 694         return true;
 695
 696       tmp = gsi_stmt (*gsi);
 697       if (!stmt_ends_bb_p (tmp))
 698         return true;
 699
 700       switch (gimple_code (tmp))
 701         {
 702         case GIMPLE_RETURN:
 703         case GIMPLE_RESX:
 704           return false;
 705         default:
 706           break;
 707         }
 708     }
 709
 710   /* Otherwise, create a new basic block, and split this edge.  */
 711   dest = split_edge (e);
 712   if (new_bb)
 713     *new_bb = dest;
 714   e = single_pred_edge (dest);
 715   goto restart;
 716 }
 717
 718
 719 /* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts.  If a new
 720    block has to be created, it is returned.  */
 721
 722 basic_block
 723 gsi_insert_on_edge_immediate (edge e, gimple stmt)
 724 {
 725   gimple_stmt_iterator gsi;
 726   struct gimple_seq_node_d node;
 727   basic_block new_bb = NULL;
 728   bool ins_after;
 729
 730   gcc_assert (!PENDING_STMT (e));
 731
 732   ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb);
 733
 734   node.stmt = stmt;
 735   node.prev = node.next = NULL;
 736   update_call_edge_frequencies (&node, gsi.bb);
 737
 738   if (ins_after)
 739     gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
 740   else
 741     gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
 742
 743   return new_bb;
 744 }
 745
 746 /* Insert STMTS on edge E.  If a new block has to be created, it
 747    is returned.  */
 748
 749 basic_block
 750 gsi_insert_seq_on_edge_immediate (edge e, gimple_seq stmts)
 751 {
 752   gimple_stmt_iterator gsi;
 753   basic_block new_bb = NULL;
 754   bool ins_after;
 755
 756   gcc_assert (!PENDING_STMT (e));
 757
 758   ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb);
 759   update_call_edge_frequencies (gimple_seq_first (stmts), gsi.bb);
 760
 761   if (ins_after)
 762     gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
 763   else
 764     gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT);
 765
 766   return new_bb;
 767 }
 768
 769 /* This routine will commit all pending edge insertions, creating any new
 770    basic blocks which are necessary.  */
 771
 772 void
 773 gsi_commit_edge_inserts (void)
 774 {
 775   basic_block bb;
 776   edge e;
 777   edge_iterator ei;
 778
 779   gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL);
 780
 781   FOR_EACH_BB (bb)
 782     FOR_EACH_EDGE (e, ei, bb->succs)
 783       gsi_commit_one_edge_insert (e, NULL);
 784 }
 785
 786
 787 /* Commit insertions pending at edge E. If a new block is created, set NEW_BB
 788    to this block, otherwise set it to NULL.  */
 789
 790 void
 791 gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
 792 {
 793   if (new_bb)
 794     *new_bb = NULL;
 795
 796   if (PENDING_STMT (e))
 797     {
 798       gimple_stmt_iterator gsi;
 799       gimple_seq seq = PENDING_STMT (e);
 800       bool ins_after;
 801
 802       PENDING_STMT (e) = NULL;
 803
 804       ins_after = gimple_find_edge_insert_loc (e, &gsi, new_bb);
 805       update_call_edge_frequencies (gimple_seq_first (seq), gsi.bb);
 806
 807       if (ins_after)
 808         gsi_insert_seq_after (&gsi, seq, GSI_NEW_STMT);
 809       else
 810         gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT);
 811     }
 812 }
 813
 814 /* Returns iterator at the start of the list of phi nodes of BB.  */
 815
 816 gimple_stmt_iterator
 817 gsi_start_phis (basic_block bb)
 818 {
 819   return gsi_start (phi_nodes (bb));
 820 }