1 // New abi Support -*- C++ -*-
3 // Copyright (C) 2000, 2001 Free Software Foundation, Inc.
5 // This file is part of GNU CC.
7 // GNU CC 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 // GNU CC 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 GNU CC; see the file COPYING. If not, write to
19 // the Free Software Foundation, 59 Temple Place - Suite 330,
20 // Boston, MA 02111-1307, 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 // Written by Nathan Sidwell, Codesourcery LLC, <nathan@codesourcery.com>
36 #include <exception_defines.h>
38 #include "unwind-cxx.h"
44 struct uncatch_exception
47 ~uncatch_exception () { __cxa_begin_catch (&p->unwindHeader); }
52 uncatch_exception::uncatch_exception ()
54 __cxa_eh_globals *globals = __cxa_get_globals_fast ();
56 p = globals->caughtExceptions;
58 globals->caughtExceptions = p->nextException;
59 globals->uncaughtExceptions += 1;
63 // Allocate and construct array.
65 __cxa_vec_new(std::size_t element_count,
66 std::size_t element_size,
67 std::size_t padding_size,
68 void (*constructor) (void *),
69 void (*destructor) (void *))
71 return __cxa_vec_new2(element_count, element_size, padding_size,
72 constructor, destructor,
73 &operator new[], &operator delete []);
77 __cxa_vec_new2(std::size_t element_count,
78 std::size_t element_size,
79 std::size_t padding_size,
80 void (*constructor) (void *),
81 void (*destructor) (void *),
82 void *(*alloc) (std::size_t),
83 void (*dealloc) (void *))
85 std::size_t size = element_count * element_size + padding_size;
86 char *base = static_cast <char *> (alloc (size));
91 reinterpret_cast <std::size_t *> (base)[-1] = element_count;
95 __cxa_vec_ctor(base, element_count, element_size,
96 constructor, destructor);
101 uncatch_exception ue;
102 dealloc(base - padding_size);
104 __throw_exception_again;
110 __cxa_vec_new3(std::size_t element_count,
111 std::size_t element_size,
112 std::size_t padding_size,
113 void (*constructor) (void *),
114 void (*destructor) (void *),
115 void *(*alloc) (std::size_t),
116 void (*dealloc) (void *, std::size_t))
118 std::size_t size = element_count * element_size + padding_size;
119 char *base = static_cast<char *>(alloc (size));
123 base += padding_size;
124 reinterpret_cast<std::size_t *>(base)[-1] = element_count;
128 __cxa_vec_ctor(base, element_count, element_size,
129 constructor, destructor);
134 uncatch_exception ue;
135 dealloc(base - padding_size, size);
137 __throw_exception_again;
144 __cxa_vec_ctor(void *array_address,
145 std::size_t element_count,
146 std::size_t element_size,
147 void (*constructor) (void *),
148 void (*destructor) (void *))
151 char *ptr = static_cast<char *>(array_address);
156 for (; ix != element_count; ix++, ptr += element_size)
162 uncatch_exception ue;
163 __cxa_vec_cleanup(array_address, ix, element_size, destructor);
165 __throw_exception_again;
169 // Construct an array by copying.
171 __cxa_vec_cctor(void *dest_array,
173 std::size_t element_count,
174 std::size_t element_size,
175 void (*constructor) (void *, void *),
176 void (*destructor) (void *))
179 char *dest_ptr = static_cast<char *>(dest_array);
180 char *src_ptr = static_cast<char *>(src_array);
185 for (; ix != element_count;
186 ix++, src_ptr += element_size, dest_ptr += element_size)
187 constructor(dest_ptr, src_ptr);
192 uncatch_exception ue;
193 __cxa_vec_cleanup(dest_array, ix, element_size, destructor);
195 __throw_exception_again;
201 __cxa_vec_dtor(void *array_address,
202 std::size_t element_count,
203 std::size_t element_size,
204 void (*destructor) (void *))
208 char *ptr = static_cast<char *>(array_address);
209 std::size_t ix = element_count;
211 ptr += element_count * element_size;
224 uncatch_exception ue;
225 __cxa_vec_cleanup(array_address, ix, element_size, destructor);
227 __throw_exception_again;
232 // Destruct array as a result of throwing an exception.
233 // [except.ctor]/3 If a destructor called during stack unwinding
234 // exits with an exception, terminate is called.
236 __cxa_vec_cleanup(void *array_address,
237 std::size_t element_count,
238 std::size_t element_size,
239 void (*destructor) (void *))
243 char *ptr = static_cast <char *> (array_address);
244 std::size_t ix = element_count;
246 ptr += element_count * element_size;
263 // Destruct and release array.
265 __cxa_vec_delete(void *array_address,
266 std::size_t element_size,
267 std::size_t padding_size,
268 void (*destructor) (void *))
270 __cxa_vec_delete2(array_address, element_size, padding_size,
272 &operator delete []);
276 __cxa_vec_delete2(void *array_address,
277 std::size_t element_size,
278 std::size_t padding_size,
279 void (*destructor) (void *),
280 void (*dealloc) (void *))
282 char *base = static_cast<char *>(array_address);
286 std::size_t element_count = reinterpret_cast<std::size_t *>(base)[-1];
287 base -= padding_size;
290 __cxa_vec_dtor(array_address, element_count, element_size,
296 uncatch_exception ue;
299 __throw_exception_again;
306 __cxa_vec_delete3(void *array_address,
307 std::size_t element_size,
308 std::size_t padding_size,
309 void (*destructor) (void *),
310 void (*dealloc) (void *, std::size_t))
312 char *base = static_cast <char *> (array_address);
313 std::size_t size = 0;
317 std::size_t element_count = reinterpret_cast<std::size_t *> (base)[-1];
318 base -= padding_size;
319 size = element_count * element_size + padding_size;
322 __cxa_vec_dtor(array_address, element_count, element_size,
328 uncatch_exception ue;
331 __throw_exception_again;
336 } // namespace __cxxabiv1