1 // -*- C++ -*- Allocate exception objects.
2 // Copyright (C) 2001-2015 Free Software Foundation, Inc.
4 // This file is part of GCC.
6 // GCC is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 3, or (at your option)
11 // GCC is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
25 // This is derived from the C++ ABI for IA-64. Where we diverge
26 // for cross-architecture compatibility are noted with "@@@".
28 #include <bits/c++config.h>
35 #include "unwind-cxx.h"
36 #include <ext/concurrence.h>
44 // In a freestanding environment, these functions may not be available
45 // -- but for now, we assume that they are.
46 extern "C" void *malloc (std::size_t);
47 extern "C" void free(void *);
48 extern "C" void *memset (void *, int, std::size_t);
51 using namespace __cxxabiv1
;
53 // ??? How to control these parameters.
55 // Guess from the size of basic types how large a buffer is reasonable.
56 // Note that the basic c++ exception header has 13 pointers and 2 ints,
57 // so on a system with PSImode pointers we're talking about 56 bytes
61 # define EMERGENCY_OBJ_SIZE 128
62 # define EMERGENCY_OBJ_COUNT 16
63 #elif !defined (_GLIBCXX_LLP64) && LONG_MAX == 2147483647
64 # define EMERGENCY_OBJ_SIZE 512
65 # define EMERGENCY_OBJ_COUNT 32
67 # define EMERGENCY_OBJ_SIZE 1024
68 # define EMERGENCY_OBJ_COUNT 64
72 # undef EMERGENCY_OBJ_COUNT
73 # define EMERGENCY_OBJ_COUNT 4
79 // A fixed-size heap, variable size object allocator
85 void *allocate (std::size_t);
88 bool in_pool (void *);
95 struct allocated_entry
{
97 char data
[] __attribute__((aligned
));
100 // A single mutex controlling emergency allocations.
101 __gnu_cxx::__mutex emergency_mutex
;
104 free_entry
*first_free_entry
;
105 // The arena itself - we need to keep track of these only
106 // to implement in_pool.
108 std::size_t arena_size
;
113 // Allocate the arena - we could add a GLIBCXX_EH_ARENA_SIZE environment
114 // to make this tunable.
115 arena_size
= (EMERGENCY_OBJ_SIZE
* EMERGENCY_OBJ_COUNT
116 + EMERGENCY_OBJ_COUNT
* sizeof (__cxa_dependent_exception
));
117 arena
= (char *)malloc (arena_size
);
120 // If the allocation failed go without an emergency pool.
122 first_free_entry
= NULL
;
126 // Populate the free-list with a single entry covering the whole arena
127 first_free_entry
= reinterpret_cast <free_entry
*> (arena
);
128 new (first_free_entry
) free_entry
;
129 first_free_entry
->size
= arena_size
;
130 first_free_entry
->next
= NULL
;
133 void *pool::allocate (std::size_t size
)
135 __gnu_cxx::__scoped_lock
sentry(emergency_mutex
);
136 // We need an additional size_t member plus the padding to
137 // ensure proper alignment of data.
138 size
+= offsetof (allocated_entry
, data
);
139 // And we need to at least hand out objects of the size of
141 if (size
< sizeof (free_entry
))
142 size
= sizeof (free_entry
);
143 // And we need to align objects we hand out to the maximum
144 // alignment required on the target (this really aligns the
145 // tail which will become a new freelist entry).
146 size
= ((size
+ __alignof__ (allocated_entry::data
) - 1)
147 & ~(__alignof__ (allocated_entry::data
) - 1));
148 // Search for an entry of proper size on the freelist.
150 for (e
= &first_free_entry
;
151 *e
&& (*e
)->size
< size
;
157 if ((*e
)->size
- size
>= sizeof (free_entry
))
159 // Slit block if it is too large.
160 free_entry
*f
= reinterpret_cast <free_entry
*>
161 (reinterpret_cast <char *> (*e
) + size
);
162 std::size_t sz
= (*e
)->size
;
163 free_entry
*next
= (*e
)->next
;
167 x
= reinterpret_cast <allocated_entry
*> (*e
);
168 new (x
) allocated_entry
;
174 // Exact size match or too small overhead for a free entry.
175 std::size_t sz
= (*e
)->size
;
176 free_entry
*next
= (*e
)->next
;
177 x
= reinterpret_cast <allocated_entry
*> (*e
);
178 new (x
) allocated_entry
;
185 void pool::free (void *data
)
187 __gnu_cxx::__scoped_lock
sentry(emergency_mutex
);
188 allocated_entry
*e
= reinterpret_cast <allocated_entry
*>
189 (reinterpret_cast <char *> (data
) - offsetof (allocated_entry
, data
));
190 std::size_t sz
= e
->size
;
191 if (!first_free_entry
)
193 // If the free list is empty just put the entry there.
194 free_entry
*f
= reinterpret_cast <free_entry
*> (e
);
198 first_free_entry
= f
;
200 else if (reinterpret_cast <char *> (e
) + sz
201 == reinterpret_cast <char *> (first_free_entry
))
203 // Check if we can merge with the first free entry being right
205 free_entry
*f
= reinterpret_cast <free_entry
*> (e
);
207 f
->size
= sz
+ first_free_entry
->size
;
208 f
->next
= first_free_entry
->next
;
209 first_free_entry
= f
;
213 // Else search for a free item we can merge with at its end.
215 for (fe
= &first_free_entry
;
217 && (reinterpret_cast <char *> ((*fe
)->next
)
218 > reinterpret_cast <char *> (e
) + sz
);
221 if (reinterpret_cast <char *> (*fe
) + (*fe
)->size
222 == reinterpret_cast <char *> (e
))
223 /* Merge with the freelist entry. */
227 // Else put it after it which keeps the freelist sorted.
228 free_entry
*f
= reinterpret_cast <free_entry
*> (e
);
231 f
->next
= (*fe
)->next
;
237 bool pool::in_pool (void *ptr
)
239 char *p
= reinterpret_cast <char *> (ptr
);
241 && p
< arena
+ arena_size
);
248 __cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size
) _GLIBCXX_NOTHROW
252 thrown_size
+= sizeof (__cxa_refcounted_exception
);
253 ret
= malloc (thrown_size
);
256 ret
= emergency_pool
.allocate (thrown_size
);
261 memset (ret
, 0, sizeof (__cxa_refcounted_exception
));
263 return (void *)((char *)ret
+ sizeof (__cxa_refcounted_exception
));
268 __cxxabiv1::__cxa_free_exception(void *vptr
) _GLIBCXX_NOTHROW
270 char *ptr
= (char *) vptr
- sizeof (__cxa_refcounted_exception
);
271 if (emergency_pool
.in_pool (ptr
))
272 emergency_pool
.free (ptr
);
278 extern "C" __cxa_dependent_exception
*
279 __cxxabiv1::__cxa_allocate_dependent_exception() _GLIBCXX_NOTHROW
281 __cxa_dependent_exception
*ret
;
283 ret
= static_cast<__cxa_dependent_exception
*>
284 (malloc (sizeof (__cxa_dependent_exception
)));
287 ret
= static_cast <__cxa_dependent_exception
*>
288 (emergency_pool
.allocate (sizeof (__cxa_dependent_exception
)));
293 memset (ret
, 0, sizeof (__cxa_dependent_exception
));
300 __cxxabiv1::__cxa_free_dependent_exception
301 (__cxa_dependent_exception
*vptr
) _GLIBCXX_NOTHROW
303 if (emergency_pool
.in_pool (vptr
))
304 emergency_pool
.free (vptr
);