1 // -*- C++ -*- Allocate exception objects.
2 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2008, 2009
3 // Free Software Foundation, Inc.
5 // This file is part of GCC.
7 // GCC is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU General Public License as published by
9 // the Free Software Foundation; either version 2, or (at your option)
12 // GCC is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
17 // You should have received a copy of the GNU General Public License
18 // along with GCC; see the file COPYING. If not, write to
19 // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
20 // Boston, MA 02110-1301, USA.
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction. Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License. This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
31 // This is derived from the C++ ABI for IA-64. Where we diverge
32 // for cross-architecture compatibility are noted with "@@@".
34 #include <bits/c++config.h>
41 #include "unwind-cxx.h"
42 #include <ext/concurrence.h>
49 // In a freestanding environment, these functions may not be available
50 // -- but for now, we assume that they are.
51 extern "C" void *malloc (std::size_t);
52 extern "C" void free(void *);
53 extern "C" void *memset (void *, int, std::size_t);
56 using namespace __cxxabiv1;
58 // ??? How to control these parameters.
60 // Guess from the size of basic types how large a buffer is reasonable.
61 // Note that the basic c++ exception header has 13 pointers and 2 ints,
62 // so on a system with PSImode pointers we're talking about 56 bytes
66 # define EMERGENCY_OBJ_SIZE 128
67 # define EMERGENCY_OBJ_COUNT 16
68 #elif LONG_MAX == 2147483647
69 # define EMERGENCY_OBJ_SIZE 512
70 # define EMERGENCY_OBJ_COUNT 32
72 # define EMERGENCY_OBJ_SIZE 1024
73 # define EMERGENCY_OBJ_COUNT 64
77 # undef EMERGENCY_OBJ_COUNT
78 # define EMERGENCY_OBJ_COUNT 4
81 #if INT_MAX == 32767 || EMERGENCY_OBJ_COUNT <= 32
82 typedef unsigned int bitmask_type;
84 typedef unsigned long bitmask_type;
88 typedef char one_buffer[EMERGENCY_OBJ_SIZE] __attribute__((aligned));
89 static one_buffer emergency_buffer[EMERGENCY_OBJ_COUNT];
90 static bitmask_type emergency_used;
92 static __cxa_dependent_exception dependents_buffer[EMERGENCY_OBJ_COUNT];
93 static bitmask_type dependents_used;
97 // A single mutex controlling emergency allocations.
98 __gnu_cxx::__mutex emergency_mutex;
102 __cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size) throw()
106 thrown_size += sizeof (__cxa_refcounted_exception);
107 ret = malloc (thrown_size);
111 __gnu_cxx::__scoped_lock sentry(emergency_mutex);
113 bitmask_type used = emergency_used;
114 unsigned int which = 0;
116 if (thrown_size > EMERGENCY_OBJ_SIZE)
121 if (++which >= EMERGENCY_OBJ_COUNT)
125 emergency_used |= (bitmask_type)1 << which;
126 ret = &emergency_buffer[which][0];
134 // We have an uncaught exception as soon as we allocate memory. This
135 // yields uncaught_exception() true during the copy-constructor that
136 // initializes the exception object. See Issue 475.
137 __cxa_eh_globals *globals = __cxa_get_globals ();
138 globals->uncaughtExceptions += 1;
140 memset (ret, 0, sizeof (__cxa_refcounted_exception));
142 return (void *)((char *)ret + sizeof (__cxa_refcounted_exception));
147 __cxxabiv1::__cxa_free_exception(void *vptr) throw()
149 char *base = (char *) emergency_buffer;
150 char *ptr = (char *) vptr;
152 && ptr < base + sizeof (emergency_buffer))
154 const unsigned int which
155 = (unsigned) (ptr - base) / EMERGENCY_OBJ_SIZE;
157 __gnu_cxx::__scoped_lock sentry(emergency_mutex);
158 emergency_used &= ~((bitmask_type)1 << which);
161 free (ptr - sizeof (__cxa_refcounted_exception));
165 extern "C" __cxa_dependent_exception*
166 __cxxabiv1::__cxa_allocate_dependent_exception() throw()
168 __cxa_dependent_exception *ret;
170 ret = static_cast<__cxa_dependent_exception*>
171 (malloc (sizeof (__cxa_dependent_exception)));
175 __gnu_cxx::__scoped_lock sentry(emergency_mutex);
177 bitmask_type used = dependents_used;
178 unsigned int which = 0;
183 if (++which >= EMERGENCY_OBJ_COUNT)
187 dependents_used |= (bitmask_type)1 << which;
188 ret = &dependents_buffer[which];
196 // We have an uncaught exception as soon as we allocate memory. This
197 // yields uncaught_exception() true during the copy-constructor that
198 // initializes the exception object. See Issue 475.
199 __cxa_eh_globals *globals = __cxa_get_globals ();
200 globals->uncaughtExceptions += 1;
202 memset (ret, 0, sizeof (__cxa_dependent_exception));
209 __cxxabiv1::__cxa_free_dependent_exception
210 (__cxa_dependent_exception *vptr) throw()
212 char *base = (char *) dependents_buffer;
213 char *ptr = (char *) vptr;
215 && ptr < base + sizeof (dependents_buffer))
217 const unsigned int which
218 = (unsigned) (ptr - base) / sizeof (__cxa_dependent_exception);
220 __gnu_cxx::__scoped_lock sentry(emergency_mutex);
221 dependents_used &= ~((bitmask_type)1 << which);