Make 3.5 branch.

#===============================================================================

# Setup Project

#===============================================================================

cmake_minimum_required(VERSION 2.8.8)

if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)

  project(libcxxabi)

  # Rely on llvm-config.

  set(CONFIG_OUTPUT)

  find_program(LLVM_CONFIG "llvm-config")

  if(LLVM_CONFIG)

    message(STATUS "Found LLVM_CONFIG as ${LLVM_CONFIG}")

    set(CONFIG_COMMAND ${LLVM_CONFIG}

      "--bindir"

      "--includedir"

      "--libdir"

      "--prefix"

      "--src-root")

    execute_process(

      COMMAND ${CONFIG_COMMAND}

      RESULT_VARIABLE HAD_ERROR

      OUTPUT_VARIABLE CONFIG_OUTPUT

    )

    if(NOT HAD_ERROR)

      string(REGEX REPLACE

        "[ \t]*[\r\n]+[ \t]*" ";"

        CONFIG_OUTPUT ${CONFIG_OUTPUT})

    else()

      string(REPLACE ";" " " CONFIG_COMMAND_STR "${CONFIG_COMMAND}")

      message(STATUS "${CONFIG_COMMAND_STR}")

      message(FATAL_ERROR "llvm-config failed with status ${HAD_ERROR}")

    endif()

  else()

    message(FATAL_ERROR "llvm-config not found -- ${LLVM_CONFIG}")

  endif()

  list(GET CONFIG_OUTPUT 0 TOOLS_BINARY_DIR)

  list(GET CONFIG_OUTPUT 1 INCLUDE_DIR)

  list(GET CONFIG_OUTPUT 2 LIBRARY_DIR)

  list(GET CONFIG_OUTPUT 3 LLVM_OBJ_ROOT)

  list(GET CONFIG_OUTPUT 4 MAIN_SRC_DIR)

  set(LLVM_TOOLS_BINARY_DIR ${TOOLS_BINARY_DIR} CACHE PATH "Path to llvm/bin")

  set(LLVM_INCLUDE_DIR ${INCLUDE_DIR} CACHE PATH "Path to llvm/include")

  set(LLVM_LIBRARY_DIR ${LIBRARY_DIR} CACHE PATH "Path to llvm/lib")

  set(LLVM_BINARY_DIR ${LLVM_OBJ_ROOT} CACHE PATH "Path to LLVM build tree")

  set(LLVM_MAIN_SRC_DIR ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")

  set(LLVM_CMAKE_PATH "${LLVM_BINARY_DIR}/share/llvm/cmake")

  set(LLVMCONFIG_FILE "${LLVM_CMAKE_PATH}/LLVMConfig.cmake")

  if(EXISTS ${LLVMCONFIG_FILE})

    list(APPEND CMAKE_MODULE_PATH "${LLVM_CMAKE_PATH}")

    include(${LLVMCONFIG_FILE})

    include("${LLVM_CMAKE_PATH}/AddLLVM.cmake")

    include("${LLVM_CMAKE_PATH}/HandleLLVMOptions.cmake")

  else()

    message(FATAL_ERROR "Not found: ${LLVMCONFIG_FILE}")

  endif()

  set(PACKAGE_NAME libcxxabi)

  set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")

  set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")

  set(PACKAGE_BUGREPORT "llvmbugs@cs.uiuc.edu")

  if(EXISTS ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)

    set(LLVM_LIT ${LLVM_MAIN_SRC_DIR}/utils/lit/lit.py)

  else()

    # Seek installed Lit.

    find_program(LLVM_LIT "lit.py" ${LLVM_MAIN_SRC_DIR}/utils/lit

      DOC "Path to lit.py")

  endif()

  if(LLVM_LIT)

    # Define the default arguments to use with 'lit', and an option for the user

    # to override.

    set(LIT_ARGS_DEFAULT "-sv")

    if (MSVC OR XCODE)

      set(LIT_ARGS_DEFAULT "${LIT_ARGS_DEFAULT} --no-progress-bar")

    endif()

    set(LLVM_LIT_ARGS "${LIT_ARGS_DEFAULT}" CACHE STRING "Default options for lit")

    # On Win32 hosts, provide an option to specify the path to the GnuWin32 tools.

    if( WIN32 AND NOT CYGWIN )

      set(LLVM_LIT_TOOLS_DIR "" CACHE PATH "Path to GnuWin32 tools")

    endif()

  else()

    set(LLVM_INCLUDE_TESTS OFF)

  endif()

  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

  set(LIBCXXABI_BUILT_STANDALONE 1)

else()

  set(LLVM_LIT "${CMAKE_SOURCE_DIR}/utils/lit/lit.py")

endif()

#===============================================================================

# Setup CMake Options

#===============================================================================

# Define options.

option(LIBCXXABI_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)

option(LIBCXXABI_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)

option(LIBCXXABI_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)

option(LIBCXXABI_USE_LLVM_UNWINDER "Build and use the LLVM unwinder." OFF)

# Default to building a shared library so that the default options still test

# the libc++abi that is being built. There are two problems with testing a

# static libc++abi. In the case of a standalone build, the tests will link the

# system's libc++, which might not have been built against our libc++abi. In the

# case of an in tree build, libc++ will prefer a dynamic libc++abi from the

# system over a static libc++abi from the output directory.

option(LIBCXXABI_ENABLE_SHARED "Build libc++abi as a shared library." ON)

find_path(

  LIBCXXABI_LIBCXX_INCLUDES

  vector

  PATHS ${LIBCXXABI_LIBCXX_INCLUDES}

        ${CMAKE_BINARY_DIR}/${LIBCXXABI_LIBCXX_INCLUDES}

        ${LLVM_MAIN_SRC_DIR}/projects/libcxx/include

        ${LLVM_INCLUDE_DIR}/c++/v1

  )

set(LIBCXXABI_LIBCXX_INCLUDES "${LIBCXXABI_LIBCXX_INCLUDES}" CACHE STRING

    "Specify path to libc++ includes." FORCE)

#===============================================================================

# Configure System

#===============================================================================

# Add path for custom modules

set(CMAKE_MODULE_PATH

  "${CMAKE_CURRENT_SOURCE_DIR}/cmake"

  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"

  ${CMAKE_MODULE_PATH}

  )

# Configure compiler.

include(config-ix)

#===============================================================================

# Setup Compiler Flags

#===============================================================================

# Get required flags.

macro(append_if list condition var)

  if (${condition})

    list(APPEND ${list} ${var})

  endif()

endmacro()

if (LIBCXXABI_HAS_NOSTDINCXX_FLAG)

  list(APPEND LIBCXXABI_CXX_REQUIRED_FLAGS -nostdinc++)

endif()

append_if(LIBCXXABI_CXX_REQUIRED_FLAGS LIBCXXABI_HAS_WERROR_FLAG -Werror=return-type)

# Get warning flags

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_W_FLAG -W)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WALL_FLAG -Wall)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WCHAR_SUBSCRIPTS_FLAG -Wchar-subscripts)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WCONVERSION_FLAG -Wconversion)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WMISMATCHED_TAGS_FLAG -Wmismatched-tags)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WMISSING_BRACES_FLAG -Wmissing-braces)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WNEWLINE_EOF_FLAG -Wnewline-eof)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WNO_UNUSED_FUNCTION_FLAG -Wno-unused-function)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WSHADOW_FLAG -Wshadow)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WSHORTEN_64_TO_32_FLAG -Wshorten-64-to-32)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WSIGN_COMPARE_FLAG -Wsign-compare)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WSIGN_CONVERSION_FLAG -Wsign-conversion)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WSTRICT_ALIASING_FLAG -Wstrict-aliasing=2)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WSTRICT_OVERFLOW_FLAG -Wstrict-overflow=4)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WUNUSED_PARAMETER_FLAG -Wunused-parameter)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WUNUSED_VARIABLE_FLAG -Wunused-variable)

