-dump_def_use_chain (struct du_chain *chains)
-{
- while (chains)
- {
- struct du_chain *this = chains;
- int r = REGNO (*this->loc);
- int nregs = hard_regno_nregs[r][GET_MODE (*this->loc)];
- fprintf (rtl_dump_file, "Register %s (%d):", reg_names[r], nregs);
- while (this)
- {
- fprintf (rtl_dump_file, " %d [%s]", INSN_UID (this->insn),
- reg_class_names[this->class]);
- this = this->next_use;
- }
- fprintf (rtl_dump_file, "\n");
- chains = chains->next_chain;
- }
-}
-\f
-/* 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_regno (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, rtx, void *);
-static void kill_set_value (rtx, 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. */
-
-static void
-kill_value_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 X. This is a convenience function for kill_value_regno
- so that we mind the mode the register is in. */
-
-static void
-kill_value (rtx x, struct value_data *vd)
-{
- /* SUBREGS are supposed to have been eliminated by now. But some
- ports, e.g. i386 sse, use them to smuggle vector type information
- through to instruction selection. Each such SUBREG should simplify,
- so if we get a NULL we've done something wrong elsewhere. */
-
- if (GET_CODE (x) == SUBREG)
- x = simplify_subreg (GET_MODE (x), SUBREG_REG (x),
- GET_MODE (SUBREG_REG (x)), SUBREG_BYTE (x));
- if (REG_P (x))
- {
- unsigned int regno = REGNO (x);
- unsigned int n = hard_regno_nregs[regno][GET_MODE (x)];
- unsigned int i, j;
-
- /* Kill the value we're told to kill. */
- for (i = 0; i < n; ++i)
- kill_value_regno (regno + i, vd);
-
- /* Kill everything that overlapped what we're told to kill. */
- if (regno < vd->max_value_regs)
- j = 0;
- else
- j = regno - vd->max_value_regs;
- for (; j < regno; ++j)
- {
- if (vd->e[j].mode == VOIDmode)
- continue;
- n = hard_regno_nregs[j][vd->e[j].mode];
- if (j + n > regno)
- for (i = 0; i < n; ++i)
- kill_value_regno (j + i, vd);
- }
- }
-}
-
-/* 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, 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 (rtx x, rtx set, void *data)
-{
- struct value_data *vd = 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 *vd = data;
-
- if (GET_RTX_CLASS (GET_CODE (x)) == 'a')
- {
- 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;
-
- /* 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)