[PATCH 18/18] make last_pending_memory_flush a vec

[tbsaunde+gcc at tbsaunde dot org]

From: Trevor Saunders <tbsaunde+gcc@tbsaunde.org>

Same story for the new functions here as for the previous patch.

gcc/ChangeLog:

2016-04-20  Trevor Saunders  <tbsaunde+gcc@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