This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

post-reload register copy-propagation


The following pass cleans up a lot of gunk left over from reload
insertting too many copies, and post-reload splitters which created
some of the problem in the first place by not describing to the
register allocator what was going on.

I once had some really nice examples of how this can clean up x86
long long operations, but I seem to have misplaced them.

A trivial example from Alpha is

	int f(int x) { x += x; return x; }

-       bis $31,$16,$0
-       addq $0,$0,$0
+       addq $16,$16,$0
        addl $0,$31,$0

Anyway, bootstrapped on alphaev6, i686 and ia64 linux.


r~


        * regrename.c (copyprop_hardreg_forward): New optimization.
        (kill_value_regno, kill_value, init_value_data, kill_clobbered_value,
        kill_set_value, kill_autoinc_value, copy_value, 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): New.
        * rtl.h (copyprop_hardreg_forward): Declare.
        * toplev.c (flag_cprop_registers): New.
        (f_options): Add -fcprop-registers
        (rest_of_compilation): Invoke it.
        (parse_options_and_default_flags): Set it at -O1.
        * doc/invoke.texi: Document it.

Index: regrename.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/regrename.c,v
retrieving revision 1.25
diff -c -p -d -r1.25 regrename.c
*** regrename.c	2001/09/29 21:52:11	1.25
--- regrename.c	2001/12/12 22:44:38
***************
*** 33,38 ****
--- 33,39 ----
  #include "function.h"
  #include "recog.h"
  #include "flags.h"
+ #include "toplev.h"
  #include "obstack.h"
  
  #define obstack_chunk_alloc xmalloc
*************** dump_def_use_chain (chains)
*** 960,962 ****
--- 961,1702 ----
        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];
