From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2153) id 1CC0D38346B2; Tue, 10 May 2022 08:26:02 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 1CC0D38346B2 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jakub Jelinek To: gcc-cvs@gcc.gnu.org Subject: [gcc r10-10704] combine: Don't record for UNDO_MODE pointers into regno_reg_rtx array [PR104985] X-Act-Checkin: gcc X-Git-Author: Jakub Jelinek X-Git-Refname: refs/heads/releases/gcc-10 X-Git-Oldrev: e18956892bf35e13771e1360f07670d422c3e5e7 X-Git-Newrev: 6c081dee437170a34416c40411000ec33230409f Message-Id: <20220510082602.1CC0D38346B2@sourceware.org> Date: Tue, 10 May 2022 08:26:02 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 10 May 2022 08:26:02 -0000 https://gcc.gnu.org/g:6c081dee437170a34416c40411000ec33230409f commit r10-10704-g6c081dee437170a34416c40411000ec33230409f Author: Jakub Jelinek Date: Wed Apr 6 18:42:52 2022 +0200 combine: Don't record for UNDO_MODE pointers into regno_reg_rtx array [PR104985] The testcase in the PR fails under valgrind on mips64 (but only Martin can reproduce, I couldn't). But the problem reported there is that SUBST_MODE remembers addresses into the regno_reg_rtx array, then some splitter needs a new pseudo and calls gen_reg_rtx, which reallocates the regno_reg_rtx array and finally undo operation is done and dereferences the old regno_reg_rtx entry. The rtx values stored in regno_reg_rtx array seems to be created by gen_reg_rtx only and since then aren't modified, all we do for it is adjusting its fields (e.g. adjust_reg_mode that SUBST_MODE does). So, I think it is useless to use where.r for UNDO_MODE and store ®no_reg_rtx[regno] in struct undo, we can store just regno_reg_rtx[regno] (i.e. pointer to the REG itself instead of pointer to pointer to REG) or could also store just the regno. The following patch does the latter, and because SUBST_MODE no longer needs to be a macro, changes all SUBST_MODE uses to subst_mode. 2022-04-06 Jakub Jelinek PR rtl-optimization/104985 * combine.c (struct undo): Add where.regno member. (do_SUBST_MODE): Rename to ... (subst_mode): ... this. Change first argument from rtx * into int, operate on regno_reg_rtx[regno] and save regno into where.regno. (SUBST_MODE): Remove. (try_combine): Use subst_mode instead of SUBST_MODE, change first argument from regno_reg_rtx[whatever] to whatever. For UNDO_MODE, use regno_reg_rtx[undo->where.regno] instead of *undo->where.r. (undo_to_marker): For UNDO_MODE, use regno_reg_rtx[undo->where.regno] instead of *undo->where.r. (simplify_set): Use subst_mode instead of SUBST_MODE, change first argument from regno_reg_rtx[whatever] to whatever. (cherry picked from commit 61bee6aed26eb30b798c75b9a595c9d51e080442) Diff: --- gcc/combine.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/gcc/combine.c b/gcc/combine.c index c71da0ee9a6..3cbf0d06fc9 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -396,7 +396,7 @@ struct undo struct undo *next; enum undo_kind kind; union { rtx r; int i; machine_mode m; struct insn_link *l; } old_contents; - union { rtx *r; int *i; struct insn_link **l; } where; + union { rtx *r; int *i; int regno; struct insn_link **l; } where; }; /* Record a bunch of changes to be undone, up to MAX_UNDO of them. @@ -792,10 +792,11 @@ do_SUBST_INT (int *into, int newval) well. */ static void -do_SUBST_MODE (rtx *into, machine_mode newval) +subst_mode (int regno, machine_mode newval) { struct undo *buf; - machine_mode oldval = GET_MODE (*into); + rtx reg = regno_reg_rtx[regno]; + machine_mode oldval = GET_MODE (reg); if (oldval == newval) return; @@ -806,15 +807,13 @@ do_SUBST_MODE (rtx *into, machine_mode newval) buf = XNEW (struct undo); buf->kind = UNDO_MODE; - buf->where.r = into; + buf->where.regno = regno; buf->old_contents.m = oldval; - adjust_reg_mode (*into, newval); + adjust_reg_mode (reg, newval); buf->next = undobuf.undos, undobuf.undos = buf; } -#define SUBST_MODE(INTO, NEWVAL) do_SUBST_MODE (&(INTO), (NEWVAL)) - /* Similar to SUBST, but NEWVAL is a LOG_LINKS expression. */ static void @@ -3336,7 +3335,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, newpat_dest = gen_rtx_REG (compare_mode, regno); else { - SUBST_MODE (regno_reg_rtx[regno], compare_mode); + subst_mode (regno, compare_mode); newpat_dest = regno_reg_rtx[regno]; } } @@ -3726,7 +3725,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, ni2dest = gen_rtx_REG (new_mode, REGNO (i2dest)); else { - SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], new_mode); + subst_mode (REGNO (i2dest), new_mode); ni2dest = regno_reg_rtx[REGNO (i2dest)]; } @@ -3863,7 +3862,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, newdest = gen_rtx_REG (split_mode, REGNO (i2dest)); else { - SUBST_MODE (regno_reg_rtx[REGNO (i2dest)], split_mode); + subst_mode (REGNO (i2dest), split_mode); newdest = regno_reg_rtx[REGNO (i2dest)]; } } @@ -4231,7 +4230,7 @@ try_combine (rtx_insn *i3, rtx_insn *i2, rtx_insn *i1, rtx_insn *i0, for (undo = undobuf.undos; undo; undo = undo->next) if (undo->kind == UNDO_MODE) { - rtx reg = *undo->where.r; + rtx reg = regno_reg_rtx[undo->where.regno]; machine_mode new_mode = GET_MODE (reg); machine_mode old_mode = undo->old_contents.m; @@ -4904,7 +4903,8 @@ undo_to_marker (void *marker) *undo->where.i = undo->old_contents.i; break; case UNDO_MODE: - adjust_reg_mode (*undo->where.r, undo->old_contents.m); + adjust_reg_mode (regno_reg_rtx[undo->where.regno], + undo->old_contents.m); break; case UNDO_LINKS: *undo->where.l = undo->old_contents.l; @@ -6979,7 +6979,7 @@ simplify_set (rtx x) new_dest = gen_rtx_REG (compare_mode, regno); else { - SUBST_MODE (regno_reg_rtx[regno], compare_mode); + subst_mode (regno, compare_mode); new_dest = regno_reg_rtx[regno]; }