[Bug tree-optimization/92715] [10 Regression] error: position plus size exceeds size of referenced object in ‘bit_field_ref’

[dcb314 at hotmail dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92715

--- Comment #5 from David Binderman <dcb314 at hotmail dot com> ---
Reduced C++ code:

typedef double a __attribute__((__vector_size__(32)));
double b;
a c;
enum { d, e };
template <typename> struct h;
template <typename> class i;
template <typename, int g, int, int = 0, int = g, int = d> class aa;
template <typename> class j;
template <typename, typename> class ab;
template <typename> struct ae;
template <typename> struct w;
template <typename af> struct x { typedef typename ae<af>::k k; };
template <typename ah> struct y { typedef j<ah> k; };
template <typename ai> ai aj(const typename w<ai>::k &);
template <> struct ae<double> { typedef a k; };
template <> struct w<a> { typedef double k; };
template <> a aj(const double &ak) {
  c = a{ak, ak, ak, ak};
  return c;
}
struct z {
  z(double am) : an(am) {}
  template <typename ag> void ao() { aj<ag>(an); }
  double an;
};
struct ap {
  template <int, typename ai> void aq(double *, ai);
};
template <typename ah> class ar {
public:
  typedef typename h<ah>::al al;
  typedef aa<al, h<ah>::as, h<ah>::at, e, h<ah>::au, h<ah>::av> aw;
  typedef ab<z, aw> ax;
  const ax ay(const al &);
  template <typename az> const ab<az, aw> ba(const az &);
  ah &operator/=(const al &);
};
template <typename ah> class j : public ar<ah> {};
template <typename ah> struct ac { typename ah::al &bb(long); };
template <typename al, int bc, int bd, int be, int bf, int bg>
struct ac<aa<al, bc, bd, be, bf, bg>> : ac<i<aa<al, bf, bg>>> {
  typedef aa<al, bc, bd> bh;
  ac(bh);
};
struct bi {
  template <typename af, typename bj> void ao(z bk, bj) { bk.ao<af>(); }
};
template <typename bl, typename bm> struct ac<ab<bl, bm>> {
  ac(ab<bl, bm> l) : bn(l.bo()) {}
  template <int, typename ag, typename bj> ag bp(bj bq) { br.ao<ag>(bn, bq); }
  bl bn;
  bi br;
};
template <typename bs> struct bt {
  typedef typename bs::bh bu;
  typedef typename x<typename bu::al>::k ag;
};
template <typename bv> struct bw {
  static void bx(bv by) {
    enum { bz, ca, cb };
    by.template aq<ca, cb, typename bv::ag>(bz);
  }
};
template <typename cc, typename cd, typename ce> class cf {
public:
  typedef cc cg;
  typedef cd ch;
  typedef typename bt<cc>::ag ag;
  cf(cg ci, ch cj, ce, cc) : ck(ci), cl(cj) {}
  template <int dg, int cm, typename> void aq(long bq) {
    bn.template aq<dg>(&ck.bb(bq), cl.template bp<cm, ag>(bq));
  }
  cg ck;
  ch cl;
  ce bn;
};
template <typename cn, typename co, typename ce> void cp(cn ci, co cj, ce cq) {
  typedef ac<cn> cg;
  typedef ac<co> ch;
  ch a(cj);
  cg d(ci);
  typedef cf<cg, ch, ce> bv;
  bv e(d, a, cq, ci);
  bw<bv>::bx(e);
}
template <typename bu, typename cr, typename cs> void m(bu ci, cr cj, cs cq) {
  ab<z, aa<double, 0, 1, 1, 2, 3>> n = cj;
  cp(ci, n, cq);
}
template <typename ah> class i : public y<ah>::k {};
template <typename o, int g, int ad, int u, int q, int r>
struct h<aa<o, g, ad, u, q, r>> {
  typedef o al;
  enum { as, at, au, av };
};
template <typename o, int g, int, int, int, int>
class aa : public i<aa<o, g, d>> {};
template <typename, typename> class ab {
public:
  ab(long, long, z cq) : bn(cq) {}
  z bo() { return bn; }
  z bn;
};
template <typename ah>
template <typename az>
const ab<az, typename ar<ah>::aw> ar<ah>::ba(const az &cq) {
  return ab<az, aw>(0, 0, cq);
}
template <typename ah> const typename ar<ah>::ax ar<ah>::ay(const al &p) {
  return ba(z(p));
}
template <typename ah> ah &ar<ah>::operator/=(const al &am) {
  ah s;
  ab<z, aa<double, 0, 1, 1, 2, 3>> t = ay(am);
  m(s, t, ap());
}
void v() {
  aa<double, 1, 1> f;
  __attribute__((__vector_size__(2 * sizeof(double)))) double g;
  b = g[0];
  f /= b;
}