| // PR rtl-optimization/23478 |
| // { dg-do run } |
| // { dg-options "-O2" } |
| |
| extern "C" void abort (); |
| bool tthrow; |
| struct C3 { int i; }; |
| class C14 {}; |
| struct C7 |
| { |
| virtual ~C7 (); |
| }; |
| |
| C7::~C7 () |
| { |
| asm volatile ("" : : : "memory"); |
| } |
| class C2 : public C7 {}; |
| |
| template <class X> class C13 |
| { |
| bool ma; |
| X *mb; |
| public: |
| explicit C13 (X *p = 0) throw () : ma (p != 0), mb (p) {} |
| ~C13 (); |
| }; |
| |
| template <class X> |
| C13<X>::~C13 () |
| { |
| asm volatile ("" : : "r" (ma), "r" (mb) : "memory"); |
| } |
| |
| struct C1 |
| { |
| C1 (const C3 &, const C3 &, const C3 &, const C3 *&); |
| }; |
| |
| C1::C1 (const C3 &, const C3 &, const C3 &, const C3 *&) |
| { |
| if (!tthrow) |
| throw 24; |
| } |
| |
| struct C8 |
| { |
| struct C15 {}; |
| typedef C15 *C9; |
| virtual void f1 (C2 &, long *, void *, C3 &, void *, bool) = 0; |
| virtual C13<C14> f3 () const = 0; |
| virtual ~C8 () {} |
| }; |
| |
| bool |
| xx14 () |
| { |
| bool b = false; |
| if (tthrow) |
| throw 6; |
| asm volatile ("" : : "r" (&b) : "memory"); |
| return b; |
| } |
| |
| bool |
| xx2 () |
| { |
| bool b = false; |
| if (tthrow) |
| throw 6; |
| asm volatile ("" : : "r" (&b) : "memory"); |
| return b; |
| } |
| |
| C13<C7> |
| xx9 () |
| { |
| return C13<C7>(); |
| } |
| |
| C2 & |
| xx10 () |
| { |
| static C2 c2; |
| return c2; |
| } |
| |
| C3 & |
| xx12 () |
| { |
| static C3 c3 = { 1 }; |
| return c3; |
| } |
| |
| const C3 & |
| xx5 () |
| { |
| static const C3 c3 = { 2 }; |
| return c3; |
| } |
| |
| const C3 *& |
| xx4 () |
| { |
| static const C3 *p; |
| if (tthrow) |
| throw 6; |
| return p; |
| } |
| |
| long ll13; |
| |
| long |
| xx13 () |
| { |
| long ret; |
| asm volatile ("" : "=r" (ret) : "r" (ll13)); |
| return ret; |
| } |
| |
| void |
| xx15 (C3 &x, C13<C1> &y) |
| { |
| asm volatile ("" : : "r" (&x), "r" (&y) : "memory"); |
| } |
| |
| long |
| xx16 (const void *x) |
| { |
| long ret; |
| asm volatile ("" : "=r" (ret) : "0" (1), "r" (x) : "memory"); |
| return ret; |
| } |
| |
| void |
| xx1 (C13<C14> x) |
| { |
| asm volatile ("" : : "r" (&x) : "memory"); |
| if (tthrow) |
| throw 6; |
| } |
| |
| void |
| xx3 (const C7 *x) |
| { |
| if (x) |
| abort (); |
| } |
| |
| void |
| xx7 () |
| { |
| asm volatile ("" : : : "memory"); |
| } |
| |
| struct C5 |
| { |
| C13<C7> f2 (C3 &v1, const void *v2, C8 *v6); |
| C7 *m2[2]; |
| long m1[2]; |
| }; |
| |
| C13<C7> |
| C5::f2 (C3 &v1, const void *v2, C8 *v6) |
| { |
| C13<C7> v13 = xx9 (); |
| C2 &v9 = xx10 (); |
| for (long i = 1; i < 2; i++) |
| xx3 (m2[i]); |
| const C3 &ld = xx5 (); |
| xx7 (); |
| if (xx2 ()) |
| throw ""; |
| xx4 (); |
| C3 &si = xx12 (); |
| for (long i = 0; i < xx16 (v2); ++i) |
| { |
| C13<C1> sk (new C1 (xx5 (), ld, xx5 (), xx4 ())); |
| xx15 (si, sk); |
| } |
| long v4 = xx13 (); |
| for (long i = v4 - 1; i >= 0; --i) |
| m1[i] = i; |
| bool v8 = xx2 (); |
| for (long i = 0; i < 2 && !xx14 (); i++) |
| { |
| v6[i].f1 (v9, 0, __null, v1, __null, v8); |
| if (v8) |
| xx1 (v6[i].f3 ()); |
| } |
| return v13; |
| } |
| |
| int |
| main (void) |
| { |
| C5 c5 = { { __null, __null }, { 0, 0 } }; |
| bool seen = false; |
| try |
| { |
| c5.f2 (xx12 (), __null, __null); |
| } |
| catch (int n) |
| { |
| if (n != 24) |
| abort (); |
| seen = true; |
| } |
| if (!seen) |
| abort (); |
| } |