Debian Codegraph @

gcc/testsuite/g++.target/aarch64/sve/pr119706.C

raw
1 /* { dg-do compile } */
2 /* { dg-options "-O3 -mcpu=neoverse-v2 --param=aarch64-autovec-preference=sve-only -w" } */
3
4 namespace a {
5 typedef long unsigned b;
6 typedef int c;
7 template <bool, typename d> struct e { using f = d; };
8 template <bool g, typename d = void> using h = typename e<g, d>::f;
9 template <typename aa, typename, template <typename> class> struct i {
10 using f = aa;
11 };
12 template <typename aa, template <typename> class j> using k = i<aa, void, j>;
13 template <typename aa, template <typename> class j>
14 using l = typename k<aa, j>::f;
15 } // namespace a
16 inline void *operator new(a::b, void *ab) { return ab; }
17 namespace a {
18 template <typename> class ac {
19 public:
20 typedef b m;
21 template <typename ad, typename... n> void ae(ad *ab, n... w) {
22 new (ab) ad(w...);
23 }
24 };
25 template <typename d> using x = ac<d>;
26 template <typename d> class af : public x<d> {
27 public:
28 typedef d o;
29 template <typename> struct ag { typedef af ah; };
30 };
31 struct ai {};
32 struct aj : ai {};
33 struct ak : aj {};
34 template <typename> struct al;
35 template <typename d> struct al<d *> {
36 typedef ak an;
37 typedef c ao;
38 typedef d ap;
39 };
40 template <typename aq> typename aq ::an ar(aq) { return typename aq ::an(); }
41 template <typename as> typename as ::ao at(as au, as av, ak) { return av - au; }
42 template <typename aw> typename aw ::ao ax(aw au, aw av) {
43 return at(au, av, ar(au));
44 }
45 template <typename> struct ay { typedef c ao; };
46 } // namespace a
47 namespace az {
48 template <typename am, typename> class ba {
49 am bb;
50 typedef a::al<am> bc;
51
52 public:
53 typedef typename bc::an an;
54 typedef typename bc::ao ao;
55 typedef typename bc::ap ap;
56 ba(am bd) : bb(bd) {}
57 ap operator*() { return *bb; }
58 ba operator++() {
59 ++bb;
60 return *this;
61 }
62 am base() { return bb; }
63 };
64 template <typename be, typename bf, typename bg>
65 bool operator!=(ba<be, bg> bh, ba<bf, bg> p) {
66 return bh.base() != p.base();
67 }
68 template <typename be, typename bf, typename bg>
69 auto operator-(ba<be, bg> bh, ba<bf, bg> p) {
70 return bh.base() - p.base();
71 }
72 } // namespace az
73 namespace a {
74 struct bi {
75 template <typename d, typename> struct bj {
76 using f = typename d::ag<d>::ah;
77 };
78 template <typename> using bk = b;
79 template <typename...> static constexpr bool bl = false;
80 template <typename, typename> static constexpr bool bm = bl<>;
81 template <typename d, typename... n> static constexpr bool bn = bm<d, n...>;
82 };
83 template <typename bo, typename ad> using bp = typename bi::bj<bo, ad>::f;
84 template <typename bo> struct bq : bi {
85 typedef typename bo::o o;
86 using br = l<o *, bk>;
87 template <typename, typename bs> struct bt { using f = typename ay<bs>::ao; };
88 template <typename bu, typename> struct bv { using f = typename bu::m; };
89 using ao = typename bt<bo, c>::f;
90 using m = typename bv<bo, ao>::f;
91 template <typename d> using bw = bp<bo, d>;
92 static br allocate(bo, m);
93 template <typename d, typename... n>
94 static h<bn<bo, d>> ae(bo ci, d ab, n... w) {
95 ci.ae(ab, w...);
96 }
97 };
98 template <typename d> struct bx {
99 static bool by(d &bz) try { d(bz.begin(), bz.ca(), bz.cb()); } catch (...) {
100 }
101 };
102 } // namespace a
103 namespace az {
104 template <typename bo> struct cc : a::bq<bo> {
105 typedef a::bq<bo> q;
106 template <typename d> struct ag { typedef typename q::bw<d> ah; };
107 };
108 } // namespace az
109 enum cd {};
110 using ce = double;
111 namespace a {
112 template <typename aw, typename cf, typename cg, typename ch>
113 cg cj(aw au, cf av, cg ck, ch cl) {
114 typedef az::cc<ch> cx;
115 for (; au != av; ++au, ++ck)
116 cx::ae(cl, ck, *au);
117 }
118 template <typename d, typename bo> struct cm {
119 typedef typename az::cc<bo>::ag<d>::ah cn;
120 typedef typename az::cc<cn>::br br;
121 struct co {
122 br db;
123 br cp;
124 };
125 struct cq : cn, co {
126 cq(cn) {}
127 } typedef cr;
128 cn cs();
129 cr cb() noexcept;
130 cm(cr ci) : ct(ci) {}
131 cq ct;
132 br cu(b cv) {
133 typedef az::cc<cn> cw;
134 return cv ? cw::allocate(ct, cv) : c();
135 }
136 };
137 template <typename d, typename bo = af<d>> class cy : cm<d, bo> {
138 typedef cm<d, bo> cz;
139
140 public:
141 typedef typename cz::br br;
142 typedef az::ba<br, cy> da;
143 typedef b m;
144 typedef bo cr;
145 cz::cs;
146 template <typename aw> cy(aw au, aw av, cr ci) : cz(ci) {
147 dg(au, av, ar(au));
148 }
149 cz::cb;
150 da begin() { return this->ct.db; }
151 da ca() { return this->ct.cp; }
152 void r() { s(); }
153 void clear() { t(this->ct.db); }
154 template <typename cg> void dg(cg au, cg av, ai) { y(au, av, ax(au, av)); }
155 template <typename am, typename cf> void y(am au, cf av, m cv) {
156 br z = this->cu(dc(cv, cs()));
157 cj(au, av, z, cs());
158 }
159 bool s();
160 m dc(m cv, cr) { return cv; }
161 void t(br dd) {
162 if (this->ct.cp - dd)
163 this->ct.cp = dd;
164 }
165 };
166 template <typename d, typename bo> bool cy<d, bo>::s() { bx<cy>::by(*this); }
167 namespace basic {
168 class u {
169 using de = ce;
170 void v(cd, b);
171 cy<de> df;
172 };
173 void u::v(cd, b) {
174 df.clear();
175 df.r();
176 }
177 } // namespace basic
178 } // namespace a