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