sources/cxx-stl/gabi++/src/cxxabi_vec.cc - toolchain/prebuilts/ndk/r13 - Git at Google

 // Copyright (C) 2013 The Android Open Source Project
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions
 // are met:
 // 1. Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
 // 2. Redistributions in binary form must reproduce the above copyright
 //    notice, this list of conditions and the following disclaimer in the
 //    documentation and/or other materials provided with the distribution.
 // 3. Neither the name of the project nor the names of its contributors
 //    may be used to endorse or promote products derived from this software
 //    without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 // ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 // SUCH DAMAGE.

 #include <cstddef>
 #include <new>

 #include "cxxabi_defines.h"

 using std::size_t;

 namespace {

 using namespace __cxxabiv1;

 typedef __cxa_vec_constructor constructor_func;
 typedef __cxa_vec_copy_constructor copy_constructor_func;
 typedef __cxa_vec_destructor destructor_func;
 typedef void* (*alloc_func)(size_t);
 typedef void (*dealloc_func)(void*);
 typedef void (*dealloc2_func)(void*, size_t);

 // Helper class to ensure a ptr is deallocated on scope exit unless
 // the release() method has been called.
 class scoped_block {
 public:
   scoped_block(void* ptr, size_t size, dealloc2_func dealloc)
     : ptr_(ptr), size_(size), dealloc_(dealloc) {}

   ~scoped_block() {
     if (dealloc_)
       dealloc_(ptr_, size_);
   }

   void release() {
     dealloc_ = 0;
   }

 private:
   void* ptr_;
   size_t size_;
   dealloc2_func dealloc_;
 };

 // Helper class to ensure a vector is cleaned up on scope exit
 // unless the release() method has been called.
 class scoped_cleanup {
 public:
   scoped_cleanup(void* array, size_t& index, size_t element_size,
                 destructor_func destructor)
     : array_(array), index_(index), element_size_(element_size),
       destructor_(destructor) {}

   ~scoped_cleanup() {
     if (destructor_)
       __cxxabiv1::__cxa_vec_cleanup(array_,
                                     index_,
                                     element_size_,
                                     destructor_);
   }

   void release() {
     destructor_ = 0;
   }
 private:
   void* array_;
   size_t& index_;
   size_t element_size_;
   destructor_func destructor_;
 };

 // Helper class that calls __fatal_error() with a given message if
 // it exits a scope without a previous call to release().
 class scoped_catcher {
 public:
   scoped_catcher(const char* message) : message_(message) {}

   ~scoped_catcher() {
     if (message_)
       __gabixx::__fatal_error(message_);
   }

   void release() {
     message_ = 0;
   }

 private:
   const char* message_;
 };

 }  // namespace

 namespace __cxxabiv1 {
 extern "C" {

 void* __cxa_vec_new(size_t element_count,
                     size_t element_size,
                     size_t padding_size,
                     constructor_func constructor,
                     destructor_func destructor) {
   return __cxa_vec_new2(element_count, element_size, padding_size,
                         constructor, destructor,
                         &operator new[], &operator delete []);
 }

 void* __cxa_vec_new2(size_t element_count,
                      size_t element_size,
                      size_t padding_size,
                      constructor_func constructor,
                      destructor_func destructor,
                      alloc_func alloc,
                      dealloc_func dealloc) {
   // The only difference with __cxa_vec_new3 is the type of the
   // dealloc parameter. force a cast because on all supported
   // platforms, it is possible to call the dealloc function here
   // with two parameters. The second one will simply be ignored.
   return __cxa_vec_new3(element_count, element_size, padding_size,
                         constructor, destructor, alloc,
                         reinterpret_cast<dealloc2_func>(dealloc));
 }

 void* __cxa_vec_new3(size_t element_count,
                      size_t element_size,
                      size_t padding_size,
                      constructor_func constructor,
                      destructor_func destructor,
                      alloc_func alloc,
                      dealloc2_func dealloc) {
   // Compute the size of the needed memory block, and throw
   // std::bad_alloc() on overflow.
   bool overflow = false;
   size_t size = 0;
   if (element_size > 0 && element_count > size_t(-1) / element_size)
     overflow = true;
   else {
     size = element_count * element_size;
     if (size + padding_size < size)
       overflow = true;
   }
   if (overflow)
     throw std::bad_alloc();

   // Allocate memory. Do not throw if NULL is returned.
   char* base = static_cast<char*>(alloc(size));
   if (!base)
     return base;

   // Ensure the block is freed if construction throws.
   scoped_block block(base, size, dealloc);

   if (padding_size) {
     base += padding_size;
     reinterpret_cast<size_t*>(base)[-1] = element_count;
 #ifdef __arm__
     // Required by the ARM C++ ABI.
     reinterpret_cast<size_t*>(base)[-2] = element_size;
 #endif
   }

   __cxa_vec_ctor(base, element_count, element_size,
                  constructor, destructor);

   // Construction succeeded, no need to release the block.
   block.release();
   return base;
 }

 #ifdef __arm__
 // On ARM, __cxa_vec_ctor and __cxa_vec_cctor must return
 // their first parameter. Handle this here.
 #define _CXA_VEC_CTOR_RETURN(x) return x
 #else
 #define _CXA_VEC_CTOR_RETURN(x) return
 #endif

 __cxa_vec_ctor_return_type
 __cxa_vec_ctor(void* array_address,
                size_t element_count,
                size_t element_size,
                constructor_func constructor,
                destructor_func destructor) {
   if (constructor) {
     size_t n = 0;
     char* base = static_cast<char*>(array_address);

     scoped_cleanup cleanup(array_address, n, element_size, destructor);
     for (; n != element_count; ++n) {
       constructor(base);
       base += element_size;
     }
     cleanup.release();
   }
   _CXA_VEC_CTOR_RETURN(array_address);
 }

 // Given the (data) address of an array, the number of elements,
 // and the size of its elements, call the given destructor on each
 // element. If the destructor throws an exception, rethrow after
 // destroying the remaining elements if possible. If the destructor
 // throws a second exception, call terminate(). The destructor
 // pointer may be NULL, in which case this routine does nothing.
 void __cxa_vec_dtor(void* array_address,
                     size_t element_count,
                     size_t element_size,
                     destructor_func destructor) {
   if (!destructor)
     return;

   char* base = static_cast<char*>(array_address);
   size_t n = element_count;
   scoped_cleanup cleanup(array_address, n, element_size, destructor);
   base += element_count * element_size;
   // Note: n must be decremented before the destructor call
   // to avoid cleaning up one extra unwanted item.
   while (n--) {
     base -= element_size;
     destructor(base);
   }
   cleanup.release();
 }

 // Given the (data) address of an array, the number of elements,
 // and the size of its elements, call the given destructor on each
 // element. If the destructor throws an exception, call terminate().
 // The destructor pointer may be NULL, in which case this routine
 // does nothing.
 void __cxa_vec_cleanup(void* array_address,
                        size_t element_count,
                        size_t element_size,
                        destructor_func destructor) {
   if (!destructor)
     return;

   char* base = static_cast<char*>(array_address);
   size_t n = element_count;
   base += n * element_size;

   scoped_catcher catcher("exception raised in vector destructor!");
   while (n--) {
     base -= element_size;
     destructor(base);
   }
   catcher.release();
 }

 // If the array_address is NULL, return immediately. Otherwise,
 // given the (data) address of an array, the non-negative size
 // of prefix padding for the cookie, and the size of its elements,
 // call the given destructor on each element, using the cookie to
 // determine the number of elements, and then delete the space by
 // calling ::operator delete[](void *). If the destructor throws an
 // exception, rethrow after (a) destroying the remaining elements,
 // and (b) deallocating the storage. If the destructor throws a
 // second exception, call terminate(). If padding_size is 0, the
 // destructor pointer must be NULL. If the destructor pointer is NULL,
 // no destructor call is to be made.
 void __cxa_vec_delete(void* array_address,
                       size_t element_size,
                       size_t padding_size,
                       destructor_func destructor) {
   __cxa_vec_delete2(array_address, element_size, padding_size,
                     destructor, &operator delete []);
 }

 // Same as __cxa_vec_delete, except that the given function is used
 // for deallocation instead of the default delete function. If dealloc
 // throws an exception, the result is undefined. The dealloc pointer
 // may not be NULL.
 void __cxa_vec_delete2(void* array_address,
                        size_t element_size,
                        size_t padding_size,
                        destructor_func destructor,
                        dealloc_func dealloc) {
   // Same trick than the one used on __cxa_vec_new2.
   __cxa_vec_delete3(array_address, element_size, padding_size,
                     destructor,
                     reinterpret_cast<dealloc2_func>(dealloc));
 }

 // Same as __cxa_vec_delete, except that the given function is used
 // for deallocation instead of the default delete function. The
 // deallocation function takes both the object address and its size.
 // If dealloc throws an exception, the result is undefined. The dealloc
 // pointer may not be NULL.
 void __cxa_vec_delete3(void* array_address,
                        size_t element_size,
                        size_t padding_size,
                        destructor_func destructor,
                        dealloc2_func dealloc) {
   if (!array_address)
     return;

   char* base = static_cast<char*>(array_address);

   if (!padding_size) {
     // If here is no padding size, asume the deallocator knows
     // how to handle this. Useful when called from __cxa_vec_delete2.
     dealloc(base, 0);
     return;
   }

   size_t element_count = reinterpret_cast<size_t*>(base)[-1];
   base -= padding_size;
   size_t size = element_count * element_size + padding_size;

   // Always deallocate base on exit.
   scoped_block block(base, size, dealloc);

   if (padding_size > 0 && destructor != 0)
     __cxa_vec_dtor(array_address, element_count, element_size, destructor);
 }

 __cxa_vec_ctor_return_type
 __cxa_vec_cctor(void* dst_array,
                 void* src_array,
                 size_t element_count,
                 size_t element_size,
                 copy_constructor_func copy_constructor,
                 destructor_func destructor) {
   if (copy_constructor) {
     size_t n = 0;
     char* dst = static_cast<char*>(dst_array);
     char* src = static_cast<char*>(src_array);

     scoped_cleanup cleanup(dst_array, n, element_size, destructor);

     for ( ; n != element_count; ++n) {
       copy_constructor(dst, src);
       dst += element_size;
       src += element_size;
     }

     cleanup.release();
   }
   _CXA_VEC_CTOR_RETURN(dst_array);
 }

 }  // extern "C"
 }  // namespace __cxxabiv1

 #if _GABIXX_ARM_ABI
 // The following functions are required by the ARM ABI, even
 // though neither GCC nor LLVM generate any code that uses it.
 // This may be important for machine code generated by other
 // compilers though (e.g. RCVT), which may depend on them.
 // They're supposed to simplify calling code.
 namespace __aeabiv1 {

 extern "C" {

 using namespace __cxxabiv1;

 void* __aeabi_vec_ctor_nocookie_nodtor(void* array_address,
                                        constructor_func constructor,
                                        size_t element_size,
                                        size_t element_count) {
   return __cxa_vec_ctor(array_address,
                         element_count,
                         element_size,
                         constructor,
                         /* destructor */ NULL);
 }

 void* __aeabi_vec_ctor_cookie_nodtor(void* array_address,
                                      constructor_func constructor,
                                      size_t element_size,
                                      size_t element_count) {
   if (!array_address)
     return array_address;

   size_t* base = reinterpret_cast<size_t*>(array_address) + 2;
   base[-2] = element_size;
   base[-1] = element_count;
   return __cxa_vec_ctor(base,
                         element_count,
                         element_size,
                         constructor,
                         /* destructor */ NULL);
 }

 void* __aeabi_vec_cctor_nocookie_nodtor(
     void* dst_array,
     void* src_array,
     size_t element_size,
     size_t element_count,
     copy_constructor_func copy_constructor) {
   return __cxa_vec_cctor(dst_array, src_array, element_count,
                          element_size, copy_constructor, NULL);
 }

 void* __aeabi_vec_new_cookie_noctor(size_t element_size,
                                     size_t element_count) {
   return __cxa_vec_new(element_count, element_size,
                        /* padding */ 2 * sizeof(size_t),
                        /* constructor */ NULL,
                        /* destructor */ NULL);
 }

 void* __aeabi_vec_new_nocookie(size_t element_size,
                                size_t element_count,
                                constructor_func constructor) {
   return __cxa_vec_new(element_count,
                        element_size,
                        /* padding */ 0,
                        constructor,
                        /* destructor */ NULL);
 }

 void* __aeabi_vec_new_cookie_nodtor(size_t element_size,
                                     size_t element_count,
                                     constructor_func constructor) {
   return __cxa_vec_new(element_count,
                        element_size,
                        /* padding */ 2 * sizeof(size_t),
                        constructor,
                        /* destructor */ NULL);
 }

 void* __aeabi_vec_new_cookie(size_t element_size,
                              size_t element_count,
                              constructor_func constructor,
                              destructor_func destructor) {
   return __cxa_vec_new(element_count,
                        element_size,
                        /* padding */ 2 * sizeof(size_t),
                        constructor,
                        destructor);
 }

 void* __aeabi_vec_dtor(void* array_address,
                        destructor_func destructor,
                        size_t element_size,
                        size_t element_count) {
   __cxa_vec_dtor(array_address, element_count, element_size,
                  destructor);
     return reinterpret_cast<size_t*>(array_address) - 2;
 }

 void* __aeabi_vec_dtor_cookie(void* array_address,
                               destructor_func destructor) {
   if (!array_address)
     return NULL;

   size_t* base = reinterpret_cast<size_t*>(array_address);
   __cxa_vec_dtor(array_address,
                  /* element_count */ base[-1],
                  /* element_size */ base[-2],
                  destructor);
   return base - 2;
 }

 void __aeabi_vec_delete(void* array_address,
                         destructor_func destructor)  {
   if (array_address) {
     size_t* base = reinterpret_cast<size_t*>(array_address);

     __cxa_vec_delete(array_address,
                     /* element_size */ base[-2],
                     /* padding */ 2 * sizeof(size_t),
                     destructor);
   }
 }

 void __aeabi_vec_delete3(void* array_address,
                          destructor_func destructor,
                          dealloc2_func dealloc) {
   if (array_address) {
     size_t* base = reinterpret_cast<size_t*>(array_address);

     __cxa_vec_delete3(array_address,
                      /* element_size */ base[-2],
                      /* padding */ 2 * sizeof(size_t),
                      destructor,
                      dealloc);
   }
 }

 void __aeabi_vec_delete3_nodtor(void* array_address,
                                 dealloc2_func dealloc) {
   if (array_address) {
     size_t* base = reinterpret_cast<size_t*>(array_address);

     __cxa_vec_delete3(array_address,
                      /* element_size */ base[-2],
                      /* padding */ 2 * sizeof(size_t),
                      /* destructor */ NULL,
                      dealloc);
   }
 }

 }  // extern "C"
 }  // namespace __aeabiv1

 #endif  // _GABIXX_ARM_ABI
	// Copyright (C) 2013 The Android Open Source Project
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions
	// are met:
	// 1. Redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer.
	// 2. Redistributions in binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in the
	// documentation and/or other materials provided with the distribution.
	// 3. Neither the name of the project nor the names of its contributors
	// may be used to endorse or promote products derived from this software
	// without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
	// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	// ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
	// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	// SUCH DAMAGE.

	#include <cstddef>
	#include <new>

	#include "cxxabi_defines.h"

	using std::size_t;

	namespace {

	using namespace __cxxabiv1;

	typedef __cxa_vec_constructor constructor_func;
	typedef __cxa_vec_copy_constructor copy_constructor_func;
	typedef __cxa_vec_destructor destructor_func;
	typedef void* (*alloc_func)(size_t);
	typedef void (dealloc_func)(void);
	typedef void (dealloc2_func)(void, size_t);

	// Helper class to ensure a ptr is deallocated on scope exit unless
	// the release() method has been called.
	class scoped_block {
	public:
	scoped_block(void* ptr, size_t size, dealloc2_func dealloc)
	: ptr_(ptr), size_(size), dealloc_(dealloc) {}

	~scoped_block() {
	if (dealloc_)
	dealloc_(ptr_, size_);
	}

	void release() {
	dealloc_ = 0;
	}

	private:
	void* ptr_;
	size_t size_;
	dealloc2_func dealloc_;
	};

	// Helper class to ensure a vector is cleaned up on scope exit
	// unless the release() method has been called.
	class scoped_cleanup {
	public:
	scoped_cleanup(void* array, size_t& index, size_t element_size,
	destructor_func destructor)
	: array_(array), index_(index), element_size_(element_size),
	destructor_(destructor) {}

	~scoped_cleanup() {
	if (destructor_)
	__cxxabiv1::__cxa_vec_cleanup(array_,
	index_,
	element_size_,
	destructor_);
	}

	void release() {
	destructor_ = 0;
	}
	private:
	void* array_;
	size_t& index_;
	size_t element_size_;
	destructor_func destructor_;
	};

	// Helper class that calls __fatal_error() with a given message if
	// it exits a scope without a previous call to release().
	class scoped_catcher {
	public:
	scoped_catcher(const char* message) : message_(message) {}

	~scoped_catcher() {
	if (message_)
	__gabixx::__fatal_error(message_);
	}

	void release() {
	message_ = 0;
	}

	private:
	const char* message_;
	};

	} // namespace

	namespace __cxxabiv1 {
	extern "C" {

	void* __cxa_vec_new(size_t element_count,
	size_t element_size,
	size_t padding_size,
	constructor_func constructor,
	destructor_func destructor) {
	return __cxa_vec_new2(element_count, element_size, padding_size,
	constructor, destructor,
	&operator new[], &operator delete []);
	}

	void* __cxa_vec_new2(size_t element_count,
	size_t element_size,
	size_t padding_size,
	constructor_func constructor,
	destructor_func destructor,
	alloc_func alloc,
	dealloc_func dealloc) {
	// The only difference with __cxa_vec_new3 is the type of the
	// dealloc parameter. force a cast because on all supported
	// platforms, it is possible to call the dealloc function here
	// with two parameters. The second one will simply be ignored.
	return __cxa_vec_new3(element_count, element_size, padding_size,
	constructor, destructor, alloc,
	reinterpret_cast<dealloc2_func>(dealloc));
	}

	void* __cxa_vec_new3(size_t element_count,
	size_t element_size,
	size_t padding_size,
	constructor_func constructor,
	destructor_func destructor,
	alloc_func alloc,
	dealloc2_func dealloc) {
	// Compute the size of the needed memory block, and throw
	// std::bad_alloc() on overflow.
	bool overflow = false;
	size_t size = 0;
	if (element_size > 0 && element_count > size_t(-1) / element_size)
	overflow = true;
	else {
	size = element_count * element_size;
	if (size + padding_size < size)
	overflow = true;
	}
	if (overflow)
	throw std::bad_alloc();

	// Allocate memory. Do not throw if NULL is returned.
	char* base = static_cast<char*>(alloc(size));
	if (!base)
	return base;

	// Ensure the block is freed if construction throws.
	scoped_block block(base, size, dealloc);

	if (padding_size) {
	base += padding_size;
	reinterpret_cast<size_t*>(base)[-1] = element_count;
	#ifdef __arm__
	// Required by the ARM C++ ABI.
	reinterpret_cast<size_t*>(base)[-2] = element_size;
	#endif
	}

	__cxa_vec_ctor(base, element_count, element_size,
	constructor, destructor);

	// Construction succeeded, no need to release the block.
	block.release();
	return base;
	}

	#ifdef __arm__
	// On ARM, __cxa_vec_ctor and __cxa_vec_cctor must return
	// their first parameter. Handle this here.
	#define _CXA_VEC_CTOR_RETURN(x) return x
	#else
	#define _CXA_VEC_CTOR_RETURN(x) return
	#endif

	__cxa_vec_ctor_return_type
	__cxa_vec_ctor(void* array_address,
	size_t element_count,
	size_t element_size,
	constructor_func constructor,
	destructor_func destructor) {
	if (constructor) {
	size_t n = 0;
	char* base = static_cast<char*>(array_address);

	scoped_cleanup cleanup(array_address, n, element_size, destructor);
	for (; n != element_count; ++n) {
	constructor(base);
	base += element_size;
	}
	cleanup.release();
	}
	_CXA_VEC_CTOR_RETURN(array_address);
	}

	// Given the (data) address of an array, the number of elements,
	// and the size of its elements, call the given destructor on each
	// element. If the destructor throws an exception, rethrow after
	// destroying the remaining elements if possible. If the destructor
	// throws a second exception, call terminate(). The destructor
	// pointer may be NULL, in which case this routine does nothing.
	void __cxa_vec_dtor(void* array_address,
	size_t element_count,
	size_t element_size,
	destructor_func destructor) {
	if (!destructor)
	return;

	char* base = static_cast<char*>(array_address);
	size_t n = element_count;
	scoped_cleanup cleanup(array_address, n, element_size, destructor);
	base += element_count * element_size;
	// Note: n must be decremented before the destructor call
	// to avoid cleaning up one extra unwanted item.
	while (n--) {
	base -= element_size;
	destructor(base);
	}
	cleanup.release();
	}

	// Given the (data) address of an array, the number of elements,
	// and the size of its elements, call the given destructor on each
	// element. If the destructor throws an exception, call terminate().
	// The destructor pointer may be NULL, in which case this routine
	// does nothing.
	void __cxa_vec_cleanup(void* array_address,
	size_t element_count,
	size_t element_size,
	destructor_func destructor) {
	if (!destructor)
	return;

	char* base = static_cast<char*>(array_address);
	size_t n = element_count;
	base += n * element_size;

	scoped_catcher catcher("exception raised in vector destructor!");
	while (n--) {
	base -= element_size;
	destructor(base);
	}
	catcher.release();
	}

	// If the array_address is NULL, return immediately. Otherwise,
	// given the (data) address of an array, the non-negative size
	// of prefix padding for the cookie, and the size of its elements,
	// call the given destructor on each element, using the cookie to
	// determine the number of elements, and then delete the space by
	// calling ::operator delete[](void *). If the destructor throws an
	// exception, rethrow after (a) destroying the remaining elements,
	// and (b) deallocating the storage. If the destructor throws a
	// second exception, call terminate(). If padding_size is 0, the
	// destructor pointer must be NULL. If the destructor pointer is NULL,
	// no destructor call is to be made.
	void __cxa_vec_delete(void* array_address,
	size_t element_size,
	size_t padding_size,
	destructor_func destructor) {
	__cxa_vec_delete2(array_address, element_size, padding_size,
	destructor, &operator delete []);
	}

	// Same as __cxa_vec_delete, except that the given function is used
	// for deallocation instead of the default delete function. If dealloc
	// throws an exception, the result is undefined. The dealloc pointer
	// may not be NULL.
	void __cxa_vec_delete2(void* array_address,
	size_t element_size,
	size_t padding_size,
	destructor_func destructor,
	dealloc_func dealloc) {
	// Same trick than the one used on __cxa_vec_new2.
	__cxa_vec_delete3(array_address, element_size, padding_size,
	destructor,
	reinterpret_cast<dealloc2_func>(dealloc));
	}

	// Same as __cxa_vec_delete, except that the given function is used
	// for deallocation instead of the default delete function. The
	// deallocation function takes both the object address and its size.
	// If dealloc throws an exception, the result is undefined. The dealloc
	// pointer may not be NULL.
	void __cxa_vec_delete3(void* array_address,
	size_t element_size,
	size_t padding_size,
	destructor_func destructor,
	dealloc2_func dealloc) {
	if (!array_address)
	return;

	char* base = static_cast<char*>(array_address);

	if (!padding_size) {
	// If here is no padding size, asume the deallocator knows
	// how to handle this. Useful when called from __cxa_vec_delete2.
	dealloc(base, 0);
	return;
	}

	size_t element_count = reinterpret_cast<size_t*>(base)[-1];
	base -= padding_size;
	size_t size = element_count * element_size + padding_size;

	// Always deallocate base on exit.
	scoped_block block(base, size, dealloc);

	if (padding_size > 0 && destructor != 0)
	__cxa_vec_dtor(array_address, element_count, element_size, destructor);
	}

	__cxa_vec_ctor_return_type
	__cxa_vec_cctor(void* dst_array,
	void* src_array,
	size_t element_count,
	size_t element_size,
	copy_constructor_func copy_constructor,
	destructor_func destructor) {
	if (copy_constructor) {
	size_t n = 0;
	char* dst = static_cast<char*>(dst_array);
	char* src = static_cast<char*>(src_array);

	scoped_cleanup cleanup(dst_array, n, element_size, destructor);

	for ( ; n != element_count; ++n) {
	copy_constructor(dst, src);
	dst += element_size;
	src += element_size;
	}

	cleanup.release();
	}
	_CXA_VEC_CTOR_RETURN(dst_array);
	}

	} // extern "C"
	} // namespace __cxxabiv1

	#if _GABIXX_ARM_ABI
	// The following functions are required by the ARM ABI, even
	// though neither GCC nor LLVM generate any code that uses it.
	// This may be important for machine code generated by other
	// compilers though (e.g. RCVT), which may depend on them.
	// They're supposed to simplify calling code.
	namespace __aeabiv1 {

	extern "C" {

	using namespace __cxxabiv1;

	void* __aeabi_vec_ctor_nocookie_nodtor(void* array_address,
	constructor_func constructor,
	size_t element_size,
	size_t element_count) {
	return __cxa_vec_ctor(array_address,
	element_count,
	element_size,
	constructor,
	/* destructor */ NULL);
	}

	void* __aeabi_vec_ctor_cookie_nodtor(void* array_address,
	constructor_func constructor,
	size_t element_size,
	size_t element_count) {
	if (!array_address)
	return array_address;

	size_t* base = reinterpret_cast<size_t*>(array_address) + 2;
	base[-2] = element_size;
	base[-1] = element_count;
	return __cxa_vec_ctor(base,
	element_count,
	element_size,
	constructor,
	/* destructor */ NULL);
	}

	void* __aeabi_vec_cctor_nocookie_nodtor(
	void* dst_array,
	void* src_array,
	size_t element_size,
	size_t element_count,
	copy_constructor_func copy_constructor) {
	return __cxa_vec_cctor(dst_array, src_array, element_count,
	element_size, copy_constructor, NULL);
	}

	void* __aeabi_vec_new_cookie_noctor(size_t element_size,
	size_t element_count) {
	return __cxa_vec_new(element_count, element_size,
	/* padding / 2 sizeof(size_t),
	/* constructor */ NULL,
	/* destructor */ NULL);
	}

	void* __aeabi_vec_new_nocookie(size_t element_size,
	size_t element_count,
	constructor_func constructor) {
	return __cxa_vec_new(element_count,
	element_size,
	/* padding */ 0,
	constructor,
	/* destructor */ NULL);
	}

	void* __aeabi_vec_new_cookie_nodtor(size_t element_size,
	size_t element_count,
	constructor_func constructor) {
	return __cxa_vec_new(element_count,
	element_size,
	/* padding / 2 sizeof(size_t),
	constructor,
	/* destructor */ NULL);
	}

	void* __aeabi_vec_new_cookie(size_t element_size,
	size_t element_count,
	constructor_func constructor,
	destructor_func destructor) {
	return __cxa_vec_new(element_count,
	element_size,
	/* padding / 2 sizeof(size_t),
	constructor,
	destructor);
	}

	void* __aeabi_vec_dtor(void* array_address,
	destructor_func destructor,
	size_t element_size,
	size_t element_count) {
	__cxa_vec_dtor(array_address, element_count, element_size,
	destructor);
	return reinterpret_cast<size_t*>(array_address) - 2;
	}

	void* __aeabi_vec_dtor_cookie(void* array_address,
	destructor_func destructor) {
	if (!array_address)
	return NULL;

	size_t* base = reinterpret_cast<size_t*>(array_address);
	__cxa_vec_dtor(array_address,
	/* element_count */ base[-1],
	/* element_size */ base[-2],
	destructor);
	return base - 2;
	}

	void __aeabi_vec_delete(void* array_address,
	destructor_func destructor) {
	if (array_address) {
	size_t* base = reinterpret_cast<size_t*>(array_address);

	__cxa_vec_delete(array_address,
	/* element_size */ base[-2],
	/* padding / 2 sizeof(size_t),
	destructor);
	}
	}

	void __aeabi_vec_delete3(void* array_address,
	destructor_func destructor,
	dealloc2_func dealloc) {
	if (array_address) {
	size_t* base = reinterpret_cast<size_t*>(array_address);

	__cxa_vec_delete3(array_address,
	/* element_size */ base[-2],
	/* padding / 2 sizeof(size_t),
	destructor,
	dealloc);
	}
	}

	void __aeabi_vec_delete3_nodtor(void* array_address,
	dealloc2_func dealloc) {
	if (array_address) {
	size_t* base = reinterpret_cast<size_t*>(array_address);

	__cxa_vec_delete3(array_address,
	/* element_size */ base[-2],
	/* padding / 2 sizeof(size_t),
	/* destructor */ NULL,
	dealloc);
	}
	}

	} // extern "C"
	} // namespace __aeabiv1

	#endif // _GABIXX_ARM_ABI