+ };
+ 
+ static void kill_value_regno PARAMS ((unsigned, struct value_data *));
+ static void kill_value PARAMS ((rtx, struct value_data *));
+ static void init_value_data PARAMS ((struct value_data *));
+ static void kill_clobbered_value PARAMS ((rtx, rtx, void *));
+ static void kill_set_value PARAMS ((rtx, rtx, void *));
+ static int kill_autoinc_value PARAMS ((rtx *, void *));
+ static void copy_value PARAMS ((rtx, rtx, struct value_data *));
+ static rtx find_oldest_value_reg PARAMS ((enum reg_class, unsigned int,
+ 					    enum machine_mode,
+ 					    struct value_data *));
+ static bool replace_oldest_value_reg PARAMS ((rtx *, enum reg_class, rtx,
+ 					      struct value_data *));
+ static bool replace_oldest_value_addr PARAMS ((rtx *, enum reg_class,
+ 					       enum machine_mode, rtx,
+ 					       struct value_data *));
+ static bool replace_oldest_value_mem PARAMS ((rtx, rtx, struct value_data *));
+ static bool copyprop_hardreg_forward_1 PARAMS ((basic_block,
+ 						 struct value_data *));
+ extern void debug_value_data PARAMS ((struct value_data *));
+ #ifdef ENABLE_CHECKING
+ static void validate_value_data PARAMS ((struct value_data *));
+ #endif
+ 
+ /* Kill register REGNO.  This involves removing it from any value lists,
+    and resetting the value mode to VOIDmode.  */
+ 
+ static void
+ kill_value_regno (regno, vd)
+      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;
+ 
+       next = vd->e[regno].next_regno;
+       while (1)
+ 	{
+ 	  vd->e[i].next_regno = next;
+ 	  if (next == INVALID_REGNUM)
+ 	    break;
+ 	  i = next;
+ 	  next = vd->e[next].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 X.  This is a convenience function for kill_value_regno
+    so that we don't have to check that X is a register first.  */
+ 
+ static void
+ kill_value (x, vd)
+      rtx x;
+      struct value_data *vd;
+ {
+   if (REG_P (x))
+     kill_value_regno (REGNO (x), vd);
+ }
+ 
+ /* Initialize VD such that there are no known relationships between regs.  */
+ 
+ static void
+ init_value_data (vd)
+      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;
+     }
+ }
+ 
+ /* Called through note_stores.  If X is clobbered, kill its value.  */
+ 
+ static void
+ kill_clobbered_value (x, set, data)
+      rtx x;
+      rtx set;
+      void *data;
+ {
+   struct value_data *vd = 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 (x, set, data)
+      rtx x;
+      rtx set;
+      void *data;
+ {
+   struct value_data *vd = data;
+   if (GET_CODE (set) != CLOBBER && REG_P (x))
+     {
+       unsigned int regno = REGNO (x);
+       kill_value_regno (regno, vd);
+       vd->e[regno].mode = GET_MODE (x);
+     }
+ }
+ 
+ /* 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 (px, data)
+      rtx *px;
+      void *data;
+ {
+   rtx x = *px;
+   struct value_data *vd = data;
+ 
+   if (GET_RTX_CLASS (GET_CODE (x)) == 'a')
+     {
+       unsigned int regno = REGNO (XEXP (x, 0));
+       kill_value_regno (regno, vd);
+       vd->e[regno].mode = Pmode;
+       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 (dest, src, vd)
+      rtx dest;
+      rtx src;
+      struct value_data *vd;
+ {
+   unsigned int dr = REGNO (dest);
+   unsigned int sr = REGNO (src);
+   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 dependancy 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;
+ 
+   /* 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)
+     vd->e[sr].mode = vd->e[dr].mode;
+ 
+   /* 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
+ }
+ 
+ /* 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
+    of that oldest register, otherwise return NULL.  */
+ 
+ static rtx
+ find_oldest_value_reg (class, regno, mode, vd)
+      enum reg_class class;
+      unsigned int regno;
+      enum machine_mode mode;
+      struct value_data *vd;
+ {
+   unsigned int i;
+ 
+   for (i = vd->e[regno].oldest_regno; i != regno; i = vd->e[i].next_regno)
+     if (vd->e[i].mode == mode
+ 	&& TEST_HARD_REG_BIT (reg_class_contents[class], i))
+       return gen_rtx_REG (mode, i);
+ 
+   return NULL_RTX;
+ }
+ 
+ /* If possible, replace the register at *LOC with the oldest register
+    in register class CLASS.  Return true if successfully replaced.  */
+ 
+ static bool
+ replace_oldest_value_reg (loc, class, insn, vd)
+      rtx *loc;
+      enum reg_class class;
+      rtx insn;
+      struct value_data *vd;
+ {
+   rtx new = find_oldest_value_reg (class, REGNO (*loc), GET_MODE (*loc), vd);
+   if (new)
+     {
+       if (rtl_dump_file)
+ 	fprintf (rtl_dump_file, "insn %u: replaced reg %u with %u\n",
+ 		 INSN_UID (insn), REGNO (*loc), REGNO (new));
+ 
+       *loc = new;
+       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
+    BASE_REG_CLASS depending on how the register is being considered.  */
+ 
+ static bool
+ replace_oldest_value_addr (loc, class, mode, insn, vd)
+      rtx *loc;
+      enum reg_class class;
+      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;
+ 
+ 	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);
+ 	  }
+ 	else if (code1 == MULT || code1 == SIGN_EXTEND || code1 == TRUNCATE
+ 		 || code1 == ZERO_EXTEND || code0 == MEM)
+ 	  {
+ 	    locI = &XEXP (x, 1);
+ 	    locB = &XEXP (x, 0);
+ 	  }
+ 	else if (code0 == CONST_INT || code0 == CONST
+ 		 || code0 == SYMBOL_REF || code0 == LABEL_REF)
+ 	  locB = &XEXP (x, 1);
+ 	else if (code1 == CONST_INT || code1 == CONST
+ 		 || code1 == SYMBOL_REF || code1 == LABEL_REF)
+ 	  locB = &XEXP (x, 0);
+ 	else if (code0 == REG && code1 == REG)
+ 	  {
+ 	    int index_op;
+ 
+ 	    if (REG_OK_FOR_INDEX_P (op0)
+ 		&& REG_MODE_OK_FOR_BASE_P (op1, mode))
+ 	      index_op = 0;
+ 	    else if (REG_OK_FOR_INDEX_P (op1)
+ 		     && REG_MODE_OK_FOR_BASE_P (op0, mode))
+ 	      index_op = 1;
+ 	    else if (REG_MODE_OK_FOR_BASE_P (op1, mode))
+ 	      index_op = 0;
+ 	    else if (REG_MODE_OK_FOR_BASE_P (op0, mode))
+ 	      index_op = 1;
+ 	    else if (REG_OK_FOR_INDEX_P (op1))
+ 	      index_op = 1;
+ 	    else
+ 	      index_op = 0;
+ 
+ 	    locI = &XEXP (x, index_op);
+ 	    locB = &XEXP (x, !index_op);
+ 	  }
+ 	else if (code0 == REG)
+ 	  {
+ 	    locI = &XEXP (x, 0);
+ 	    locB = &XEXP (x, 1);
+ 	  }
+ 	else if (code1 == REG)
+ 	  {
+ 	    locI = &XEXP (x, 1);
+ 	    locB = &XEXP (x, 0);
+ 	  }
+ 
+ 	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,
+ 					        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, class, 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), class, 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,
+ 					        mode, insn, vd);
+     }
+ 
+   return changed;
+ }
+ 
+ /* Similar to replace_oldest_value_reg, but X contains a memory.  */
+ 
+ static bool
+ replace_oldest_value_mem (x, insn, vd)
+      rtx x;
+      rtx insn;
+      struct value_data *vd;
+ {
+   return replace_oldest_value_addr (&XEXP (x, 0), BASE_REG_CLASS,
+ 				    GET_MODE (x), insn, vd);
+ }
+ 
+ /* Perform the forward copy propagation on basic block BB.  */
+ 
+ static bool
+ copyprop_hardreg_forward_1 (bb, vd)
+      basic_block bb;
+      struct value_data *vd;
+ {
+   bool changed = false;
+   rtx insn;
+ 
+   for (insn = bb->head; ; insn = NEXT_INSN (insn))
+     {
+       int n_ops, i, alt, predicated;
+       rtx set;
+ 
+       if (! INSN_P (insn))
+ 	{
+ 	  if (insn == bb->end)
+ 	    break;
+ 	  else
+ 	    continue;
+ 	}
+ 
+       set = single_set (insn);
+       extract_insn (insn);
+       constrain_operands (1);
+       preprocess_constraints ();
+       alt = which_alternative;
+       n_ops = recog_data.n_operands;
+ 
+       /* 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].class = recog_op_alt[matches][alt].class;
+ 	  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);
+ 
+       /* 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)))
+ 	{
+ 	  unsigned int regno = REGNO (SET_SRC (set));
+ 	  enum machine_mode mode = GET_MODE (SET_SRC (set));
+ 	  unsigned int i;
+ 	  rtx new;
+ 
+ 	  /* If the destination is also a register, try to find a source
+ 	     register in the same class.  */
+ 	  if (REG_P (SET_DEST (set)))
+ 	    {
+ 	      new = find_oldest_value_reg (REGNO_REG_CLASS (regno),
+ 					   regno, mode, vd);
+ 	      if (new && validate_change (insn, &SET_SRC (set), new, 0))
+ 		{
+ 		  if (rtl_dump_file)
+ 		    fprintf (rtl_dump_file,
+ 			     "insn %u: replaced reg %u with %u\n",
+ 			     INSN_UID (insn), regno, REGNO (new));
+ 	          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)
+ 	    if (mode == vd->e[regno].mode)
+ 	      {
+ 		new = gen_rtx_REG (mode, i);
+ 		if (validate_change (insn, &SET_SRC (set), new, 0))
+ 		  {
+ 		    if (rtl_dump_file)
+ 		      fprintf (rtl_dump_file,
+ 			       "insn %u: replaced reg %u with %u\n",
+ 			       INSN_UID (insn), regno, REGNO (new));
+ 		    changed = true;
+ 		    goto did_replacement;
+ 		  }
+ 	      }
+ 	}
+ 
+       /* 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;
+ 
+ 	  /* 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;
+ 
+ 	  if (recog_data.operand_type[i] == OP_IN)
+ 	    {
+ 	      if (recog_op_alt[i][alt].is_address)
+ 		replaced
+ 		  = replace_oldest_value_addr (recog_data.operand_loc[i],
+ 					       recog_op_alt[i][alt].class,
+ 					       VOIDmode, insn, vd);
+ 	      else if (REG_P (recog_data.operand[i]))
+ 		replaced
+ 		  = replace_oldest_value_reg (recog_data.operand_loc[i],
+ 					      recog_op_alt[i][alt].class,
+ 					      insn, vd);
+ 	      else if (GET_CODE (recog_data.operand[i]) == MEM)
+ 		replaced = 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);
+ 
+ 	  /* If we performed any replacement, update match_dups.  */
+ 	  if (replaced)
+ 	    {
+ 	      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;
+ 	    }
+ 	}
+ 
+     did_replacement:
+       /* Clobber call-clobbered registers.  */
+       if (GET_CODE (insn) == CALL_INSN)
+ 	for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
+ 	  if (TEST_HARD_REG_BIT (regs_invalidated_by_call, i))
+ 	    kill_value_regno (i, 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)
+ 	break;
+     }
+ 
+   return changed;
+ }
+ 
+ /* Main entry point for the forward copy propagation optimization.  */
+ 
+ void
+ copyprop_hardreg_forward ()
+ {
+   int b, need_refresh;
+   sbitmap refresh_blocks;
+   struct value_data *all_vd;
+ 
+   refresh_blocks = sbitmap_alloc (n_basic_blocks);
+   sbitmap_zero (refresh_blocks);
+   need_refresh = 0;
+ 
+   all_vd = xmalloc (sizeof (struct value_data) * n_basic_blocks);
+ 
+   for (b = 0; b < n_basic_blocks; b++)
+     {
+       basic_block bb = BASIC_BLOCK (b);
+ 
+       /* 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 queueing of blocks.  */
+       if (bb->pred
+ 	  && ! bb->pred->pred_next 
+ 	  && bb->pred->src->index != ENTRY_BLOCK
+ 	  && bb->pred->src->index < b)
+ 	all_vd[b] = all_vd[bb->pred->src->index];
+       else
+         init_value_data (all_vd + b);
+ 
+       if (copyprop_hardreg_forward_1 (bb, all_vd + b))
+ 	{
+ 	  SET_BIT (refresh_blocks, b);
+ 	  need_refresh = 1;
+ 	}
+     }
+ 
+   if (need_refresh)
+     {
+       if (rtl_dump_file)
+ 	fputs ("\n\n", rtl_dump_file);
+ 
+       update_life_info (refresh_blocks, UPDATE_LIFE_GLOBAL_RM_NOTES,
+ 			PROP_DEATH_NOTES
+ 			| PROP_SCAN_DEAD_CODE
+ 			| PROP_KILL_DEAD_CODE);
+     }
+ 
+   sbitmap_free (refresh_blocks);
+   free (all_vd);
+ }
+ 
+ /* Dump the value chain data to stderr.  */
+ 
+ void
+ debug_value_data (vd)
+      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, vd->e[j].next_regno))
+ 	      {
+ 		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 (vd)
+      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
Index: rtl.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.h,v
retrieving revision 1.318
diff -c -p -d -r1.318 rtl.h
*** rtl.h	2001/12/07 16:10:03	1.318
--- rtl.h	2001/12/12 22:44:38
*************** extern rtx stack_limit_rtx;
*** 2097,2102 ****
--- 2097,2103 ----
  
  /* In regrename.c */
  extern void regrename_optimize		PARAMS ((void));
+ extern void copyprop_hardreg_forward	PARAMS ((void));
  
  /* In ifcvt.c */
  extern void if_convert			PARAMS ((int));
Index: toplev.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/toplev.c,v
retrieving revision 1.554
diff -c -p -d -r1.554 toplev.c
*** toplev.c	2001/12/06 11:49:10	1.554
--- toplev.c	2001/12/12 22:44:38
*************** int flag_reorder_blocks = 0;
*** 427,432 ****
--- 427,433 ----
  /* Nonzero if registers should be renamed.  */
  
  int flag_rename_registers = 0;
+ int flag_cprop_registers = 0;
  
  /* Nonzero for -pedantic switch: warn about anything
     that standard spec forbids.  */
*************** lang_independent_options f_options[] =
*** 1083,1088 ****
--- 1084,1091 ----
     N_("Reorder basic blocks to improve code placement") },
    {"rename-registers", &flag_rename_registers, 1,
     N_("Do the register renaming optimization pass") },
