2009-05-07 Paolo Bonzini <bonzini@gnu.org>

	* Makefile.in (OBJS-common): Add regcprop.o.
	(regcprop.o): New.
	* timevar.def (TV_CPROP_REGISTERS): New.
	* regrename.c (regrename_optimize): Return 0.
	(rest_of_handle_regrename): Delete.
	(pass_rename_registers): Point to regrename_optimize.
	(struct value_data_entry, struct value_data, 
	kill_value_one_regno, kill_value_regno, kill_value,
	set_value_regno, init_value_data, kill_clobbered_value,
	kill_set_value, kill_autoinc_value, copy_value,
	mode_change_ok, maybe_mode_change, find_oldest_value_reg,
	replace_oldest_value_reg, replace_oldest_value_addr,
	replace_oldest_value_mem, copyprop_hardreg_forward_1,
	debug_value_data, validate_value_data): Move...
	* regcprop.c: ... here.
	(rest_of_handle_cprop): Delete.
	(pass_cprop_hardreg): Point to copyprop_hardreg_forward.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@147243 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 4 insertions, 980 deletions

diff --git a/gcc/regrename.c b/gcc/regrename.c
index c678a093ca9..fcdaaf79e81 100644
--- a/gcc/regrename.c
+++ b/gcc/regrename.c
@@ -180,7 +180,7 @@ merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
 
 /* Perform register renaming on the current function.  */
 
-static void
+static unsigned int
 regrename_optimize (void)
 {
   int tick[FIRST_PSEUDO_REGISTER];
@@ -355,6 +355,8 @@ regrename_optimize (void)
 
   if (dump_file)
     fputc ('\n', dump_file);
+
+  return 0;
 }
 
 static void
@@ -999,943 +1001,7 @@ dump_def_use_chain (struct du_chain *chains)
       chains = chains->next_chain;
     }
 }