append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WWRITE_STRINGS_FLAG -Wwrite-strings)

if (LIBCXXABI_ENABLE_WERROR)

  append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WERROR_FLAG -Werror)

  append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WX_FLAG -WX)

else()

  append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_WNO_ERROR_FLAG -Wno-error)

  append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_NO_WX_FLAG -WX-)

endif()

if (LIBCXXABI_ENABLE_PEDANTIC)

  append_if(LIBCXXABI_CXX_WARNING_FLAGS LIBCXXABI_HAS_PEDANTIC_FLAG -pedantic)

endif()

# Get feature flags.

# Exceptions

# Catches C++ exceptions only and tells the compiler to assume that extern C

# functions never throw a C++ exception.

append_if(LIBCXXABI_CXX_FEATURE_FLAGS LIBCXXABI_HAS_FSTRICT_ALIASING_FLAG -fstrict-aliasing)

append_if(LIBCXXABI_CXX_FEATURE_FLAGS LIBCXXABI_HAS_EHSC_FLAG -EHsc)

# Assert

string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)

if (LIBCXXABI_ENABLE_ASSERTIONS)

  # MSVC doesn't like _DEBUG on release builds. See PR 4379.

  if (NOT MSVC)

    list(APPEND LIBCXXABI_CXX_FEATURE_FLAGS -D_DEBUG)

  endif()

  # On Release builds cmake automatically defines NDEBUG, so we

  # explicitly undefine it:

  if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")

    list(APPEND LIBCXXABI_CXX_FEATURE_FLAGS -UNDEBUG)

  endif()

