egcs in broken.

[hjl at lucon dot org (H.J. Lu)]

This is a follow up on

http://www.cygnus.com/ml/egcs/1998-Jul/0012.html

Compile it with -O2. The resuling binary goes into an infinite
loop on linux/x86. Could someone please fix it?

Thanks.


-- 
H.J. Lu (hjl@gnu.org)
----
typedef void* Pix;
class intSet
{
protected:
  int                   count;
public:
  inline virtual              ~intSet();
  int                   length();                 
  int                   empty();
  virtual Pix           add(int  item) = 0;       
  virtual void          del(int  item) = 0;       
  virtual int           contains(int  item);      
  virtual void          clear();                  
  virtual Pix           first() = 0;              
  virtual void          next(Pix& i) = 0;         
  virtual int&          operator () (Pix i) = 0;  
  virtual int           owns(Pix i);              
  virtual Pix           seek(int  item);          
  void                  operator |= (intSet& b);  
  void                  operator -= (intSet& b);  
  void                  operator &= (intSet& b);  
  int                   operator == (intSet& b);
  int                   operator != (intSet& b);
  int                   operator <= (intSet& b); 
  virtual int           OK() = 0;                 
};
inline intSet::~intSet() {}
int intSet::length()
{
  return count;
}
int intSet::empty()
{
  return count == 0;
}
struct intSLListNode
{
  intSLListNode*         tl;
  int                    hd;
                         intSLListNode() { }
                         intSLListNode(const int  h, intSLListNode* t = 0);
                         ~intSLListNode() { }
};
inline intSLListNode::intSLListNode(const int  h, intSLListNode* t)
:tl(t), hd(h) {}
typedef intSLListNode* intSLListNodePtr;
class intSLList
{
protected:
  intSLListNode*        last;
public:
                        intSLList();
                        intSLList(const intSLList& a);
                        ~intSLList();
  intSLList&            operator = (const intSLList& a);
  int                   empty();
  int                   length();
  void                  clear();
  Pix                   prepend(int  item);
  Pix                   append(int  item);
  void                  join(intSLList&);
  Pix                   prepend(intSLListNode*);
  Pix                   append(intSLListNode*);
  int&                  operator () (Pix p);
  Pix                   first();
  void                  next(Pix& p);
  int                   owns(Pix p);
  Pix                   ins_after(Pix p, int  item);
  void                  del_after(Pix p);
  int&                  front();
  int&                  rear();
  int                   remove_front();
  int                   remove_front(int& x);
  void                  del_front();
  int                   OK();
};
inline intSLList::~intSLList()
{
  clear();
}
inline intSLList::intSLList()
{
  last = 0;
}
inline int intSLList::empty()
{
  return last == 0;
}
inline Pix intSLList::first()
{
  return (last == 0)? 0 : Pix(last->tl);
}
inline void intSLList::next(Pix& p)
{
  p = (p == 0 || p == last)? 0 : Pix(((intSLListNode*)(p))->tl);
}
inline int& intSLList::operator () (Pix p)
{
  return ((intSLListNode*)(p))->hd;
}
inline int& intSLList::front()
{
  return last->tl->hd;
}
inline int& intSLList::rear()
{
  return last->hd;
}
class intSLSet : public intSet
{
protected:
  intSLList     p;
public:
                intSLSet();
                intSLSet(const intSLSet&);
  Pix           add(int  item);
  void          del(int  item);
  inline int           contains(int  item);
  inline void          clear();
  inline Pix           first();
  inline void          next(Pix& i);
  inline int&          operator () (Pix i);
  inline int           owns(Pix i);
  Pix           seek(int  item);
  int           OK();
};
inline intSLSet::intSLSet() : p() { count = 0; }
inline intSLSet::intSLSet(const intSLSet& s) : p(s.p) { count = s.count; }
inline Pix intSLSet::first()
{
  return p.first();
}
inline void intSLSet::next(Pix  & idx)
{
  p.next(idx);
}
inline int& intSLSet::operator ()(Pix   idx)
{
  return p(idx);
}
inline void intSLSet::clear()
{
  count = 0;  p.clear();
}
inline int intSLSet::contains (int  item)
{
  return seek(item) != 0;
}
inline int intSLSet::owns (Pix   idx)
{
  return p.owns(idx);
}
int intSLSet::OK()
{
  int v = p.OK();
  v &= count == p.length();
  if (!v) return -1;
  return v;
}
Pix intSLSet::seek(int  item)
{
  Pix i;
  for (i = p.first(); i != 0 && ! (( p(i) ) == ( item )) ; p.next(i));
  return i;
}
Pix intSLSet::add(int  item)
{
  Pix i = seek(item);
  if (i == 0)
  {
    ++count;
    i = p.append(item);
  }
  return i;
}
void intSLSet::del(int  item)
{
  Pix i = p.first();
  if (i == 0)
    return;
  else if ((( p(i) ) == (  item )) )
  {
    --count;
    p.del_front();
  }
  else
  {
    Pix trail = i;
    p.next(i);
    while (i != 0)
    {
      if ((( p(i) ) == (  item )) )
      {
        --count;
        p.del_after(trail);
        return;
      }
      trail = i;
      p.next(i);
    }
  }
}    

