https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69355
--- Comment #10 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
Reduced testcase:
template <int> struct A;
template <> struct A<1> {};
template <class Obj, int> struct B
{
template <class T> struct C
{
typedef T *iterator;
C (iterator p1) : m_iter (p1) {}
void operator, (T p1) { *m_iter = p1; }
iterator m_iter;
};
typedef double *iterator;
B (Obj &p1, double) : m_object (p1) {}
C<double> operator, (double);
Obj &m_object;
};
template <class Obj, int LEN>
typename B<Obj, LEN>::template C<double>
B<Obj, LEN>::operator, (double p1)
{
iterator a = m_object.data (), b = a + 1;
*a = 1;
*b = p1;
return C<double>(b + 1);
}
class D {};
inline double operator+(const double &p1, D) { return p1; }
template <int> class U;
template <int Sz, int K = 0> struct F
{
enum { doIt = K < Sz - 1 ? 1 : 0 };
template <class Dest, class Src, class Assign>
static void assign (Dest &p1, Src &p2, Assign &p3)
{
p3.apply_on (p1 (K), p2 (K));
F<Sz * doIt, (K + 1) * doIt>::assign (p1, p2, p3);
}
template <class Dest, class Src> static double dot (Dest &p1, Src &p2)
{
return p1 (K) * p2 (K) + F<Sz * doIt, (K + 1) * doIt>::dot (p1, p2);
}
};
template <> struct F<0>
{
template <class Dest, class Src, class Assign>
static void assign (Dest &, Src &, Assign &) {}
template <class Dest, class Src> static D dot (Dest &, Src &) { return D ();
}
};
template <class E, int Sz> struct G
{
enum { ops_assign, use_meta };
G (const E &p1) : m_expr (p1) {}
double operator()(int p1) const { return m_expr (p1); }
template <class Dest, class Src, class Assign>
static void do_assign (A<1>, Dest &p2, Src &p3, Assign &p4)
{
F<Sz>::assign (p2, p3, p4);
}
template <class Dest, class Assign>
void assign_to (Dest &p1, const Assign &p2) const
{
do_assign (A<1>(), p1, *this, p2);
}
E m_expr;
};
struct H
{
static double apply_on (double p1, long double p2) { return p1 / p2; }
static void apply_on (double & __restrict p1, double p2) { p1 = p2; }
};
template <class E1, class E2> struct I
{
I (const E1 &p1, const E2 &p2) : m_lhs (p1), m_rhs (p2) {}
double operator()(int p1) const
{
double c = m_lhs (p1);
return H::apply_on (c, m_rhs (0));
}
E1 m_lhs;
const E2 m_rhs;
};
struct J
{
J (double p1) : m_data (p1) {}
long double operator()(int) const { return m_data; }
long double m_data;
};
template <int Sz> struct K
{
K (const U<Sz> &p1) : m_data (p1.data ()) {}
double operator()(int p1) const { return m_data[p1]; }
const double *m_data;
};
template <int Sz> struct U
{
U () {}
U (const U &p1)
{
*this = G<ConstReference, Sz>(p1.const_ref ());
}
B<U, Sz> operator=(double) { return B<U, Sz>(*this, 0); }
double *data () { return m_data; }
const double *data () const { return m_data; }
double &operator()(int p1) { return m_data[p1]; }
double operator()(int p1) const { return m_data[p1]; }
typedef K<Sz> ConstReference;
ConstReference const_ref () const { return *this; }
template <class E> void operator=(const G<E, Sz> &p1)
{
p1.assign_to (*this, H ());
}
double m_data[Sz];
};
template <int Sz>
G<I<K<Sz>, J>, Sz> div (U<Sz> &p1, double p2)
{
typedef I<K<Sz>, J> expr_type;
return G<expr_type, Sz>(expr_type (p1.const_ref (), p2));
}
template <int Sz> double norm2 (U<Sz> &p1)
{
return __builtin_sqrt (F<Sz>::dot (p1, p1));
}
template <int Sz>
G<I<K<Sz>, J>, Sz> operator/(U<Sz> &p1, double p2)
{
return div (p1, p2);
}
typedef U<3> V;
V foo (V p1)
{
double e = norm2 (p1);
V r;
r = p1 / e;
return r;
}
int
main ()
{
V f;
f = 1, 2, 3;
V r = foo (f);
if (__builtin_fabs (r (0) - 0.267261) > 0.001
|| __builtin_fabs (r (1) - 0.534522) > 0.001
|| __builtin_fabs (r (2) - 0.801784) > 0.001)
__builtin_abort ();
}
