gcc/sched-ebb.c

   1 /* Instruction scheduling pass.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
   6    and currently maintained by, Jim Wilson (wilson@cygnus.com)
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 3, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23 \f
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "diagnostic-core.h"
  29 #include "rtl.h"
  30 #include "tm_p.h"
  31 #include "hard-reg-set.h"
  32 #include "regs.h"
  33 #include "function.h"
  34 #include "flags.h"
  35 #include "insn-config.h"
  36 #include "insn-attr.h"
  37 #include "except.h"
  38 #include "recog.h"
  39 #include "cfglayout.h"
  40 #include "params.h"
  41 #include "sched-int.h"
  42 #include "target.h"
  43 #include "output.h"
  44
  45 \f
  46 #ifdef INSN_SCHEDULING
  47
  48 /* The number of insns to be scheduled in total.  */
  49 static int rgn_n_insns;
  50
  51 /* The number of insns scheduled so far.  */
  52 static int sched_rgn_n_insns;
  53
  54 /* Set of blocks, that already have their dependencies calculated.  */
  55 static bitmap_head dont_calc_deps;
  56
  57 /* Last basic block in current ebb.  */
  58 static basic_block last_bb;
  59
  60 /* Implementations of the sched_info functions for region scheduling.  */
  61 static void init_ready_list (void);
  62 static void begin_schedule_ready (rtx);
  63 static int schedule_more_p (void);
  64 static const char *ebb_print_insn (const_rtx, int);
  65 static int rank (rtx, rtx);
  66 static int ebb_contributes_to_priority (rtx, rtx);
  67 static basic_block earliest_block_with_similiar_load (basic_block, rtx);
  68 static void add_deps_for_risky_insns (rtx, rtx);
  69 static basic_block schedule_ebb (rtx, rtx);
  70 static void debug_ebb_dependencies (rtx, rtx);
  71
  72 static void ebb_add_remove_insn (rtx, int);
  73 static void ebb_add_block (basic_block, basic_block);
  74 static basic_block advance_target_bb (basic_block, rtx);
  75 static void ebb_fix_recovery_cfg (int, int, int);
  76
  77 /* Allocate memory and store the state of the frontend.  Return the allocated
  78    memory.  */
  79 static void *
  80 save_ebb_state (void)
  81 {
  82   int *p = XNEW (int);
  83   *p = sched_rgn_n_insns;
  84   return p;
  85 }
  86
  87 /* Restore the state of the frontend from P_, then free it.  */
  88 static void
  89 restore_ebb_state (void *p_)
  90 {
  91   int *p = (int *)p_;
  92   sched_rgn_n_insns = *p;
  93   free (p_);
  94 }
  95
  96 /* Return nonzero if there are more insns that should be scheduled.  */
  97
  98 static int
  99 schedule_more_p (void)
 100 {
 101   return sched_rgn_n_insns < rgn_n_insns;
 102 }
 103
 104 /* Print dependency information about ebb between HEAD and TAIL.  */
 105 static void
 106 debug_ebb_dependencies (rtx head, rtx tail)
 107 {
 108   fprintf (sched_dump,
 109            ";;   --------------- forward dependences: ------------ \n");
 110
 111   fprintf (sched_dump, "\n;;   --- EBB Dependences --- from bb%d to bb%d \n",
 112            BLOCK_NUM (head), BLOCK_NUM (tail));
 113
 114   debug_dependencies (head, tail);
 115 }
 116
 117 /* Add all insns that are initially ready to the ready list READY.  Called
 118    once before scheduling a set of insns.  */
 119
 120 static void
 121 init_ready_list (void)
 122 {
 123   int n = 0;
 124   rtx prev_head = current_sched_info->prev_head;
 125   rtx next_tail = current_sched_info->next_tail;
 126   rtx insn;
 127
 128   sched_rgn_n_insns = 0;
 129
 130   /* Print debugging information.  */
 131   if (sched_verbose >= 5)
 132     debug_ebb_dependencies (NEXT_INSN (prev_head), PREV_INSN (next_tail));
 133
 134   /* Initialize ready list with all 'ready' insns in target block.
 135      Count number of insns in the target block being scheduled.  */
 136   for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
 137     {
 138       try_ready (insn);
 139       n++;
 140     }
 141
 142   gcc_assert (n == rgn_n_insns);
 143 }
 144
 145 /* INSN is being scheduled after LAST.  Update counters.  */
 146 static void
 147 begin_schedule_ready (rtx insn ATTRIBUTE_UNUSED)
 148 {
 149   sched_rgn_n_insns++;
 150 }
 151
 152 /* INSN is being moved to its place in the schedule, after LAST.  */
 153 static void
 154 begin_move_insn (rtx insn, rtx last)
 155 {
 156   if (BLOCK_FOR_INSN (insn) == last_bb
 157       /* INSN is a jump in the last block, ...  */
 158       && control_flow_insn_p (insn)
 159       /* that is going to be moved over some instructions.  */
 160       && last != PREV_INSN (insn))
 161     {
 162       edge e;
 163       basic_block bb;
 164
 165       /* An obscure special case, where we do have partially dead
 166          instruction scheduled after last control flow instruction.
 167          In this case we can create new basic block.  It is
 168          always exactly one basic block last in the sequence.  */
 169
 170       e = find_fallthru_edge (last_bb->succs);
 171
 172       gcc_checking_assert (!e || !(e->flags & EDGE_COMPLEX));
 173
 174       gcc_checking_assert (BLOCK_FOR_INSN (insn) == last_bb
 175                            && !IS_SPECULATION_CHECK_P (insn)
 176                            && BB_HEAD (last_bb) != insn
 177                            && BB_END (last_bb) == insn);
 178
 179       {
 180         rtx x;
 181
 182         x = NEXT_INSN (insn);
 183         if (e)
 184           gcc_checking_assert (NOTE_P (x) || LABEL_P (x));
 185         else
 186           gcc_checking_assert (BARRIER_P (x));
 187       }
 188
 189       if (e)
 190         {
 191           bb = split_edge (e);
 192           gcc_assert (NOTE_INSN_BASIC_BLOCK_P (BB_END (bb)));
 193         }
 194       else
 195         /* Create an empty unreachable block after the INSN.  */
 196         bb = create_basic_block (NEXT_INSN (insn), NULL_RTX, last_bb);
 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 \f
 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                   dep_def _dep, *dep = &_dep;
 436
 437                   init_dep (dep, prev, insn, REG_DEP_ANTI);
 438
 439                   if (!(current_sched_info->flags & USE_DEPS_LIST))
 440                     {
 441                       enum DEPS_ADJUST_RESULT res;
 442
 443                       res = sd_add_or_update_dep (dep, false);
 444
 445                       /* We can't change an existing dependency with
 446                          DEP_ANTI.  */
 447                       gcc_assert (res != DEP_CHANGED);
 448                     }
 449                   else
 450                     {
 451                       if ((current_sched_info->flags & DO_SPECULATION)
 452                           && (spec_info->mask & BEGIN_CONTROL))
 453                         DEP_STATUS (dep) = set_dep_weak (DEP_ANTI, BEGIN_CONTROL,
 454                                                          MAX_DEP_WEAK);
 455
 456                       sd_add_or_update_dep (dep, false);
 457
 458                       /* Dep_status could have been changed.
 459                          No assertion here.  */
 460                     }
 461                 }
 462
 463               break;
 464
 465             default:
 466               break;
 467             }
 468         }
 469     }
 470   /* Maintain the invariant that bb->aux is clear after use.  */
 471   while (last_block)
 472     {
 473       bb = (basic_block) last_block->aux;
 474       last_block->aux = NULL;
 475       last_block = bb;
 476     }
 477 }
 478
 479 /* Schedule a single extended basic block, defined by the boundaries HEAD
 480    and TAIL.  */
 481
 482 static basic_block
 483 schedule_ebb (rtx head, rtx tail)
 484 {
 485   basic_block first_bb, target_bb;
 486   struct deps_desc tmp_deps;
 487
 488   first_bb = BLOCK_FOR_INSN (head);
 489   last_bb = BLOCK_FOR_INSN (tail);
 490
 491   if (no_real_insns_p (head, tail))
 492     return BLOCK_FOR_INSN (tail);
 493
 494   gcc_assert (INSN_P (head) && INSN_P (tail));
 495
 496   if (!bitmap_bit_p (&dont_calc_deps, first_bb->index))
 497     {
 498       init_deps_global ();
 499
 500       /* Compute dependencies.  */
 501       init_deps (&tmp_deps, false);
 502       sched_analyze (&tmp_deps, head, tail);
 503       free_deps (&tmp_deps);
 504
 505       add_deps_for_risky_insns (head, tail);
 506
 507       if (targetm.sched.dependencies_evaluation_hook)
 508         targetm.sched.dependencies_evaluation_hook (head, tail);
 509
 510       finish_deps_global ();
 511     }
 512   else
 513     /* Only recovery blocks can have their dependencies already calculated,
 514        and they always are single block ebbs.  */
 515     gcc_assert (first_bb == last_bb);
 516
 517   /* Set priorities.  */
 518   current_sched_info->sched_max_insns_priority = 0;
 519   rgn_n_insns = set_priorities (head, tail);
 520   current_sched_info->sched_max_insns_priority++;
 521
 522   current_sched_info->prev_head = PREV_INSN (head);
 523   current_sched_info->next_tail = NEXT_INSN (tail);
 524
 525   remove_notes (head, tail);
 526
 527   unlink_bb_notes (first_bb, last_bb);
 528
 529   target_bb = first_bb;
 530
 531   /* Make ready list big enough to hold all the instructions from the ebb.  */
 532   sched_extend_ready_list (rgn_n_insns);
 533   schedule_block (&target_bb);
 534   /* Free ready list.  */
 535   sched_finish_ready_list ();
 536
 537   /* We might pack all instructions into fewer blocks,
 538      so we may made some of them empty.  Can't assert (b == last_bb).  */
 539
 540   /* Sanity check: verify that all region insns were scheduled.  */
 541   gcc_assert (sched_rgn_n_insns == rgn_n_insns);
 542
 543   /* Free dependencies.  */
 544   sched_free_deps (current_sched_info->head, current_sched_info->tail, true);
 545
 546   gcc_assert (haifa_recovery_bb_ever_added_p
 547               || deps_pools_are_empty_p ());
 548
 549   if (EDGE_COUNT (last_bb->preds) == 0)
 550     /* LAST_BB is unreachable.  */
 551     {
 552       gcc_assert (first_bb != last_bb
 553                   && EDGE_COUNT (last_bb->succs) == 0);
 554       last_bb = last_bb->prev_bb;
 555       delete_basic_block (last_bb->next_bb);
 556     }
 557
 558   return last_bb;
 559 }
 560
 561 /* The one entry point in this file.  */
 562
 563 void
 564 schedule_ebbs (void)
 565 {
 566   basic_block bb;
 567   int probability_cutoff;
 568   rtx tail;
 569
 570   if (profile_info && flag_branch_probabilities)
 571     probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
 572   else
 573     probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
 574   probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
 575
 576   /* Taking care of this degenerate case makes the rest of
 577      this code simpler.  */
 578   if (n_basic_blocks == NUM_FIXED_BLOCKS)
 579     return;
 580
 581   /* Setup infos.  */
 582   {
 583     memcpy (&ebb_common_sched_info, &haifa_common_sched_info,
 584             sizeof (ebb_common_sched_info));
 585
 586     ebb_common_sched_info.fix_recovery_cfg = ebb_fix_recovery_cfg;
 587     ebb_common_sched_info.add_block = ebb_add_block;
 588     ebb_common_sched_info.sched_pass_id = SCHED_EBB_PASS;
 589
 590     common_sched_info = &ebb_common_sched_info;
 591     sched_deps_info = &ebb_sched_deps_info;
 592     current_sched_info = &ebb_sched_info;
 593   }
 594
 595   haifa_sched_init ();
 596
 597   compute_bb_for_insn ();
 598
 599   /* Initialize DONT_CALC_DEPS and ebb-{start, end} markers.  */
 600   bitmap_initialize (&dont_calc_deps, 0);
 601   bitmap_clear (&dont_calc_deps);
 602
 603   /* Schedule every region in the subroutine.  */
 604   FOR_EACH_BB (bb)
 605     {
 606       rtx head = BB_HEAD (bb);
 607
 608       if (bb->flags & BB_DISABLE_SCHEDULE)
 609         continue;
 610
 611       for (;;)
 612         {
 613           edge e;
 614           tail = BB_END (bb);
 615           if (bb->next_bb == EXIT_BLOCK_PTR
 616               || LABEL_P (BB_HEAD (bb->next_bb)))
 617             break;
 618           e = find_fallthru_edge (bb->succs);
 619           if (! e)
 620             break;
 621           if (e->probability <= probability_cutoff)
 622             break;
 623           if (e->dest->flags & BB_DISABLE_SCHEDULE)
 624             break;
 625           bb = bb->next_bb;
 626         }
 627
 628       /* Blah.  We should fix the rest of the code not to get confused by
 629          a note or two.  */
 630       while (head != tail)
 631         {
 632           if (NOTE_P (head) || DEBUG_INSN_P (head))
 633             head = NEXT_INSN (head);
 634           else if (NOTE_P (tail) || DEBUG_INSN_P (tail))
 635             tail = PREV_INSN (tail);
 636           else if (LABEL_P (head))
 637             head = NEXT_INSN (head);
 638           else
 639             break;
 640         }
 641
 642       bb = schedule_ebb (head, tail);
 643     }
 644   bitmap_clear (&dont_calc_deps);
 645
 646   /* Reposition the prologue and epilogue notes in case we moved the
 647      prologue/epilogue insns.  */
 648   if (reload_completed)
 649     reposition_prologue_and_epilogue_notes ();
 650
 651   haifa_sched_finish ();
 652 }
 653
 654 /* INSN has been added to/removed from current ebb.  */
 655 static void
 656 ebb_add_remove_insn (rtx insn ATTRIBUTE_UNUSED, int remove_p)
 657 {
 658   if (!remove_p)
 659     rgn_n_insns++;
 660   else
 661     rgn_n_insns--;
 662 }
 663
 664 /* BB was added to ebb after AFTER.  */
 665 static void
 666 ebb_add_block (basic_block bb, basic_block after)
 667 {
 668   /* Recovery blocks are always bounded by BARRIERS,
 669      therefore, they always form single block EBB,
 670      therefore, we can use rec->index to identify such EBBs.  */
 671   if (after == EXIT_BLOCK_PTR)
 672     bitmap_set_bit (&dont_calc_deps, bb->index);
 673   else if (after == last_bb)
 674     last_bb = bb;
 675 }
 676
 677 /* Return next block in ebb chain.  For parameter meaning please refer to
 678    sched-int.h: struct sched_info: advance_target_bb.  */
 679 static basic_block
 680 advance_target_bb (basic_block bb, rtx insn)
 681 {
 682   if (insn)
 683     {
 684       if (BLOCK_FOR_INSN (insn) != bb
 685           && control_flow_insn_p (insn)
 686           /* We handle interblock movement of the speculation check
 687              or over a speculation check in
 688              haifa-sched.c: move_block_after_check ().  */
 689           && !IS_SPECULATION_BRANCHY_CHECK_P (insn)
 690           && !IS_SPECULATION_BRANCHY_CHECK_P (BB_END (bb)))
 691         {
 692           /* Assert that we don't move jumps across blocks.  */
 693           gcc_assert (!control_flow_insn_p (BB_END (bb))
 694                       && NOTE_INSN_BASIC_BLOCK_P (BB_HEAD (bb->next_bb)));
 695           return bb;
 696         }
 697       else
 698         return 0;
 699     }
 700   else
 701     /* Return next non empty block.  */
 702     {
 703       do
 704         {
 705           gcc_assert (bb != last_bb);
 706
 707           bb = bb->next_bb;
 708         }
 709       while (bb_note (bb) == BB_END (bb));
 710
 711       return bb;
 712     }
 713 }
 714
 715 /* Fix internal data after interblock movement of jump instruction.
 716    For parameter meaning please refer to
 717    sched-int.h: struct sched_info: fix_recovery_cfg.  */
 718 static void
 719 ebb_fix_recovery_cfg (int bbi ATTRIBUTE_UNUSED, int jump_bbi,
 720                       int jump_bb_nexti)
 721 {
 722   gcc_assert (last_bb->index != bbi);
 723
 724   if (jump_bb_nexti == last_bb->index)
 725     last_bb = BASIC_BLOCK (jump_bbi);
 726 }
 727
 728 #endif /* INSN_SCHEDULING */