-
-/* The following code does forward propagation of hard register copies.
-   The object is to eliminate as many dependencies as possible, so that
-   we have the most scheduling freedom.  As a side effect, we also clean
-   up some silly register allocation decisions made by reload.  This
-   code may be obsoleted by a new register allocator.  */
-
-/* For each register, we have a list of registers that contain the same
-   value.  The OLDEST_REGNO field points to the head of the list, and
-   the NEXT_REGNO field runs through the list.  The MODE field indicates
-   what mode the data is known to be in; this field is VOIDmode when the
-   register is not known to contain valid data.  */
-
-struct value_data_entry
-{
-  enum machine_mode mode;
-  unsigned int oldest_regno;
-  unsigned int next_regno;
-};
-
-struct value_data
-{
-  struct value_data_entry e[FIRST_PSEUDO_REGISTER];
-  unsigned int max_value_regs;
-};
-
-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 *);
-static void kill_clobbered_value (rtx, const_rtx, void *);
-static void kill_set_value (rtx, const_rtx, void *);
-static int kill_autoinc_value (rtx *, void *);
-static void copy_value (rtx, rtx, struct value_data *);
-static bool mode_change_ok (enum machine_mode, enum machine_mode,
-			    unsigned int);
-static rtx maybe_mode_change (enum machine_mode, enum machine_mode,
-			      enum machine_mode, unsigned int, unsigned int);
-static rtx find_oldest_value_reg (enum reg_class, rtx, struct value_data *);
-static bool replace_oldest_value_reg (rtx *, enum reg_class, rtx,
-				      struct value_data *);
-static bool replace_oldest_value_addr (rtx *, enum reg_class,
-				       enum machine_mode, rtx,
-				       struct value_data *);
-static bool replace_oldest_value_mem (rtx, rtx, struct value_data *);
-static bool copyprop_hardreg_forward_1 (basic_block, struct value_data *);
-extern void debug_value_data (struct value_data *);
-#ifdef ENABLE_CHECKING
-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.  This is only a
-   helper function; it does not handle any hard registers overlapping
-   with REGNO.  */
-
-static void
-kill_value_one_regno (unsigned int regno, struct value_data *vd)
-{
-  unsigned int i, next;
-
-  if (vd->e[regno].oldest_regno != regno)
-    {
-      for (i = vd->e[regno].oldest_regno;
-	   vd->e[i].next_regno != regno;
-	   i = vd->e[i].next_regno)
-	continue;
-      vd->e[i].next_regno = vd->e[regno].next_regno;
-    }
-  else if ((next = vd->e[regno].next_regno) != INVALID_REGNUM)
-    {
-      for (i = next; i != INVALID_REGNUM; i = vd->e[i].next_regno)
-	vd->e[i].oldest_regno = next;
-    }
-
-  vd->e[regno].mode = VOIDmode;
-  vd->e[regno].oldest_regno = regno;
-  vd->e[regno].next_regno = INVALID_REGNUM;
-
-#ifdef ENABLE_CHECKING
-  validate_value_data (vd);
-#endif
-}
-
-/* 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)
-{
-  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));
-      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)];
 
-      kill_value_regno (regno, n, vd);
-    }
-}
-
-/* Remember that REGNO is valid in MODE.  */
-
-static void
-set_value_regno (unsigned int regno, enum machine_mode mode,
-		 struct value_data *vd)
-{
-  unsigned int nregs;
-
-  vd->e[regno].mode = mode;
-
-  nregs = hard_regno_nregs[regno][mode];
-  if (nregs > vd->max_value_regs)
-    vd->max_value_regs = nregs;
-}
-
-/* Initialize VD such that there are no known relationships between regs.  */
-
-static void
-init_value_data (struct value_data *vd)
-{
-  int i;
-  for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
-    {
-      vd->e[i].mode = VOIDmode;
-      vd->e[i].oldest_regno = i;
-      vd->e[i].next_regno = INVALID_REGNUM;
-    }
-  vd->max_value_regs = 0;
-}
-
-/* Called through note_stores.  If X is clobbered, kill its value.  */
-
-static void
-kill_clobbered_value (rtx x, const_rtx set, void *data)
-{
-  struct value_data *const vd = (struct value_data *) data;
-  if (GET_CODE (set) == CLOBBER)
-    kill_value (x, vd);
-}
-
-/* Called through note_stores.  If X is set, not clobbered, kill its
-   current value and install it as the root of its own value list.  */
-
-static void
-kill_set_value (rtx x, const_rtx set, void *data)
-{
-  struct value_data *const vd = (struct value_data *) data;
-  if (GET_CODE (set) != CLOBBER)
-    {
-      kill_value (x, vd);
-      if (REG_P (x))
-	set_value_regno (REGNO (x), GET_MODE (x), vd);
-    }
-}
-
-/* Called through for_each_rtx.  Kill any register used as the base of an
-   auto-increment expression, and install that register as the root of its
-   own value list.  */
-
-static int
-kill_autoinc_value (rtx *px, void *data)
-{
-  rtx x = *px;
-  struct value_data *const vd = (struct value_data *) data;
-
-  if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC)
-    {
-      x = XEXP (x, 0);
-      kill_value (x, vd);
-      set_value_regno (REGNO (x), Pmode, vd);
-      return -1;
-    }
-
-  return 0;
-}
-
-/* Assert that SRC has been copied to DEST.  Adjust the data structures
-   to reflect that SRC contains an older copy of the shared value.  */
-
-static void
-copy_value (rtx dest, rtx src, struct value_data *vd)
-{
-  unsigned int dr = REGNO (dest);
-  unsigned int sr = REGNO (src);
-  unsigned int dn, sn;
-  unsigned int i;
-
-  /* ??? At present, it's possible to see noop sets.  It'd be nice if
-     this were cleaned up beforehand...  */
-  if (sr == dr)
-    return;
-
-  /* Do not propagate copies to the stack pointer, as that can leave
-     memory accesses with no scheduling dependency on the stack update.  */
-  if (dr == STACK_POINTER_REGNUM)
-    return;
-
-  /* Likewise with the frame pointer, if we're using one.  */
-  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)];
-  if ((dr > sr && dr < sr + sn)
-      || (sr > dr && sr < dr + dn))
-    return;
-
-  /* If SRC had no assigned mode (i.e. we didn't know it was live)
-     assign it now and assume the value came from an input argument
-     or somesuch.  */
-  if (vd->e[sr].mode == VOIDmode)
-    set_value_regno (sr, vd->e[dr].mode, vd);
-
-  /* If we are narrowing the input to a smaller number of hard regs,
-     and it is in big endian, we are really extracting a high part.
-     Since we generally associate a low part of a value with the value itself,
-     we must not do the same for the high part.
-     Note we can still get low parts for the same mode combination through
-     a two-step copy involving differently sized hard regs.
-     Assume hard regs fr* are 32 bits bits each, while r* are 64 bits each:
-     (set (reg:DI r0) (reg:DI fr0))
-     (set (reg:SI fr2) (reg:SI r0))
-     loads the low part of (reg:DI fr0) - i.e. fr1 - into fr2, while:
-     (set (reg:SI fr2) (reg:SI fr0))
-     loads the high part of (reg:DI fr0) into fr2.
-
-     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]
-	   && (GET_MODE_SIZE (vd->e[sr].mode) > UNITS_PER_WORD
-	       ? WORDS_BIG_ENDIAN : BYTES_BIG_ENDIAN))
-    return;
-
-  /* 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])
-    return;
-
-  /* Link DR at the end of the value chain used by SR.  */
-
-  vd->e[dr].oldest_regno = vd->e[sr].oldest_regno;
-
-  for (i = sr; vd->e[i].next_regno != INVALID_REGNUM; i = vd->e[i].next_regno)
-    continue;
-  vd->e[i].next_regno = dr;
-
-#ifdef ENABLE_CHECKING
-  validate_value_data (vd);
-#endif
-}
-
-/* Return true if a mode change from ORIG to NEW is allowed for REGNO.  */
-
-static bool
-mode_change_ok (enum machine_mode orig_mode, enum machine_mode new_mode,
-		unsigned int regno ATTRIBUTE_UNUSED)
-{
-  if (GET_MODE_SIZE (orig_mode) < GET_MODE_SIZE (new_mode))
-    return false;
-
-#ifdef CANNOT_CHANGE_MODE_CLASS
-  return !REG_CANNOT_CHANGE_MODE_P (regno, orig_mode, new_mode);
-#endif
-
-  return true;
-}
-
-/* Register REGNO was originally set in ORIG_MODE.  It - or a copy of it -
-   was copied in COPY_MODE to COPY_REGNO, and then COPY_REGNO was accessed
-   in NEW_MODE.
-   Return a NEW_MODE rtx for REGNO if that's OK, otherwise return NULL_RTX.  */
-
-static rtx
-maybe_mode_change (enum machine_mode orig_mode, enum machine_mode copy_mode,
-		   enum machine_mode new_mode, unsigned int regno,
-		   unsigned int copy_regno ATTRIBUTE_UNUSED)
-{
-  if (GET_MODE_SIZE (copy_mode) < GET_MODE_SIZE (orig_mode)
-      && GET_MODE_SIZE (copy_mode) < GET_MODE_SIZE (new_mode))
-    return NULL_RTX;
-
-  if (orig_mode == new_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_offset
-	= GET_MODE_SIZE (copy_mode) / copy_nregs * (copy_nregs - use_nregs);
-      int offset
-	= GET_MODE_SIZE (orig_mode) - GET_MODE_SIZE (new_mode) - copy_offset;
-      int byteoffset = offset % UNITS_PER_WORD;
-      int wordoffset = offset - byteoffset;
-
-      offset = ((WORDS_BIG_ENDIAN ? wordoffset : 0)
-		+ (BYTES_BIG_ENDIAN ? byteoffset : 0));
-      return gen_rtx_raw_REG (new_mode,
-			      regno + subreg_regno_offset (regno, orig_mode,
-							   offset,
-							   new_mode));
-    }
-  return NULL_RTX;
-}
-
-/* Find the oldest copy of the value contained in REGNO that is in
-   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 cl, rtx reg, struct value_data *vd)
-{
-  unsigned int regno = REGNO (reg);
-  enum machine_mode mode = GET_MODE (reg);
-  unsigned int i;
-
-  /* If we are accessing REG in some mode other that what we set it in,
-     make sure that the replacement is valid.  In particular, consider
-	(set (reg:DI r11) (...))
-	(set (reg:SI r9) (reg:SI r11))
-	(set (reg:SI r10) (...))
-	(set (...) (reg:DI r9))
-     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])
-	return NULL_RTX;
-    }
-
-  for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
-    {
-      enum machine_mode oldmode = vd->e[i].mode;
-      rtx new_rtx;
-
-      if (!in_hard_reg_set_p (reg_class_contents[cl], mode, i))
-	return NULL_RTX;
-
-      new_rtx = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
-      if (new_rtx)
-	{
-	  ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (reg);
-	  REG_ATTRS (new_rtx) = REG_ATTRS (reg);
-	  REG_POINTER (new_rtx) = REG_POINTER (reg);
-	  return new_rtx;
-	}
-    }
-
-  return NULL_RTX;
-}
-
-/* If possible, replace the register at *LOC with the oldest register
-   in register class CL.  Return true if successfully replaced.  */
-
-static bool
-replace_oldest_value_reg (rtx *loc, enum reg_class cl, rtx insn,
-			  struct value_data *vd)
-{
-  rtx new_rtx = find_oldest_value_reg (cl, *loc, vd);
-  if (new_rtx)
-    {
-      if (dump_file)
-	fprintf (dump_file, "insn %u: replaced reg %u with %u\n",
-		 INSN_UID (insn), REGNO (*loc), REGNO (new_rtx));
-
-      validate_change (insn, loc, new_rtx, 1);
-      return true;
-    }
-  return false;
-}
-
-/* Similar to replace_oldest_value_reg, but *LOC contains an address.
-   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 cl,
-			   enum machine_mode mode, rtx insn,
-			   struct value_data *vd)
-{
-  rtx x = *loc;
-  RTX_CODE code = GET_CODE (x);
-  const char *fmt;
-  int i, j;
-  bool changed = false;
-
-  switch (code)
-    {
-    case PLUS:
-      {
-	rtx orig_op0 = XEXP (x, 0);
-	rtx orig_op1 = XEXP (x, 1);
-	RTX_CODE code0 = GET_CODE (orig_op0);
-	RTX_CODE code1 = GET_CODE (orig_op1);
-	rtx op0 = orig_op0;
-	rtx op1 = orig_op1;
-	rtx *locI = NULL;
-	rtx *locB = NULL;
-	enum rtx_code index_code = SCRATCH;
-
-	if (GET_CODE (op0) == SUBREG)
-	  {
-	    op0 = SUBREG_REG (op0);
-	    code0 = GET_CODE (op0);
-	  }
-
-	if (GET_CODE (op1) == SUBREG)
-	  {
-	    op1 = SUBREG_REG (op1);
-	    code1 = GET_CODE (op1);
-	  }
-
-	if (code0 == MULT || code0 == SIGN_EXTEND || code0 == TRUNCATE
-	    || code0 == ZERO_EXTEND || code1 == MEM)
-	  {
-	    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);
-	    index_code = GET_CODE (XEXP (x, 0));
-	  }
-	else if (code1 == CONST_INT || code1 == CONST
-		 || code1 == SYMBOL_REF || code1 == LABEL_REF)
-	  {
-	    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 (REGNO_OK_FOR_INDEX_P (regno1)
-		&& regno_ok_for_base_p (regno0, mode, PLUS, REG))
-	      index_op = 1;
-	    else if (REGNO_OK_FOR_INDEX_P (regno0)
-		     && regno_ok_for_base_p (regno1, mode, PLUS, REG))
-	      index_op = 0;
-	    else if (regno_ok_for_base_p (regno0, mode, PLUS, REG)
-		     || REGNO_OK_FOR_INDEX_P (regno1))
-	      index_op = 1;
-	    else if (regno_ok_for_base_p (regno1, mode, PLUS, REG))
-	      index_op = 0;
-	    else
-	      index_op = 1;
-
-	    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)
-	  changed |= replace_oldest_value_addr (locI, INDEX_REG_CLASS, mode,
-						insn, vd);
-	if (locB)
-	  changed |= replace_oldest_value_addr (locB,
-						base_reg_class (mode, PLUS,
-								index_code),
-						mode, insn, vd);
-	return changed;
-      }
-
-    case POST_INC:
-    case POST_DEC:
-    case POST_MODIFY:
-    case PRE_INC:
-    case PRE_DEC:
-    case PRE_MODIFY:
-      return false;
-
-    case MEM:
-      return replace_oldest_value_mem (x, insn, vd);
-
-    case REG:
-      return replace_oldest_value_reg (loc, cl, insn, vd);
-
-    default:
-      break;
-    }
-
-  fmt = GET_RTX_FORMAT (code);
-  for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
-    {
-      if (fmt[i] == 'e')
-	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), cl,
-						mode, insn, vd);
-    }
-
-  return changed;
-}
-
-/* Similar to replace_oldest_value_reg, but X contains a memory.  */
-
-static bool
-replace_oldest_value_mem (rtx x, rtx insn, struct value_data *vd)
-{
-  return replace_oldest_value_addr (&XEXP (x, 0),
-				    base_reg_class (GET_MODE (x), MEM,
-						    SCRATCH),
-				    GET_MODE (x), insn, vd);
-}
-
-/* Perform the forward copy propagation on basic block BB.  */
-
-static bool
-copyprop_hardreg_forward_1 (basic_block bb, struct value_data *vd)
-{
-  bool changed = false;
-  rtx insn;
-
-  for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
-    {
-      int n_ops, i, alt, predicated;
-      bool is_asm, any_replacements;
-      rtx set;
-      bool replaced[MAX_RECOG_OPERANDS];
-
-      if (! INSN_P (insn))
-	{
-	  if (insn == BB_END (bb))
-	    break;
-	  else
-	    continue;
-	}
-
-      set = single_set (insn);
-      extract_insn (insn);
-      if (! constrain_operands (1))
-	fatal_insn_not_found (insn);
-      preprocess_constraints ();
-      alt = which_alternative;
-      n_ops = recog_data.n_operands;
-      is_asm = asm_noperands (PATTERN (insn)) >= 0;
-
-      /* Simplify the code below by rewriting things to reflect
-	 matching constraints.  Also promote OP_OUT to OP_INOUT
-	 in predicated instructions.  */
-
-      predicated = GET_CODE (PATTERN (insn)) == COND_EXEC;
-      for (i = 0; i < n_ops; ++i)
-	{
-	  int matches = recog_op_alt[i][alt].matches;
-	  if (matches >= 0)
-	    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;
-	}
-
-      /* For each earlyclobber operand, zap the value data.  */
-      for (i = 0; i < n_ops; i++)
-	if (recog_op_alt[i][alt].earlyclobber)
-	  kill_value (recog_data.operand[i], vd);
-
-      /* Within asms, a clobber cannot overlap inputs or outputs.
-	 I wouldn't think this were true for regular insns, but
-	 scan_rtx treats them like that...  */
-      note_stores (PATTERN (insn), kill_clobbered_value, vd);
-
-      /* Kill all auto-incremented values.  */
-      /* ??? REG_INC is useless, since stack pushes aren't done that way.  */
-      for_each_rtx (&PATTERN (insn), kill_autoinc_value, vd);
-
-      /* Kill all early-clobbered operands.  */
-      for (i = 0; i < n_ops; i++)
-	if (recog_op_alt[i][alt].earlyclobber)
-	  kill_value (recog_data.operand[i], vd);
-
-      /* Special-case plain move instructions, since we may well
-	 be able to do the move from a different register class.  */
-      if (set && REG_P (SET_SRC (set)))
-	{
-	  rtx src = SET_SRC (set);
-	  unsigned int regno = REGNO (src);
-	  enum machine_mode mode = GET_MODE (src);
-	  unsigned int i;
-	  rtx new_rtx;
-
-	  /* If we are accessing SRC in some mode other that what we
-	     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])
-		goto no_move_special_case;
-	    }
-
-	  /* If the destination is also a register, try to find a source
-	     register in the same class.  */
-	  if (REG_P (SET_DEST (set)))
-	    {
-	      new_rtx = find_oldest_value_reg (REGNO_REG_CLASS (regno), src, vd);
-	      if (new_rtx && validate_change (insn, &SET_SRC (set), new_rtx, 0))
-		{
-		  if (dump_file)
-		    fprintf (dump_file,
-			     "insn %u: replaced reg %u with %u\n",
-			     INSN_UID (insn), regno, REGNO (new_rtx));
-		  changed = true;
-		  goto did_replacement;
-		}
-	    }
-
-	  /* Otherwise, try all valid registers and see if its valid.  */
-	  for (i = vd->e[regno].oldest_regno; i != regno;
-	       i = vd->e[i].next_regno)
-	    {
-	      new_rtx = maybe_mode_change (vd->e[i].mode, vd->e[regno].mode,
-				       mode, i, regno);
-	      if (new_rtx != NULL_RTX)
-		{
-		  if (validate_change (insn, &SET_SRC (set), new_rtx, 0))
-		    {
-		      ORIGINAL_REGNO (new_rtx) = ORIGINAL_REGNO (src);
-		      REG_ATTRS (new_rtx) = REG_ATTRS (src);
-		      REG_POINTER (new_rtx) = REG_POINTER (src);
-		      if (dump_file)
-			fprintf (dump_file,
-				 "insn %u: replaced reg %u with %u\n",
-				 INSN_UID (insn), regno, REGNO (new_rtx));
-		      changed = true;
-		      goto did_replacement;
-		    }
-		}
-	    }
-	}
-      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++)
-	{
-	  replaced[i] = false;
-
-	  /* Don't scan match_operand here, since we've no reg class
-	     information to pass down.  Any operands that we could
-	     substitute in will be represented elsewhere.  */
-	  if (recog_data.constraints[i][0] == '\0')
-	    continue;
-
-	  /* Don't replace in asms intentionally referencing hard regs.  */
-	  if (is_asm && REG_P (recog_data.operand[i])
-	      && (REGNO (recog_data.operand[i])
-		  == ORIGINAL_REGNO (recog_data.operand[i])))
-	    continue;
-
-	  if (recog_data.operand_type[i] == OP_IN)
-	    {
-	      if (recog_op_alt[i][alt].is_address)
-		replaced[i]
-		  = replace_oldest_value_addr (recog_data.operand_loc[i],
-					       recog_op_alt[i][alt].cl,
-					       VOIDmode, insn, vd);
-	      else if (REG_P (recog_data.operand[i]))
-		replaced[i]
-		  = replace_oldest_value_reg (recog_data.operand_loc[i],
-					      recog_op_alt[i][alt].cl,
-					      insn, vd);
-	      else if (MEM_P (recog_data.operand[i]))
-		replaced[i] = 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[i])
-	    {
-	      int j;
-	      rtx new_rtx;
-
-	      new_rtx = *recog_data.operand_loc[i];
-	      recog_data.operand[i] = new_rtx;
-	      for (j = 0; j < recog_data.n_dups; j++)
-		if (recog_data.dup_num[j] == i)
-		  validate_unshare_change (insn, recog_data.dup_loc[j], new_rtx, 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 (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, 1, vd);
-
-      /* Notice stores.  */
-      note_stores (PATTERN (insn), kill_set_value, vd);
-
-      /* Notice copies.  */
-      if (set && REG_P (SET_DEST (set)) && REG_P (SET_SRC (set)))
-	copy_value (SET_DEST (set), SET_SRC (set), vd);
-
-      if (insn == BB_END (bb))
-	break;
-    }
-
-  return changed;
-}
-
-/* Main entry point for the forward copy propagation optimization.  */
-
-static void
-copyprop_hardreg_forward (void)
-{
-  struct value_data *all_vd;
-  basic_block bb;
-  sbitmap visited;
-
-  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 (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);
-
-      copyprop_hardreg_forward_1 (bb, all_vd + bb->index);
-    }
-
-  sbitmap_free (visited);  
-  free (all_vd);
-}
-
-/* Dump the value chain data to stderr.  */
-
-void
-debug_value_data (struct value_data *vd)
-{
-  HARD_REG_SET set;
-  unsigned int i, j;
-
-  CLEAR_HARD_REG_SET (set);
-
-  for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
-    if (vd->e[i].oldest_regno == i)
-      {
-	if (vd->e[i].mode == VOIDmode)
-	  {
-	    if (vd->e[i].next_regno != INVALID_REGNUM)
-	      fprintf (stderr, "[%u] Bad next_regno for empty chain (%u)\n",
-		       i, vd->e[i].next_regno);
-	    continue;
-	  }
-
-	SET_HARD_REG_BIT (set, i);
-	fprintf (stderr, "[%u %s] ", i, GET_MODE_NAME (vd->e[i].mode));
-
-	for (j = vd->e[i].next_regno;
-	     j != INVALID_REGNUM;
-	     j = vd->e[j].next_regno)
-	  {
-	    if (TEST_HARD_REG_BIT (set, j))
-	      {
-		fprintf (stderr, "[%u] Loop in regno chain\n", j);
-		return;
-	      }
-
-	    if (vd->e[j].oldest_regno != i)
-	      {
-		fprintf (stderr, "[%u] Bad oldest_regno (%u)\n",
-			 j, vd->e[j].oldest_regno);
-		return;
-	      }
-	    SET_HARD_REG_BIT (set, j);
-	    fprintf (stderr, "[%u %s] ", j, GET_MODE_NAME (vd->e[j].mode));
-	  }
-	fputc ('\n', stderr);
-      }
-
-  for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
-    if (! TEST_HARD_REG_BIT (set, i)
-	&& (vd->e[i].mode != VOIDmode
-	    || vd->e[i].oldest_regno != i
-	    || vd->e[i].next_regno != INVALID_REGNUM))
-      fprintf (stderr, "[%u] Non-empty reg in chain (%s %u %i)\n",
-	       i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
-	       vd->e[i].next_regno);
-}
-
-#ifdef ENABLE_CHECKING
-static void
-validate_value_data (struct value_data *vd)
-{
-  HARD_REG_SET set;
-  unsigned int i, j;
-
-  CLEAR_HARD_REG_SET (set);
-
-  for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
-    if (vd->e[i].oldest_regno == i)
-      {
-	if (vd->e[i].mode == VOIDmode)
-	  {
-	    if (vd->e[i].next_regno != INVALID_REGNUM)
-	      internal_error ("validate_value_data: [%u] Bad next_regno for empty chain (%u)",
-			      i, vd->e[i].next_regno);
-	    continue;
-	  }
-
-	SET_HARD_REG_BIT (set, i);
-
-	for (j = vd->e[i].next_regno;
-	     j != INVALID_REGNUM;
-	     j = vd->e[j].next_regno)
-	  {
-	    if (TEST_HARD_REG_BIT (set, j))
-	      internal_error ("validate_value_data: Loop in regno chain (%u)",
-			      j);
-	    if (vd->e[j].oldest_regno != i)
-	      internal_error ("validate_value_data: [%u] Bad oldest_regno (%u)",
-			      j, vd->e[j].oldest_regno);
-
-	    SET_HARD_REG_BIT (set, j);
-	  }
-      }
-
-  for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
-    if (! TEST_HARD_REG_BIT (set, i)
-	&& (vd->e[i].mode != VOIDmode
-	    || vd->e[i].oldest_regno != i
-	    || vd->e[i].next_regno != INVALID_REGNUM))
-      internal_error ("validate_value_data: [%u] Non-empty reg in chain (%s %u %i)",
-		      i, GET_MODE_NAME (vd->e[i].mode), vd->e[i].oldest_regno,
-		      vd->e[i].next_regno);
-}
-#endif
 
 static bool
 gate_handle_regrename (void)
@@ -1943,22 +1009,13 @@ gate_handle_regrename (void)
   return (optimize > 0 && (flag_rename_registers));
 }
 
-
-/* Run the regrename and cprop passes.  */
-static unsigned int
-rest_of_handle_regrename (void)
-{
-  regrename_optimize ();
-  return 0;
-}
-
 struct rtl_opt_pass pass_regrename =
 {
  {
   RTL_PASS,
   "rnreg",                              /* name */
   gate_handle_regrename,                /* gate */
-  rest_of_handle_regrename,             /* execute */
+  regrename_optimize,                   /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
@@ -1972,36 +1029,3 @@ struct rtl_opt_pass pass_regrename =
  }
 };
 
-static bool
-gate_handle_cprop (void)
-{
-  return (optimize > 0 && (flag_cprop_registers));
-}
-
-
-/* Run the regrename and cprop passes.  */
-static unsigned int
-rest_of_handle_cprop (void)
-{
-  copyprop_hardreg_forward ();
-  return 0;
-}
-
-struct rtl_opt_pass pass_cprop_hardreg =
-{
- {
-  RTL_PASS,
-  "cprop_hardreg",                      /* name */
-  gate_handle_cprop,                    /* gate */
-  rest_of_handle_cprop,                 /* 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_verify_rtl_sharing /* todo_flags_finish */
- }
-};