On Thu, 26 Jun 2014, Jakub Jelinek wrote:
> On Thu, Jun 26, 2014 at 01:16:41PM +0200, Marc Glisse wrote:
> > >+ if (compute_type == TREE_TYPE (type)
> > >+ && !VECTOR_INTEGER_TYPE_P (TREE_TYPE (rhs2)))
> > >+ {
> > >+ optab oplv, opl, oprv, opr, opo;
> > >+ oplv = optab_for_tree_code (LSHIFT_EXPR, type, optab_vector);
> > >+ /* Right shift always has to be logical, no matter what
> > >+ signedness type has. */
> > >+ oprv = vlshr_optab;
> > >+ opo = optab_for_tree_code (BIT_IOR_EXPR, type, optab_default);
> > >+ opl = optab_for_tree_code (LSHIFT_EXPR, type, optab_scalar);
> > >+ oprv = lshr_optab;
> > >+ opr = optab_for_tree_code (RSHIFT_EXPR, type, optab_scalar);
> >
> > Looks like there are some typos in there, you are assigning to oprv twice.
>
> Oops, fixed thusly.
Ok.
Thanks,
Richard.
> 2014-06-25 Jakub Jelinek <ja...@redhat.com>
>
> PR tree-optimization/57233
> PR tree-optimization/61299
> * tree-vect-generic.c (get_compute_type, count_type_subparts): New
> functions.
> (expand_vector_operations_1): Use them. If {L,R}ROTATE_EXPR
> would be lowered to scalar shifts, check if corresponding
> shifts and vector BIT_IOR_EXPR are supported and don't lower
> or lower just to narrower vector type in that case.
> * expmed.c (expand_shift_1): Fix up handling of vector
> shifts and rotates.
>
> * gcc.dg/pr57233.c: New test.
> * gcc.target/i386/pr57233.c: New test.
> * gcc.target/i386/sse2-pr57233.c: New test.
> * gcc.target/i386/avx-pr57233.c: New test.
> * gcc.target/i386/avx2-pr57233.c: New test.
> * gcc.target/i386/avx512f-pr57233.c: New test.
> * gcc.target/i386/xop-pr57233.c: New test.
>
> --- gcc/tree-vect-generic.c.jj 2014-06-26 11:00:00.477268305 +0200
> +++ gcc/tree-vect-generic.c 2014-06-26 13:33:33.024069715 +0200
> @@ -1334,15 +1334,67 @@ lower_vec_perm (gimple_stmt_iterator *gs
> update_stmt (gsi_stmt (*gsi));
> }
>
> +/* Return type in which CODE operation with optab OP can be
> + computed. */
> +
> +static tree
> +get_compute_type (enum tree_code code, optab op, tree type)
> +{
> + /* For very wide vectors, try using a smaller vector mode. */
> + tree compute_type = type;
> + if (op
> + && (!VECTOR_MODE_P (TYPE_MODE (type))
> + || optab_handler (op, TYPE_MODE (type)) == CODE_FOR_nothing))
> + {
> + tree vector_compute_type
> + = type_for_widest_vector_mode (TREE_TYPE (type), op);
> + if (vector_compute_type != NULL_TREE
> + && (TYPE_VECTOR_SUBPARTS (vector_compute_type)
> + < TYPE_VECTOR_SUBPARTS (compute_type))
> + && (optab_handler (op, TYPE_MODE (vector_compute_type))
> + != CODE_FOR_nothing))
> + compute_type = vector_compute_type;
> + }
> +
> + /* If we are breaking a BLKmode vector into smaller pieces,
> + type_for_widest_vector_mode has already looked into the optab,
> + so skip these checks. */
> + if (compute_type == type)
> + {
> + enum machine_mode compute_mode = TYPE_MODE (compute_type);
> + if (VECTOR_MODE_P (compute_mode))
> + {
> + if (op && optab_handler (op, compute_mode) != CODE_FOR_nothing)
> + return compute_type;
> + if (code == MULT_HIGHPART_EXPR
> + && can_mult_highpart_p (compute_mode,
> + TYPE_UNSIGNED (compute_type)))
> + return compute_type;
> + }
> + /* There is no operation in hardware, so fall back to scalars. */
> + compute_type = TREE_TYPE (type);
> + }
> +
> + return compute_type;
> +}
> +
> +/* Helper function of expand_vector_operations_1. Return number of
> + vector elements for vector types or 1 for other types. */
> +
> +static inline int
> +count_type_subparts (tree type)
> +{
> + return VECTOR_TYPE_P (type) ? TYPE_VECTOR_SUBPARTS (type) : 1;
> +}
> +
> /* Process one statement. If we identify a vector operation, expand it. */
>
> static void
> expand_vector_operations_1 (gimple_stmt_iterator *gsi)
> {
> gimple stmt = gsi_stmt (*gsi);
> - tree lhs, rhs1, rhs2 = NULL, type, compute_type;
> + tree lhs, rhs1, rhs2 = NULL, type, compute_type = NULL_TREE;
> enum tree_code code;
> - enum machine_mode compute_mode;
> optab op = unknown_optab;
> enum gimple_rhs_class rhs_class;
> tree new_rhs;
> @@ -1455,11 +1507,76 @@ expand_vector_operations_1 (gimple_stmt_
> {
> op = optab_for_tree_code (code, type, optab_scalar);
>
> + compute_type = get_compute_type (code, op, type);
> + if (compute_type == type)
> + return;
> /* The rtl expander will expand vector/scalar as vector/vector
> - if necessary. Don't bother converting the stmt here. */
> - if (optab_handler (op, TYPE_MODE (type)) == CODE_FOR_nothing
> - && optab_handler (opv, TYPE_MODE (type)) != CODE_FOR_nothing)
> + if necessary. Pick one with wider vector type. */
> + tree compute_vtype = get_compute_type (code, opv, type);
> + if (count_type_subparts (compute_vtype)
> + > count_type_subparts (compute_type))
> + {
> + compute_type = compute_vtype;
> + op = opv;
> + }
> + }
> +
> + if (code == LROTATE_EXPR || code == RROTATE_EXPR)
> + {
> + if (compute_type == NULL_TREE)
> + compute_type = get_compute_type (code, op, type);
> + if (compute_type == type)
> return;
> + /* Before splitting vector rotates into scalar rotates,
> + see if we can't use vector shifts and BIT_IOR_EXPR
> + instead. For vector by vector rotates we'd also
> + need to check BIT_AND_EXPR and NEGATE_EXPR, punt there
> + for now, fold doesn't seem to create such rotates anyway. */
> + if (compute_type == TREE_TYPE (type)
> + && !VECTOR_INTEGER_TYPE_P (TREE_TYPE (rhs2)))
> + {
> + optab oplv = vashl_optab, opl = ashl_optab;
> + optab oprv = vlshr_optab, opr = lshr_optab, opo = ior_optab;
> + tree compute_lvtype = get_compute_type (LSHIFT_EXPR, oplv, type);
> + tree compute_rvtype = get_compute_type (RSHIFT_EXPR, oprv, type);
> + tree compute_otype = get_compute_type (BIT_IOR_EXPR, opo, type);
> + tree compute_ltype = get_compute_type (LSHIFT_EXPR, opl, type);
> + tree compute_rtype = get_compute_type (RSHIFT_EXPR, opr, type);
> + /* The rtl expander will expand vector/scalar as vector/vector
> + if necessary. Pick one with wider vector type. */
> + if (count_type_subparts (compute_lvtype)
> + > count_type_subparts (compute_ltype))
> + {
> + compute_ltype = compute_lvtype;
> + opl = oplv;
> + }
> + if (count_type_subparts (compute_rvtype)
> + > count_type_subparts (compute_rtype))
> + {
> + compute_rtype = compute_rvtype;
> + opr = oprv;
> + }
> + /* Pick the narrowest type from LSHIFT_EXPR, RSHIFT_EXPR and
> + BIT_IOR_EXPR. */
> + compute_type = compute_ltype;
> + if (count_type_subparts (compute_type)
> + > count_type_subparts (compute_rtype))
> + compute_type = compute_rtype;
> + if (count_type_subparts (compute_type)
> + > count_type_subparts (compute_otype))
> + compute_type = compute_otype;
> + /* Verify all 3 operations can be performed in that type. */
> + if (compute_type != TREE_TYPE (type))
> + {
> + if (optab_handler (opl, TYPE_MODE (compute_type))
> + == CODE_FOR_nothing
> + || optab_handler (opr, TYPE_MODE (compute_type))
> + == CODE_FOR_nothing
> + || optab_handler (opo, TYPE_MODE (compute_type))
> + == CODE_FOR_nothing)
> + compute_type = TREE_TYPE (type);
> + }
> + }
> }
> }
> else
> @@ -1473,38 +1590,10 @@ expand_vector_operations_1 (gimple_stmt_
> && INTEGRAL_TYPE_P (TREE_TYPE (type)))
> op = optab_for_tree_code (MINUS_EXPR, type, optab_default);
>
> - /* For very wide vectors, try using a smaller vector mode. */
> - compute_type = type;
> - if (!VECTOR_MODE_P (TYPE_MODE (type)) && op)
> - {
> - tree vector_compute_type
> - = type_for_widest_vector_mode (TREE_TYPE (type), op);
> - if (vector_compute_type != NULL_TREE
> - && (TYPE_VECTOR_SUBPARTS (vector_compute_type)
> - < TYPE_VECTOR_SUBPARTS (compute_type))
> - && (optab_handler (op, TYPE_MODE (vector_compute_type))
> - != CODE_FOR_nothing))
> - compute_type = vector_compute_type;
> - }
> -
> - /* If we are breaking a BLKmode vector into smaller pieces,
> - type_for_widest_vector_mode has already looked into the optab,
> - so skip these checks. */
> + if (compute_type == NULL_TREE)
> + compute_type = get_compute_type (code, op, type);
> if (compute_type == type)
> - {
> - compute_mode = TYPE_MODE (compute_type);
> - if (VECTOR_MODE_P (compute_mode))
> - {
> - if (op && optab_handler (op, compute_mode) != CODE_FOR_nothing)
> - return;
> - if (code == MULT_HIGHPART_EXPR
> - && can_mult_highpart_p (compute_mode,
> - TYPE_UNSIGNED (compute_type)))
> - return;
> - }
> - /* There is no operation in hardware, so fall back to scalars. */
> - compute_type = TREE_TYPE (type);
> - }
> + return;
>
> gcc_assert (code != VEC_LSHIFT_EXPR && code != VEC_RSHIFT_EXPR);
> new_rhs = expand_vector_operation (gsi, type, compute_type, stmt, code);
> --- gcc/expmed.c.jj 2014-06-26 11:00:00.034270690 +0200
> +++ gcc/expmed.c 2014-06-26 13:28:49.802581691 +0200
> @@ -2128,9 +2128,12 @@ expand_shift_1 (enum tree_code code, enu
> optab lrotate_optab = rotl_optab;
> optab rrotate_optab = rotr_optab;
> enum machine_mode op1_mode;
> + enum machine_mode scalar_mode = mode;
> int attempt;
> bool speed = optimize_insn_for_speed_p ();
>
> + if (VECTOR_MODE_P (mode))
> + scalar_mode = GET_MODE_INNER (mode);
> op1 = amount;
> op1_mode = GET_MODE (op1);
>
> @@ -2153,9 +2156,9 @@ expand_shift_1 (enum tree_code code, enu
> {
> if (CONST_INT_P (op1)
> && ((unsigned HOST_WIDE_INT) INTVAL (op1) >=
> - (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (mode)))
> + (unsigned HOST_WIDE_INT) GET_MODE_BITSIZE (scalar_mode)))
> op1 = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (op1)
> - % GET_MODE_BITSIZE (mode));
> + % GET_MODE_BITSIZE (scalar_mode));
> else if (GET_CODE (op1) == SUBREG
> && subreg_lowpart_p (op1)
> && SCALAR_INT_MODE_P (GET_MODE (SUBREG_REG (op1)))
> @@ -2169,10 +2172,10 @@ expand_shift_1 (enum tree_code code, enu
> amount instead. */
> if (rotate
> && CONST_INT_P (op1)
> - && IN_RANGE (INTVAL (op1), GET_MODE_BITSIZE (mode) / 2 + left,
> - GET_MODE_BITSIZE (mode) - 1))
> + && IN_RANGE (INTVAL (op1), GET_MODE_BITSIZE (scalar_mode) / 2 + left,
> + GET_MODE_BITSIZE (scalar_mode) - 1))
> {
> - op1 = GEN_INT (GET_MODE_BITSIZE (mode) - INTVAL (op1));
> + op1 = GEN_INT (GET_MODE_BITSIZE (scalar_mode) - INTVAL (op1));
> left = !left;
> code = left ? LROTATE_EXPR : RROTATE_EXPR;
> }
> @@ -2185,7 +2188,7 @@ expand_shift_1 (enum tree_code code, enu
> if (code == LSHIFT_EXPR
> && CONST_INT_P (op1)
> && INTVAL (op1) > 0
> - && INTVAL (op1) < GET_MODE_PRECISION (mode)
> + && INTVAL (op1) < GET_MODE_PRECISION (scalar_mode)
> && INTVAL (op1) < MAX_BITS_PER_WORD
> && (shift_cost (speed, mode, INTVAL (op1))
> > INTVAL (op1) * add_cost (speed, mode))
> @@ -2240,14 +2243,14 @@ expand_shift_1 (enum tree_code code, enu
> if (op1 == const0_rtx)
> return shifted;
> else if (CONST_INT_P (op1))
> - other_amount = GEN_INT (GET_MODE_BITSIZE (mode)
> + other_amount = GEN_INT (GET_MODE_BITSIZE (scalar_mode)
> - INTVAL (op1));
> else
> {
> other_amount
> = simplify_gen_unary (NEG, GET_MODE (op1),
> op1, GET_MODE (op1));
> - HOST_WIDE_INT mask = GET_MODE_PRECISION (mode) - 1;
> + HOST_WIDE_INT mask = GET_MODE_PRECISION (scalar_mode) - 1;
> other_amount
> = simplify_gen_binary (AND, GET_MODE (op1), other_amount,
> gen_int_mode (mask, GET_MODE (op1)));
> --- gcc/testsuite/gcc.target/i386/sse2-pr57233.c.jj 2014-06-26
> 13:28:49.802581691 +0200
> +++ gcc/testsuite/gcc.target/i386/sse2-pr57233.c 2014-06-26
> 13:28:49.802581691 +0200
> @@ -0,0 +1,16 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do run { target sse2 } } */
> +/* { dg-options "-O2 -msse2" } */
> +
> +#include "sse2-check.h"
> +
> +static void
> +sse2_test (void)
> +{
> + do_main ();
> +}
> +
> +#undef main
> +#define main() do_main ()
> +
> +#include "../../gcc.dg/pr57233.c"
> --- gcc/testsuite/gcc.target/i386/pr57233.c.jj 2014-06-26
> 13:28:49.802581691 +0200
> +++ gcc/testsuite/gcc.target/i386/pr57233.c 2014-06-26 13:28:49.802581691
> +0200
> @@ -0,0 +1,15 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do compile { target avx } } */
> +/* { dg-options "-O2 -mavx -mno-xop" } */
> +
> +typedef unsigned V4 __attribute__((vector_size(4 * sizeof (int))));
> +V4 a;
> +
> +__attribute__((noinline)) void
> +foo (void)
> +{
> + a = (a << 2) | (a >> 30);
> +}
> +
> +/* { dg-final { scan-assembler "vpsrld\[^\n\r]*30" } } */
> +/* { dg-final { scan-assembler "vpslld\[^\n\r]*2" } } */
> --- gcc/testsuite/gcc.target/i386/xop-pr57233.c.jj 2014-06-26
> 13:28:49.802581691 +0200
> +++ gcc/testsuite/gcc.target/i386/xop-pr57233.c 2014-06-26
> 13:28:49.802581691 +0200
> @@ -0,0 +1,16 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do run { target xop } } */
> +/* { dg-options "-O2 -mxop" } */
> +
> +#include "xop-check.h"
> +
> +static void
> +xop_test (void)
> +{
> + do_main ();
> +}
> +
> +#undef main
> +#define main() do_main ()
> +
> +#include "../../gcc.dg/pr57233.c"
> --- gcc/testsuite/gcc.target/i386/avx2-pr57233.c.jj 2014-06-26
> 13:28:49.803581572 +0200
> +++ gcc/testsuite/gcc.target/i386/avx2-pr57233.c 2014-06-26
> 13:28:49.802581691 +0200
> @@ -0,0 +1,16 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do run { target avx2 } } */
> +/* { dg-options "-O2 -mavx2" } */
> +
> +#include "avx2-check.h"
> +
> +static void
> +avx2_test (void)
> +{
> + do_main ();
> +}
> +
> +#undef main
> +#define main() do_main ()
> +
> +#include "../../gcc.dg/pr57233.c"
> --- gcc/testsuite/gcc.target/i386/avx-pr57233.c.jj 2014-06-26
> 13:28:49.803581572 +0200
> +++ gcc/testsuite/gcc.target/i386/avx-pr57233.c 2014-06-26
> 13:28:49.803581572 +0200
> @@ -0,0 +1,16 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do run { target avx } } */
> +/* { dg-options "-O2 -mavx" } */
> +
> +#include "avx-check.h"
> +
> +static void
> +avx_test (void)
> +{
> + do_main ();
> +}
> +
> +#undef main
> +#define main() do_main ()
> +
> +#include "../../gcc.dg/pr57233.c"
> --- gcc/testsuite/gcc.target/i386/avx512f-pr57233.c.jj 2014-06-26
> 13:28:49.803581572 +0200
> +++ gcc/testsuite/gcc.target/i386/avx512f-pr57233.c 2014-06-26
> 13:28:49.803581572 +0200
> @@ -0,0 +1,16 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do run { target avx512f } } */
> +/* { dg-options "-O2 -mavx512f" } */
> +
> +#include "avx512f-check.h"
> +
> +static void
> +avx512f_test (void)
> +{
> + do_main ();
> +}
> +
> +#undef main
> +#define main() do_main ()
> +
> +#include "../../gcc.dg/pr57233.c"
> --- gcc/testsuite/gcc.dg/pr57233.c.jj 2014-06-26 13:28:49.803581572 +0200
> +++ gcc/testsuite/gcc.dg/pr57233.c 2014-06-26 13:28:49.803581572 +0200
> @@ -0,0 +1,171 @@
> +/* PR tree-optimization/57233 */
> +/* { dg-do run { target { ilp32 || lp64 } } } */
> +/* { dg-options "-O2" } */
> +
> +typedef unsigned V4 __attribute__((vector_size(4 * sizeof (int))));
> +typedef unsigned V8 __attribute__((vector_size(8 * sizeof (int))));
> +typedef unsigned V16 __attribute__((vector_size(16 * sizeof (int))));
> +V4 a, b, g;
> +V8 c, d, h;
> +V16 e, f, j;
> +
> +__attribute__((noinline)) void
> +f1 (void)
> +{
> + a = (a << 2) | (a >> 30);
> +}
> +
> +__attribute__((noinline)) void
> +f2 (void)
> +{
> + a = (a << 30) | (a >> 2);
> +}
> +
> +__attribute__((noinline)) void
> +f3 (void)
> +{
> + a = (a << b) | (a >> (32 - b));
> +}
> +
> +__attribute__((noinline, noclone)) void
> +f4 (int x)
> +{
> + a = (a << x) | (a >> (32 - x));
> +}
> +
> +__attribute__((noinline)) void
> +f5 (void)
> +{
> + c = (c << 2) | (c >> 30);
> +}
> +
> +__attribute__((noinline)) void
> +f6 (void)
> +{
> + c = (c << 30) | (c >> 2);
> +}
> +
> +__attribute__((noinline)) void
> +f7 (void)
> +{
> + c = (c << d) | (c >> (32 - d));
> +}
> +
> +__attribute__((noinline, noclone)) void
> +f8 (int x)
> +{
> + c = (c << x) | (c >> (32 - x));
> +}
> +
> +__attribute__((noinline)) void
> +f9 (void)
> +{
> + e = (e << 2) | (e >> 30);
> +}
> +
> +__attribute__((noinline)) void
> +f10 (void)
> +{
> + e = (e << 30) | (e >> 2);
> +}
> +
> +__attribute__((noinline)) void
> +f11 (void)
> +{
> + e = (e << f) | (e >> (32 - f));
> +}
> +
> +__attribute__((noinline, noclone)) void
> +f12 (int x)
> +{
> + e = (e << x) | (e >> (32 - x));
> +}
> +
> +unsigned
> +r (void)
> +{
> + static unsigned x = 0xdeadbeefU;
> + static unsigned y = 0x12347654U;
> + static unsigned z = 0x1a2b3c4dU;
> + static unsigned w = 0x87654321U;
> + unsigned t = x ^ (x << 11);
> + x = y;
> + y = z;
> + z = w;
> + w = w ^ (w >> 19) ^ t ^ (t >> 8);
> + return w;
> +}
> +
> +void
> +init (unsigned int *p, int count, int mod)
> +{
> + int i;
> + for (i = 0; i < count; i++)
> + {
> + unsigned int v = r ();
> + if (mod)
> + v = (v % 31) + 1;
> + p[i] = v;
> + }
> +}
> +
> +void
> +check (unsigned int *p, unsigned int *q, int count, unsigned int *s, int ss)
> +{
> + int i;
> + for (i = 0; i < count; i++)
> + {
> + if (s)
> + ss = s[i];
> + if (p[i] != ((q[i] << ss) | (q[i] >> (32 - ss))))
> + __builtin_abort ();
> + }
> +}
> +
> +int
> +main ()
> +{
> + init ((unsigned int *) &a, 4, 0);
> + init ((unsigned int *) &b, 4, 1);
> + init ((unsigned int *) &c, 8, 0);
> + init ((unsigned int *) &d, 8, 1);
> + init ((unsigned int *) &e, 16, 0);
> + init ((unsigned int *) &f, 16, 1);
> + g = a;
> + h = c;
> + j = e;
> + f1 ();
> + f5 ();
> + f9 ();
> + check ((unsigned int *) &a, (unsigned int *) &g, 4, 0, 2);
> + check ((unsigned int *) &c, (unsigned int *) &h, 8, 0, 2);
> + check ((unsigned int *) &e, (unsigned int *) &j, 16, 0, 2);
> + g = a;
> + h = c;
> + j = e;
> + f2 ();
> + f6 ();
> + f10 ();
> + check ((unsigned int *) &a, (unsigned int *) &g, 4, 0, 30);
> + check ((unsigned int *) &c, (unsigned int *) &h, 8, 0, 30);
> + check ((unsigned int *) &e, (unsigned int *) &j, 16, 0, 30);
> + g = a;
> + h = c;
> + j = e;
> + f3 ();
> + f7 ();
> + f11 ();
> + check ((unsigned int *) &a, (unsigned int *) &g, 4, (unsigned int *) &b,
> 0);
> + check ((unsigned int *) &c, (unsigned int *) &h, 8, (unsigned int *) &d,
> 0);
> + check ((unsigned int *) &e, (unsigned int *) &j, 16, (unsigned int *) &f,
> 0);
> + g = a;
> + h = c;
> + j = e;
> + f4 (5);
> + f8 (5);
> + f12 (5);
> + check ((unsigned int *) &a, (unsigned int *) &g, 4, 0, 5);
> + check ((unsigned int *) &c, (unsigned int *) &h, 8, 0, 5);
> + check ((unsigned int *) &e, (unsigned int *) &j, 16, 0, 5);
> + return 0;
> +}
>
>
> Jakub
>
>
--
Richard Biener <rguent...@suse.de>
SUSE / SUSE Labs
SUSE LINUX Products GmbH - Nuernberg - AG Nuernberg - HRB 16746
GF: Jeff Hawn, Jennifer Guild, Felix Imend"orffer
