2008-05-01 H.J. Lu <hongjiu.lu@intel.com>

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

diff --git a/gcc/postreload.c b/gcc/postreload.c
index c4ab4f2..7e40728 100644 (file)
--- a/gcc/postreload.c
+++ b/gcc/postreload.c
@@ -1,12 +1,13 @@
 /* Perform simple optimizations to clean up the result of reload.
 /* Perform simple optimizations to clean up the result of reload.

-   Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-   1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
+   1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+   Free Software Foundation, Inc.

 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free

-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -15,9 +16,8 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License

-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"


@@ -44,6 +44,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "toplev.h"
 #include "except.h"
 #include "tree.h"
 #include "toplev.h"
 #include "except.h"
 #include "tree.h"

+#include "timevar.h"
+#include "tree-pass.h"
+#include "df.h"
+#include "dbgcnt.h"

 
 static int reload_cse_noop_set_p (rtx);
 static void reload_cse_simplify (rtx, rtx);
 
 static int reload_cse_noop_set_p (rtx);
 static void reload_cse_simplify (rtx, rtx);


@@ -53,10 +57,10 @@ static int reload_cse_simplify_operands (rtx, rtx);
 
 static void reload_combine (void);
 static void reload_combine_note_use (rtx *, rtx);
 
 static void reload_combine (void);
 static void reload_combine_note_use (rtx *, rtx);

-static void reload_combine_note_store (rtx, rtx, void *);
+static void reload_combine_note_store (rtx, const_rtx, void *);

 
 static void reload_cse_move2add (rtx);
 
 static void reload_cse_move2add (rtx);

-static void move2add_note_store (rtx, rtx, void *);
+static void move2add_note_store (rtx, const_rtx, void *);

 
 /* Call cse / combine like post-reload optimization phases.
    FIRST is the first instruction.  */
 
 /* Call cse / combine like post-reload optimization phases.
    FIRST is the first instruction.  */


@@ -118,6 +122,19 @@ reload_cse_simplify (rtx insn, rtx testreg)
       int count = 0;
       rtx value = NULL_RTX;
 
       int count = 0;
       rtx value = NULL_RTX;
 

+      /* Registers mentioned in the clobber list for an asm cannot be reused
+        within the body of the asm.  Invalidate those registers now so that
+        we don't try to substitute values for them.  */
+      if (asm_noperands (body) >= 0)
+       {
+         for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
+           {
+             rtx part = XVECEXP (body, 0, i);
+             if (GET_CODE (part) == CLOBBER && REG_P (XEXP (part, 0)))
+               cselib_invalidate_rtx (XEXP (part, 0));
+           }
+       }
+

       /* If every action in a PARALLEL is a noop, we can delete
         the entire PARALLEL.  */
       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)
       /* If every action in a PARALLEL is a noop, we can delete
         the entire PARALLEL.  */
       for (i = XVECLEN (body, 0) - 1; i >= 0; --i)


@@ -214,7 +231,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
   cselib_val *val;
   struct elt_loc_list *l;
 #ifdef LOAD_EXTEND_OP
   cselib_val *val;
   struct elt_loc_list *l;
 #ifdef LOAD_EXTEND_OP

-  enum rtx_code extend_op = NIL;
+  enum rtx_code extend_op = UNKNOWN;

 #endif
 
   dreg = true_regnum (SET_DEST (set));
 #endif
 
   dreg = true_regnum (SET_DEST (set));


@@ -234,7 +251,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
      the destination must be a register that we can widen.  */
   if (MEM_P (src)
       && GET_MODE_BITSIZE (GET_MODE (src)) < BITS_PER_WORD
      the destination must be a register that we can widen.  */
   if (MEM_P (src)
       && GET_MODE_BITSIZE (GET_MODE (src)) < BITS_PER_WORD

-      && (extend_op = LOAD_EXTEND_OP (GET_MODE (src))) != NIL
+      && (extend_op = LOAD_EXTEND_OP (GET_MODE (src))) != UNKNOWN

       && !REG_P (SET_DEST (set)))
     return 0;
 #endif
       && !REG_P (SET_DEST (set)))
     return 0;
 #endif


