[PATCH][big but trivial] move regcprop to its own file
Richard Guenther
richard.guenther@gmail.com
Thu May 7 14:33:00 GMT 2009
On Thu, May 7, 2009 at 3:36 PM, Paolo Bonzini <bonzini@gnu.org> wrote:
> I would like to rewrite regrename sooner or later, and one small step is
> to separate the two passes in regrename.c.
>
> The patch was generated after "svn cp", so it only shows deleting
> regcprop in regrename.c and deleting regrename in regcprop.c.
>
> Bootstrapped i686-pc-linux-gnu (stage2 so far), will regtest before
> committing.
Ok.
Thanks,
Richard.
> Paolo
>
> 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.
>
> Index: Makefile.in
> ===================================================================
> --- Makefile.in (revision 147147)
> +++ Makefile.in (working copy)
> @@ -1174,6 +1174,7 @@ OBJS-common = \
> real.o \
> recog.o \
> reg-stack.o \
> + regcprop.o \
> reginfo.o \
> regmove.o \
> regrename.o \
> @@ -3050,6 +3051,10 @@ cfglayout.o : cfglayout.c $(CONFIG_H) $(
> $(DF_H)
> timevar.o : timevar.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
> $(TIMEVAR_H) $(FLAGS_H) intl.h $(TOPLEV_H) $(RTL_H) timevar.def
> +regcprop.o : regcprop.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
> + $(RTL_H) insn-config.h $(BASIC_BLOCK_H) $(REGS_H) hard-reg-set.h \
> + output.h $(RECOG_H) $(FUNCTION_H) $(OBSTACK_H) $(FLAGS_H) $(TM_P_H) \
> + addresses.h reload.h $(TOPLEV_H) $(TIMEVAR_H) $(TREE_PASS_H) $(DF_H)
> regrename.o : regrename.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) \
> $(RTL_H) insn-config.h $(BASIC_BLOCK_H) $(REGS_H) hard-reg-set.h \
> output.h $(RECOG_H) $(FUNCTION_H) $(OBSTACK_H) $(FLAGS_H) $(TM_P_H) \
> Index: timevar.def
> ===================================================================
> --- timevar.def (revision 147147)
> +++ timevar.def (working copy)
> @@ -182,6 +182,7 @@ DEFTIMEVAR (TV_THREAD_PROLOGUE_AND_EPILO
> DEFTIMEVAR (TV_IFCVT2 , "if-conversion 2")
> DEFTIMEVAR (TV_PEEPHOLE2 , "peephole 2")
> DEFTIMEVAR (TV_RENAME_REGISTERS , "rename registers")
> +DEFTIMEVAR (TV_CPROP_REGISTERS , "hard reg cprop")
> DEFTIMEVAR (TV_SCHED2 , "scheduling 2")
> DEFTIMEVAR (TV_MACH_DEP , "machine dep reorg")
> DEFTIMEVAR (TV_DBR_SCHED , "delay branch sched")
> Index: regrename.c
> ===================================================================
> --- regrename.c (revision 147147)
> +++ regrename.c (working copy)
> @@ -180,7 +180,7 @@ merge_overlapping_regs (basic_block b, H
>
> /* 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 *cha
> 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 */
> - }
> -};
> Index: regcprop.c
> ===================================================================
> --- regcprop.c (revision 147147)
> +++ regcprop.c (working copy)
> @@ -1,4 +1,4 @@
> -/* Register renaming for the GNU compiler.
> +/* Copy propagation on hard registers for the GNU compiler.
> Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
> Free Software Foundation, Inc.
>
> @@ -40,966 +40,6 @@
> #include "tree-pass.h"
> #include "df.h"
>
> -struct du_chain
> -{
> - struct du_chain *next_chain;
> - struct du_chain *next_use;
> -
> - rtx insn;
> - rtx *loc;
> - ENUM_BITFIELD(reg_class) cl : 16;
> - unsigned int need_caller_save_reg:1;
> - unsigned int earlyclobber:1;
> -};
> -
> -enum scan_actions
> -{
> - terminate_all_read,
> - terminate_overlapping_read,
> - terminate_write,
> - terminate_dead,
> - mark_read,
> - 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[] =
> -{
> - "terminate_all_read",
> - "terminate_overlapping_read",
> - "terminate_write",
> - "terminate_dead",
> - "mark_read",
> - "mark_write",
> - "mark_access"
> -};
> -
> -static struct obstack rename_obstack;
> -
> -static void do_replace (struct du_chain *, int);
> -static void scan_rtx_reg (rtx, rtx *, enum reg_class,
> - enum scan_actions, enum op_type, int);
> -static void scan_rtx_address (rtx, rtx *, enum reg_class,
> - enum scan_actions, enum machine_mode);
> -static void scan_rtx (rtx, rtx *, enum reg_class, enum scan_actions,
> - enum op_type, int);
> -static struct du_chain *build_def_use (basic_block);
> -static void dump_def_use_chain (struct du_chain *);
> -static void note_sets (rtx, const_rtx, void *);
> -static void clear_dead_regs (HARD_REG_SET *, enum reg_note, rtx);
> -static void merge_overlapping_regs (basic_block, HARD_REG_SET *,
> - struct du_chain *);
> -
> -/* Called through note_stores. Find sets of registers, and
> - record them in *DATA (which is actually a HARD_REG_SET *). */
> -
> -static void
> -note_sets (rtx x, const_rtx set ATTRIBUTE_UNUSED, void *data)
> -{
> - HARD_REG_SET *pset = (HARD_REG_SET *) data;
> -
> - if (GET_CODE (x) == SUBREG)
> - x = SUBREG_REG (x);
> - if (!REG_P (x))
> - return;
> - /* There must not be pseudos at this point. */
> - gcc_assert (HARD_REGISTER_P (x));
> - add_to_hard_reg_set (pset, GET_MODE (x), REGNO (x));
> -}
> -
> -/* Clear all registers from *PSET for which a note of kind KIND can be found
> - in the list NOTES. */
> -
> -static void
> -clear_dead_regs (HARD_REG_SET *pset, enum reg_note kind, rtx notes)
> -{
> - rtx note;
> - for (note = notes; note; note = XEXP (note, 1))
> - if (REG_NOTE_KIND (note) == kind && REG_P (XEXP (note, 0)))
> - {
> - rtx reg = XEXP (note, 0);
> - /* There must not be pseudos at this point. */
> - gcc_assert (HARD_REGISTER_P (reg));
> - remove_from_hard_reg_set (pset, GET_MODE (reg), REGNO (reg));
> - }
> -}
> -
> -/* For a def-use chain CHAIN in basic block B, find which registers overlap
> - its lifetime and set the corresponding bits in *PSET. */
> -
> -static void
> -merge_overlapping_regs (basic_block b, HARD_REG_SET *pset,
> - struct du_chain *chain)
> -{
> - struct du_chain *t = chain;
> - rtx insn;
> - HARD_REG_SET live;
> - df_ref *def_rec;
> -
> - REG_SET_TO_HARD_REG_SET (live, df_get_live_in (b));
> - for (def_rec = df_get_artificial_defs (b->index); *def_rec; def_rec++)
> - {
> - df_ref def = *def_rec;
> - if (DF_REF_FLAGS (def) & DF_REF_AT_TOP)
> - SET_HARD_REG_BIT (live, DF_REF_REGNO (def));
> - }
> - insn = BB_HEAD (b);
> - while (t)
> - {
> - /* Search forward until the next reference to the register to be
> - renamed. */
> - while (insn != t->insn)
> - {
> - if (INSN_P (insn))
> - {
> - clear_dead_regs (&live, REG_DEAD, REG_NOTES (insn));
> - note_stores (PATTERN (insn), note_sets, (void *) &live);
> - /* Only record currently live regs if we are inside the
> - reg's live range. */
> - if (t != chain)
> - IOR_HARD_REG_SET (*pset, live);
> - clear_dead_regs (&live, REG_UNUSED, REG_NOTES (insn));
> - }
> - insn = NEXT_INSN (insn);
> - }
> -
> - IOR_HARD_REG_SET (*pset, live);
> -
> - /* For the last reference, also merge in all registers set in the
> - same insn.
> - @@@ We only have take earlyclobbered sets into account. */
> - if (! t->next_use)
> - note_stores (PATTERN (insn), note_sets, (void *) pset);
> -
> - t = t->next_use;
> - }
> -}
> -
> -/* Perform register renaming on the current function. */
> -
> -static void
> -regrename_optimize (void)
> -{
> - int tick[FIRST_PSEUDO_REGISTER];
> - int this_tick = 0;
> - basic_block bb;
> - char *first_obj;
> -
> - df_set_flags (DF_LR_RUN_DCE);
> - df_note_add_problem ();
> - df_analyze ();
> - df_set_flags (DF_DEFER_INSN_RESCAN);
> -
> - memset (tick, 0, sizeof tick);
> -
> - gcc_obstack_init (&rename_obstack);
> - first_obj = XOBNEWVAR (&rename_obstack, char, 0);
> -
> - FOR_EACH_BB (bb)
> - {
> - struct du_chain *all_chains = 0;
> - HARD_REG_SET unavailable;
> - HARD_REG_SET regs_seen;
> -
> - CLEAR_HARD_REG_SET (unavailable);
> -
> - if (dump_file)
> - fprintf (dump_file, "\nBasic block %d:\n", bb->index);
> -
> - all_chains = build_def_use (bb);
> -
> - if (dump_file)
> - dump_def_use_chain (all_chains);
> -
> - CLEAR_HARD_REG_SET (unavailable);
> - /* Don't clobber traceback for noreturn functions. */
> - if (frame_pointer_needed)
> - {
> - add_to_hard_reg_set (&unavailable, Pmode, FRAME_POINTER_REGNUM);
> -#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
> - add_to_hard_reg_set (&unavailable, Pmode, HARD_FRAME_POINTER_REGNUM);
> -#endif
> - }
> -
> - CLEAR_HARD_REG_SET (regs_seen);
> - while (all_chains)
> - {
> - int new_reg, best_new_reg;
> - int n_uses;
> - struct du_chain *this_du = all_chains;
> - struct du_chain *tmp, *last;
> - HARD_REG_SET this_unavailable;
> - int reg = REGNO (*this_du->loc);
> - int i;
> -
> - all_chains = this_du->next_chain;
> -
> - best_new_reg = reg;
> -
> -#if 0 /* This just disables optimization opportunities. */
> - /* Only rename once we've seen the reg more than once. */
> - if (! TEST_HARD_REG_BIT (regs_seen, reg))
> - {
> - SET_HARD_REG_BIT (regs_seen, reg);
> - continue;
> - }
> -#endif
> -
> - if (fixed_regs[reg] || global_regs[reg]
> -#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
> - || (frame_pointer_needed && reg == HARD_FRAME_POINTER_REGNUM)
> -#else
> - || (frame_pointer_needed && reg == FRAME_POINTER_REGNUM)
> -#endif
> - )
> - continue;
> -
> - COPY_HARD_REG_SET (this_unavailable, unavailable);
> -
> - /* Find last entry on chain (which has the need_caller_save bit),
> - count number of uses, and narrow the set of registers we can
> - use for renaming. */
> - n_uses = 0;
> - for (last = this_du; last->next_use; last = last->next_use)
> - {
> - n_uses++;
> - IOR_COMPL_HARD_REG_SET (this_unavailable,
> - reg_class_contents[last->cl]);
> - }
> - if (n_uses < 1)
> - continue;
> -
> - IOR_COMPL_HARD_REG_SET (this_unavailable,
> - reg_class_contents[last->cl]);
> -
> - if (this_du->need_caller_save_reg)
> - IOR_HARD_REG_SET (this_unavailable, call_used_reg_set);
> -
> - merge_overlapping_regs (bb, &this_unavailable, this_du);
> -
> - /* Now potential_regs is a reasonable approximation, let's
> - 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_du->loc)];
> -
> - for (i = nregs - 1; i >= 0; --i)
> - if (TEST_HARD_REG_BIT (this_unavailable, new_reg + i)
> - || fixed_regs[new_reg + i]
> - || global_regs[new_reg + i]
> - /* Can't use regs which aren't saved by the prologue. */
> - || (! df_regs_ever_live_p (new_reg + i)
> - && ! call_used_regs[new_reg + i])
> -#ifdef LEAF_REGISTERS
> - /* We can't use a non-leaf register if we're in a
> - leaf function. */
> - || (current_function_is_leaf
> - && !LEAF_REGISTERS[new_reg + i])
> -#endif
> -#ifdef HARD_REGNO_RENAME_OK
> - || ! HARD_REGNO_RENAME_OK (reg + i, new_reg + i)
> -#endif
> - )
> - break;
> - if (i >= 0)
> - continue;
> -
> - /* See whether it accepts all modes that occur in
> - definition and uses. */
> - for (tmp = this_du; tmp; tmp = tmp->next_use)
> - if (! HARD_REGNO_MODE_OK (new_reg, GET_MODE (*tmp->loc))
> - || (tmp->need_caller_save_reg
> - && ! (HARD_REGNO_CALL_PART_CLOBBERED
> - (reg, GET_MODE (*tmp->loc)))
> - && (HARD_REGNO_CALL_PART_CLOBBERED
> - (new_reg, GET_MODE (*tmp->loc)))))
> - break;
> - if (! tmp)
> - {
> - if (tick[best_new_reg] > tick[new_reg])
> - best_new_reg = new_reg;
> - }
> - }
> -
> - if (dump_file)
> - {
> - fprintf (dump_file, "Register %s in insn %d",
> - reg_names[reg], INSN_UID (last->insn));
> - if (last->need_caller_save_reg)
> - fprintf (dump_file, " crosses a call");
> - }
> -
> - if (best_new_reg == reg)
> - {
> - tick[reg] = ++this_tick;
> - if (dump_file)
> - fprintf (dump_file, "; no available better choice\n");
> - continue;
> - }
> -
> - if (dump_file)
> - fprintf (dump_file, ", renamed as %s\n", reg_names[best_new_reg]);
> -
> - do_replace (this_du, best_new_reg);
> - tick[best_new_reg] = ++this_tick;
> - df_set_regs_ever_live (best_new_reg, true);
> - }
> -
> - obstack_free (&rename_obstack, first_obj);
> - }
> -
> - obstack_free (&rename_obstack, NULL);
> -
> - if (dump_file)
> - fputc ('\n', dump_file);
> -}
> -
> -static void
> -do_replace (struct du_chain *chain, int reg)
> -{
> - while (chain)
> - {
> - unsigned int regno = ORIGINAL_REGNO (*chain->loc);
> - struct reg_attrs * attr = REG_ATTRS (*chain->loc);
> - int reg_ptr = REG_POINTER (*chain->loc);
> -
> - *chain->loc = gen_raw_REG (GET_MODE (*chain->loc), reg);
> - if (regno >= FIRST_PSEUDO_REGISTER)
> - ORIGINAL_REGNO (*chain->loc) = regno;
> - REG_ATTRS (*chain->loc) = attr;
> - REG_POINTER (*chain->loc) = reg_ptr;
> - df_insn_rescan (chain->insn);
> - chain = chain->next_use;
> - }
> -}
> -
> -
> -static struct du_chain *open_chains;
> -static struct du_chain *closed_chains;
> -
> -static void
> -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];
> -
> - if (action == mark_write)
> - {
> - if (type == OP_OUT)
> - {
> - struct du_chain *this_du = XOBNEW (&rename_obstack, struct du_chain);
> - this_du->next_use = 0;
> - this_du->next_chain = open_chains;
> - this_du->loc = loc;
> - this_du->insn = insn;
> - this_du->cl = cl;
> - this_du->need_caller_save_reg = 0;
> - this_du->earlyclobber = earlyclobber;
> - open_chains = this_du;
> - }
> - return;
> - }
> -
> - if ((type == OP_OUT) != (action == terminate_write || action == mark_access))
> - return;
> -
> - for (p = &open_chains; *p;)
> - {
> - struct du_chain *this_du = *p;
> -
> - /* Check if the chain has been terminated if it has then skip to
> - the next chain.
> -
> - This can happen when we've already appended the location to
> - the chain in Step 3, but are trying to hide in-out operands
> - from terminate_write in Step 5. */
> -
> - if (*this_du->loc == cc0_rtx)
> - p = &this_du->next_chain;
> - else
> - {
> - int regno = REGNO (*this_du->loc);
> - int nregs = hard_regno_nregs[regno][GET_MODE (*this_du->loc)];
> - int exact_match = (regno == this_regno && nregs == this_nregs);
> -
> - if (regno + nregs <= this_regno
> - || this_regno + this_nregs <= regno)
> - {
> - p = &this_du->next_chain;
> - continue;
> - }
> -
> - if (action == mark_read || action == mark_access)
> - {
> - 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 (cl != NO_REGS)
> - {
> - this_du = XOBNEW (&rename_obstack, struct du_chain);
> - this_du->next_use = 0;
> - this_du->next_chain = (*p)->next_chain;
> - this_du->loc = loc;
> - this_du->insn = insn;
> - this_du->cl = cl;
> - this_du->need_caller_save_reg = 0;
> - while (*p)
> - p = &(*p)->next_use;
> - *p = this_du;
> - return;
> - }
> - }
> -
> - if (action != terminate_overlapping_read || ! exact_match)
> - {
> - struct du_chain *next = this_du->next_chain;
> -
> - /* Whether the terminated chain can be used for renaming
> - depends on the action and this being an exact match.
> - In either case, we remove this element from open_chains. */
> -
> - if ((action == terminate_dead || action == terminate_write)
> - && exact_match)
> - {
> - this_du->next_chain = closed_chains;
> - closed_chains = this_du;
> - if (dump_file)
> - fprintf (dump_file,
> - "Closing chain %s at insn %d (%s)\n",
> - reg_names[REGNO (*this_du->loc)], INSN_UID (insn),
> - scan_actions_name[(int) action]);
> - }
> - else
> - {
> - if (dump_file)
> - fprintf (dump_file,
> - "Discarding chain %s at insn %d (%s)\n",
> - reg_names[REGNO (*this_du->loc)], INSN_UID (insn),
> - scan_actions_name[(int) action]);
> - }
> - *p = next;
> - }
> - else
> - p = &this_du->next_chain;
> - }
> - }
> -}
> -
> -/* 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 cl,
> - enum scan_actions action, enum machine_mode mode)
> -{
> - rtx x = *loc;
> - RTX_CODE code = GET_CODE (x);
> - const char *fmt;
> - int i, j;
> -
> - if (action == mark_write || action == mark_access)
> - return;
> -
> - 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)
> - scan_rtx_address (insn, locI, INDEX_REG_CLASS, action, mode);
> - if (locB)
> - scan_rtx_address (insn, locB, base_reg_class (mode, PLUS, index_code),
> - action, mode);
> -
> - return;
> - }
> -
> - case POST_INC:
> - case POST_DEC:
> - case POST_MODIFY:
> - case PRE_INC:
> - case PRE_DEC:
> - case PRE_MODIFY:
> -#ifndef AUTO_INC_DEC
> - /* If the target doesn't claim to handle autoinc, this must be
> - something special, like a stack push. Kill this chain. */
> - action = terminate_all_read;
> -#endif
> - break;
> -
> - case MEM:
> - scan_rtx_address (insn, &XEXP (x, 0),
> - base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
> - GET_MODE (x));
> - return;
> -
> - case REG:
> - scan_rtx_reg (insn, loc, cl, action, OP_IN, 0);
> - return;
> -
> - default:
> - break;
> - }
> -
> - fmt = GET_RTX_FORMAT (code);
> - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
> - {
> - if (fmt[i] == 'e')
> - 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), cl, action, mode);
> - }
> -}
> -
> -static void
> -scan_rtx (rtx insn, rtx *loc, enum reg_class cl,
> - enum scan_actions action, enum op_type type, int earlyclobber)
> -{
> - const char *fmt;
> - rtx x = *loc;
> - enum rtx_code code = GET_CODE (x);
> - int i, j;
> -
> - code = GET_CODE (x);
> - switch (code)
> - {
> - case CONST:
> - case CONST_INT:
> - case CONST_DOUBLE:
> - case CONST_FIXED:
> - case CONST_VECTOR:
> - case SYMBOL_REF:
> - case LABEL_REF:
> - case CC0:
> - case PC:
> - return;
> -
> - case REG:
> - scan_rtx_reg (insn, loc, cl, action, type, earlyclobber);
> - return;
> -
> - case MEM:
> - scan_rtx_address (insn, &XEXP (x, 0),
> - base_reg_class (GET_MODE (x), MEM, SCRATCH), action,
> - GET_MODE (x));
> - return;
> -
> - case SET:
> - 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), cl, action, OP_INOUT, earlyclobber);
> - return;
> -
> - case ZERO_EXTRACT:
> - case SIGN_EXTRACT:
> - scan_rtx (insn, &XEXP (x, 0), cl, action,
> - type == OP_IN ? OP_IN : OP_INOUT, earlyclobber);
> - 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:
> - case PRE_INC:
> - case POST_DEC:
> - case PRE_DEC:
> - case POST_MODIFY:
> - case PRE_MODIFY:
> - /* Should only happen inside MEM. */
> - gcc_unreachable ();
> -
> - case CLOBBER:
> - 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), cl, action, type, 0);
> - if (XEXP (x, 1))
> - scan_rtx (insn, &XEXP (x, 1), cl, action, type, 0);
> - return;
> -
> - default:
> - break;
> - }
> -
> - fmt = GET_RTX_FORMAT (code);
> - for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
> - {
> - if (fmt[i] == 'e')
> - 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), cl, action, type, 0);
> - }
> -}
> -
> -/* Build def/use chain. */
> -
> -static struct du_chain *
> -build_def_use (basic_block bb)
> -{
> - rtx insn;
> -
> - open_chains = closed_chains = NULL;
> -
> - for (insn = BB_HEAD (bb); ; insn = NEXT_INSN (insn))
> - {
> - if (INSN_P (insn))
> - {
> - int n_ops;
> - rtx note;
> - rtx old_operands[MAX_RECOG_OPERANDS];
> - rtx old_dups[MAX_DUP_OPERANDS];
> - int i, icode;
> - int alt;
> - int predicated;
> -
> - /* Process the insn, determining its effect on the def-use
> - chains. We perform the following steps with the register
> - references in the insn:
> - (1) Any read that overlaps an open chain, but doesn't exactly
> - match, causes that chain to be closed. We can't deal
> - with overlaps yet.
> - (2) Any read outside an operand causes any chain it overlaps
> - with to be closed, since we can't replace it.
> - (3) Any read inside an operand is added if there's already
> - an open chain for it.
> - (4) For any REG_DEAD note we find, close open chains that
> - overlap it.
> - (5) For any write we find, close open chains that overlap it.
> - (6) For any write we find in an operand, make a new chain.
> - (7) For any REG_UNUSED, close any chains we just opened. */
> -
> - icode = recog_memoized (insn);
> - extract_insn (insn);
> - if (! constrain_operands (1))
> - fatal_insn_not_found (insn);
> - 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].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;
> - }
> -
> - /* Step 1: Close chains for which we have overlapping reads. */
> - for (i = 0; i < n_ops; i++)
> - scan_rtx (insn, recog_data.operand_loc[i],
> - NO_REGS, terminate_overlapping_read,
> - recog_data.operand_type[i], 0);
> -
> - /* Step 2: Close chains for which we have reads outside operands.
> - We do this by munging all operands into CC0, and closing
> - everything remaining. */
> -
> - for (i = 0; i < n_ops; i++)
> - {
> - old_operands[i] = recog_data.operand[i];
> - /* Don't squash match_operator or match_parallel here, since
> - we don't know that all of the contained registers are
> - reachable by proper operands. */
> - if (recog_data.constraints[i][0] == '\0')
> - continue;
> - *recog_data.operand_loc[i] = cc0_rtx;
> - }
> - for (i = 0; i < recog_data.n_dups; i++)
> - {
> - old_dups[i] = *recog_data.dup_loc[i];
> - *recog_data.dup_loc[i] = cc0_rtx;
> - }
> -
> - scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_all_read,
> - OP_IN, 0);
> -
> - for (i = 0; i < recog_data.n_dups; i++)
> - *recog_data.dup_loc[i] = old_dups[i];
> - for (i = 0; i < n_ops; i++)
> - *recog_data.operand_loc[i] = old_operands[i];
> - if (recog_data.n_dups)
> - df_insn_rescan (insn);
> -
> - /* Step 2B: Can't rename function call argument registers. */
> - 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);
> -
> - /* Step 2C: Can't rename asm operands that were originally
> - hard registers. */
> - if (asm_noperands (PATTERN (insn)) > 0)
> - for (i = 0; i < n_ops; i++)
> - {
> - rtx *loc = recog_data.operand_loc[i];
> - rtx op = *loc;
> -
> - if (REG_P (op)
> - && REGNO (op) == ORIGINAL_REGNO (op)
> - && (recog_data.operand_type[i] == OP_IN
> - || recog_data.operand_type[i] == OP_INOUT))
> - scan_rtx (insn, loc, NO_REGS, terminate_all_read, OP_IN, 0);
> - }
> -
> - /* Step 3: Append to chains for reads inside operands. */
> - 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 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
> - information to pass down. Any operands that we could
> - substitute in will be represented elsewhere. */
> - if (recog_data.constraints[opn][0] == '\0')
> - continue;
> -
> - if (recog_op_alt[opn][alt].is_address)
> - scan_rtx_address (insn, loc, cl, mark_read, VOIDmode);
> - else
> - scan_rtx (insn, loc, cl, mark_read, type, 0);
> - }
> -
> - /* 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_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 (CALL_P (insn))
> - {
> - struct du_chain *p;
> - for (p = open_chains; p; p = p->next_chain)
> - p->need_caller_save_reg = 1;
> - }
> -
> - /* Step 5: Close open chains that overlap writes. Similar to
> - step 2, we hide in-out operands, since we do not want to
> - close these chains. */
> -
> - for (i = 0; i < n_ops; i++)
> - {
> - old_operands[i] = recog_data.operand[i];
> - if (recog_data.operand_type[i] == OP_INOUT)
> - *recog_data.operand_loc[i] = cc0_rtx;
> - }
> - for (i = 0; i < recog_data.n_dups; i++)
> - {
> - int opn = recog_data.dup_num[i];
> - old_dups[i] = *recog_data.dup_loc[i];
> - if (recog_data.operand_type[opn] == OP_INOUT)
> - *recog_data.dup_loc[i] = cc0_rtx;
> - }
> -
> - scan_rtx (insn, &PATTERN (insn), NO_REGS, terminate_write, OP_IN, 0);
> -
> - for (i = 0; i < recog_data.n_dups; i++)
> - *recog_data.dup_loc[i] = old_dups[i];
> - for (i = 0; i < n_ops; i++)
> - *recog_data.operand_loc[i] = old_operands[i];
> -
> - /* Step 6: Begin new chains for writes inside operands. */
> - /* ??? Many targets have output constraints on the SET_DEST
> - of a call insn, which is stupid, since these are certainly
> - ABI defined hard registers. Don't change calls at all.
> - Similarly take special care for asm statement that originally
> - referenced hard registers. */
> - if (asm_noperands (PATTERN (insn)) > 0)
> - {
> - for (i = 0; i < n_ops; i++)
> - if (recog_data.operand_type[i] == OP_OUT)
> - {
> - rtx *loc = recog_data.operand_loc[i];
> - rtx op = *loc;
> - enum reg_class cl = recog_op_alt[i][alt].cl;
> -
> - if (REG_P (op)
> - && REGNO (op) == ORIGINAL_REGNO (op))
> - continue;
> -
> - scan_rtx (insn, loc, cl, mark_write, OP_OUT,
> - recog_op_alt[i][alt].earlyclobber);
> - }
> - }
> - 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 cl = recog_op_alt[opn][alt].cl;
> -
> - if (recog_data.operand_type[opn] == 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))
> - if (REG_NOTE_KIND (note) == REG_UNUSED)
> - scan_rtx (insn, &XEXP (note, 0), NO_REGS, terminate_dead,
> - OP_IN, 0);
> - }
> - if (insn == BB_END (bb))
> - break;
> - }
> -
> - /* Since we close every chain when we find a REG_DEAD note, anything that
> - is still open lives past the basic block, so it can't be renamed. */
> - return closed_chains;
> -}
> -
> -/* 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
> -dump_def_use_chain (struct du_chain *chains)
> -{
> - while (chains)
> - {
> - struct du_chain *this_du = chains;
> - int r = REGNO (*this_du->loc);
> - int nregs = hard_regno_nregs[r][GET_MODE (*this_du->loc)];
> - fprintf (dump_file, "Register %s (%d):", reg_names[r], nregs);
> - while (this_du)
> - {
> - fprintf (dump_file, " %d [%s]", INSN_UID (this_du->insn),
> - reg_class_names[this_du->cl]);
> - this_du = this_du->next_use;
> - }
> - fprintf (dump_file, "\n");
> - 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
> @@ -1799,7 +839,7 @@ copyprop_hardreg_forward_1 (basic_block
>
> /* Main entry point for the forward copy propagation optimization. */
>
> -static void
> +static unsigned int
> copyprop_hardreg_forward (void)
> {
> struct value_data *all_vd;
> @@ -1831,6 +871,7 @@ copyprop_hardreg_forward (void)
>
> sbitmap_free (visited);
> free (all_vd);
> + return 0;
> }
>
> /* Dump the value chain data to stderr. */
> @@ -1938,66 +979,23 @@ validate_value_data (struct value_data *
> #endif
>
> static bool
> -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 */
> - 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_df_finish | TODO_verify_rtl_sharing |
> - TODO_dump_func /* todo_flags_finish */
> - }
> -};
> -
> -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 */
> + copyprop_hardreg_forward, /* execute */
> NULL, /* sub */
> NULL, /* next */
> 0, /* static_pass_number */
> - TV_RENAME_REGISTERS, /* tv_id */
> + TV_CPROP_REGISTERS, /* tv_id */
> 0, /* properties_required */
> 0, /* properties_provided */
> 0, /* properties_destroyed */
>
>
More information about the Gcc-patches
mailing list