[Bug rtl-optimization/111267] [14 Regression] Codegen regression from i386 argument passing changes

["jakub at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=111267

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |segher at gcc dot gnu.org

--- Comment #5 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Slightly cleaned up testcase:
struct S { float a, b, c, d; };

int
foo (struct S x, struct S y)
{
  return x.a <= y.c && x.b <= y.d && x.c >= y.a && x.c >= y.a;
}

int
bar (struct S x, struct S y)
{
  return x.b <= y.d && x.c >= y.a;
}

I think the pattern be using reg_overlap_mentioned_p, register_operand doesn't
really guarantee the operand is REG_P on which REGNO can be used.

So something like:
--- gcc/config/i386/i386.md.jj  2024-01-03 12:01:11.649644854 +0100
+++ gcc/config/i386/i386.md     2024-01-12 16:24:10.806783889 +0100
@@ -13347,6 +13347,27 @@
   DONE;
 }
   [(set_attr "isa" "*,nox64,x64,*")])
+
+;; Extract from concat
+
+(define_insn_and_split "*extv<dwi><mode>2_concat"
+  [(set (match_operand:DWIH 0 "register_operand")
+       (match_operand:DWIH 1 "register_operand"))
+   (set (match_operand:<DWI> 2 "register_operand")
+       (any_or_plus:<DWI>
+         (ashift:<DWI>
+           (zero_extend:<DWI> (match_operand:DWIH 3 "register_operand"))
+           (match_operand:QI 4 "const_scalar_int_operand"))
+         (zero_extend:<DWI> (match_operand:DWIH 5 "register_operand"))))]
+  "INTVAL (operands[4]) == <MODE_SIZE> * BITS_PER_UNIT
+   && !reg_overlap_mentioned_p (operands[0], operands[3])
+   && !reg_overlap_mentioned_p (operands[0], operands[5])"
+  "#"
+  "&& 1"
+  [(set (match_dup 0) (match_dup 1))
+   (set (match_dup 2) (ior:<DWI> (ashift:<DWI> (zero_extend:<DWI> (match_dup
3))
+                                              (match_dup 4))
+                                (zero_extend:<DWI> (match_dup 5))))])


 ;; Negation instructions

Note, while that improves the generated code for the first function (almost but
not 100% to what GCC 13 emitted), the second function still results in much
larger code than before.
Bet it would be even better if we could just define_split the pattern instead
of define_insn_and_split, but unfortunately this is a 2 insn combination and
that doesn't allow to be split into 2 new instructions.