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

--- Comment #6 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Somewhat reduced but it's still ugly:

```
extern "C" void __assert_fail(const char *, const char *);
struct Data;
void *operator new(unsigned long, void *__p) { return __p; }
template <typename> struct __new_allocator {
  Data *allocate(long __n) {
    return static_cast<Data *>(__builtin_operator_new(__n));
  }
  template <typename _Up, typename... _Args>
  void construct(_Up *__p, _Args... __args) {
    new (__p) _Up(__args...);
  }
};
template <typename> struct allocator_traits;
template <typename _Up> using rebind_alloc = __new_allocator<_Up>;
template <typename _Tp> struct allocator_traits<__new_allocator<_Tp>> {
  using allocator_type = __new_allocator<_Tp>;
  using pointer = _Tp *;
  static pointer allocate() {
    allocator_type __a;
    return __a.allocate(0);
  }
  template <typename _Up, typename... _Args>
  static void construct(allocator_type __a, _Up __p, _Args... __args) {
    __a.construct(__p, __args...);
  }
};
struct __alloc_traits : allocator_traits<__new_allocator<Data>> {};
template <typename _ForwardIterator>
_ForwardIterator __uninitialized_fill_n_a(_ForwardIterator __first, long __n,
                                          const Data &__x,
                                          __new_allocator<Data> __alloc) {
  for (; __n; --__n, ++__first) {
    Data *__trans_tmp_1(__first);
    __alloc_traits::construct(__alloc, __trans_tmp_1, __x);
  }
  return __first;
}
typedef __alloc_traits::pointer pointer;
pointer P, _M_impl_1;
struct _Vector_base {
  _Vector_base(long __n) {
    P = __alloc_traits::allocate();
  }
};
struct vector : _Vector_base {
  vector(long __n, const Data &__value) : _Vector_base(__n) {
    long __trans_tmp_4 = __n;
    rebind_alloc<Data> __trans_tmp_2;
    _M_impl_1 = __uninitialized_fill_n_a(P,
                                         __trans_tmp_4, __value,
__trans_tmp_2);
  }
  pointer begin() { return P; }
  pointer end() { return _M_impl_1; }
};


struct Foo {
  virtual ~Foo() = default;
};
struct Data {
  int status;
  Foo data{};
};
int kValue;
struct Vector : vector {
  Vector(long size) : vector(size, Data{}) {}
};

int main() {
  Vector items_(10);
  for (auto item : items_)
    item.status == kValue ? void() : __assert_fail("", __builtin_FILE());
}
```

Reply via email to