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_get_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.  Returns
 503    true whether EH edge cleanup is required.  */
 504
 505 bool
 506 gsi_remove (gimple_stmt_iterator *i, bool remove_permanently)
 507 {
 508   gimple_seq_node cur, next, prev;
 509   gimple stmt = gsi_stmt (*i);
 510   bool require_eh_edge_purge = false;
 511
 512   if (gimple_code (stmt) != GIMPLE_PHI)
 513     insert_debug_temps_for_defs (i);
 514
 515   /* Free all the data flow information for STMT.  */
 516   gimple_set_bb (stmt, NULL);
 517   delink_stmt_imm_use (stmt);
 518   gimple_set_modified (stmt, true);
 519
 520   if (remove_permanently)
 521     {
 522       require_eh_edge_purge = remove_stmt_from_eh_lp (stmt);
 523       gimple_remove_stmt_histograms (cfun, stmt);
 524     }
 525
 526   /* Update the iterator and re-wire the links in I->SEQ.  */
 527   cur = i->ptr;
 528   next = cur->next;
 529   prev = cur->prev;
 530
 531   if (prev)
 532     prev->next = next;
 533   else
 534     gimple_seq_set_first (i->seq, next);
 535
 536   if (next)
 537     next->prev = prev;
 538   else
 539     gimple_seq_set_last (i->seq, prev);
 540
 541   i->ptr = next;
 542
 543   return require_eh_edge_purge;
 544 }
 545
 546
 547 /* Finds iterator for STMT.  */
 548
 549 gimple_stmt_iterator
 550 gsi_for_stmt (gimple stmt)
 551 {
 552   gimple_stmt_iterator i;
 553   basic_block bb = gimple_bb (stmt);
 554
 555   if (gimple_code (stmt) == GIMPLE_PHI)
 556     i = gsi_start_phis (bb);
 557   else
 558     i = gsi_start_bb (bb);
 559
 560   for (; !gsi_end_p (i); gsi_next (&i))
 561     if (gsi_stmt (i) == stmt)
 562       return i;
 563
 564   gcc_unreachable ();
 565 }
 566
 567
 568 /* Move the statement at FROM so it comes right after the statement at TO.  */
 569
 570 void
 571 gsi_move_after (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 572 {
 573   gimple stmt = gsi_stmt (*from);
 574   gsi_remove (from, false);
 575
 576   /* We must have GSI_NEW_STMT here, as gsi_move_after is sometimes used to
 577      move statements to an empty block.  */
 578   gsi_insert_after (to, stmt, GSI_NEW_STMT);
 579 }
 580
 581
 582 /* Move the statement at FROM so it comes right before the statement
 583    at TO.  */
 584
 585 void
 586 gsi_move_before (gimple_stmt_iterator *from, gimple_stmt_iterator *to)
 587 {
 588   gimple stmt = gsi_stmt (*from);
 589   gsi_remove (from, false);
 590
 591   /* For consistency with gsi_move_after, it might be better to have
 592      GSI_NEW_STMT here; however, that breaks several places that expect
 593      that TO does not change.  */
 594   gsi_insert_before (to, stmt, GSI_SAME_STMT);
 595 }
 596
 597
 598 /* Move the statement at FROM to the end of basic block BB.  */
 599
 600 void
 601 gsi_move_to_bb_end (gimple_stmt_iterator *from, basic_block bb)
 602 {
 603   gimple_stmt_iterator last = gsi_last_bb (bb);
 604   gcc_checking_assert (gsi_bb (last) == bb);
 605
 606   /* Have to check gsi_end_p because it could be an empty block.  */
 607   if (!gsi_end_p (last) && is_ctrl_stmt (gsi_stmt (last)))
 608     gsi_move_before (from, &last);
 609   else
 610     gsi_move_after (from, &last);
 611 }
 612
 613
 614 /* Add STMT to the pending list of edge E.  No actual insertion is
 615    made until a call to gsi_commit_edge_inserts () is made.  */
 616
 617 void
 618 gsi_insert_on_edge (edge e, gimple stmt)
 619 {
 620   gimple_seq_add_stmt (&PENDING_STMT (e), stmt);
 621 }
 622
 623 /* Add the sequence of statements SEQ to the pending list of edge E.
 624    No actual insertion is made until a call to gsi_commit_edge_inserts
 625    is made.  */
 626
 627 void
 628 gsi_insert_seq_on_edge (edge e, gimple_seq seq)
 629 {
 630   gimple_seq_add_seq (&PENDING_STMT (e), seq);
 631 }
 632
 633
 634 /* Insert the statement pointed-to by GSI into edge E.  Every attempt
 635    is made to place the statement in an existing basic block, but
 636    sometimes that isn't possible.  When it isn't possible, the edge is
 637    split and the statement is added to the new block.
 638
 639    In all cases, the returned *GSI points to the correct location.  The
 640    return value is true if insertion should be done after the location,
 641    or false if it should be done before the location.  If a new basic block
 642    has to be created, it is stored in *NEW_BB.  */
 643
 644 static bool
 645 gimple_find_edge_insert_loc (edge e, gimple_stmt_iterator *gsi,
 646                              basic_block *new_bb)
 647 {
 648   basic_block dest, src;
 649   gimple tmp;
 650
 651   dest = e->dest;
 652
 653   /* If the destination has one predecessor which has no PHI nodes,
 654      insert there.  Except for the exit block.
 655
 656      The requirement for no PHI nodes could be relaxed.  Basically we
 657      would have to examine the PHIs to prove that none of them used
 658      the value set by the statement we want to insert on E.  That
 659      hardly seems worth the effort.  */
 660  restart:
 661   if (single_pred_p (dest)
 662       && gimple_seq_empty_p (phi_nodes (dest))
 663       && dest != EXIT_BLOCK_PTR)
 664     {
 665       *gsi = gsi_start_bb (dest);
 666       if (gsi_end_p (*gsi))
 667         return true;
 668
 669       /* Make sure we insert after any leading labels.  */
 670       tmp = gsi_stmt (*gsi);
 671       while (gimple_code (tmp) == GIMPLE_LABEL)
 672         {
 673           gsi_next (gsi);
 674           if (gsi_end_p (*gsi))
 675             break;
 676           tmp = gsi_stmt (*gsi);
 677         }
 678
 679       if (gsi_end_p (*gsi))
 680         {
 681           *gsi = gsi_last_bb (dest);
 682           return true;
 683         }
 684       else
 685         return false;
 686     }
 687
 688   /* If the source has one successor, the edge is not abnormal and
 689      the last statement does not end a basic block, insert there.
 690      Except for the entry block.  */
 691   src = e->src;
 692   if ((e->flags & EDGE_ABNORMAL) == 0
 693       && single_succ_p (src)
 694       && src != ENTRY_BLOCK_PTR)
 695     {
 696       *gsi = gsi_last_bb (src);
 697       if (gsi_end_p (*gsi))
 698         return true;
 699
 700       tmp = gsi_stmt (*gsi);
 701       if (!stmt_ends_bb_p (tmp))
 702         return true;
 703
 704       switch (gimple_code (tmp))
 705         {
 706         case GIMPLE_RETURN:
 707         case GIMPLE_RESX:
 708           return false;
 709         default:
 710           break;
 711         }
 712     }
 713
 714   /* Otherwise, create a new basic block, and split this edge.  */
 715   dest = split_edge (e);
 716   if (new_bb)
 717     *new_bb = dest;
 718   e = single_pred_edge (dest);
 719   goto restart;
 720 }
 721
 722
 723 /* Similar to gsi_insert_on_edge+gsi_commit_edge_inserts.  If a new
 724    block has to be created, it is returned.  */
 725
 726 basic_block
 727 gsi_insert_on_edge_immediate (edge e, gimple stmt)
 728 {
 729   gimple_stmt_iterator gsi;
 730   struct gimple_seq_node_d node;
 731   basic_block new_bb = NULL;
 732   bool ins_after;
 733
 734   gcc_assert (!PENDING_STMT (e));
 735
 736   ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb);
 737
 738   node.stmt = stmt;
 739   node.prev = node.next = NULL;
 740   update_call_edge_frequencies (&node, gsi.bb);
 741
 742   if (ins_after)
 743     gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
 744   else
 745     gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
 746
 747   return new_bb;
 748 }
 749
 750 /* Insert STMTS on edge E.  If a new block has to be created, it
 751    is returned.  */
 752
 753 basic_block
 754 gsi_insert_seq_on_edge_immediate (edge e, gimple_seq stmts)
 755 {
 756   gimple_stmt_iterator gsi;
 757   basic_block new_bb = NULL;
 758   bool ins_after;
 759
 760   gcc_assert (!PENDING_STMT (e));
 761
 762   ins_after = gimple_find_edge_insert_loc (e, &gsi, &new_bb);
 763   update_call_edge_frequencies (gimple_seq_first (stmts), gsi.bb);
 764
 765   if (ins_after)
 766     gsi_insert_seq_after (&gsi, stmts, GSI_NEW_STMT);
 767   else
 768     gsi_insert_seq_before (&gsi, stmts, GSI_NEW_STMT);
 769
 770   return new_bb;
 771 }
 772
 773 /* This routine will commit all pending edge insertions, creating any new
 774    basic blocks which are necessary.  */
 775
 776 void
 777 gsi_commit_edge_inserts (void)
 778 {
 779   basic_block bb;
 780   edge e;
 781   edge_iterator ei;
 782
 783   gsi_commit_one_edge_insert (single_succ_edge (ENTRY_BLOCK_PTR), NULL);
 784
 785   FOR_EACH_BB (bb)
 786     FOR_EACH_EDGE (e, ei, bb->succs)
 787       gsi_commit_one_edge_insert (e, NULL);
 788 }
 789
 790
 791 /* Commit insertions pending at edge E. If a new block is created, set NEW_BB
 792    to this block, otherwise set it to NULL.  */
 793
 794 void
 795 gsi_commit_one_edge_insert (edge e, basic_block *new_bb)
 796 {
 797   if (new_bb)
 798     *new_bb = NULL;
 799
 800   if (PENDING_STMT (e))
 801     {
 802       gimple_stmt_iterator gsi;
 803       gimple_seq seq = PENDING_STMT (e);
 804       bool ins_after;
 805
 806       PENDING_STMT (e) = NULL;
 807
 808       ins_after = gimple_find_edge_insert_loc (e, &gsi, new_bb);
 809       update_call_edge_frequencies (gimple_seq_first (seq), gsi.bb);
 810
 811       if (ins_after)
 812         gsi_insert_seq_after (&gsi, seq, GSI_NEW_STMT);
 813       else
 814         gsi_insert_seq_before (&gsi, seq, GSI_NEW_STMT);
 815     }
 816 }
 817
 818 /* Returns iterator at the start of the list of phi nodes of BB.  */
 819
 820 gimple_stmt_iterator
 821 gsi_start_phis (basic_block bb)
 822 {
 823   return gsi_start (phi_nodes (bb));
 824 }