From b0681c9e51cafab3bf40c1997e7da9e3d13bdefd Mon Sep 17 00:00:00 2001 From: Vladimir Makarov Date: Tue, 10 Sep 2013 15:37:57 +0000 Subject: [PATCH] lra.c (lra): Clear lra_optional_reload_pseudos before every constraint pass. 2013-09-10 Vladimir Makarov * lra.c (lra): Clear lra_optional_reload_pseudos before every constraint pass. * lra-constraints.c (curr_insn_transform): Switch on optional reloads. Check destination too to check move insn. (undo_optional_reloads): Add check that the original peudo did not changed its allocation and the optional reload was inherited on last inheritance pass. Break loop after deciding to keep optional reload. (lra_undo_inheritance): Add check that inherited pseudo still in memory. From-SVN: r202468 --- gcc/ChangeLog | 13 ++++++++ gcc/lra-constraints.c | 72 ++++++++++++++++++++++++++++--------------- gcc/lra.c | 2 +- 3 files changed, 62 insertions(+), 25 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 707ece6f6ea..bf0a9b46d2f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,16 @@ +2013-09-10 Vladimir Makarov + + * lra.c (lra): Clear lra_optional_reload_pseudos before every + constraint pass. + * lra-constraints.c (curr_insn_transform): Switch on optional + reloads. Check destination too to check move insn. + (undo_optional_reloads): Add check that the original peudo did not + changed its allocation and the optional reload was inherited on + last inheritance pass. Break loop after deciding to keep optional + reload. + (lra_undo_inheritance): Add check that inherited pseudo still in + memory. + 2013-09-10 James Greenhalgh * config/aarch64/aarch64.md (generic_sched): New. diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c index 4d59b5a6ff2..479d2cbc22d 100644 --- a/gcc/lra-constraints.c +++ b/gcc/lra-constraints.c @@ -3309,15 +3309,19 @@ curr_insn_transform (void) reg, we might improve the code through inheritance. If it does not get a hard register we coalesce memory/memory moves later. Ignore move insns to avoid cycling. */ - if (0 && ! lra_simple_p + if (! lra_simple_p && lra_undo_inheritance_iter < LRA_MAX_INHERITANCE_PASSES && goal_alt[i] != NO_REGS && REG_P (op) && (regno = REGNO (op)) >= FIRST_PSEUDO_REGISTER + && ! lra_former_scratch_p (regno) && reg_renumber[regno] < 0 && (curr_insn_set == NULL_RTX - || !(REG_P (SET_SRC (curr_insn_set)) - || MEM_P (SET_SRC (curr_insn_set)) - || GET_CODE (SET_SRC (curr_insn_set)) == SUBREG))) + || !((REG_P (SET_SRC (curr_insn_set)) + || MEM_P (SET_SRC (curr_insn_set)) + || GET_CODE (SET_SRC (curr_insn_set)) == SUBREG) + && (REG_P (SET_DEST (curr_insn_set)) + || MEM_P (SET_DEST (curr_insn_set)) + || GET_CODE (SET_DEST (curr_insn_set)) == SUBREG)))) optional_p = true; else continue; @@ -5441,7 +5445,7 @@ remove_inheritance_pseudos (bitmap remove_pseudos) static bool undo_optional_reloads (void) { - bool change_p; + bool change_p, keep_p; unsigned int regno, uid; bitmap_iterator bi, bi2; rtx insn, set, src, dest; @@ -5451,26 +5455,42 @@ undo_optional_reloads (void) bitmap_copy (&removed_optional_reload_pseudos, &lra_optional_reload_pseudos); EXECUTE_IF_SET_IN_BITMAP (&lra_optional_reload_pseudos, 0, regno, bi) if (reg_renumber[regno] >= 0) - EXECUTE_IF_SET_IN_BITMAP (&lra_reg_info[regno].insn_bitmap, 0, uid, bi2) - { - insn = lra_insn_recog_data[uid]->insn; - if ((set = single_set (insn)) == NULL_RTX) - continue; - src = SET_SRC (set); - dest = SET_DEST (set); - if (! REG_P (src) || ! REG_P (dest)) - continue; - if ((REGNO (src) == regno - && lra_reg_info[regno].restore_regno != (int) REGNO (dest)) - || (REGNO (dest) == regno - && lra_reg_info[regno].restore_regno != (int) REGNO (src))) + { + keep_p = false; + if (reg_renumber[lra_reg_info[regno].restore_regno] >= 0) + /* If the original pseudo changed its allocation, just + removing the optional pseudo is dangerous as the original + pseudo will have longer live range. */ + keep_p = true; + else + EXECUTE_IF_SET_IN_BITMAP (&lra_reg_info[regno].insn_bitmap, 0, uid, bi2) { - /* Optional reload was inherited. Keep it. */ - bitmap_clear_bit (&removed_optional_reload_pseudos, regno); - if (lra_dump_file != NULL) - fprintf (lra_dump_file, "Keep optional reload reg %d\n", regno); + insn = lra_insn_recog_data[uid]->insn; + if ((set = single_set (insn)) == NULL_RTX) + continue; + src = SET_SRC (set); + dest = SET_DEST (set); + if (! REG_P (src) || ! REG_P (dest)) + continue; + if (REGNO (dest) == regno + /* Ignore insn for optional reloads itself. */ + && lra_reg_info[regno].restore_regno != (int) REGNO (src) + /* Check only inheritance on last inheritance pass. */ + && (int) REGNO (src) >= new_regno_start + /* Check that the optional reload was inherited. */ + && bitmap_bit_p (&lra_inheritance_pseudos, REGNO (src))) + { + keep_p = true; + break; + } } - } + if (keep_p) + { + bitmap_clear_bit (&removed_optional_reload_pseudos, regno); + if (lra_dump_file != NULL) + fprintf (lra_dump_file, "Keep optional reload reg %d\n", regno); + } + } change_p = ! bitmap_empty_p (&removed_optional_reload_pseudos); bitmap_initialize (&insn_bitmap, ®_obstack); EXECUTE_IF_SET_IN_BITMAP (&removed_optional_reload_pseudos, 0, regno, bi) @@ -5552,7 +5572,11 @@ lra_undo_inheritance (void) if (lra_reg_info[regno].restore_regno >= 0) { n_all_inherit++; - if (reg_renumber[regno] < 0) + if (reg_renumber[regno] < 0 + /* If the original pseudo changed its allocation, just + removing inheritance is dangerous as for changing + allocation we used shorter live-ranges. */ + && reg_renumber[lra_reg_info[regno].restore_regno] < 0) bitmap_set_bit (&remove_pseudos, regno); else n_inherit++; diff --git a/gcc/lra.c b/gcc/lra.c index ef69526b0ec..df457f5bc9e 100644 --- a/gcc/lra.c +++ b/gcc/lra.c @@ -2315,6 +2315,7 @@ lra (FILE *f) { for (;;) { + bitmap_clear (&lra_optional_reload_pseudos); /* We should try to assign hard registers to scratches even if there were no RTL transformations in lra_constraints. */ @@ -2365,7 +2366,6 @@ lra (FILE *f) if (! live_p) lra_clear_live_ranges (); } - bitmap_clear (&lra_optional_reload_pseudos); } bitmap_clear (&lra_subreg_reload_pseudos); bitmap_clear (&lra_inheritance_pseudos);