| // PR tree-optimization/92262 |
| // { dg-do compile { target c++11 } } |
| // { dg-options "-O2 -ftree-loop-distribution -g" } |
| |
| struct A; |
| struct B { template <typename T> using b = T *; }; |
| template <typename, typename T> using c = B::b<T>; |
| void *operator new (__SIZE_TYPE__, void *p) { return p; } |
| struct C { |
| template <typename T, typename... U> void |
| foo (T *x, U... y) { new (x) T(y...); } |
| }; |
| template <typename> class D : public C {}; |
| template <typename> struct E; |
| template <typename T> struct E<D<T>> { |
| using e = D<T>; |
| template <typename U> using f = D<U>; |
| template <typename U, typename... V> |
| static void |
| bar (e x, U y, V... z) { x.foo (y, z...); } |
| }; |
| template <typename T> struct F : E<T> { |
| template <typename U> struct G { typedef typename E<T>::template f<U> O; }; |
| }; |
| template <typename T, typename U, typename V> void |
| baz (T x, U y, V z) |
| { |
| F<V>::bar (z, y, *x); |
| } |
| struct H { |
| typedef c<int, A> I; |
| typedef c<int, I> J; |
| I i; |
| J j; |
| void qux (J x) { j = x; } |
| }; |
| template <typename> |
| struct K { |
| K(D<A> x) : k (x) {} |
| typedef H::J L; |
| struct M { L m; H n, o; }; |
| struct N : F<D<int>>::G<A>::O, M { N (F<D>::G<A>::O); }; |
| void quux (); |
| N k; |
| }; |
| template <typename T> |
| void |
| K<T>::quux () |
| { |
| L K (k.m - 1); |
| k.n.qux (K); |
| } |
| template <typename, typename = int> |
| struct P : K<int> { |
| template <typename T> |
| P (T x, T, D<A> y = D<A> ()) : K (y) { corge (x); } |
| template <typename T> void corge (T); |
| typedef L L; |
| }; |
| template <typename T, typename U> |
| template <typename V> |
| void P<T, U>::corge (V y) |
| { |
| quux (); |
| for (L x = k.n.j; x < k.o.j; ++x) |
| { |
| ++y; |
| D<int> pv; |
| baz (y, *x, pv); |
| } |
| D<int> z; |
| baz (y, k.o.i, z); |
| } |
| struct A { |
| A (int x) : a (x) {} |
| int a; |
| }; |
| int a[2]{}; |
| |
| int |
| main () |
| { |
| P<int> (a, a); |
| return 0; |
| } |