@@ -260,7 +277,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
       if (CONSTANT_P (this_rtx) && ! references_value_p (this_rtx, 0))
        {
 #ifdef LOAD_EXTEND_OP
       if (CONSTANT_P (this_rtx) && ! references_value_p (this_rtx, 0))
        {
 #ifdef LOAD_EXTEND_OP

-         if (extend_op != NIL)
+         if (extend_op != UNKNOWN)

            {
              HOST_WIDE_INT this_val;
 
            {
              HOST_WIDE_INT this_val;
 


@@ -280,7 +297,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
                  if (this_val == trunc_int_for_mode (this_val, GET_MODE (src)))
                    break;
                default:
                  if (this_val == trunc_int_for_mode (this_val, GET_MODE (src)))
                    break;
                default:

-                 abort ();
+                 gcc_unreachable ();

                }
              this_rtx = GEN_INT (this_val);
            }
                }
              this_rtx = GEN_INT (this_val);
            }


@@ -290,7 +307,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
       else if (REG_P (this_rtx))
        {
 #ifdef LOAD_EXTEND_OP
       else if (REG_P (this_rtx))
        {
 #ifdef LOAD_EXTEND_OP

-         if (extend_op != NIL)
+         if (extend_op != UNKNOWN)

            {
              this_rtx = gen_rtx_fmt_e (extend_op, word_mode, this_rtx);
              this_cost = rtx_cost (this_rtx, SET);
            {
              this_rtx = gen_rtx_fmt_e (extend_op, word_mode, this_rtx);
              this_cost = rtx_cost (this_rtx, SET);


@@ -313,7 +330,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
        {
 #ifdef LOAD_EXTEND_OP
          if (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) < BITS_PER_WORD
        {
 #ifdef LOAD_EXTEND_OP
          if (GET_MODE_BITSIZE (GET_MODE (SET_DEST (set))) < BITS_PER_WORD

-             && extend_op != NIL
+             && extend_op != UNKNOWN

 #ifdef CANNOT_CHANGE_MODE_CLASS
              && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SET_DEST (set)),
                                            word_mode,
 #ifdef CANNOT_CHANGE_MODE_CLASS
              && !CANNOT_CHANGE_MODE_CLASS (GET_MODE (SET_DEST (set)),
                                            word_mode,


@@ -327,7 +344,7 @@ reload_cse_simplify_set (rtx set, rtx insn)
            }
 #endif
 
            }
 #endif
 

-         validate_change (insn, &SET_SRC (set), copy_rtx (this_rtx), 1);
+         validate_unshare_change (insn, &SET_SRC (set), this_rtx, 1);

          old_cost = this_cost, did_change = 1;
        }
     }
          old_cost = this_cost, did_change = 1;
        }
     }


@@ -406,7 +423,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
 #ifdef LOAD_EXTEND_OP
       if (MEM_P (op)
          && GET_MODE_BITSIZE (mode) < BITS_PER_WORD
 #ifdef LOAD_EXTEND_OP
       if (MEM_P (op)
          && GET_MODE_BITSIZE (mode) < BITS_PER_WORD

-         && LOAD_EXTEND_OP (mode) != NIL)
+         && LOAD_EXTEND_OP (mode) != UNKNOWN)

        {
          rtx set = single_set (insn);
 
        {
          rtx set = single_set (insn);
 


@@ -414,7 +431,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
             extension.  Punt on this for now.  */
          if (! set)
            continue;
             extension.  Punt on this for now.  */
          if (! set)
            continue;

-         /* If the destination is a also MEM or a STRICT_LOW_PART, no
+         /* If the destination is also a MEM or a STRICT_LOW_PART, no

             extension applies.
             Also, if there is an explicit extension, we don't have to
             worry about an implicit one.  */
             extension applies.
             Also, if there is an explicit extension, we don't have to
             worry about an implicit one.  */


@@ -506,7 +523,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
          if (! TEST_HARD_REG_BIT (equiv_regs[i], regno))
            continue;
 
          if (! TEST_HARD_REG_BIT (equiv_regs[i], regno))
            continue;
 

-         REGNO (testreg) = regno;
+         SET_REGNO (testreg, regno);

          PUT_MODE (testreg, mode);
 
          /* We found a register equal to this operand.  Now look for all
          PUT_MODE (testreg, mode);
 
          /* We found a register equal to this operand.  Now look for all


@@ -560,6 +577,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
                      op_alt_regno[i][j] = regno;
                    }
                  j++;
                      op_alt_regno[i][j] = regno;
                    }
                  j++;

+                 class = (int) NO_REGS;

                  break;
                }
              p += CONSTRAINT_LEN (c, p);
                  break;
                }
              p += CONSTRAINT_LEN (c, p);


@@ -592,7 +610,7 @@ reload_cse_simplify_operands (rtx insn, rtx testreg)
          int this_nregs = alternative_nregs[alternative_order[j]];
 
          if (this_reject < best_reject
          int this_nregs = alternative_nregs[alternative_order[j]];
 
          if (this_reject < best_reject

-             || (this_reject == best_reject && this_nregs < best_nregs))
+             || (this_reject == best_reject && this_nregs > best_nregs))

            {
              best = j;
              best_reject = this_reject;
            {
              best = j;
              best_reject = this_reject;


@@ -715,7 +733,7 @@ reload_combine (void)
      destination.  */
   min_labelno = get_first_label_num ();
   n_labels = max_label_num () - min_labelno;
      destination.  */
   min_labelno = get_first_label_num ();
   n_labels = max_label_num () - min_labelno;

-  label_live = xmalloc (n_labels * sizeof (HARD_REG_SET));
+  label_live = XNEWVEC (HARD_REG_SET, n_labels);

   CLEAR_HARD_REG_SET (ever_live_at_start);
 
   FOR_EACH_BB_REVERSE (bb)
   CLEAR_HARD_REG_SET (ever_live_at_start);
 
   FOR_EACH_BB_REVERSE (bb)


@@ -724,11 +742,10 @@ reload_combine (void)
       if (LABEL_P (insn))
        {
          HARD_REG_SET live;
       if (LABEL_P (insn))
        {
          HARD_REG_SET live;

+         bitmap live_in = df_get_live_in (bb);

 
 

-         REG_SET_TO_HARD_REG_SET (live,
-                                  bb->global_live_at_start);
-         compute_use_by_pseudos (&live,
-                                 bb->global_live_at_start);
+         REG_SET_TO_HARD_REG_SET (live, live_in);
+         compute_use_by_pseudos (&live, live_in);

          COPY_HARD_REG_SET (LABEL_LIVE (insn), live);
          IOR_HARD_REG_SET (ever_live_at_start, live);
        }
          COPY_HARD_REG_SET (LABEL_LIVE (insn), live);
          IOR_HARD_REG_SET (ever_live_at_start, live);
        }


@@ -863,30 +880,21 @@ reload_combine (void)
                 with REG_SUM.  */
              for (i = reg_state[regno].use_index;
                   i < RELOAD_COMBINE_MAX_USES; i++)
                 with REG_SUM.  */
              for (i = reg_state[regno].use_index;
                   i < RELOAD_COMBINE_MAX_USES; i++)

-               validate_change (reg_state[regno].reg_use[i].insn,
-                                reg_state[regno].reg_use[i].usep,
-                                /* Each change must have its own
-                                   replacement.  */
-                                copy_rtx (reg_sum), 1);
+               validate_unshare_change (reg_state[regno].reg_use[i].insn,
+                                        reg_state[regno].reg_use[i].usep,
+                                        /* Each change must have its own
+                                           replacement.  */
+                                        reg_sum, 1);

 
              if (apply_change_group ())
                {
 
              if (apply_change_group ())
                {

-                 rtx *np;
-

                  /* Delete the reg-reg addition.  */
                  delete_insn (insn);
 
                  if (reg_state[regno].offset != const0_rtx)
                    /* Previous REG_EQUIV / REG_EQUAL notes for PREV
                       are now invalid.  */
                  /* Delete the reg-reg addition.  */
                  delete_insn (insn);
 
                  if (reg_state[regno].offset != const0_rtx)
                    /* Previous REG_EQUIV / REG_EQUAL notes for PREV
                       are now invalid.  */

-                   for (np = &REG_NOTES (prev); *np;)
-                     {
-                       if (REG_NOTE_KIND (*np) == REG_EQUAL
-                           || REG_NOTE_KIND (*np) == REG_EQUIV)
-                         *np = XEXP (*np, 1);
-                       else
-                         np = &XEXP (*np, 1);
-                     }
+                   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].use_index = RELOAD_COMBINE_MAX_USES;
                  reg_state[REGNO (const_reg)].store_ruid


@@ -972,7 +980,7 @@ reload_combine (void)
    accordingly.  Called via note_stores from reload_combine.  */
 
 static void
    accordingly.  Called via note_stores from reload_combine.  */
 
 static void

-reload_combine_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
+reload_combine_note_store (rtx dst, const_rtx set, void *data ATTRIBUTE_UNUSED)

 {
   int regno = 0;
   int i;
 {
   int regno = 0;
   int i;


@@ -992,11 +1000,9 @@ reload_combine_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
 
   /* note_stores might have stripped a STRICT_LOW_PART, so we have to be
      careful with registers / register parts that are not full words.
 
   /* note_stores might have stripped a STRICT_LOW_PART, so we have to be
      careful with registers / register parts that are not full words.

-
-     Similarly for ZERO_EXTRACT and SIGN_EXTRACT.  */
+     Similarly for ZERO_EXTRACT.  */

   if (GET_CODE (set) != SET
       || GET_CODE (SET_DEST (set)) == ZERO_EXTRACT
   if (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)
     {
       for (i = hard_regno_nregs[regno][mode] - 1 + regno; i >= regno; i--)
       || GET_CODE (SET_DEST (set)) == STRICT_LOW_PART)
     {
       for (i = hard_regno_nregs[regno][mode] - 1 + regno; i >= regno; i--)


@@ -1057,8 +1063,7 @@ reload_combine_note_use (rtx *xp, rtx insn)
       if (REG_P (SET_DEST (x)))
        {
          /* No spurious CLOBBERs of pseudo registers may remain.  */
       if (REG_P (SET_DEST (x)))
        {
          /* No spurious CLOBBERs of pseudo registers may remain.  */

-         if (REGNO (SET_DEST (x)) >= FIRST_PSEUDO_REGISTER)
-           abort ();
+         gcc_assert (REGNO (SET_DEST (x)) < FIRST_PSEUDO_REGISTER);

          return;
        }
       break;
          return;
        }
       break;


@@ -1078,8 +1083,7 @@ reload_combine_note_use (rtx *xp, rtx insn)
        int nregs;
 
        /* No spurious USEs of pseudo registers may remain.  */
        int nregs;
 
        /* No spurious USEs of pseudo registers may remain.  */

-       if (regno >= FIRST_PSEUDO_REGISTER)
-         abort ();
+       gcc_assert (regno < FIRST_PSEUDO_REGISTER);

 
        nregs = hard_regno_nregs[regno][GET_MODE (x)];
 
 
        nregs = hard_regno_nregs[regno][GET_MODE (x)];
 


@@ -1216,7 +1220,8 @@ reload_cse_move2add (rtx first)
          /* Check if we have valid information on the contents of this
             register in the mode of REG.  */
          if (reg_set_luid[regno] > move2add_last_label_luid
          /* Check if we have valid information on the contents of this
             register in the mode of REG.  */
          if (reg_set_luid[regno] > move2add_last_label_luid

-             && MODES_OK_FOR_MOVE2ADD (GET_MODE (reg), reg_mode[regno]))
+             && MODES_OK_FOR_MOVE2ADD (GET_MODE (reg), reg_mode[regno])
+              && dbg_cnt (cse2_move2add))

            {
              /* Try to transform (set (REGX) (CONST_INT A))
                                  ...
            {
              /* Try to transform (set (REGX) (CONST_INT A))
                                  ...


@@ -1233,10 +1238,8 @@ reload_cse_move2add (rtx first)
 
              if (GET_CODE (src) == CONST_INT && reg_base_reg[regno] < 0)
                {
 
              if (GET_CODE (src) == CONST_INT && reg_base_reg[regno] < 0)
                {

-                 rtx new_src =
-                   GEN_INT (trunc_int_for_mode (INTVAL (src)
-                                                - reg_offset[regno],
-                                                GET_MODE (reg)));
+                 rtx new_src = gen_int_mode (INTVAL (src) - reg_offset[regno],
+                                             GET_MODE (reg));

                  /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
                     use (set (reg) (reg)) instead.
                     We don't delete this insn, nor do we convert it into a
                  /* (set (reg) (plus (reg) (const_int 0))) is not canonical;
                     use (set (reg) (reg)) instead.
                     We don't delete this insn, nor do we convert it into a


@@ -1258,11 +1261,12 @@ reload_cse_move2add (rtx first)
                      rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
                      validate_change (insn, &SET_SRC (pat), tem, 0);
                    }
                      rtx tem = gen_rtx_PLUS (GET_MODE (reg), reg, new_src);
                      validate_change (insn, &SET_SRC (pat), tem, 0);
                    }

-                 else
+                 else if (GET_MODE (reg) != BImode)

                    {
                      enum machine_mode narrow_mode;
                      for (narrow_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
                    {
                      enum machine_mode narrow_mode;
                      for (narrow_mode = GET_CLASS_NARROWEST_MODE (MODE_INT);

-                          narrow_mode != GET_MODE (reg);
+                          narrow_mode != VOIDmode
+                          && narrow_mode != GET_MODE (reg);

                           narrow_mode = GET_MODE_WIDER_MODE (narrow_mode))
                        {
                          if (have_insn_for (STRICT_LOW_PART, narrow_mode)
                           narrow_mode = GET_MODE_WIDER_MODE (narrow_mode))
                        {
                          if (have_insn_for (STRICT_LOW_PART, narrow_mode)


@@ -1273,9 +1277,8 @@ reload_cse_move2add (rtx first)
                            {
                              rtx narrow_reg = gen_rtx_REG (narrow_mode,
                                                            REGNO (reg));
                            {
                              rtx narrow_reg = gen_rtx_REG (narrow_mode,
                                                            REGNO (reg));

-                             rtx narrow_src =
-                               GEN_INT (trunc_int_for_mode (INTVAL (src),
-                                                            narrow_mode));
+                             rtx narrow_src = gen_int_mode (INTVAL (src),
+                                                            narrow_mode);

                              rtx new_set =
                                gen_rtx_SET (VOIDmode,
                                             gen_rtx_STRICT_LOW_PART (VOIDmode,
                              rtx new_set =
                                gen_rtx_SET (VOIDmode,
                                             gen_rtx_STRICT_LOW_PART (VOIDmode,


@@ -1324,10 +1327,10 @@ reload_cse_move2add (rtx first)
                      HOST_WIDE_INT base_offset = reg_offset[REGNO (src)];
                      HOST_WIDE_INT regno_offset = reg_offset[regno];
                      rtx new_src =
                      HOST_WIDE_INT base_offset = reg_offset[REGNO (src)];
                      HOST_WIDE_INT regno_offset = reg_offset[regno];
                      rtx new_src =

-                       GEN_INT (trunc_int_for_mode (added_offset
-                                                    + base_offset
-                                                    - regno_offset,
-                                                    GET_MODE (reg)));
+                       gen_int_mode (added_offset
+                                     + base_offset
+                                     - regno_offset,
+                                     GET_MODE (reg));

                      int success = 0;
 
                      if (new_src == const0_rtx)
                      int success = 0;
 
                      if (new_src == const0_rtx)


@@ -1375,13 +1378,14 @@ reload_cse_move2add (rtx first)
 
       /* If INSN is a conditional branch, we try to extract an
         implicit set out of it.  */
 
       /* If INSN is a conditional branch, we try to extract an
         implicit set out of it.  */

-      if (any_condjump_p (insn) && onlyjump_p (insn))
+      if (any_condjump_p (insn))

        {
          rtx cnd = fis_get_condition (insn);
 
          if (cnd != NULL_RTX
              && GET_CODE (cnd) == NE
              && REG_P (XEXP (cnd, 0))
        {
          rtx cnd = fis_get_condition (insn);
 
          if (cnd != NULL_RTX
              && GET_CODE (cnd) == NE
              && REG_P (XEXP (cnd, 0))

+             && !reg_set_p (XEXP (cnd, 0), insn)

              /* 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
              /* 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


@@ -1415,9 +1419,10 @@ reload_cse_move2add (rtx first)
    Called from reload_cse_move2add via note_stores.  */
 
 static void
    Called from reload_cse_move2add via note_stores.  */
 
 static void

-move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
+move2add_note_store (rtx dst, const_rtx set, void *data ATTRIBUTE_UNUSED)

 {
   unsigned int regno = 0;
 {
   unsigned int regno = 0;

+  unsigned int nregs = 0;

   unsigned int i;
   enum machine_mode mode = GET_MODE (dst);
 
   unsigned int i;
   enum machine_mode mode = GET_MODE (dst);
 


@@ -1427,6 +1432,7 @@ move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
                                   GET_MODE (SUBREG_REG (dst)),
                                   SUBREG_BYTE (dst),
                                   GET_MODE (dst));
                                   GET_MODE (SUBREG_REG (dst)),
                                   SUBREG_BYTE (dst),
                                   GET_MODE (dst));

+      nregs = subreg_nregs (dst);

       dst = SUBREG_REG (dst);
     }
 
       dst = SUBREG_REG (dst);
     }
 


@@ -1444,11 +1450,12 @@ move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
     return;
 
   regno += REGNO (dst);
     return;
 
   regno += REGNO (dst);

+  if (!nregs)
+    nregs = hard_regno_nregs[regno][mode];

 
 

-  if (SCALAR_INT_MODE_P (mode)
-      && hard_regno_nregs[regno][mode] == 1 && GET_CODE (set) == SET
+  if (SCALAR_INT_MODE_P (GET_MODE (dst))
+      && nregs == 1 && GET_CODE (set) == SET

       && GET_CODE (SET_DEST (set)) != ZERO_EXTRACT
       && GET_CODE (SET_DEST (set)) != ZERO_EXTRACT

-      && GET_CODE (SET_DEST (set)) != SIGN_EXTRACT

       && GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
     {
       rtx src = SET_SRC (set);
       && GET_CODE (SET_DEST (set)) != STRICT_LOW_PART)
     {
       rtx src = SET_SRC (set);


@@ -1547,10 +1554,54 @@ move2add_note_store (rtx dst, rtx set, void *data ATTRIBUTE_UNUSED)
     }
   else
     {
     }
   else
     {

-      unsigned int endregno = regno + hard_regno_nregs[regno][mode];
+      unsigned int endregno = regno + nregs;

 
       for (i = regno; i < endregno; i++)
        /* Reset the information about this register.  */
        reg_set_luid[i] = 0;
     }
 }
 
       for (i = regno; i < endregno; i++)
        /* Reset the information about this register.  */
        reg_set_luid[i] = 0;
     }
 }

+\f
+static bool
+gate_handle_postreload (void)
+{
+  return (optimize > 0);
+}
+
+
+static unsigned int
+rest_of_handle_postreload (void)
+{
+  if (!dbg_cnt (postreload_cse))
+    return 0;
+
+  /* Do a very simple CSE pass over just the hard registers.  */
+  reload_cse_regs (get_insns ());
+  /* Reload_cse_regs can eliminate potentially-trapping MEMs.
+     Remove any EH edges associated with them.  */
+  if (flag_non_call_exceptions)
+    purge_all_dead_edges ();
+
+  return 0;
+}
+
+struct rtl_opt_pass pass_postreload_cse =
+{
+ {
+  RTL_PASS,
+  "postreload",                         /* name */
+  gate_handle_postreload,               /* gate */
+  rest_of_handle_postreload,            /* execute */
+  NULL,                                 /* sub */
+  NULL,                                 /* next */
+  0,                                    /* static_pass_number */
+  TV_RELOAD_CSE_REGS,                   /* tv_id */
+  0,                                    /* properties_required */
+  0,                                    /* properties_provided */
+  0,                                    /* properties_destroyed */
+  0,                                    /* todo_flags_start */
+  TODO_df_finish | TODO_verify_rtl_sharing |
+  TODO_dump_func                        /* todo_flags_finish */
+ }
+};
+