https://gcc.gnu.org/g:fd476c1abf45fcb96b42db91ac1b12b7f16ea3b2

commit r17-5975-gfd476c1abf45fcb96b42db91ac1b12b7f16ea3b2
Author: Robin Dapp <[email protected]>
Date:   Thu Oct 29 14:58:43 2026 +0100

    vect: Query target vec_extract via perm.
    
    This makes can_vec_extract call the new function vec_extract_perm_p
    and replaces the vectorizer's vec_extract optab checks with it.
    That way it is mostly in sync with what we can actually expand.
    The patch passes a dummy extraction index because we don't know the
    final index yet.
    
    A side effect of using can_vec_extract instead of a direct check is that
    we perform type punning a bit earlier now in vectorizable_store.  This
    leads to slightly different codegen in one case where we had
    
       (set (reg:DI 123) (vec_select:DI (subreg:V2DI (reg:V4SI 121) 0) ...))
       (set (mem:DI ...) (reg:DI 123))
    
    before but now get
    
      (set (reg:DI 125) (vec_select:DI (subreg:V2DI (reg:V4SI 109) 0) ...))
      (set (mem:V2SI ...) (subreg:V2SI (reg:DI 125) 0))
    
    The latter is not recognized as direct DImode store.  This is a
    scalar/vector corner case and could be fixed at the target level as well
    as by an RTL optimization.  In order not to change too much I made
    can_vec_extract's scalar punning explicit by having it return the
    extract mode.
    
    gcc/ChangeLog:
    
            * optabs-query.cc (vec_extract_perm_p): New function
            * (can_vec_extract): Query vec_extract_perm_p and return
            extract mode.
            * optabs-query.h (can_vec_extract): Change return type.
            (vec_extract_perm_p): Declare.
            * tree-vect-loop.cc (vect_find_reusable_accumulator): Use
            can_vec_extract.
            (vect_create_partial_epilog): Likewise.
            * tree-vect-stmts.cc (vectorizable_store): Likewise.

Diff:
---
 gcc/optabs-query.cc    | 69 ++++++++++++++++++++++++++++++++++++++++++--------
 gcc/optabs-query.h     |  4 ++-
 gcc/tree-vect-loop.cc  | 17 ++++++-------
 gcc/tree-vect-stmts.cc |  8 ++----
 4 files changed, 71 insertions(+), 27 deletions(-)

diff --git a/gcc/optabs-query.cc b/gcc/optabs-query.cc
index da0d37cf5df3..a9474bc6312d 100644
--- a/gcc/optabs-query.cc
+++ b/gcc/optabs-query.cc
@@ -792,33 +792,80 @@ supports_vec_scatter_store_p (machine_mode mode)
   return this_fn_optabs->supports_vec_scatter_store[mode] > 0;
 }
 