else()

  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")

    list(APPEND LIBCXXABI_CXX_FEATURE_FLAGS -DNDEBUG)

  endif()

endif()

# Static library

if (NOT LIBCXXABI_ENABLE_SHARED)

  list(APPEND LIBCXXABI_CXX_FEATURE_FLAGS -D_LIBCPP_BUILD_STATIC)

endif()

# This is the _ONLY_ place where add_definitions is called.

if (MSVC)

  add_definitions(-D_CRT_SECURE_NO_WARNINGS)

endif()

string(REPLACE ";" " " LIBCXXABI_CXX_REQUIRED_FLAGS "${LIBCXXABI_CXX_REQUIRED_FLAGS}")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_REQUIRED_FLAGS}")

string(REPLACE ";" " " LIBCXXABI_CXX_WARNING_FLAGS "${LIBCXXABI_CXX_WARNING_FLAGS}")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_WARNING_FLAGS}")

string(REPLACE ";" " " LIBCXXABI_CXX_FEATURE_FLAGS "${LIBCXXABI_CXX_FEATURE_FLAGS}")

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${LIBCXXABI_CXX_FEATURE_FLAGS}")

#===============================================================================

# Setup Source Code

#===============================================================================

include_directories(include)

# Add source code. This also contains all of the logic for deciding linker flags

# soname, etc...

add_subdirectory(src)

if (LIBCXXABI_USE_LLVM_UNWINDER)

  add_subdirectory(src/Unwind)

endif()

if(NOT LIBCXXABI_ENABLE_SHARED)

  # TODO: Fix the libc++ cmake files so that libc++abi can be statically linked.

  # As it is now, libc++ will prefer linking against a dynamic libc++abi in the

  # system library paths over a static libc++abi in the out directory. This

  # would test the system library rather than the one we just built, which isn't

  # very helpful.

  message(WARNING "The libc++abi tests are currently only valid when "

                  "LIBCXXABI_ENABLE_SHARED is on, no check target will be "

                  "available!")

else()

  add_subdirectory(test)

endif()

This file is a partial list of people who have contributed to the LLVM/libc++abi

project.  If you have contributed a patch or made some other contribution to

LLVM/libc++abi, please submit a patch to this file to add yourself, and it will be

done!

The list is sorted by surname and formatted to allow easy grepping and

beautification by scripts.  The fields are: name (N), email (E), web-address

(W), PGP key ID and fingerprint (P), description (D), and snail-mail address

(S).

N: Logan Chien

E: logan.chien@mediatek.com

D: ARM EHABI Unwind & Exception Handling

N: Marshall Clow

E: mclow.lists@gmail.com

E: marshall@idio.com

D: Architect and primary coauthor of libc++abi

N: Matthew Dempsky

E: matthew@dempsky.org

D: Minor patches and bug fixes.

N: Nowar Gu

E: wenhan.gu@gmail.com

