| // Copyright (C) 2011 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. |
| // |
| |
| #ifndef __GABIXX_CXXABI_H__ |
| #define __GABIXX_CXXABI_H__ |
| |
| // The specifications for the declarations found in this header are |
| // the following: |
| // |
| // - Itanium C++ ABI [1] |
| // Used on about every CPU architecture, _except_ ARM, this |
| // is also commonly referred as the "generic C++ ABI". |
| // |
| // NOTE: This document seems to only covers C++98 |
| // |
| // - Itanium C++ ABI: Exception Handling. [2] |
| // Supplement to the above document describing how exception |
| // handle works with the generic C++ ABI. Again, this only |
| // seems to support C++98. |
| // |
| // - C++ ABI for the ARM architecture [3] |
| // Describes the ARM C++ ABI, mainly as a set of differences from |
| // the generic one. |
| // |
| // - Exception Handling for the ARM Architecture [4] |
| // Describes exception handling for ARM in detail. There are rather |
| // important differences in the stack unwinding process and |
| // exception cleanup. |
| // |
| // There are also no freely availabel documentation about certain |
| // features introduced in C++0x or later. In this case, the best |
| // source for information are the GNU and LLVM C++ runtime libraries |
| // (libcxxabi, libsupc++ and even libc++ sources), as well as a few |
| // proposals, for example: |
| // |
| // - For exception propagation: |
| // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2179.html |
| // But the paper only describs the high-level language feature, not |
| // the low-level runtime support required to implement it. |
| // |
| // - For nested exceptions: |
| // http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2559.html |
| // Yet another high-level description without low-level details. |
| // |
| #include <gabixx_config.h> |
| |
| #include <exception> |
| #include <stdint.h> |
| #include <typeinfo> |
| #include <unwind.h> |
| |
| // When LIBCXXABI, gabi++ should emulate libc++abi. _LIBCPPABI_VERSION must |
| // be defined in cxxabi.h to complete this abstraction for libc++. |
| #if defined(LIBCXXABI) |
| #define _LIBCPPABI_VERSION 1001 |
| #endif |
| |
| namespace __cxxabiv1 |
| { |
| extern "C" { |
| |
| // TODO: Support dependent exception |
| // TODO: Support C++0x exception propagation |
| // http://sourcery.mentor.com/archives/cxx-abi-dev/msg01924.html |
| struct __cxa_exception; |
| struct __cxa_eh_globals; |
| |
| __cxa_eh_globals* __cxa_get_globals() _GABIXX_NOEXCEPT ; |
| __cxa_eh_globals* __cxa_get_globals_fast() _GABIXX_NOEXCEPT; |
| |
| void* __cxa_allocate_exception(size_t thrown_size) _GABIXX_NOEXCEPT; |
| void __cxa_free_exception(void* thrown_exception) _GABIXX_NOEXCEPT; |
| |
| void __cxa_throw(void* thrown_exception, |
| std::type_info* tinfo, |
| void (*dest)(void*)) _GABIXX_NORETURN; |
| |
| void __cxa_rethrow() _GABIXX_NORETURN; |
| |
| void* __cxa_begin_catch(void* exceptionObject) _GABIXX_NOEXCEPT; |
| void __cxa_end_catch() _GABIXX_NOEXCEPT; |
| |
| #ifdef __arm__ |
| bool __cxa_begin_cleanup(_Unwind_Exception*); |
| void __cxa_end_cleanup(); |
| #endif |
| |
| void __cxa_bad_cast() _GABIXX_NORETURN; |
| void __cxa_bad_typeid() _GABIXX_NORETURN; |
| |
| void* __cxa_get_exception_ptr(void* exceptionObject) _GABIXX_NOEXCEPT; |
| |
| void __cxa_pure_virtual() _GABIXX_NORETURN; |
| void __cxa_deleted_virtual() _GABIXX_NORETURN; |
| |
| // Missing libcxxabi functions. |
| bool __cxa_uncaught_exception() _GABIXX_NOEXCEPT; |
| |
| void __cxa_decrement_exception_refcount(void* exceptionObject) |
| _GABIXX_NOEXCEPT; |
| |
| void __cxa_increment_exception_refcount(void* exceptionObject) |
| _GABIXX_NOEXCEPT; |
| |
| void __cxa_rethrow_primary_exception(void* exceptionObject); |
| |
| void* __cxa_current_primary_exception() _GABIXX_NOEXCEPT; |
| |
| // The ARM ABI mandates that constructors and destructors |
| // must return 'this', i.e. their first parameter. This is |
| // also true for __cxa_vec_ctor and __cxa_vec_cctor. |
| #ifdef __arm__ |
| typedef void* __cxa_vec_ctor_return_type; |
| #else |
| typedef void __cxa_vec_ctor_return_type; |
| #endif |
| |
| typedef __cxa_vec_ctor_return_type |
| (*__cxa_vec_constructor)(void *); |
| |
| typedef __cxa_vec_constructor __cxa_vec_destructor; |
| |
| typedef __cxa_vec_ctor_return_type |
| (*__cxa_vec_copy_constructor)(void*, void*); |
| |
| void* __cxa_vec_new(size_t element_count, |
| size_t element_size, |
| size_t padding_size, |
| __cxa_vec_constructor constructor, |
| __cxa_vec_destructor destructor); |
| |
| void* __cxa_vec_new2(size_t element_count, |
| size_t element_size, |
| size_t padding_size, |
| __cxa_vec_constructor constructor, |
| __cxa_vec_destructor destructor, |
| void* (*alloc)(size_t), |
| void (*dealloc)(void*)); |
| |
| void* __cxa_vec_new3(size_t element_count, |
| size_t element_size, |
| size_t padding_size, |
| __cxa_vec_constructor constructor, |
| __cxa_vec_destructor destructor, |
| void* (*alloc)(size_t), |
| void (*dealloc)(void*, size_t)); |
| |
| __cxa_vec_ctor_return_type |
| __cxa_vec_ctor(void* array_address, |
| size_t element_count, |
| size_t element_size, |
| __cxa_vec_constructor constructor, |
| __cxa_vec_destructor destructor); |
| |
| void __cxa_vec_dtor(void* array_address, |
| size_t element_count, |
| size_t element_size, |
| __cxa_vec_destructor destructor); |
| |
| void __cxa_vec_cleanup(void* array_address, |
| size_t element_count, |
| size_t element_size, |
| __cxa_vec_destructor destructor); |
| |
| void __cxa_vec_delete(void* array_address, |
| size_t element_size, |
| size_t padding_size, |
| __cxa_vec_destructor destructor); |
| |
| void __cxa_vec_delete2(void* array_address, |
| size_t element_size, |
| size_t padding_size, |
| __cxa_vec_destructor destructor, |
| void (*dealloc)(void*)); |
| |
| void __cxa_vec_delete3(void* array_address, |
| size_t element_size, |
| size_t padding_size, |
| __cxa_vec_destructor destructor, |
| void (*dealloc) (void*, size_t)); |
| |
| __cxa_vec_ctor_return_type |
| __cxa_vec_cctor(void* dest_array, |
| void* src_array, |
| size_t element_count, |
| size_t element_size, |
| __cxa_vec_copy_constructor constructor, |
| __cxa_vec_destructor destructor ); |
| |
| } // extern "C" |
| |
| } // namespace __cxxabiv1 |
| |
| namespace abi = __cxxabiv1; |
| |
| #if _GABIXX_ARM_ABI |
| // ARM-specific ABI additions. They must be provided by the |
| // C++ runtime to simplify calling code generated by the compiler. |
| // Note that neither GCC nor Clang seem to use these, but this can |
| // happen when using machine code generated with other ocmpilers |
| // like RCVT. |
| |
| namespace __aeabiv1 { |
| extern "C" { |
| |
| using __cxxabiv1::__cxa_vec_constructor; |
| using __cxxabiv1::__cxa_vec_copy_constructor; |
| using __cxxabiv1::__cxa_vec_destructor; |
| |
| void* __aeabi_vec_ctor_nocookie_nodtor(void* array_address, |
| __cxa_vec_constructor constructor, |
| size_t element_size, |
| size_t element_count); |
| |
| void* __aeabi_vec_ctor_cookie_nodtor(void* array_address, |
| __cxa_vec_constructor constructor, |
| size_t element_size, |
| size_t element_count); |
| |
| void* __aeabi_vec_cctor_nocookie_nodtor( |
| void* dst_array, |
| void* src_array, |
| size_t element_size, |
| size_t element_count, |
| __cxa_vec_copy_constructor constructor); |
| |
| void* __aeabi_vec_new_nocookie_noctor(size_t element_size, |
| size_t element_count); |
| |
| void* __aeabi_vec_new_nocookie(size_t element_size, |
| size_t element_count, |
| __cxa_vec_constructor constructor); |
| |
| void* __aeabi_vec_new_cookie_nodtor(size_t element_size, |
| size_t element_count, |
| __cxa_vec_constructor constructor); |
| |
| void* __aeabi_vec_new_cookie(size_t element_size, |
| size_t element_count, |
| __cxa_vec_constructor constructor, |
| __cxa_vec_destructor destructor); |
| |
| void* __aeabi_vec_dtor(void* array_address, |
| __cxa_vec_destructor destructor, |
| size_t element_size, |
| size_t element_count); |
| |
| void* __aeabi_vec_dtor_cookie(void* array_address, |
| __cxa_vec_destructor destructor); |
| |
| void __aeabi_vec_delete(void* array_address, |
| __cxa_vec_destructor destructor); |
| |
| void __aeabi_vec_delete3(void* array_address, |
| __cxa_vec_destructor destructor, |
| void (*dealloc)(void*, size_t)); |
| |
| void __aeabi_vec_delete3_nodtor(void* array_address, |
| void (*dealloc)(void*, size_t)); |
| |
| } // extern "C" |
| } // namespace __ |
| |
| #endif // _GABIXX_ARM_ABI == 1 |
| |
| #endif /* defined(__GABIXX_CXXABI_H__) */ |
| |
