https://gcc.gnu.org/g:03eaf93f337ac456eec16b294c68c8f9d1950eb9

commit r17-6011-g03eaf93f337ac456eec16b294c68c8f9d1950eb9
Author: Stefan Schulze Frielinghaus <[email protected]>
Date:   Sat Nov 7 09:38:20 2026 +0100

    s390: Fix operand setup in vec_perm expanders and add V8HF support
    
    In a Sashiko review it was pointed out that in
    expand_perm_as_a_vlbr_vstbr_candidate, d.target and d.op0 were wrapped
    with gen_rtx_SUBREG before emitting bswap / rotate insn.  Since
    targetm.vectorize.vec_perm_const is invoked in expand_vec_perm_const
    before operands are forced into registers, d.op0 is not guaranteed to be
    a REG.  Blindly wrapping d.op0 with gen_rtx_SUBREG creates invalid RTL
    (such as nested subregs, subregs of constant vectors, or subregs of
    memory).  Furthermore, wrapping d.target in a subreg generates
    ill-formed RTL.
    
    Fixed by simplifying subregs with simplify_gen_subreg, falling back to
    force_reg on d.op0 if necessary, and expanding the instruction via
    expand_insn with create_output_operand and create_input_operand to
    properly legitimize operands matching predicates.
    
    Similarly, in expand_perm_reverse_elements, use expand_insn to ensure
    operands match predicates, handle V1TFmode, return false instead of
    calling gcc_unreachable() for unsupported modes, and add support for
    V8HFmode.
    
    In expand_perm_with_merge, ensure simplify_gen_subreg cannot fail by
    forcing input operands into registers.
    
    Furthermore, extend halfword merge and element-swap support to V8HFmode
    in vector.md by introducing the V_HW_H mode iterator, adding HF vector
    modes to vec_2x_nelts, and parameterizing *vmrhh, *vmrlh, and
    eltswap<mode> with V_HW_H.
    
    gcc/ChangeLog:
    
            * config/s390/s390.cc (expand_perm_as_a_vlbr_vstbr_candidate): Use
            simplify_gen_subreg and expand_insn instead of gen_rtx_SUBREG.
            (expand_perm_reverse_elements): Ditto.
            (expand_perm_with_merge): Force input operands into registers.
            * config/s390/vector.md (V_HW_H): New mode iterator for V8HI and 
V8HF.
            (vec_2x_nelts): Add mappings for V1HF, V2HF, V4HF, and V8HF.
            (*vmrhh, *vmrlh): Use V_HW_H and vec_2x_nelts.
            (eltswapv8hi): Rename to eltswap<mode> and use V_HW_H.
    
    gcc/testsuite/ChangeLog:
    
            * gcc.target/s390/vector/vperm-rev-1.c: New test.

Diff:
---
 gcc/config/s390/s390.cc                            | 109 ++--
 gcc/config/s390/vector.md                          |  30 +-
 gcc/testsuite/gcc.target/s390/vector/vperm-rev-1.c | 662 +++++++++++++++++++++
 3 files changed, 740 insertions(+), 61 deletions(-)

diff --git a/gcc/config/s390/s390.cc b/gcc/config/s390/s390.cc
index eee99624797b..8dee816806ea 100644
--- a/gcc/config/s390/s390.cc
+++ b/gcc/config/s390/s390.cc
@@ -17978,6 +17978,10 @@ expand_perm_with_merge (const struct expand_vec_perm_d 
&d)
       op0 = d.op0;
       op1 = d.op1;
     }