D: Minor patches and fixes

N: Howard Hinnant

E: hhinnant@apple.com

D: Architect and primary coauthor of libc++abi

N: Dana Jansens

E: danakj@chromium.org

D: ARM EHABI Unwind & Exception Handling

N: Nick Kledzik

E: kledzik@apple.com

N: Antoine Labour

E: piman@chromium.org

D: ARM EHABI Unwind & Exception Handling

N: Bruce Mitchener, Jr.

E: bruce.mitchener@gmail.com

D: Minor typo fixes

N: Andrew Morrow

E: andrew.c.morrow@gmail.com

D: Minor patches and fixes

N: Erik Olofsson

E: erik.olofsson@hansoft.se

E: erik@olofsson.info

D: Minor patches and fixes

N: Jon Roelofs

E: jonathan@codesourcery.com

D: ARM EHABI Unwind & Exception Handling, Bare-metal

N: Nico Weber

E: thakis@chromium.org

D: ARM EHABI Unwind & Exception Handling

N: Albert J. Wong

E: ajwong@google.com

D: ARM EHABI Unwind & Exception Handling

==============================================================================

libc++abi License

==============================================================================

The libc++abi library is dual licensed under both the University of Illinois

"BSD-Like" license and the MIT license.  As a user of this code you may choose

to use it under either license.  As a contributor, you agree to allow your code

to be used under both.

Full text of the relevant licenses is included below.

==============================================================================

University of Illinois/NCSA

Open Source License

Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT

All rights reserved.

Developed by:

    LLVM Team

    University of Illinois at Urbana-Champaign

    http://llvm.org

Permission is hereby granted, free of charge, to any person obtaining a copy of

this software and associated documentation files (the "Software"), to deal with

the Software without restriction, including without limitation the rights to

use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies

of the Software, and to permit persons to whom the Software is furnished to do

so, subject to the following conditions:

    * Redistributions of source code must retain the above copyright notice,

      this list of conditions and the following disclaimers.

    * Redistributions in binary form must reproduce the above copyright notice,

      this list of conditions and the following disclaimers in the

      documentation and/or other materials provided with the distribution.

    * Neither the names of the LLVM Team, University of Illinois at

      Urbana-Champaign, nor the names of its contributors may be used to

      endorse or promote products derived from this Software without specific

      prior written permission.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE

SOFTWARE.

==============================================================================

Copyright (c) 2009-2014 by the contributors listed in CREDITS.TXT

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

include(CheckLibraryExists)

include(CheckCXXCompilerFlag)

# Check compiler flags

check_cxx_compiler_flag(-fPIC                 LIBCXXABI_HAS_FPIC_FLAG)

check_cxx_compiler_flag(-fstrict-aliasing     LIBCXXABI_HAS_FSTRICT_ALIASING_FLAG)

check_cxx_compiler_flag(-nodefaultlibs        LIBCXXABI_HAS_NODEFAULTLIBS_FLAG)

check_cxx_compiler_flag(-nostdinc++           LIBCXXABI_HAS_NOSTDINCXX_FLAG)

check_cxx_compiler_flag(-Wall                 LIBCXXABI_HAS_WALL_FLAG)

check_cxx_compiler_flag(-W                    LIBCXXABI_HAS_W_FLAG)

check_cxx_compiler_flag(-Wno-unused-function  LIBCXXABI_HAS_WNO_UNUSED_FUNCTION_FLAG)

check_cxx_compiler_flag(-Wunused-variable     LIBCXXABI_HAS_WUNUSED_VARIABLE_FLAG)

check_cxx_compiler_flag(-Wunused-parameter    LIBCXXABI_HAS_WUNUSED_PARAMETER_FLAG)

check_cxx_compiler_flag(-Wstrict-aliasing     LIBCXXABI_HAS_WSTRICT_ALIASING_FLAG)

check_cxx_compiler_flag(-Wstrict-overflow     LIBCXXABI_HAS_WSTRICT_OVERFLOW_FLAG)

check_cxx_compiler_flag(-Wwrite-strings       LIBCXXABI_HAS_WWRITE_STRINGS_FLAG)