int intSLList::length()
{
  int l = 0;
  intSLListNode* t = last;
  if (t != 0) do { ++l; t = t->tl; } while (t != last);
  return l;
}
intSLList::intSLList(const intSLList& a)
{
  if (a.last == 0)
    last = 0;
  else
  {
    intSLListNode* p = a.last->tl;
    intSLListNode* h = new intSLListNode(p->hd);
    last = h;
    for (;;)
    {
      if (p == a.last)
      {
        last->tl = h;
        return;
      }
      p = p->tl;
      intSLListNode* n = new intSLListNode(p->hd);
      last->tl = n;
      last = n;
    }
  }
}
intSLList& intSLList::operator = (const intSLList& a)
{
  if (last != a.last)
  {
    clear();
    if (a.last != 0)
    {
      intSLListNode* p = a.last->tl;
      intSLListNode* h = new intSLListNode(p->hd);
      last = h;
      for (;;)
      {
        if (p == a.last)
        {
          last->tl = h;
          break;
        }
        p = p->tl;
        intSLListNode* n = new intSLListNode(p->hd);
        last->tl = n;
        last = n;
      }
    }
  }
  return *this;
}
void intSLList::clear()
{
  if (last == 0)
    return;
  intSLListNode* p = last->tl;
  last->tl = 0;
  last = 0;
  while (p != 0)
  {
    intSLListNode* nxt = p->tl;
    delete(p);
    p = nxt;
  }
}
Pix intSLList::prepend(int  item)
{
  intSLListNode* t = new intSLListNode(item);
  if (last == 0)
    t->tl = last = t;
  else
  {
    t->tl = last->tl;
    last->tl = t;
  }
  return Pix(t);
}
Pix intSLList::prepend(intSLListNode* t)
{
  if (t == 0) return 0;
  if (last == 0)
    t->tl = last = t;
  else
  {
    t->tl = last->tl;
    last->tl = t;
  }
  return Pix(t);
}
Pix intSLList::append(int  item)
{
  intSLListNode* t = new intSLListNode(item);
  if (last == 0)
    t->tl = last = t;
  else
  {
    t->tl = last->tl;
    last->tl = t;
    last = t;
  }
  return Pix(t);
}
Pix intSLList::append(intSLListNode* t)
{
  if (t == 0) return 0;
  if (last == 0)
    t->tl = last = t;
  else
  {
    t->tl = last->tl;
    last->tl = t;
    last = t;
  }
  return Pix(t);
}
void intSLList::join(intSLList& b)
{
  intSLListNode* t = b.last;
  b.last = 0;
  if (last == 0)
    last = t;
  else if (t != 0)
  {
    intSLListNode* f = last->tl;
    last->tl = t->tl;
    t->tl = f;
    last = t;
  }
}
Pix intSLList::ins_after(Pix p, int  item)
{
  intSLListNode* u = (intSLListNode*)p;
  intSLListNode* t = new intSLListNode(item);
  if (last == 0)
    t->tl = last = t;
  else if (u == 0)  
  {
    t->tl = last->tl;
    last->tl = t;
  }
  else
  {
    t->tl = u->tl;
    u->tl = t;
    if (u == last) 
      last = t;
  }
  return Pix(t);
}
void intSLList::del_after(Pix p)
{
  intSLListNode* u = (intSLListNode*)p;
  if (last == 0 || u == last) return;
  if (u == 0) u = last;  
  intSLListNode* t = u->tl;
  if (u == t)
    last = 0;
  else
  {
    u->tl = t->tl;
    if (last == t)
      last = u;
  }
  delete t;
}
int intSLList::owns(Pix p)
{
  intSLListNode* t = last;
  if (t != 0 && p != 0)
  {
    do
    {
      if (Pix(t) == p) return 1;
      t = t->tl;
    } while (t != last);
  }
  return 0;
}
int intSLList::remove_front()
{
  intSLListNode* t = last->tl;
  int res = t->hd;
  if (t == last)
    last = 0;
  else
    last->tl = t->tl;
  delete t;
  return res;
}
int intSLList::remove_front(int& x)
{
  if (last == 0)
    return 0;
  else
  {
    intSLListNode* t = last->tl;
    x = t->hd;
    if (t == last)
      last = 0;
    else
      last->tl = t->tl;
    delete t;
    return 1;
  }
}
void intSLList::del_front()
{
  if (last == 0) return;
  intSLListNode* t = last->tl;
  if (t == last)
    last = 0;
  else
    last->tl = t->tl;
  delete t;
}
int intSLList::OK()
{
  int v = 1;
  if (last != 0)
  {
    intSLListNode* t = last;
    long count = 2147483647L;       
    do
    {
      count--;
      t = t->tl;
    } while (count > 0 && t != last);
    v &= count > 0;
  }
  return v;
}

