https://gcc.gnu.org/g:c6ed1bc38b17d650ae678b7cac28ce8c2692eb09
commit c6ed1bc38b17d650ae678b7cac28ce8c2692eb09
Author: Jeff Law <j...@ventanamicro.com>
Date: Mon May 13 17:37:46 2024 -0600
[to-be-committed,RISC-V] Improve AND with some constants
If we have an AND with a constant operand and the constant operand
requires synthesis, then we may be able to generate more efficient code
than we do now.
Essentially the need for constant synthesis gives us a budget for
alternative ways to clear bits, which zext.w can do for bits 32..63
trivially. So if we clear 32..63 via zext.w, the constant for the
remaining bits to clear may be simple enough to use with andi or bseti.
That will save us an instruction.
This has tested in Ventana's CI system as well as my own. I'll wait for
the upstream CI tester to report success before committing.
Jeff
gcc/
* config/riscv/bitmanip.md: Add new splitter for AND with
a constant that masks off bits 32..63 and needs synthesis.
gcc/testsuite/
* gcc.target/riscv/zba_zbs_and-1.c: New test.
(cherry picked from commit 158aa1b65ce29d5e58182782de66292c51774d71)
Diff:
---
gcc/config/riscv/bitmanip.md | 34 ++++++++++++++++++++++++++
gcc/testsuite/gcc.target/riscv/zba_zbs_and-1.c | 22 +++++++++++++++++
2 files changed, 56 insertions(+)
diff --git a/gcc/config/riscv/bitmanip.md b/gcc/config/riscv/bitmanip.md
index 724511b6df3b..8769a6b818b7 100644
--- a/gcc/config/riscv/bitmanip.md
+++ b/gcc/config/riscv/bitmanip.md
@@ -843,6 +843,40 @@
}
[(set_attr "type" "bitmanip")])
+;; If we have the ZBA extension, then we can clear the upper half of a 64
+;; bit object with a zext.w. So if we have AND where the constant would
+;; require synthesis of two or more instructions, but 32->64 sign extension
+;; of the constant is a simm12, then we can use zext.w+andi. If the adjusted
+;; constant is a single bit constant, then we can use zext.w+bclri
+;;
+;; With the mvconst_internal pattern claiming a single insn to synthesize
+;; constants, this must be a define_insn_and_split.
+(define_insn_and_split ""
+ [(set (match_operand:DI 0 "register_operand" "=r")
+ (and:DI (match_operand:DI 1 "register_operand" "r")
+ (match_operand 2 "const_int_operand" "n")))]
+ "TARGET_64BIT
+ && TARGET_ZBA
+ && !paradoxical_subreg_p (operands[1])
+ /* Only profitable if synthesis takes more than one insn. */
+ && riscv_const_insns (operands[2]) != 1
+ /* We need the upper half to be zero. */
+ && (INTVAL (operands[2]) & HOST_WIDE_INT_C (0xffffffff00000000)) == 0
+ /* And the the adjusted constant must either be something we can
+ implement with andi or bclri. */
+ && ((SMALL_OPERAND (sext_hwi (INTVAL (operands[2]), 32))
+ || (TARGET_ZBS && popcount_hwi (INTVAL (operands[2])) == 31))
+ && INTVAL (operands[2]) != 0x7fffffff)"
+ "#"
+ "&& 1"
+ [(set (match_dup 0) (zero_extend:DI (match_dup 3)))
+ (set (match_dup 0) (and:DI (match_dup 0) (match_dup 2)))]
+ "{
+ operands[3] = gen_lowpart (SImode, operands[1]);
+ operands[2] = GEN_INT (sext_hwi (INTVAL (operands[2]), 32));
+ }"
+ [(set_attr "type" "bitmanip")])
+
;; IF_THEN_ELSE: test for 2 bits of opposite polarity
(define_insn_and_split "*branch<X:mode>_mask_twobits_equals_singlebit"
[(set (pc)
diff --git a/gcc/testsuite/gcc.target/riscv/zba_zbs_and-1.c
b/gcc/testsuite/gcc.target/riscv/zba_zbs_and-1.c
new file mode 100644
index 000000000000..23fd769449ea
--- /dev/null
+++ b/gcc/testsuite/gcc.target/riscv/zba_zbs_and-1.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-march=rv64gc_zba_zbb_zbs -mabi=lp64" } */
+/* { dg-skip-if "" { *-*-* } { "-O0" "-Og" } } */
+
+
+unsigned long long w32mem_1(unsigned long long w32)
+{
+ return w32 & ~(1U << 0);
+}
+
+unsigned long long w32mem_2(unsigned long long w32)
+{
+ return w32 & ~(1U << 30);
+}
+
+unsigned long long w32mem_3(unsigned long long w32)
+{
+ return w32 & ~(1U << 31);
+}
+
+/* If we do synthesis, then we'd see an addi. */
+/* { dg-final { scan-assembler-not "addi\t" } } */