check_cxx_compiler_flag(-Wchar-subscripts     LIBCXXABI_HAS_WCHAR_SUBSCRIPTS_FLAG)

check_cxx_compiler_flag(-Wmismatched-tags     LIBCXXABI_HAS_WMISMATCHED_TAGS_FLAG)

check_cxx_compiler_flag(-Wmissing-braces      LIBCXXABI_HAS_WMISSING_BRACES_FLAG)

check_cxx_compiler_flag(-Wshorten-64-to-32    LIBCXXABI_HAS_WSHORTEN_64_TO_32_FLAG)

check_cxx_compiler_flag(-Wsign-conversion     LIBCXXABI_HAS_WSIGN_CONVERSION_FLAG)

check_cxx_compiler_flag(-Wsign-compare        LIBCXXABI_HAS_WSIGN_COMPARE_FLAG)

check_cxx_compiler_flag(-Wshadow              LIBCXXABI_HAS_WSHADOW_FLAG)

check_cxx_compiler_flag(-Wconversion          LIBCXXABI_HAS_WCONVERSION_FLAG)

check_cxx_compiler_flag(-Wnewline-eof         LIBCXXABI_HAS_WNEWLINE_EOF_FLAG)

check_cxx_compiler_flag(-pedantic             LIBCXXABI_HAS_PEDANTIC_FLAG)

check_cxx_compiler_flag(-Werror               LIBCXXABI_HAS_WERROR_FLAG)

check_cxx_compiler_flag(-Wno-error            LIBCXXABI_HAS_WNO_ERROR_FLAG)

check_cxx_compiler_flag(/WX                   LIBCXXABI_HAS_WX_FLAG)

check_cxx_compiler_flag(/WX-                  LIBCXXABI_HAS_NO_WX_FLAG)

check_cxx_compiler_flag(/EHsc                 LIBCXXABI_HAS_EHSC_FLAG)

check_cxx_compiler_flag(/EHs-                 LIBCXXABI_HAS_NO_EHS_FLAG)

check_cxx_compiler_flag(/EHa-                 LIBCXXABI_HAS_NO_EHA_FLAG)

check_cxx_compiler_flag(/GR-                  LIBCXXABI_HAS_NO_GR_FLAG)

# Check libraries

check_library_exists(c printf "" LIBCXXABI_HAS_C_LIB)

check_library_exists(dl dladdr "" LIBCXXABI_HAS_DL_LIB)

check_library_exists(pthread pthread_once "" LIBCXXABI_HAS_PTHREAD_LIB)

check_library_exists(gcc_eh _Unwind_GetRegionStart "" LIBCXXABI_HAS_GCC_EH_LIB)

//===--------------------------- cxxabi.h ---------------------------------===//

//

//                     The LLVM Compiler Infrastructure

//

// This file is dual licensed under the MIT and the University of Illinois Open

// Source Licenses. See LICENSE.TXT for details.

//

//===----------------------------------------------------------------------===//

#ifndef __CXXABI_H

#define __CXXABI_H 

/*

 * This header provides the interface to the C++ ABI as defined at:

 *       http://www.codesourcery.com/cxx-abi/

 */

#include <stddef.h>

#include <stdint.h>

#define _LIBCPPABI_VERSION 1001

#define LIBCXXABI_NORETURN  __attribute__((noreturn))

// FIXME: This is also in unwind.h and libunwind.h, can we consolidate?

#if !defined(__USING_SJLJ_EXCEPTIONS__) && defined(__arm__) && \

    !defined(__ARM_DWARF_EH__) && !defined(__APPLE__)

#define LIBCXXABI_ARM_EHABI 1

#else

#define LIBCXXABI_ARM_EHABI 0

#endif

#ifdef __cplusplus

namespace std {

    class type_info; // forward declaration

}

// runtime routines use C calling conventions, but are in __cxxabiv1 namespace

namespace __cxxabiv1 {  

