gcc/sched-ebb.c

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