1 // New abi Support -*- C++ -*-
3 // Copyright (C) 2000, 2001, 2003, 2004 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, 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>
37 #include "unwind-cxx.h"
43 struct uncatch_exception
46 ~uncatch_exception () { __cxa_begin_catch (&p
->unwindHeader
); }
52 operator=(const uncatch_exception
&);
54 uncatch_exception(const uncatch_exception
&);
57 uncatch_exception::uncatch_exception() : p(0)
59 __cxa_eh_globals
*globals
= __cxa_get_globals_fast ();
61 p
= globals
->caughtExceptions
;
63 globals
->caughtExceptions
= p
->nextException
;
64 globals
->uncaughtExceptions
+= 1;
68 // Allocate and construct array.
70 __cxa_vec_new(std::size_t element_count
,
71 std::size_t element_size
,
72 std::size_t padding_size
,
73 void (*constructor
) (void *),
74 void (*destructor
) (void *))
76 return __cxa_vec_new2(element_count
, element_size
, padding_size
,
77 constructor
, destructor
,
78 &operator new[], &operator delete []);
82 __cxa_vec_new2(std::size_t element_count
,
83 std::size_t element_size
,
84 std::size_t padding_size
,
85 void (*constructor
) (void *),
86 void (*destructor
) (void *),
87 void *(*alloc
) (std::size_t),
88 void (*dealloc
) (void *))
90 std::size_t size
= element_count
* element_size
+ padding_size
;
91 char *base
= static_cast <char *> (alloc (size
));
98 reinterpret_cast <std::size_t *> (base
)[-1] = element_count
;
99 #ifdef _GLIBCXX_ELTSIZE_IN_COOKIE
100 reinterpret_cast <std::size_t *> (base
)[-2] = element_size
;
105 __cxa_vec_ctor(base
, element_count
, element_size
,
106 constructor
, destructor
);
111 uncatch_exception ue
;
112 dealloc(base
- padding_size
);
114 __throw_exception_again
;
120 __cxa_vec_new3(std::size_t element_count
,
121 std::size_t element_size
,
122 std::size_t padding_size
,
123 void (*constructor
) (void *),
124 void (*destructor
) (void *),
125 void *(*alloc
) (std::size_t),
126 void (*dealloc
) (void *, std::size_t))
128 std::size_t size
= element_count
* element_size
+ padding_size
;
129 char *base
= static_cast<char *>(alloc (size
));
135 base
+= padding_size
;
136 reinterpret_cast<std::size_t *>(base
)[-1] = element_count
;
137 #ifdef _GLIBCXX_ELTSIZE_IN_COOKIE
138 reinterpret_cast <std::size_t *> (base
)[-2] = element_size
;
143 __cxa_vec_ctor(base
, element_count
, element_size
,
144 constructor
, destructor
);
149 uncatch_exception ue
;
150 dealloc(base
- padding_size
, size
);
152 __throw_exception_again
;
158 extern "C" __cxa_vec_ctor_return_type
159 __cxa_vec_ctor(void *array_address
,
160 std::size_t element_count
,
161 std::size_t element_size
,
162 void (*constructor
) (void *),
163 void (*destructor
) (void *))
166 char *ptr
= static_cast<char *>(array_address
);
171 for (; ix
!= element_count
; ix
++, ptr
+= element_size
)
177 uncatch_exception ue
;
178 __cxa_vec_cleanup(array_address
, ix
, element_size
, destructor
);
180 __throw_exception_again
;
182 _GLIBCXX_CXA_VEC_CTOR_RETURN (array_address
);
185 // Construct an array by copying.
186 extern "C" __cxa_vec_ctor_return_type
187 __cxa_vec_cctor(void *dest_array
,
189 std::size_t element_count
,
190 std::size_t element_size
,
191 void (*constructor
) (void *, void *),
192 void (*destructor
) (void *))
195 char *dest_ptr
= static_cast<char *>(dest_array
);
196 char *src_ptr
= static_cast<char *>(src_array
);
201 for (; ix
!= element_count
;
202 ix
++, src_ptr
+= element_size
, dest_ptr
+= element_size
)
203 constructor(dest_ptr
, src_ptr
);
208 uncatch_exception ue
;
209 __cxa_vec_cleanup(dest_array
, ix
, element_size
, destructor
);
211 __throw_exception_again
;
213 _GLIBCXX_CXA_VEC_CTOR_RETURN (dest_array
);
218 __cxa_vec_dtor(void *array_address
,
219 std::size_t element_count
,
220 std::size_t element_size
,
221 void (*destructor
) (void *))
225 char *ptr
= static_cast<char *>(array_address
);
226 std::size_t ix
= element_count
;
228 ptr
+= element_count
* element_size
;
241 uncatch_exception ue
;
242 __cxa_vec_cleanup(array_address
, ix
, element_size
, destructor
);
244 __throw_exception_again
;
249 // Destruct array as a result of throwing an exception.
250 // [except.ctor]/3 If a destructor called during stack unwinding
251 // exits with an exception, terminate is called.
253 __cxa_vec_cleanup(void *array_address
,
254 std::size_t element_count
,
255 std::size_t element_size
,
256 void (*destructor
) (void *))
260 char *ptr
= static_cast <char *> (array_address
);
261 std::size_t ix
= element_count
;
263 ptr
+= element_count
* element_size
;
280 // Destruct and release array.
282 __cxa_vec_delete(void *array_address
,
283 std::size_t element_size
,
284 std::size_t padding_size
,
285 void (*destructor
) (void *))
287 __cxa_vec_delete2(array_address
, element_size
, padding_size
,
289 &operator delete []);
293 __cxa_vec_delete2(void *array_address
,
294 std::size_t element_size
,
295 std::size_t padding_size
,
296 void (*destructor
) (void *),
297 void (*dealloc
) (void *))
302 char* base
= static_cast<char *>(array_address
);
306 std::size_t element_count
= reinterpret_cast<std::size_t *>(base
)[-1];
307 base
-= padding_size
;
310 __cxa_vec_dtor(array_address
, element_count
, element_size
,
316 uncatch_exception ue
;
319 __throw_exception_again
;
326 __cxa_vec_delete3(void *array_address
,
327 std::size_t element_size
,
328 std::size_t padding_size
,
329 void (*destructor
) (void *),
330 void (*dealloc
) (void *, std::size_t))
335 char* base
= static_cast <char *> (array_address
);
336 std::size_t size
= 0;
340 std::size_t element_count
= reinterpret_cast<std::size_t *> (base
)[-1];
341 base
-= padding_size
;
342 size
= element_count
* element_size
+ padding_size
;
345 __cxa_vec_dtor(array_address
, element_count
, element_size
,
351 uncatch_exception ue
;
354 __throw_exception_again
;
359 } // namespace __cxxabiv1