GCC 4.2.0 release.

1 files changed, 347 insertions, 226 deletions

diff --git a/contrib/gcc/regrename.c b/contrib/gcc/regrename.c
index 1183f44..c55f9c4 100644
--- a/contrib/gcc/regrename.c
+++ b/contrib/gcc/regrename.c
@@ -1,5 +1,6 @@
 /* Register renaming for the GNU compiler.
-   Copyright (C) 2000, 2001, 2002, 2003, 2004  Free Software Foundation, Inc.
+   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005
+   Free Software Foundation, Inc.
 
    This file is part of GCC.
 
@@ -15,10 +16,8 @@
 
    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.  */
-
-#define REG_OK_STRICT
+   Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+   02110-1301, USA.  */
 
 #include "config.h"
 #include "system.h"
@@ -28,6 +27,7 @@
 #include "tm_p.h"
 #include "insn-config.h"
 #include "regs.h"
+#include "addresses.h"
 #include "hard-reg-set.h"
 #include "basic-block.h"
 #include "reload.h"
@@ -37,12 +37,8 @@
 #include "flags.h"
 #include "toplev.h"
 #include "obstack.h"
-
-#ifndef REG_MODE_OK_FOR_BASE_P
-#define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
-#endif
-
-static const char *const reg_class_names[] = REG_CLASS_NAMES;
+#include "timevar.h"
+#include "tree-pass.h"
 
 struct du_chain
 {
@@ -51,7 +47,7 @@ struct du_chain
 
   rtx insn;
   rtx *loc;
-  ENUM_BITFIELD(reg_class) class : 16;
+  ENUM_BITFIELD(reg_class) cl : 16;
   unsigned int need_caller_save_reg:1;
   unsigned int earlyclobber:1;
 };
@@ -63,7 +59,11 @@ enum scan_actions
   terminate_write,
   terminate_dead,
   mark_read,
-  mark_write
+  mark_write,
+  /* mark_access is for marking the destination regs in
+     REG_FRAME_RELATED_EXPR notes (as if they were read) so that the
+     note is updated properly.  */
+  mark_access
 };
 
 static const char * const scan_actions_name[] =
@@ -73,7 +73,8 @@ static const char * const scan_actions_name[] =
   "terminate_write",
   "terminate_dead",
   "mark_read",
-  "mark_write"
+  "mark_write",
+  "mark_access"
 };
 
 static struct obstack rename_obstack;
@@ -104,15 +105,13 @@ note_sets (rtx x, rtx set ATTRIBUTE_UNUSED, void *data)
 
   if (GET_CODE (x) == SUBREG)
     x = SUBREG_REG (x);
-  if (GET_CODE (x) != REG)
+  if (!REG_P (x))
     return;
-
   regno = REGNO (x);
-  nregs = HARD_REGNO_NREGS (regno, GET_MODE (x));
+  nregs = hard_regno_nregs[regno][GET_MODE (x)];
 
   /* There must not be pseudos at this point.  */
-  if (regno + nregs > FIRST_PSEUDO_REGISTER)
-    abort ();
+  gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
 
   while (nregs-- > 0)
     SET_HARD_REG_BIT (*pset, regno + nregs);
@@ -130,11 +129,10 @@ clear_dead_regs (HARD_REG_SET *pset, enum machine_mode kind, rtx notes)
       {
 	rtx reg = XEXP (note, 0);
 	unsigned int regno = REGNO (reg);
-	int nregs = HARD_REGNO_NREGS (regno, GET_MODE (reg));
+	int nregs = hard_regno_nregs[regno][GET_MODE (reg)];
 
 	/* There must not be pseudos at this point.  */
-	if (regno + nregs > FIRST_PSEUDO_REGISTER)
-	  abort ();
+	gcc_assert (regno + nregs <= FIRST_PSEUDO_REGISTER);
 
 	while (nregs-- > 0)
 	  CLEAR_HARD_REG_BIT (*pset, regno + nregs);
@@ -152,7 +150,7 @@ merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
   rtx insn;
   HARD_REG_SET live;
 
-  REG_SET_TO_HARD_REG_SET (live, b->global_live_at_start);
+  REG_SET_TO_HARD_REG_SET (live, b->il.rtl->global_live_at_start);
   insn = BB_HEAD (b);
   while (t)
     {
@@ -187,7 +185,7 @@ merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
 
 /* Perform register renaming on the current function.  */
 
-void
+static void
 regrename_optimize (void)
 {
   int tick[FIRST_PSEUDO_REGISTER];
@@ -208,12 +206,12 @@ regrename_optimize (void)
 
       CLEAR_HARD_REG_SET (unavailable);
 
-      if (rtl_dump_file)
-	fprintf (rtl_dump_file, "\nBasic block %d:\n", bb->index);
+      if (dump_file)
+	fprintf (dump_file, "\nBasic block %d:\n", bb->index);
 
       all_chains = build_def_use (bb);
 
-      if (rtl_dump_file)
+      if (dump_file)
 	dump_def_use_chain (all_chains);
 
       CLEAR_HARD_REG_SET (unavailable);
@@ -222,11 +220,11 @@ regrename_optimize (void)
 	{
 	  int i;
 
-	  for (i = HARD_REGNO_NREGS (FRAME_POINTER_REGNUM, Pmode); i--;)
+	  for (i = hard_regno_nregs[FRAME_POINTER_REGNUM][Pmode]; i--;)
 	    SET_HARD_REG_BIT (unavailable, FRAME_POINTER_REGNUM + i);
 
 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
-	  for (i = HARD_REGNO_NREGS (HARD_FRAME_POINTER_REGNUM, Pmode); i--;)
+	  for (i = hard_regno_nregs[HARD_FRAME_POINTER_REGNUM][Pmode]; i--;)
 	    SET_HARD_REG_BIT (unavailable, HARD_FRAME_POINTER_REGNUM + i);
 #endif
 	}
@@ -274,13 +272,13 @@ regrename_optimize (void)
 	    {
 	      n_uses++;
 	      IOR_COMPL_HARD_REG_SET (this_unavailable,
-				      reg_class_contents[last->class]);
+				      reg_class_contents[last->cl]);
 	    }
 	  if (n_uses < 1)
 	    continue;
 
 	  IOR_COMPL_HARD_REG_SET (this_unavailable,
-				  reg_class_contents[last->class]);
+				  reg_class_contents[last->cl]);
 
 	  if (this->need_caller_save_reg)
 	    IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
@@ -291,7 +289,7 @@ regrename_optimize (void)
 	     have a closer look at each register still in there.  */
 	  for (new_reg = 0; new_reg < FIRST_PSEUDO_REGISTER; new_reg++)
 	    {
-	      int nregs = HARD_REGNO_NREGS (new_reg, GET_MODE (*this->loc));
+	      int nregs = hard_regno_nregs[new_reg][GET_MODE (*this->loc)];
 
 	      for (i = nregs - 1; i >= 0; --i)
 	        if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
@@ -331,27 +329,28 @@ regrename_optimize (void)
 		}
 	    }
 
