* loop-invariant.c: New file.

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

diff --git a/gcc/postreload.c b/gcc/postreload.c
index 7b7e3d2..58a3735 100644 (file)
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -181,7 +181,7 @@ reload_cse_regs_1 (rtx first)
   rtx insn;
   rtx testreg = gen_rtx_REG (VOIDmode, -1);
 
-  cselib_init ();
+  cselib_init (true);
   init_alias_analysis ();
 
   for (insn = first; insn; insn = NEXT_INSN (insn))
@@ -235,7 +235,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
   if (GET_CODE (src) == MEM
       && GET_MODE_BITSIZE (GET_MODE (src)) < BITS_PER_WORD
       && (extend_op = LOAD_EXTEND_OP (GET_MODE (src))) != NIL
-      && GET_CODE (SET_DEST (set)) != REG)
+      && !REG_P (SET_DEST (set)))
     return 0;
 #endif
 
@@ -246,7 +246,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
   /* If memory loads are cheaper than register copies, don't change them.  */
   if (GET_CODE (src) == MEM)
     old_cost = MEMORY_MOVE_COST (GET_MODE (src), dclass, 1);
-  else if (GET_CODE (src) == REG)
+  else if (REG_P (src))
     old_cost = REGISTER_MOVE_COST (GET_MODE (src),
                                   REGNO_REG_CLASS (REGNO (src)), dclass);
   else
@@ -287,7 +287,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
 #endif
          this_cost = rtx_cost (this_rtx, SET);
        }
