On Tue, May 18, 2021 at 9:16 PM H.J. Lu <hjl.to...@gmail.com> wrote: > > Add TARGET_READ_MEMSET_VALUE and TARGET_GEN_MEMSET_VALUE to support > target instructions to duplicate QImode value to TImode/OImode/XImode > value for memmset. > > PR middle-end/90773 > * builtins.c (builtin_memset_read_str): Call > targetm.read_memset_value. > (builtin_memset_gen_str): Call targetm.gen_memset_value. > * target.def (read_memset_value): New hook. > (gen_memset_value): Likewise. > * targhooks.c: Inclue "builtins.h". > (default_read_memset_value): New function. > (default_gen_memset_value): Likewise. > * targhooks.h (default_read_memset_value): New prototype. > (default_gen_memset_value): Likewise. > * doc/tm.texi.in: Add TARGET_READ_MEMSET_VALUE and > TARGET_GEN_MEMSET_VALUE hooks. > * doc/tm.texi: Regenerated. > --- > gcc/builtins.c | 47 ++++---------------------------------- > gcc/doc/tm.texi | 16 +++++++++++++ > gcc/doc/tm.texi.in | 4 ++++ > gcc/target.def | 20 +++++++++++++++++ > gcc/targhooks.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++ > gcc/targhooks.h | 4 ++++ > 6 files changed, 104 insertions(+), 43 deletions(-) > > diff --git a/gcc/builtins.c b/gcc/builtins.c > index e1b284846b1..f78a36478ef 100644 > --- a/gcc/builtins.c > +++ b/gcc/builtins.c > @@ -6584,24 +6584,11 @@ expand_builtin_strncpy (tree exp, rtx target) > previous iteration. */ > > rtx > -builtin_memset_read_str (void *data, void *prevp, > +builtin_memset_read_str (void *data, void *prev, > HOST_WIDE_INT offset ATTRIBUTE_UNUSED, > scalar_int_mode mode) > { > - by_pieces_prev *prev = (by_pieces_prev *) prevp; > - if (prev != nullptr && prev->data != nullptr) > - { > - /* Use the previous data in the same mode. */ > - if (prev->mode == mode) > - return prev->data; > - } > - > - const char *c = (const char *) data; > - char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode)); > - > - memset (p, *c, GET_MODE_SIZE (mode)); > - > - return c_readstr (p, mode); > + return targetm.read_memset_value ((const char *) data, prev, mode); > } > > /* Callback routine for store_by_pieces. Return the RTL of a register > @@ -6611,37 +6598,11 @@ builtin_memset_read_str (void *data, void *prevp, > nullptr, it has the RTL info from the previous iteration. */ > > static rtx > -builtin_memset_gen_str (void *data, void *prevp, > +builtin_memset_gen_str (void *data, void *prev, > HOST_WIDE_INT offset ATTRIBUTE_UNUSED, > scalar_int_mode mode) > { > - rtx target, coeff; > - size_t size; > - char *p; > - > - by_pieces_prev *prev = (by_pieces_prev *) prevp; > - if (prev != nullptr && prev->data != nullptr) > - { > - /* Use the previous data in the same mode. */ > - if (prev->mode == mode) > - return prev->data; > - > - target = simplify_gen_subreg (mode, prev->data, prev->mode, 0); > - if (target != nullptr) > - return target; > - } > - > - size = GET_MODE_SIZE (mode); > - if (size == 1) > - return (rtx) data; > - > - p = XALLOCAVEC (char, size); > - memset (p, 1, size); > - coeff = c_readstr (p, mode); > - > - target = convert_to_mode (mode, (rtx) data, 1); > - target = expand_mult (mode, target, coeff, NULL_RTX, 1); > - return force_reg (mode, target); > + return targetm.gen_memset_value ((rtx) data, prev, mode); > } > > /* Expand expression EXP, which is a call to the memset builtin. Return > diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi > index 85ea9395560..51385044e76 100644 > --- a/gcc/doc/tm.texi > +++ b/gcc/doc/tm.texi > @@ -11868,6 +11868,22 @@ This function prepares to emit a conditional > comparison within a sequence > @var{bit_code} is @code{AND} or @code{IOR}, which is the op on the compares. > @end deftypefn > > +@deftypefn {Target Hook} rtx TARGET_READ_MEMSET_VALUE (const char *@var{c}, > void *@var{prev}, scalar_int_mode @var{mode}) > +This function returns the RTL of a constant integer corresponding to > +target reading @code{GET_MODE_SIZE (@var{mode})} bytes from the stringn > +constant @var{str}. If @var{prev} is not @samp{nullptr}, it contains > +the RTL information from the previous interation. > +@end deftypefn > + > +@deftypefn {Target Hook} rtx TARGET_GEN_MEMSET_VALUE (rtx @var{data}, void > *@var{prev}, scalar_int_mode @var{mode}) > +This function returns the RTL of a register containing > +@code{GET_MODE_SIZE (@var{mode})} consecutive copies of the unsigned > +char value given in the RTL register @var{data}. For example, if > +@var{mode} is 4 bytes wide, return the RTL for 0x01010101*@var{data}. > +If @var{PREV} is not @samp{nullptr}, it is the RTL information from > +the previous iteration. > +@end deftypefn > + > @deftypefn {Target Hook} unsigned TARGET_LOOP_UNROLL_ADJUST (unsigned > @var{nunroll}, class loop *@var{loop}) > This target hook returns a new value for the number of times @var{loop} > should be unrolled. The parameter @var{nunroll} is the number of times > diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in > index d8e3de14af1..8d4c3949fbf 100644 > --- a/gcc/doc/tm.texi.in > +++ b/gcc/doc/tm.texi.in > @@ -7956,6 +7956,10 @@ lists. > > @hook TARGET_GEN_CCMP_NEXT > > +@hook TARGET_READ_MEMSET_VALUE > + > +@hook TARGET_GEN_MEMSET_VALUE > + > @hook TARGET_LOOP_UNROLL_ADJUST > > @defmac POWI_MAX_MULTS > diff --git a/gcc/target.def b/gcc/target.def > index bbaf6b4f3a0..c9aca40fa88 100644 > --- a/gcc/target.def > +++ b/gcc/target.def > @@ -2694,6 +2694,26 @@ DEFHOOK > rtx, (rtx_insn **prep_seq, rtx_insn **gen_seq, rtx prev, int cmp_code, tree > op0, tree op1, int bit_code), > NULL) > > +DEFHOOK > +(read_memset_value, > + "This function returns the RTL of a constant integer corresponding to\n\ > +target reading @code{GET_MODE_SIZE (@var{mode})} bytes from the stringn\n\ > +constant @var{str}. If @var{prev} is not @samp{nullptr}, it contains\n\
where is 'str' defined? I can't really tell what's the difference from read_memset_value and gen_memset_value. Somehow I feel that an optab for the "splat" operation similar to vec_duplicate might be a better way to expose this - of course that doesn't handle the "prev" thing. So how's this the right point of abstraction to the target? > +the RTL information from the previous interation.", > + rtx, (const char *c, void *prev, scalar_int_mode mode), > + default_read_memset_value) > + > +DEFHOOK > +(gen_memset_value, > + "This function returns the RTL of a register containing\n\ > +@code{GET_MODE_SIZE (@var{mode})} consecutive copies of the unsigned\n\ > +char value given in the RTL register @var{data}. For example, if\n\ > +@var{mode} is 4 bytes wide, return the RTL for 0x01010101*@var{data}.\n\ > +If @var{PREV} is not @samp{nullptr}, it is the RTL information from\n\ > +the previous iteration.", > + rtx, (rtx data, void *prev, scalar_int_mode mode), > + default_gen_memset_value) > + > /* Return a new value for loop unroll size. */ > DEFHOOK > (loop_unroll_adjust, > diff --git a/gcc/targhooks.c b/gcc/targhooks.c > index 1947ef26fd6..b55e6ec6756 100644 > --- a/gcc/targhooks.c > +++ b/gcc/targhooks.c > @@ -90,6 +90,7 @@ along with GCC; see the file COPYING3. If not see > #include "attribs.h" > #include "asan.h" > #include "emit-rtl.h" > +#include "builtins.h" > > bool > default_legitimate_address_p (machine_mode mode ATTRIBUTE_UNUSED, > @@ -2627,4 +2628,59 @@ default_memtag_untagged_pointer (rtx tagged_pointer, > rtx target) > return untagged_base; > } > > +/* Default implementation of TARGET_READ_MEMSET_VALUE. */ > + > +rtx > +default_read_memset_value (const char *c, void *prevp, > + scalar_int_mode mode) > +{ > + by_pieces_prev *prev = (by_pieces_prev *) prevp; > + if (prev != nullptr && prev->data != nullptr) > + { > + /* Use the previous data in the same mode. */ > + if (prev->mode == mode) > + return prev->data; > + } > + > + char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode)); > + > + memset (p, *c, GET_MODE_SIZE (mode)); > + > + return c_readstr (p, mode); > +} > + > +/* Default implementation of TARGET_GEN_MEMSET_VALUE. */ > + > +rtx > +default_gen_memset_value (rtx data, void *prevp, scalar_int_mode mode) > +{ > + rtx target, coeff; > + size_t size; > + char *p; > + > + by_pieces_prev *prev = (by_pieces_prev *) prevp; > + if (prev != nullptr && prev->data != nullptr) > + { > + /* Use the previous data in the same mode. */ > + if (prev->mode == mode) > + return prev->data; > + > + target = simplify_gen_subreg (mode, prev->data, prev->mode, 0); > + if (target != nullptr) > + return target; > + } > + > + size = GET_MODE_SIZE (mode); > + if (size == 1) > + return data; > + > + p = XALLOCAVEC (char, size); > + memset (p, 1, size); > + coeff = c_readstr (p, mode); > + > + target = convert_to_mode (mode, data, 1); > + target = expand_mult (mode, target, coeff, NULL_RTX, 1); > + return force_reg (mode, target); > +} > + > #include "gt-targhooks.h" > diff --git a/gcc/targhooks.h b/gcc/targhooks.h > index b537038c0aa..3c00927e196 100644 > --- a/gcc/targhooks.h > +++ b/gcc/targhooks.h > @@ -300,4 +300,8 @@ extern rtx default_memtag_set_tag (rtx, rtx, rtx); > extern rtx default_memtag_extract_tag (rtx, rtx); > extern rtx default_memtag_untagged_pointer (rtx, rtx); > > +extern rtx default_read_memset_value (const char *, void *, > + scalar_int_mode); > +extern rtx default_gen_memset_value (rtx, void *, scalar_int_mode); > + > #endif /* GCC_TARGHOOKS_H */ > -- > 2.31.1 >