+/* See if we can extract a vector of mode SUBVEC_MODE from a larger vector
+   of mode VEC_MODE at EXTRACT_IDX.  EXTRACT_IDX counts in elements
+   of VEC_MODE and SUBVEC_MODE.  If we can, return the possibly punned
+   input mode.  */
+
+opt_machine_mode
+vec_extract_perm_p (machine_mode vec_mode, machine_mode subvec_mode,
+                   poly_uint64 extract_idx)
+{
+  if (!VECTOR_MODE_P (vec_mode) || !VECTOR_MODE_P (subvec_mode))
+    return opt_machine_mode ();
+
+  if (GET_MODE_UNIT_SIZE (vec_mode) != GET_MODE_UNIT_SIZE (subvec_mode))
+    return opt_machine_mode ();
+
+  if (maybe_gt (GET_MODE_NUNITS (subvec_mode) + extract_idx,
+               GET_MODE_NUNITS (vec_mode)))
+    return opt_machine_mode ();
+
+  /* Look for a matching mode for the vector elements.
+     Do not pun the whole vector with a mode of different element size
+     here (e.g. V2DI and V4SI).  We expect a target to do that itself.  */
+  if (GET_MODE_INNER (vec_mode) != GET_MODE_INNER (subvec_mode)
+      && !related_vector_mode (vec_mode, GET_MODE_INNER (subvec_mode),
+                              GET_MODE_NUNITS (vec_mode)).exists
+          (&vec_mode))
+    return opt_machine_mode ();
+
+  poly_uint64 out_nunits = GET_MODE_NUNITS (subvec_mode);
+  poly_uint64 in_nunits = GET_MODE_NUNITS (vec_mode);
+
+  vec_perm_builder sel (out_nunits, 1, 3);
+  for (unsigned int i = 0; i < 3; ++i)
+    sel.quick_push (extract_idx + i);
+
+  vec_perm_indices indices (sel, 1, in_nunits);
+  if (can_vec_perm_const_p (subvec_mode, vec_mode, indices))
+    return vec_mode;
+  return opt_machine_mode ();
+}
+
+
 /* Whether we can extract part of the vector mode MODE as
-   (scalar or vector) mode EXTR_MODE.  */
+   (scalar or vector) mode EXTR_MODE.  Returns the extraction mode
+   we would use or no mode.  */
 
-bool
+opt_machine_mode
 can_vec_extract (machine_mode mode, machine_mode extr_mode)
 {
   unsigned m;
   if (!VECTOR_MODE_P (mode)
       || !constant_multiple_p (GET_MODE_SIZE (mode),
                               GET_MODE_SIZE (extr_mode), &m))
-    return false;
+    return opt_machine_mode ();
 
   if (convert_optab_handler (vec_extract_optab, mode, extr_mode)
       != CODE_FOR_nothing)
-    return true;
+    return extr_mode;
 
   /* Besides a direct vec_extract we can also use an element extract from
      an integer vector mode with elements of the size of the extr_mode.  */
   scalar_int_mode imode;
   machine_mode vmode;
-  if (!int_mode_for_size (GET_MODE_BITSIZE (extr_mode), 0).exists (&imode)
-      || !related_vector_mode (mode, imode, m).exists (&vmode)
-      || (convert_optab_handler (vec_extract_optab, vmode, imode)
-         == CODE_FOR_nothing))
-    return false;
-  /* We assume we can pun mode to vmode and imode to extr_mode.  */
-  return true;
+  if (int_mode_for_size (GET_MODE_BITSIZE (extr_mode), 0).exists (&imode)
+      && related_vector_mode (mode, imode, m).exists (&vmode)
+      && (convert_optab_handler (vec_extract_optab, vmode, imode)
+         != CODE_FOR_nothing))
+    return imode;
+
+  /* We don't know yet where exactly to extract from, just use element 0.  */
+  if (vec_extract_perm_p (mode, extr_mode, 0).exists ())
+    return extr_mode;
+
+  return opt_machine_mode ();
 }
 
 /* OP is either neg_optab or abs_optab and FMODE is the floating-point inner
diff --git a/gcc/optabs-query.h b/gcc/optabs-query.h
index faa688a06095..3a5842d82c26 100644
--- a/gcc/optabs-query.h
+++ b/gcc/optabs-query.h
@@ -173,7 +173,9 @@ bool supports_vec_gather_load_p (machine_mode = E_VOIDmode,
 bool supports_vec_scatter_store_p (machine_mode = E_VOIDmode);
 opt_machine_mode get_absneg_bit_mode (optab, machine_mode,
                                      scalar_float_mode, int *);
-bool can_vec_extract (machine_mode, machine_mode);
+
+opt_machine_mode vec_extract_perm_p (machine_mode, machine_mode, poly_uint64);
+opt_machine_mode can_vec_extract (machine_mode, machine_mode);
 bool can_open_code_p (optab, machine_mode);
 bool can_implement_p (optab, machine_mode);
 
diff --git a/gcc/tree-vect-loop.cc b/gcc/tree-vect-loop.cc
index 07fef37f320f..26563e61dc1a 100644
--- a/gcc/tree-vect-loop.cc
+++ b/gcc/tree-vect-loop.cc
@@ -5231,7 +5231,10 @@ vect_find_reusable_accumulator (loop_vec_info loop_vinfo,
          || !directly_supported_p (VECT_REDUC_INFO_CODE (reduc_info),
                                    intermediate_vectype)
          || !can_vec_extract (TYPE_MODE (prev_vectype),
-                              TYPE_MODE (intermediate_vectype)))
+                              TYPE_MODE (intermediate_vectype)).exists ()
+         /* We could actually extract VLA vectors but bit_field_ref and
+            friends aren't yet prepared for it.  */
+         || !TYPE_VECTOR_SUBPARTS (intermediate_vectype).is_constant ())
        return false;
       prev_vectype = intermediate_vectype;
     }
