void (*__constructor) (void *),
void (*__destructor) (void *));
+extern "C"
+void *__cxa_vec_new2 (__SIZE_TYPE__ __element_count,
+ __SIZE_TYPE__ __element_size,
+ __SIZE_TYPE__ __padding_size,
+ void (*__constructor) (void *),
+ void (*__destructor) (void *),
+ void *(*__alloc) (__SIZE_TYPE__),
+ void (*__dealloc) (void *));
+
+extern "C"
+void *__cxa_vec_new3 (__SIZE_TYPE__ __element_count,
+ __SIZE_TYPE__ __element_size,
+ __SIZE_TYPE__ __padding_size,
+ void (*__constructor) (void *),
+ void (*__destructor) (void *),
+ void *(*__alloc) (__SIZE_TYPE__),
+ void (*__dealloc) (void *, __SIZE_TYPE__));
+
/* construct array */
extern "C"
void __cxa_vec_ctor (void *__array_address,
__SIZE_TYPE__ __padding_size,
void (*__destructor) (void *));
+extern "C"
+void __cxa_vec_delete2 (void *__array_address,
+ __SIZE_TYPE__ __element_size,
+ __SIZE_TYPE__ __padding_size,
+ void (*__destructor) (void *),
+ void (*__dealloc) (void *));
+
+extern "C"
+void __cxa_vec_delete3 (void *__array_address,
+ __SIZE_TYPE__ __element_size,
+ __SIZE_TYPE__ __padding_size,
+ void (*__destructor) (void *),
+ void (*__dealloc) (void *, __SIZE_TYPE__));
+
/* demangling routines */
extern "C"
void (*constructor) (void *),
void (*destructor) (void *))
{
+ return __cxa_vec_new2 (element_count, element_size, padding_size,
+ constructor, destructor,
+ &operator new[], &operator delete []);
+}
+
+extern "C" void *
+__cxa_vec_new2 (size_t element_count,
+ size_t element_size,
+ size_t padding_size,
+ void (*constructor) (void *),
+ void (*destructor) (void *),
+ void *(*alloc) (size_t),
+ void (*dealloc) (void *))
+{
size_t size = element_count * element_size + padding_size;
- char *base = static_cast <char *> (operator new[] (size));
+ char *base = static_cast <char *> (alloc (size));
if (padding_size)
{
}
catch (...)
{
- // operator delete [] cannot throw, so no need to protect it
- operator delete[] (base - padding_size);
+ __uncatch_exception ();
+ dealloc (base - padding_size);
+ throw;
+ }
+ return base;
+}
+
+extern "C" void *
+__cxa_vec_new3 (size_t element_count,
+ size_t element_size,
+ size_t padding_size,
+ void (*constructor) (void *),
+ void (*destructor) (void *),
+ void *(*alloc) (size_t),
+ void (*dealloc) (void *, size_t))
+{
+ size_t size = element_count * element_size + padding_size;
+ char *base = static_cast <char *> (alloc (size));
+
+ if (padding_size)
+ {
+ base += padding_size;
+ reinterpret_cast <size_t *> (base)[-1] = element_count;
+ }
+ try
+ {
+ __cxa_vec_ctor (base, element_count, element_size,
+ constructor, destructor);
+ }
+ catch (...)
+ {
+ __uncatch_exception ();
+ dealloc (base - padding_size, size);
throw;
}
return base;
{
if (unwinding)
// [except.ctor]/3 If a destructor called during stack unwinding
- // exists with an exception, terminate is called.
+ // exits with an exception, terminate is called.
std::terminate ();
__uncatch_exception ();
__cxa_vec_dtor (array_address, ix, element_size, destructor);
size_t padding_size,
void (*destructor) (void *))
{
+ __cxa_vec_delete2 (array_address, element_size, padding_size,
+ destructor,
+ &operator delete []);
+}
+
+extern "C" void
+__cxa_vec_delete2 (void *array_address,
+ size_t element_size,
+ size_t padding_size,
+ void (*destructor) (void *),
+ void (*dealloc) (void *))
+{
+ char *base = static_cast <char *> (array_address);
+
+ if (padding_size)
+ {
+ size_t element_count = reinterpret_cast <size_t *> (base)[-1];
+ base -= padding_size;
+ try
+ {
+ __cxa_vec_dtor (array_address, element_count, element_size,
+ destructor);
+ }
+ catch (...)
+ {
+ __uncatch_exception ();
+ dealloc (base);
+ throw;
+ }
+ }
+ dealloc (base);
+}
+
+extern "C" void
+__cxa_vec_delete3 (void *array_address,
+ size_t element_size,
+ size_t padding_size,
+ void (*destructor) (void *),
+ void (*dealloc) (void *, size_t))
+{
char *base = static_cast <char *> (array_address);
+ size_t size = 0;
if (padding_size)
{
size_t element_count = reinterpret_cast <size_t *> (base)[-1];
base -= padding_size;
+ size = element_count * element_size + padding_size;
try
{
__cxa_vec_dtor (array_address, element_count, element_size,
}
catch (...)
{
- // operator delete [] cannot throw, so no need to protect it
- operator delete[] (base);
+ __uncatch_exception ();
+ dealloc (base, size);
throw;
}
}
- operator delete[] (base);
+ dealloc (base, size);
}
} // namespace __cxxabiv1