diff options
Diffstat (limited to 'libstdc++-v3/libsupc++/eh_alloc.cc')
| -rw-r--r-- | libstdc++-v3/libsupc++/eh_alloc.cc | 220 |
1 files changed, 220 insertions, 0 deletions
diff --git a/libstdc++-v3/libsupc++/eh_alloc.cc b/libstdc++-v3/libsupc++/eh_alloc.cc new file mode 100644 index 000000000..818af0fe1 --- /dev/null +++ b/libstdc++-v3/libsupc++/eh_alloc.cc @@ -0,0 +1,220 @@ +// -*- C++ -*- Allocate exception objects. +// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009 +// Free Software Foundation, Inc. +// +// This file is part of GCC. +// +// GCC is free software; you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// GCC is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// This is derived from the C++ ABI for IA-64. Where we diverge +// for cross-architecture compatibility are noted with "@@@". + +#include <bits/c++config.h> +#include <cstdlib> +#if _GLIBCXX_HOSTED +#include <cstring> +#endif +#include <climits> +#include <exception> +#include "unwind-cxx.h" +#include <ext/concurrence.h> + +#if _GLIBCXX_HOSTED +using std::free; +using std::malloc; +using std::memset; +#else +// In a freestanding environment, these functions may not be available +// -- but for now, we assume that they are. +extern "C" void *malloc (std::size_t); +extern "C" void free(void *); +extern "C" void *memset (void *, int, std::size_t); +#endif + +using namespace __cxxabiv1; + +// ??? How to control these parameters. + +// Guess from the size of basic types how large a buffer is reasonable. +// Note that the basic c++ exception header has 13 pointers and 2 ints, +// so on a system with PSImode pointers we're talking about 56 bytes +// just for overhead. + +#if INT_MAX == 32767 +# define EMERGENCY_OBJ_SIZE 128 +# define EMERGENCY_OBJ_COUNT 16 +#elif LONG_MAX == 2147483647 +# define EMERGENCY_OBJ_SIZE 512 +# define EMERGENCY_OBJ_COUNT 32 +#else +# define EMERGENCY_OBJ_SIZE 1024 +# define EMERGENCY_OBJ_COUNT 64 +#endif + +#ifndef __GTHREADS +# undef EMERGENCY_OBJ_COUNT +# define EMERGENCY_OBJ_COUNT 4 +#endif + +#if INT_MAX == 32767 || EMERGENCY_OBJ_COUNT <= 32 +typedef unsigned int bitmask_type; +#else +typedef unsigned long bitmask_type; +#endif + + +typedef char one_buffer[EMERGENCY_OBJ_SIZE] __attribute__((aligned)); +static one_buffer emergency_buffer[EMERGENCY_OBJ_COUNT]; +static bitmask_type emergency_used; + +static __cxa_dependent_exception dependents_buffer[EMERGENCY_OBJ_COUNT]; +static bitmask_type dependents_used; + +namespace +{ + // A single mutex controlling emergency allocations. + __gnu_cxx::__mutex emergency_mutex; +} + +extern "C" void * +__cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size) throw() +{ + void *ret; + + thrown_size += sizeof (__cxa_refcounted_exception); + ret = malloc (thrown_size); + + if (! ret) + { + __gnu_cxx::__scoped_lock sentry(emergency_mutex); + + bitmask_type used = emergency_used; + unsigned int which = 0; + + if (thrown_size > EMERGENCY_OBJ_SIZE) + goto failed; + while (used & 1) + { + used >>= 1; + if (++which >= EMERGENCY_OBJ_COUNT) + goto failed; + } + + emergency_used |= (bitmask_type)1 << which; + ret = &emergency_buffer[which][0]; + + failed:; + + if (!ret) + std::terminate (); + } + + // We have an uncaught exception as soon as we allocate memory. This + // yields uncaught_exception() true during the copy-constructor that + // initializes the exception object. See Issue 475. + __cxa_eh_globals *globals = __cxa_get_globals (); + globals->uncaughtExceptions += 1; + + memset (ret, 0, sizeof (__cxa_refcounted_exception)); + + return (void *)((char *)ret + sizeof (__cxa_refcounted_exception)); +} + + +extern "C" void +__cxxabiv1::__cxa_free_exception(void *vptr) throw() +{ + char *base = (char *) emergency_buffer; + char *ptr = (char *) vptr; + if (ptr >= base + && ptr < base + sizeof (emergency_buffer)) + { + const unsigned int which + = (unsigned) (ptr - base) / EMERGENCY_OBJ_SIZE; + + __gnu_cxx::__scoped_lock sentry(emergency_mutex); + emergency_used &= ~((bitmask_type)1 << which); + } + else + free (ptr - sizeof (__cxa_refcounted_exception)); +} + + +extern "C" __cxa_dependent_exception* +__cxxabiv1::__cxa_allocate_dependent_exception() throw() +{ + __cxa_dependent_exception *ret; + + ret = static_cast<__cxa_dependent_exception*> + (malloc (sizeof (__cxa_dependent_exception))); + + if (!ret) + { + __gnu_cxx::__scoped_lock sentry(emergency_mutex); + + bitmask_type used = dependents_used; + unsigned int which = 0; + + while (used & 1) + { + used >>= 1; + if (++which >= EMERGENCY_OBJ_COUNT) + goto failed; + } + + dependents_used |= (bitmask_type)1 << which; + ret = &dependents_buffer[which]; + + failed:; + + if (!ret) + std::terminate (); + } + + // We have an uncaught exception as soon as we allocate memory. This + // yields uncaught_exception() true during the copy-constructor that + // initializes the exception object. See Issue 475. + __cxa_eh_globals *globals = __cxa_get_globals (); + globals->uncaughtExceptions += 1; + + memset (ret, 0, sizeof (__cxa_dependent_exception)); + + return ret; +} + + +extern "C" void +__cxxabiv1::__cxa_free_dependent_exception + (__cxa_dependent_exception *vptr) throw() +{ + char *base = (char *) dependents_buffer; + char *ptr = (char *) vptr; + if (ptr >= base + && ptr < base + sizeof (dependents_buffer)) + { + const unsigned int which + = (unsigned) (ptr - base) / sizeof (__cxa_dependent_exception); + + __gnu_cxx::__scoped_lock sentry(emergency_mutex); + dependents_used &= ~((bitmask_type)1 << which); + } + else + free (vptr); +} |