Daily bump.

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

diff --git a/gcc/postreload.c b/gcc/postreload.c
index 01e1f17..f878582 100644 (file)
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -407,7 +407,6 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
       cselib_val *v;
       struct elt_loc_list *l;
       rtx op;
-      enum machine_mode mode;
 
       CLEAR_HARD_REG_SET (equiv_regs[i]);
 
@@ -420,11 +419,10 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
        continue;
 
       op = recog_data.operand[i];
-      mode = GET_MODE (op);
 #ifdef LOAD_EXTEND_OP
       if (MEM_P (op)
-         && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
-         && LOAD_EXTEND_OP (mode) != UNKNOWN)
+         && GET_MODE_BITSIZE (GET_MODE (op)) < BITS_PER_WORD
+         && LOAD_EXTEND_OP (GET_MODE (op)) != UNKNOWN)
        {
          rtx set = single_set (insn);
 
@@ -457,7 +455,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
                   && SET_DEST (set) == recog_data.operand[1-i])
            {
              validate_change (insn, recog_data.operand_loc[i],
-                              gen_rtx_fmt_e (LOAD_EXTEND_OP (mode),
+                              gen_rtx_fmt_e (LOAD_EXTEND_OP (GET_MODE (op)),
                                              word_mode, op),
                               1);
              validate_change (insn, recog_data.operand_loc[1-i],
@@ -794,7 +792,7 @@ reload_combine (void)
         ... (MEM (PLUS (REGZ) (REGY)))... .
 
         First, check that we have (set (REGX) (PLUS (REGX) (REGY)))
-        and that we know all uses of REGX before it dies.  
+        and that we know all uses of REGX before it dies.
         Also, explicitly check that REGX != REGY; our life information
         does not yet show whether REGY changes in this insn.  */
       set = single_set (insn);
@@ -815,22 +813,19 @@ reload_combine (void)
          rtx prev = prev_nonnote_insn (insn);
          rtx prev_set = prev ? single_set (prev) : NULL_RTX;
          unsigned int regno = REGNO (reg);
-         rtx const_reg = NULL_RTX;
+         rtx index_reg = NULL_RTX;
          rtx reg_sum = NULL_RTX;
 
-         /* Now, we need an index register.
-            We'll set index_reg to this index register, const_reg to the
-            register that is to be loaded with the constant
-            (denoted as REGZ in the substitution illustration above),
-            and reg_sum to the register-register that we want to use to
-            substitute uses of REG (typically in MEMs) with.
-            First check REG and BASE for being index registers;
-            we can use them even if they are not dead.  */
+         /* Now we need to set INDEX_REG to an index register (denoted as
+            REGZ in the illustration above) and REG_SUM to the expression
+            register+register that we want to use to substitute uses of REG
+            (typically in MEMs) with.  First check REG and BASE for being
+            index registers; we can use them even if they are not dead.  */
          if (TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS], regno)
              || TEST_HARD_REG_BIT (reg_class_contents[INDEX_REG_CLASS],
                                    REGNO (base)))
            {
-             const_reg = reg;
+             index_reg = reg;
              reg_sum = plus;
            }
          else
@@ -847,9 +842,7 @@ reload_combine (void)
                      && reg_state[i].store_ruid <= reg_state[regno].use_ruid
                      && hard_regno_nregs[i][GET_MODE (reg)] == 1)
                    {
-                     rtx index_reg = gen_rtx_REG (GET_MODE (reg), i);
-
-                     const_reg = index_reg;
+                     index_reg = gen_rtx_REG (GET_MODE (reg), i);
                      reg_sum = gen_rtx_PLUS (GET_MODE (reg), index_reg, base);
                      break;
                    }
@@ -859,19 +852,19 @@ reload_combine (void)
          /* Check that PREV_SET is indeed (set (REGX) (CONST_INT)) and that
             (REGY), i.e. BASE, is not clobbered before the last use we'll
             create.  */
-         if (prev_set != 0
+         if (reg_sum
+             && prev_set
              && CONST_INT_P (SET_SRC (prev_set))
              && rtx_equal_p (SET_DEST (prev_set), reg)
              && reg_state[regno].use_index >= 0
              && (reg_state[REGNO (base)].store_ruid
-                 <= reg_state[regno].use_ruid)
-             && reg_sum != 0)
+                 <= reg_state[regno].use_ruid))
            {
              int i;
 
-             /* Change destination register and, if necessary, the
-                constant value in PREV, the constant loading instruction.  */
-             validate_change (prev, &SET_DEST (prev_set), const_reg, 1);
+             /* Change destination register and, if necessary, the constant
+                value in PREV, the constant loading instruction.  */
+             validate_change (prev, &SET_DEST (prev_set), index_reg, 1);
              if (reg_state[regno].offset != const0_rtx)
                validate_change (prev,
                                 &SET_SRC (prev_set),
@@ -891,6 +884,19 @@ reload_combine (void)
 
              if (apply_change_group ())
                {
+                 /* For every new use of REG_SUM, we have to record the use
+                    of BASE therein, i.e. operand 1.  */
+                 for (i = reg_state[regno].use_index;
+                      i < RELOAD_COMBINE_MAX_USES; i++)
+                   reload_combine_note_use
+                     (&XEXP (*reg_state[regno].reg_use[i].usep, 1),
+                      reg_state[regno].reg_use[i].insn);
+
+                 if (reg_state[REGNO (base)].use_ruid
+                     > reg_state[regno].use_ruid)
+                   reg_state[REGNO (base)].use_ruid
+                     = reg_state[regno].use_ruid;
+
                  /* Delete the reg-reg addition.  */
                  delete_insn (insn);
 
@@ -900,7 +906,7 @@ reload_combine (void)
                    remove_reg_equal_equiv_notes (prev);
 
                  reg_state[regno].use_index = RELOAD_COMBINE_MAX_USES;
-                 reg_state[REGNO (const_reg)].store_ruid
+                 reg_state[REGNO (index_reg)].store_ruid
                    = reload_combine_ruid;
                  continue;
                }