--- /dev/null
+// PR target/85503
+// { dg-do compile { target { { powerpc64le-*-* } && c++11 } } }
+// { dg-require-effective-target powerpc_vsx_ok }
+// { dg-options "-O2 -mvsx" }
+
+namespace b {
+template < int c > struct d { static constexpr int e = c; };
+typedef d< false > f;
+template < typename g > struct h { typedef g i; };
+template < typename > class j;
+template < bool, bool, typename... > struct aa;
+struct k {
+ template < typename n, typename... q >
+ static h< decltype(n()(q()...)) > o(int);
+};
+template < typename p, typename... t > struct aa< false, false, p, t... > : k {
+ typedef decltype(o< p, t... >(0)) i;
+};
+template < typename p, typename... t >
+struct ab : aa< f::e, f::e, p, t... >::i {};
+template < typename p, typename... t > struct j< p(t...) > : ab< p, t... > {};
+} enum { r, s };
+typedef long x;
+template < typename > struct ac;
+template < typename y > struct ac< y & > { typedef y i; };
+template < typename y > struct j { typedef typename b::j< y >::i i; };
+template < typename > struct ad;
+template < typename > struct ae;
+template < typename > class af;
+template < typename, int ag, int ah, int = 0, int = ag, int = ah > class ai;
+template < typename > class aj;
+template < typename, typename, typename > class ak;
+template < typename > class al;
+template < typename > struct am;
+template < typename > struct an;
+template < typename y > struct ao { typedef typename am< y >::i i; };
+struct aq {
+ typedef const ai< double, 2, 1 > &ar;
+};
+template < typename as > struct at { typedef aj< as > i; };
+template < typename as > struct au { typedef typename at< as >::i i; };
+template < typename av > av aw(const typename an< av >::i *);
+template < typename av, int > av az(const typename an< av >::i *ba) {
+ return aw< av >(ba);
+}
+typedef __attribute__((altivec(vector__))) double bb;
+template <> struct am< double > { typedef bb i; };
+template <> struct an< bb > { typedef double i; };
+template <> bb aw(const double *ba) { return __builtin_vec_vsx_ld(0, ba); }
+struct bc {
+ template < typename av > int bd(av a) { bd(a); __builtin_unreachable (); }
+};
+struct be {
+ double operator()(const int, const int);
+};
+template < typename as > class bf : public ae< as > {
+public:
+ typedef typename ad< as >::bg bg;
+ using ae< as >::bh;
+ enum { bi };
+ bg bj() const;
+ template < typename bk > bg bl(const bk &) const;
+};
+template < typename as > class aj : public bf< as > {
+public:
+ using bf< as >::bh;
+ template < typename bm > ak< be, const as, const bm > operator-(bm bn) {
+ return ak< be, const as, const bm >(bh(), bn);
+ }
+ int bo() const;
+ al< as > array() { return bh(); }
+};
+template < typename as > struct ae {
+ const as &bh() const { return *static_cast< const as * >(this); }
+};
+template < typename > struct bp;
+template < typename > struct bq;
+template < typename y > struct br : bq< y > {
+ br(y bs) : bq< y >(bs) {}
+};
+template < typename y > struct br< const y > : br< y > {
+ br(const y &bs) : br< y >(bs) {}
+};
+template < typename as > struct br< af< as > > {
+ typedef as bt;
+ br(const bt &m) : bu(m.bv()) {}
+ template < int bw, typename ay > ay bx(x, x by) {
+ return az< ay, bw >(bu + by);
+ }
+ const typename bt::bg *bu;
+};
+template < typename bg, int u, int bz, int ca, int cb, int cc >
+struct br< ai< bg, u, bz, ca, cb, cc > > : br< af< ai< bg, u, bz > > > {
+ typedef ai< bg, u, bz > cd;
+ br(const cd &m) : br< af< cd > >(m) {}
+};
+template < typename bk, typename ce, typename cf >
+struct br< ak< bk, ce, cf > > : bp< ak< bk, ce, cf > > {
+ br(ak< bk, ce, cf > bs) : bp< ak< bk, ce, cf > >(bs) {}
+};
+template < typename bk, typename ce, typename cf >
+struct bp< ak< bk, ce, cf > > {
+ bp(ak< bk, ce, cf > bs) : cg(), ch(bs.ci()) {}
+ template < int bw, typename ay > ay bx(x cj, x by) {
+ return ch.template bx< bw, ay >(cj, by);
+ }
+ ce cg;
+ br< cf > ch;
+};
+template < typename cd > struct v {
+ typedef typename ac< typename cd::ck >::i cl;
+ v(cl &arg) : cn(arg) {}
+ template < int bw, typename ay > ay bx(x cj, x by) {
+ return cn.template bx< bw, ay >(cj, by);
+ }
+ br< cl > cn;
+};
+template < typename cm > struct bq< al< cm > > : v< al< cm > > {
+ bq(al< cm > w) : v< al< cm > >(w.dd()) {}
+};
+template < typename as > class ap : public bf< as > {};
+template < int ax > struct co { double array[ax]; };
+template < int ax > class cq {
+ co< ax > bu;
+
+public:
+ const double *bv() const { return bu.array; }
+};
+template < typename as > class af : public at< as >::i {
+public:
+ typedef typename at< as >::i cp;
+ cq< cp::bi > cs;
+ const typename ad< as >::bg *bv() const { return cs.bv(); }
+};
+template < typename cr, int ag, int ah, int cu, int ct, int cw >
+struct ad< ai< cr, ag, ah, cu, ct, cw > > {
+ typedef cr bg;
+};
+template < typename, int ag, int ah, int, int, int >
+class ai : public af< ai< double, ag, ah > > {
+ typedef ai cv;
+};
+template < typename bk, typename ce, typename cf >
+struct ad< ak< bk, ce, cf > > {
+ typedef typename j< bk(typename ce::bg, typename cf::bg) >::i bg;
+};
+template < typename, typename, typename > class z;
+template < typename bk, typename cy, typename cx >
+class ak : public z< bk, cy, cx > {
+public:
+ typedef cx RhsNested;
+ ak(cy, cx cz) : da(), db(cz) {}
+ RhsNested ci() { return db; }
+ cy da;
+ RhsNested db;
+};
+template < typename bk, typename ce, typename cf >
+class z : public au< ak< bk, ce, cf > >::i {};
+template < typename as > int aj< as >::bo() const { (*this).bj(); __builtin_unreachable (); }
+template < typename as > struct dc {
+ typedef typename ao< typename as::bg >::i ay;
+ enum { d, de };
+ enum { df = de };
+};
+template < typename as > struct dk {
+ enum { dh, di, dj, alignment };
+ typedef typename dc< as >::ay PacketScalar;
+ static PacketScalar dl(as dm, bc) {
+ return dm.template dn< alignment, PacketScalar >(di, dj);
+ }
+};
+template < typename, typename as, int = dc< as >::df > struct redux_impl;
+template < typename Func, typename as > struct redux_impl< Func, as, s > {
+ static int dl(as dm, Func func) { func.bd(dk< as >::dl(dm, func)); __builtin_unreachable (); }
+};
+template < typename _XprType > class redux_evaluator {
+public:
+ typedef _XprType cd;
+ redux_evaluator(cd bs) : m_evaluator(bs), m_xpr(bs) {}
+ typedef typename cd::bg bg;
+ template < int bw, typename ay > ay dn(x di, x dj) {
+ return m_evaluator.template bx< bw, ay >(dj, di);
+ }
+ br< cd > m_evaluator;
+ cd m_xpr;
+};
+template < typename as >
+template < typename Func >
+typename ad< as >::bg bf< as >::bl(const Func &func) const {
+ typedef redux_evaluator< as > ThisEvaluator;
+ ThisEvaluator thisEval(bh());
+ redux_impl< Func, ThisEvaluator >::dl(thisEval, func);
+ __builtin_unreachable ();
+}
+template < typename as > typename ad< as >::bg bf< as >::bj() const {
+ bl(bc());
+ __builtin_unreachable ();
+}
+template < typename ExpressionType >
+struct ad< al< ExpressionType > > : ad< typename ExpressionType::cv > {};
+template < typename > class al : public ap< al< ai< double, 2, 1 > > > {
+public:
+ typedef aq::ar ck;
+ al(const ai< double, 2, 1 > &dg) : m_expression(dg) {}
+ const ai< double, 2, 1 > &dd() { return m_expression; }
+ ck m_expression;
+};
+typedef ai< double, 2, 1 > Vector2d;
+class OnHoverHandlerGraphicsItem {
+public:
+ static Vector2d corners;
+};
+int
+GasGraphicsItemcreateOnHoverHandler() {
+ Vector2d l;
+ (l - OnHoverHandlerGraphicsItem::corners.array()).bo();
+ __builtin_unreachable ();
+}
projects / gcc.git / commitdiff