| /* PR target/97682 */ |
| /* { dg-do compile } */ |
| /* { dg-options "-fPIC -O2 -march=rv64g -mabi=lp64" } */ |
| |
| template <typename ab, int ac> struct g { ab b[ac]; }; |
| long i, m; |
| |
| namespace std |
| { |
| template <typename c> struct t |
| { |
| int a; |
| c h; |
| }; |
| |
| struct ad |
| { |
| enum { j }; |
| }; |
| |
| template <typename k> k l(k); |
| struct al {}; |
| template <typename k> k aa(k); |
| |
| struct v |
| { |
| template <typename n, typename q> static q o(n, n, q); |
| }; |
| |
| template <int, typename n, typename q> void p(n z, n ao, q ap) |
| { |
| v::o(z, ao, ap); |
| } |
| |
| template <int ae, typename n, typename q> void r(n z, n ao, q ap) |
| { |
| p<ae>(z, ao, ap); |
| } |
| |
| template <int ae, typename n, typename q> void af(n z, n ao, q) |
| { |
| r<ae>(aa(z), aa(ao), 0); |
| } |
| |
| template <typename n, typename q> void ag(n z, n ao, q ap) |
| { |
| af<ad::j>(l(z), l(ao), ap); |
| } |
| |
| template <typename> class allocator; |
| template <typename ah, typename ai, typename aj> void ak(ah, ai, aj); |
| |
| template <typename s> class aq |
| { |
| template <typename am> struct ar { using f = am *; }; |
| public: |
| using an = typename ar<s>::f; |
| }; |
| |
| template <typename s> class as |
| { |
| public: |
| using an = typename aq<s>::an; |
| an operator->(); |
| }; |
| |
| struct ay |
| { |
| int at(); |
| }; |
| |
| template <typename s, typename = allocator<s>> class vector : ay |
| { |
| public: |
| long au(); |
| long x; |
| void av() { _M_default_append(x); } |
| void _M_default_append(unsigned long); |
| void aw(); |
| long ax(int); |
| }; |
| |
| template <typename s, typename y> |
| void vector<s, y>::_M_default_append(unsigned long z) |
| { |
| long az = au(); |
| int w = at(), bc = at(); |
| i = ax(w); |
| m = ax(w); |
| if (i || m) |
| aw(); |
| ak(az, z, bc); |
| } |
| } |
| |
| namespace llvm |
| { |
| template <int bd> class bh |
| { |
| enum { bf = bd } * bg[bf]; |
| }; |
| |
| template <class> class bi; |
| |
| class bm |
| { |
| using bj = bi<int>; |
| std::as<bj> bk; |
| void bl(); |
| }; |
| |
| template <class> struct bn; |
| |
| class br |
| { |
| bh<8> bo; |
| }; |
| |
| class ca |
| { |
| int *d; |
| int e; |
| }; |
| |
| template <class bp> class bv : std::al, br |
| { |
| g<std::t<ca>, 8> b; |
| }; |
| |
| template <class ab> bv<ab> bt(ab); |
| |
| class BlockFrequencyInfoImplBase |
| { |
| public: |
| struct FrequencyData; |
| std::vector<FrequencyData> bu; |
| }; |
| |
| template <class> struct cb { using bw = int; }; |
| template <class bx> class bi : BlockFrequencyInfoImplBase |
| { |
| using bw = typename cb<bx>::bw; |
| public: |
| void bl(); |
| }; |
| |
| template <class bx> void bi<bx>::bl() |
| { |
| const bw *by; |
| bv<const int *> bz; |
| ag(bz, bt(by), 0); |
| bu.av(); |
| } |
| |
| template <> struct bn<const int *> { using u = ca; }; |
| void bm::bl() { bk->bl(); } |
| } |
| |
| /* The t1 register is to initial symbol reference for call instruction. */ |
| /* { dg-final { scan-assembler "la\tt1,.*FrequencyData.*_M_default_append.*" } } */ |