gnu/dist/gcc4/gcc/testsuite/g++.dg/opt/const1.C

   1 // This testcase was miscompiled on IA-64 to read from unitialized memory
   2 // and dereference it.
   3 // { dg-do run }
   4 // { dg-options "-O2" }
   5
   6 struct A
   7 {
   8   A () { a = 1; }
   9   void a1 () { a++; }
  10   bool a2 () { return !--a; }
  11   unsigned int a;
  12 };
  13
  14 struct B {};
  15
  16 template <class T> struct C
  17 {
  18   C () {}
  19   C (const T& t) : c (t) {}
  20   C<T> *next, *prev;
  21   T c;
  22 };
  23
  24 template <class T> struct D
  25 {
  26   C<T> *d;
  27   D () : d (0) {}
  28   D (C<T> *x) : d (x) {}
  29   D (const D<T>& x) : d (x.d) {}
  30   bool operator!= (const D<T>& x) const { return d != x.d; }
  31   const T& operator* () const { return d->c; }
  32   D<T> operator++ (int) { D<T> t = *this; d = d->next; return t; }
  33 };
  34
  35 template <class T> struct E
  36 {
  37   C<T> *e;
  38   E () : e (0) {}
  39   E (C<T> *p) : e (p) {}
  40   E (const E<T>& x) : e (x.e) {}
  41   E (const D<T>& x) : e (x.e) {}
  42   bool operator!= (const E<T>& x) const { return e != x.e; }
  43   const T& operator* () const { return e->c; }
  44   E<T>& operator++ () { e = e->next; return *this; }
  45 };
  46
  47 template <class T> struct F : public A
  48 {
  49   C<T> *f;
  50   unsigned long f0;
  51   F () { f = new C<T>; f->next = f->prev = f; f0 = 0; }
  52   F (const F<T>& x) : A ()
  53   {
  54     f = new C<T>; f->next = f->prev = f; f0 = 0;
  55     D<T> b (x.f->next), e (x.f), i (f);
  56     while (b != e)
  57       f1 (i, *b++);
  58   }
  59
  60   ~F ()
  61   {
  62     C<T> *p = f->next;
  63     while (p != f)
  64       {
  65         C<T> *x = p->next;
  66         delete p;
  67         p = x;
  68       }
  69     delete f;
  70   }
  71
  72   D<T> f1 (D<T> x, const T& y)
  73   {
  74     C<T> *p = new C<T> (y);
  75     p->next = x.d;
  76     p->prev = x.d->prev;
  77     x.d->prev->next = p;
  78     x.d->prev = p;
  79     f0++;
  80     return p;
  81   }
  82 };
  83
  84 template <class T> struct G
  85 {
  86   F<T> *g;
  87   G () { g = new F<T>; }
  88   G (const G<T>& x) { g = x.g; g->a1 (); }
  89   ~G () {}
  90   G<T>& operator= (const G<T>& x) { x.g->a1 (); g = x.g; return *this; }
  91   D<T> g1 () { g4 (); return D<T> (g->f); }
  92   E<T> g1 () const { return E<T> (g->f); }
  93   E<T> g2 () const { return E<T> (g->f->next); }
  94   D<T> g3 (const T& x) { g4 (); return g->f1 (g1 (), x); }
  95   void g4 () { if (g->a > 1) { g->a2 (); g = new F<T> (*g); } }
  96
  97   G<T> operator+ (const G<T>& x) const
  98   {
  99     G<T> x2 (*this);
 100     for (E<T> i = x.g2 (); i != x.g1 (); ++i)
 101       x2.g3 (*i);
 102     return x2;
 103   }
 104
 105   G<T>& operator+= (const G<T>& x)
 106   {
 107     for (E<T> i = x.g2 (); i != x.g1 (); ++i)
 108       g3 (*i);
 109     return *this;
 110   }
 111 };
 112
 113 struct H : public G<B>
 114 {
 115   H () {}
 116   H (const H& x) : G<B> (x) {}
 117   H (const G<B>& x) : G<B> (x) {}
 118 };
 119
 120 void foo ();
 121
 122 int
 123 main ()
 124 {
 125   H a = H () + H ();
 126   a += H ();
 127   H b;
 128   b = H () + H ();
 129 }