reload.h (earlyclobber_operand_p): Declare.

	* reload.h (earlyclobber_operand_p): Declare.
	* reload.c (earlyclobber_operand_p): Don't declare.  No longer static.
	* reload1.c (reload_reg_free_for_value_p):  RELOAD_OTHER reloads with
	an earlyclobbered output conflict with RELOAD_INPUT reloads - handle
	case where the RELOAD_OTHER reload is new.  Use earlyclobber_operand_p.

From-SVN: r30202

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6614d8ba543b3c3c0afb2186e59ef9caadde21f1..bbec9cfcd1ed20dd9fe31602080f89bd4095f6aa 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,11 @@
+Wed Oct 27 03:09:23 1999  J"orn Rennecke <amylaar@cygnus.co.uk>
+
+       * reload.h (earlyclobber_operand_p): Declare.
+       * reload.c (earlyclobber_operand_p): Don't declare.  No longer static.
+       * reload1.c (reload_reg_free_for_value_p):  RELOAD_OTHER reloads with
+       an earlyclobbered output conflict with RELOAD_INPUT reloads - handle
+       case where the RELOAD_OTHER reload is new.  Use earlyclobber_operand_p.
+
 Tue Oct 26 18:23:38 1999  Jan Hubicka  <hubicka@freesoft.cz>
                          Richard Henderson  <rth@cygnus.com>
 

diff --git a/gcc/reload.c b/gcc/reload.c
index bd32ba303417e9a8098ef207f364510f16e2d773..40103390727d333d0d04960fa1d24adb23de5a57 100644 (file)
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -252,7 +252,6 @@ static int find_reusable_reload     PROTO((rtx *, rtx, enum reg_class,
 static rtx find_dummy_reload   PROTO((rtx, rtx, rtx *, rtx *,
                                       enum machine_mode, enum machine_mode,
                                       enum reg_class, int, int));
-static int earlyclobber_operand_p PROTO((rtx));
 static int hard_reg_set_here_p PROTO((int, int, rtx));
 static struct decomposition decompose PROTO((rtx));
 static int immune_p            PROTO((rtx, rtx, struct decomposition));
@@ -1921,7 +1920,7 @@ find_dummy_reload (real_in, real_out, inloc, outloc,
 
 /* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
 
-static int
+int
 earlyclobber_operand_p (x)
      rtx x;
 {

diff --git a/gcc/reload.h b/gcc/reload.h
index c07515fe12b151dd95adc2bfe2b33de35964341f..953e0592ce088a2cd8c7541b6bb6d01cca598cf8 100644 (file)
--- a/gcc/reload.h
+++ b/gcc/reload.h
@@ -354,6 +354,9 @@ extern rtx find_equiv_reg PROTO((rtx, rtx, enum reg_class, int, short *,
 /* Return 1 if register REGNO is the subject of a clobber in insn INSN.  */
 extern int regno_clobbered_p PROTO((int, rtx));
 
+/* Return 1 if X is an operand of an insn that is being earlyclobbered.  */
+int earlyclobber_operand_p PROTO((rtx));
+
 /* Functions in reload1.c:  */
 
 extern int reloads_conflict            PROTO ((int, int));

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 0528860c15d36d8237f01484997f3875b95eff84..955acca04942623443decb857a67b8d29248ee8e 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -5291,6 +5291,10 @@ reload_reg_free_for_value_p (regno, opnum, type, value, out, reloadnum,
      int ignore_address_reloads;
 {
   int time1;
+  /* Set if we see an input reload that must not share its reload register
+     with any new earlyclobber, but might otherwise share the reload
+     register with an output or input-output reload.  */
+  int check_earlyclobber = 0;
   int i;
   int copy = 0;
 
@@ -5372,7 +5376,7 @@ reload_reg_free_for_value_p (regno, opnum, type, value, out, reloadnum,
          if (! rld[i].in || ! rtx_equal_p (rld[i].in, value)
              || rld[i].out || out)
            {
-             int j, time2;
+             int time2;
              switch (rld[i].when_needed)
                {
                case RELOAD_FOR_OTHER_ADDRESS:
@@ -5411,6 +5415,7 @@ reload_reg_free_for_value_p (regno, opnum, type, value, out, reloadnum,
                  break;
                case RELOAD_FOR_INPUT:
                  time2 = rld[i].opnum * 4 + 4;
+                 check_earlyclobber = 1;
                  break;
                  /* rld[i].opnum * 4 + 4 <= (MAX_RECOG_OPERAND - 1) * 4 + 4
                     == MAX_RECOG_OPERAND * 4  */
@@ -5423,6 +5428,7 @@ reload_reg_free_for_value_p (regno, opnum, type, value, out, reloadnum,
                  break;
                case RELOAD_FOR_OPERAND_ADDRESS:
                  time2 = MAX_RECOG_OPERANDS * 4 + 2;
+                 check_earlyclobber = 1;
                  break;
                case RELOAD_FOR_INSN:
                  time2 = MAX_RECOG_OPERANDS * 4 + 3;
@@ -5452,9 +5458,8 @@ reload_reg_free_for_value_p (regno, opnum, type, value, out, reloadnum,
                    {
                      time2 = MAX_RECOG_OPERANDS * 4 + 4;
                      /* Earlyclobbered outputs must conflict with inputs.  */
-                     for (j = 0; j < n_earlyclobbers; j++)
-                       if (rld[i].out == reload_earlyclobbers[j])
-                         time2 = MAX_RECOG_OPERANDS * 4 + 3;
+                     if (earlyclobber_operand_p (rld[i].out))
+                       time2 = MAX_RECOG_OPERANDS * 4 + 3;
                          
                      break;
                    }
@@ -5478,6 +5483,11 @@ reload_reg_free_for_value_p (regno, opnum, type, value, out, reloadnum,
            }
        }
     }
+
+  /* Earlyclobbered outputs must conflict with inputs.  */
+  if (check_earlyclobber && out && earlyclobber_operand_p (out))
+    return 0;
+
   return 1;
 }