Pix intSet::seek(int  item)
{
  Pix i;
  for (i = first(); i != 0 && !((*this)(i) == item); next(i));
  return i;
}

int intSet::owns(Pix idx)
{
  if (idx == 0) return 0;
  for (Pix i = first(); i; next(i)) if (i == idx) return 1;
  return 0;
}

void intSet::clear()
{
  Pix i = first(); 
  while (i != 0)
  {
    del((*this)(i));
    i = first();
  }
}

int intSet::contains (int  item)
{
  return seek(item) != 0;
}

int intSet::operator <= (intSet& b)
{
  if (count > b.count) return 0;
  if (count == 0) return 1;
  for (Pix i = first(); i; next(i)) if (b.seek((*this)(i)) == 0) return 0;
  return 1;
}

int intSet::operator == (intSet& b)
{
  int n = count;
  if (n != b.count) return 0;
  if (n == 0) return 1;
  Pix i = first();
  Pix j = b.first();
  while (n-- > 0)
  {
    if ((b.seek((*this)(i)) == 0) || (seek(b(j)) == 0)) return 0;
    next(i);
    b.next(j);
  }
  return 1;
}

int intSet::operator != (intSet& b)
{
  return !(*this == b);
}

void intSet::operator |= (intSet& b)
{
  if (&b != this)
    for (Pix i = b.first(); i; b.next(i)) add(b(i));
}

void intSet::operator -= (intSet& b)
{
  if (&b == this)
    clear();
  else
    for (Pix i = b.first(); i; b.next(i)) del(b(i));
}


void intSet::operator &= (intSet& b)
{
  if (&b != this)
  {
    Pix i = first();
    Pix n = i;
    while (i != 0)
    {
      next(n);
      if (b.seek((*this)(i)) == 0) del((*this)(i));
      i = n;
    }
  }
}
main ()
{
  intSLSet a;
  int x [2] = {0, 1};
  for (int i = 0; i < 2; i++)
    a.add(x[i]);

  return a.length ();
}