From: Trevor Saunders <tbsaunde+...@tbsaunde.org>
The old versions of the functions copied here are removed in later patches in
my queue once all the lists are gone from sched-*. However they are necessary
temporarily to not have to convert all the lists at once which made writing and
hopefully reviewing these patches much easier.
gcc/ChangeLog:
2016-04-20 Trevor Saunders <tbsaunde+...@tbsaunde.org>
* sched-deps.c (add_dependence_list): Adjust.
(add_dependence_list_and_free): Likewise.
(remove_from_both_dependence_lists): Likewise.
(add_insn_mem_dependence): Likewise. Likewise.
(flush_pending_lists): Likewise.
(sched_analyze_1): Likewise.
(sched_analyze_2): Likewise.
(sched_analyze_insn): Likewise.
(init_deps): Likewise.
(free_deps): Likewise.
* sched-int.h (struct deps_desc): Make pending_read_insns and
pending_write_insns vectors.
* sched-rgn.c (concat_mem_list): Adjust.
(deps_join): Likewise.
(propagate_deps): Likewise.
(free_pending_lists): Likewise.
---
gcc/sched-deps.c | 134 ++++++++++++++++++++++++++++++-------------------------
gcc/sched-int.h | 4 +-
gcc/sched-rgn.c | 41 +++++++----------
3 files changed, 91 insertions(+), 88 deletions(-)
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index 8f3a124..879c9ca 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -1568,6 +1568,20 @@ add_dependence_list (rtx_insn *insn, rtx_insn_list
*list, int uncond,
mark_as_hard = false;
}
+static void
+add_dependence_list (rtx_insn *insn, const vec<rtx_insn *> &insns, int uncond,
+ enum reg_note dep_type, bool hard)
+{
+ mark_as_hard = hard;
+ unsigned int len = insns.length ();
+ for (unsigned int i = len - 1; i < len; i--)
+ {
+ if (uncond || ! sched_insns_conditions_mutex_p (insn, insns[i]))
+ add_dependence (insn, insns[i], dep_type);
+ }
+ mark_as_hard = false;
+}
+
/* Similar, but free *LISTP at the same time, when the context
is not readonly. HARD should be true if DEP_NONREG should be set on
newly created dependencies. */
@@ -1588,6 +1602,22 @@ add_dependence_list_and_free (struct deps_desc *deps,
rtx_insn *insn,
free_INSN_LIST_list (listp);
}
+static void
+add_dependence_list_and_free (struct deps_desc *deps, rtx_insn *insn,
+ vec<rtx_insn *> *insns,
+ int uncond, enum reg_note dep_type, bool hard)
+{
+ add_dependence_list (insn, *insns, uncond, dep_type, hard);
+
+ /* We don't want to short-circuit dependencies involving debug
+ insns, because they may cause actual dependencies to be
+ disregarded. */
+ if (deps->readonly || DEBUG_INSN_P (insn))
+ return;
+
+ insns->release ();
+}
+
/* Remove all occurrences of INSN from LIST. Return the number of
occurrences removed. */
@@ -1614,22 +1644,22 @@ remove_from_dependence_list (rtx_insn *insn,
rtx_insn_list **listp)
/* Same as above, but process two lists at once. */
static int
remove_from_both_dependence_lists (rtx_insn *insn,
- rtx_insn_list **listp,
+ vec<rtx_insn *> *insns,
rtx_expr_list **exprp)
{
int removed = 0;
- while (*listp)
+ unsigned int len = insns->length ();
+ for (unsigned int i = len - 1; i < len; i--)
{
- if (XEXP (*listp, 0) == insn)
+ if ((*insns)[i] == insn)
{
- remove_free_INSN_LIST_node (listp);
+ insns->ordered_remove (i);
remove_free_EXPR_LIST_node (exprp);
removed++;
continue;
}
- listp = (rtx_insn_list **)&XEXP (*listp, 1);
exprp = (rtx_expr_list **)&XEXP (*exprp, 1);
}
@@ -1710,29 +1740,24 @@ static void
add_insn_mem_dependence (struct deps_desc *deps, bool read_p,
rtx_insn *insn, rtx mem)
{
- rtx_insn_list **insn_list;
- rtx_insn_list *insn_node;
rtx_expr_list **mem_list;
rtx_expr_list *mem_node;
gcc_assert (!deps->readonly);
if (read_p)
{
- insn_list = &deps->pending_read_insns;
+ deps->pending_read_insns.safe_push (insn);
mem_list = &deps->pending_read_mems;
if (!DEBUG_INSN_P (insn))
deps->pending_read_list_length++;
}
else
{
- insn_list = &deps->pending_write_insns;
+ deps->pending_write_insns.safe_push (insn);
mem_list = &deps->pending_write_mems;
deps->pending_write_list_length++;
}
- insn_node = alloc_INSN_LIST (insn, *insn_list);
- *insn_list = insn_node;
-
if (sched_deps_info->use_cselib)
{
mem = shallow_copy_rtx (mem);
@@ -1777,8 +1802,8 @@ flush_pending_lists (struct deps_desc *deps, rtx_insn
*insn, int for_read,
if (DEBUG_INSN_P (insn))
{
if (for_write)
- free_INSN_LIST_list (&deps->pending_read_insns);
- free_INSN_LIST_list (&deps->pending_write_insns);
+ deps->pending_read_insns.release ();
+ deps->pending_write_insns.release ();
free_INSN_LIST_list (&deps->last_pending_memory_flush);
free_INSN_LIST_list (&deps->pending_jump_insns);
}
@@ -2489,33 +2514,29 @@ sched_analyze_1 (struct deps_desc *deps, rtx x,
rtx_insn *insn)
}
else
{
- rtx_insn_list *pending;
rtx_expr_list *pending_mem;
- pending = deps->pending_read_insns;
+ unsigned int len = deps->pending_read_insns.length ();
pending_mem = deps->pending_read_mems;
- while (pending)
+ for (unsigned int i = len - 1; i < len; i--)
{
+ rtx_insn *temp = deps->pending_read_insns[i];
if (anti_dependence (pending_mem->element (), t)
- && ! sched_insns_conditions_mutex_p (insn, pending->insn ()))
- note_mem_dep (t, pending_mem->element (), pending->insn (),
- DEP_ANTI);
+ && ! sched_insns_conditions_mutex_p (insn, temp))
+ note_mem_dep (t, pending_mem->element (), temp, DEP_ANTI);
- pending = pending->next ();
pending_mem = pending_mem->next ();
}
- pending = deps->pending_write_insns;
+ len = deps->pending_write_insns.length ();
pending_mem = deps->pending_write_mems;
- while (pending)
+ for (unsigned int i = len - 1; i < len; i--)
{
+ rtx_insn *temp = deps->pending_write_insns[i];
if (output_dependence (pending_mem->element (), t)
- && ! sched_insns_conditions_mutex_p (insn, pending->insn ()))
- note_mem_dep (t, pending_mem->element (),
- pending->insn (),
- DEP_OUTPUT);
+ && ! sched_insns_conditions_mutex_p (insn, temp))
+ note_mem_dep (t, pending_mem->element (), temp, DEP_OUTPUT);
- pending = pending->next ();
pending_mem = pending_mem-> next ();
}
@@ -2620,7 +2641,6 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn
*insn)
{
/* Reading memory. */
rtx_insn_list *u;
- rtx_insn_list *pending;
rtx_expr_list *pending_mem;
rtx t = x;
@@ -2639,34 +2659,29 @@ sched_analyze_2 (struct deps_desc *deps, rtx x,
rtx_insn *insn)
if (!DEBUG_INSN_P (insn))
{
t = canon_rtx (t);
- pending = deps->pending_read_insns;
+ unsigned int len = deps->pending_read_insns.length ();
pending_mem = deps->pending_read_mems;
- while (pending)
+ for (unsigned int i = len - 1; i < len; i--)
{
+ rtx_insn *temp = deps->pending_read_insns[i];
if (read_dependence (pending_mem->element (), t)
- && ! sched_insns_conditions_mutex_p (insn,
- pending->insn ()))
- note_mem_dep (t, pending_mem->element (),
- pending->insn (),
- DEP_ANTI);
+ && ! sched_insns_conditions_mutex_p (insn, temp))
+ note_mem_dep (t, pending_mem->element (), temp, DEP_ANTI);
- pending = pending->next ();
pending_mem = pending_mem->next ();
}
- pending = deps->pending_write_insns;
+ len = deps->pending_write_insns.length ();
pending_mem = deps->pending_write_mems;
- while (pending)
+ for (unsigned int i = len - 1; i < len; i--)
{
+ rtx_insn *temp = deps->pending_write_insns[i];
if (true_dependence (pending_mem->element (), VOIDmode, t)
- && ! sched_insns_conditions_mutex_p (insn,
- pending->insn ()))
- note_mem_dep (t, pending_mem->element (),
- pending->insn (),
+ && ! sched_insns_conditions_mutex_p (insn, temp))
+ note_mem_dep (t, pending_mem->element (), temp,
sched_deps_info->generate_spec_deps
? BEGIN_DATA | DEP_TRUE : DEP_TRUE);
- pending = pending->next ();
pending_mem = pending_mem->next ();
}
@@ -2987,7 +3002,6 @@ sched_analyze_insn (struct deps_desc *deps, rtx x,
rtx_insn *insn)
reg_pending_barrier = MOVE_BARRIER;
else
{
- rtx_insn_list *pending;
rtx_expr_list *pending_mem;
if (sched_deps_info->compute_jump_reg_dependencies)
@@ -3012,26 +3026,24 @@ sched_analyze_insn (struct deps_desc *deps, rtx x,
rtx_insn *insn)
jump. Non-volatile reads must happen before the jump iff
the result is needed by the above register used mask. */
- pending = deps->pending_write_insns;
+ unsigned int len = deps->pending_write_insns.length ();
pending_mem = deps->pending_write_mems;
- while (pending)
+ for (unsigned int i = len - 1; i < len; i--)
{
- if (! sched_insns_conditions_mutex_p (insn, pending->insn ()))
- add_dependence (insn, pending->insn (),
- REG_DEP_OUTPUT);
- pending = pending->next ();
+ rtx_insn *temp = deps->pending_write_insns[i];
+ if (! sched_insns_conditions_mutex_p (insn, temp))
+ add_dependence (insn, temp, REG_DEP_OUTPUT);
pending_mem = pending_mem->next ();
}
- pending = deps->pending_read_insns;
+ len = deps->pending_read_insns.length ();
pending_mem = deps->pending_read_mems;
- while (pending)
+ for (unsigned int i = len - 1; i < len; i--)
{
+ rtx_insn *temp = deps->pending_read_insns[i];
if (MEM_VOLATILE_P (pending_mem->element ())
- && ! sched_insns_conditions_mutex_p (insn, pending->insn ()))
- add_dependence (insn, pending->insn (),
- REG_DEP_OUTPUT);
- pending = pending->next ();
+ && ! sched_insns_conditions_mutex_p (insn, temp))
+ add_dependence (insn, temp, REG_DEP_OUTPUT);
pending_mem = pending_mem->next ();
}
@@ -3887,9 +3899,9 @@ init_deps (struct deps_desc *deps, bool lazy_reg_last)
deps->reg_last = XCNEWVEC (struct deps_reg, max_reg);
INIT_REG_SET (&deps->reg_last_in_use);
- deps->pending_read_insns = 0;
+ deps->pending_read_insns.create (0);
deps->pending_read_mems = 0;
- deps->pending_write_insns = 0;
+ deps->pending_write_insns.create (0);
deps->pending_write_mems = 0;
deps->pending_jump_insns = 0;
deps->pending_read_list_length = 0;
@@ -3935,9 +3947,9 @@ free_deps (struct deps_desc *deps)
}
deps->max_reg = 0;
- free_INSN_LIST_list (&deps->pending_read_insns);
+ deps->pending_read_insns.release ();
free_EXPR_LIST_list (&deps->pending_read_mems);
- free_INSN_LIST_list (&deps->pending_write_insns);
+ deps->pending_write_insns.release ();
free_EXPR_LIST_list (&deps->pending_write_mems);
free_INSN_LIST_list (&deps->last_pending_memory_flush);
diff --git a/gcc/sched-int.h b/gcc/sched-int.h
index de5d326..45890b8 100644
--- a/gcc/sched-int.h
+++ b/gcc/sched-int.h
@@ -466,13 +466,13 @@ struct deps_desc
to a list more than once. */
/* An INSN_LIST containing all insns with pending read operations. */
- rtx_insn_list *pending_read_insns;
+ vec<rtx_insn *> pending_read_insns;
/* An EXPR_LIST containing all MEM rtx's which are pending reads. */
rtx_expr_list *pending_read_mems;
/* An INSN_LIST containing all insns with pending write operations. */
- rtx_insn_list *pending_write_insns;
+ vec<rtx_insn *> pending_write_insns;
/* An EXPR_LIST containing all MEM rtx's which are pending writes. */
rtx_expr_list *pending_write_mems;
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index d4b71a1..9e807a1 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -238,8 +238,7 @@ static void add_branch_dependences (rtx_insn *, rtx_insn *);
static void compute_block_dependences (int);
static void schedule_region (int);
-static void concat_insn_mem_list (rtx_insn_list *, rtx_expr_list *,
- rtx_insn_list **, rtx_expr_list **);
+static void concat_mem_list (rtx_expr_list *, rtx_expr_list **);
static void propagate_deps (int, struct deps_desc *);
static void free_pending_lists (void);
@@ -2576,23 +2575,16 @@ add_branch_dependences (rtx_insn *head, rtx_insn *tail)
static struct deps_desc *bb_deps;
static void
-concat_insn_mem_list (rtx_insn_list *copy_insns,
- rtx_expr_list *copy_mems,
- rtx_insn_list **old_insns_p,
- rtx_expr_list **old_mems_p)
+concat_mem_list (rtx_expr_list *copy_mems, rtx_expr_list **old_mems_p)
{
- rtx_insn_list *new_insns = *old_insns_p;
rtx_expr_list *new_mems = *old_mems_p;
- while (copy_insns)
+ while (copy_mems)
{
- new_insns = alloc_INSN_LIST (copy_insns->insn (), new_insns);
new_mems = alloc_EXPR_LIST (VOIDmode, copy_mems->element (), new_mems);
- copy_insns = copy_insns->next ();
copy_mems = copy_mems->next ();
}
- *old_insns_p = new_insns;
*old_mems_p = new_mems;
}
@@ -2621,14 +2613,12 @@ deps_join (struct deps_desc *succ_deps, struct
deps_desc *pred_deps)
IOR_REG_SET (&succ_deps->reg_last_in_use, &pred_deps->reg_last_in_use);
/* Mem read/write lists are inherited by successor. */
- concat_insn_mem_list (pred_deps->pending_read_insns,
- pred_deps->pending_read_mems,
- &succ_deps->pending_read_insns,
- &succ_deps->pending_read_mems);
- concat_insn_mem_list (pred_deps->pending_write_insns,
- pred_deps->pending_write_mems,
- &succ_deps->pending_write_insns,
- &succ_deps->pending_write_mems);
+ succ_deps->pending_read_insns.safe_splice (pred_deps->pending_read_insns);
+ succ_deps->pending_write_insns.safe_splice (pred_deps->pending_write_insns);
+ concat_mem_list (pred_deps->pending_read_mems,
+ &succ_deps->pending_read_mems);
+ concat_mem_list (pred_deps->pending_write_mems,
+ &succ_deps->pending_write_mems);
succ_deps->pending_jump_insns
= concat_INSN_LIST (pred_deps->pending_jump_insns,
@@ -2678,18 +2668,19 @@ propagate_deps (int bb, struct deps_desc *pred_deps)
deps_join (bb_deps + BLOCK_TO_BB (e->dest->index), pred_deps);
}
+ bb_deps[bb].pending_read_insns = pred_deps->pending_read_insns;
+ pred_deps->pending_read_insns = vNULL;
+ bb_deps[bb].pending_write_insns = pred_deps->pending_write_insns;
+ pred_deps->pending_write_insns = vNULL;
+
/* These lists should point to the right place, for correct
freeing later. */
- bb_deps[bb].pending_read_insns = pred_deps->pending_read_insns;
bb_deps[bb].pending_read_mems = pred_deps->pending_read_mems;
- bb_deps[bb].pending_write_insns = pred_deps->pending_write_insns;
bb_deps[bb].pending_write_mems = pred_deps->pending_write_mems;
bb_deps[bb].pending_jump_insns = pred_deps->pending_jump_insns;
/* Can't allow these to be freed twice. */
- pred_deps->pending_read_insns = 0;
pred_deps->pending_read_mems = 0;
- pred_deps->pending_write_insns = 0;
pred_deps->pending_write_mems = 0;
pred_deps->pending_jump_insns = 0;
}
@@ -2766,8 +2757,8 @@ free_pending_lists (void)
for (bb = 0; bb < current_nr_blocks; bb++)
{
- free_INSN_LIST_list (&bb_deps[bb].pending_read_insns);
- free_INSN_LIST_list (&bb_deps[bb].pending_write_insns);
+ bb_deps[bb].pending_read_insns.release ();
+ bb_deps[bb].pending_write_insns.release ();
free_EXPR_LIST_list (&bb_deps[bb].pending_read_mems);
free_EXPR_LIST_list (&bb_deps[bb].pending_write_mems);
free_INSN_LIST_list (&bb_deps[bb].pending_jump_insns);
--
2.7.4
