public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc(refs/users/aoliva/heads/testme)] try multi-reg dest in default_zero_call_used_regs
@ 2022-04-01 5:48 Alexandre Oliva
0 siblings, 0 replies; 2+ messages in thread
From: Alexandre Oliva @ 2022-04-01 5:48 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:8e95a7059f792975b799923b3cd129ecef2c9595
commit 8e95a7059f792975b799923b3cd129ecef2c9595
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Apr 1 02:46:20 2022 -0300
try multi-reg dest in default_zero_call_used_regs
When the mode of regno_reg_rtx is not hard_regno_mode_ok for the
target, try grouping the register with subsequent ones. This enables
s16 to s31 and their hidden pairs to be zeroed with the default logic
on some arm variants.
for gcc/ChangeLog
* targhooks.c (default_zero_call_used_regs): Attempt to group
regs that the target refuses to use in their natural modes.
(zcur_select_mode_rtx): New.
* regs.h (struct target_regs): Add x_hard_regno_max_nregs.
(hard_regno_max_nregs): Define.
* reginfo.c (init_reg_modes_target): Set hard_regno_max_nregs.
Diff:
---
gcc/reginfo.cc | 9 ++++--
gcc/regs.h | 5 ++++
gcc/targhooks.cc | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++------
3 files changed, 89 insertions(+), 11 deletions(-)
diff --git a/gcc/reginfo.cc b/gcc/reginfo.cc
index 234f72eceeb..67e30cab428 100644
--- a/gcc/reginfo.cc
+++ b/gcc/reginfo.cc
@@ -441,10 +441,15 @@ init_reg_modes_target (void)
{
int i, j;
+ this_target_regs->x_hard_regno_max_nregs = 1;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = 0; j < MAX_MACHINE_MODE; j++)
- this_target_regs->x_hard_regno_nregs[i][j]
- = targetm.hard_regno_nregs (i, (machine_mode) j);
+ {
+ unsigned char nregs = targetm.hard_regno_nregs (i, (machine_mode) j);
+ this_target_regs->x_hard_regno_nregs[i][j] = nregs;
+ if (nregs > this_target_regs->x_hard_regno_max_nregs)
+ this_target_regs->x_hard_regno_max_nregs = nregs;
+ }
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
diff --git a/gcc/regs.h b/gcc/regs.h
index 74f1f637703..f72b06fb565 100644
--- a/gcc/regs.h
+++ b/gcc/regs.h
@@ -202,6 +202,9 @@ struct target_regs {
registers that a given machine mode occupies. */
unsigned char x_hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
+ /* The max value found in x_hard_regno_nregs. */
+ unsigned char x_hard_regno_max_nregs;
+
/* For each hard register, the widest mode object that it can contain.
This will be a MODE_INT mode if the register can hold integers. Otherwise
it will be a MODE_FLOAT or a MODE_CC mode, whichever is valid for the
@@ -235,6 +238,8 @@ extern struct target_regs *this_target_regs;
#else
#define this_target_regs (&default_target_regs)
#endif
+#define hard_regno_max_nregs \
+ (this_target_regs->x_hard_regno_max_nregs)
#define reg_raw_mode \
(this_target_regs->x_reg_raw_mode)
#define have_regs_of_mode \
diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
index fc49235eb38..2681833e2ce 100644
--- a/gcc/targhooks.cc
+++ b/gcc/targhooks.cc
@@ -1017,6 +1017,45 @@ default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
#endif
}
+/* Choose the mode and rtx to use to zero REGNO, storing tem in PMODE and
+ PREGNO_RTX and returning TRUE if successful, otherwise returning FALSE. If
+ the natural mode for REGNO doesn't work, attempt to group it with subsequent
+ adjacent registers set in TOZERO. */
+
+static inline bool
+zcur_select_mode_rtx (unsigned int regno, machine_mode *pmode,
+ rtx *pregno_rtx, HARD_REG_SET tozero)
+{
+ rtx regno_rtx = regno_reg_rtx[regno];
+ machine_mode mode = GET_MODE (regno_rtx);
+
+ /* If the natural mode doesn't work, try some wider mode. */
+ if (!targetm.hard_regno_mode_ok (regno, mode))
+ {
+ bool found = false;
+ for (int nregs = 2;
+ !found && nregs <= hard_regno_max_nregs
+ && regno + nregs <= FIRST_PSEUDO_REGISTER
+ && TEST_HARD_REG_BIT (tozero,
+ regno + nregs - 1);
+ nregs++)
+ {
+ mode = choose_hard_reg_mode (regno, nregs, 0);
+ if (mode == E_VOIDmode)
+ continue;
+ gcc_checking_assert (targetm.hard_regno_mode_ok (regno, mode));
+ regno_rtx = gen_rtx_REG (mode, regno);
+ found = true;
+ }
+ if (!found)
+ return false;
+ }
+
+ *pmode = mode;
+ *pregno_rtx = regno_rtx;
+ return true;
+}
+
/* The default hook for TARGET_ZERO_CALL_USED_REGS. */
HARD_REG_SET
@@ -1035,16 +1074,28 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
if (TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
{
rtx_insn *last_insn = get_last_insn ();
- machine_mode mode = GET_MODE (regno_reg_rtx[regno]);
+ rtx regno_rtx;
+ machine_mode mode;
+
+ if (!zcur_select_mode_rtx (regno, &mode, ®no_rtx,
+ need_zeroed_hardregs))
+ {
+ SET_HARD_REG_BIT (failed, regno);
+ continue;
+ }
+
rtx zero = CONST0_RTX (mode);
- rtx_insn *insn = emit_move_insn (regno_reg_rtx[regno], zero);
+ rtx_insn *insn = emit_move_insn (regno_rtx, zero);
if (!valid_insn_p (insn))
{
SET_HARD_REG_BIT (failed, regno);
delete_insns_since (last_insn);
}
else
- progress = true;
+ {
+ progress = true;
+ regno += hard_regno_nregs (regno, mode) - 1;
+ }
}
/* Now retry with copies from zeroed registers, as long as we've
@@ -1060,7 +1111,18 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (retrying, regno))
{
- machine_mode mode = GET_MODE (regno_reg_rtx[regno]);
+ rtx regno_rtx;
+ machine_mode mode;
+
+ /* This might select registers we've already zeroed. If grouping
+ with them is what it takes to get regno zeroed, so be it. */
+ if (!zcur_select_mode_rtx (regno, &mode, ®no_rtx,
+ need_zeroed_hardregs))
+ {
+ SET_HARD_REG_BIT (failed, regno);
+ continue;
+ }
+
bool success = false;
/* Look for a source. */
for (unsigned int src = 0; src < FIRST_PSEUDO_REGISTER; src++)
@@ -1086,8 +1148,11 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
/* SRC is usable, try to copy from it. */
rtx_insn *last_insn = get_last_insn ();
- rtx zsrc = gen_rtx_REG (mode, src);
- rtx_insn *insn = emit_move_insn (regno_reg_rtx[regno], zsrc);
+ /* Try to avoid allocating RTL that we have handy. */
+ rtx src_rtx = (mode == GET_MODE (regno_reg_rtx[src])
+ ? regno_reg_rtx[src]
+ : gen_rtx_REG (mode, src));
+ rtx_insn *insn = emit_move_insn (regno_rtx, src_rtx);
if (!valid_insn_p (insn))
/* It didn't work, remove any inserts. We'll look
for another SRC. */
@@ -1100,13 +1165,16 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
}
}
- /* If nothing worked for REGNO this round, marked it to be
+ /* If nothing worked for REGNO this round, mark it to be
retried if we get another round. */
if (!success)
SET_HARD_REG_BIT (failed, regno);
else
- /* Take note so as to enable another round if needed. */
- progress = true;
+ {
+ /* Take note so as to enable another round if needed. */
+ progress = true;
+ regno += hard_regno_nregs (regno, mode) - 1;
+ }
}
}
^ permalink raw reply [flat|nested] 2+ messages in thread
* [gcc(refs/users/aoliva/heads/testme)] try multi-reg dest in default_zero_call_used_regs
@ 2022-04-05 0:45 Alexandre Oliva
0 siblings, 0 replies; 2+ messages in thread
From: Alexandre Oliva @ 2022-04-05 0:45 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:5692d9f814e2cc479aee73036c249ab9ff0a3197
commit 5692d9f814e2cc479aee73036c249ab9ff0a3197
Author: Alexandre Oliva <oliva@adacore.com>
Date: Fri Apr 1 02:46:20 2022 -0300
try multi-reg dest in default_zero_call_used_regs
When the mode of regno_reg_rtx is not hard_regno_mode_ok for the
target, try grouping the register with subsequent ones. This enables
s16 to s31 and their hidden pairs to be zeroed with the default logic
on some arm variants.
for gcc/ChangeLog
* targhooks.c (default_zero_call_used_regs): Attempt to group
regs that the target refuses to use in their natural modes.
(zcur_select_mode_rtx): New.
* regs.h (struct target_regs): Add x_hard_regno_max_nregs.
(hard_regno_max_nregs): Define.
* reginfo.c (init_reg_modes_target): Set hard_regno_max_nregs.
Diff:
---
gcc/reginfo.cc | 9 ++++--
gcc/regs.h | 5 ++++
gcc/targhooks.cc | 83 ++++++++++++++++++++++++++++++++++++++++++++++++++------
3 files changed, 86 insertions(+), 11 deletions(-)
diff --git a/gcc/reginfo.cc b/gcc/reginfo.cc
index 234f72eceeb..67e30cab428 100644
--- a/gcc/reginfo.cc
+++ b/gcc/reginfo.cc
@@ -441,10 +441,15 @@ init_reg_modes_target (void)
{
int i, j;
+ this_target_regs->x_hard_regno_max_nregs = 1;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = 0; j < MAX_MACHINE_MODE; j++)
- this_target_regs->x_hard_regno_nregs[i][j]
- = targetm.hard_regno_nregs (i, (machine_mode) j);
+ {
+ unsigned char nregs = targetm.hard_regno_nregs (i, (machine_mode) j);
+ this_target_regs->x_hard_regno_nregs[i][j] = nregs;
+ if (nregs > this_target_regs->x_hard_regno_max_nregs)
+ this_target_regs->x_hard_regno_max_nregs = nregs;
+ }
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
diff --git a/gcc/regs.h b/gcc/regs.h
index 74f1f637703..f72b06fb565 100644
--- a/gcc/regs.h
+++ b/gcc/regs.h
@@ -202,6 +202,9 @@ struct target_regs {
registers that a given machine mode occupies. */
unsigned char x_hard_regno_nregs[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
+ /* The max value found in x_hard_regno_nregs. */
+ unsigned char x_hard_regno_max_nregs;
+
/* For each hard register, the widest mode object that it can contain.
This will be a MODE_INT mode if the register can hold integers. Otherwise
it will be a MODE_FLOAT or a MODE_CC mode, whichever is valid for the
@@ -235,6 +238,8 @@ extern struct target_regs *this_target_regs;
#else
#define this_target_regs (&default_target_regs)
#endif
+#define hard_regno_max_nregs \
+ (this_target_regs->x_hard_regno_max_nregs)
#define reg_raw_mode \
(this_target_regs->x_reg_raw_mode)
#define have_regs_of_mode \
diff --git a/gcc/targhooks.cc b/gcc/targhooks.cc
index fc49235eb38..e22bc66a6c8 100644
--- a/gcc/targhooks.cc
+++ b/gcc/targhooks.cc
@@ -1017,6 +1017,45 @@ default_function_value_regno_p (const unsigned int regno ATTRIBUTE_UNUSED)
#endif
}
+/* Choose the mode and rtx to use to zero REGNO, storing tem in PMODE and
+ PREGNO_RTX and returning TRUE if successful, otherwise returning FALSE. If
+ the natural mode for REGNO doesn't work, attempt to group it with subsequent
+ adjacent registers set in TOZERO. */
+
+static inline bool
+zcur_select_mode_rtx (unsigned int regno, machine_mode *pmode,
+ rtx *pregno_rtx, HARD_REG_SET tozero)
+{
+ rtx regno_rtx = regno_reg_rtx[regno];
+ machine_mode mode = GET_MODE (regno_rtx);
+
+ /* If the natural mode doesn't work, try some wider mode. */
+ if (!targetm.hard_regno_mode_ok (regno, mode))
+ {
+ bool found = false;
+ for (int nregs = 2;
+ !found && nregs <= hard_regno_max_nregs
+ && regno + nregs <= FIRST_PSEUDO_REGISTER
+ && TEST_HARD_REG_BIT (tozero,
+ regno + nregs - 1);
+ nregs++)
+ {
+ mode = choose_hard_reg_mode (regno, nregs, 0);
+ if (mode == E_VOIDmode)
+ continue;
+ gcc_checking_assert (targetm.hard_regno_mode_ok (regno, mode));
+ regno_rtx = gen_rtx_REG (mode, regno);
+ found = true;
+ }
+ if (!found)
+ return false;
+ }
+
+ *pmode = mode;
+ *pregno_rtx = regno_rtx;
+ return true;
+}
+
/* The default hook for TARGET_ZERO_CALL_USED_REGS. */
HARD_REG_SET
@@ -1035,16 +1074,28 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
if (TEST_HARD_REG_BIT (need_zeroed_hardregs, regno))
{
rtx_insn *last_insn = get_last_insn ();
- machine_mode mode = GET_MODE (regno_reg_rtx[regno]);
+ rtx regno_rtx;
+ machine_mode mode;
+
+ if (!zcur_select_mode_rtx (regno, &mode, ®no_rtx,
+ need_zeroed_hardregs))
+ {
+ SET_HARD_REG_BIT (failed, regno);
+ continue;
+ }
+
rtx zero = CONST0_RTX (mode);
- rtx_insn *insn = emit_move_insn (regno_reg_rtx[regno], zero);
+ rtx_insn *insn = emit_move_insn (regno_rtx, zero);
if (!valid_insn_p (insn))
{
SET_HARD_REG_BIT (failed, regno);
delete_insns_since (last_insn);
}
else
- progress = true;
+ {
+ progress = true;
+ regno += hard_regno_nregs (regno, mode) - 1;
+ }
}
/* Now retry with copies from zeroed registers, as long as we've
@@ -1060,7 +1111,18 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (retrying, regno))
{
- machine_mode mode = GET_MODE (regno_reg_rtx[regno]);
+ rtx regno_rtx;
+ machine_mode mode;
+
+ /* This might select registers we've already zeroed. If grouping
+ with them is what it takes to get regno zeroed, so be it. */
+ if (!zcur_select_mode_rtx (regno, &mode, ®no_rtx,
+ need_zeroed_hardregs))
+ {
+ SET_HARD_REG_BIT (failed, regno);
+ continue;
+ }
+
bool success = false;
/* Look for a source. */
for (unsigned int src = 0; src < FIRST_PSEUDO_REGISTER; src++)
@@ -1086,8 +1148,8 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
/* SRC is usable, try to copy from it. */
rtx_insn *last_insn = get_last_insn ();
- rtx zsrc = gen_rtx_REG (mode, src);
- rtx_insn *insn = emit_move_insn (regno_reg_rtx[regno], zsrc);
+ rtx src_rtx = gen_rtx_REG (mode, src);
+ rtx_insn *insn = emit_move_insn (regno_rtx, src_rtx);
if (!valid_insn_p (insn))
/* It didn't work, remove any inserts. We'll look
for another SRC. */
@@ -1100,13 +1162,16 @@ default_zero_call_used_regs (HARD_REG_SET need_zeroed_hardregs)
}
}
- /* If nothing worked for REGNO this round, marked it to be
+ /* If nothing worked for REGNO this round, mark it to be
retried if we get another round. */
if (!success)
SET_HARD_REG_BIT (failed, regno);
else
- /* Take note so as to enable another round if needed. */
- progress = true;
+ {
+ /* Take note so as to enable another round if needed. */
+ progress = true;
+ regno += hard_regno_nregs (regno, mode) - 1;
+ }
}
}
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2022-04-05 0:45 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-04-01 5:48 [gcc(refs/users/aoliva/heads/testme)] try multi-reg dest in default_zero_call_used_regs Alexandre Oliva
2022-04-05 0:45 Alexandre Oliva
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).