================
@@ -822,13 +819,97 @@ let Predicates = [HasSVE_or_SME] in {
     def : Pat<(VT (int_aarch64_sve_and (PT (SVEAllActive)), VT:$a,
                     (VT (int_aarch64_sve_not (VT srcvalue), (PT 
(SVEAllActive)), VT:$b)))),
               (BIC_ZZZ $a, $b)>;
+
+    // ===== AND-XOR patterns =====
+
+    // Lanes inactive in EOR may be replaced by a & ~b in result.
+    def : Pat<(and VT:$a, (SVEEorU (PT srcvalue), VT:$a, VT:$b)),
+              (BIC_ZZZ $a, $b)>;
+
+    // Inactive lanes in AND or EOR may be replaced by a & ~b.
+    def : Pat<(VT (SVEAndU (PT srcvalue), VT:$a,
+                    (VT (SVEEorU (PT srcvalue), VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Similarly, for normal LLVM XOR.
+    def : Pat<(VT (SVEAndU (PT srcvalue), VT:$a, (xor VT:$a, VT:$b))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Matching predicate ensures that the active lanes in EOR can be
+    // replaced by a & ~b.
+    def : Pat<(VT (SVEAndU PT:$pg, VT:$a,
+                    (VT (AArch64eor_m1 PT:$pg, VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Similarly, for _z form of EOR.
+    def : Pat<(VT (SVEAndU PT:$pg, VT:$a,
+                    (VT (SVEEorZ PT:$pg, VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // AllActive predicate in EOR ensures that the active lane in the
+    // result is a & ~b.
+    def : Pat<(VT (SVEAndU (PT srcvalue), VT:$a,
+                (VT (AArch64eor_m1 (PT (SVEAllActive)), VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Similarly, for _z form of EOR.
+    def : Pat<(VT (SVEAndU (PT srcvalue), VT:$a,
+                    (VT (SVEEorZ (PT (SVEAllActive)), VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // ===== XOR-AND patterns =====
+
+    // Lanes inactive in AND may be replaced by a & ~b in result.
+    def : Pat<(xor VT:$a, (SVEAndU (PT srcvalue), VT:$a, VT:$b)),
+              (BIC_ZZZ $a, $b)>;
+
+    // Inactive lanes in EOR or AND may be replaced by a & ~b.
+    def : Pat<(VT (SVEEorU (PT srcvalue), VT:$a,
+                    (VT (SVEAndU (PT srcvalue), VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Similarly, for normal LLVM AND.
+    def : Pat<(VT (SVEEorU (PT srcvalue), VT:$a, (and VT:$a, VT:$b))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Matching predicate ensures that the active lanes in EOR can be
+    // replaced by a & ~b.
+    def : Pat<(VT (SVEEorU PT:$pg, VT:$a,
+                    (VT (AArch64and_m1 PT:$pg, VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Similarly, for _z form of AND.
+    def : Pat<(VT (SVEEorU PT:$pg, VT:$a,
+                    (VT (SVEAndZ PT:$pg, VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // AllActive predicate in AND node ensures that the active lane
+    // in the result may be replaced by a & ~b.
+    def : Pat<(VT (SVEEorU (PT srcvalue), VT:$a,
+                (VT (AArch64and_m1 (PT (SVEAllActive)), VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
+
+    // Similarly, for _z form of AND.
+    def : Pat<(VT (SVEEorU (PT srcvalue), VT:$a,
+                    (VT (SVEAndZ (PT (SVEAllActive)), VT:$a, VT:$b)))),
+              (BIC_ZZZ $a, $b)>;
   }
-  defm : SVEMergingAndNotPats<nxv16i8, nxv16i1, BIC_ZPmZ_B>;
-  defm : SVEMergingAndNotPats<nxv8i16, nxv8i1, BIC_ZPmZ_H>;
-  defm : SVEMergingAndNotPats<nxv4i32, nxv4i1, BIC_ZPmZ_S>;
-  defm : SVEMergingAndNotPats<nxv2i64, nxv2i1, BIC_ZPmZ_D>;
+  defm : sve_log_bic_pats<nxv16i8, nxv16i1, BIC_ZPmZ_B>;
+  defm : sve_log_bic_pats<nxv8i16, nxv8i1, BIC_ZPmZ_H>;
+  defm : sve_log_bic_pats<nxv4i32, nxv4i1, BIC_ZPmZ_S>;
+  defm : sve_log_bic_pats<nxv2i64, nxv2i1, BIC_ZPmZ_D>;
 } // End HasSVE_or_SME
 
+let Predicates = [HasSVE_or_SME] in {
+  // Fallback patterns for predicated AND and EOR nodes.
+  foreach I = !range(0, 4) in {
+    defvar VT = [nxv16i8, nxv8i16, nxv4i32, nxv2i64][I];
+    defvar PT = [nxv16i1, nxv8i1, nxv4i1, nxv2i1][I];
+    def : Pat<(VT (AArch64and_p (PT srcvalue), VT:$a, VT:$b)), (AND_ZZZ $a, 
$b)>;
+    def : Pat<(VT (AArch64eor_p (PT srcvalue), VT:$a, VT:$b)), (EOR_ZZZ $a, 
$b)>;
----------------
CarolineConcatto wrote:

BTW I think we should not use (PT srcvalue), but SVEAnyPredicate

https://github.com/llvm/llvm-project/pull/238442
_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to