-      else if (GET_CODE (this_rtx) == REG)
+      else if (REG_P (this_rtx))
        {
 #ifdef LOAD_EXTEND_OP
          if (extend_op != NIL)
@@ -308,8 +308,8 @@ reload_cse_simplify_set (rtx set, rtx insn)
         tends to lead to smaller instructions on some machines.  */
       if (this_cost < old_cost
          || (this_cost == old_cost
-             && GET_CODE (this_rtx) == REG
-             && GET_CODE (SET_SRC (set)) != REG))
+             && REG_P (this_rtx)
+             && !REG_P (SET_SRC (set))))
        {
 #ifdef LOAD_EXTEND_OP
          if (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) < BITS_PER_WORD
@@ -426,14 +426,14 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
 #ifdef CANNOT_CHANGE_MODE_CLASS
          /* If the register cannot change mode to word_mode, it follows that
             it cannot have been used in word_mode.  */
-         else if (GET_CODE (SET_DEST (set)) == REG
+         else if (REG_P (SET_DEST (set))
                   && CANNOT_CHANGE_MODE_CLASS (GET_MODE (SET_DEST (set)),
                                                word_mode,
                                                REGNO_REG_CLASS (REGNO (SET_DEST (set)))))
            ; /* Continue ordinary processing.  */
 #endif
          /* If this is a straight load, make the extension explicit.  */
-         else if (GET_CODE (SET_DEST (set)) == REG
+         else if (REG_P (SET_DEST (set))
                   && recog_data.n_operands == 2
                   && SET_SRC (set) == op
                   && SET_DEST (set) == recog_data.operand[1-i])
@@ -460,7 +460,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
        continue;
 
       for (l = v->locs; l; l = l->next)
-       if (GET_CODE (l->loc) == REG)
+       if (REG_P (l->loc))
          SET_HARD_REG_BIT (equiv_regs[i], REGNO (l->loc));
     }
 
@@ -779,12 +779,12 @@ reload_combine (void)
         does not yet show whether REGY changes in this insn.  */
       set = single_set (insn);
       if (set != NULL_RTX
-         && GET_CODE (SET_DEST (set)) == REG
-         && (HARD_REGNO_NREGS (REGNO (SET_DEST (set)),
-                               GET_MODE (SET_DEST (set)))
+         && REG_P (SET_DEST (set))
+         && (hard_regno_nregs[REGNO (SET_DEST (set))]
+                             [GET_MODE (SET_DEST (set))]
              == 1)
          && GET_CODE (SET_SRC (set)) == PLUS
-         && GET_CODE (XEXP (SET_SRC (set), 1)) == REG
+         && REG_P (XEXP (SET_SRC (set), 1))
          && rtx_equal_p (XEXP (SET_SRC (set), 0), SET_DEST (set))
          && !rtx_equal_p (XEXP (SET_SRC (set), 1), SET_DEST (set))
          && last_label_ruid < reg_state[REGNO (SET_DEST (set))].use_ruid)
@@ -825,7 +825,7 @@ reload_combine (void)
                                         i)
                      && reg_state[i].use_index == RELOAD_COMBINE_MAX_USES
                      && reg_state[i].store_ruid <= reg_state[regno].use_ruid
-                     && HARD_REGNO_NREGS (i, GET_MODE (reg)) == 1)
+                     && hard_regno_nregs[i][GET_MODE (reg)] == 1)
                    {
                      rtx index_reg = gen_rtx_REG (GET_MODE (reg), i);
 
@@ -913,12 +913,12 @@ reload_combine (void)
               link = XEXP (link, 1))
            {
              rtx usage_rtx = XEXP (XEXP (link, 0), 0);
-             if (GET_CODE (usage_rtx) == REG)
+             if (REG_P (usage_rtx))
                {
                  unsigned int i;
                  unsigned int start_reg = REGNO (usage_rtx);
                  unsigned int num_regs =
-                       HARD_REGNO_NREGS (start_reg, GET_MODE (usage_rtx));
+                       hard_regno_nregs[start_reg][GET_MODE (usage_rtx)];
                  unsigned int end_reg  = start_reg + num_regs - 1;
                  for (i = start_reg; i <= end_reg; i++)
                    if (GET_CODE (XEXP (link, 0)) == CLOBBER)
@@ -954,7 +954,7 @@ reload_combine (void)
       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
        {
          if (REG_NOTE_KIND (note) == REG_INC
-             && GET_CODE (XEXP (note, 0)) == REG)
+             && REG_P (XEXP (note, 0)))
            {
              int regno = REGNO (XEXP (note, 0));
 
@@ -986,7 +986,7 @@ reload_combine_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
                                   GET_MODE (dst));
       dst = SUBREG_REG (dst);
     }
-  if (GET_CODE (dst) != REG)
+  if (!REG_P (dst))
     return;
   regno += REGNO (dst);
 
@@ -999,7 +999,7 @@ reload_combine_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
       || GET_CODE (SET_DEST (set)) == SIGN_EXTRACT
       || GET_CODE (SET_DEST (set)) == STRICT_LOW_PART)
     {
-      for (i = HARD_REGNO_NREGS (regno, mode) - 1 + regno; i >= regno; i--)
+      for (i = hard_regno_nregs[regno][mode] - 1 + regno; i >= regno; i--)
        {
          reg_state[i].use_index = -1;
          reg_state[i].store_ruid = reload_combine_ruid;
@@ -1007,7 +1007,7 @@ reload_combine_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
     }
   else
     {
-      for (i = HARD_REGNO_NREGS (regno, mode) - 1 + regno; i >= regno; i--)
+      for (i = hard_regno_nregs[regno][mode] - 1 + regno; i >= regno; i--)
        {
          reg_state[i].store_ruid = reload_combine_ruid;
          reg_state[i].use_index = RELOAD_COMBINE_MAX_USES;
@@ -1031,7 +1031,7 @@ reload_combine_note_use (rtx *xp, rtx insn)
   switch (code)
     {
     case SET:
-      if (GET_CODE (SET_DEST (x)) == REG)
+      if (REG_P (SET_DEST (x)))
        {
          reload_combine_note_use (&SET_SRC (x), insn);
          return;
@@ -1040,12 +1040,12 @@ reload_combine_note_use (rtx *xp, rtx insn)
 
     case USE:
       /* If this is the USE of a return value, we can't change it.  */
-      if (GET_CODE (XEXP (x, 0)) == REG && REG_FUNCTION_VALUE_P (XEXP (x, 0)))
+      if (REG_P (XEXP (x, 0)) && REG_FUNCTION_VALUE_P (XEXP (x, 0)))
        {
        /* Mark the return register as used in an unknown fashion.  */
          rtx reg = XEXP (x, 0);
          int regno = REGNO (reg);
-         int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
+         int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
 
          while (--nregs >= 0)
            reg_state[regno + nregs].use_index = -1;
@@ -1054,7 +1054,7 @@ reload_combine_note_use (rtx *xp, rtx insn)
       break;
 
     case CLOBBER:
-      if (GET_CODE (SET_DEST (x)) == REG)
+      if (REG_P (SET_DEST (x)))
        {
          /* No spurious CLOBBERs of pseudo registers may remain.  */
          if (REGNO (SET_DEST (x)) >= FIRST_PSEUDO_REGISTER)
@@ -1065,7 +1065,7 @@ reload_combine_note_use (rtx *xp, rtx insn)
 
     case PLUS:
       /* We are interested in (plus (reg) (const_int)) .  */
-      if (GET_CODE (XEXP (x, 0)) != REG
+      if (!REG_P (XEXP (x, 0))
          || GET_CODE (XEXP (x, 1)) != CONST_INT)
        break;
       offset = XEXP (x, 1);
@@ -1081,7 +1081,7 @@ reload_combine_note_use (rtx *xp, rtx insn)
        if (regno >= FIRST_PSEUDO_REGISTER)
          abort ();
 
-       nregs = HARD_REGNO_NREGS (regno, GET_MODE (x));
+       nregs = hard_regno_nregs[regno][GET_MODE (x)];
 
        /* We can't substitute into multi-hard-reg uses.  */
        if (nregs > 1)
@@ -1207,7 +1207,7 @@ reload_cse_move2add (rtx first)
       /* For simplicity, we only perform this optimization on
         straightforward SETs.  */
       if (GET_CODE (pat) == SET
-         && GET_CODE (SET_DEST (pat)) == REG)
+         && REG_P (SET_DEST (pat)))
        {
          rtx reg = SET_DEST (pat);
          int regno = REGNO (reg);
@@ -1255,12 +1255,8 @@ reload_cse_move2add (rtx first)
                  else if (rtx_cost (new_src, PLUS) < rtx_cost (src, SET)
                           && have_add2_insn (reg, new_src))
                    {
-                     rtx newpat = gen_rtx_SET (VOIDmode,
-                                               reg,
-                                               gen_rtx_PLUS (GET_MODE (reg),
-                                                             reg,
-                                                             new_src));
-                     validate_change (insn, &PATTERN (insn), newpat, 0);
+                     rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
+                     validate_change (insn, &SET_SRC (pat), tem, 0);
                    }
                  else
                    {
@@ -1307,7 +1303,7 @@ reload_cse_move2add (rtx first)
                                  (set (REGX) (PLUS (REGX) (CONST_INT A)))
                                  ...
                                  (set (REGX) (plus (REGX) (CONST_INT B-A)))  */
-             else if (GET_CODE (src) == REG
+             else if (REG_P (src)
                       && reg_set_luid[regno] == reg_set_luid[REGNO (src)]
                       && reg_base_reg[regno] == reg_base_reg[REGNO (src)]
                       && MODES_OK_FOR_MOVE2ADD (GET_MODE (reg),
@@ -1367,7 +1363,7 @@ reload_cse_move2add (rtx first)
       for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
        {
          if (REG_NOTE_KIND (note) == REG_INC
-             && GET_CODE (XEXP (note, 0)) == REG)
+             && REG_P (XEXP (note, 0)))
            {
              /* Reset the information about this register.  */
              int regno = REGNO (XEXP (note, 0));
@@ -1385,13 +1381,13 @@ reload_cse_move2add (rtx first)
 
          if (cnd != NULL_RTX
              && GET_CODE (cnd) == NE
-             && GET_CODE (XEXP (cnd, 0)) == REG
+             && REG_P (XEXP (cnd, 0))
              /* The following two checks, which are also in
                 move2add_note_store, are intended to reduce the
                 number of calls to gen_rtx_SET to avoid memory
                 allocation if possible.  */
              && SCALAR_INT_MODE_P (GET_MODE (XEXP (cnd, 0)))
-             && HARD_REGNO_NREGS (REGNO (XEXP (cnd, 0)), GET_MODE (XEXP (cnd, 0))) == 1
+             && hard_regno_nregs[REGNO (XEXP (cnd, 0))][GET_MODE (XEXP (cnd, 0))] == 1
              && GET_CODE (XEXP (cnd, 1)) == CONST_INT)
            {
              rtx implicit_set =
@@ -1444,13 +1440,13 @@ move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
        reg_set_luid[REGNO (XEXP (dst, 0))] = 0;
       return;
     }
-  if (GET_CODE (dst) != REG)
+  if (!REG_P (dst))
     return;
 
   regno += REGNO (dst);
 
   if (SCALAR_INT_MODE_P (mode)
-      && HARD_REGNO_NREGS (regno, mode) == 1 && GET_CODE (set) == SET
+      && hard_regno_nregs[regno][mode] == 1 && GET_CODE (set) == SET
       && GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
       && GET_CODE (SET_DEST (set)) != SIGN_EXTRACT
       && GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
@@ -1466,13 +1462,13 @@ move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
       switch (GET_CODE (src))
        {
        case PLUS:
-         if (GET_CODE (XEXP (src, 0)) == REG)
+         if (REG_P (XEXP (src, 0)))
            {
              base_reg = XEXP (src, 0);
 
              if (GET_CODE (XEXP (src, 1)) == CONST_INT)
                offset = INTVAL (XEXP (src, 1));
-             else if (GET_CODE (XEXP (src, 1)) == REG
+             else if (REG_P (XEXP (src, 1))
                       && (reg_set_luid[REGNO (XEXP (src, 1))]
                           > move2add_last_label_luid)
                       && (MODES_OK_FOR_MOVE2ADD
@@ -1551,7 +1547,7 @@ move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
     }
   else
     {
-      unsigned int endregno = regno + HARD_REGNO_NREGS (regno, mode);
+      unsigned int endregno = regno + hard_regno_nregs[regno][mode];
 
       for (i = regno; i < endregno; i++)
        /* Reset the information about this register.  */