Mercurial > hg > CbC > CbC_gcc
diff gcc/testsuite/g++.target/i386/pr88785.C @ 145:1830386684a0
gcc-9.2.0
author | anatofuz |
---|---|
date | Thu, 13 Feb 2020 11:34:05 +0900 |
parents | |
children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gcc/testsuite/g++.target/i386/pr88785.C Thu Feb 13 11:34:05 2020 +0900 @@ -0,0 +1,197 @@ +// PR target/88785 +// { dg-do compile } +// { dg-options "-O2 -g -std=c++17 -mavx512vl -mavx512dq" } + +namespace a { +template <class> class b; +template <class> class d; +} +template <int f> struct g { static constexpr int e = f; }; +template <typename> struct aa; +template <typename...> struct o; +template <typename h, typename ab> struct o<h, ab> : aa<h>::ac {}; +template <typename...> struct j; +template <typename h, typename ab> struct j<h, ab> : aa<ab>::ac {}; +template <typename... k> constexpr bool l = o<k...>::e; +template <typename, typename> struct r : g<false> {}; +template <typename m> struct r<m, m> : g<true> {}; +template <typename ad> struct aa { typedef ad ac; }; +template <bool, typename ad, typename> using ae = ad; +template <typename...> using af = void; +typedef float ag __attribute__((__vector_size__(16))); +ag ah; +ag ai(__attribute__((__vector_size__(2 * sizeof(long long)))) long long z) { + ah = ag{}; + __attribute__((__vector_size__(4 * sizeof(float)))) float aj = ah; + return __builtin_ia32_cvtqq2ps128_mask(z, aj, 1); +} +namespace a { +int ak; +int al; +template <long> int am; +template <class> struct an; +template <class> struct ao; +template <class m> using ap = typename ao<m>::ac; +template <class, unsigned long, class = af<>> struct aq; +template <class m> using ar = aq<m, sizeof(m)>; +template <class as, class at> as au(at); +template <class> struct av; +template <class m> using aw = typename av<m>::ac; +template <class m, int ax> struct ay { + static constexpr long az = ax * sizeof(int); + using ac [[gnu::__vector_size__(az)]] = m; +}; +template <class m, long ba> using bb = typename ay<m, ba>::ac; +template <class m> struct p { + using bc = decltype(m()[0]); + static constexpr int bd = sizeof(bc); +}; +template <class as, class m, class = p<m>> as be(m); +template <class as, class... at> as bf(at... z) { return be<as>(z...); } +template <class m, unsigned long ax, class bg = aw<m>> bg bh(aq<m, ax>) { + return bg(); +} +template <> struct av<float> { + using ac [[gnu::__vector_size__(16)]] = float; +}; +template <class> struct av { + using ac [[gnu::__vector_size__(16)]] = long long; +}; +template <unsigned long bi> struct aq<bool, bi> {}; +template <class m, unsigned long bi, class bj = bb<m, bi>, + bool = l<r<bb<m, bi>, aw<m>>, r<bj, m>>> +struct bk; +template <class m, unsigned long bi, class bj> struct bk<m, bi, bj, true> { + bj bl; + bk(bb<m, bi> z) : bl(z) {} +}; +template <class m, unsigned long bi, class bj> struct bk<m, bi, bj, false> {}; +template <class m, unsigned long bi> struct aq<m, bi> : bk<m, bi> { + using bm = bb<m, bi>; + static constexpr long bd = bi; + aq(); + template <class bn> aq(bn z) : bk<m, bi>(z) {} + m operator[](long); +}; +template <class> constexpr long bo = g<0>::e; +template <class m> struct ao { using ac = typename an<m>::br; }; +template <class bp, class m> class bq { + using bu = m; + bp bs; + m bt; + +public: + template <class bn, class bv> void q(bn z, bv bw) { + auto s = bx(bt), by = bx(bs); + ap<bu>::bz(s, z, bw, by); + } +}; +class ca { +public: + template <class bn, class bv> void cb(bn, bv); +}; +template <class m> ca cc(typename b<m>::cd, m &); +template <class m> bq<d<m>, b<m>> cc(typename b<m>::cd, const m &); +struct ce; +template <class t, int ax> struct cf { + using br = typename t::br; + using cg = aq<long, ax>; + using ch = aq<long, ax>; +}; +struct ci { + template <class m> static constexpr long cj = sizeof(m); + struct ck : j<int, g<sizeof(int)>> {}; + template <class> static constexpr bool cl = ck::e; + using br = ce; + template <class m> using cn = ae<cl<m>, cf<ci, cj<m>>, int>; +}; +template <class> struct an : ci::cn<long> {}; +template <class> class d : an<int> { + using cm = ch; + +public: + cm bl; +}; +template <class m> auto bx(m z) { return z.bl; } +template <class> class b : an<int> { + using cm = cg; + +public: + using cd = d<long>; + static long cu(); + b(); + template <class bn, class bv> b(bn, bv) {} + cm bl; +}; +template <class m> auto bx(b<m> z) { return z.bl; } +template <class m, class co> void cq(ar<m>, co, aq<bool, ar<m>::bd>); +template <class as, class bu, class cp> as be(bu z) { + using cs = typename cp::bc; + constexpr long ax = cp::bd; + auto cr = bh(z); + aq<cs, ax> f; + using bn = typename p<as>::bc; + constexpr bool cy = sizeof(f), ct = sizeof(bn); + if (ct) + if (cy) { + ag cw = ai(cr); + return cw; + } +} +template <class as, class at> auto cv(at z) { return bf<as>(z); } +struct G { + template <class m> using ch = typename ci::cn<m>::ch; + template <class m, unsigned long ax, class bn, class co> + static void bz(aq<m, ax> z, bn *, co, ch<m> cx) { + using da = aq<bn, sizeof(bn)>; + using bu = typename da::bm; + using bp = aq<ae<1, bool, bn>, da::bd>; + auto cz = cv<bu>(z); + cq(da(cz), ae<0, int, co>(), au<bp>(cx)); + } +}; +struct ce : G {}; +} +class D { +public: + D(...); + template <typename db> void operator<<(db); +}; +template <class dc> dc dd; +struct de { + long cu(); +}; +template <typename dc> void dg() { + using db = long; + auto df = dd<a::b<long>>; + using a::ak; + using a::al; + constexpr long di = 1, alignment = a::bo<a::b<long>>; + using dh = ae<di, decltype(al), int>; + dh dk, am = a::am<alignment>; + const a::b<long> dj; + de u; + auto dm = 0 ? u.cu() : 0; + float dl[dm]; + db reference; + a::b<long> x; + auto compare = [&](long) { + int n; + a::b<long>(reference, ak); + for (auto i = 0; 0; ++i) + [] { + auto v = 0, w = 0; + return D(w, v); + }() << n; + }; + compare(0); + using c = a::b<long>::cd; + c dn; + a::b y = df; + auto v(y); + cc(dn, x).cb(dl, am); + long i; + cc(dn, dj).q(&dl[dc::cu()], dk); + ++i; +} +void test() { dg<a::b<long>>(); }