  extern "C"  {

// 2.4.2 Allocating the Exception Object

extern void * __cxa_allocate_exception(size_t thrown_size) throw();

extern void __cxa_free_exception(void * thrown_exception) throw();

// 2.4.3 Throwing the Exception Object

extern LIBCXXABI_NORETURN void __cxa_throw(void * thrown_exception, 

        std::type_info * tinfo, void (*dest)(void *));

// 2.5.3 Exception Handlers

extern void * __cxa_get_exception_ptr(void * exceptionObject) throw();

extern void * __cxa_begin_catch(void * exceptionObject) throw();

extern void __cxa_end_catch();

#if LIBCXXABI_ARM_EHABI

extern bool __cxa_begin_cleanup(void * exceptionObject) throw();

extern void __cxa_end_cleanup();

#endif

extern std::type_info * __cxa_current_exception_type();

// 2.5.4 Rethrowing Exceptions

extern LIBCXXABI_NORETURN void __cxa_rethrow();

// 2.6 Auxiliary Runtime APIs

extern LIBCXXABI_NORETURN void __cxa_bad_cast(void);

extern LIBCXXABI_NORETURN void __cxa_bad_typeid(void);

// 3.2.6 Pure Virtual Function API

extern LIBCXXABI_NORETURN void __cxa_pure_virtual(void);

// 3.2.7 Deleted Virtual Function API

extern LIBCXXABI_NORETURN void __cxa_deleted_virtual(void);

// 3.3.2 One-time Construction API

#if __arm__

extern int  __cxa_guard_acquire(uint32_t*);

extern void __cxa_guard_release(uint32_t*);

extern void __cxa_guard_abort(uint32_t*);

#else

extern int  __cxa_guard_acquire(uint64_t*);

extern void __cxa_guard_release(uint64_t*);

extern void __cxa_guard_abort(uint64_t*);

#endif

// 3.3.3 Array Construction and Destruction API

extern void* __cxa_vec_new(size_t element_count, 

                           size_t element_size, 

                           size_t padding_size, 

                           void (*constructor)(void*),

                           void (*destructor)(void*) );

extern 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*) );

extern 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) );

extern void __cxa_vec_ctor(void*  array_address, 

                           size_t element_count,

                           size_t element_size, 

                           void (*constructor)(void*),

                           void (*destructor)(void*) );

extern void __cxa_vec_dtor(void*  array_address, 

                           size_t element_count,

                           size_t element_size, 

                           void (*destructor)(void*) );

extern void __cxa_vec_cleanup(void* array_address, 

                             size_t element_count,

                             size_t element_size, 

                             void  (*destructor)(void*) );

extern void __cxa_vec_delete(void*  array_address, 

                             size_t element_size, 

                             size_t padding_size, 

                             void  (*destructor)(void*) );

extern void __cxa_vec_delete2(void* array_address, 

                             size_t element_size, 

                             size_t padding_size, 

                             void  (*destructor)(void*),

                             void  (*dealloc)(void*) );

extern void __cxa_vec_delete3(void* __array_address, 

                             size_t element_size, 

                             size_t padding_size, 

                             void  (*destructor)(void*),

                             void  (*dealloc) (void*, size_t));

extern void __cxa_vec_cctor(void*  dest_array, 

                            void*  src_array, 

                            size_t element_count, 

                            size_t element_size, 

                            void  (*constructor) (void*, void*), 

                            void  (*destructor)(void*) );

// 3.3.5.3 Runtime API

extern int __cxa_atexit(void (*f)(void*), void* p, void* d);

extern int __cxa_finalize(void*);

// 3.4 Demangler API

extern char* __cxa_demangle(const char* mangled_name, 

                            char*       output_buffer,

                            size_t*     length, 

                            int*        status);

// Apple additions to support C++ 0x exception_ptr class

// These are primitives to wrap a smart pointer around an exception object

extern void * __cxa_current_primary_exception() throw();

extern void __cxa_rethrow_primary_exception(void* primary_exception);

extern void __cxa_increment_exception_refcount(void* primary_exception) throw();

extern void __cxa_decrement_exception_refcount(void* primary_exception) throw();

// Apple addition to support std::uncaught_exception()

extern bool __cxa_uncaught_exception() throw();

  } // extern "C"

} // namespace __cxxabiv1

namespace abi = __cxxabiv1;

#endif // __cplusplus

#endif // __CXXABI_H