X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;f=libstdc%2B%2B-v3%2Flibsupc%2B%2B%2Feh_alloc.cc;fp=libstdc%2B%2B-v3%2Flibsupc%2B%2B%2Feh_alloc.cc;h=818af0fe1f024ec7175320d57d253cc036f3ed75;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=b328acbc914c4adcfcfe3f07b2c3b59160aa7098;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git
diff --git a/libstdc++-v3/libsupc++/eh_alloc.cc b/libstdc++-v3/libsupc++/eh_alloc.cc
index b328acbc..818af0fe 100644
--- a/libstdc++-v3/libsupc++/eh_alloc.cc
+++ b/libstdc++-v3/libsupc++/eh_alloc.cc
@@ -1,45 +1,54 @@
// -*- C++ -*- Allocate exception objects.
-// Copyright (C) 2001 Free Software Foundation, Inc.
+// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009
+// Free Software Foundation, Inc.
//
-// This file is part of GNU CC.
+// This file is part of GCC.
//
-// GNU CC is free software; you can redistribute it and/or modify
+// 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 2, or (at your option)
+// the Free Software Foundation; either version 3, or (at your option)
// any later version.
//
-// GNU CC is distributed in the hope that it will be useful,
+// 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.
//
-// You should have received a copy of the GNU General Public License
-// along with GNU CC; see the file COPYING. If not, write to
-// the Free Software Foundation, 59 Temple Place - Suite 330,
-// Boston, MA 02111-1307, USA.
-
-// As a special exception, you may use this file as part of a free software
-// library without restriction. Specifically, if other files instantiate
-// templates or use macros or inline functions from this file, or you compile
-// this file and link it with other files to produce an executable, this
-// file does not by itself cause the resulting executable to be covered by
-// the GNU General Public License. This exception does not however
-// invalidate any other reasons why the executable file might be covered by
-// the GNU General Public License.
+// 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
+// .
// This is derived from the C++ ABI for IA-64. Where we diverge
// for cross-architecture compatibility are noted with "@@@".
+#include
#include
+#if _GLIBCXX_HOSTED
#include
+#endif
#include
#include
#include "unwind-cxx.h"
-#include "bits/c++config.h"
-#include "bits/gthr.h"
+#include
-using namespace __cxxabiv1;
+#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.
@@ -75,41 +84,26 @@ 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;
-#ifdef __GTHREADS
-#ifdef __GTHREAD_MUTEX_INIT
-static __gthread_mutex_t emergency_mutex =__GTHREAD_MUTEX_INIT;
-#else
-static __gthread_mutex_t emergency_mutex;
-#endif
-
-#ifdef __GTHREAD_MUTEX_INIT_FUNCTION
-static void
-emergency_mutex_init ()
+namespace
{
- __GTHREAD_MUTEX_INIT_FUNCTION (&emergency_mutex);
+ // A single mutex controlling emergency allocations.
+ __gnu_cxx::__mutex emergency_mutex;
}
-#endif
-#endif
-
extern "C" void *
-__cxa_allocate_exception(std::size_t thrown_size)
+__cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size) throw()
{
void *ret;
- thrown_size += sizeof (__cxa_exception);
- ret = std::malloc (thrown_size);
+ thrown_size += sizeof (__cxa_refcounted_exception);
+ ret = malloc (thrown_size);
if (! ret)
{
-#ifdef __GTHREADS
-#ifdef __GTHREAD_MUTEX_INIT_FUNCTION
- static __gthread_once_t once = __GTHREAD_ONCE_INIT;
- __gthread_once (&once, emergency_mutex_init);
-#endif
- __gthread_mutex_lock (&emergency_mutex);
-#endif
+ __gnu_cxx::__scoped_lock sentry(emergency_mutex);
bitmask_type used = emergency_used;
unsigned int which = 0;
@@ -127,37 +121,100 @@ __cxa_allocate_exception(std::size_t thrown_size)
ret = &emergency_buffer[which][0];
failed:;
-#ifdef __GTHREADS
- __gthread_mutex_unlock (&emergency_mutex);
-#endif
+
if (!ret)
std::terminate ();
}
- std::memset (ret, 0, sizeof (__cxa_exception));
+ // 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_exception));
+ return (void *)((char *)ret + sizeof (__cxa_refcounted_exception));
}
extern "C" void
-__cxa_free_exception(void *vptr)
+__cxxabiv1::__cxa_free_exception(void *vptr) throw()
{
+ char *base = (char *) emergency_buffer;
char *ptr = (char *) vptr;
- if (ptr >= &emergency_buffer[0][0]
- && ptr < &emergency_buffer[0][0] + sizeof (emergency_buffer))
+ if (ptr >= base
+ && ptr < base + sizeof (emergency_buffer))
{
- unsigned int which
- = (unsigned)(ptr - &emergency_buffer[0][0]) / EMERGENCY_OBJ_SIZE;
+ const unsigned int which
+ = (unsigned) (ptr - base) / EMERGENCY_OBJ_SIZE;
-#ifdef __GTHREADS
- __gthread_mutex_lock (&emergency_mutex);
- emergency_used &= ~((bitmask_type)1 << which);
- __gthread_mutex_unlock (&emergency_mutex);
-#else
+ __gnu_cxx::__scoped_lock sentry(emergency_mutex);
emergency_used &= ~((bitmask_type)1 << which);
-#endif
}
else
- std::free (ptr - sizeof (__cxa_exception));
+ 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);
}