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); +}
