From: Richard Henderson Date: Wed, 12 Dec 2001 22:50:05 +0000 (-0800) Subject: regrename.c (copyprop_hardreg_forward): New optimization. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=8582c27b18b4b930dc202ee851528377e2234348;p=gcc.git regrename.c (copyprop_hardreg_forward): New optimization. * 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. From-SVN: r47951 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d5046325797..0a5f9e29aba 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,18 @@ +2001-12-12 Richard Henderson + + * 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. + 2001-12-12 Jakub Jelinek * dwarf2out.c (dw_val_class): Add dw_val_class_range_list. diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 66a0ddf6efa..66314f1dab8 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -259,7 +259,7 @@ in the following sections. @gccoptlist{ -falign-functions=@var{n} -falign-jumps=@var{n} @gol -falign-labels=@var{n} -falign-loops=@var{n} @gol --fbranch-probabilities -fcaller-saves @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 @@ -3774,6 +3774,12 @@ 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 In some places, GCC uses various constants to control the amount of diff --git a/gcc/regrename.c b/gcc/regrename.c index c0cf2326360..69e267cfaca 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -33,6 +33,7 @@ #include "function.h" #include "recog.h" #include "flags.h" +#include "toplev.h" #include "obstack.h" #define obstack_chunk_alloc xmalloc @@ -960,3 +961,742 @@ dump_def_use_chain (chains) chains = chains->next_chain; } } + +/* The following code does forward propagation of hard register copies. + The object is to eliminate as many dependencies as possible, so that + we have the most scheduling freedom. As a side effect, we also clean + up some silly register allocation decisions made by reload. This + code may be obsoleted by a new register allocator. */ + +/* For each register, we have a list of registers that contain the same + value. The OLDEST_REGNO field points to the head of the list, and + the NEXT_REGNO field runs through the list. The MODE field indicates + what mode the data is known to be in; this field is VOIDmode when the + register is not known to contain valid data. */ + +struct value_data_entry +{ + enum machine_mode mode; + unsigned int oldest_regno; + unsigned int next_regno; +}; + +struct value_data +{ + struct value_data_entry e[FIRST_PSEUDO_REGISTER]; +}; + +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 diff --git a/gcc/rtl.h b/gcc/rtl.h index 0fe43aae370..4c8d1ff7407 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -2097,6 +2097,7 @@ extern rtx stack_limit_rtx; /* 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)); diff --git a/gcc/toplev.c b/gcc/toplev.c index 66615008200..d2c7ca02054 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -427,6 +427,7 @@ int flag_reorder_blocks = 0; /* 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. */ @@ -1083,6 +1084,8 @@ lang_independent_options f_options[] = 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, @@ -3280,12 +3283,15 @@ rest_of_compilation (decl) } #endif - if (optimize > 0 && flag_rename_registers) + if (flag_rename_registers || flag_cprop_registers) { timevar_push (TV_RENAME_REGISTERS); open_dump_file (DFI_rnreg, decl); - regrename_optimize (); + 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); @@ -4620,6 +4626,7 @@ parse_options_and_default_flags (argc, argv) flag_omit_frame_pointer = 1; #endif flag_guess_branch_prob = 1; + flag_cprop_registers = 1; } if (optimize >= 2)