@@ -5291,10 +5294,8 @@ vect_create_partial_epilog (tree vec_def, tree vectype, 
code_helper code,
         an integer mode punning.  */
       tree dst1, dst2;
       gimple *epilog_stmt;
-      if (convert_optab_handler (vec_extract_optab,
-                                TYPE_MODE (TREE_TYPE (new_temp)),
-                                TYPE_MODE (vectype1))
-         != CODE_FOR_nothing)
+      if (can_vec_extract (TYPE_MODE (TREE_TYPE (new_temp)),
+                          TYPE_MODE (vectype1)).exists ())
        {
          /* Extract sub-vectors directly once vec_extract becomes
             a conversion optab.  */
@@ -5319,10 +5320,8 @@ vect_create_partial_epilog (tree vec_def, tree vectype, 
code_helper code,
             vector.  */
          tree eltype = build_nonstandard_integer_type (bitsize, 1);
          tree etype = build_vector_type (eltype, 2);
-         gcc_assert (convert_optab_handler (vec_extract_optab,
-                                            TYPE_MODE (etype),
-                                            TYPE_MODE (eltype))
-                     != CODE_FOR_nothing);
+         gcc_assert (can_vec_extract (TYPE_MODE (etype),
+                                      TYPE_MODE (eltype)).exists ());
          tree tem = make_ssa_name (etype);
          epilog_stmt = gimple_build_assign (tem, VIEW_CONVERT_EXPR,
                                             build1 (VIEW_CONVERT_EXPR,
diff --git a/gcc/tree-vect-stmts.cc b/gcc/tree-vect-stmts.cc
index f08152009e2a..7a4596c337cd 100644
--- a/gcc/tree-vect-stmts.cc
+++ b/gcc/tree-vect-stmts.cc
@@ -8552,9 +8552,7 @@ vectorizable_store (vec_info *vinfo,
          if (!VECTOR_MODE_P (TYPE_MODE (vectype))
              || !related_vector_mode (TYPE_MODE (vectype), elmode,
                                       n).exists (&vmode)
-             || (convert_optab_handler (vec_extract_optab,
-                                        TYPE_MODE (vectype), vmode)
-                 == CODE_FOR_nothing)
+             || can_vec_extract (TYPE_MODE (vectype), vmode) != vmode
              || !(dr_align == dr_aligned
                   || dr_align == dr_unaligned_supported))
            {
@@ -8572,9 +8570,7 @@ vectorizable_store (vec_info *vinfo,
                  && VECTOR_MODE_P (TYPE_MODE (vectype))
                  && related_vector_mode (TYPE_MODE (vectype), elmode,
                                          lnunits).exists (&vmode)
-                 && (convert_optab_handler (vec_extract_optab,
-                                            vmode, elmode)
-                     != CODE_FOR_nothing))
+                 && can_vec_extract (vmode, elmode).exists ())
                {
                  nstores = lnunits;
                  lnel = n;

Reply via email to