This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

RFA: patch to solve PR 39762.


The problem is described on

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=39762


The patch has been successfully bootstrapped on x86_64. Ok to commit into the trunk?



2009-04-15 Vladimir Makarov <vmakarov@redhat.com>


PR rtl-optimization/39762
* ira-int.h (ira_register_move_cost, ira_may_move_in_cost,
ira_may_move_out_cost): Add comments about way of their usage.
(ira_get_register_move_cost, ira_get_may_move_cost): New
functions.
* ira-conflicts.c (process_regs_for_copy): Use function
ira_get_register_move_cost instead of global
ira_register_move_cost.


   * ira-color.c (update_copy_costs, calculate_allocno_spill_cost,
   color_pass, move_spill_restore, update_curr_costs): Ditto.

* ira-lives.c (process_single_reg_class_operands): Ditto.

* ira-emit.c (emit_move_list): Ditto.

* ira-costs.c (copy_cost): Don't call ira_init_register_move_cost.
(record_reg_classes): Ditto. Use functions
ira_get_register_move_cost and ira_get_may_move_cost instead of
global vars ira_register_move_cost, ira_may_move_out_cost and
ira_may_move_in_cost.
(record_address_regs): Don't call ira_init_register_move_cost.
Use function ira_get_may_move_cost instead of global
ira_may_move_in_cost.
(process_bb_node_for_hard_reg_moves): Use function
ira_get_register_move_cost instead of global
ira_register_move_cost.
(ira_costs): Don't call ira_init_register_move_cost.


