1 /* Instruction scheduling pass. 2 Copyright (C) 1992-2013 Free Software Foundation, Inc. 3 Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by, 4 and currently maintained by, Jim Wilson (wilson@cygnus.com) 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "tm.h" 26 #include "diagnostic-core.h" 27 #include "rtl.h" 28 #include "tm_p.h" 29 #include "hard-reg-set.h" 30 #include "regs.h" 31 #include "function.h" 32 #include "flags.h" 33 #include "insn-config.h" 34 #include "insn-attr.h" 35 #include "except.h" 36 #include "recog.h" 37 #include "params.h" 38 #include "sched-int.h" 39 #include "target.h" 40 41 42 #ifdef INSN_SCHEDULING 43 44 /* The number of insns to be scheduled in total. */ 45 static int rgn_n_insns; 46 47 /* The number of insns scheduled so far. */ 48 static int sched_rgn_n_insns; 49 50 /* Set of blocks, that already have their dependencies calculated. */ 51 static bitmap_head dont_calc_deps; 52 53 /* Last basic block in current ebb. */ 54 static basic_block last_bb; 55 56 /* Implementations of the sched_info functions for region scheduling. */ 57 static void init_ready_list (void); 58 static void begin_schedule_ready (rtx); 59 static int schedule_more_p (void); 60 static const char *ebb_print_insn (const_rtx, int); 61 static int rank (rtx, rtx); 62 static int ebb_contributes_to_priority (rtx, rtx); 63 static basic_block earliest_block_with_similiar_load (basic_block, rtx); 64 static void add_deps_for_risky_insns (rtx, rtx); 65 static void debug_ebb_dependencies (rtx, rtx); 66 67 static void ebb_add_remove_insn (rtx, int); 68 static void ebb_add_block (basic_block, basic_block); 69 static basic_block advance_target_bb (basic_block, rtx); 70 static void ebb_fix_recovery_cfg (int, int, int); 71 72 /* Allocate memory and store the state of the frontend. Return the allocated 73 memory. */ 74 static void * 75 save_ebb_state (void) 76 { 77 int *p = XNEW (int); 78 *p = sched_rgn_n_insns; 79 return p; 80 } 81 82 /* Restore the state of the frontend from P_, then free it. */ 83 static void 84 restore_ebb_state (void *p_) 85 { 86 int *p = (int *)p_; 87 sched_rgn_n_insns = *p; 88 free (p_); 89 } 90 91 /* Return nonzero if there are more insns that should be scheduled. */ 92 93 static int 94 schedule_more_p (void) 95 { 96 return sched_rgn_n_insns < rgn_n_insns; 97 } 98 99 /* Print dependency information about ebb between HEAD and TAIL. */ 100 static void 101 debug_ebb_dependencies (rtx head, rtx tail) 102 { 103 fprintf (sched_dump, 104 ";; --------------- forward dependences: ------------ \n"); 105 106 fprintf (sched_dump, "\n;; --- EBB Dependences --- from bb%d to bb%d \n", 107 BLOCK_NUM (head), BLOCK_NUM (tail)); 108 109 debug_dependencies (head, tail); 110 } 111 112 /* Add all insns that are initially ready to the ready list READY. Called 113 once before scheduling a set of insns. */ 114 115 static void 116 init_ready_list (void) 117 { 118 int n = 0; 119 rtx prev_head = current_sched_info->prev_head; 120 rtx next_tail = current_sched_info->next_tail; 121 rtx insn; 122 123 sched_rgn_n_insns = 0; 124 125 /* Print debugging information. */ 126 if (sched_verbose >= 5) 127 debug_ebb_dependencies (NEXT_INSN (prev_head), PREV_INSN (next_tail)); 128 129 /* Initialize ready list with all 'ready' insns in target block. 130 Count number of insns in the target block being scheduled. */ 131 for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn)) 132 { 133 try_ready (insn); 134 n++; 135 } 136 137 gcc_assert (n == rgn_n_insns); 138 } 139 140 /* INSN is being scheduled after LAST. Update counters. */ 141 static void 142 begin_schedule_ready (rtx insn ATTRIBUTE_UNUSED) 143 { 144 sched_rgn_n_insns++; 145 } 146 147 /* INSN is being moved to its place in the schedule, after LAST. */ 148 static void 149 begin_move_insn (rtx insn, rtx last) 150 { 151 if (BLOCK_FOR_INSN (insn) == last_bb 152 /* INSN is a jump in the last block, ... */ 153 && control_flow_insn_p (insn) 154 /* that is going to be moved over some instructions. */ 155 && last != PREV_INSN (insn)) 156 { 157 edge e; 158 basic_block bb; 159 160 /* An obscure special case, where we do have partially dead 161 instruction scheduled after last control flow instruction. 162 In this case we can create new basic block. It is 163 always exactly one basic block last in the sequence. */ 164 165 e = find_fallthru_edge (last_bb->succs); 166 167 gcc_checking_assert (!e || !(e->flags & EDGE_COMPLEX)); 168 169 gcc_checking_assert (BLOCK_FOR_INSN (insn) == last_bb 170 && !IS_SPECULATION_CHECK_P (insn) 171 && BB_HEAD (last_bb) != insn 172 && BB_END (last_bb) == insn); 173 174 { 175 rtx x; 176 177 x = NEXT_INSN (insn); 178 if (e) 179 gcc_checking_assert (NOTE_P (x) || LABEL_P (x)); 180 else 181 gcc_checking_assert (BARRIER_P (x)); 182 } 183 184 if (e) 185 { 186 bb = split_edge (e); 187 gcc_assert (NOTE_INSN_BASIC_BLOCK_P (BB_END (bb))); 188 } 189 else 190 { 191 /* Create an empty unreachable block after the INSN. */ 192 rtx next = NEXT_INSN (insn); 193 if (next && BARRIER_P (next)) 194 next = NEXT_INSN (next); 195 bb = create_basic_block (next, NULL_RTX, last_bb); 196 } 197 198 /* split_edge () creates BB before E->DEST. Keep in mind, that 199 this operation extends scheduling region till the end of BB. 200 Hence, we need to shift NEXT_TAIL, so haifa-sched.c won't go out 201 of the scheduling region. */ 202 current_sched_info->next_tail = NEXT_INSN (BB_END (bb)); 203 gcc_assert (current_sched_info->next_tail); 204 205 /* Append new basic block to the end of the ebb. */ 206 sched_init_only_bb (bb, last_bb); 207 gcc_assert (last_bb == bb); 208 } 209 } 210 211 /* Return a string that contains the insn uid and optionally anything else 212 necessary to identify this insn in an output. It's valid to use a 213 static buffer for this. The ALIGNED parameter should cause the string 214 to be formatted so that multiple output lines will line up nicely. */ 215 216 static const char * 217 ebb_print_insn (const_rtx insn, int aligned ATTRIBUTE_UNUSED) 218 { 219 static char tmp[80]; 220 221 /* '+' before insn means it is a new cycle start. */ 222 if (GET_MODE (insn) == TImode) 223 sprintf (tmp, "+ %4d", INSN_UID (insn)); 224 else 225 sprintf (tmp, " %4d", INSN_UID (insn)); 226 227 return tmp; 228 } 229 230 /* Compare priority of two insns. Return a positive number if the second 231 insn is to be preferred for scheduling, and a negative one if the first 232 is to be preferred. Zero if they are equally good. */ 233 234 static int 235 rank (rtx insn1, rtx insn2) 236 { 237 basic_block bb1 = BLOCK_FOR_INSN (insn1); 238 basic_block bb2 = BLOCK_FOR_INSN (insn2); 239 240 if (bb1->count > bb2->count 241 || bb1->frequency > bb2->frequency) 242 return -1; 243 if (bb1->count < bb2->count 244 || bb1->frequency < bb2->frequency) 245 return 1; 246 return 0; 247 } 248 249 /* NEXT is an instruction that depends on INSN (a backward dependence); 250 return nonzero if we should include this dependence in priority 251 calculations. */ 252 253 static int 254 ebb_contributes_to_priority (rtx next ATTRIBUTE_UNUSED, 255 rtx insn ATTRIBUTE_UNUSED) 256 { 257 return 1; 258 } 259 260 /* INSN is a JUMP_INSN. Store the set of registers that 261 must be considered as used by this jump in USED. */ 262 263 void 264 ebb_compute_jump_reg_dependencies (rtx insn, regset used) 265 { 266 basic_block b = BLOCK_FOR_INSN (insn); 267 edge e; 268 edge_iterator ei; 269 270 FOR_EACH_EDGE (e, ei, b->succs) 271 if ((e->flags & EDGE_FALLTHRU) == 0) 272 bitmap_ior_into (used, df_get_live_in (e->dest)); 273 } 274 275 /* Used in schedule_insns to initialize current_sched_info for scheduling 276 regions (or single basic blocks). */ 277 278 static struct common_sched_info_def ebb_common_sched_info; 279 280 static struct sched_deps_info_def ebb_sched_deps_info = 281 { 282 ebb_compute_jump_reg_dependencies, 283 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 284 NULL, 285 1, 0, 0 286 }; 287 288 static struct haifa_sched_info ebb_sched_info = 289 { 290 init_ready_list, 291 NULL, 292 schedule_more_p, 293 NULL, 294 rank, 295 ebb_print_insn, 296 ebb_contributes_to_priority, 297 NULL, /* insn_finishes_block_p */ 298 299 NULL, NULL, 300 NULL, NULL, 301 1, 0, 302 303 ebb_add_remove_insn, 304 begin_schedule_ready, 305 begin_move_insn, 306 advance_target_bb, 307 308 save_ebb_state, 309 restore_ebb_state, 310 311 SCHED_EBB 312 /* We can create new blocks in begin_schedule_ready (). */ 313 | NEW_BBS 314 }; 315 316 /* Returns the earliest block in EBB currently being processed where a 317 "similar load" 'insn2' is found, and hence LOAD_INSN can move 318 speculatively into the found block. All the following must hold: 319 320 (1) both loads have 1 base register (PFREE_CANDIDATEs). 321 (2) load_insn and load2 have a def-use dependence upon 322 the same insn 'insn1'. 323 324 From all these we can conclude that the two loads access memory 325 addresses that differ at most by a constant, and hence if moving 326 load_insn would cause an exception, it would have been caused by 327 load2 anyhow. 328 329 The function uses list (given by LAST_BLOCK) of already processed 330 blocks in EBB. The list is formed in `add_deps_for_risky_insns'. */ 331 332 static basic_block 333 earliest_block_with_similiar_load (basic_block last_block, rtx load_insn) 334 { 335 sd_iterator_def back_sd_it; 336 dep_t back_dep; 337 basic_block bb, earliest_block = NULL; 338 339 FOR_EACH_DEP (load_insn, SD_LIST_BACK, back_sd_it, back_dep) 340 { 341 rtx insn1 = DEP_PRO (back_dep); 342 343 if (DEP_TYPE (back_dep) == REG_DEP_TRUE) 344 /* Found a DEF-USE dependence (insn1, load_insn). */ 345 { 346 sd_iterator_def fore_sd_it; 347 dep_t fore_dep; 348 349 FOR_EACH_DEP (insn1, SD_LIST_FORW, fore_sd_it, fore_dep) 350 { 351 rtx insn2 = DEP_CON (fore_dep); 352 basic_block insn2_block = BLOCK_FOR_INSN (insn2); 353 354 if (DEP_TYPE (fore_dep) == REG_DEP_TRUE) 355 { 356 if (earliest_block != NULL 357 && earliest_block->index < insn2_block->index) 358 continue; 359 360 /* Found a DEF-USE dependence (insn1, insn2). */ 361 if (haifa_classify_insn (insn2) != PFREE_CANDIDATE) 362 /* insn2 not guaranteed to be a 1 base reg load. */ 363 continue; 364 365 for (bb = last_block; bb; bb = (basic_block) bb->aux) 366 if (insn2_block == bb) 367 break; 368 369 if (!bb) 370 /* insn2 is the similar load. */ 371 earliest_block = insn2_block; 372 } 373 } 374 } 375 } 376 377 return earliest_block; 378 } 379 380 /* The following function adds dependencies between jumps and risky 381 insns in given ebb. */ 382 383 static void 384 add_deps_for_risky_insns (rtx head, rtx tail) 385 { 386 rtx insn, prev; 387 int classification; 388 rtx last_jump = NULL_RTX; 389 rtx next_tail = NEXT_INSN (tail); 390 basic_block last_block = NULL, bb; 391 392 for (insn = head; insn != next_tail; insn = NEXT_INSN (insn)) 393 { 394 add_delay_dependencies (insn); 395 if (control_flow_insn_p (insn)) 396 { 397 bb = BLOCK_FOR_INSN (insn); 398 bb->aux = last_block; 399 last_block = bb; 400 /* Ensure blocks stay in the same order. */ 401 if (last_jump) 402 add_dependence (insn, last_jump, REG_DEP_ANTI); 403 last_jump = insn; 404 } 405 else if (INSN_P (insn) && last_jump != NULL_RTX) 406 { 407 classification = haifa_classify_insn (insn); 408 prev = last_jump; 409 410 switch (classification) 411 { 412 case PFREE_CANDIDATE: 413 if (flag_schedule_speculative_load) 414 { 415 bb = earliest_block_with_similiar_load (last_block, insn); 416 if (bb) 417 { 418 bb = (basic_block) bb->aux; 419 if (!bb) 420 break; 421 prev = BB_END (bb); 422 } 423 } 424 /* Fall through. */ 425 case TRAP_RISKY: 426 case IRISKY: 427 case PRISKY_CANDIDATE: 428 /* ??? We could implement better checking PRISKY_CANDIDATEs 429 analogous to sched-rgn.c. */ 430 /* We can not change the mode of the backward 431 dependency because REG_DEP_ANTI has the lowest 432 rank. */ 433 if (! sched_insns_conditions_mutex_p (insn, prev)) 434 { 435 if ((current_sched_info->flags & DO_SPECULATION) 436 && (spec_info->mask & BEGIN_CONTROL)) 437 { 438 dep_def _dep, *dep = &_dep; 439 440 init_dep (dep, prev, insn, REG_DEP_ANTI); 441 442 if (current_sched_info->flags & USE_DEPS_LIST) 443 { 444 DEP_STATUS (dep) = set_dep_weak (DEP_ANTI, BEGIN_CONTROL, 445 MAX_DEP_WEAK); 446 447 } 448 sd_add_or_update_dep (dep, false); 449 } 450 else 451 add_dependence (insn, prev, REG_DEP_CONTROL); 452 } 453 454 break; 455 456 default: 457 break; 458 } 459 } 460 } 461 /* Maintain the invariant that bb->aux is clear after use. */ 462 while (last_block) 463 { 464 bb = (basic_block) last_block->aux; 465 last_block->aux = NULL; 466 last_block = bb; 467 } 468 } 469 470 /* Schedule a single extended basic block, defined by the boundaries 471 HEAD and TAIL. 472 473 We change our expectations about scheduler behaviour depending on 474 whether MODULO_SCHEDULING is true. If it is, we expect that the 475 caller has already called set_modulo_params and created delay pairs 476 as appropriate. If the modulo schedule failed, we return 477 NULL_RTX. */ 478 479 basic_block 480 schedule_ebb (rtx head, rtx tail, bool modulo_scheduling) 481 { 482 basic_block first_bb, target_bb; 483 struct deps_desc tmp_deps; 484 bool success; 485 486 /* Blah. We should fix the rest of the code not to get confused by 487 a note or two. */ 488 while (head != tail) 489 { 490 if (NOTE_P (head) || DEBUG_INSN_P (head)) 491 head = NEXT_INSN (head); 492 else if (NOTE_P (tail) || DEBUG_INSN_P (tail)) 493 tail = PREV_INSN (tail); 494 else if (LABEL_P (head)) 495 head = NEXT_INSN (head); 496 else 497 break; 498 } 499 500 first_bb = BLOCK_FOR_INSN (head); 501 last_bb = BLOCK_FOR_INSN (tail); 502 503 if (no_real_insns_p (head, tail)) 504 return BLOCK_FOR_INSN (tail); 505 506 gcc_assert (INSN_P (head) && INSN_P (tail)); 507 508 if (!bitmap_bit_p (&dont_calc_deps, first_bb->index)) 509 { 510 init_deps_global (); 511 512 /* Compute dependencies. */ 513 init_deps (&tmp_deps, false); 514 sched_analyze (&tmp_deps, head, tail); 515 free_deps (&tmp_deps); 516 517 add_deps_for_risky_insns (head, tail); 518 519 if (targetm.sched.dependencies_evaluation_hook) 520 targetm.sched.dependencies_evaluation_hook (head, tail); 521 522 finish_deps_global (); 523 } 524 else 525 /* Only recovery blocks can have their dependencies already calculated, 526 and they always are single block ebbs. */ 527 gcc_assert (first_bb == last_bb); 528 529 /* Set priorities. */ 530 current_sched_info->sched_max_insns_priority = 0; 531 rgn_n_insns = set_priorities (head, tail); 532 current_sched_info->sched_max_insns_priority++; 533 534 current_sched_info->prev_head = PREV_INSN (head); 535 current_sched_info->next_tail = NEXT_INSN (tail); 536 537 remove_notes (head, tail); 538 539 unlink_bb_notes (first_bb, last_bb); 540 541 target_bb = first_bb; 542 543 /* Make ready list big enough to hold all the instructions from the ebb. */ 544 sched_extend_ready_list (rgn_n_insns); 545 success = schedule_block (&target_bb, NULL); 546 gcc_assert (success || modulo_scheduling); 547 548 /* Free ready list. */ 549 sched_finish_ready_list (); 550 551 /* We might pack all instructions into fewer blocks, 552 so we may made some of them empty. Can't assert (b == last_bb). */ 553 554 /* Sanity check: verify that all region insns were scheduled. */ 555 gcc_assert (modulo_scheduling || sched_rgn_n_insns == rgn_n_insns); 556 557 /* Free dependencies. */ 558 sched_free_deps (current_sched_info->head, current_sched_info->tail, true); 559 560 gcc_assert (haifa_recovery_bb_ever_added_p 561 || deps_pools_are_empty_p ()); 562 563 if (EDGE_COUNT (last_bb->preds) == 0) 564 /* LAST_BB is unreachable. */ 565 { 566 gcc_assert (first_bb != last_bb 567 && EDGE_COUNT (last_bb->succs) == 0); 568 last_bb = last_bb->prev_bb; 569 delete_basic_block (last_bb->next_bb); 570 } 571 572 return success ? last_bb : NULL; 573 } 574 575 /* Perform initializations before running schedule_ebbs or a single 576 schedule_ebb. */ 577 void 578 schedule_ebbs_init (void) 579 { 580 /* Setup infos. */ 581 { 582 memcpy (&ebb_common_sched_info, &haifa_common_sched_info, 583 sizeof (ebb_common_sched_info)); 584 585 ebb_common_sched_info.fix_recovery_cfg = ebb_fix_recovery_cfg; 586 ebb_common_sched_info.add_block = ebb_add_block; 587 ebb_common_sched_info.sched_pass_id = SCHED_EBB_PASS; 588 589 common_sched_info = &ebb_common_sched_info; 590 sched_deps_info = &ebb_sched_deps_info; 591 current_sched_info = &ebb_sched_info; 592 } 593 594 haifa_sched_init (); 595 596 compute_bb_for_insn (); 597 598 /* Initialize DONT_CALC_DEPS and ebb-{start, end} markers. */ 599 bitmap_initialize (&dont_calc_deps, 0); 600 bitmap_clear (&dont_calc_deps); 601 } 602 603 /* Perform cleanups after scheduling using schedules_ebbs or schedule_ebb. */ 604 void 605 schedule_ebbs_finish (void) 606 { 607 bitmap_clear (&dont_calc_deps); 608 609 /* Reposition the prologue and epilogue notes in case we moved the 610 prologue/epilogue insns. */ 611 if (reload_completed) 612 reposition_prologue_and_epilogue_notes (); 613 614 haifa_sched_finish (); 615 } 616 617 /* The main entry point in this file. */ 618 619 void 620 schedule_ebbs (void) 621 { 622 basic_block bb; 623 int probability_cutoff; 624 rtx tail; 625 626 /* Taking care of this degenerate case makes the rest of 627 this code simpler. */ 628 if (n_basic_blocks == NUM_FIXED_BLOCKS) 629 return; 630 631 if (profile_info && flag_branch_probabilities) 632 probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK); 633 else 634 probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY); 635 probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff; 636 637 schedule_ebbs_init (); 638 639 /* Schedule every region in the subroutine. */ 640 FOR_EACH_BB (bb) 641 { 642 rtx head = BB_HEAD (bb); 643 644 if (bb->flags & BB_DISABLE_SCHEDULE) 645 continue; 646 647 for (;;) 648 { 649 edge e; 650 tail = BB_END (bb); 651 if (bb->next_bb == EXIT_BLOCK_PTR 652 || LABEL_P (BB_HEAD (bb->next_bb))) 653 break; 654 e = find_fallthru_edge (bb->succs); 655 if (! e) 656 break; 657 if (e->probability <= probability_cutoff) 658 break; 659 if (e->dest->flags & BB_DISABLE_SCHEDULE) 660 break; 661 bb = bb->next_bb; 662 } 663 664 bb = schedule_ebb (head, tail, false); 665 } 666 schedule_ebbs_finish (); 667 } 668 669 /* INSN has been added to/removed from current ebb. */ 670 static void 671 ebb_add_remove_insn (rtx insn ATTRIBUTE_UNUSED, int remove_p) 672 { 673 if (!remove_p) 674 rgn_n_insns++; 675 else 676 rgn_n_insns--; 677 } 678 679 /* BB was added to ebb after AFTER. */ 680 static void 681 ebb_add_block (basic_block bb, basic_block after) 682 { 683 /* Recovery blocks are always bounded by BARRIERS, 684 therefore, they always form single block EBB, 685 therefore, we can use rec->index to identify such EBBs. */ 686 if (after == EXIT_BLOCK_PTR) 687 bitmap_set_bit (&dont_calc_deps, bb->index); 688 else if (after == last_bb) 689 last_bb = bb; 690 } 691 692 /* Return next block in ebb chain. For parameter meaning please refer to 693 sched-int.h: struct sched_info: advance_target_bb. */ 694 static basic_block 695 advance_target_bb (basic_block bb, rtx insn) 696 { 697 if (insn) 698 { 699 if (BLOCK_FOR_INSN (insn) != bb 700 && control_flow_insn_p (insn) 701 /* We handle interblock movement of the speculation check 702 or over a speculation check in 703 haifa-sched.c: move_block_after_check (). */ 704 && !IS_SPECULATION_BRANCHY_CHECK_P (insn) 705 && !IS_SPECULATION_BRANCHY_CHECK_P (BB_END (bb))) 706 { 707 /* Assert that we don't move jumps across blocks. */ 708 gcc_assert (!control_flow_insn_p (BB_END (bb)) 709 && NOTE_INSN_BASIC_BLOCK_P (BB_HEAD (bb->next_bb))); 710 return bb; 711 } 712 else 713 return 0; 714 } 715 else 716 /* Return next non empty block. */ 717 { 718 do 719 { 720 gcc_assert (bb != last_bb); 721 722 bb = bb->next_bb; 723 } 724 while (bb_note (bb) == BB_END (bb)); 725 726 return bb; 727 } 728 } 729 730 /* Fix internal data after interblock movement of jump instruction. 731 For parameter meaning please refer to 732 sched-int.h: struct sched_info: fix_recovery_cfg. */ 733 static void 734 ebb_fix_recovery_cfg (int bbi ATTRIBUTE_UNUSED, int jump_bbi, 735 int jump_bb_nexti) 736 { 737 gcc_assert (last_bb->index != bbi); 738 739 if (jump_bb_nexti == last_bb->index) 740 last_bb = BASIC_BLOCK (jump_bbi); 741 } 742 743 #endif /* INSN_SCHEDULING */ 744