From: Richard Biener Date: Fri, 2 Aug 2019 12:07:33 +0000 (+0000) Subject: backport: re PR tree-optimization/91280 (ICE in get_constraint_for_component_ref... X-Git-Tag: releases/gcc-9.2.0~77 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=baefa04d7699b934fe05414ed6ec80d2107fe97d;p=thirdparty%2Fgcc.git backport: re PR tree-optimization/91280 (ICE in get_constraint_for_component_ref, at tree-ssa-structalias.c:3259 since r260354) 2019-08-02 Richard Biener Backport from mainline 2019-07-31 Richard Biener PR tree-optimization/91280 * tree-ssa-structalias.c (get_constraint_for_component_ref): Decompose MEM_REF manually for offset handling. * g++.dg/torture/pr91280.C: New testcase. 2019-07-31 Richard Biener PR tree-optimization/91293 * tree-vect-slp.c (vect_build_slp_tree_2): Do not swap operands of reduction stmts. * gcc.dg/vect/pr91293-1.c: New testcase. * gcc.dg/vect/pr91293-2.c: Likewise. * gcc.dg/vect/pr91293-3.c: Likewise. From-SVN: r274007 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 57c1025f6e34..57f7bcabbb3d 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,18 @@ +2019-08-02 Richard Biener + + Backport from mainline + 2019-07-31 Richard Biener + + PR tree-optimization/91280 + * tree-ssa-structalias.c (get_constraint_for_component_ref): + Decompose MEM_REF manually for offset handling. + + 2019-07-31 Richard Biener + + PR tree-optimization/91293 + * tree-vect-slp.c (vect_build_slp_tree_2): Do not swap operands + of reduction stmts. + 2019-08-02 Richard Biener Backport from mainline diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 337b50e194c0..41208128e600 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,18 @@ +2019-08-02 Richard Biener + + Backport from mainline + 2019-07-31 Richard Biener + + PR tree-optimization/91280 + * g++.dg/torture/pr91280.C: New testcase. + + 2019-07-31 Richard Biener + + PR tree-optimization/91293 + * gcc.dg/vect/pr91293-1.c: New testcase. + * gcc.dg/vect/pr91293-2.c: Likewise. + * gcc.dg/vect/pr91293-3.c: Likewise. + 2019-08-02 Richard Biener Backport from mainline diff --git a/gcc/testsuite/g++.dg/torture/pr91280.C b/gcc/testsuite/g++.dg/torture/pr91280.C new file mode 100644 index 000000000000..063bef836f9a --- /dev/null +++ b/gcc/testsuite/g++.dg/torture/pr91280.C @@ -0,0 +1,223 @@ +// { dg-do compile } + +enum { Aligned, RowMajor }; +enum { ReadOnlyAccessors }; +template struct K { + enum { value }; +}; +template struct traits; +template struct traits : traits {}; +struct A { + enum { has_write_access, value }; +}; +template class array { +public: + int operator[](unsigned long p1) { return values[p1]; } + int values[n]; +}; +template struct I; +template class = I> class M; +template class J; +template class N; +template class D; +template class TensorContractionOp; +template class TensorChippingOp; +class C; +template +struct K> { + static const long value = NumDims; +}; +template +struct traits> { + typedef IndexType_ Index; +}; +template class MakePointer_> +struct traits> + : traits {}; +template struct B { typedef T type; }; +template class N { +public: + typedef typename traits::Index Index; + D m_fn1(); + template + TensorContractionOp + m_fn2(OtherDerived, Dimensions); + template TensorChippingOp<1, Derived> m_fn3(Index); +}; +template +class N : public N { +public: + template C m_fn4(DeviceType); +}; +template struct TensorEvaluator; +template +struct TensorEvaluator, Device> { + TensorEvaluator(D, Device); +}; +template class D { +public: + typedef typename B::type Nested; +}; +template +struct traits< + TensorEvaluator, + Device_>> { + typedef Indices_ Indices; + typedef LeftArgType_ LeftArgType; + typedef RightArgType_ RightArgType; + typedef OutputKernelType_ OutputKernelType; + typedef Device_ Device; +}; +template +class TensorContractionOp { +public: + typedef typename B::type Nested; + typename LhsXprType::Nested m_fn5(); + typename RhsXprType::Nested m_fn6(); +}; +template struct TensorContractionEvaluatorBase { + typedef typename traits::LeftArgType LeftArgType; + typedef typename traits::RightArgType RightArgType; + typedef typename traits::Device Device; + TensorContractionEvaluatorBase( + TensorContractionOp::Indices, LeftArgType, + RightArgType, + typename traits::OutputKernelType> + p1, + Device p2) + : m_leftImpl(p1.m_fn6(), p2), m_rightImpl(p1.m_fn5(), p2) { + long nocontract_idx; + for (int i;; i++) { + bool contracting; + if (contracting) { + if (nocontract_idx < K::value) + m_j_size = m_j_strides[nocontract_idx]; + nocontract_idx++; + } + } + } + array m_j_strides; + long m_j_size; + TensorEvaluator m_leftImpl; + TensorEvaluator m_rightImpl; +}; +template +struct TensorEvaluator< + const TensorContractionOp, + Device> + : TensorContractionEvaluatorBase, + Device>> { + typedef TensorEvaluator Self; + typedef TensorContractionEvaluatorBase Base; + TensorEvaluator( + TensorContractionOp + p1, + Device p2) + : Base(p1, p2) {} +}; +template +struct traits> : traits {}; +template +class TensorChippingOp : public N> { +public: + typedef typename B::type Nested; +}; +template +struct TensorEvaluator, Device> { + static const int NumInputDims = K::value; + array m_dimensions; +}; +template +struct TensorEvaluator, Device> + : TensorEvaluator, Device> { + TensorEvaluator(TensorChippingOp, Device); +}; +template class TensorAssignOp { +public: + TensorAssignOp(TensorChippingOp<0, const M, 1>>, + RhsXprType); + TensorChippingOp<0, const M, 1>> m_fn7(); + typename RhsXprType::Nested m_fn8(); +}; +template +struct TensorEvaluator, + Device> { + TensorEvaluator(TensorAssignOp p1, Device p2) + : m_leftImpl(p1.m_fn7(), p2), m_rightImpl(p1.m_fn8(), p2) {} + TensorEvaluator m_leftImpl; + TensorEvaluator m_rightImpl; +}; +template class F { +public: + static void m_fn9(Expression p1) { + int device; + TensorEvaluator(p1, device); + } +}; +class C { +public: + void + operator=(TensorContractionOp, + TensorChippingOp<1, M, 0>>, + const D, 0>>, int> + p1) { + TensorAssignOp< + TensorChippingOp<0, const M, 1>>, + const TensorContractionOp< + array, TensorChippingOp<1, M, 0>>, + const D, 0>>, int>> + assign(m_expression, p1); + F, 1>>, + const TensorContractionOp< + array, TensorChippingOp<1, M, 0>>, + const D, 0>>, int>>>::m_fn9(assign); + } + TensorChippingOp<0, const M, 1>> m_expression; +}; +template class J { +public: + typedef array Dimensions; +}; +template class> +class M : public N> { +public: + typedef typename PlainObjectType::Dimensions Dimensions; +}; +template struct TTypes { + typedef M, Aligned> ConstTensor; +}; +class L { +public: + template typename TTypes::ConstTensor m_fn10(); +}; +class H { +public: + H(int *); +}; +class G { +public: + G(H *(int *)); +}; +int Run_d; +class O : H { +public: + int BatchMatMul_context; + O() : H(&BatchMatMul_context) { + L out, in_y, in_x; + auto Tx = in_x.m_fn10(), Ty = in_y.m_fn10(), + Tz = out.m_fn10(), z = Tz; + array contract_pairs; + auto x = Tx.m_fn3<0>(0); + auto y = Ty.m_fn1(); + z.m_fn4(Run_d) = x.m_fn2(y, contract_pairs); + } +}; +G registrar__body__0__object([](int *) -> H * { O(); return 0; }); diff --git a/gcc/testsuite/gcc.dg/vect/pr91293-1.c b/gcc/testsuite/gcc.dg/vect/pr91293-1.c new file mode 100644 index 000000000000..dc321f5726fd --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr91293-1.c @@ -0,0 +1,19 @@ +/* { dg-do run } */ +/* { dg-additional-options "-msse4.1" { target { sse4_runtime } } } */ + +long long a; +unsigned b, c; +int d = 62; +void e(long long *f, int p2) { *f = p2; } +int main() +{ + for (int g = 2; g <= d; g++) + { + b += g + 4; + c += 5 - g; + } + e(&a, b); + if (a != 2196) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/pr91293-2.c b/gcc/testsuite/gcc.dg/vect/pr91293-2.c new file mode 100644 index 000000000000..b9354bbd5e84 --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr91293-2.c @@ -0,0 +1,19 @@ +/* { dg-do run } */ +/* { dg-additional-options "-msse4.1" { target { sse4_runtime } } } */ + +long long a; +unsigned b, c; +int d = 62; +void e(long long *f, int p2) { *f = p2; } +int main() +{ + for (int g = 2; g <= d; g++) + { + c += 5 - g; + b += g + 4; + } + e(&a, b); + if (a != 2196) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/vect/pr91293-3.c b/gcc/testsuite/gcc.dg/vect/pr91293-3.c new file mode 100644 index 000000000000..c35bc3481cbe --- /dev/null +++ b/gcc/testsuite/gcc.dg/vect/pr91293-3.c @@ -0,0 +1,20 @@ +/* { dg-do run } */ +/* { dg-additional-options "-msse4.1" { target { sse4_runtime } } } */ + +long long a; +unsigned b, c; +int d = 62; +void e(long long *f, int p2) { *f = p2; } +int xx = 5, yy = 4; +int main() +{ + for (int g = 2; g <= d; g++) + { + c += xx - g; + b += yy + g; + } + e(&a, b); + if (a != 2196) + __builtin_abort (); + return 0; +} diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 4a0b02e9b03c..f80b8e456b5c 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -3250,9 +3250,29 @@ get_constraint_for_component_ref (tree t, vec *results, return; } - /* Pretend to take the address of the base, we'll take care of - adding the required subset of sub-fields below. */ - get_constraint_for_1 (t, results, true, lhs_p); + /* Avoid creating pointer-offset constraints, so handle MEM_REF + offsets directly. Pretend to take the address of the base, + we'll take care of adding the required subset of sub-fields below. */ + if (TREE_CODE (t) == MEM_REF + && !integer_zerop (TREE_OPERAND (t, 0))) + { + poly_offset_int off = mem_ref_offset (t); + off <<= LOG2_BITS_PER_UNIT; + off += bitpos; + poly_int64 off_hwi; + if (off.to_shwi (&off_hwi)) + bitpos = off_hwi; + else + { + bitpos = 0; + bitmaxsize = -1; + } + get_constraint_for_1 (TREE_OPERAND (t, 0), results, false, lhs_p); + do_deref (results); + } + else + get_constraint_for_1 (t, results, true, lhs_p); + /* Strip off nothing_id. */ if (results->length () == 2) { diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c index c3137460fd14..017bfa873f73 100644 --- a/gcc/tree-vect-slp.c +++ b/gcc/tree-vect-slp.c @@ -1285,6 +1285,9 @@ vect_build_slp_tree_2 (vec_info *vinfo, && nops == 2 && oprnds_info[1]->first_dt == vect_internal_def && is_gimple_assign (stmt_info->stmt) + /* Swapping operands for reductions breaks assumptions later on. */ + && STMT_VINFO_DEF_TYPE (stmt_info) != vect_reduction_def + && STMT_VINFO_DEF_TYPE (stmt_info) != vect_double_reduction_def /* Do so only if the number of not successful permutes was nor more than a cut-ff as re-trying the recursive match on possibly each level of the tree would expose exponential