*** empty log message ***

From-SVN: r790

gcc/cse.c

@@ -453,7 +453,7 @@ struct table_elt
       : (FIXED_REGNO_P (REGNO (X))			\
 	 && REGNO_REG_CLASS (REGNO (X)) != NO_REGS) ? 0	\
       : 2)						\
-   : rtx_cost (X) * 2)					\
+   : rtx_cost (X, SET) * 2)
 
 /* Determine if the quantity number for register X represents a valid index
    into the `qty_...' variables.  */
@@ -569,8 +569,9 @@ static void cse_set_around_loop ();
 #define COSTS_N_INSNS(N) ((N) * 4 - 2)
 
 int
-rtx_cost (x)
+rtx_cost (x, outer_code)
      rtx x;
+     enum rtx_code outer_code;
 {
   register int i, j;
   register enum rtx_code code;
@@ -627,9 +628,9 @@ rtx_cost (x)
 			      + GET_MODE_SIZE (GET_MODE (x)) / UNITS_PER_WORD);
       return 2;
 #ifdef RTX_COSTS
-      RTX_COSTS (x, code);
+      RTX_COSTS (x, code, outer_code);
 #endif 
-      CONST_COSTS (x, code);
+      CONST_COSTS (x, code, outer_code);
     }
 
   /* Sum the costs of the sub-rtx's, plus cost of this operation,
@@ -638,10 +639,10 @@ rtx_cost (x)
   fmt = GET_RTX_FORMAT (code);
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     if (fmt[i] == 'e')
-      total += rtx_cost (XEXP (x, i));
+      total += rtx_cost (XEXP (x, i), code);
     else if (fmt[i] == 'E')
       for (j = 0; j < XVECLEN (x, i); j++)
-	total += rtx_cost (XVECEXP (x, i, j));
+	total += rtx_cost (XVECEXP (x, i, j), code);
 
   return total;
 }
@@ -815,7 +816,7 @@ mention_regs (x)
   register int changed = 0;
 
   if (x == 0)
-    return;
+    return 0;
 
   code = GET_CODE (x);
   if (code == REG)
@@ -4157,6 +4158,11 @@ fold_rtx (x, insn)
 	  && (new = lookup_as_function (x, CONST_INT)) != 0)
 	return new;
 
+      /* If this is a paradoxical SUBREG, we can't do anything with
+	 it because we have no idea what value the extra bits would have.  */
+      if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
+	return x;
+
       /* Fold SUBREG_REG.  If it changed, see if we can simplify the SUBREG.
 	 We might be able to if the SUBREG is extracting a single word in an
 	 integral mode or extracting the low part.  */
@@ -4180,6 +4186,86 @@ fold_rtx (x, insn)
 	  if (new)
 	    return new;
 	}
+
+      /* If this is a narrowing SUBREG and our operand is a REG, see if
+	 we can find an equivalence for REG that is a arithmetic operation
+	 in a wider mode where both operands are paradoxical SUBREGs
+	 from objects of our result mode.  In that case, we couldn't report
+	 an equivalent value for that operation, since we don't know what the
+	 extra bits will be.  But we can find an equivalence for this SUBREG
+	 by folding that operation is the narrow mode.  This allows us to
+	 fold arithmetic in narrow modes when the machine only supports
+	 word-sized arithmetic.  */
+
+      if (GET_CODE (folded_arg0) == REG
+	  && GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (folded_arg0)))
+	{
+	  struct table_elt *elt;
+
+	  /* We can use HASH here since we know that canon_hash won't be
+	     called.  */
+	  elt = lookup (folded_arg0,
+			HASH (folded_arg0, GET_MODE (folded_arg0)),
+			GET_MODE (folded_arg0));
+
+	  if (elt)
+	    elt = elt->first_same_value;
+
+	  for (; elt; elt = elt->next_same_value)
+	    {
+	      /* Just check for unary and binary operations.  */
+	      if (GET_RTX_CLASS (GET_CODE (elt->exp)) == '1'
+		  && GET_CODE (elt->exp) != SIGN_EXTEND
+		  && GET_CODE (elt->exp) != ZERO_EXTEND
+		  && GET_CODE (XEXP (elt->exp, 0)) == SUBREG
+		  && GET_MODE (SUBREG_REG (XEXP (elt->exp, 0))) == mode)
+		{
+		  rtx op0 = SUBREG_REG (XEXP (elt->exp, 0));
+
+		  if (GET_CODE (op0) != REG && ! CONSTANT_P (op0))
+		    op0 = fold_rtx (op0, 0);
+
+		  op0 = equiv_constant (op0);
+		  if (op0)
+		    new = simplify_unary_operation (GET_CODE (elt->exp), mode,
+						    op0, mode);
+		}
+	      else if ((GET_RTX_CLASS (GET_CODE (elt->exp)) == '2'
+			|| GET_RTX_CLASS (GET_CODE (elt->exp)) == 'c')
+		       && ((GET_CODE (XEXP (elt->exp, 0)) == SUBREG
+			    && (GET_MODE (SUBREG_REG (XEXP (elt->exp, 0)))
+				== mode))
+			   || CONSTANT_P (XEXP (elt->exp, 0)))
+		       && ((GET_CODE (XEXP (elt->exp, 1)) == SUBREG
+			    && (GET_MODE (SUBREG_REG (XEXP (elt->exp, 1)))
+				== mode))
+			   || CONSTANT_P (XEXP (elt->exp, 1))))
+		{
+		  rtx op0 = gen_lowpart_common (mode, XEXP (elt->exp, 0));
+		  rtx op1 = gen_lowpart_common (mode, XEXP (elt->exp, 1));
+
+		  if (op0 && GET_CODE (op0) != REG && ! CONSTANT_P (op0))
+		    op0 = fold_rtx (op0, 0);
+
+		  if (op0)
+		    op0 = equiv_constant (op0);
+
+		  if (op1 && GET_CODE (op1) != REG && ! CONSTANT_P (op1))
+		    op1 = fold_rtx (op1, 0);
+
+		  if (op1)
+		    op1 = equiv_constant (op1);
+
+		  if (op0 && op1)
+		    new = simplify_binary_operation (GET_CODE (elt->exp), mode,
+						     op0, op1);
+		}
+
+	      if (new)
+		return new;
+	    }
+	}
+
       return x;
 
     case NOT:

gcc/genemit.c

@@ -47,12 +47,20 @@ static int insn_index_number;
 
 struct clobber_pat
 {
-  int code_number;		/* Counts only insns.  */
+  struct clobber_ent *insns;
   rtx pattern;
   int first_clobber;
   struct clobber_pat *next;
 } *clobber_list;
 
+/* Records one insn that uses the clobber list.  */
+
+struct clobber_ent
+{
+  int code_number;		/* Counts only insns.  */
+  struct clobber_ent *next;
+};
+
 static void
 max_operand_1 (x)
      rtx x;
@@ -271,14 +279,54 @@ gen_insn (insn)
 
       if (i != XVECLEN (insn, 1) - 1)
 	{
-	  register struct clobber_pat *new
-	    = (struct clobber_pat *) xmalloc (sizeof (struct clobber_pat));
+	  register struct clobber_pat *p;
+	  register struct clobber_ent *link
+	    = (struct clobber_ent *) xmalloc (sizeof (struct clobber_ent));
+	  register int j;
+
+	  link->code_number = insn_code_number;
+
+	  /* See if any previous CLOBBER_LIST entry is the same as this
+	     one.  */
+
+	  for (p = clobber_list; p; p = p->next)
+	    {
+	      if (p->first_clobber != i + 1
+		  || XVECLEN (p->pattern, 1) != XVECLEN (insn, 1))
+		continue;
+
+	      for (j = i + 1; j < XVECLEN (insn, 1); j++)
+		{
+		  rtx old = XEXP (XVECEXP (p->pattern, 1, j), 0);
+		  rtx new = XEXP (XVECEXP (insn, 1, j), 0);
+
+		  /* OLD and NEW are the same if both are to be a SCRATCH
+		     or if both are registers of the same mode and number.  */
+		  if (! ((GET_CODE (old) == MATCH_SCRATCH
+			  && GET_CODE (new) == MATCH_SCRATCH)
+			 || (GET_CODE (old) == REG && GET_CODE (new) == REG
+			     && GET_MODE (old) == GET_MODE (new)
+			     && REGNO (old) == REGNO (new))))
+		    break;
+		}
+      
+	      if (j == XVECLEN (insn, 1))
+		break;
+	    }
+
+	  if (p == 0)
+	    {
+	      p = (struct clobber_pat *) xmalloc (sizeof (struct clobber_pat));
 	  
-	  new->code_number = insn_code_number;
-	  new->pattern = insn;
-	  new->first_clobber = i + 1;
-	  new->next = clobber_list;
-	  clobber_list = new;
+	      p->insns = 0;
+	      p->pattern = insn;
+	      p->first_clobber = i + 1;
+	      p->next = clobber_list;
+	      clobber_list = p;
+	    }
+
+	  link->next = p->insns;
+	  p->insns = link;
 	}
     }
 
@@ -547,6 +595,7 @@ static void
 output_add_clobbers ()
 {
   struct clobber_pat *clobber;
+  struct clobber_ent *ent;
   int i;
 
   printf ("\n\nvoid\nadd_clobbers (pattern, insn_code_number)\n");
@@ -558,7 +607,8 @@ output_add_clobbers ()
 
   for (clobber = clobber_list; clobber; clobber = clobber->next)
     {
-      printf ("    case %d:\n", clobber->code_number);
+      for (ent = clobber->insns; ent; ent = ent->next)
+	printf ("    case %d:\n", ent->code_number);
 
       for (i = clobber->first_clobber; i < XVECLEN (clobber->pattern, 1); i++)
 	{
@@ -567,7 +617,7 @@ output_add_clobbers ()
 	  printf (";\n");
 	}
 
-      printf ("      break;\n");
+      printf ("      break;\n\n");
     }
 
   printf ("    default:\n");