+
+  op0 = force_reg (d.vmode, op0);
+  op1 = force_reg (d.vmode, op1);
+
   if (mergemode != d.vmode)
     {
       target = simplify_gen_subreg (mergemode, target, d.vmode, 0);
@@ -18137,21 +18141,34 @@ expand_perm_reverse_elements (const struct 
expand_vec_perm_d &d)
   if (d.op0 != d.op1 || !is_reverse_perm_mask (d))
     return false;
 
-  if (d.testing_p)
-    return true;
-
+  insn_code icode;
   switch (d.vmode)
     {
-    case V1TImode: emit_move_insn (d.target, d.op0); break;
-    case V2DImode: emit_insn (gen_eltswapv2di (d.target, d.op0)); break;
-    case V4SImode: emit_insn (gen_eltswapv4si (d.target, d.op0)); break;
-    case V8HImode: emit_insn (gen_eltswapv8hi (d.target, d.op0)); break;
-    case V16QImode: emit_insn (gen_eltswapv16qi (d.target, d.op0)); break;
-    case V2DFmode: emit_insn (gen_eltswapv2df (d.target, d.op0)); break;
-    case V4SFmode: emit_insn (gen_eltswapv4sf (d.target, d.op0)); break;
-    default: gcc_unreachable();
+    case V1TImode:
+    case V1TFmode:
+      if (!d.testing_p)
+       emit_move_insn (d.target, d.op0);
+      return true;
+    case V2DImode: icode = CODE_FOR_eltswapv2di; break;
+    case V4SImode: icode = CODE_FOR_eltswapv4si; break;
+    case V8HImode: icode = CODE_FOR_eltswapv8hi; break;
+    case V16QImode: icode = CODE_FOR_eltswapv16qi; break;
+    case V2DFmode: icode = CODE_FOR_eltswapv2df; break;
+    case V4SFmode: icode = CODE_FOR_eltswapv4sf; break;
+    case V8HFmode: icode = CODE_FOR_eltswapv8hf; break;
+    default: return false;
     }
 
+  if (d.testing_p)
+    return true;
+
+  class expand_operand ops[2];
+  create_output_operand (&ops[0], d.target, d.vmode);
+  create_input_operand (&ops[1], d.op0, d.vmode);
+  expand_insn (icode, 2, ops);
+  if (!rtx_equal_p (ops[0].value, d.target))
+    emit_move_insn (d.target, ops[0].value);
+
   return true;
 }
 
@@ -18173,56 +18190,54 @@ expand_perm_as_a_vlbr_vstbr_candidate (const struct 
expand_vec_perm_d &d)
   if (d.vmode != V16QImode || d.op0 != d.op1)
     return false;
 
+  insn_code icode;
+  machine_mode mode;
+
   /* For halfwords a byte-swap is a rotate by 8 bits (verllh), which does not
      require VXE2.  */
   if (memcmp (d.perm, perm[0], MAX_VECT_LEN) == 0)
     {
-      if (!d.testing_p)
-       {
-         rtx target = gen_rtx_SUBREG (V8HImode, d.target, 0);
-         rtx op0 = gen_rtx_SUBREG (V8HImode, d.op0, 0);
-         emit_insn (gen_bswapv8hi (target, op0));
-       }
-      return true;
+      mode = V8HImode;
+      icode = CODE_FOR_bswapv8hi;
     }
-
-  if (!TARGET_VXE2)
+  /* All remaining operations require VXE2.  */
+  else if (!TARGET_VXE2)
     return false;
-
-  if (memcmp (d.perm, perm[1], MAX_VECT_LEN) == 0)
+  else if (memcmp (d.perm, perm[1], MAX_VECT_LEN) == 0)
     {
-      if (!d.testing_p)
-       {
-         rtx target = gen_rtx_SUBREG (V4SImode, d.target, 0);
-         rtx op0 = gen_rtx_SUBREG (V4SImode, d.op0, 0);
-         emit_insn (gen_bswapv4si (target, op0));
-       }
-      return true;
+      mode = V4SImode;
+      icode = CODE_FOR_bswapv4si;
     }
-
-  if (memcmp (d.perm, perm[2], MAX_VECT_LEN) == 0)
+  else if (memcmp (d.perm, perm[2], MAX_VECT_LEN) == 0)
     {
-      if (!d.testing_p)
-       {
-         rtx target = gen_rtx_SUBREG (V2DImode, d.target, 0);
-         rtx op0 = gen_rtx_SUBREG (V2DImode, d.op0, 0);
-         emit_insn (gen_bswapv2di (target, op0));
-       }
-      return true;
+      mode = V2DImode;
+      icode = CODE_FOR_bswapv2di;
+    }
+  else if (memcmp (d.perm, perm[3], MAX_VECT_LEN) == 0)
+    {
+      mode = V1TImode;
+      icode = CODE_FOR_bswapv1ti;
     }
+  else
+    return false;
 
