Small local-alloc tweak

[Bernd Schmidt]

GCC's global register allocator used to have a restriction: when a register
was spilled in reload, and global was re-run, it could not do anything to
reallocate a register that had previously been allocated by local-alloc.

This restriction has been gone for a while now; I believe John Wehle
fixed it in 1998.  However, there's still code in local-alloc.c which
believes it has to be careful about allocating registers that are likely
to be spilled.  This code is likely to be entirely bogus these days.
The patch below removes it; on average it seems to improve code quality
a tiny bit on sh-elf.  I've also seen byte benchmark improvements with
a smaller version of this patch earlier this year.

This patch does not always improve code, there are some (relatively minor)
regressions as well.  These are likely to be due to other problems with the
local/global-alloc relationship.


Bernd

	* local-alloc.c (local_alloc): Ignore CLASS_LIKELY_SPILLED.
	(update_equiv_regs): Likewise, except for the mn10200 kludge.
	(combine_regs): Likewise.

Index: local-alloc.c
===================================================================
RCS file: /cvs/cvsfiles/devo/gcc/local-alloc.c,v
retrieving revision 1.108
diff -u -p -r1.108 local-alloc.c
--- local-alloc.c	2000/08/27 16:10:08	1.108
+++ local-alloc.c	2000/09/04 18:17:28
@@ -349,19 +349,14 @@ local_alloc ()
 
   /* Determine which pseudo-registers can be allocated by local-alloc.
      In general, these are the registers used only in a single block and
-     which only die once.  However, if a register's preferred class has only
-     a few entries, don't allocate this register here unless it is preferred
-     or nothing since retry_global_alloc won't be able to move it to
-     GENERAL_REGS if a reload register of this class is needed.
+     which only die once.
 
      We need not be concerned with which block actually uses the register
      since we will never see it outside that block.  */
 
   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
     {
-      if (REG_BASIC_BLOCK (i) >= 0 && REG_N_DEATHS (i) == 1
-	  && (reg_alternate_class (i) == NO_REGS
-	      || ! CLASS_LIKELY_SPILLED_P (reg_preferred_class (i))))
+      if (REG_BASIC_BLOCK (i) >= 0 && REG_N_DEATHS (i) == 1)
 	reg_qty[i] = -2;
       else
 	reg_qty[i] = -1;
@@ -789,15 +784,6 @@ update_equiv_regs ()
 	  note_stores (set, no_equiv, NULL);
 	  continue;
 	}
-      /* Don't handle the equivalence if the source is in a register
-	 class that's likely to be spilled.  */
-      if (GET_CODE (src) == REG
-	  && REGNO (src) >= FIRST_PSEUDO_REGISTER
-	  && CLASS_LIKELY_SPILLED_P (reg_preferred_class (REGNO (src))))
-	{
-	  no_equiv (dest, set, NULL);
-	  continue;
-	}
 
       note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
 
@@ -1653,11 +1639,6 @@ combine_regs (usedreg, setreg, may_save_
       || ureg == sreg
       /* Don't try to connect two different hardware registers.  */
       || (ureg < FIRST_PSEUDO_REGISTER && sreg < FIRST_PSEUDO_REGISTER)
-      /* Don't use a hard reg that might be spilled.  */
-      || (ureg < FIRST_PSEUDO_REGISTER
-	  && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (ureg)))
-      || (sreg < FIRST_PSEUDO_REGISTER
-	  && CLASS_LIKELY_SPILLED_P (REGNO_REG_CLASS (sreg)))
       /* Don't connect two different machine modes if they have different
 	 implications as to which registers may be used.  */
       || !MODES_TIEABLE_P (GET_MODE (usedreg), GET_MODE (setreg)))