/* Instruction scheduling pass.
|
/* Instruction scheduling pass.
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
1999, 2000, 2001, 2002, 2003, 2004, 2007
|
1999, 2000, 2001, 2002, 2003, 2004, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
|
Contributed by Michael Tiemann (tiemann@cygnus.com) Enhanced by,
|
and currently maintained by, Jim Wilson (wilson@cygnus.com)
|
and currently maintained by, Jim Wilson (wilson@cygnus.com)
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "function.h"
|
#include "function.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "insn-config.h"
|
#include "insn-config.h"
|
#include "insn-attr.h"
|
#include "insn-attr.h"
|
#include "except.h"
|
#include "except.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "recog.h"
|
#include "recog.h"
|
#include "cfglayout.h"
|
#include "cfglayout.h"
|
#include "params.h"
|
#include "params.h"
|
#include "sched-int.h"
|
#include "sched-int.h"
|
#include "target.h"
|
#include "target.h"
|
#include "output.h"
|
#include "output.h"
|
|
|
/* The number of insns scheduled so far. */
|
/* The number of insns scheduled so far. */
|
static int sched_n_insns;
|
static int sched_n_insns;
|
|
|
/* The number of insns to be scheduled in total. */
|
/* The number of insns to be scheduled in total. */
|
static int n_insns;
|
static int n_insns;
|
|
|
/* Set of blocks, that already have their dependencies calculated. */
|
/* Set of blocks, that already have their dependencies calculated. */
|
static bitmap_head dont_calc_deps;
|
static bitmap_head dont_calc_deps;
|
/* Set of basic blocks, that are ebb heads of tails respectively. */
|
/* Set of basic blocks, that are ebb heads of tails respectively. */
|
static bitmap_head ebb_head, ebb_tail;
|
static bitmap_head ebb_head, ebb_tail;
|
|
|
/* Last basic block in current ebb. */
|
/* Last basic block in current ebb. */
|
static basic_block last_bb;
|
static basic_block last_bb;
|
|
|
/* Implementations of the sched_info functions for region scheduling. */
|
/* Implementations of the sched_info functions for region scheduling. */
|
static void init_ready_list (void);
|
static void init_ready_list (void);
|
static void begin_schedule_ready (rtx, rtx);
|
static void begin_schedule_ready (rtx, rtx);
|
static int schedule_more_p (void);
|
static int schedule_more_p (void);
|
static const char *ebb_print_insn (rtx, int);
|
static const char *ebb_print_insn (rtx, int);
|
static int rank (rtx, rtx);
|
static int rank (rtx, rtx);
|
static int contributes_to_priority (rtx, rtx);
|
static int contributes_to_priority (rtx, rtx);
|
static void compute_jump_reg_dependencies (rtx, regset, regset, regset);
|
static void compute_jump_reg_dependencies (rtx, regset, regset, regset);
|
static basic_block earliest_block_with_similiar_load (basic_block, rtx);
|
static basic_block earliest_block_with_similiar_load (basic_block, rtx);
|
static void add_deps_for_risky_insns (rtx, rtx);
|
static void add_deps_for_risky_insns (rtx, rtx);
|
static basic_block schedule_ebb (rtx, rtx);
|
static basic_block schedule_ebb (rtx, rtx);
|
|
|
static void add_remove_insn (rtx, int);
|
static void add_remove_insn (rtx, int);
|
static void add_block1 (basic_block, basic_block);
|
static void add_block1 (basic_block, basic_block);
|
static basic_block advance_target_bb (basic_block, rtx);
|
static basic_block advance_target_bb (basic_block, rtx);
|
static void fix_recovery_cfg (int, int, int);
|
static void fix_recovery_cfg (int, int, int);
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
static int ebb_head_or_leaf_p (basic_block, int);
|
static int ebb_head_or_leaf_p (basic_block, int);
|
#endif
|
#endif
|
|
|
/* Return nonzero if there are more insns that should be scheduled. */
|
/* Return nonzero if there are more insns that should be scheduled. */
|
|
|
static int
|
static int
|
schedule_more_p (void)
|
schedule_more_p (void)
|
{
|
{
|
return sched_n_insns < n_insns;
|
return sched_n_insns < n_insns;
|
}
|
}
|
|
|
/* Add all insns that are initially ready to the ready list READY. Called
|
/* Add all insns that are initially ready to the ready list READY. Called
|
once before scheduling a set of insns. */
|
once before scheduling a set of insns. */
|
|
|
static void
|
static void
|
init_ready_list (void)
|
init_ready_list (void)
|
{
|
{
|
int n = 0;
|
int n = 0;
|
rtx prev_head = current_sched_info->prev_head;
|
rtx prev_head = current_sched_info->prev_head;
|
rtx next_tail = current_sched_info->next_tail;
|
rtx next_tail = current_sched_info->next_tail;
|
rtx insn;
|
rtx insn;
|
|
|
sched_n_insns = 0;
|
sched_n_insns = 0;
|
|
|
#if 0
|
#if 0
|
/* Print debugging information. */
|
/* Print debugging information. */
|
if (sched_verbose >= 5)
|
if (sched_verbose >= 5)
|
debug_dependencies ();
|
debug_dependencies ();
|
#endif
|
#endif
|
|
|
/* Initialize ready list with all 'ready' insns in target block.
|
/* Initialize ready list with all 'ready' insns in target block.
|
Count number of insns in the target block being scheduled. */
|
Count number of insns in the target block being scheduled. */
|
for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
|
for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
|
{
|
{
|
try_ready (insn);
|
try_ready (insn);
|
n++;
|
n++;
|
}
|
}
|
|
|
gcc_assert (n == n_insns);
|
gcc_assert (n == n_insns);
|
}
|
}
|
|
|
/* INSN is being scheduled after LAST. Update counters. */
|
/* INSN is being scheduled after LAST. Update counters. */
|
static void
|
static void
|
begin_schedule_ready (rtx insn, rtx last)
|
begin_schedule_ready (rtx insn, rtx last)
|
{
|
{
|
sched_n_insns++;
|
sched_n_insns++;
|
|
|
if (BLOCK_FOR_INSN (insn) == last_bb
|
if (BLOCK_FOR_INSN (insn) == last_bb
|
/* INSN is a jump in the last block, ... */
|
/* INSN is a jump in the last block, ... */
|
&& control_flow_insn_p (insn)
|
&& control_flow_insn_p (insn)
|
/* that is going to be moved over some instructions. */
|
/* that is going to be moved over some instructions. */
|
&& last != PREV_INSN (insn))
|
&& last != PREV_INSN (insn))
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
basic_block bb;
|
basic_block bb;
|
|
|
/* An obscure special case, where we do have partially dead
|
/* An obscure special case, where we do have partially dead
|
instruction scheduled after last control flow instruction.
|
instruction scheduled after last control flow instruction.
|
In this case we can create new basic block. It is
|
In this case we can create new basic block. It is
|
always exactly one basic block last in the sequence. */
|
always exactly one basic block last in the sequence. */
|
|
|
FOR_EACH_EDGE (e, ei, last_bb->succs)
|
FOR_EACH_EDGE (e, ei, last_bb->succs)
|
if (e->flags & EDGE_FALLTHRU)
|
if (e->flags & EDGE_FALLTHRU)
|
break;
|
break;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (!e || !(e->flags & EDGE_COMPLEX));
|
gcc_assert (!e || !(e->flags & EDGE_COMPLEX));
|
|
|
gcc_assert (BLOCK_FOR_INSN (insn) == last_bb
|
gcc_assert (BLOCK_FOR_INSN (insn) == last_bb
|
&& !IS_SPECULATION_CHECK_P (insn)
|
&& !IS_SPECULATION_CHECK_P (insn)
|
&& BB_HEAD (last_bb) != insn
|
&& BB_HEAD (last_bb) != insn
|
&& BB_END (last_bb) == insn);
|
&& BB_END (last_bb) == insn);
|
|
|
{
|
{
|
rtx x;
|
rtx x;
|
|
|
x = NEXT_INSN (insn);
|
x = NEXT_INSN (insn);
|
if (e)
|
if (e)
|
gcc_assert (NOTE_P (x) || LABEL_P (x));
|
gcc_assert (NOTE_P (x) || LABEL_P (x));
|
else
|
else
|
gcc_assert (BARRIER_P (x));
|
gcc_assert (BARRIER_P (x));
|
}
|
}
|
#endif
|
#endif
|
|
|
if (e)
|
if (e)
|
{
|
{
|
bb = split_edge (e);
|
bb = split_edge (e);
|
gcc_assert (NOTE_INSN_BASIC_BLOCK_P (BB_END (bb)));
|
gcc_assert (NOTE_INSN_BASIC_BLOCK_P (BB_END (bb)));
|
}
|
}
|
else
|
else
|
/* Create an empty unreachable block after the INSN. */
|
/* Create an empty unreachable block after the INSN. */
|
bb = create_basic_block (NEXT_INSN (insn), NULL_RTX, last_bb);
|
bb = create_basic_block (NEXT_INSN (insn), NULL_RTX, last_bb);
|
|
|
/* split_edge () creates BB before E->DEST. Keep in mind, that
|
/* split_edge () creates BB before E->DEST. Keep in mind, that
|
this operation extends scheduling region till the end of BB.
|
this operation extends scheduling region till the end of BB.
|
Hence, we need to shift NEXT_TAIL, so haifa-sched.c won't go out
|
Hence, we need to shift NEXT_TAIL, so haifa-sched.c won't go out
|
of the scheduling region. */
|
of the scheduling region. */
|
current_sched_info->next_tail = NEXT_INSN (BB_END (bb));
|
current_sched_info->next_tail = NEXT_INSN (BB_END (bb));
|
gcc_assert (current_sched_info->next_tail);
|
gcc_assert (current_sched_info->next_tail);
|
|
|
add_block (bb, last_bb);
|
add_block (bb, last_bb);
|
gcc_assert (last_bb == bb);
|
gcc_assert (last_bb == bb);
|
}
|
}
|
}
|
}
|
|
|
/* Return a string that contains the insn uid and optionally anything else
|
/* Return a string that contains the insn uid and optionally anything else
|
necessary to identify this insn in an output. It's valid to use a
|
necessary to identify this insn in an output. It's valid to use a
|
static buffer for this. The ALIGNED parameter should cause the string
|
static buffer for this. The ALIGNED parameter should cause the string
|
to be formatted so that multiple output lines will line up nicely. */
|
to be formatted so that multiple output lines will line up nicely. */
|
|
|
static const char *
|
static const char *
|
ebb_print_insn (rtx insn, int aligned ATTRIBUTE_UNUSED)
|
ebb_print_insn (rtx insn, int aligned ATTRIBUTE_UNUSED)
|
{
|
{
|
static char tmp[80];
|
static char tmp[80];
|
|
|
sprintf (tmp, "%4d", INSN_UID (insn));
|
sprintf (tmp, "%4d", INSN_UID (insn));
|
return tmp;
|
return tmp;
|
}
|
}
|
|
|
/* Compare priority of two insns. Return a positive number if the second
|
/* Compare priority of two insns. Return a positive number if the second
|
insn is to be preferred for scheduling, and a negative one if the first
|
insn is to be preferred for scheduling, and a negative one if the first
|
is to be preferred. Zero if they are equally good. */
|
is to be preferred. Zero if they are equally good. */
|
|
|
static int
|
static int
|
rank (rtx insn1, rtx insn2)
|
rank (rtx insn1, rtx insn2)
|
{
|
{
|
basic_block bb1 = BLOCK_FOR_INSN (insn1);
|
basic_block bb1 = BLOCK_FOR_INSN (insn1);
|
basic_block bb2 = BLOCK_FOR_INSN (insn2);
|
basic_block bb2 = BLOCK_FOR_INSN (insn2);
|
|
|
if (bb1->count > bb2->count
|
if (bb1->count > bb2->count
|
|| bb1->frequency > bb2->frequency)
|
|| bb1->frequency > bb2->frequency)
|
return -1;
|
return -1;
|
if (bb1->count < bb2->count
|
if (bb1->count < bb2->count
|
|| bb1->frequency < bb2->frequency)
|
|| bb1->frequency < bb2->frequency)
|
return 1;
|
return 1;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* NEXT is an instruction that depends on INSN (a backward dependence);
|
/* NEXT is an instruction that depends on INSN (a backward dependence);
|
return nonzero if we should include this dependence in priority
|
return nonzero if we should include this dependence in priority
|
calculations. */
|
calculations. */
|
|
|
static int
|
static int
|
contributes_to_priority (rtx next ATTRIBUTE_UNUSED,
|
contributes_to_priority (rtx next ATTRIBUTE_UNUSED,
|
rtx insn ATTRIBUTE_UNUSED)
|
rtx insn ATTRIBUTE_UNUSED)
|
{
|
{
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* INSN is a JUMP_INSN, COND_SET is the set of registers that are
|
/* INSN is a JUMP_INSN, COND_SET is the set of registers that are
|
conditionally set before INSN. Store the set of registers that
|
conditionally set before INSN. Store the set of registers that
|
must be considered as used by this jump in USED and that of
|
must be considered as used by this jump in USED and that of
|
registers that must be considered as set in SET. */
|
registers that must be considered as set in SET. */
|
|
|
static void
|
static void
|
compute_jump_reg_dependencies (rtx insn, regset cond_set, regset used,
|
compute_jump_reg_dependencies (rtx insn, regset cond_set, regset used,
|
regset set)
|
regset set)
|
{
|
{
|
basic_block b = BLOCK_FOR_INSN (insn);
|
basic_block b = BLOCK_FOR_INSN (insn);
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
|
|
FOR_EACH_EDGE (e, ei, b->succs)
|
FOR_EACH_EDGE (e, ei, b->succs)
|
if (e->flags & EDGE_FALLTHRU)
|
if (e->flags & EDGE_FALLTHRU)
|
/* The jump may be a by-product of a branch that has been merged
|
/* The jump may be a by-product of a branch that has been merged
|
in the main codepath after being conditionalized. Therefore
|
in the main codepath after being conditionalized. Therefore
|
it may guard the fallthrough block from using a value that has
|
it may guard the fallthrough block from using a value that has
|
conditionally overwritten that of the main codepath. So we
|
conditionally overwritten that of the main codepath. So we
|
consider that it restores the value of the main codepath. */
|
consider that it restores the value of the main codepath. */
|
bitmap_and (set, glat_start [e->dest->index], cond_set);
|
bitmap_and (set, glat_start [e->dest->index], cond_set);
|
else
|
else
|
bitmap_ior_into (used, glat_start [e->dest->index]);
|
bitmap_ior_into (used, glat_start [e->dest->index]);
|
}
|
}
|
|
|
/* Used in schedule_insns to initialize current_sched_info for scheduling
|
/* Used in schedule_insns to initialize current_sched_info for scheduling
|
regions (or single basic blocks). */
|
regions (or single basic blocks). */
|
|
|
static struct sched_info ebb_sched_info =
|
static struct sched_info ebb_sched_info =
|
{
|
{
|
init_ready_list,
|
init_ready_list,
|
NULL,
|
NULL,
|
schedule_more_p,
|
schedule_more_p,
|
NULL,
|
NULL,
|
rank,
|
rank,
|
ebb_print_insn,
|
ebb_print_insn,
|
contributes_to_priority,
|
contributes_to_priority,
|
compute_jump_reg_dependencies,
|
compute_jump_reg_dependencies,
|
|
|
NULL, NULL,
|
NULL, NULL,
|
NULL, NULL,
|
NULL, NULL,
|
0, 1, 0,
|
0, 1, 0,
|
|
|
add_remove_insn,
|
add_remove_insn,
|
begin_schedule_ready,
|
begin_schedule_ready,
|
add_block1,
|
add_block1,
|
advance_target_bb,
|
advance_target_bb,
|
fix_recovery_cfg,
|
fix_recovery_cfg,
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
ebb_head_or_leaf_p,
|
ebb_head_or_leaf_p,
|
#endif
|
#endif
|
/* We need to DETACH_LIVE_INFO to be able to create new basic blocks.
|
/* We need to DETACH_LIVE_INFO to be able to create new basic blocks.
|
See begin_schedule_ready (). */
|
See begin_schedule_ready (). */
|
SCHED_EBB | USE_GLAT | DETACH_LIFE_INFO
|
SCHED_EBB | USE_GLAT | DETACH_LIFE_INFO
|
};
|
};
|
|
|
/* Returns the earliest block in EBB currently being processed where a
|
/* Returns the earliest block in EBB currently being processed where a
|
"similar load" 'insn2' is found, and hence LOAD_INSN can move
|
"similar load" 'insn2' is found, and hence LOAD_INSN can move
|
speculatively into the found block. All the following must hold:
|
speculatively into the found block. All the following must hold:
|
|
|
(1) both loads have 1 base register (PFREE_CANDIDATEs).
|
(1) both loads have 1 base register (PFREE_CANDIDATEs).
|
(2) load_insn and load2 have a def-use dependence upon
|
(2) load_insn and load2 have a def-use dependence upon
|
the same insn 'insn1'.
|
the same insn 'insn1'.
|
|
|
From all these we can conclude that the two loads access memory
|
From all these we can conclude that the two loads access memory
|
addresses that differ at most by a constant, and hence if moving
|
addresses that differ at most by a constant, and hence if moving
|
load_insn would cause an exception, it would have been caused by
|
load_insn would cause an exception, it would have been caused by
|
load2 anyhow.
|
load2 anyhow.
|
|
|
The function uses list (given by LAST_BLOCK) of already processed
|
The function uses list (given by LAST_BLOCK) of already processed
|
blocks in EBB. The list is formed in `add_deps_for_risky_insns'. */
|
blocks in EBB. The list is formed in `add_deps_for_risky_insns'. */
|
|
|
static basic_block
|
static basic_block
|
earliest_block_with_similiar_load (basic_block last_block, rtx load_insn)
|
earliest_block_with_similiar_load (basic_block last_block, rtx load_insn)
|
{
|
{
|
rtx back_link;
|
rtx back_link;
|
basic_block bb, earliest_block = NULL;
|
basic_block bb, earliest_block = NULL;
|
|
|
for (back_link = LOG_LINKS (load_insn);
|
for (back_link = LOG_LINKS (load_insn);
|
back_link;
|
back_link;
|
back_link = XEXP (back_link, 1))
|
back_link = XEXP (back_link, 1))
|
{
|
{
|
rtx insn1 = XEXP (back_link, 0);
|
rtx insn1 = XEXP (back_link, 0);
|
|
|
if (GET_MODE (back_link) == VOIDmode)
|
if (GET_MODE (back_link) == VOIDmode)
|
{
|
{
|
/* Found a DEF-USE dependence (insn1, load_insn). */
|
/* Found a DEF-USE dependence (insn1, load_insn). */
|
rtx fore_link;
|
rtx fore_link;
|
|
|
for (fore_link = INSN_DEPEND (insn1);
|
for (fore_link = INSN_DEPEND (insn1);
|
fore_link;
|
fore_link;
|
fore_link = XEXP (fore_link, 1))
|
fore_link = XEXP (fore_link, 1))
|
{
|
{
|
rtx insn2 = XEXP (fore_link, 0);
|
rtx insn2 = XEXP (fore_link, 0);
|
basic_block insn2_block = BLOCK_FOR_INSN (insn2);
|
basic_block insn2_block = BLOCK_FOR_INSN (insn2);
|
|
|
if (GET_MODE (fore_link) == VOIDmode)
|
if (GET_MODE (fore_link) == VOIDmode)
|
{
|
{
|
if (earliest_block != NULL
|
if (earliest_block != NULL
|
&& earliest_block->index < insn2_block->index)
|
&& earliest_block->index < insn2_block->index)
|
continue;
|
continue;
|
|
|
/* Found a DEF-USE dependence (insn1, insn2). */
|
/* Found a DEF-USE dependence (insn1, insn2). */
|
if (haifa_classify_insn (insn2) != PFREE_CANDIDATE)
|
if (haifa_classify_insn (insn2) != PFREE_CANDIDATE)
|
/* insn2 not guaranteed to be a 1 base reg load. */
|
/* insn2 not guaranteed to be a 1 base reg load. */
|
continue;
|
continue;
|
|
|
for (bb = last_block; bb; bb = bb->aux)
|
for (bb = last_block; bb; bb = bb->aux)
|
if (insn2_block == bb)
|
if (insn2_block == bb)
|
break;
|
break;
|
|
|
if (!bb)
|
if (!bb)
|
/* insn2 is the similar load. */
|
/* insn2 is the similar load. */
|
earliest_block = insn2_block;
|
earliest_block = insn2_block;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return earliest_block;
|
return earliest_block;
|
}
|
}
|
|
|
/* The following function adds dependencies between jumps and risky
|
/* The following function adds dependencies between jumps and risky
|
insns in given ebb. */
|
insns in given ebb. */
|
|
|
static void
|
static void
|
add_deps_for_risky_insns (rtx head, rtx tail)
|
add_deps_for_risky_insns (rtx head, rtx tail)
|
{
|
{
|
rtx insn, prev;
|
rtx insn, prev;
|
int class;
|
int class;
|
rtx last_jump = NULL_RTX;
|
rtx last_jump = NULL_RTX;
|
rtx next_tail = NEXT_INSN (tail);
|
rtx next_tail = NEXT_INSN (tail);
|
basic_block last_block = NULL, bb;
|
basic_block last_block = NULL, bb;
|
|
|
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
|
for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
|
if (control_flow_insn_p (insn))
|
if (control_flow_insn_p (insn))
|
{
|
{
|
bb = BLOCK_FOR_INSN (insn);
|
bb = BLOCK_FOR_INSN (insn);
|
bb->aux = last_block;
|
bb->aux = last_block;
|
last_block = bb;
|
last_block = bb;
|
last_jump = insn;
|
last_jump = insn;
|
}
|
}
|
else if (INSN_P (insn) && last_jump != NULL_RTX)
|
else if (INSN_P (insn) && last_jump != NULL_RTX)
|
{
|
{
|
class = haifa_classify_insn (insn);
|
class = haifa_classify_insn (insn);
|
prev = last_jump;
|
prev = last_jump;
|
switch (class)
|
switch (class)
|
{
|
{
|
case PFREE_CANDIDATE:
|
case PFREE_CANDIDATE:
|
if (flag_schedule_speculative_load)
|
if (flag_schedule_speculative_load)
|
{
|
{
|
bb = earliest_block_with_similiar_load (last_block, insn);
|
bb = earliest_block_with_similiar_load (last_block, insn);
|
if (bb)
|
if (bb)
|
{
|
{
|
bb = bb->aux;
|
bb = bb->aux;
|
if (!bb)
|
if (!bb)
|
break;
|
break;
|
prev = BB_END (bb);
|
prev = BB_END (bb);
|
}
|
}
|
}
|
}
|
/* Fall through. */
|
/* Fall through. */
|
case TRAP_RISKY:
|
case TRAP_RISKY:
|
case IRISKY:
|
case IRISKY:
|
case PRISKY_CANDIDATE:
|
case PRISKY_CANDIDATE:
|
/* ??? We could implement better checking PRISKY_CANDIDATEs
|
/* ??? We could implement better checking PRISKY_CANDIDATEs
|
analogous to sched-rgn.c. */
|
analogous to sched-rgn.c. */
|
/* We can not change the mode of the backward
|
/* We can not change the mode of the backward
|
dependency because REG_DEP_ANTI has the lowest
|
dependency because REG_DEP_ANTI has the lowest
|
rank. */
|
rank. */
|
if (! sched_insns_conditions_mutex_p (insn, prev))
|
if (! sched_insns_conditions_mutex_p (insn, prev))
|
{
|
{
|
if (!(current_sched_info->flags & DO_SPECULATION))
|
if (!(current_sched_info->flags & DO_SPECULATION))
|
{
|
{
|
enum DEPS_ADJUST_RESULT res;
|
enum DEPS_ADJUST_RESULT res;
|
|
|
res = add_or_update_back_dep (insn, prev,
|
res = add_or_update_back_dep (insn, prev,
|
REG_DEP_ANTI, DEP_ANTI);
|
REG_DEP_ANTI, DEP_ANTI);
|
|
|
if (res == DEP_CREATED)
|
if (res == DEP_CREATED)
|
add_forw_dep (insn, LOG_LINKS (insn));
|
add_forw_dep (insn, LOG_LINKS (insn));
|
else
|
else
|
gcc_assert (res != DEP_CHANGED);
|
gcc_assert (res != DEP_CHANGED);
|
}
|
}
|
else
|
else
|
add_or_update_back_forw_dep (insn, prev, REG_DEP_ANTI,
|
add_or_update_back_forw_dep (insn, prev, REG_DEP_ANTI,
|
set_dep_weak (DEP_ANTI,
|
set_dep_weak (DEP_ANTI,
|
BEGIN_CONTROL,
|
BEGIN_CONTROL,
|
MAX_DEP_WEAK));
|
MAX_DEP_WEAK));
|
}
|
}
|
|
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
}
|
}
|
/* Maintain the invariant that bb->aux is clear after use. */
|
/* Maintain the invariant that bb->aux is clear after use. */
|
while (last_block)
|
while (last_block)
|
{
|
{
|
bb = last_block->aux;
|
bb = last_block->aux;
|
last_block->aux = NULL;
|
last_block->aux = NULL;
|
last_block = bb;
|
last_block = bb;
|
}
|
}
|
}
|
}
|
|
|
/* Schedule a single extended basic block, defined by the boundaries HEAD
|
/* Schedule a single extended basic block, defined by the boundaries HEAD
|
and TAIL. */
|
and TAIL. */
|
|
|
static basic_block
|
static basic_block
|
schedule_ebb (rtx head, rtx tail)
|
schedule_ebb (rtx head, rtx tail)
|
{
|
{
|
basic_block first_bb, target_bb;
|
basic_block first_bb, target_bb;
|
struct deps tmp_deps;
|
struct deps tmp_deps;
|
|
|
first_bb = BLOCK_FOR_INSN (head);
|
first_bb = BLOCK_FOR_INSN (head);
|
last_bb = BLOCK_FOR_INSN (tail);
|
last_bb = BLOCK_FOR_INSN (tail);
|
|
|
if (no_real_insns_p (head, tail))
|
if (no_real_insns_p (head, tail))
|
return BLOCK_FOR_INSN (tail);
|
return BLOCK_FOR_INSN (tail);
|
|
|
gcc_assert (INSN_P (head) && INSN_P (tail));
|
gcc_assert (INSN_P (head) && INSN_P (tail));
|
|
|
if (!bitmap_bit_p (&dont_calc_deps, first_bb->index))
|
if (!bitmap_bit_p (&dont_calc_deps, first_bb->index))
|
{
|
{
|
init_deps_global ();
|
init_deps_global ();
|
|
|
/* Compute LOG_LINKS. */
|
/* Compute LOG_LINKS. */
|
init_deps (&tmp_deps);
|
init_deps (&tmp_deps);
|
sched_analyze (&tmp_deps, head, tail);
|
sched_analyze (&tmp_deps, head, tail);
|
free_deps (&tmp_deps);
|
free_deps (&tmp_deps);
|
|
|
/* Compute INSN_DEPEND. */
|
/* Compute INSN_DEPEND. */
|
compute_forward_dependences (head, tail);
|
compute_forward_dependences (head, tail);
|
|
|
add_deps_for_risky_insns (head, tail);
|
add_deps_for_risky_insns (head, tail);
|
|
|
if (targetm.sched.dependencies_evaluation_hook)
|
if (targetm.sched.dependencies_evaluation_hook)
|
targetm.sched.dependencies_evaluation_hook (head, tail);
|
targetm.sched.dependencies_evaluation_hook (head, tail);
|
|
|
finish_deps_global ();
|
finish_deps_global ();
|
}
|
}
|
else
|
else
|
/* Only recovery blocks can have their dependencies already calculated,
|
/* Only recovery blocks can have their dependencies already calculated,
|
and they always are single block ebbs. */
|
and they always are single block ebbs. */
|
gcc_assert (first_bb == last_bb);
|
gcc_assert (first_bb == last_bb);
|
|
|
/* Set priorities. */
|
/* Set priorities. */
|
current_sched_info->sched_max_insns_priority = 0;
|
current_sched_info->sched_max_insns_priority = 0;
|
n_insns = set_priorities (head, tail);
|
n_insns = set_priorities (head, tail);
|
current_sched_info->sched_max_insns_priority++;
|
current_sched_info->sched_max_insns_priority++;
|
|
|
current_sched_info->prev_head = PREV_INSN (head);
|
current_sched_info->prev_head = PREV_INSN (head);
|
current_sched_info->next_tail = NEXT_INSN (tail);
|
current_sched_info->next_tail = NEXT_INSN (tail);
|
|
|
if (write_symbols != NO_DEBUG)
|
if (write_symbols != NO_DEBUG)
|
{
|
{
|
save_line_notes (first_bb->index, head, tail);
|
save_line_notes (first_bb->index, head, tail);
|
rm_line_notes (head, tail);
|
rm_line_notes (head, tail);
|
}
|
}
|
|
|
/* rm_other_notes only removes notes which are _inside_ the
|
/* rm_other_notes only removes notes which are _inside_ the
|
block---that is, it won't remove notes before the first real insn
|
block---that is, it won't remove notes before the first real insn
|
or after the last real insn of the block. So if the first insn
|
or after the last real insn of the block. So if the first insn
|
has a REG_SAVE_NOTE which would otherwise be emitted before the
|
has a REG_SAVE_NOTE which would otherwise be emitted before the
|
insn, it is redundant with the note before the start of the
|
insn, it is redundant with the note before the start of the
|
block, and so we have to take it out. */
|
block, and so we have to take it out. */
|
if (INSN_P (head))
|
if (INSN_P (head))
|
{
|
{
|
rtx note;
|
rtx note;
|
|
|
for (note = REG_NOTES (head); note; note = XEXP (note, 1))
|
for (note = REG_NOTES (head); note; note = XEXP (note, 1))
|
if (REG_NOTE_KIND (note) == REG_SAVE_NOTE)
|
if (REG_NOTE_KIND (note) == REG_SAVE_NOTE)
|
remove_note (head, note);
|
remove_note (head, note);
|
}
|
}
|
|
|
/* Remove remaining note insns from the block, save them in
|
/* Remove remaining note insns from the block, save them in
|
note_list. These notes are restored at the end of
|
note_list. These notes are restored at the end of
|
schedule_block (). */
|
schedule_block (). */
|
rm_other_notes (head, tail);
|
rm_other_notes (head, tail);
|
|
|
unlink_bb_notes (first_bb, last_bb);
|
unlink_bb_notes (first_bb, last_bb);
|
|
|
current_sched_info->queue_must_finish_empty = 1;
|
current_sched_info->queue_must_finish_empty = 1;
|
|
|
target_bb = first_bb;
|
target_bb = first_bb;
|
schedule_block (&target_bb, n_insns);
|
schedule_block (&target_bb, n_insns);
|
|
|
/* We might pack all instructions into fewer blocks,
|
/* We might pack all instructions into fewer blocks,
|
so we may made some of them empty. Can't assert (b == last_bb). */
|
so we may made some of them empty. Can't assert (b == last_bb). */
|
|
|
/* Sanity check: verify that all region insns were scheduled. */
|
/* Sanity check: verify that all region insns were scheduled. */
|
gcc_assert (sched_n_insns == n_insns);
|
gcc_assert (sched_n_insns == n_insns);
|
head = current_sched_info->head;
|
head = current_sched_info->head;
|
tail = current_sched_info->tail;
|
tail = current_sched_info->tail;
|
|
|
if (write_symbols != NO_DEBUG)
|
if (write_symbols != NO_DEBUG)
|
restore_line_notes (head, tail);
|
restore_line_notes (head, tail);
|
|
|
if (EDGE_COUNT (last_bb->preds) == 0)
|
if (EDGE_COUNT (last_bb->preds) == 0)
|
/* LAST_BB is unreachable. */
|
/* LAST_BB is unreachable. */
|
{
|
{
|
gcc_assert (first_bb != last_bb
|
gcc_assert (first_bb != last_bb
|
&& EDGE_COUNT (last_bb->succs) == 0);
|
&& EDGE_COUNT (last_bb->succs) == 0);
|
last_bb = last_bb->prev_bb;
|
last_bb = last_bb->prev_bb;
|
delete_basic_block (last_bb->next_bb);
|
delete_basic_block (last_bb->next_bb);
|
}
|
}
|
|
|
return last_bb;
|
return last_bb;
|
}
|
}
|
|
|
/* The one entry point in this file. */
|
/* The one entry point in this file. */
|
|
|
void
|
void
|
schedule_ebbs (void)
|
schedule_ebbs (void)
|
{
|
{
|
basic_block bb;
|
basic_block bb;
|
int probability_cutoff;
|
int probability_cutoff;
|
rtx tail;
|
rtx tail;
|
sbitmap large_region_blocks, blocks;
|
sbitmap large_region_blocks, blocks;
|
int any_large_regions;
|
int any_large_regions;
|
|
|
if (profile_info && flag_branch_probabilities)
|
if (profile_info && flag_branch_probabilities)
|
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
|
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY_FEEDBACK);
|
else
|
else
|
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
|
probability_cutoff = PARAM_VALUE (TRACER_MIN_BRANCH_PROBABILITY);
|
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
|
probability_cutoff = REG_BR_PROB_BASE / 100 * probability_cutoff;
|
|
|
/* Taking care of this degenerate case makes the rest of
|
/* Taking care of this degenerate case makes the rest of
|
this code simpler. */
|
this code simpler. */
|
if (n_basic_blocks == NUM_FIXED_BLOCKS)
|
if (n_basic_blocks == NUM_FIXED_BLOCKS)
|
return;
|
return;
|
|
|
/* We need current_sched_info in init_dependency_caches, which is
|
/* We need current_sched_info in init_dependency_caches, which is
|
invoked via sched_init. */
|
invoked via sched_init. */
|
current_sched_info = &ebb_sched_info;
|
current_sched_info = &ebb_sched_info;
|
|
|
sched_init ();
|
sched_init ();
|
|
|
compute_bb_for_insn ();
|
compute_bb_for_insn ();
|
|
|
/* Initialize DONT_CALC_DEPS and ebb-{start, end} markers. */
|
/* Initialize DONT_CALC_DEPS and ebb-{start, end} markers. */
|
bitmap_initialize (&dont_calc_deps, 0);
|
bitmap_initialize (&dont_calc_deps, 0);
|
bitmap_clear (&dont_calc_deps);
|
bitmap_clear (&dont_calc_deps);
|
bitmap_initialize (&ebb_head, 0);
|
bitmap_initialize (&ebb_head, 0);
|
bitmap_clear (&ebb_head);
|
bitmap_clear (&ebb_head);
|
bitmap_initialize (&ebb_tail, 0);
|
bitmap_initialize (&ebb_tail, 0);
|
bitmap_clear (&ebb_tail);
|
bitmap_clear (&ebb_tail);
|
|
|
/* Schedule every region in the subroutine. */
|
/* Schedule every region in the subroutine. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
rtx head = BB_HEAD (bb);
|
rtx head = BB_HEAD (bb);
|
|
|
for (;;)
|
for (;;)
|
{
|
{
|
edge e;
|
edge e;
|
edge_iterator ei;
|
edge_iterator ei;
|
tail = BB_END (bb);
|
tail = BB_END (bb);
|
if (bb->next_bb == EXIT_BLOCK_PTR
|
if (bb->next_bb == EXIT_BLOCK_PTR
|
|| LABEL_P (BB_HEAD (bb->next_bb)))
|
|| LABEL_P (BB_HEAD (bb->next_bb)))
|
break;
|
break;
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
FOR_EACH_EDGE (e, ei, bb->succs)
|
if ((e->flags & EDGE_FALLTHRU) != 0)
|
if ((e->flags & EDGE_FALLTHRU) != 0)
|
break;
|
break;
|
if (! e)
|
if (! e)
|
break;
|
break;
|
if (e->probability <= probability_cutoff)
|
if (e->probability <= probability_cutoff)
|
break;
|
break;
|
bb = bb->next_bb;
|
bb = bb->next_bb;
|
}
|
}
|
|
|
/* Blah. We should fix the rest of the code not to get confused by
|
/* Blah. We should fix the rest of the code not to get confused by
|
a note or two. */
|
a note or two. */
|
while (head != tail)
|
while (head != tail)
|
{
|
{
|
if (NOTE_P (head))
|
if (NOTE_P (head))
|
head = NEXT_INSN (head);
|
head = NEXT_INSN (head);
|
else if (NOTE_P (tail))
|
else if (NOTE_P (tail))
|
tail = PREV_INSN (tail);
|
tail = PREV_INSN (tail);
|
else if (LABEL_P (head))
|
else if (LABEL_P (head))
|
head = NEXT_INSN (head);
|
head = NEXT_INSN (head);
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
bitmap_set_bit (&ebb_head, BLOCK_NUM (head));
|
bitmap_set_bit (&ebb_head, BLOCK_NUM (head));
|
bb = schedule_ebb (head, tail);
|
bb = schedule_ebb (head, tail);
|
bitmap_set_bit (&ebb_tail, bb->index);
|
bitmap_set_bit (&ebb_tail, bb->index);
|
}
|
}
|
bitmap_clear (&dont_calc_deps);
|
bitmap_clear (&dont_calc_deps);
|
|
|
gcc_assert (current_sched_info->flags & DETACH_LIFE_INFO);
|
gcc_assert (current_sched_info->flags & DETACH_LIFE_INFO);
|
/* We can create new basic blocks during scheduling, and
|
/* We can create new basic blocks during scheduling, and
|
attach_life_info () will create regsets for them
|
attach_life_info () will create regsets for them
|
(along with attaching existing info back). */
|
(along with attaching existing info back). */
|
attach_life_info ();
|
attach_life_info ();
|
|
|
/* Updating register live information. */
|
/* Updating register live information. */
|
allocate_reg_life_data ();
|
allocate_reg_life_data ();
|
|
|
any_large_regions = 0;
|
any_large_regions = 0;
|
large_region_blocks = sbitmap_alloc (last_basic_block);
|
large_region_blocks = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (large_region_blocks);
|
sbitmap_zero (large_region_blocks);
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
SET_BIT (large_region_blocks, bb->index);
|
SET_BIT (large_region_blocks, bb->index);
|
|
|
blocks = sbitmap_alloc (last_basic_block);
|
blocks = sbitmap_alloc (last_basic_block);
|
sbitmap_zero (blocks);
|
sbitmap_zero (blocks);
|
|
|
/* Update life information. For regions consisting of multiple blocks
|
/* Update life information. For regions consisting of multiple blocks
|
we've possibly done interblock scheduling that affects global liveness.
|
we've possibly done interblock scheduling that affects global liveness.
|
For regions consisting of single blocks we need to do only local
|
For regions consisting of single blocks we need to do only local
|
liveness. */
|
liveness. */
|
FOR_EACH_BB (bb)
|
FOR_EACH_BB (bb)
|
{
|
{
|
int bbi;
|
int bbi;
|
|
|
bbi = bb->index;
|
bbi = bb->index;
|
|
|
if (!bitmap_bit_p (&ebb_head, bbi)
|
if (!bitmap_bit_p (&ebb_head, bbi)
|
|| !bitmap_bit_p (&ebb_tail, bbi)
|
|| !bitmap_bit_p (&ebb_tail, bbi)
|
/* New blocks (e.g. recovery blocks) should be processed
|
/* New blocks (e.g. recovery blocks) should be processed
|
as parts of large regions. */
|
as parts of large regions. */
|
|| !glat_start[bbi])
|
|| !glat_start[bbi])
|
any_large_regions = 1;
|
any_large_regions = 1;
|
else
|
else
|
{
|
{
|
SET_BIT (blocks, bbi);
|
SET_BIT (blocks, bbi);
|
RESET_BIT (large_region_blocks, bbi);
|
RESET_BIT (large_region_blocks, bbi);
|
}
|
}
|
}
|
}
|
|
|
update_life_info (blocks, UPDATE_LIFE_LOCAL, 0);
|
update_life_info (blocks, UPDATE_LIFE_LOCAL, 0);
|
sbitmap_free (blocks);
|
sbitmap_free (blocks);
|
|
|
if (any_large_regions)
|
if (any_large_regions)
|
{
|
{
|
update_life_info (large_region_blocks, UPDATE_LIFE_GLOBAL, 0);
|
update_life_info (large_region_blocks, UPDATE_LIFE_GLOBAL, 0);
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
/* !!! We can't check reg_live_info here because of the fact,
|
/* !!! We can't check reg_live_info here because of the fact,
|
that destination registers of COND_EXEC's may be dead
|
that destination registers of COND_EXEC's may be dead
|
before scheduling (while they should be alive). Don't know why. */
|
before scheduling (while they should be alive). Don't know why. */
|
/*check_reg_live (true);*/
|
/*check_reg_live (true);*/
|
#endif
|
#endif
|
}
|
}
|
sbitmap_free (large_region_blocks);
|
sbitmap_free (large_region_blocks);
|
|
|
bitmap_clear (&ebb_head);
|
bitmap_clear (&ebb_head);
|
bitmap_clear (&ebb_tail);
|
bitmap_clear (&ebb_tail);
|
|
|
/* Reposition the prologue and epilogue notes in case we moved the
|
/* Reposition the prologue and epilogue notes in case we moved the
|
prologue/epilogue insns. */
|
prologue/epilogue insns. */
|
if (reload_completed)
|
if (reload_completed)
|
reposition_prologue_and_epilogue_notes (get_insns ());
|
reposition_prologue_and_epilogue_notes (get_insns ());
|
|
|
if (write_symbols != NO_DEBUG)
|
if (write_symbols != NO_DEBUG)
|
rm_redundant_line_notes ();
|
rm_redundant_line_notes ();
|
|
|
sched_finish ();
|
sched_finish ();
|
}
|
}
|
|
|
/* INSN has been added to/removed from current ebb. */
|
/* INSN has been added to/removed from current ebb. */
|
static void
|
static void
|
add_remove_insn (rtx insn ATTRIBUTE_UNUSED, int remove_p)
|
add_remove_insn (rtx insn ATTRIBUTE_UNUSED, int remove_p)
|
{
|
{
|
if (!remove_p)
|
if (!remove_p)
|
n_insns++;
|
n_insns++;
|
else
|
else
|
n_insns--;
|
n_insns--;
|
}
|
}
|
|
|
/* BB was added to ebb after AFTER. */
|
/* BB was added to ebb after AFTER. */
|
static void
|
static void
|
add_block1 (basic_block bb, basic_block after)
|
add_block1 (basic_block bb, basic_block after)
|
{
|
{
|
/* Recovery blocks are always bounded by BARRIERS,
|
/* Recovery blocks are always bounded by BARRIERS,
|
therefore, they always form single block EBB,
|
therefore, they always form single block EBB,
|
therefore, we can use rec->index to identify such EBBs. */
|
therefore, we can use rec->index to identify such EBBs. */
|
if (after == EXIT_BLOCK_PTR)
|
if (after == EXIT_BLOCK_PTR)
|
bitmap_set_bit (&dont_calc_deps, bb->index);
|
bitmap_set_bit (&dont_calc_deps, bb->index);
|
else if (after == last_bb)
|
else if (after == last_bb)
|
last_bb = bb;
|
last_bb = bb;
|
}
|
}
|
|
|
/* Return next block in ebb chain. For parameter meaning please refer to
|
/* Return next block in ebb chain. For parameter meaning please refer to
|
sched-int.h: struct sched_info: advance_target_bb. */
|
sched-int.h: struct sched_info: advance_target_bb. */
|
static basic_block
|
static basic_block
|
advance_target_bb (basic_block bb, rtx insn)
|
advance_target_bb (basic_block bb, rtx insn)
|
{
|
{
|
if (insn)
|
if (insn)
|
{
|
{
|
if (BLOCK_FOR_INSN (insn) != bb
|
if (BLOCK_FOR_INSN (insn) != bb
|
&& control_flow_insn_p (insn)
|
&& control_flow_insn_p (insn)
|
/* We handle interblock movement of the speculation check
|
/* We handle interblock movement of the speculation check
|
or over a speculation check in
|
or over a speculation check in
|
haifa-sched.c: move_block_after_check (). */
|
haifa-sched.c: move_block_after_check (). */
|
&& !IS_SPECULATION_BRANCHY_CHECK_P (insn)
|
&& !IS_SPECULATION_BRANCHY_CHECK_P (insn)
|
&& !IS_SPECULATION_BRANCHY_CHECK_P (BB_END (bb)))
|
&& !IS_SPECULATION_BRANCHY_CHECK_P (BB_END (bb)))
|
{
|
{
|
/* Assert that we don't move jumps across blocks. */
|
/* Assert that we don't move jumps across blocks. */
|
gcc_assert (!control_flow_insn_p (BB_END (bb))
|
gcc_assert (!control_flow_insn_p (BB_END (bb))
|
&& NOTE_INSN_BASIC_BLOCK_P (BB_HEAD (bb->next_bb)));
|
&& NOTE_INSN_BASIC_BLOCK_P (BB_HEAD (bb->next_bb)));
|
return bb;
|
return bb;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
else
|
else
|
/* Return next non empty block. */
|
/* Return next non empty block. */
|
{
|
{
|
do
|
do
|
{
|
{
|
gcc_assert (bb != last_bb);
|
gcc_assert (bb != last_bb);
|
|
|
bb = bb->next_bb;
|
bb = bb->next_bb;
|
}
|
}
|
while (bb_note (bb) == BB_END (bb));
|
while (bb_note (bb) == BB_END (bb));
|
|
|
return bb;
|
return bb;
|
}
|
}
|
}
|
}
|
|
|
/* Fix internal data after interblock movement of jump instruction.
|
/* Fix internal data after interblock movement of jump instruction.
|
For parameter meaning please refer to
|
For parameter meaning please refer to
|
sched-int.h: struct sched_info: fix_recovery_cfg. */
|
sched-int.h: struct sched_info: fix_recovery_cfg. */
|
static void
|
static void
|
fix_recovery_cfg (int bbi ATTRIBUTE_UNUSED, int jump_bbi, int jump_bb_nexti)
|
fix_recovery_cfg (int bbi ATTRIBUTE_UNUSED, int jump_bbi, int jump_bb_nexti)
|
{
|
{
|
gcc_assert (last_bb->index != bbi);
|
gcc_assert (last_bb->index != bbi);
|
|
|
if (jump_bb_nexti == last_bb->index)
|
if (jump_bb_nexti == last_bb->index)
|
last_bb = BASIC_BLOCK (jump_bbi);
|
last_bb = BASIC_BLOCK (jump_bbi);
|
}
|
}
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
/* Return non zero, if BB is first or last (depending of LEAF_P) block in
|
/* Return non zero, if BB is first or last (depending of LEAF_P) block in
|
current ebb. For more information please refer to
|
current ebb. For more information please refer to
|
sched-int.h: struct sched_info: region_head_or_leaf_p. */
|
sched-int.h: struct sched_info: region_head_or_leaf_p. */
|
static int
|
static int
|
ebb_head_or_leaf_p (basic_block bb, int leaf_p)
|
ebb_head_or_leaf_p (basic_block bb, int leaf_p)
|
{
|
{
|
if (!leaf_p)
|
if (!leaf_p)
|
return bitmap_bit_p (&ebb_head, bb->index);
|
return bitmap_bit_p (&ebb_head, bb->index);
|
else
|
else
|
return bitmap_bit_p (&ebb_tail, bb->index);
|
return bitmap_bit_p (&ebb_tail, bb->index);
|
}
|
}
|
#endif /* ENABLE_CHECKING */
|
#endif /* ENABLE_CHECKING */
|
|
|