-  if (memcmp (d.perm, perm[3], MAX_VECT_LEN) == 0)
+  if (!d.testing_p)
     {
-      if (!d.testing_p)
-       {
-         rtx target = gen_rtx_SUBREG (V1TImode, d.target, 0);
-         rtx op0 = gen_rtx_SUBREG (V1TImode, d.op0, 0);
-         emit_insn (gen_bswapv1ti (target, op0));
-       }
-      return true;
+      rtx target = simplify_gen_subreg (mode, d.target, d.vmode, 0);
+      rtx op0 = simplify_gen_subreg (mode, d.op0, d.vmode, 0);
+      if (op0 == NULL_RTX)
+       op0
+         = simplify_gen_subreg (mode, force_reg (d.vmode, d.op0), d.vmode, 0);
+
+      class expand_operand ops[2];
+      create_output_operand (&ops[0], target, mode);
+      create_input_operand (&ops[1], op0, mode);
+      expand_insn (icode, 2, ops);
+      if (!rtx_equal_p (ops[0].value, target))
+       emit_move_insn (target, ops[0].value);
     }
 
-  return false;
+  return true;
 }
 
 static bool
diff --git a/gcc/config/s390/vector.md b/gcc/config/s390/vector.md
index 500cb0b59615..65bd61e6f8d9 100644
--- a/gcc/config/s390/vector.md
+++ b/gcc/config/s390/vector.md
@@ -44,6 +44,7 @@
 (define_mode_iterator VT_HW_SDT [V4SI V4SF V2DI V2DF V1TI V1TF TI TF])
 (define_mode_iterator V_HW_HSD [V8HI V4SI (V4SF "TARGET_VXE") V2DI V2DF])
 (define_mode_iterator V_HW_SD [V4SI (V4SF "TARGET_VXE") V2DI V2DF])
+(define_mode_iterator V_HW_H [V8HI V8HF])
 
 ; Including TI for instructions that support it (va, vn, ...)
 (define_mode_iterator VT_HW [V16QI V8HI V4SI V2DI V2DF V1TI TI (V4SF 
"TARGET_VXE") (V1TF "TARGET_VXE")])
@@ -227,6 +228,7 @@
                                (V1HI "V2HI") (V2HI "V4HI") (V4HI "V8HI") (V8HI 
"V16HI")
                                (V1SI "V2SI") (V2SI "V4SI") (V4SI "V8SI")
                                (V1DI "V2DI") (V2DI "V4DI")
+                               (V1HF "V2HF") (V2HF "V4HF") (V4HF "V8HF") (V8HF 
"V16HF")
                                (V1SF "V2SF") (V2SF "V4SF") (V4SF "V8SF")
                                (V1DF "V2DF") (V2DF "V4DF")])
 