-	  if (rtl_dump_file)
+	  if (dump_file)
 	    {
-	      fprintf (rtl_dump_file, "Register %s in insn %d",
+	      fprintf (dump_file, "Register %s in insn %d",
 		       reg_names[reg], INSN_UID (last->insn));
 	      if (last->need_caller_save_reg)
-		fprintf (rtl_dump_file, " crosses a call");
+		fprintf (dump_file, " crosses a call");
 	    }
 
 	  if (best_new_reg == reg)
 	    {
 	      tick[reg] = ++this_tick;
-	      if (rtl_dump_file)
-		fprintf (rtl_dump_file, "; no available better choice\n");
+	      if (dump_file)
+		fprintf (dump_file, "; no available better choice\n");
 	      continue;
 	    }
 
 	  do_replace (this, best_new_reg);
 	  tick[best_new_reg] = ++this_tick;
+	  regs_ever_live[best_new_reg] = 1;
 
-	  if (rtl_dump_file)
-	    fprintf (rtl_dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
+	  if (dump_file)
+	    fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
 	}
 
       obstack_free (&rename_obstack, first_obj);
@@ -359,12 +358,12 @@ regrename_optimize (void)
 
   obstack_free (&rename_obstack, NULL);
 
-  if (rtl_dump_file)
-    fputc ('\n', rtl_dump_file);
+  if (dump_file)
+    fputc ('\n', dump_file);
 
   count_or_remove_death_notes (NULL, 1);
   update_life_info (NULL, UPDATE_LIFE_LOCAL,
-		    PROP_REG_INFO | PROP_DEATH_NOTES);
+		    PROP_DEATH_NOTES);
 }
 
 static void
@@ -388,14 +387,14 @@ static struct du_chain *open_chains;
 static struct du_chain *closed_chains;
 
 static void
-scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx_reg (rtx insn, rtx *loc, enum reg_class cl,
 	      enum scan_actions action, enum op_type type, int earlyclobber)
 {
   struct du_chain **p;
   rtx x = *loc;
   enum machine_mode mode = GET_MODE (x);
   int this_regno = REGNO (x);
-  int this_nregs = HARD_REGNO_NREGS (this_regno, mode);
+  int this_nregs = hard_regno_nregs[this_regno][mode];
 
   if (action == mark_write)
     {
@@ -407,7 +406,7 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
 	  this->next_chain = open_chains;
 	  this->loc = loc;
 	  this->insn = insn;
-	  this->class = class;
+	  this->cl = cl;
 	  this->need_caller_save_reg = 0;
 	  this->earlyclobber = earlyclobber;
 	  open_chains = this;
@@ -415,8 +414,7 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
       return;
     }
 
-  if ((type == OP_OUT && action != terminate_write)
-      || (type != OP_OUT && action == terminate_write))
+  if ((type == OP_OUT) != (action == terminate_write || action == mark_access))
     return;
 
   for (p = &open_chains; *p;)
@@ -435,7 +433,7 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
       else
 	{
 	  int regno = REGNO (*this->loc);
-	  int nregs = HARD_REGNO_NREGS (regno, GET_MODE (*this->loc));
+	  int nregs = hard_regno_nregs[regno][GET_MODE (*this->loc)];
 	  int exact_match = (regno == this_regno && nregs == this_nregs);
 
 	  if (regno + nregs <= this_regno
@@ -445,23 +443,22 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
 	      continue;
 	    }
 
-	  if (action == mark_read)
+	  if (action == mark_read || action == mark_access)
 	    {
-	      if (! exact_match)
-		abort ();
+	      gcc_assert (exact_match);
 
 	      /* ??? Class NO_REGS can happen if the md file makes use of
 		 EXTRA_CONSTRAINTS to match registers.  Which is arguably
 		 wrong, but there we are.  Since we know not what this may
 		 be replaced with, terminate the chain.  */
-	      if (class != NO_REGS)
+	      if (cl != NO_REGS)
 		{
 		  this = obstack_alloc (&rename_obstack, sizeof (struct du_chain));
 		  this->next_use = 0;
 		  this->next_chain = (*p)->next_chain;
 		  this->loc = loc;
 		  this->insn = insn;
-		  this->class = class;
+		  this->cl = cl;
 		  this->need_caller_save_reg = 0;
 		  while (*p)
 		    p = &(*p)->next_use;
@@ -483,16 +480,16 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
 		{
 		  this->next_chain = closed_chains;
 		  closed_chains = this;
-		  if (rtl_dump_file)
-		    fprintf (rtl_dump_file,
+		  if (dump_file)
+		    fprintf (dump_file,
 			     "Closing chain %s at insn %d (%s)\n",
 			     reg_names[REGNO (*this->loc)], INSN_UID (insn),
 			     scan_actions_name[(int) action]);
 		}
 	      else
 		{
-		  if (rtl_dump_file)
-		    fprintf (rtl_dump_file,
+		  if (dump_file)
+		    fprintf (dump_file,
 			     "Discarding chain %s at insn %d (%s)\n",
 			     reg_names[REGNO (*this->loc)], INSN_UID (insn),
 			     scan_actions_name[(int) action]);
@@ -505,11 +502,11 @@ scan_rtx_reg (rtx insn, rtx *loc, enum reg_class class,
     }
 }
 
-/* Adapted from find_reloads_address_1.  CLASS is INDEX_REG_CLASS or
+/* Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
    BASE_REG_CLASS depending on how the register is being considered.  */
 
 static void
-scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx_address (rtx insn, rtx *loc, enum reg_class cl,
 		  enum scan_actions action, enum machine_mode mode)
 {
   rtx x = *loc;
@@ -517,7 +514,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
   const char *fmt;
   int i, j;
 
-  if (action == mark_write)
+  if (action == mark_write || action == mark_access)
     return;
 
   switch (code)
@@ -532,6 +529,7 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
 	rtx op1 = orig_op1;
 	rtx *locI = NULL;
 	rtx *locB = NULL;
+	enum rtx_code index_code = SCRATCH;
 
 	if (GET_CODE (op0) == SUBREG)
 	  {
@@ -550,56 +548,70 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
 	  {
 	    locI = &XEXP (x, 0);
 	    locB = &XEXP (x, 1);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
 		 || code1 == ZERO_EXTEND || code0 == MEM)
 	  {
 	    locI = &XEXP (x, 1);
 	    locB = &XEXP (x, 0);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code0 == CONST_INT || code0 == CONST
 		 || code0 == SYMBOL_REF || code0 == LABEL_REF)
-	  locB = &XEXP (x, 1);
+	  {
+	    locB = &XEXP (x, 1);
+	    index_code = GET_CODE (XEXP (x, 0));
+	  }
 	else if (code1 == CONST_INT || code1 == CONST
 		 || code1 == SYMBOL_REF || code1 == LABEL_REF)
-	  locB = &XEXP (x, 0);
+	  {
+	    locB = &XEXP (x, 0);
+	    index_code = GET_CODE (XEXP (x, 1));
+	  }
 	else if (code0 == REG && code1 == REG)
 	  {
 	    int index_op;
+	    unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
 
-	    if (REG_OK_FOR_INDEX_P (op0)
-		&& REG_MODE_OK_FOR_BASE_P (op1, mode))
+	    if (REGNO_OK_FOR_INDEX_P (regno0)
+		&& regno_ok_for_base_p (regno1, mode, PLUS, REG))
 	      index_op = 0;
-	    else if (REG_OK_FOR_INDEX_P (op1)
-		     && REG_MODE_OK_FOR_BASE_P (op0, mode))
+	    else if (REGNO_OK_FOR_INDEX_P (regno1)
+		     && regno_ok_for_base_p (regno0, mode, PLUS, REG))
 	      index_op = 1;
-	    else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
+	    else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
 	      index_op = 0;
-	    else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
+	    else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
 	      index_op = 1;
-	    else if (REG_OK_FOR_INDEX_P (op1))
+	    else if (REGNO_OK_FOR_INDEX_P (regno1))
 	      index_op = 1;
 	    else
 	      index_op = 0;
 
 	    locI = &XEXP (x, index_op);
 	    locB = &XEXP (x, !index_op);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code0 == REG)
 	  {
 	    locI = &XEXP (x, 0);
 	    locB = &XEXP (x, 1);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code1 == REG)
 	  {
 	    locI = &XEXP (x, 1);
 	    locB = &XEXP (x, 0);
+	    index_code = GET_CODE (*locI);
 	  }
 
 	if (locI)
 	  scan_rtx_address (insn, locI, INDEX_REG_CLASS, action, mode);
 	if (locB)
-	  scan_rtx_address (insn, locB, MODE_BASE_REG_CLASS (mode), action, mode);
+	  scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code),
+			    action, mode);
+
 	return;
       }
 
@@ -618,12 +630,12 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
 
     case MEM:
       scan_rtx_address (insn, &XEXP (x, 0),
-			MODE_BASE_REG_CLASS (GET_MODE (x)), action,
+			base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
 			GET_MODE (x));
       return;
 
     case REG:
-      scan_rtx_reg (insn, loc, class, action, OP_IN, 0);
+      scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
       return;
 
     default:
@@ -634,15 +646,15 @@ scan_rtx_address (rtx insn, rtx *loc, enum reg_class class,
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	scan_rtx_address (insn, &XEXP (x, i), class, action, mode);
+	scan_rtx_address (insn, &XEXP (x, i), cl, action, mode);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  scan_rtx_address (insn, &XVECEXP (x, i, j), class, action, mode);
+	  scan_rtx_address (insn, &XVECEXP (x, i, j), cl, action, mode);
     }
 }
 
 static void
-scan_rtx (rtx insn, rtx *loc, enum reg_class class,
+scan_rtx (rtx insn, rtx *loc, enum reg_class cl,
 	  enum scan_actions action, enum op_type type, int earlyclobber)
 {
   const char *fmt;
@@ -664,31 +676,31 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
       return;
 
     case REG:
-      scan_rtx_reg (insn, loc, class, action, type, earlyclobber);
+      scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
       return;
 
     case MEM:
       scan_rtx_address (insn, &XEXP (x, 0),
-			MODE_BASE_REG_CLASS (GET_MODE (x)), action,
+			base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
 			GET_MODE (x));
       return;
 
     case SET:
-      scan_rtx (insn, &SET_SRC (x), class, action, OP_IN, 0);
-      scan_rtx (insn, &SET_DEST (x), class, action, 
+      scan_rtx (insn, &SET_SRC (x), cl, action, OP_IN, 0);
+      scan_rtx (insn, &SET_DEST (x), cl, action,
 		GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0);
       return;
 
     case STRICT_LOW_PART:
-      scan_rtx (insn, &XEXP (x, 0), class, action, OP_INOUT, earlyclobber);
+      scan_rtx (insn, &XEXP (x, 0), cl, action, OP_INOUT, earlyclobber);
       return;
 
     case ZERO_EXTRACT:
     case SIGN_EXTRACT:
-      scan_rtx (insn, &XEXP (x, 0), class, action,
+      scan_rtx (insn, &XEXP (x, 0), cl, action,
 		type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
-      scan_rtx (insn, &XEXP (x, 1), class, action, OP_IN, 0);
-      scan_rtx (insn, &XEXP (x, 2), class, action, OP_IN, 0);
+      scan_rtx (insn, &XEXP (x, 1), cl, action, OP_IN, 0);
+      scan_rtx (insn, &XEXP (x, 2), cl, action, OP_IN, 0);
       return;
 
     case POST_INC:
@@ -698,17 +710,17 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
     case POST_MODIFY:
     case PRE_MODIFY:
       /* Should only happen inside MEM.  */
-      abort ();
+      gcc_unreachable ();
 
     case CLOBBER:
-      scan_rtx (insn, &SET_DEST (x), class, action,
-		GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 1);
+      scan_rtx (insn, &SET_DEST (x), cl, action,
+		GET_CODE (PATTERN (insn)) == COND_EXEC ? OP_INOUT : OP_OUT, 0);
       return;
 
     case EXPR_LIST:
-      scan_rtx (insn, &XEXP (x, 0), class, action, type, 0);
+      scan_rtx (insn, &XEXP (x, 0), cl, action, type, 0);
       if (XEXP (x, 1))
-	scan_rtx (insn, &XEXP (x, 1), class, action, type, 0);
+	scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
       return;
 
     default:
@@ -719,10 +731,10 @@ scan_rtx (rtx insn, rtx *loc, enum reg_class class,
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	scan_rtx (insn, &XEXP (x, i), class, action, type, 0);
+	scan_rtx (insn, &XEXP (x, i), cl, action, type, 0);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  scan_rtx (insn, &XVECEXP (x, i, j), class, action, type, 0);
+	  scan_rtx (insn, &XVECEXP (x, i, j), cl, action, type, 0);
     }
 }
 
@@ -780,7 +792,7 @@ build_def_use (basic_block bb)
 	    {
 	      int matches = recog_op_alt[i][alt].matches;
 	      if (matches >= 0)
-		recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
+		recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
 	      if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
 	          || (predicated && recog_data.operand_type[i] == OP_OUT))
 		recog_data.operand_type[i] = OP_INOUT;
@@ -829,7 +841,7 @@ build_def_use (basic_block bb)
 	    *recog_data.operand_loc[i] = old_operands[i];
 
 	  /* Step 2B: Can't rename function call argument registers.  */
-	  if (GET_CODE (insn) == CALL_INSN && CALL_INSN_FUNCTION_USAGE (insn))
+	  if (CALL_P (insn) && CALL_INSN_FUNCTION_USAGE (insn))
 	    scan_rtx (insn, &CALL_INSN_FUNCTION_USAGE (insn),
 		      NO_REGS, terminate_all_read, OP_IN, 0);
 
@@ -841,7 +853,7 @@ build_def_use (basic_block bb)
 		rtx *loc = recog_data.operand_loc[i];
 		rtx op = *loc;
 
-		if (GET_CODE (op) == REG
+		if (REG_P (op)
 		    && REGNO (op) == ORIGINAL_REGNO (op)
 		    && (recog_data.operand_type[i] == OP_IN
 			|| recog_data.operand_type[i] == OP_INOUT))
@@ -855,7 +867,7 @@ build_def_use (basic_block bb)
 	      rtx *loc = (i < n_ops
 			  ? recog_data.operand_loc[opn]
 			  : recog_data.dup_loc[i - n_ops]);
-	      enum reg_class class = recog_op_alt[opn][alt].class;
+	      enum reg_class cl = recog_op_alt[opn][alt].cl;
 	      enum op_type type = recog_data.operand_type[opn];
 
 	      /* Don't scan match_operand here, since we've no reg class
@@ -865,26 +877,28 @@ build_def_use (basic_block bb)
 		continue;
 
 	      if (recog_op_alt[opn][alt].is_address)
-		scan_rtx_address (insn, loc, class, mark_read, VOIDmode);
+		scan_rtx_address (insn, loc, cl, mark_read, VOIDmode);
 	      else
-		scan_rtx (insn, loc, class, mark_read, type, 0);
+		scan_rtx (insn, loc, cl, mark_read, type, 0);
 	    }
 
-	  /* Step 4: Close chains for registers that die here.
-	     Also record updates for REG_INC notes.  */
+	  /* Step 3B: Record updates for regs in REG_INC notes, and
+	     source regs in REG_FRAME_RELATED_EXPR notes.  */
 	  for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
-	    {
-	      if (REG_NOTE_KIND (note) == REG_DEAD)
-		scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
-			  OP_IN, 0);
-	      else if (REG_NOTE_KIND (note) == REG_INC)
-		scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read,
-			  OP_INOUT, 0);
-	    }
+	    if (REG_NOTE_KIND (note) == REG_INC
+		|| REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR)
+	      scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_read,
+			OP_INOUT, 0);
+
+	  /* Step 4: Close chains for registers that die here.  */
+	  for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
+	    if (REG_NOTE_KIND (note) == REG_DEAD)
+	      scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
+			OP_IN, 0);
 
 	  /* Step 4B: If this is a call, any chain live at this point
 	     requires a caller-saved reg.  */
-	  if (GET_CODE (insn) == CALL_INSN)
+	  if (CALL_P (insn))
 	    {
 	      struct du_chain *p;
 	      for (p = open_chains; p; p = p->next_chain)
@@ -929,30 +943,37 @@ build_def_use (basic_block bb)
 		  {
 		    rtx *loc = recog_data.operand_loc[i];
 		    rtx op = *loc;
-		    enum reg_class class = recog_op_alt[i][alt].class;
+		    enum reg_class cl = recog_op_alt[i][alt].cl;
 
-		    if (GET_CODE (op) == REG
+		    if (REG_P (op)
 			&& REGNO (op) == ORIGINAL_REGNO (op))
 		      continue;
 
-		    scan_rtx (insn, loc, class, mark_write, OP_OUT,
+		    scan_rtx (insn, loc, cl, mark_write, OP_OUT,
 			      recog_op_alt[i][alt].earlyclobber);
 		  }
 	    }
-	  else if (GET_CODE (insn) != CALL_INSN)
+	  else if (!CALL_P (insn))
 	    for (i = 0; i < n_ops + recog_data.n_dups; i++)
 	      {
 		int opn = i < n_ops ? i : recog_data.dup_num[i - n_ops];
 		rtx *loc = (i < n_ops
 			    ? recog_data.operand_loc[opn]
 			    : recog_data.dup_loc[i - n_ops]);
-		enum reg_class class = recog_op_alt[opn][alt].class;
+		enum reg_class cl = recog_op_alt[opn][alt].cl;
 
 		if (recog_data.operand_type[opn] == OP_OUT)
-		  scan_rtx (insn, loc, class, mark_write, OP_OUT,
+		  scan_rtx (insn, loc, cl, mark_write, OP_OUT,
 			    recog_op_alt[opn][alt].earlyclobber);
 	      }
 
+	  /* Step 6B: Record destination regs in REG_FRAME_RELATED_EXPR
+	     notes for update.  */
+	  for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
+	    if (REG_NOTE_KIND (note) == REG_FRAME_RELATED_EXPR)
+	      scan_rtx (insn, &XEXP (note, 0), ALL_REGS, mark_access,
+			OP_INOUT, 0);
+
 	  /* Step 7: Close chains for registers that were never
 	     really used here.  */
 	  for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
@@ -969,7 +990,7 @@ build_def_use (basic_block bb)
   return closed_chains;
 }
 
-/* Dump all def/use chains in CHAINS to RTL_DUMP_FILE.  They are
+/* Dump all def/use chains in CHAINS to DUMP_FILE.  They are
    printed in reverse order as that's how we build them.  */
 
 static void
@@ -979,15 +1000,15 @@ dump_def_use_chain (struct du_chain *chains)
     {
       struct du_chain *this = chains;
       int r = REGNO (*this->loc);
-      int nregs = HARD_REGNO_NREGS (r, GET_MODE (*this->loc));
-      fprintf (rtl_dump_file, "Register %s (%d):", reg_names[r], nregs);
+      int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
+      fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs);
       while (this)
 	{
-	  fprintf (rtl_dump_file, " %d [%s]", INSN_UID (this->insn),
-		   reg_class_names[this->class]);
+	  fprintf (dump_file, " %d [%s]", INSN_UID (this->insn),
+		   reg_class_names[this->cl]);
 	  this = this->next_use;
 	}
-      fprintf (rtl_dump_file, "\n");
+      fprintf (dump_file, "\n");
       chains = chains->next_chain;
     }
 }
@@ -1017,7 +1038,8 @@ struct value_data
   unsigned int max_value_regs;
 };
 
-static void kill_value_regno (unsigned, struct value_data *);
+static void kill_value_one_regno (unsigned, struct value_data *);
+static void kill_value_regno (unsigned, unsigned, struct value_data *);
 static void kill_value (rtx, struct value_data *);
 static void set_value_regno (unsigned, enum machine_mode, struct value_data *);
 static void init_value_data (struct value_data *);
@@ -1042,11 +1064,13 @@ extern void debug_value_data (struct value_data *);
 static void validate_value_data (struct value_data *);
 #endif
 
-/* Kill register REGNO.  This involves removing it from any value lists,
-   and resetting the value mode to VOIDmode.  */
+/* Kill register REGNO.  This involves removing it from any value
+   lists, and resetting the value mode to VOIDmode.  This is only a
+   helper function; it does not handle any hard registers overlapping
+   with REGNO.  */
 
 static void
-kill_value_regno (unsigned int regno, struct value_data *vd)
+kill_value_one_regno (unsigned int regno, struct value_data *vd)
 {
   unsigned int i, next;
 
@@ -1073,44 +1097,57 @@ kill_value_regno (unsigned int regno, struct value_data *vd)
 #endif
 }
 
-/* Kill X.  This is a convenience function for kill_value_regno
+/* Kill the value in register REGNO for NREGS, and any other registers
+   whose values overlap.  */
+
+static void
+kill_value_regno (unsigned int regno, unsigned int nregs,
+		  struct value_data *vd)
+{
+  unsigned int j;
+
+  /* Kill the value we're told to kill.  */
+  for (j = 0; j < nregs; ++j)
+    kill_value_one_regno (regno + j, vd);
+
+  /* Kill everything that overlapped what we're told to kill.  */
+  if (regno < vd->max_value_regs)
+    j = 0;
+  else
+    j = regno - vd->max_value_regs;
+  for (; j < regno; ++j)
+    {
+      unsigned int i, n;
+      if (vd->e[j].mode == VOIDmode)
+	continue;
+      n = hard_regno_nregs[j][vd->e[j].mode];
+      if (j + n > regno)
+	for (i = 0; i < n; ++i)
+	  kill_value_one_regno (j + i, vd);
+    }
+}
+
+/* Kill X.  This is a convenience function wrapping kill_value_regno
    so that we mind the mode the register is in.  */
 
 static void
 kill_value (rtx x, struct value_data *vd)
 {
-  /* SUBREGS are supposed to have been eliminated by now.  But some
-     ports, e.g. i386 sse, use them to smuggle vector type information
-     through to instruction selection.  Each such SUBREG should simplify,
-     so if we get a NULL  we've done something wrong elsewhere.  */
+  rtx orig_rtx = x;
 
   if (GET_CODE (x) == SUBREG)
-    x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
-			 GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
+    {
+      x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
+			   GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
+      if (x == NULL_RTX)
+	x = SUBREG_REG (orig_rtx);
+    }
   if (REG_P (x))
     {
       unsigned int regno = REGNO (x);
-      unsigned int n = HARD_REGNO_NREGS (regno, GET_MODE (x));
-      unsigned int i, j;
-
-      /* Kill the value we're told to kill.  */
-      for (i = 0; i < n; ++i)
-	kill_value_regno (regno + i, vd);
+      unsigned int n = hard_regno_nregs[regno][GET_MODE (x)];
 
-      /* Kill everything that overlapped what we're told to kill.  */
-      if (regno < vd->max_value_regs)
-	j = 0;
-      else
-	j = regno - vd->max_value_regs;
-      for (; j < regno; ++j)
-	{
-	  if (vd->e[j].mode == VOIDmode)
-	    continue;
-	  n = HARD_REGNO_NREGS (j, vd->e[j].mode);
-	  if (j + n > regno)
-	    for (i = 0; i < n; ++i)
-	      kill_value_regno (j + i, vd);
-	}
+      kill_value_regno (regno, n, vd);
     }
 }
 
@@ -1124,7 +1161,7 @@ set_value_regno (unsigned int regno, enum machine_mode mode,
 
   vd->e[regno].mode = mode;
 
-  nregs = HARD_REGNO_NREGS (regno, mode);
+  nregs = hard_regno_nregs[regno][mode];
   if (nregs > vd->max_value_regs)
     vd->max_value_regs = nregs;
 }
@@ -1179,7 +1216,7 @@ kill_autoinc_value (rtx *px, void *data)
   rtx x = *px;
   struct value_data *vd = data;
 
-  if (GET_RTX_CLASS (GET_CODE (x)) == 'a')
+  if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
     {
       x = XEXP (x, 0);
       kill_value (x, vd);
@@ -1215,9 +1252,15 @@ copy_value (rtx dest, rtx src, struct value_data *vd)
   if (frame_pointer_needed && dr == HARD_FRAME_POINTER_REGNUM)
     return;
 
+  /* Do not propagate copies to fixed or global registers, patterns
+     can be relying to see particular fixed register or users can
+     expect the chosen global register in asm.  */
+  if (fixed_regs[dr] || global_regs[dr])
+    return;
+
   /* If SRC and DEST overlap, don't record anything.  */
-  dn = HARD_REGNO_NREGS (dr, GET_MODE (dest));
-  sn = HARD_REGNO_NREGS (sr, GET_MODE (dest));
+  dn = hard_regno_nregs[dr][GET_MODE (dest)];
+  sn = hard_regno_nregs[sr][GET_MODE (dest)];
   if ((dr > sr && dr < sr + sn)
       || (sr > dr && sr < dr + dn))
     return;
@@ -1243,7 +1286,7 @@ copy_value (rtx dest, rtx src, struct value_data *vd)
 
      We can't properly represent the latter case in our tables, so don't
      record anything then.  */
-  else if (sn < (unsigned int) HARD_REGNO_NREGS (sr, vd->e[sr].mode)
+  else if (sn < (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode]
 	   && (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
 	       ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
     return;
@@ -1251,7 +1294,7 @@ copy_value (rtx dest, rtx src, struct value_data *vd)
   /* If SRC had been assigned a mode narrower than the copy, we can't
      link DEST into the chain, because not all of the pieces of the
      copy came from oldest_regno.  */
-  else if (sn > (unsigned int) HARD_REGNO_NREGS (sr, vd->e[sr].mode))
+  else if (sn > (unsigned int) hard_regno_nregs[sr][vd->e[sr].mode])
     return;
 
   /* Link DR at the end of the value chain used by SR.  */
@@ -1297,8 +1340,8 @@ maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
     return gen_rtx_raw_REG (new_mode, regno);
   else if (mode_change_ok (orig_mode, new_mode, regno))
     {
-      int copy_nregs = HARD_REGNO_NREGS (copy_regno, copy_mode);
-      int use_nregs = HARD_REGNO_NREGS (copy_regno, new_mode);
+      int copy_nregs = hard_regno_nregs[copy_regno][copy_mode];
+      int use_nregs = hard_regno_nregs[copy_regno][new_mode];
       int copy_offset
 	= GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
       int offset
@@ -1317,11 +1360,11 @@ maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
 }
 
 /* Find the oldest copy of the value contained in REGNO that is in
-   register class CLASS and has mode MODE.  If found, return an rtx
+   register class CL and has mode MODE.  If found, return an rtx
    of that oldest register, otherwise return NULL.  */
 
 static rtx
-find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
+find_oldest_value_reg (enum reg_class cl, rtx reg, struct value_data *vd)
 {
   unsigned int regno = REGNO (reg);
   enum machine_mode mode = GET_MODE (reg);
@@ -1336,8 +1379,8 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
      Replacing r9 with r11 is invalid.  */
   if (mode != vd->e[regno].mode)
     {
-      if (HARD_REGNO_NREGS (regno, mode)
-	  > HARD_REGNO_NREGS (regno, vd->e[regno].mode))
+      if (hard_regno_nregs[regno][mode]
+	  > hard_regno_nregs[regno][vd->e[regno].mode])
 	return NULL_RTX;
     }
 
@@ -1347,8 +1390,8 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
       rtx new;
       unsigned int last;
 
-      for (last = i; last < i + HARD_REGNO_NREGS (i, mode); last++)
-	if (!TEST_HARD_REG_BIT (reg_class_contents[class], last))
+      for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
+	if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
 	  return NULL_RTX;
 
       new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
@@ -1364,31 +1407,31 @@ find_oldest_value_reg (enum reg_class class, rtx reg, struct value_data *vd)
 }
 
 /* If possible, replace the register at *LOC with the oldest register
-   in register class CLASS.  Return true if successfully replaced.  */
+   in register class CL.  Return true if successfully replaced.  */
 
 static bool
-replace_oldest_value_reg (rtx *loc, enum reg_class class, rtx insn,
+replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
 			  struct value_data *vd)
 {
-  rtx new = find_oldest_value_reg (class, *loc, vd);
+  rtx new = find_oldest_value_reg (cl, *loc, vd);
   if (new)
     {
-      if (rtl_dump_file)
-	fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n",
+      if (dump_file)
+	fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
 		 INSN_UID (insn), REGNO (*loc), REGNO (new));
 
-      *loc = new;
+      validate_change (insn, loc, new, 1);
       return true;
     }
   return false;
 }
 
 /* Similar to replace_oldest_value_reg, but *LOC contains an address.
-   Adapted from find_reloads_address_1.  CLASS is INDEX_REG_CLASS or
+   Adapted from find_reloads_address_1.  CL is INDEX_REG_CLASS or
    BASE_REG_CLASS depending on how the register is being considered.  */
 
 static bool
-replace_oldest_value_addr (rtx *loc, enum reg_class class,
+replace_oldest_value_addr (rtx *loc, enum reg_class cl,
 			   enum machine_mode mode, rtx insn,
 			   struct value_data *vd)
 {
@@ -1410,6 +1453,7 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
 	rtx op1 = orig_op1;
 	rtx *locI = NULL;
 	rtx *locB = NULL;
+	enum rtx_code index_code = SCRATCH;
 
 	if (GET_CODE (op0) == SUBREG)
 	  {
@@ -1428,50 +1472,62 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
 	  {
 	    locI = &XEXP (x, 0);
 	    locB = &XEXP (x, 1);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
 		 || code1 == ZERO_EXTEND || code0 == MEM)
 	  {
 	    locI = &XEXP (x, 1);
 	    locB = &XEXP (x, 0);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code0 == CONST_INT || code0 == CONST
 		 || code0 == SYMBOL_REF || code0 == LABEL_REF)
-	  locB = &XEXP (x, 1);
+	  {
+	    locB = &XEXP (x, 1);
+	    index_code = GET_CODE (XEXP (x, 0));
+	  }
 	else if (code1 == CONST_INT || code1 == CONST
 		 || code1 == SYMBOL_REF || code1 == LABEL_REF)
-	  locB = &XEXP (x, 0);
+	  {
+	    locB = &XEXP (x, 0);
+	    index_code = GET_CODE (XEXP (x, 1));
+	  }
 	else if (code0 == REG && code1 == REG)
 	  {
 	    int index_op;
+	    unsigned regno0 = REGNO (op0), regno1 = REGNO (op1);
 
-	    if (REG_OK_FOR_INDEX_P (op0)
-		&& REG_MODE_OK_FOR_BASE_P (op1, mode))
+	    if (REGNO_OK_FOR_INDEX_P (regno0)
+		&& regno_ok_for_base_p (regno1, mode, PLUS, REG))
 	      index_op = 0;
-	    else if (REG_OK_FOR_INDEX_P (op1)
-		     && REG_MODE_OK_FOR_BASE_P (op0, mode))
+	    else if (REGNO_OK_FOR_INDEX_P (regno1)
+		     && regno_ok_for_base_p (regno0, mode, PLUS, REG))
 	      index_op = 1;
-	    else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
+	    else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
 	      index_op = 0;
-	    else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
+	    else if (regno_ok_for_base_p (regno0, mode, PLUS, REG))
 	      index_op = 1;
-	    else if (REG_OK_FOR_INDEX_P (op1))
+	    else if (REGNO_OK_FOR_INDEX_P (regno1))
 	      index_op = 1;
 	    else
 	      index_op = 0;
 
 	    locI = &XEXP (x, index_op);
 	    locB = &XEXP (x, !index_op);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code0 == REG)
 	  {
 	    locI = &XEXP (x, 0);
 	    locB = &XEXP (x, 1);
+	    index_code = GET_CODE (*locI);
 	  }
 	else if (code1 == REG)
 	  {
 	    locI = &XEXP (x, 1);
 	    locB = &XEXP (x, 0);
+	    index_code = GET_CODE (*locI);
 	  }
 
 	if (locI)
@@ -1479,7 +1535,8 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
 						insn, vd);
 	if (locB)
 	  changed |= replace_oldest_value_addr (locB,
-						MODE_BASE_REG_CLASS (mode),
+						base_reg_class (mode, PLUS,
+								index_code),
 						mode, insn, vd);
 	return changed;
       }
@@ -1496,7 +1553,7 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
       return replace_oldest_value_mem (x, insn, vd);
 
     case REG:
-      return replace_oldest_value_reg (loc, class, insn, vd);
+      return replace_oldest_value_reg (loc, cl, insn, vd);
 
     default:
       break;
@@ -1506,11 +1563,11 @@ replace_oldest_value_addr (rtx *loc, enum reg_class class,
   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
     {
       if (fmt[i] == 'e')
-	changed |= replace_oldest_value_addr (&XEXP (x, i), class, mode,
+	changed |= replace_oldest_value_addr (&XEXP (x, i), cl, mode,
 					      insn, vd);
       else if (fmt[i] == 'E')
 	for (j = XVECLEN (x, i) - 1; j >= 0; j--)
-	  changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), class,
+	  changed |= replace_oldest_value_addr (&XVECEXP (x, i, j), cl,
 						mode, insn, vd);
     }
 
@@ -1523,7 +1580,8 @@ static bool
 replace_oldest_value_mem (rtx x, rtx insn, struct value_data *vd)
 {
   return replace_oldest_value_addr (&XEXP (x, 0),
-				    MODE_BASE_REG_CLASS (GET_MODE (x)),
+				    base_reg_class (GET_MODE (x), MEM,
+						    SCRATCH),
 				    GET_MODE (x), insn, vd);
 }
 
@@ -1538,8 +1596,9 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
   for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
     {
       int n_ops, i, alt, predicated;
-      bool is_asm;
+      bool is_asm, any_replacements;
       rtx set;
+      bool replaced[MAX_RECOG_OPERANDS];
 
       if (! INSN_P (insn))
 	{
@@ -1567,7 +1626,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	{
 	  int matches = recog_op_alt[i][alt].matches;
 	  if (matches >= 0)
-	    recog_op_alt[i][alt].class = recog_op_alt[matches][alt].class;
+	    recog_op_alt[i][alt].cl = recog_op_alt[matches][alt].cl;
 	  if (matches >= 0 || recog_op_alt[i][alt].matched >= 0
 	      || (predicated && recog_data.operand_type[i] == OP_OUT))
 	    recog_data.operand_type[i] = OP_INOUT;
@@ -1606,8 +1665,8 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	     set it in, make sure that the replacement is valid.  */
 	  if (mode != vd->e[regno].mode)
 	    {
-	      if (HARD_REGNO_NREGS (regno, mode)
-		  > HARD_REGNO_NREGS (regno, vd->e[regno].mode))
+	      if (hard_regno_nregs[regno][mode]
+		  > hard_regno_nregs[regno][vd->e[regno].mode])
 		goto no_move_special_case;
 	    }
 
@@ -1618,8 +1677,8 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	      new = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
 	      if (new && validate_change (insn, &SET_SRC (set), new, 0))
 		{
-		  if (rtl_dump_file)
-		    fprintf (rtl_dump_file,
+		  if (dump_file)
+		    fprintf (dump_file,
 			     "insn %u: replaced reg %u with %u\n",
 			     INSN_UID (insn), regno, REGNO (new));
 		  changed = true;
@@ -1639,8 +1698,8 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 		    {
 		      ORIGINAL_REGNO (new) = ORIGINAL_REGNO (src);
 		      REG_ATTRS (new) = REG_ATTRS (src);
-		      if (rtl_dump_file)
-			fprintf (rtl_dump_file,
+		      if (dump_file)
+			fprintf (dump_file,
 				 "insn %u: replaced reg %u with %u\n",
 				 INSN_UID (insn), regno, REGNO (new));
 		      changed = true;
@@ -1651,11 +1710,13 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	}
       no_move_special_case:
 
+      any_replacements = false;
+
       /* For each input operand, replace a hard register with the
 	 eldest live copy that's in an appropriate register class.  */
       for (i = 0; i < n_ops; i++)
 	{
-	  bool replaced = false;
+	  replaced[i] = false;
 
 	  /* Don't scan match_operand here, since we've no reg class
 	     information to pass down.  Any operands that we could
@@ -1664,7 +1725,7 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	    continue;
 
 	  /* Don't replace in asms intentionally referencing hard regs.  */
-	  if (is_asm && GET_CODE (recog_data.operand[i]) == REG
+	  if (is_asm && REG_P (recog_data.operand[i])
 	      && (REGNO (recog_data.operand[i])
 		  == ORIGINAL_REGNO (recog_data.operand[i])))
 	    continue;
@@ -1672,45 +1733,65 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 	  if (recog_data.operand_type[i] == OP_IN)
 	    {
 	      if (recog_op_alt[i][alt].is_address)
-		replaced
+		replaced[i]
 		  = replace_oldest_value_addr (recog_data.operand_loc[i],
-					       recog_op_alt[i][alt].class,
+					       recog_op_alt[i][alt].cl,
 					       VOIDmode, insn, vd);
 	      else if (REG_P (recog_data.operand[i]))
-		replaced
+		replaced[i]
 		  = replace_oldest_value_reg (recog_data.operand_loc[i],
-					      recog_op_alt[i][alt].class,
+					      recog_op_alt[i][alt].cl,
 					      insn, vd);
-	      else if (GET_CODE (recog_data.operand[i]) == MEM)
-		replaced = replace_oldest_value_mem (recog_data.operand[i],
-						     insn, vd);
+	      else if (MEM_P (recog_data.operand[i]))
+		replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
+							insn, vd);
 	    }
-	  else if (GET_CODE (recog_data.operand[i]) == MEM)
-	    replaced = replace_oldest_value_mem (recog_data.operand[i],
-						 insn, vd);
+	  else if (MEM_P (recog_data.operand[i]))
+	    replaced[i] = replace_oldest_value_mem (recog_data.operand[i],
+						    insn, vd);
 
 	  /* If we performed any replacement, update match_dups.  */
-	  if (replaced)
+	  if (replaced[i])
 	    {
 	      int j;
 	      rtx new;
 
-	      changed = true;
-
 	      new = *recog_data.operand_loc[i];
 	      recog_data.operand[i] = new;
 	      for (j = 0; j < recog_data.n_dups; j++)
 		if (recog_data.dup_num[j] == i)
-		  *recog_data.dup_loc[j] = new;
+		  validate_change (insn, recog_data.dup_loc[j], new, 1);
+
+	      any_replacements = true;
 	    }
 	}
 
+      if (any_replacements)
+	{
+	  if (! apply_change_group ())
+	    {
+	      for (i = 0; i < n_ops; i++)
+		if (replaced[i])
+		  {
+		    rtx old = *recog_data.operand_loc[i];
+		    recog_data.operand[i] = old;
+		  }
+
+	      if (dump_file)
+		fprintf (dump_file,
+			 "insn %u: reg replacements not verified\n",
+			 INSN_UID (insn));
+	    }
+	  else
+	    changed = true;
+	}
+
     did_replacement:
       /* Clobber call-clobbered registers.  */
-      if (GET_CODE (insn) == CALL_INSN)
+      if (CALL_P (insn))
 	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 	  if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
-	    kill_value_regno (i, vd);
+	    kill_value_regno (i, 1, vd);
 
       /* Notice stores.  */
       note_stores (PATTERN (insn), kill_set_value, vd);
@@ -1728,31 +1809,33 @@ copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
 
 /* Main entry point for the forward copy propagation optimization.  */
 
-void
+static void
 copyprop_hardreg_forward (void)
 {
   struct value_data *all_vd;
   bool need_refresh;
-  basic_block bb, bbp = 0;
+  basic_block bb;
+  sbitmap visited;
 
   need_refresh = false;
 
-  all_vd = xmalloc (sizeof (struct value_data) * last_basic_block);
+  all_vd = XNEWVEC (struct value_data, last_basic_block);
+
+  visited = sbitmap_alloc (last_basic_block);
+  sbitmap_zero (visited);
 
   FOR_EACH_BB (bb)
     {
+      SET_BIT (visited, bb->index);
+
       /* If a block has a single predecessor, that we've already
 	 processed, begin with the value data that was live at
 	 the end of the predecessor block.  */
       /* ??? Ought to use more intelligent queuing of blocks.  */
-      if (bb->pred)
-	for (bbp = bb; bbp && bbp != bb->pred->src; bbp = bbp->prev_bb);
-      if (bb->pred
-	  && ! bb->pred->pred_next
-	  && ! (bb->pred->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
-	  && bb->pred->src != ENTRY_BLOCK_PTR
-	  && bbp)
-	all_vd[bb->index] = all_vd[bb->pred->src->index];
+      if (single_pred_p (bb) 
+	  && TEST_BIT (visited, single_pred (bb)->index)
+	  && ! (single_pred_edge (bb)->flags & (EDGE_ABNORMAL_CALL | EDGE_EH)))
+	all_vd[bb->index] = all_vd[single_pred (bb)->index];
       else
 	init_value_data (all_vd + bb->index);
 
@@ -1760,15 +1843,17 @@ copyprop_hardreg_forward (void)
 	need_refresh = true;
     }
 
+  sbitmap_free (visited);  
+
   if (need_refresh)
     {
-      if (rtl_dump_file)
-	fputs ("\n\n", rtl_dump_file);
+      if (dump_file)
+	fputs ("\n\n", dump_file);
 
       /* ??? Irritatingly, delete_noop_moves does not take a set of blocks
 	 to scan, so we have to do a life update with no initial set of
 	 blocks Just In Case.  */
-      delete_noop_moves (get_insns ());
+      delete_noop_moves ();
       update_life_info (NULL, UPDATE_LIFE_GLOBAL_RM_NOTES,
 			PROP_DEATH_NOTES
 			| PROP_SCAN_DEAD_CODE
@@ -1881,3 +1966,39 @@ validate_value_data (struct value_data *vd)
 		      vd->e[i].next_regno);
 }
 #endif
+
+static bool
+gate_handle_regrename (void)
+{
+  return (optimize > 0 && (flag_rename_registers || flag_cprop_registers));
+}
+
+
+/* Run the regrename and cprop passes.  */
+static unsigned int
+rest_of_handle_regrename (void)
+{
+  if (flag_rename_registers)
+    regrename_optimize ();
+  if (flag_cprop_registers)
+    copyprop_hardreg_forward ();
+  return 0;
+}
+
+struct tree_opt_pass pass_regrename =
+{
+  "rnreg",                              /* name */
+  gate_handle_regrename,                /* gate */
+  rest_of_handle_regrename,             /* execute */
+  NULL,                                 /* sub */
+  NULL,                                 /* next */
+  0,                                    /* static_pass_number */
+  TV_RENAME_REGISTERS,                  /* tv_id */
+  0,                                    /* properties_required */
+  0,                                    /* properties_provided */
+  0,                                    /* properties_destroyed */
+  0,                                    /* todo_flags_start */
+  TODO_dump_func,                       /* todo_flags_finish */
+  'n'                                   /* letter */
+};
+