+   {"cprop-registers", &flag_cprop_registers, 1,
+    N_("Do the register copy-propagation optimization pass") },
    {"common", &flag_no_common, 0,
     N_("Do not put uninitialized globals in the common section") },
    {"inhibit-size-directive", &flag_inhibit_size_directive, 1,
*************** rest_of_compilation (decl)
*** 3280,3291 ****
      }
  #endif
  
!   if (optimize > 0 && flag_rename_registers)
      {
        timevar_push (TV_RENAME_REGISTERS);
        open_dump_file (DFI_rnreg, decl);
  
!       regrename_optimize ();
  
        close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
        timevar_pop (TV_RENAME_REGISTERS);
--- 3283,3297 ----
      }
  #endif
  
!   if (flag_rename_registers || flag_cprop_registers)
      {
        timevar_push (TV_RENAME_REGISTERS);
        open_dump_file (DFI_rnreg, decl);
  
!       if (flag_rename_registers)
!         regrename_optimize ();
!       if (flag_cprop_registers)
!         copyprop_hardreg_forward ();
  
        close_dump_file (DFI_rnreg, print_rtl_with_bb, insns);
        timevar_pop (TV_RENAME_REGISTERS);
*************** parse_options_and_default_flags (argc, a
*** 4620,4625 ****
--- 4626,4632 ----
        flag_omit_frame_pointer = 1;
  #endif
        flag_guess_branch_prob = 1;
+       flag_cprop_registers = 1;
      }
  
    if (optimize >= 2)
Index: doc/invoke.texi
===================================================================
RCS file: /cvs/gcc/gcc/gcc/doc/invoke.texi,v
retrieving revision 1.88
diff -c -p -d -r1.88 invoke.texi
*** invoke.texi	2001/12/10 03:27:49	1.88
--- invoke.texi	2001/12/12 22:44:38
*************** in the following sections.
*** 259,265 ****
  @gccoptlist{
  -falign-functions=@var{n}  -falign-jumps=@var{n} @gol
  -falign-labels=@var{n}  -falign-loops=@var{n}  @gol
! -fbranch-probabilities  -fcaller-saves @gol
  -fcse-follow-jumps  -fcse-skip-blocks  -fdata-sections @gol
  -fdelayed-branch  -fdelete-null-pointer-checks @gol
  -fexpensive-optimizations  -ffast-math  -ffloat-store @gol
--- 259,265 ----
  @gccoptlist{
  -falign-functions=@var{n}  -falign-jumps=@var{n} @gol
  -falign-labels=@var{n}  -falign-loops=@var{n}  @gol
! -fbranch-probabilities  -fcaller-saves -fcprop-registers @gol
  -fcse-follow-jumps  -fcse-skip-blocks  -fdata-sections @gol
  -fdelayed-branch  -fdelete-null-pointer-checks @gol
  -fexpensive-optimizations  -ffast-math  -ffloat-store @gol
*************** of registers left over after register al
*** 3773,3778 ****
--- 3773,3784 ----
  will most benefit processors with lots of registers.  It can, however,
  make debugging impossible, since variables will no longer stay in
  a ``home register''.
+ 
+ @item -fno-cprop-registers
+ @opindex fno-cprop-registers
+ After register allocation and post-register allocation instruction splitting,
+ we perform a copy-propagation pass to try to reduce scheduling dependencies
+ and occasionally eliminate the copy.
  
  @item --param @var{name}=@var{value}
  @opindex param


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]