[PATCH v2 1/3] bpf: TARGET_RTX_COSTS: don't synthesize trivial multiply

[Jose E. Marchesi]

OK, thanks.

> The default cost of MULT/DIV/MOD in rtx_cost () is high: 5,7 insns
> respectively. This causes even a trivial mpy by 7 to be synthesized.
> Given these have direct equivalents in BPF ISA, fix the cost to generate
> native BPF insns.
>
> Note the existing divmod-licall-2.c test was a bit fragile as it forced
> cast signed an actual unsigned int which is provably non-negative. In
> the new cost model compiler would generate a native unsigned divide
> not available for -mcpu=v3, tripping up the test. Fix by ensuring the
> arg is actually signed.
>
> gcc/ChangeLog:
>
> 	* config/bpf/bpf.cc (bpf_rtx_costs): Assign MPY/DIV/MOD cost 1.
>
> gcc/testsuite/ChangeLog:
>
> 	* gcc.target/bpf/divmod-libcall-2.c: Change args/ret to signed.
> 	* gcc.target/bpf/mult-large.c: New test.
> 	* gcc.target/bpf/mult-small.c: New test.
>
> Signed-off-by: Vineet Gupta <vineet.gupta@linux.dev>
> ---
>  gcc/config/bpf/bpf.cc                         | 24 ++++++++++++++++---
>  .../gcc.target/bpf/divmod-libcall-2.c         | 15 +++++++-----
>  gcc/testsuite/gcc.target/bpf/mult-large.c     | 22 +++++++++++++++++
>  gcc/testsuite/gcc.target/bpf/mult-small.c     | 20 ++++++++++++++++
>  4 files changed, 72 insertions(+), 9 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.target/bpf/mult-large.c
>  create mode 100644 gcc/testsuite/gcc.target/bpf/mult-small.c
>
> diff --git a/gcc/config/bpf/bpf.cc b/gcc/config/bpf/bpf.cc
> index 89a4917cd0a0..58d2318f972b 100644
> --- a/gcc/config/bpf/bpf.cc
> +++ b/gcc/config/bpf/bpf.cc
> @@ -602,14 +602,32 @@ bpf_legitimate_address_p (machine_mode mode,
>     `rtx_cost' should recurse.  */
>  
>  static bool
> -bpf_rtx_costs (rtx x ATTRIBUTE_UNUSED,
> +bpf_rtx_costs (rtx x,
>  	       enum machine_mode mode ATTRIBUTE_UNUSED,
>  	       int outer_code ATTRIBUTE_UNUSED,
>  	       int opno ATTRIBUTE_UNUSED,
> -               int *total ATTRIBUTE_UNUSED,
> +	       int *total,
>  	       bool speed ATTRIBUTE_UNUSED)
>  {
> -  /* To be written.  */
> +  switch (GET_CODE (x))
> +    {
> +    case MULT:
> +    case DIV:
> +    case UDIV:
> +    case MOD:
> +    case UMOD:
> +      /* BPF implements these as a single instruction, so keep the native
> +	 operation cheaper than synthesized sequence.
> +	 Only influences choice between actually available alternatives;
> +	 if the operation has no insn (e.g. a 64-bit signed divide before
> +	 -mcpu=v4) expand_divmod () still falls back to a libcall.
> +	 Return false so caller rtx_cost keeps recursing for operands.  */
> +      *total = COSTS_N_INSNS (1);
> +      return false;
> +
> +    default:
> +      return false;
> +    }
>    return false;
>  }
>  
> diff --git a/gcc/testsuite/gcc.target/bpf/divmod-libcall-2.c b/gcc/testsuite/gcc.target/bpf/divmod-libcall-2.c
> index 792d689395a2..7296579171d2 100644
> --- a/gcc/testsuite/gcc.target/bpf/divmod-libcall-2.c
> +++ b/gcc/testsuite/gcc.target/bpf/divmod-libcall-2.c
> @@ -1,16 +1,19 @@
> +/* Inverse of divmod-libcall-1.c. Ensure libcalls are generated for
> +   -mcpu=v3 due to lack of signed div/mod.  */
> +
>  /* { dg-do compile } */
>  /* { dg-options "-O2 -mcpu=v3" } */
>  /* { dg-final { scan-assembler "global\t__divdi3" } } */
>  /* { dg-final { scan-assembler "global\t__moddi3" } } */
>  
> -int
> -foo (unsigned int len)
> +long
> +foo (long len)
>  {
> -  return ((long)len) * 234 / 5;
> +  return len * 234 / 5;
>  }
>  
> -int
> -bar (unsigned int len)
> +long
> +bar (long len)
>  {
> -  return ((long)len) * 234 % 5;
> +  return len * 234 % 5;
>  }
> diff --git a/gcc/testsuite/gcc.target/bpf/mult-large.c b/gcc/testsuite/gcc.target/bpf/mult-large.c
> new file mode 100644
> index 000000000000..4a5ef5da2b15
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/bpf/mult-large.c
> @@ -0,0 +1,22 @@
> +/* The multiply core of memset-4.c: a memset of a non-constant value
> +   broadcasts a byte across the word with "x * 0x01010101".  With the generic
> +   COSTS_N_INSNS (5) multiply cost this large-constant multiply was
> +   strength-reduced into a shift/add sequence; BPF has a single-instruction
> +   mul, so the native mul must be used instead.
> +
> +   Use a full 32-bit input (not 'unsigned char'): for a byte 'x * 0x01010101'
> +   equals the carry-free broadcast 'x | x<<8 | x<<16 | x<<24', which the
> +   compiler could lower without a multiply at all, weakening the test.  A
> +   32-bit input has no such equivalence, so this is a genuine multiply.  */
> +
> +/* { dg-do compile } */
> +/* { dg-options "-O2" } */
> +
> +unsigned
> +bcast (unsigned x)
> +{
> +  return x * 0x01010101u;
> +}
> +
> +/* { dg-final { scan-assembler {\*= 16843009} } } */
> +/* { dg-final { scan-assembler-not {<<=} } } */
> diff --git a/gcc/testsuite/gcc.target/bpf/mult-small.c b/gcc/testsuite/gcc.target/bpf/mult-small.c
> new file mode 100644
> index 000000000000..7c82f3276266
> --- /dev/null
> +++ b/gcc/testsuite/gcc.target/bpf/mult-small.c
> @@ -0,0 +1,20 @@
> +/* Verify that a multiply by a small constant uses BPF's native single
> +   instruction mul rather than a synthesized shift/add(-sub) sequence.
> +
> +   BPF has a single-instruction multiply, so "x * 7" should be "r0 *= 7",
> +   not the strength-reduced "(x << 3) - x".  synth_mult () only avoids the
> +   native multiply when it finds a cheaper sequence, so the rtx_cost hook
> +   must report MULT as a single instruction (rather than the generic
> +   COSTS_N_INSNS (5) schoolbook default) for the native op to win.  */
> +
> +/* { dg-do compile } */
> +/* { dg-options "-O2 -mcpu=v4" } */
> +
> +unsigned
> +mul7 (unsigned x)
> +{
> +  return x * 7;
> +}
> +
> +/* { dg-final { scan-assembler {\*= 7} } } */
> +/* { dg-final { scan-assembler-not {<<=} } } */