@@ -1049,10 +1051,10 @@
   [(set_attr "op_type" "VRR")])
 
 (define_insn "*vmrhh"
-  [(set (match_operand:V8HI                     0 "register_operand" "=v")
-        (vec_select:V8HI
-         (vec_concat:V16HI (match_operand:V8HI 1 "register_operand"  "v")
-                           (match_operand:V8HI 2 "register_operand"  "v"))
+  [(set (match_operand:V_HW_H                              0 
"register_operand" "=v")
+        (vec_select:V_HW_H
+         (vec_concat:<vec_2x_nelts> (match_operand:V_HW_H 1 "register_operand" 
 "v")
+                                    (match_operand:V_HW_H 2 "register_operand" 
 "v"))
          (parallel [(const_int 0) (const_int 8)
                     (const_int 1) (const_int 9)
                     (const_int 2) (const_int 10)
@@ -1062,10 +1064,10 @@
   [(set_attr "op_type" "VRR")])
 
 (define_insn "*vmrlh"
-  [(set (match_operand:V8HI                     0 "register_operand" "=v")
-        (vec_select:V8HI
-         (vec_concat:V16HI (match_operand:V8HI 1 "register_operand"  "v")
-                           (match_operand:V8HI 2 "register_operand"  "v"))
+  [(set (match_operand:V_HW_H                              0 
"register_operand" "=v")
+        (vec_select:V_HW_H
+         (vec_concat:<vec_2x_nelts> (match_operand:V_HW_H 1 "register_operand" 
 "v")
+                                    (match_operand:V_HW_H 2 "register_operand" 
 "v"))
          (parallel [(const_int 4) (const_int 12)
                     (const_int 5) (const_int 13)
                     (const_int 6) (const_int 14)
@@ -1222,12 +1224,12 @@
   [(set_attr "cpu_facility" "*,vxe2,vxe2")
    (set_attr "op_type" "*,VRX,VRX")])
 
-;; VECTOR REVERSE ELEMENTS V8HI
+;; VECTOR REVERSE ELEMENTS V8HI / V8HF
 
-(define_insn_and_split "eltswapv8hi"
-  [(set (match_operand:V8HI  0 "nonimmediate_operand" "=v,R,v")
-       (vec_select:V8HI
-        (match_operand:V8HI 1 "nonimmediate_operand"  "v,v,R")
+(define_insn_and_split "eltswap<mode>"
+  [(set (match_operand:V_HW_H  0 "nonimmediate_operand" "=v,R,v")
+       (vec_select:V_HW_H
+        (match_operand:V_HW_H 1 "nonimmediate_operand"  "v,v,R")
         (parallel [(const_int 7)
                    (const_int 6)
                    (const_int 5)
@@ -1261,7 +1263,7 @@
         (match_dup 3)
         (const_int 16)))
    (set (match_dup 0)
-       (subreg:V8HI (match_dup 3) 0))]
+       (subreg:<MODE> (match_dup 3) 0))]
   ""
   [(set_attr "cpu_facility" "*,vxe2,vxe2")
    (set_attr "op_type" "*,VRX,VRX")])
diff --git a/gcc/testsuite/gcc.target/s390/vector/vperm-rev-1.c 
b/gcc/testsuite/gcc.target/s390/vector/vperm-rev-1.c
new file mode 100644
index 000000000000..f2e6422a5dc3
--- /dev/null
+++ b/gcc/testsuite/gcc.target/s390/vector/vperm-rev-1.c
@@ -0,0 +1,662 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -march=z13" } */
+/* { dg-final { check-function-bodies "**" "" "" } } */
+
+typedef signed char v16qi __attribute__ ((vector_size (16)));
+typedef short v8hi __attribute__ ((vector_size (16)));
+typedef int v4si __attribute__ ((vector_size (16)));
+typedef long v2di __attribute__ ((vector_size (16)));
+typedef __int128 v1ti __attribute__ ((vector_size (16)));
+
+typedef _Float16 v8hf __attribute__ ((vector_size (16)));
+typedef float v4sf __attribute__ ((vector_size (16)));
+typedef double v2df __attribute__ ((vector_size (16)));
+typedef long double v1tf __attribute__ ((vector_size (16)));
+
+/* INTEGER */
+
+/*
+** rev_v16qi_rr:
+**     larl    (%r[0-9]+),.L[0-9]+
+**     vl      (%v[0-9]+),.L[0-9]+-.L[0-9]+\(\1\),3
+**     vperm   %v24,%v24,%v24,\2
+**     br      %r14
+*/
+
+v16qi
+rev_v16qi_rr (v16qi x)
+{
+  v16qi m = { 15, 14, 13, 12, 11, 10, 9, 8,
+               7,  6,  5,  4,  3,  2, 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v16qi_rm:
+**     larl    %r[0-9]+,.L[0-9]+
+**     vl      .*
+**     vl      .*
+**     vperm   %v24,.*
+**     br      %r14
+*/
+
+v16qi
+rev_v16qi_rm (v16qi *x)
+{
+  v16qi m = { 15, 14, 13, 12, 11, 10, 9, 8,
+               7,  6,  5,  4,  3,  2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v16qi_rm_z15:
+**     vlbrq   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v16qi
+rev_v16qi_rm_z15 (v16qi *x)
+{
+  v16qi m = { 15, 14, 13, 12, 11, 10, 9, 8,
+               7,  6,  5,  4,  3,  2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v16qi_mr:
+**     larl    (%r[0-9]+),.L[0-9]+
+**     vl      (%v[0-9]+),.L[0-9]+-.L[0-9]+\(\1\),3
+**     vperm   (%v[0-9]+),%v24,%v24,\2
+**     vst     \3,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v16qi_mr (v16qi *x, v16qi y)
+{
+  v16qi m = { 15, 14, 13, 12, 11, 10, 9, 8,
+               7,  6,  5,  4,  3,  2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v16qi_mr_z15:
+**     vstbrq  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v16qi_mr_z15 (v16qi *x, v16qi y)
+{
+  v16qi m = { 15, 14, 13, 12, 11, 10, 9, 8,
+               7,  6,  5,  4,  3,  2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v8hi_rr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  (%v[0-9]+),\1,32
+**     verllf  %v24,\2,16
+**     br      %r14
+*/
+
+v8hi
+rev_v8hi_rr (v8hi x)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v8hi_rm:
+**     vl      (%v[0-9]+),0\(%r2\),3
+**     vpdi    (%v[0-9]+),\1,\1,4
+**     verllg  (%v[0-9]+),\2,32
+**     verllf  %v24,\3,16
+**     br      %r14
+*/
+
+v8hi
+rev_v8hi_rm (v8hi *x)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v8hi_rm_z15:
+**     vlerh   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v8hi
+rev_v8hi_rm_z15 (v8hi *x)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v8hi_mr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  (%v[0-9]+),\1,32
+**     verllf  (%v[0-9]+),\2,16
+**     vst     \3,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v8hi_mr (v8hi *x, v8hi y)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v8hi_mr_z15:
+**     vsterh  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v8hi_mr_z15 (v8hi *x, v8hi y)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v4si_rr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  %v24,\1,32
+**     br      %r14
+*/
+
+v4si
+rev_v4si_rr (v4si x)
+{
+  v4si m = { 3, 2, 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v4si_rm:
+**     vl      (%v[0-9]+),0\(%r2\),3
+**     vpdi    (%v[0-9]+),\1,\1,4
+**     verllg  %v24,\2,32
+**     br      %r14
+*/
+
+v4si
+rev_v4si_rm (v4si *x)
+{
+  v4si m = { 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v4si_rm_z15:
+**     vlerf   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v4si
+rev_v4si_rm_z15 (v4si *x)
+{
+  v4si m = { 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v4si_mr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  (%v[0-9]+),\1,32
+**     vst     \2,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v4si_mr (v4si *x, v4si y)
+{
+  v4si m = { 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v4si_mr_z15:
+**     vsterf  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v4si_mr_z15 (v4si *x, v4si y)
+{
+  v4si m = { 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v2di_rr:
+**     vpdi    %v24,%v24,%v24,4
+**     br      %r14
+*/
+
+v2di
+rev_v2di_rr (v2di x)
+{
+  v2di m = { 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v2di_rm:
+**     vl      (%v[0-9]+),0\(%r2\),3
+**     vpdi    %v24,\1,\1,4
+**     br      %r14
+*/
+
+v2di
+rev_v2di_rm (v2di *x)
+{
+  v2di m = { 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v2di_rm_z15:
+**     vlerg   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v2di
+rev_v2di_rm_z15 (v2di *x)
+{
+  v2di m = { 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v2di_mr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     vst     \1,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v2di_mr (v2di *x, v2di y)
+{
+  v2di m = { 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v2di_mr_z15:
+**     vsterg  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v2di_mr_z15 (v2di *x, v2di y)
+{
+  v2di m = { 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v1ti_rr:
+**     br      %r14
+*/
+
+v1ti
+rev_v1ti_rr (v1ti x)
+{
+  v1ti m = { 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v1ti_rm:
+**     vl      %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+v1ti
+rev_v1ti_rm (v1ti *x)
+{
+  v1ti m = { 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v1ti_rm_z15:
+**     vl      %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v1ti
+rev_v1ti_rm_z15 (v1ti *x)
+{
+  v1ti m = { 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v1ti_mr:
+**     vst     %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v1ti_mr (v1ti *x, v1ti y)
+{
+  v1ti m = { 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v1ti_mr_z15:
+**     vst     %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v1ti_mr_z15 (v1ti *x, v1ti y)
+{
+  v1ti m = { 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/* FLOAT */
+
+/*
+** rev_v8hf_rr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  (%v[0-9]+),\1,32
+**     verllf  %v24,\2,16
+**     br      %r14
+*/
+
+v8hf
+rev_v8hf_rr (v8hf x)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v8hf_rm:
+**     vl      (%v[0-9]+),0\(%r2\),3
+**     vpdi    (%v[0-9]+),\1,\1,4
+**     verllg  (%v[0-9]+),\2,32
+**     verllf  %v24,\3,16
+**     br      %r14
+*/
+
+v8hf
+rev_v8hf_rm (v8hf *x)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v8hf_rm_z15:
+**     vlerh   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v8hf
+rev_v8hf_rm_z15 (v8hf *x)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v8hf_mr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  (%v[0-9]+),\1,32
+**     verllf  (%v[0-9]+),\2,16
+**     vst     \3,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v8hf_mr (v8hf *x, v8hf y)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v8hf_mr_z15:
+**     vsterh  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v8hf_mr_z15 (v8hf *x, v8hf y)
+{
+  v8hi m = { 7, 6, 5, 4, 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v4sf_rr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  %v24,\1,32
+**     br      %r14
+*/
+
+v4sf
+rev_v4sf_rr (v4sf x)
+{
+  v4si m = { 3, 2, 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v4sf_rm:
+**     vl      (%v[0-9]+),0\(%r2\),3
+**     vpdi    (%v[0-9]+),\1,\1,4
+**     verllg  %v24,\2,32
+**     br      %r14
+*/
+
+v4sf
+rev_v4sf_rm (v4sf *x)
+{
+  v4si m = { 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v4sf_rm_z15:
+**     vlerf   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v4sf
+rev_v4sf_rm_z15 (v4sf *x)
+{
+  v4si m = { 3, 2, 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v4sf_mr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     verllg  (%v[0-9]+),\1,32
+**     vst     \2,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v4sf_mr (v4sf *x, v4sf y)
+{
+  v4si m = { 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v4sf_mr_z15:
+**     vsterf  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v4sf_mr_z15 (v4sf *x, v4sf y)
+{
+  v4si m = { 3, 2, 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v2df_rr:
+**     vpdi    %v24,%v24,%v24,4
+**     br      %r14
+*/
+
+v2df
+rev_v2df_rr (v2df x)
+{
+  v2di m = { 1, 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v2df_rm:
+**     vl      (%v[0-9]+),0\(%r2\),3
+**     vpdi    %v24,\1,\1,4
+**     br      %r14
+*/
+
+v2df
+rev_v2df_rm (v2df *x)
+{
+  v2di m = { 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v2df_rm_z15:
+**     vlerg   %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v2df
+rev_v2df_rm_z15 (v2df *x)
+{
+  v2di m = { 1, 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v2df_mr:
+**     vpdi    (%v[0-9]+),%v24,%v24,4
+**     vst     \1,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v2df_mr (v2df *x, v2df y)
+{
+  v2di m = { 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v2df_mr_z15:
+**     vsterg  %v24,0\(%r2\)
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v2df_mr_z15 (v2df *x, v2df y)
+{
+  v2di m = { 1, 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v1tf_rr:
+**     br      %r14
+*/
+
+v1tf
+rev_v1tf_rr (v1tf x)
+{
+  v1ti m = { 0 };
+  return __builtin_shuffle (x, m);
+}
+
+/*
+** rev_v1tf_rm:
+**     vl      %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+v1tf
+rev_v1tf_rm (v1tf *x)
+{
+  v1ti m = { 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v1tf_rm_z15:
+**     vl      %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+v1tf
+rev_v1tf_rm_z15 (v1tf *x)
+{
+  v1ti m = { 0 };
+  return __builtin_shuffle (*x, m);
+}
+
+/*
+** rev_v1tf_mr:
+**     vst     %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+void
+rev_v1tf_mr (v1tf *x, v1tf y)
+{
+  v1ti m = { 0 };
+  *x = __builtin_shuffle (y, m);
+}
+
+/*
+** rev_v1tf_mr_z15:
+**     vst     %v24,0\(%r2\),3
+**     br      %r14
+*/
+
+__attribute__ ((target ("arch=z15")))
+void
+rev_v1tf_mr_z15 (v1tf *x, v1tf y)
+{
+  v1ti m = { 0 };
+  *x = __builtin_shuffle (y, m);
+}

Reply via email to