Index: ira-int.h
===================================================================
--- ira-int.h	(revision 146051)
+++ ira-int.h	(working copy)
@@ -730,21 +730,24 @@ ira_allocno_set_iter_next (ira_allocno_s
 extern HARD_REG_SET ira_reg_mode_hard_regset
                     [FIRST_PSEUDO_REGISTER][NUM_MACHINE_MODES];
 
-/* Arrays analogous to macros MEMORY_MOVE_COST and
-   REGISTER_MOVE_COST.  */
+/* Arrays analogous to macros MEMORY_MOVE_COST and REGISTER_MOVE_COST.
+   Don't use ira_register_move_cost directly.  Use function of
+   ira_get_may_move_cost instead.  */
 extern short ira_memory_move_cost[MAX_MACHINE_MODE][N_REG_CLASSES][2];
 extern move_table *ira_register_move_cost[MAX_MACHINE_MODE];
 
 /* Similar to may_move_in_cost but it is calculated in IRA instead of
    regclass.  Another difference we take only available hard registers
    into account to figure out that one register class is a subset of
-   the another one.  */
+   the another one.  Don't use it directly.  Use function of
+   ira_get_may_move_cost instead.  */
 extern move_table *ira_may_move_in_cost[MAX_MACHINE_MODE];
 
 /* Similar to may_move_out_cost but it is calculated in IRA instead of
    regclass.  Another difference we take only available hard registers
    into account to figure out that one register class is a subset of
-   the another one.  */
+   the another one.  Don't use it directly.  Use function of
+   ira_get_may_move_cost instead.  */
 extern move_table *ira_may_move_out_cost[MAX_MACHINE_MODE];
 
 /* Register class subset relation: TRUE if the first class is a subset
@@ -941,6 +944,34 @@ extern void ira_emit (bool);
 
 
 
+/* Return cost of moving value of MODE from register of class FROM to
+   register of class TO.  */
+static inline int
+ira_get_register_move_cost (enum machine_mode mode,
+			    enum reg_class from, enum reg_class to)
+{
+  if (ira_register_move_cost[mode] == NULL)
+    ira_init_register_move_cost (mode);
+  return ira_register_move_cost[mode][from][to];
+}
+
+/* Return cost of moving value of MODE from register of class FROM to
+   register of class TO.  Return zero if IN_P is true and FROM is
+   subset of TO or if IN_P is false and FROM is superset of TO.  */
+static inline int
+ira_get_may_move_cost (enum machine_mode mode,
+		       enum reg_class from, enum reg_class to,
+		       bool in_p)
+{
+  if (ira_register_move_cost[mode] == NULL)
+    ira_init_register_move_cost (mode);
+  return (in_p
+	  ? ira_may_move_in_cost[mode][from][to]
+	  : ira_may_move_out_cost[mode][from][to]);
+}
+
+
+
 /* The iterator for all allocnos.  */
 typedef struct {
   /* The number of the current element in IRA_ALLOCNOS.  */
Index: ira-conflicts.c
===================================================================
--- ira-conflicts.c	(revision 146051)
+++ ira-conflicts.c	(working copy)
@@ -411,9 +411,9 @@ process_regs_for_copy (rtx reg1, rtx reg
     /* Can not be tied.  It is not in the cover class.  */
     return false;
   if (HARD_REGISTER_P (reg1))
-    cost = ira_register_move_cost[mode][cover_class][rclass] * freq;
+    cost = ira_get_register_move_cost (mode, cover_class, rclass) * freq;
   else
-    cost = ira_register_move_cost[mode][rclass][cover_class] * freq;
+    cost = ira_get_register_move_cost (mode, rclass, cover_class) * freq;
   for (;;)
     {
       ira_allocate_and_set_costs
Index: ira-color.c
===================================================================
--- ira-color.c	(revision 146051)
+++ ira-color.c	(working copy)
@@ -285,8 +285,8 @@ update_copy_costs (ira_allocno_t allocno
 	    continue;
 
 	  cost = (cp->second == allocno
-		  ? ira_register_move_cost[mode][rclass][cover_class]
-		  : ira_register_move_cost[mode][cover_class][rclass]);
+		  ? ira_get_register_move_cost (mode, rclass, cover_class)
+		  : ira_get_register_move_cost (mode, cover_class, rclass));
 	  if (decr_p)
 	    cost = -cost;
 
@@ -1071,7 +1071,7 @@ calculate_allocno_spill_cost (ira_allocn
 	      * ira_loop_edge_freq (loop_node, regno, true)
 	      + ira_memory_move_cost[mode][rclass][0]
 	      * ira_loop_edge_freq (loop_node, regno, false))
-	     - (ira_register_move_cost[mode][rclass][rclass]
+	     - (ira_get_register_move_cost (mode, rclass, rclass)
 		* (ira_loop_edge_freq (loop_node, regno, false)
 		   + ira_loop_edge_freq (loop_node, regno, true))));
   return cost;
@@ -2039,7 +2039,7 @@ color_pass (ira_loop_tree_node_t loop_tr
 	  else
 	    {
 	      cover_class = ALLOCNO_COVER_CLASS (subloop_allocno);
-	      cost = (ira_register_move_cost[mode][rclass][rclass] 
+	      cost = (ira_get_register_move_cost (mode, rclass, rclass)
 		      * (exit_freq + enter_freq));
 	      ira_allocate_and_set_or_copy_costs
 		(&ALLOCNO_UPDATED_HARD_REG_COSTS (subloop_allocno), cover_class,
@@ -2164,7 +2164,7 @@ move_spill_restore (void)
 		    += (ira_memory_move_cost[mode][rclass][0] * exit_freq
 			+ ira_memory_move_cost[mode][rclass][1] * enter_freq);
 		  if (hard_regno2 != hard_regno)
-		    cost -= (ira_register_move_cost[mode][rclass][rclass]
+		    cost -= (ira_get_register_move_cost (mode, rclass, rclass)
 			     * (exit_freq + enter_freq));
 		}
 	    }
@@ -2183,7 +2183,7 @@ move_spill_restore (void)
 		    += (ira_memory_move_cost[mode][rclass][1] * exit_freq
 			+ ira_memory_move_cost[mode][rclass][0] * enter_freq);
 		  if (hard_regno2 != hard_regno)
-		    cost -= (ira_register_move_cost[mode][rclass][rclass]
+		    cost -= (ira_get_register_move_cost (mode, rclass, rclass)
 			     * (exit_freq + enter_freq));
 		}
 	    }
@@ -2249,8 +2249,8 @@ update_curr_costs (ira_allocno_t a)
       if (i < 0)
 	continue;
       cost = (cp->first == a
-	      ? ira_register_move_cost[mode][rclass][cover_class]
-	      : ira_register_move_cost[mode][cover_class][rclass]);
+	      ? ira_get_register_move_cost (mode, rclass, cover_class)
+	      : ira_get_register_move_cost (mode, cover_class, rclass));
       ira_allocate_and_set_or_copy_costs
 	(&ALLOCNO_UPDATED_HARD_REG_COSTS (a),
 	 cover_class, ALLOCNO_COVER_CLASS_COST (a),
Index: ira-lives.c
===================================================================
--- ira-lives.c	(revision 146051)
+++ ira-lives.c	(working copy)
@@ -782,10 +782,11 @@ process_single_reg_class_operands (bool 
 		  [ira_class_hard_regs[cl][0]]) >= 0
 	      && reg_class_size[cl] <= (unsigned) CLASS_MAX_NREGS (cl, mode))
 	    {
-	      /* ??? FREQ */
-	      cost = freq * (in_p
-			     ? ira_register_move_cost[mode][cover_class][cl]
-			     : ira_register_move_cost[mode][cl][cover_class]);
+	      cost
+		= (freq
+		   * (in_p
+		      ? ira_get_register_move_cost (mode, cover_class, cl)
+		      : ira_get_register_move_cost (mode, cl, cover_class)));
 	      ira_allocate_and_set_costs
 		(&ALLOCNO_CONFLICT_HARD_REG_COSTS (operand_a), cover_class, 0);
 	      ALLOCNO_CONFLICT_HARD_REG_COSTS (operand_a)
Index: ira-emit.c
===================================================================
--- ira-emit.c	(revision 146051)
+++ ira-emit.c	(working copy)
@@ -812,7 +812,8 @@ emit_move_list (move_t list, int freq)
 	}
       else
 	{
-	  cost = ira_register_move_cost[mode][cover_class][cover_class] * freq;
+	  cost = (ira_get_register_move_cost (mode, cover_class, cover_class)
+		  * freq);
 	  ira_shuffle_cost += cost;
 	}
       ira_overall_cost += cost;
Index: ira-costs.c
===================================================================
--- ira-costs.c	(revision 146051)
+++ ira-costs.c	(working copy)
@@ -138,9 +138,6 @@ copy_cost (rtx x, enum machine_mode mode
   sri.extra_cost = 0;
   secondary_class = targetm.secondary_reload (to_p, x, rclass, mode, &sri);
 
-  if (ira_register_move_cost[mode] == NULL)
-    ira_init_register_move_cost (mode);
-
   if (secondary_class != NO_REGS)
     {
       if (!move_cost[mode])
@@ -294,19 +291,17 @@ record_reg_classes (int n_alts, int n_op
 		     needs to do a copy, which is one insn.  */
 		  struct costs *pp = this_op_costs[i];
 
-		  if (ira_register_move_cost[mode] == NULL)
-		    ira_init_register_move_cost (mode);
-
 		  for (k = 0; k < cost_classes_num; k++)
 		    {
 		      rclass = cost_classes[k];
 		      pp->cost[k]
-			= ((recog_data.operand_type[i] != OP_OUT
-			    ? ira_may_move_in_cost[mode][rclass]
-			      [classes[i]] * frequency : 0)
-			   + (recog_data.operand_type[i] != OP_IN
-			      ? ira_may_move_out_cost[mode][classes[i]]
-			        [rclass] * frequency : 0));
+			= (((recog_data.operand_type[i] != OP_OUT
+			     ? ira_get_may_move_cost (mode, rclass,
+						      classes[i], true) : 0)
+			    + (recog_data.operand_type[i] != OP_IN
+			       ? ira_get_may_move_cost (mode, classes[i],
+							rclass, false) : 0))
+			   * frequency);
 		    }
 
 		  /* If the alternative actually allows memory, make
@@ -342,8 +337,9 @@ record_reg_classes (int n_alts, int n_op
 				 : 0));
 		      else if (ira_reg_class_intersect
 			       [pref_class][classes[i]] == NO_REGS)
-			alt_cost += (ira_register_move_cost
-				     [mode][pref_class][classes[i]]);
+			alt_cost += ira_get_register_move_cost (mode,
+								pref_class,
+								classes[i]);
 		    }
 		  if (REGNO (ops[i]) != REGNO (ops[j])
 		      && ! find_reg_note (insn, REG_DEAD, op))
@@ -540,19 +536,17 @@ record_reg_classes (int n_alts, int n_op
 		{
 		  struct costs *pp = this_op_costs[i];
 
-		  if (ira_register_move_cost[mode] == NULL)
-		    ira_init_register_move_cost (mode);
-
 		  for (k = 0; k < cost_classes_num; k++)
 		    {
 		      rclass = cost_classes[k];
 		      pp->cost[k]
-			= ((recog_data.operand_type[i] != OP_OUT
-			    ? ira_may_move_in_cost[mode][rclass]
-			      [classes[i]] * frequency : 0)
-			   + (recog_data.operand_type[i] != OP_IN
-			      ? ira_may_move_out_cost[mode][classes[i]]
-			        [rclass] * frequency : 0));
+			= (((recog_data.operand_type[i] != OP_OUT
+			     ? ira_get_may_move_cost (mode, rclass,
+						      classes[i], true) : 0)
+			    + (recog_data.operand_type[i] != OP_IN
+			       ? ira_get_may_move_cost (mode, classes[i],
+							rclass, false) : 0))
+			   * frequency);
 		    }
 
 		  /* If the alternative actually allows memory, make
@@ -587,8 +581,9 @@ record_reg_classes (int n_alts, int n_op
 				 : 0));
 		      else if (ira_reg_class_intersect[pref_class][classes[i]]
 			       == NO_REGS)
-			alt_cost += (ira_register_move_cost
-				     [mode][pref_class][classes[i]]);
+			alt_cost += ira_get_register_move_cost (mode,
+								pref_class,
+								classes[i]);
 		    }
 		}
 	    }
@@ -901,13 +896,11 @@ record_address_regs (enum machine_mode m
 			       ALLOCNO_NUM (ira_curr_regno_allocno_map
 					    [REGNO (x)]));
 	pp->mem_cost += (ira_memory_move_cost[Pmode][rclass][1] * scale) / 2;
-	if (ira_register_move_cost[Pmode] == NULL)
-	  ira_init_register_move_cost (Pmode);
 	for (k = 0; k < cost_classes_num; k++)
 	  {
 	    i = cost_classes[k];
 	    pp->cost[k]
-	      += (ira_may_move_in_cost[Pmode][i][rclass] * scale) / 2;
+	      += (ira_get_may_move_cost (Pmode, i, rclass, true) * scale) / 2;
 	  }
       }
       break;
@@ -1425,8 +1418,9 @@ process_bb_node_for_hard_reg_moves (ira_
 	continue;
       mode = ALLOCNO_MODE (a);
       hard_reg_class = REGNO_REG_CLASS (hard_regno);
-      cost = (to_p ? ira_register_move_cost[mode][hard_reg_class][rclass]
-	      : ira_register_move_cost[mode][rclass][hard_reg_class]) * freq;
+      cost
+	= (to_p ? ira_get_register_move_cost (mode, hard_reg_class, rclass)
+	   : ira_get_register_move_cost (mode, rclass, hard_reg_class)) * freq;
       ira_allocate_and_set_costs (&ALLOCNO_HARD_REG_COSTS (a), rclass,
 				  ALLOCNO_COVER_CLASS_COST (a));
       ira_allocate_and_set_costs (&ALLOCNO_CONFLICT_HARD_REG_COSTS (a),
@@ -1579,9 +1573,6 @@ ira_finish_costs_once (void)
 void
 ira_costs (void)
 {
-  ira_allocno_t a;
-  ira_allocno_iterator ai;
-
   allocno_costs = (struct costs *) ira_allocate (max_struct_costs_size
 					       * ira_allocnos_num);
   total_costs = (struct costs *) ira_allocate (max_struct_costs_size
@@ -1594,12 +1585,6 @@ ira_costs (void)
 				       * max_reg_num ());
   find_allocno_class_costs ();
   setup_allocno_cover_class_and_costs ();
-  /* Because we could process operands only as subregs, check mode of
-     the registers themselves too.  */
-  FOR_EACH_ALLOCNO (a, ai)
-    if (ira_register_move_cost[ALLOCNO_MODE (a)] == NULL
-	&& have_regs_of_mode[ALLOCNO_MODE (a)])
-      ira_init_register_move_cost (ALLOCNO_MODE (a));
   ira_free (common_classes);
   ira_free (allocno_pref_buffer);
   ira_free (total_costs);

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]