From: Trevor Saunders <tbsaunde+...@tbsaunde.org>
Same story for the new functions here as for the previous patch.
gcc/ChangeLog:
2016-04-20 Trevor Saunders <tbsaunde+...@tbsaunde.org>
* sched-deps.c (remove_from_dependence_list): Adjust.
(flush_pending_lists): Likewise.
(sched_analyze_2): Likewise.
(sched_analyze_insn): Likewise.
(deps_analyze_insn): Likewise.
(init_deps): Likewise.
(free_deps): Likewise.
* sched-int.h (struct deps_desc): Make last_pending_memory_flush
a vector.
* sched-rgn.c (deps_join): Adjust.
(propagate_deps): Likewise.
(free_pending_lists): Likewise.
---
gcc/sched-deps.c | 61 ++++++++++++++++++++++++++++++++++++++++----------------
gcc/sched-int.h | 4 ++--
gcc/sched-rgn.c | 14 +++++--------
3 files changed, 51 insertions(+), 28 deletions(-)
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c
index 879c9ca..1361967 100644
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -1641,6 +1641,27 @@ remove_from_dependence_list (rtx_insn *insn,
rtx_insn_list **listp)
return removed;
}
+/* Similar but operate on a vec<rtx_insn *>. */
+
+static int
+remove_from_dependence_list (rtx_insn *insn, vec<rtx_insn *> *insns)
+{
+ int removed = 0;
+
+ unsigned int len = insns->length ();
+ for (unsigned int i = len - 1; i < len; i--)
+ {
+ if ((*insns)[i] == insn)
+ {
+ insns->ordered_remove (i);
+ removed++;
+ continue;
+ }
+ }
+
+ return removed;
+}
+
/* Same as above, but process two lists at once. */
static int
remove_from_both_dependence_lists (rtx_insn *insn,
@@ -1804,8 +1825,8 @@ flush_pending_lists (struct deps_desc *deps, rtx_insn
*insn, int for_read,
if (for_write)
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);
+ deps->last_pending_memory_flush.release ();
+ deps->pending_jump_insns.release ();
}
if (!deps->readonly)
@@ -1813,7 +1834,8 @@ flush_pending_lists (struct deps_desc *deps, rtx_insn
*insn, int for_read,
free_EXPR_LIST_list (&deps->pending_write_mems);
deps->pending_write_list_length = 0;
- deps->last_pending_memory_flush = alloc_INSN_LIST (insn, NULL_RTX);
+ deps->last_pending_memory_flush.truncate (0);
+ deps->last_pending_memory_flush.safe_push (insn);
deps->pending_flush_length = 1;
}
mark_as_hard = false;
@@ -2640,7 +2662,6 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn
*insn)
case MEM:
{
/* Reading memory. */
- rtx_insn_list *u;
rtx_expr_list *pending_mem;
rtx t = x;
@@ -2685,22 +2706,26 @@ sched_analyze_2 (struct deps_desc *deps, rtx x,
rtx_insn *insn)
pending_mem = pending_mem->next ();
}
- for (u = deps->last_pending_memory_flush; u; u = u->next ())
- add_dependence (insn, u->insn (), REG_DEP_ANTI);
+ len = deps->last_pending_memory_flush.length ();
+ for (unsigned int i = len - 1; i < len; i--)
+ add_dependence (insn, deps->last_pending_memory_flush[i],
+ REG_DEP_ANTI);
- for (u = deps->pending_jump_insns; u; u = u->next ())
+ len = deps->pending_jump_insns.length ();
+ for (unsigned int i = len - 1; i < len; i--)
if (deps_may_trap_p (x))
{
+ rtx_insn *temp = deps->pending_jump_insns[i];
if ((sched_deps_info->generate_spec_deps)
&& sel_sched_p () && (spec_info->mask & BEGIN_CONTROL))
{
ds_t ds = set_dep_weak (DEP_ANTI, BEGIN_CONTROL,
MAX_DEP_WEAK);
- note_dep (u->insn (), ds);
+ note_dep (temp, ds);
}
else
- add_dependence (insn, u->insn (), REG_DEP_CONTROL);
+ add_dependence (insn, temp, REG_DEP_CONTROL);
}
}
@@ -3074,7 +3099,6 @@ sched_analyze_insn (struct deps_desc *deps, rtx x,
rtx_insn *insn)
if (DEBUG_INSN_P (insn))
{
rtx_insn *prev = deps->last_debug_insn;
- rtx_insn_list *u;
if (!deps->readonly)
deps->last_debug_insn = insn;
@@ -3086,8 +3110,12 @@ sched_analyze_insn (struct deps_desc *deps, rtx x,
rtx_insn *insn)
REG_DEP_ANTI, false);
if (!sel_sched_p ())
- for (u = deps->last_pending_memory_flush; u; u = u->next ())
- add_dependence (insn, u->insn (), REG_DEP_ANTI);
+ {
+ unsigned int len = deps->last_pending_memory_flush.length ();
+ for (unsigned int i = len - 1; i < len; i--)
+ add_dependence (insn, deps->last_pending_memory_flush[i],
+ REG_DEP_ANTI);
+ }
EXECUTE_IF_SET_IN_REG_SET (reg_pending_uses, 0, i, rsi)
{
@@ -3653,8 +3681,7 @@ deps_analyze_insn (struct deps_desc *deps, rtx_insn *insn)
if (deps->pending_flush_length++ >= MAX_PENDING_LIST_LENGTH)
flush_pending_lists (deps, insn, true, true);
else
- deps->pending_jump_insns
- = alloc_INSN_LIST (insn, deps->pending_jump_insns);
+ deps->pending_jump_insns.safe_push (insn);
}
/* For each insn which shouldn't cross a jump, add a dependence. */
@@ -3903,11 +3930,11 @@ init_deps (struct deps_desc *deps, bool lazy_reg_last)
deps->pending_read_mems = 0;
deps->pending_write_insns.create (0);
deps->pending_write_mems = 0;
- deps->pending_jump_insns = 0;
+ deps->pending_jump_insns.create (0);
deps->pending_read_list_length = 0;
deps->pending_write_list_length = 0;
deps->pending_flush_length = 0;
- deps->last_pending_memory_flush = 0;
+ deps->last_pending_memory_flush.create (0);
deps->last_function_call = 0;
deps->last_function_call_may_noreturn = 0;
deps->sched_before_next_call = 0;
@@ -3951,7 +3978,7 @@ free_deps (struct deps_desc *deps)
free_EXPR_LIST_list (&deps->pending_read_mems);
deps->pending_write_insns.release ();
free_EXPR_LIST_list (&deps->pending_write_mems);
- free_INSN_LIST_list (&deps->last_pending_memory_flush);
+ deps->last_pending_memory_flush.release ();
/* Without the EXECUTE_IF_SET, this loop is executed max_reg * nr_regions
times. For a testcase with 42000 regs and 8000 small basic blocks,
diff --git a/gcc/sched-int.h b/gcc/sched-int.h
index 45890b8..d75a85c 100644
--- a/gcc/sched-int.h
+++ b/gcc/sched-int.h
@@ -478,7 +478,7 @@ struct deps_desc
rtx_expr_list *pending_write_mems;
/* An INSN_LIST containing all jump insns. */
- rtx_insn_list *pending_jump_insns;
+ vec<rtx_insn *> pending_jump_insns;
/* We must prevent the above lists from ever growing too large since
the number of dependencies produced is at least O(N*N),
@@ -505,7 +505,7 @@ struct deps_desc
alias analysis, this restriction can be relaxed.
This may also be an INSN that writes memory if the pending lists grow
too large. */
- rtx_insn_list *last_pending_memory_flush;
+ vec<rtx_insn *> last_pending_memory_flush;
/* A list of the last function calls we have seen. We use a list to
represent last function calls from multiple predecessor blocks.
diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c
index 9e807a1..6ba4757 100644
--- a/gcc/sched-rgn.c
+++ b/gcc/sched-rgn.c
@@ -2620,12 +2620,8 @@ deps_join (struct deps_desc *succ_deps, struct deps_desc
*pred_deps)
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,
- succ_deps->pending_jump_insns);
- succ_deps->last_pending_memory_flush
- = concat_INSN_LIST (pred_deps->last_pending_memory_flush,
- succ_deps->last_pending_memory_flush);
+ succ_deps->pending_jump_insns.safe_splice (pred_deps->pending_jump_insns);
+ succ_deps->last_pending_memory_flush.safe_splice
(pred_deps->last_pending_memory_flush);
succ_deps->pending_read_list_length += pred_deps->pending_read_list_length;
succ_deps->pending_write_list_length += pred_deps->pending_write_list_length;
@@ -2672,17 +2668,17 @@ propagate_deps (int bb, struct deps_desc *pred_deps)
pred_deps->pending_read_insns = vNULL;
bb_deps[bb].pending_write_insns = pred_deps->pending_write_insns;
pred_deps->pending_write_insns = vNULL;
+ bb_deps[bb].pending_jump_insns = pred_deps->pending_jump_insns;
+ pred_deps->pending_jump_insns = vNULL;
/* These lists should point to the right place, for correct
freeing later. */
bb_deps[bb].pending_read_mems = pred_deps->pending_read_mems;
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_mems = 0;
pred_deps->pending_write_mems = 0;
- pred_deps->pending_jump_insns = 0;
}
/* Compute dependences inside bb. In a multiple blocks region:
@@ -2761,7 +2757,7 @@ free_pending_lists (void)
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);
+ bb_deps[bb].pending_jump_insns.release ();
}
}
--
2.7.4
