+2003-01-16 Vladimir Makarov <vmakarov@redhat.com>
+
+ * haifa-sched.c (move_insn): Restore moving all schedule group.
+ (set_priorities): Restore taking SCHED_GROUP_P into account.
+
+ * sched-deps.c (add_dependence): Restore processing the last group
+ insn.
+ (remove_dependence, group_leader): Restore the functions.
+ (set_sched_group_p): Restore adding dependencies from previous insn
+ in the group.
+ (compute_forward_dependences): Restore usage of group_leader.
+
+ * sched-ebb.c (init_ready_list): Restore taking SCHED_GROUP_P into
+ account.
+
+ * sched-rgn.c (init_ready_list): Restore taking SCHED_GROUP_P into
+ account.
+ (can_schedule_ready_p): Ditto.
+ (add_branch_dependences): Restore skipping over the group insns.
+
2003-01-16 Stephane Carrez <stcarrez@nerim.fr>
* config/m68hc11/m68hc11.c (m68hc11_check_z_replacement): Fix handling
{
rtx retval = NULL;
+ /* If INSN has SCHED_GROUP_P set, then issue it and any other
+ insns with SCHED_GROUP_P set first. */
+ while (SCHED_GROUP_P (insn))
+ {
+ rtx prev = PREV_INSN (insn);
+
+ /* Move a SCHED_GROUP_P insn. */
+ move_insn1 (insn, last);
+ /* If this is the first call to reemit_notes, then record
+ its return value. */
+ if (retval == NULL_RTX)
+ retval = reemit_notes (insn, insn);
+ else
+ reemit_notes (insn, insn);
+ /* Consume SCHED_GROUP_P flag. */
+ SCHED_GROUP_P (insn) = 0;
+ insn = prev;
+ }
+
/* Now move the first non SCHED_GROUP_P insn. */
move_insn1 (insn, last);
else
reemit_notes (insn, insn);
- SCHED_GROUP_P (insn) = 0;
-
return retval;
}
if (GET_CODE (insn) == NOTE)
continue;
- n_insn++;
+ if (! SCHED_GROUP_P (insn))
+ n_insn++;
(void) priority (insn);
}
static int deps_may_trap_p PARAMS ((rtx));
static void add_dependence_list PARAMS ((rtx, rtx, enum reg_note));
static void add_dependence_list_and_free PARAMS ((rtx, rtx *, enum reg_note));
+static void remove_dependence PARAMS ((rtx, rtx));
static void set_sched_group_p PARAMS ((rtx));
static void flush_pending_lists PARAMS ((struct deps *, rtx, int, int));
static void sched_analyze_1 PARAMS ((struct deps *, rtx, rtx));
static void sched_analyze_2 PARAMS ((struct deps *, rtx, rtx));
static void sched_analyze_insn PARAMS ((struct deps *, rtx, rtx, rtx));
+static rtx group_leader PARAMS ((rtx));
static rtx get_condition PARAMS ((rtx));
static int conditions_mutex_p PARAMS ((rtx, rtx));
rtx nnext;
while ((nnext = next_nonnote_insn (next)) != NULL
&& INSN_P (nnext)
- && next != insn
&& SCHED_GROUP_P (nnext))
next = nnext;
- if (insn != next)
- add_dependence (insn, next, REG_DEP_ANTI);
+ /* Again, don't depend an insn on itself. */
+ if (insn == next)
+ return;
+ /* Make the dependence to NEXT, the last insn of the group,
+ instead of the original ELEM. */
+ elem = next;
}
}
}
+/* Remove ELEM wrapped in an INSN_LIST from the LOG_LINKS
+ of INSN. Abort if not found. */
+
+static void
+remove_dependence (insn, elem)
+ rtx insn;
+ rtx elem;
+{
+ rtx prev, link, next;
+ int found = 0;
+
+ for (prev = 0, link = LOG_LINKS (insn); link; link = next)
+ {
+ next = XEXP (link, 1);
+ if (XEXP (link, 0) == elem)
+ {
+ if (prev)
+ XEXP (prev, 1) = next;
+ else
+ LOG_LINKS (insn) = next;
+
+#ifdef INSN_SCHEDULING
+ /* If we are removing a dependency from the LOG_LINKS list,
+ make sure to remove it from the cache too. */
+ if (true_dependency_cache != NULL)
+ {
+ if (REG_NOTE_KIND (link) == 0)
+ RESET_BIT (true_dependency_cache[INSN_LUID (insn)],
+ INSN_LUID (elem));
+ else if (REG_NOTE_KIND (link) == REG_DEP_ANTI)
+ RESET_BIT (anti_dependency_cache[INSN_LUID (insn)],
+ INSN_LUID (elem));
+ else if (REG_NOTE_KIND (link) == REG_DEP_OUTPUT)
+ RESET_BIT (output_dependency_cache[INSN_LUID (insn)],
+ INSN_LUID (elem));
+ }
+#endif
+
+ free_INSN_LIST_node (link);
+
+ found = 1;
+ }
+ else
+ prev = link;
+ }
+
+ if (!found)
+ abort ();
+ return;
+}
+
+/* Return an insn which represents a SCHED_GROUP, which is
+ the last insn in the group. */
+
+static rtx
+group_leader (insn)
+ rtx insn;
+{
+ rtx prev;
+
+ do
+ {
+ prev = insn;
+ insn = next_nonnote_insn (insn);
+ }
+ while (insn && INSN_P (insn) && SCHED_GROUP_P (insn));
+
+ return prev;
+}
+
/* Set SCHED_GROUP_P and care for the rest of the bookkeeping that
goes along with that. */
SCHED_GROUP_P (insn) = 1;
- for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
- {
- prev = insn;
- do
- {
- prev = prev_nonnote_insn (prev);
- if (XEXP (link, 0) == prev)
- break;
- }
- while (SCHED_GROUP_P (prev));
- if (XEXP (link, 0) != prev)
- add_dependence (prev, XEXP (link, 0), REG_DEP_ANTI);
- }
+ /* There may be a note before this insn now, but all notes will
+ be removed before we actually try to schedule the insns, so
+ it won't cause a problem later. We must avoid it here
+ though. */
prev = prev_nonnote_insn (insn);
- add_dependence (insn, prev, REG_DEP_ANTI);
+
+ /* Make a copy of all dependencies on the immediately previous
+ insn, and add to this insn. This is so that all the
+ dependencies will apply to the group. Remove an explicit
+ dependence on this insn as SCHED_GROUP_P now represents it. */
+
+ if (find_insn_list (prev, LOG_LINKS (insn)))
+ remove_dependence (insn, prev);
+
+ for (link = LOG_LINKS (prev); link; link = XEXP (link, 1))
+ add_dependence (insn, XEXP (link, 0), REG_NOTE_KIND (link));
}
\f
/* Process an insn's memory dependencies. There are four kinds of
if (! INSN_P (insn))
continue;
+ insn = group_leader (insn);
+
for (link = LOG_LINKS (insn); link; link = XEXP (link, 1))
{
- rtx x = XEXP (link, 0);
+ rtx x = group_leader (XEXP (link, 0));
rtx new_link;
if (x != XEXP (link, 0))
Count number of insns in the target block being scheduled. */
for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
{
- if (INSN_DEP_COUNT (insn) == 0)
+ rtx next;
+
+ if (! INSN_P (insn))
+ continue;
+ next = NEXT_INSN (insn);
+
+ if (INSN_DEP_COUNT (insn) == 0
+ && (! INSN_P (next) || SCHED_GROUP_P (next) == 0))
ready_add (ready, insn);
- if (!(SCHED_GROUP_P (insn)))
+ if (! SCHED_GROUP_P (insn))
target_n_insns++;
}
}
Count number of insns in the target block being scheduled. */
for (insn = NEXT_INSN (prev_head); insn != next_tail; insn = NEXT_INSN (insn))
{
- if (INSN_DEP_COUNT (insn) == 0)
+ rtx next;
+
+ if (! INSN_P (insn))
+ continue;
+ next = NEXT_INSN (insn);
+
+ if (INSN_DEP_COUNT (insn) == 0
+ && (! INSN_P (next) || SCHED_GROUP_P (next) == 0))
ready_add (ready, insn);
- target_n_insns++;
+ if (! SCHED_GROUP_P (insn))
+ target_n_insns++;
}
/* Add to ready list all 'ready' insns in valid source blocks.
insn, insn) <= 3)))
&& check_live (insn, bb_src)
&& is_exception_free (insn, bb_src, target_bb))))
- if (INSN_DEP_COUNT (insn) == 0)
- ready_add (ready, insn);
+ {
+ rtx next;
+
+ /* Note that we haven't squirreled away the notes for
+ blocks other than the current. So if this is a
+ speculative insn, NEXT might otherwise be a note. */
+ next = next_nonnote_insn (insn);
+ if (INSN_DEP_COUNT (insn) == 0
+ && (! next
+ || ! INSN_P (next)
+ || SCHED_GROUP_P (next) == 0))
+ ready_add (ready, insn);
+ }
}
}
}
/* An interblock motion? */
if (INSN_BB (insn) != target_bb)
{
+ rtx temp;
basic_block b1;
if (IS_SPECULATIVE_INSN (insn))
}
nr_inter++;
+ /* Find the beginning of the scheduling group. */
+ /* ??? Ought to update basic block here, but later bits of
+ schedule_block assumes the original insn block is
+ still intact. */
+
+ temp = insn;
+ while (SCHED_GROUP_P (temp))
+ temp = PREV_INSN (temp);
+
/* Update source block boundaries. */
- b1 = BLOCK_FOR_INSN (insn);
- if (insn == b1->head && insn == b1->end)
+ b1 = BLOCK_FOR_INSN (temp);
+ if (temp == b1->head && temp == b1->end)
{
/* We moved all the insns in the basic block.
Emit a note after the last insn and update the
/* We took insns from the end of the basic block,
so update the end of block boundary so that it
points to the first insn we did not move. */
- b1->end = PREV_INSN (insn);
+ b1->end = PREV_INSN (temp);
}
- else if (insn == b1->head)
+ else if (temp == b1->head)
{
/* We took insns from the start of the basic block,
so update the start of block boundary so that
CANT_MOVE (insn) = 1;
last = insn;
+ /* Skip over insns that are part of a group.
+ Make each insn explicitly depend on the previous insn.
+ This ensures that only the group header will ever enter
+ the ready queue (and, when scheduled, will automatically
+ schedule the SCHED_GROUP_P block). */
+ while (SCHED_GROUP_P (insn))
+ {
+ rtx temp = prev_nonnote_insn (insn);
+ add_dependence (insn, temp, REG_DEP_ANTI);
+ insn = temp;
+ }
}
/* Don't overrun the bounds of the basic block. */
add_dependence (last, insn, REG_DEP_ANTI);
INSN_REF_COUNT (insn) = 1;
+
+ /* Skip over insns that are part of a group. */
+ while (SCHED_GROUP_P (insn))
+ insn = prev_nonnote_insn (insn);
}
}
projects / gcc.git / commitdiff