android-6.0.0_r1/s

// 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