[gcc/ChangeLog]

[pf3gnuchains/gcc-fork.git] / gcc / rtlanal.c

diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c
index b802e3f..91fe437 100644 (file)
--- a/gcc/rtlanal.c
+++ b/gcc/rtlanal.c
@@ -81,10 +81,7 @@ rtx_unstable_p (rtx x)
   switch (code)
     {
     case MEM:
-      return ! RTX_UNCHANGING_P (x) || rtx_unstable_p (XEXP (x, 0));
-
-    case QUEUED:
-      return 1;
+      return !MEM_READONLY_P (x) || rtx_unstable_p (XEXP (x, 0));
 
     case CONST:
     case CONST_INT:
@@ -98,8 +95,7 @@ rtx_unstable_p (rtx x)
       /* As in rtx_varies_p, we have to use the actual rtx, not reg number.  */
       if (x == frame_pointer_rtx || x == hard_frame_pointer_rtx
          /* The arg pointer varies if it is not a fixed register.  */
-         || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM])
-         || RTX_UNCHANGING_P (x))
+         || (x == arg_pointer_rtx && fixed_regs[ARG_POINTER_REGNUM]))
        return 0;
 #ifndef PIC_OFFSET_TABLE_REG_CALL_CLOBBERED
       /* ??? When call-clobbered, the value is stable modulo the restore
@@ -159,10 +155,7 @@ rtx_varies_p (rtx x, int for_alias)
   switch (code)
     {
     case MEM:
-      return ! RTX_UNCHANGING_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
-
-    case QUEUED:
-      return 1;
+      return !MEM_READONLY_P (x) || rtx_varies_p (XEXP (x, 0), for_alias);
 
     case CONST:
     case CONST_INT:
@@ -947,14 +940,10 @@ reg_set_p (rtx reg, rtx insn)
   if (INSN_P (insn)
       && (FIND_REG_INC_NOTE (insn, reg)
          || (CALL_P (insn)
-             /* We'd like to test call_used_regs here, but rtlanal.c can't
-                reference that variable due to its use in genattrtab.  So
-                we'll just be more conservative.
-
-                ??? Unless we could ensure that the CALL_INSN_FUNCTION_USAGE
-                information holds all clobbered registers.  */
              && ((REG_P (reg)
-                  && REGNO (reg) < FIRST_PSEUDO_REGISTER)
+                  && REGNO (reg) < FIRST_PSEUDO_REGISTER
+                  && TEST_HARD_REG_BIT (regs_invalidated_by_call,
+                                        REGNO (reg)))
                  || MEM_P (reg)
                  || find_reg_fusage (insn, CLOBBER, reg)))))
     return 1;
@@ -1037,7 +1026,7 @@ modified_between_p (rtx x, rtx start, rtx end)
       return 1;
 
     case MEM:
-      if (RTX_UNCHANGING_P (x))
+      if (MEM_READONLY_P (x))
        return 0;
       if (modified_between_p (XEXP (x, 0), start, end))
        return 1;
@@ -1095,7 +1084,7 @@ modified_in_p (rtx x, rtx insn)
       return 1;
 
     case MEM:
-      if (RTX_UNCHANGING_P (x))
+      if (MEM_READONLY_P (x))
        return 0;
       if (modified_in_p (XEXP (x, 0), insn))
        return 1;
@@ -3165,7 +3154,7 @@ loc_mentioned_in_p (rtx *loc, rtx in)
 
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
-      if (loc == &in->u.fld[i].rtx)
+      if (loc == &in->u.fld[i].rt_rtx)
        return 1;
       if (fmt[i] == 'e')
        {
@@ -4785,3 +4774,39 @@ num_sign_bit_copies1 (rtx x, enum machine_mode mode, rtx known_x,
   return nonzero & ((HOST_WIDE_INT) 1 << (bitwidth - 1))
         ? 1 : bitwidth - floor_log2 (nonzero) - 1;
 }
+
+/* Calculate the rtx_cost of a single instruction.  A return value of
+   zero indicates an instruction pattern without a known cost.  */
+
+int
+insn_rtx_cost (rtx pat)
+{
+  int i, cost;
+  rtx set;
+
+  /* Extract the single set rtx from the instruction pattern.
+     We can't use single_set since we only have the pattern.  */
+  if (GET_CODE (pat) == SET)
+    set = pat;
+  else if (GET_CODE (pat) == PARALLEL)
+    {
+      set = NULL_RTX;
+      for (i = 0; i < XVECLEN (pat, 0); i++)
+       {
+         rtx x = XVECEXP (pat, 0, i);
+         if (GET_CODE (x) == SET)
+           {
+             if (set)
+               return 0;
+             set = x;
+           }
+       }
+      if (!set)
+       return 0;
+    }
+  else
+    return 0;
+
+  cost = rtx_cost (SET_SRC (set), SET);
+  return cost > 0 ? cost : COSTS_N_INSNS (1);
+}