-\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_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, 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. 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, 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)) == 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;
-
- /* 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 (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;
- unsigned int last;
-
- for (last = i; last < i + hard_regno_nregs[i][mode]; last++)
- if (!TEST_HARD_REG_BIT (reg_class_contents[cl], last))
- return NULL_RTX;
-
- new = maybe_mode_change (oldmode, vd->e[regno].mode, mode, i, regno);
- if (new)
- {
- ORIGINAL_REGNO (new) = ORIGINAL_REGNO (reg);
- REG_ATTRS (new) = REG_ATTRS (reg);
- return new;
- }
- }
-
- 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 = find_oldest_value_reg (cl, *loc, vd);
- if (new)
- {
- if (dump_file)
- fprintf (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. 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;
- rtx *locB_reg = 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_REG_BASE_P (op1, mode))
- index_op = 0;
- else if (REG_OK_FOR_INDEX_P (op1)
- && REG_MODE_OK_FOR_REG_BASE_P (op0, mode))
- index_op = 1;
- else if (REG_MODE_OK_FOR_REG_BASE_P (op1, mode))
- index_op = 0;
- else if (REG_MODE_OK_FOR_REG_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_reg = &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,
- MODE_BASE_REG_CLASS (mode),
- mode, insn, vd);
- if (locB_reg)
- changed |= replace_oldest_value_addr (locB_reg,
- MODE_BASE_REG_REG_CLASS (mode),
- 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),
- MODE_BASE_REG_CLASS (GET_MODE (x)),
- GET_MODE (x), insn, vd);
-}
-
-/* Perform the forward copy propagation on basic block BB. */