contrib/gcc-5.0/gcc/sched-ebb.c

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