ira-int.h (ira_parent_allocno, [...]): Declare.

	* ira-int.h (ira_parent_allocno, ira_parent_or_cap_allocno): Declare.
	* ira-build.c (ira_parent_allocno, ira_parent_or_cap_allocno): New
	functions.
	(ira_flattening): Use ira_parent_allocno.
	* ira-conflicts.c (process_regs_for_copy, propagate_copies)
	build_allocno_conflicts): Use ira_parent_or_cap_allocno.

From-SVN: r161347

1 files changed, 9 insertions, 23 deletions

diff --git a/gcc/ira-conflicts.c b/gcc/ira-conflicts.c
index 70100ac..9b66150 100644
--- a/gcc/ira-conflicts.c
+++ b/gcc/ira-conflicts.c
@@ -346,7 +346,6 @@ process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
   enum reg_class rclass, cover_class;
   enum machine_mode mode;
   ira_copy_t cp;
-  ira_loop_tree_node_t parent;
 
   gcc_assert (REG_SUBREG_P (reg1) && REG_SUBREG_P (reg2));
   only_regs_p = REG_P (reg1) && REG_P (reg2);
@@ -397,7 +396,7 @@ process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
     cost = ira_get_register_move_cost (mode, cover_class, rclass) * freq;
   else
     cost = ira_get_register_move_cost (mode, rclass, cover_class) * freq;
-  for (;;)
+  do
     {
       ira_allocate_and_set_costs
 	(&ALLOCNO_HARD_REG_COSTS (a), cover_class,
@@ -408,12 +407,9 @@ process_regs_for_copy (rtx reg1, rtx reg2, bool constraint_p,
       ALLOCNO_CONFLICT_HARD_REG_COSTS (a)[index] -= cost;
       if (ALLOCNO_HARD_REG_COSTS (a)[index] < ALLOCNO_COVER_CLASS_COST (a))
 	ALLOCNO_COVER_CLASS_COST (a) = ALLOCNO_HARD_REG_COSTS (a)[index];
-      if (ALLOCNO_CAP (a) != NULL)
-	a = ALLOCNO_CAP (a);
-      else if ((parent = ALLOCNO_LOOP_TREE_NODE (a)->parent) == NULL
-	       || (a = parent->regno_allocno_map[ALLOCNO_REGNO (a)]) == NULL)
-	break;
+      a = ira_parent_or_cap_allocno (a);
     }
+  while (a != NULL);
   return true;
 }
 
@@ -533,7 +529,6 @@ propagate_copies (void)
   ira_copy_t cp;
   ira_copy_iterator ci;
   ira_allocno_t a1, a2, parent_a1, parent_a2;
-  ira_loop_tree_node_t parent;
 
   FOR_EACH_COPY (cp, ci)
     {
@@ -542,11 +537,8 @@ propagate_copies (void)
       if (ALLOCNO_LOOP_TREE_NODE (a1) == ira_loop_tree_root)
 	continue;
       ira_assert ((ALLOCNO_LOOP_TREE_NODE (a2) != ira_loop_tree_root));
-      parent = ALLOCNO_LOOP_TREE_NODE (a1)->parent;
-      if ((parent_a1 = ALLOCNO_CAP (a1)) == NULL)
-	parent_a1 = parent->regno_allocno_map[ALLOCNO_REGNO (a1)];
-      if ((parent_a2 = ALLOCNO_CAP (a2)) == NULL)
-	parent_a2 = parent->regno_allocno_map[ALLOCNO_REGNO (a2)];
+      parent_a1 = ira_parent_or_cap_allocno (a1);
+      parent_a2 = ira_parent_or_cap_allocno (a2);
       ira_assert (parent_a1 != NULL && parent_a2 != NULL);
       if (! CONFLICT_ALLOCNO_P (parent_a1, parent_a2))
 	ira_add_allocno_copy (parent_a1, parent_a2, cp->freq,
@@ -565,7 +557,6 @@ build_allocno_conflicts (ira_allocno_t a)
 {
   int i, px, parent_num;
   int conflict_bit_vec_words_num;
-  ira_loop_tree_node_t parent;
   ira_allocno_t parent_a, another_a, another_parent_a;
   ira_allocno_t *vec;
   IRA_INT_TYPE *allocno_conflicts;
@@ -601,13 +592,9 @@ build_allocno_conflicts (ira_allocno_t a)
       ALLOCNO_CONFLICT_ALLOCNO_ARRAY_SIZE (a)
 	= conflict_bit_vec_words_num * sizeof (IRA_INT_TYPE);
     }
-  parent = ALLOCNO_LOOP_TREE_NODE (a)->parent;
-  if ((parent_a = ALLOCNO_CAP (a)) == NULL
-      && (parent == NULL
-	  || (parent_a = parent->regno_allocno_map[ALLOCNO_REGNO (a)])
-	  == NULL))
+  parent_a = ira_parent_or_cap_allocno (a);
+  if (parent_a == NULL)
     return;
-  ira_assert (parent != NULL);
   ira_assert (ALLOCNO_COVER_CLASS (a) == ALLOCNO_COVER_CLASS (parent_a));
   parent_num = ALLOCNO_NUM (parent_a);
   FOR_EACH_ALLOCNO_IN_SET (allocno_conflicts,
@@ -616,9 +603,8 @@ build_allocno_conflicts (ira_allocno_t a)
       another_a = ira_conflict_id_allocno_map[i];
       ira_assert (ira_reg_classes_intersect_p
 		  [ALLOCNO_COVER_CLASS (a)][ALLOCNO_COVER_CLASS (another_a)]);
-      if ((another_parent_a = ALLOCNO_CAP (another_a)) == NULL
-	  && (another_parent_a = (parent->regno_allocno_map
-				  [ALLOCNO_REGNO (another_a)])) == NULL)
+      another_parent_a = ira_parent_or_cap_allocno (another_a);
+      if (another_parent_a == NULL)
 	continue;
       ira_assert (ALLOCNO_NUM (another_parent_a) >= 0);
       ira_assert (ALLOCNO_COVER_CLASS (another_a)