This is the mail archive of the gcc@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]

Re: [RFC] avoiding too narrow register classes in reload

On Dec 14, 2004, Richard Henderson <rth@redhat.com> wrote:

> On Mon, Dec 13, 2004 at 07:20:21PM -0200, Alexandre Oliva wrote:
>> Does this look like a reasonable approach?

> Yes.

>> Should other locations that compare
>> reg_class_size with 1 be adjusted similarly?

> Probably would be good.

Here's the patch I've bootstrapped and tested on x86_64-linux-gnu.
There's one use of reg_class_size that I wasn't sure whether to
replace with the new macro, in combine_reloads():

							     rld[output_reload].out))))
	&& ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
					 rld[i].when_needed != RELOAD_FOR_INPUT)
	&& (reg_class_size[(int) rld[i].class] || SMALL_REGISTER_CLASSES)
	/* We will allow making things slightly worse by combining an
	   input and an output, but no worse than that.  */
	&& (rld[i].when_needed == RELOAD_FOR_INPUT

The logic was different from all other cases, that tested for
reg_class_size[...] == 1 || SMALL_REGISTER_CLASSES, and I couldn't
tell whether it was on purpose or a typo.  Can anyone?

I realize the patch introduces some possibly-significant semantic
changes, in that NO_REGS is now regarded as a SMALL_REGISTER_CLASS_P
and so it passes a number of cases where we tested for
reg_class_size[...] == 1 || SMALL_REGISTER_CLASSES.  Since
SMALL_REGISTER_CLASSES would pass, I figured this couldn't be a
problem.  The last hunk, where || SMALL_REGISTER_CLASSES wasn't
present, uses the new predicate but also ensures that reg_class_size
is non-zero (it broke otherwise).  Does it make sense to narrow the
predicate to hold only for non-empty classes, and adjust the
one-before-last hunk, that uses the negated predicate in a way that
requires it to hold for empty classes?

Ok to install this for now?


Index: gcc/ChangeLog
from  Alexandre Oliva  <aoliva@redhat.com>

	* reload.c (SMALL_REGISTER_CLASS_P): New.
	(push_secondary_reload, find_reusable_reload, find_reloads): Use
	it instead of testing only the class size.

Index: gcc/reload.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/reload.c,v
retrieving revision 1.260
diff -u -p -r1.260 reload.c
--- gcc/reload.c 7 Dec 2004 01:14:40 -0000 1.260
+++ gcc/reload.c 14 Dec 2004 21:16:57 -0000
@@ -113,6 +113,12 @@ a register with any other reload.  */
   (CONSTANT_P (X)				\
    && GET_CODE (X) != HIGH			\
    && !targetm.cannot_force_const_mem (X))
+
+/* True if C is a register class that has too few registers to be
+   safely used as a reload target class.  */
+#define SMALL_REGISTER_CLASS_P(C) \
+  (reg_class_size [(int)(C)] <= 1 || CLASS_LIKELY_SPILLED_P (C))
+
 
 /* All reloads of the current insn are recorded here.  See reload.h for
    comments.  */
@@ -443,7 +449,7 @@ push_secondary_reload (int in_p, rtx x, 
 			  == CODE_FOR_nothing))
 		|| (! in_p &&(rld[t_reload].secondary_out_icode
 			      == CODE_FOR_nothing)))
-	    && (reg_class_size[(int) t_class] == 1 || SMALL_REGISTER_CLASSES)
+	    && (SMALL_REGISTER_CLASS_P (t_class) || SMALL_REGISTER_CLASSES)
 	    && MERGABLE_RELOADS (secondary_type,
 				 rld[t_reload].when_needed,
 				 opnum, rld[t_reload].opnum))
@@ -501,7 +507,7 @@ push_secondary_reload (int in_p, rtx x, 
 	    || (! in_p && rld[s_reload].secondary_out_reload == t_reload))
 	&& ((in_p && rld[s_reload].secondary_in_icode == t_icode)
 	    || (! in_p && rld[s_reload].secondary_out_icode == t_icode))
-	&& (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
+	&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
 	&& MERGABLE_RELOADS (secondary_type, rld[s_reload].when_needed,
 			     opnum, rld[s_reload].opnum))
       {
@@ -755,7 +761,7 @@ find_reusable_reload (rtx *p_in, rtx out
 	    || (out != 0 && MATCHES (rld[i].out, out)
 		&& (in == 0 || rld[i].in == 0 || MATCHES (rld[i].in, in))))
 	&& (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
-	&& (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
+	&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
 	&& MERGABLE_RELOADS (type, rld[i].when_needed, opnum, rld[i].opnum))
       return i;
 
@@ -780,7 +786,7 @@ find_reusable_reload (rtx *p_in, rtx out
 		&& GET_RTX_CLASS (GET_CODE (in)) == RTX_AUTOINC
 		&& MATCHES (XEXP (in, 0), rld[i].in)))
 	&& (rld[i].out == 0 || ! earlyclobber_operand_p (rld[i].out))
-	&& (reg_class_size[(int) class] == 1 || SMALL_REGISTER_CLASSES)
+	&& (SMALL_REGISTER_CLASS_P (class) || SMALL_REGISTER_CLASSES)
 	&& MERGABLE_RELOADS (type, rld[i].when_needed,
 			     opnum, rld[i].opnum))
       {
@@ -1768,8 +1774,7 @@ combine_reloads (void)
 							     rld[output_reload].out))))
 	&& ! reload_inner_reg_of_subreg (rld[i].in, rld[i].inmode,
 					 rld[i].when_needed != RELOAD_FOR_INPUT)
-	&& (reg_class_size[(int) rld[i].class]
-	    || SMALL_REGISTER_CLASSES)
+	&& (reg_class_size[(int) rld[i].class] || SMALL_REGISTER_CLASSES)
 	/* We will allow making things slightly worse by combining an
 	   input and an output, but no worse than that.  */
 	&& (rld[i].when_needed == RELOAD_FOR_INPUT
@@ -3484,7 +3489,7 @@ find_reloads (rtx insn, int replace, int
 	  if (! win && ! did_match
 	      && this_alternative[i] != (int) NO_REGS
 	      && GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD
-	      && reg_class_size[(int) preferred_class[i]] > 1)
+	      && ! SMALL_REGISTER_CLASS_P (preferred_class[i]))
 	    {
 	      if (! reg_class_subset_p (this_alternative[i],
 					preferred_class[i]))
@@ -3542,7 +3547,8 @@ find_reloads (rtx insn, int replace, int
 		{
 		  /* If the output is in a single-reg class,
 		     it's costly to reload it, so reload the input instead.  */
-		  if (reg_class_size[this_alternative[i]] == 1
+		  if (reg_class_size[this_alternative[i]] > 0
+		      && SMALL_REGISTER_CLASS_P (this_alternative[i])
 		      && (REG_P (recog_data.operand[j])
 			  || GET_CODE (recog_data.operand[j]) == SUBREG))
 		    {

-- 
Alexandre Oliva             http://www.ic.unicamp.br/~oliva/
Red Hat Compiler Engineer   aoliva@{redhat.com, gcc.gnu.org}
Free Software Evangelist  oliva@{lsd.ic.unicamp.br, gnu.org}
Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]