[Bug middle-end/60787] [4.7 Regression] ICE in expand_builtin_eh_common, at except.c:1953

[trippels at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=60787

Markus Trippelsdorf <trippels at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2014-04-08
                 CC|                            |trippels at gcc dot gnu.org
     Ever confirmed|0                           |1

--- Comment #2 from Markus Trippelsdorf <trippels at gcc dot gnu.org> ---
This is what creduce came up with:

template <class T> void destroy (T *);
template <class FI> struct ArrayFill
{
  ArrayFill (FI, FI &p2) : tgt_start_ (), tgt_end_ (p2) {}
  template <class Val> void m_fn1 (Val &, int &)
  {
    while (tgt_cur_ != tgt_end_)
      ++tgt_cur_;
  }
  ~ArrayFill () throw()
  {
    if (tgt_cur_ != tgt_end_)
      while (tgt_cur_ != tgt_start_)
        {
          --tgt_cur_;
          destroy (&*tgt_cur_);
        }
  }
  const FI tgt_start_, tgt_end_;
  FI tgt_cur_;
};

template <class FI, class Val>
inline FI uninitialized_fill (FI &p1, FI &p2, Val &p3, int &p4)
{
  ArrayFill<FI> a (p1, p2);
  a.m_fn1 (p3, p4);
}

template <class, typename> struct A
{
  typedef int *pointer;
  typedef int &const_reference;
  template <class Val2> int m_fn1 (const A<Val2, int> &p1)
  {
    return cur_ == p1.cur_;
  }
  const_reference operator*() {}
  void operator++()
  {
    if (last_)
      cur_ = first_;
  }
  void operator--() { --cur_; }
  pointer cur_;
  pointer first_;
  pointer last_;
};

template <class Val, class Val2, typename BufSize>
inline int operator==(A<Val, BufSize> &p1, const A<Val2, BufSize> &p2)
{
  return p1.m_fn1 (p2);
}

template <class Val, class Val2, typename BufSize>
inline int operator!=(A<Val, BufSize> &p1, const A<Val2, BufSize> &p2)
{
  return !(p1 == p2);
}

struct B
{
  typedef A<int, int>::const_reference const_reference;
};
class C
{
public:
  typedef B::const_reference const_reference;
  int *p_ma_;
  struct MapCreator
  {
    ~MapCreator ();
  };
  struct MultiNodeCreator
  {
    MultiNodeCreator (A<int, int>::pointer *, A<int, int>::pointer *, int &p3)
        : ma_ (p3)
    {
    }
    ~MultiNodeCreator () throw();
    void m_fn1 ();
    int &ma_;
  };
  void m_fn1 (A<int, int>::pointer *, A<int, int>::pointer *, int &)
  {
    MultiNodeCreator b (0, 0, *p_ma_);
    b.m_fn1 ();
  }
  C::MapCreator initialize_map__new_map;
  int &m_fn2_p3;
  void m_fn2 (int, int)
  {
    m_fn1 (0, 0, m_fn2_p3);
    this->finish_.cur_ = this->finish_.first_;
  }
  C (int &);
  A<int, int> start_;
  A<int, int> finish_;
};

class G : C
{
  void m_fn3 (const_reference p1, const int &)
  {
    this->m_fn2 (0, 0);
    uninitialized_fill (this->start_, this->finish_, p1, *this->p_ma_);
  }
public:
  G (int, const_reference p2, int &p3) : C (p3) { m_fn3 (p2, 0); }
  void m_fn4 (const_reference p1) { G (0, p1, *this->p_ma_); }
};

class F
{
  void m_fn1 (int &);
  G m_jobs;
};
void F::m_fn1 (int &p1) { m_jobs.m_fn4 (p1); }