1 // { dg-do compile }
2 // { dg-require-effective-target c++17 }
3
4 typedef double b __attribute__((__vector_size__(16)));
5 b c;
6 enum { d };
7 namespace e {
8 template <typename> struct g;
9 struct h {
10 enum { i, j };
11 };
12 template <typename> struct aa;
13 } // namespace e
14 template <typename> struct k;
15 template <typename> class l;
16 template <typename, int = e::h::j> class ab;
17 template <typename, int m, int n, int = 0, int = m, int = n> class o;
18 template <typename> class ac;
19 class p;
20 namespace e {
21 template <typename> struct q { typedef ac<o<double, 2, 1>> ae; };
22 struct s {
afe::s23 template <int, typename t> void af(double *ak, t) { *(b *)ak = c; }
24 };
25 } // namespace e
26 template <typename ad> class ab<ad, d> : public k<ad> {};
27 template <typename ad> class ab<ad> : public ab<ad, d> {
28 public:
29 typedef typename e::g<ad>::ag ag;
30 using ab<ad, d>::ah;
ai()31 ag ai() {
32 long aj = 0;
33 return e::aa(ah()).ai(aj);
34 }
operator [](long)35 ag operator[](long) { return ai(); }
36 };
37 template <typename ad> class ay : public ab<ad> {
38 public:
39 enum { a, al };
40 };
41 template <typename ad> class ac : public ay<ad> {
42 public:
43 p am();
44 };
45 template <typename> struct k {
ahk46 o<double, 2, 1> &ah() { return *static_cast<o<double, 2, 1> *>(this); }
47 };
48 namespace e {
49 template <typename f> struct aa { aa(f); };
50 template <typename ad> struct aa<l<ad>> {
51 typedef ad ao;
52 typedef typename ao::ag ag;
aae::aa53 aa(ao &ak) : ap(ak.aq()) {}
aie::aa54 ag &ai(long ak) { return ap[ak]; }
55 ag *ap;
56 };
57 template <typename ag, int ar, int as, int at, int au, int av>
58 struct aa<o<ag, ar, as, at, au, av>> : aa<l<o<ag, ar, as>>> {
59 typedef o<ag, ar, as> aw;
aae::aa60 aa(aw &ak) : aa<l<aw>>(ak) {}
61 };
62 template <typename ax> struct u {
63 enum { az, ba, bb };
bce::u64 static void bc(ax ak) { ak.template be<bb, d, typename ax::bf>(az, ba); }
65 };
66 template <typename ax> struct v {
bce::v67 static void bc(ax ak) { u<ax>::bc(ak); }
68 };
69 template <typename bg, typename bh> class w {
70 typedef bg bi;
71
72 public:
73 typedef bg bj;
74 typedef bg bf;
w(bj ak,int,bh,bi x)75 w(bj ak, int, bh, bi x) : bk(ak), bl(x) {}
be(long,long)76 template <int bm, int, typename> void be(long, long) {
77 bn.template af<bm>(&bk.ai(0), 0);
78 }
79 bj bk;
80 bh bn;
81 bi bl;
82 };
bp(bi & ak,bo,bh bq)83 template <typename bi, typename bo, typename bh> void bp(bi &ak, bo, bh bq) {
84 typedef aa<bi> bj;
85 bo br;
86 bj bs(ak);
87 typedef w<bj, bh> ax;
88 ax bd(bs, br, bq, ak);
89 v<ax>::bc(bd);
90 }
91 template <typename> struct bt;
bx(bu & ak,bv by,bw bq)92 template <typename bu, typename bv, typename bw> void bx(bu &ak, bv by, bw bq) {
93 bt<bw>::bc(ak, by, bq);
94 }
95 template <typename> struct bt {
bce::bt96 static void bc(o<double, 2, 1> &ak, int by, s bq) { bp(ak, by, bq); }
97 };
98 } // namespace e
99 class bz {
100 public:
101 template <typename an> void operator*(an);
102 };
103 namespace e {
104 template <int ca> struct cb { double am[ca]; };
105 } // namespace e
106 template <int ca> class cc {
107 e::cb<ca> ap;
108
109 public:
aq()110 double *aq() { return ap.am; }
111 };
112 template <typename ad> class l : public e::q<ad>::ae {
113 public:
114 typedef typename e::q<ad>::ae cd;
115 typedef typename e::g<ad>::ag ag;
116 cc<cd::al> ce;
aq()117 ag *aq() { return ce.aq(); }
l()118 l() {}
l(an ak)119 template <typename an> l(an ak) { bx(this->ah(), ak, e::s()); }
ch(cf,cg by)120 template <typename cf, typename cg> void ch(cf, cg by) {
121 ag *z, *y;
122 { z = aq(); }
123 y = z;
124 y[0] = aq()[1] = by;
125 }
126 };
127 namespace e {
128 template <typename ci, int m, int n, int cj, int ck, int cl>
129 struct g<o<ci, m, n, cj, ck, cl>> {
130 typedef ci ag;
131 };
132 } // namespace e
133 template <typename, int m, int n, int, int, int>
134 class o : public l<o<double, m, n>> {
135 public:
136 typedef l<o> cd;
o(cf ak,cg by)137 template <typename cf, typename cg> o(cf ak, cg by) { cd::ch(ak, by); }
o(an ak)138 template <typename an> o(an ak) : cd(ak) {}
139 };
140 class p : public bz {};
141 double cq;
cm()142 void cm() {
143 o<double, 2, 1> r = 0;
144 o cn = r;
145 cn.am() * o<double, 2, 1>(0, r[0] / cq).am();
146 }
147