annotate libcxxabi/www/spec.html @ 164:fdfabb438fbf

...
author anatofuz
date Thu, 19 Mar 2020 17:02:53 +0900
parents 1d019706d866
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
anatofuz
parents:
diff changeset
2 "http://www.w3.org/TR/html4/strict.dtd">
anatofuz
parents:
diff changeset
3 <html>
anatofuz
parents:
diff changeset
4 <head>
anatofuz
parents:
diff changeset
5 <title>libc++abi spec</title>
anatofuz
parents:
diff changeset
6 </head>
anatofuz
parents:
diff changeset
7 <body>
anatofuz
parents:
diff changeset
8
anatofuz
parents:
diff changeset
9 <table border=1>
anatofuz
parents:
diff changeset
10 <tr>
anatofuz
parents:
diff changeset
11 <th rowspan=2>libc++abi Specification</th>
anatofuz
parents:
diff changeset
12 <th colspan=3>Completed ?</th>
anatofuz
parents:
diff changeset
13 </tr>
anatofuz
parents:
diff changeset
14
anatofuz
parents:
diff changeset
15 <tr>
anatofuz
parents:
diff changeset
16 <th>darwin</th><th>linux</th><th>arm</th>
anatofuz
parents:
diff changeset
17 </tr>
anatofuz
parents:
diff changeset
18
anatofuz
parents:
diff changeset
19 <tr>
anatofuz
parents:
diff changeset
20 <td colspan=4 align="center">Memory management</td>
anatofuz
parents:
diff changeset
21 </tr>
anatofuz
parents:
diff changeset
22
anatofuz
parents:
diff changeset
23 <tr>
anatofuz
parents:
diff changeset
24 <td>
anatofuz
parents:
diff changeset
25 <p>
anatofuz
parents:
diff changeset
26 <code>void* __cxa_allocate_exception(size_t thrown_size) throw();</code>
anatofuz
parents:
diff changeset
27 </p>
anatofuz
parents:
diff changeset
28 <blockquote>
anatofuz
parents:
diff changeset
29 <p>
anatofuz
parents:
diff changeset
30 <i>Effects:</i> Allocates memory to hold the exception to be thrown.
anatofuz
parents:
diff changeset
31 <tt>thrown_size</tt> is the size of the exception object. Can allocate
anatofuz
parents:
diff changeset
32 additional memory to hold private data. If memory can not be allocated, call
anatofuz
parents:
diff changeset
33 <tt>std::terminate()</tt>.
anatofuz
parents:
diff changeset
34 </p>
anatofuz
parents:
diff changeset
35 <p>
anatofuz
parents:
diff changeset
36 <i>Returns:</i> A pointer to the memory allocated for the exception object.
anatofuz
parents:
diff changeset
37 </p>
anatofuz
parents:
diff changeset
38 </blockquote>
anatofuz
parents:
diff changeset
39 </td>
anatofuz
parents:
diff changeset
40 <td>&#10003;</td>
anatofuz
parents:
diff changeset
41 <td>&#10003;</td>
anatofuz
parents:
diff changeset
42 <td>&#10003;</td>
anatofuz
parents:
diff changeset
43 </tr>
anatofuz
parents:
diff changeset
44
anatofuz
parents:
diff changeset
45 <tr>
anatofuz
parents:
diff changeset
46 <td>
anatofuz
parents:
diff changeset
47 <p>
anatofuz
parents:
diff changeset
48 <code>void __cxa_free_exception(void * thrown_exception) throw();</code>
anatofuz
parents:
diff changeset
49 </p>
anatofuz
parents:
diff changeset
50 <blockquote>
anatofuz
parents:
diff changeset
51 <p>
anatofuz
parents:
diff changeset
52 <i>Effects:</i> Frees memory allocated by <tt>__cxa_allocate_exception</tt>.
anatofuz
parents:
diff changeset
53 </p>
anatofuz
parents:
diff changeset
54 </blockquote>
anatofuz
parents:
diff changeset
55 </td>
anatofuz
parents:
diff changeset
56 <td>&#10003;</td>
anatofuz
parents:
diff changeset
57 <td>&#10003;</td>
anatofuz
parents:
diff changeset
58 <td>&#10003;</td>
anatofuz
parents:
diff changeset
59 </tr>
anatofuz
parents:
diff changeset
60
anatofuz
parents:
diff changeset
61 <tr>
anatofuz
parents:
diff changeset
62 <td>
anatofuz
parents:
diff changeset
63 <p>
anatofuz
parents:
diff changeset
64 <code>void* __cxa_allocate_dependent_exception() throw();</code>
anatofuz
parents:
diff changeset
65 </p>
anatofuz
parents:
diff changeset
66 <blockquote>
anatofuz
parents:
diff changeset
67 <p>
anatofuz
parents:
diff changeset
68 <i>Effects:</i> Allocates memory to hold a "dependent" exception to be thrown.
anatofuz
parents:
diff changeset
69 <tt>thrown_size</tt> is the size of the exception object. Can allocate
anatofuz
parents:
diff changeset
70 additional memory to hold private data. If memory can not be allocated, call
anatofuz
parents:
diff changeset
71 <tt>std::terminate()</tt>.
anatofuz
parents:
diff changeset
72 </p>
anatofuz
parents:
diff changeset
73 <p>
anatofuz
parents:
diff changeset
74 <i>Returns:</i> A pointer to the memory allocated for the exception object.
anatofuz
parents:
diff changeset
75 </p>
anatofuz
parents:
diff changeset
76 </blockquote>
anatofuz
parents:
diff changeset
77 </td>
anatofuz
parents:
diff changeset
78 <td>&#10003;</td>
anatofuz
parents:
diff changeset
79 <td>&#10003;</td>
anatofuz
parents:
diff changeset
80 <td>&#10003;</td>
anatofuz
parents:
diff changeset
81 </tr>
anatofuz
parents:
diff changeset
82
anatofuz
parents:
diff changeset
83 <tr>
anatofuz
parents:
diff changeset
84 <td>
anatofuz
parents:
diff changeset
85 <p>
anatofuz
parents:
diff changeset
86 <code>void __cxa_free_dependent_exception (void* dependent_exception) throw();</code>
anatofuz
parents:
diff changeset
87 </p>
anatofuz
parents:
diff changeset
88 <blockquote>
anatofuz
parents:
diff changeset
89 <p>
anatofuz
parents:
diff changeset
90 <i>Effects:</i> Frees memory allocated by <tt>__cxa_allocate_dependent_exception</tt>.
anatofuz
parents:
diff changeset
91 </p>
anatofuz
parents:
diff changeset
92 </blockquote>
anatofuz
parents:
diff changeset
93 </td>
anatofuz
parents:
diff changeset
94 <td>&#10003;</td>
anatofuz
parents:
diff changeset
95 <td>&#10003;</td>
anatofuz
parents:
diff changeset
96 <td>&#10003;</td>
anatofuz
parents:
diff changeset
97 </tr>
anatofuz
parents:
diff changeset
98
anatofuz
parents:
diff changeset
99 <tr>
anatofuz
parents:
diff changeset
100 <td colspan=4 align="center">Exception Handling</td>
anatofuz
parents:
diff changeset
101 </tr>
anatofuz
parents:
diff changeset
102
anatofuz
parents:
diff changeset
103 <tr>
anatofuz
parents:
diff changeset
104 <td>
anatofuz
parents:
diff changeset
105 <p>
anatofuz
parents:
diff changeset
106 <code>void __cxa_throw(void* thrown_exception, struct std::type_info * tinfo,
anatofuz
parents:
diff changeset
107 void (*dest)(void*));</code>
anatofuz
parents:
diff changeset
108 </p>
anatofuz
parents:
diff changeset
109 <blockquote>
anatofuz
parents:
diff changeset
110 <p>
anatofuz
parents:
diff changeset
111 <i>Effects:</i>
anatofuz
parents:
diff changeset
112 </p>
anatofuz
parents:
diff changeset
113 </blockquote>
anatofuz
parents:
diff changeset
114 </td>
anatofuz
parents:
diff changeset
115 <td>&#10003;</td>
anatofuz
parents:
diff changeset
116 <td>&#10003;</td>
anatofuz
parents:
diff changeset
117 <td>&#10003;</td>
anatofuz
parents:
diff changeset
118 </tr>
anatofuz
parents:
diff changeset
119
anatofuz
parents:
diff changeset
120 <tr>
anatofuz
parents:
diff changeset
121 <td>
anatofuz
parents:
diff changeset
122 <p>
anatofuz
parents:
diff changeset
123 <code>void* __cxa_get_exception_ptr(void* exceptionObject) throw();</code>
anatofuz
parents:
diff changeset
124 </p>
anatofuz
parents:
diff changeset
125 <blockquote>
anatofuz
parents:
diff changeset
126 <p>
anatofuz
parents:
diff changeset
127 <i>Returns:</i> The adjusted pointer to the exception object. (The adjusted
anatofuz
parents:
diff changeset
128 pointer is typically computed by the personality routine during phase 1 and
anatofuz
parents:
diff changeset
129 saved in the exception object.)
anatofuz
parents:
diff changeset
130 </p>
anatofuz
parents:
diff changeset
131 </blockquote>
anatofuz
parents:
diff changeset
132 </td>
anatofuz
parents:
diff changeset
133 <td>&#10003;</td>
anatofuz
parents:
diff changeset
134 <td>&#10003;</td>
anatofuz
parents:
diff changeset
135 <td>&#10003;</td>
anatofuz
parents:
diff changeset
136 </tr>
anatofuz
parents:
diff changeset
137
anatofuz
parents:
diff changeset
138 <tr>
anatofuz
parents:
diff changeset
139 <td>
anatofuz
parents:
diff changeset
140 <p>
anatofuz
parents:
diff changeset
141 <code>void* __cxa_begin_catch(void* exceptionObject) throw();</code>
anatofuz
parents:
diff changeset
142 </p>
anatofuz
parents:
diff changeset
143 <blockquote>
anatofuz
parents:
diff changeset
144 <p>
anatofuz
parents:
diff changeset
145 <i>Effects:</i>
anatofuz
parents:
diff changeset
146 </p>
anatofuz
parents:
diff changeset
147 <ul>
anatofuz
parents:
diff changeset
148 <li>Increment's the exception's handler count.</li>
anatofuz
parents:
diff changeset
149 <li>Places the exception on the stack of currently-caught exceptions if it is
anatofuz
parents:
diff changeset
150 not already there, linking the exception to the previous top of the stack.</li>
anatofuz
parents:
diff changeset
151 <li>Decrements the uncaught_exception count.</li>
anatofuz
parents:
diff changeset
152 </ul>
anatofuz
parents:
diff changeset
153 <p>
anatofuz
parents:
diff changeset
154 If the initialization of the catch parameter is trivial (e,g., there is no
anatofuz
parents:
diff changeset
155 formal catch parameter, or the parameter has no copy constructor), the calls to
anatofuz
parents:
diff changeset
156 <tt>__cxa_get_exception_ptr()</tt> and <tt>__cxa_begin_catch()</tt> may be
anatofuz
parents:
diff changeset
157 combined into a single call to <tt>__cxa_begin_catch()</tt>.
anatofuz
parents:
diff changeset
158 </p>
anatofuz
parents:
diff changeset
159 <p>
anatofuz
parents:
diff changeset
160 When the personality routine encounters a termination condition, it will call
anatofuz
parents:
diff changeset
161 <tt>__cxa_begin_catch()</tt> to mark the exception as handled and then call
anatofuz
parents:
diff changeset
162 <tt>terminate()</tt>, which shall not return to its caller.
anatofuz
parents:
diff changeset
163 </p>
anatofuz
parents:
diff changeset
164 <p>
anatofuz
parents:
diff changeset
165 <i>Returns:</i> The adjusted pointer to the exception object.
anatofuz
parents:
diff changeset
166 </p>
anatofuz
parents:
diff changeset
167 </blockquote>
anatofuz
parents:
diff changeset
168 </td>
anatofuz
parents:
diff changeset
169 <td>&#10003;</td>
anatofuz
parents:
diff changeset
170 <td>&#10003;</td>
anatofuz
parents:
diff changeset
171 <td>&#10003;</td>
anatofuz
parents:
diff changeset
172 </tr>
anatofuz
parents:
diff changeset
173
anatofuz
parents:
diff changeset
174 <tr>
anatofuz
parents:
diff changeset
175 <td>
anatofuz
parents:
diff changeset
176 <p>
anatofuz
parents:
diff changeset
177 <code>void __cxa_end_catch();</code>
anatofuz
parents:
diff changeset
178 </p>
anatofuz
parents:
diff changeset
179 <blockquote>
anatofuz
parents:
diff changeset
180 <p>
anatofuz
parents:
diff changeset
181 <i>Effects:</i> Locates the most recently caught exception and decrements its
anatofuz
parents:
diff changeset
182 handler count. Removes the exception from the caughtÓexception stack, if the
anatofuz
parents:
diff changeset
183 handler count goes to zero. Destroys the exception if the handler count goes to
anatofuz
parents:
diff changeset
184 zero, and the exception was not re-thrown by throw. Collaboration between
anatofuz
parents:
diff changeset
185 __cxa_rethrow() and __cxa_end_catch() is necessary to handle the last point.
anatofuz
parents:
diff changeset
186 Though implementation-defined, one possibility is for __cxa_rethrow() to set a
anatofuz
parents:
diff changeset
187 flag in the handlerCount member of the exception header to mark an exception
anatofuz
parents:
diff changeset
188 being rethrown.
anatofuz
parents:
diff changeset
189 </p>
anatofuz
parents:
diff changeset
190 </blockquote>
anatofuz
parents:
diff changeset
191 </td>
anatofuz
parents:
diff changeset
192 <td>&#10003;</td>
anatofuz
parents:
diff changeset
193 <td>&#10003;</td>
anatofuz
parents:
diff changeset
194 <td>&#10003;</td>
anatofuz
parents:
diff changeset
195 </tr>
anatofuz
parents:
diff changeset
196
anatofuz
parents:
diff changeset
197 <tr>
anatofuz
parents:
diff changeset
198 <td>
anatofuz
parents:
diff changeset
199 <p>
anatofuz
parents:
diff changeset
200 <code>std::type_info* __cxa_current_exception_type();</code>
anatofuz
parents:
diff changeset
201 </p>
anatofuz
parents:
diff changeset
202 <blockquote>
anatofuz
parents:
diff changeset
203 <p>
anatofuz
parents:
diff changeset
204 <i>Returns:</i> the type of the currently handled exception, or null if there
anatofuz
parents:
diff changeset
205 are no caught exceptions.
anatofuz
parents:
diff changeset
206 </p>
anatofuz
parents:
diff changeset
207 </blockquote>
anatofuz
parents:
diff changeset
208 </td>
anatofuz
parents:
diff changeset
209 <td>&#10003;</td>
anatofuz
parents:
diff changeset
210 <td>&#10003;</td>
anatofuz
parents:
diff changeset
211 <td>&#10003;</td>
anatofuz
parents:
diff changeset
212 </tr>
anatofuz
parents:
diff changeset
213
anatofuz
parents:
diff changeset
214 <tr>
anatofuz
parents:
diff changeset
215 <td>
anatofuz
parents:
diff changeset
216 <p>
anatofuz
parents:
diff changeset
217 <code>void __cxa_rethrow();</code>
anatofuz
parents:
diff changeset
218 </p>
anatofuz
parents:
diff changeset
219 <blockquote>
anatofuz
parents:
diff changeset
220 <p>
anatofuz
parents:
diff changeset
221 <i>Effects:</i> Marks the exception object on top of the caughtExceptions stack
anatofuz
parents:
diff changeset
222 (in an implementation-defined way) as being rethrown. If the caughtExceptions
anatofuz
parents:
diff changeset
223 stack is empty, it calls terminate() (see [C++FDIS] [except.throw], 15.1.8). It
anatofuz
parents:
diff changeset
224 then returns to the handler that called it, which must call __cxa_end_catch(),
anatofuz
parents:
diff changeset
225 perform any necessary cleanup, and finally call _Unwind_Resume() to continue
anatofuz
parents:
diff changeset
226 unwinding.
anatofuz
parents:
diff changeset
227 </p>
anatofuz
parents:
diff changeset
228 </blockquote>
anatofuz
parents:
diff changeset
229 </td>
anatofuz
parents:
diff changeset
230 <td>&#10003;</td>
anatofuz
parents:
diff changeset
231 <td>&#10003;</td>
anatofuz
parents:
diff changeset
232 <td>&#10003;</td>
anatofuz
parents:
diff changeset
233 </tr>
anatofuz
parents:
diff changeset
234
anatofuz
parents:
diff changeset
235 <tr>
anatofuz
parents:
diff changeset
236 <td>
anatofuz
parents:
diff changeset
237 <p>
anatofuz
parents:
diff changeset
238 <code>void* __cxa_current_primary_exception() throw();</code>
anatofuz
parents:
diff changeset
239 </p>
anatofuz
parents:
diff changeset
240 <blockquote>
anatofuz
parents:
diff changeset
241 <p>
anatofuz
parents:
diff changeset
242 <i>Effects:</i> Increments the ownership count of the currently handled
anatofuz
parents:
diff changeset
243 exception (if any) by one.
anatofuz
parents:
diff changeset
244 </p>
anatofuz
parents:
diff changeset
245 <p>
anatofuz
parents:
diff changeset
246 <i>Returns:</i> the type of the currently handled exception, or null if there
anatofuz
parents:
diff changeset
247 are no caught exceptions.
anatofuz
parents:
diff changeset
248 </p>
anatofuz
parents:
diff changeset
249 </blockquote>
anatofuz
parents:
diff changeset
250 </td>
anatofuz
parents:
diff changeset
251 <td>&#10003;</td>
anatofuz
parents:
diff changeset
252 <td>&#10003;</td>
anatofuz
parents:
diff changeset
253 <td>&#10003;</td>
anatofuz
parents:
diff changeset
254 </tr>
anatofuz
parents:
diff changeset
255
anatofuz
parents:
diff changeset
256 <tr>
anatofuz
parents:
diff changeset
257 <td>
anatofuz
parents:
diff changeset
258 <p>
anatofuz
parents:
diff changeset
259 <code>void __cxa_decrement_exception_refcount(void* primary_exception) throw();</code>
anatofuz
parents:
diff changeset
260 </p>
anatofuz
parents:
diff changeset
261 <blockquote>
anatofuz
parents:
diff changeset
262 <p>
anatofuz
parents:
diff changeset
263 <i>Effects:</i> Decrements the ownership count of the exception by 1, and on
anatofuz
parents:
diff changeset
264 zero calls <tt>_Unwind_DeleteException</tt> with the exception object.
anatofuz
parents:
diff changeset
265 </p>
anatofuz
parents:
diff changeset
266 </blockquote>
anatofuz
parents:
diff changeset
267 </td>
anatofuz
parents:
diff changeset
268 <td>&#10003;</td>
anatofuz
parents:
diff changeset
269 <td>&#10003;</td>
anatofuz
parents:
diff changeset
270 <td>&#10003;</td>
anatofuz
parents:
diff changeset
271 </tr>
anatofuz
parents:
diff changeset
272
anatofuz
parents:
diff changeset
273 <tr>
anatofuz
parents:
diff changeset
274 <td>
anatofuz
parents:
diff changeset
275 <p>
anatofuz
parents:
diff changeset
276 <code>__cxa_eh_globals* __cxa_get_globals() throw();</code>
anatofuz
parents:
diff changeset
277 </p>
anatofuz
parents:
diff changeset
278 <blockquote>
anatofuz
parents:
diff changeset
279 <p>
anatofuz
parents:
diff changeset
280 <i>Returns:</i> A pointer to the __cxa_eh_globals structure for the current
anatofuz
parents:
diff changeset
281 thread, initializing it if necessary.
anatofuz
parents:
diff changeset
282 </p>
anatofuz
parents:
diff changeset
283 </blockquote>
anatofuz
parents:
diff changeset
284 </td>
anatofuz
parents:
diff changeset
285 <td>&#10003;</td>
anatofuz
parents:
diff changeset
286 <td>&#10003;</td>
anatofuz
parents:
diff changeset
287 <td>&#10003;</td>
anatofuz
parents:
diff changeset
288 </tr>
anatofuz
parents:
diff changeset
289
anatofuz
parents:
diff changeset
290 <tr>
anatofuz
parents:
diff changeset
291 <td>
anatofuz
parents:
diff changeset
292 <p>
anatofuz
parents:
diff changeset
293 <code>__cxa_eh_globals* __cxa_get_globals_fast() throw();</code>
anatofuz
parents:
diff changeset
294 </p>
anatofuz
parents:
diff changeset
295 <blockquote>
anatofuz
parents:
diff changeset
296 <p>
anatofuz
parents:
diff changeset
297 <i>Requires:</i> At least one prior call to __cxa_get_globals has been made from
anatofuz
parents:
diff changeset
298 the current thread.
anatofuz
parents:
diff changeset
299 </p>
anatofuz
parents:
diff changeset
300 <p>
anatofuz
parents:
diff changeset
301 <i>Returns:</i> A pointer to the __cxa_eh_globals structure for the current
anatofuz
parents:
diff changeset
302 thread.
anatofuz
parents:
diff changeset
303 </p>
anatofuz
parents:
diff changeset
304 </blockquote>
anatofuz
parents:
diff changeset
305 </td>
anatofuz
parents:
diff changeset
306 <td>&#10003;</td>
anatofuz
parents:
diff changeset
307 <td>&#10003;</td>
anatofuz
parents:
diff changeset
308 <td>&#10003;</td>
anatofuz
parents:
diff changeset
309 </tr>
anatofuz
parents:
diff changeset
310
anatofuz
parents:
diff changeset
311 <tr>
anatofuz
parents:
diff changeset
312 <td>
anatofuz
parents:
diff changeset
313 <p>
anatofuz
parents:
diff changeset
314 <code>void __cxa_increment_exception_refcount(void* primary_exception) throw();</code>
anatofuz
parents:
diff changeset
315 </p>
anatofuz
parents:
diff changeset
316 <blockquote>
anatofuz
parents:
diff changeset
317 <p>
anatofuz
parents:
diff changeset
318 <i>Effects:</i> Increments the ownership count of the referenced exception.
anatofuz
parents:
diff changeset
319 </p>
anatofuz
parents:
diff changeset
320 </blockquote>
anatofuz
parents:
diff changeset
321 </td>
anatofuz
parents:
diff changeset
322 <td>&#10003;</td>
anatofuz
parents:
diff changeset
323 <td>&#10003;</td>
anatofuz
parents:
diff changeset
324 <td>&#10003;</td>
anatofuz
parents:
diff changeset
325 </tr>
anatofuz
parents:
diff changeset
326
anatofuz
parents:
diff changeset
327 <tr>
anatofuz
parents:
diff changeset
328 <td>
anatofuz
parents:
diff changeset
329 <p>
anatofuz
parents:
diff changeset
330 <code>void __cxa_rethrow_primary_exception(void* primary_exception);</code>
anatofuz
parents:
diff changeset
331 </p>
anatofuz
parents:
diff changeset
332 <blockquote>
anatofuz
parents:
diff changeset
333 <p>
anatofuz
parents:
diff changeset
334 <i>Effects:</i> Implements <tt>std::rethrow_exception(exception_ptr p)</tt>.
anatofuz
parents:
diff changeset
335 </p>
anatofuz
parents:
diff changeset
336 </blockquote>
anatofuz
parents:
diff changeset
337 </td>
anatofuz
parents:
diff changeset
338 <td>&#10003;</td>
anatofuz
parents:
diff changeset
339 <td>&#10003;</td>
anatofuz
parents:
diff changeset
340 <td>&#10003;</td>
anatofuz
parents:
diff changeset
341 </tr>
anatofuz
parents:
diff changeset
342
anatofuz
parents:
diff changeset
343 <tr>
anatofuz
parents:
diff changeset
344 <td>
anatofuz
parents:
diff changeset
345 <p>
anatofuz
parents:
diff changeset
346 <code>bool __cxa_uncaught_exception() throw();</code>
anatofuz
parents:
diff changeset
347 </p>
anatofuz
parents:
diff changeset
348 <blockquote>
anatofuz
parents:
diff changeset
349 <p>
anatofuz
parents:
diff changeset
350 <i>Effects:</i>
anatofuz
parents:
diff changeset
351 </p>
anatofuz
parents:
diff changeset
352 <p>
anatofuz
parents:
diff changeset
353 <i>Returns:</i>
anatofuz
parents:
diff changeset
354 </p>
anatofuz
parents:
diff changeset
355 </blockquote>
anatofuz
parents:
diff changeset
356 </td>
anatofuz
parents:
diff changeset
357 <td>&#10003;</td>
anatofuz
parents:
diff changeset
358 <td>&#10003;</td>
anatofuz
parents:
diff changeset
359 <td>&#10003;</td>
anatofuz
parents:
diff changeset
360 </tr>
anatofuz
parents:
diff changeset
361
anatofuz
parents:
diff changeset
362 <tr>
anatofuz
parents:
diff changeset
363 <td>
anatofuz
parents:
diff changeset
364 <p>
anatofuz
parents:
diff changeset
365 <code>_Unwind_Reason_Code __gxx_personality_v0
anatofuz
parents:
diff changeset
366 (int, _Unwind_Action, _Unwind_Exception_Class,
anatofuz
parents:
diff changeset
367 struct _Unwind_Exception *, struct _Unwind_Context *);</code>
anatofuz
parents:
diff changeset
368 </p>
anatofuz
parents:
diff changeset
369 <blockquote>
anatofuz
parents:
diff changeset
370 <p>
anatofuz
parents:
diff changeset
371 <i>Effects:</i>
anatofuz
parents:
diff changeset
372 </p>
anatofuz
parents:
diff changeset
373 <p>
anatofuz
parents:
diff changeset
374 <i>Returns:</i>
anatofuz
parents:
diff changeset
375 </p>
anatofuz
parents:
diff changeset
376 </blockquote>
anatofuz
parents:
diff changeset
377 </td>
anatofuz
parents:
diff changeset
378 <td>&#10003;</td>
anatofuz
parents:
diff changeset
379 <td>&#10003;</td>
anatofuz
parents:
diff changeset
380 <td>&#10003;</td>
anatofuz
parents:
diff changeset
381 </tr>
anatofuz
parents:
diff changeset
382
anatofuz
parents:
diff changeset
383 <tr>
anatofuz
parents:
diff changeset
384 <td colspan=4 align="center">Guard objects</td>
anatofuz
parents:
diff changeset
385 </tr>
anatofuz
parents:
diff changeset
386
anatofuz
parents:
diff changeset
387 <tr>
anatofuz
parents:
diff changeset
388 <td>
anatofuz
parents:
diff changeset
389 <p>
anatofuz
parents:
diff changeset
390 <code>int __cxa_guard_acquire(uint64_t* guard_object);</code>
anatofuz
parents:
diff changeset
391 </p>
anatofuz
parents:
diff changeset
392 <blockquote>
anatofuz
parents:
diff changeset
393 <p>
anatofuz
parents:
diff changeset
394 <i>Effects:</i> This function is called before initialization takes place. If
anatofuz
parents:
diff changeset
395 this function returns 1, either <code>__cxa_guard_release</code> or
anatofuz
parents:
diff changeset
396 <code>__cxa_guard_abort</code> must be called with the same argument. The first
anatofuz
parents:
diff changeset
397 byte of the <code>guard_object</code> is not modified by this function.
anatofuz
parents:
diff changeset
398 </p>
anatofuz
parents:
diff changeset
399 <p>
anatofuz
parents:
diff changeset
400 On Darwin the implementation checks for deadlock.
anatofuz
parents:
diff changeset
401 </p>
anatofuz
parents:
diff changeset
402 <p>
anatofuz
parents:
diff changeset
403 <i>Returns:</i> 1 if the initialization is not yet complete, otherwise 0.
anatofuz
parents:
diff changeset
404 </p>
anatofuz
parents:
diff changeset
405 </blockquote>
anatofuz
parents:
diff changeset
406 </td>
anatofuz
parents:
diff changeset
407 <td>&#10003;</td>
anatofuz
parents:
diff changeset
408 <td>&#10003;</td>
anatofuz
parents:
diff changeset
409 <td>&#10003;</td>
anatofuz
parents:
diff changeset
410 </tr>
anatofuz
parents:
diff changeset
411
anatofuz
parents:
diff changeset
412 <tr>
anatofuz
parents:
diff changeset
413 <td>
anatofuz
parents:
diff changeset
414 <p>
anatofuz
parents:
diff changeset
415 <code>void __cxa_guard_release(uint64_t*);</code>
anatofuz
parents:
diff changeset
416 </p>
anatofuz
parents:
diff changeset
417 <blockquote>
anatofuz
parents:
diff changeset
418 <p>
anatofuz
parents:
diff changeset
419 <i>Effects:</i> Sets the first byte of the guard object to a non-zero value.
anatofuz
parents:
diff changeset
420 This function is called after initialization is complete. A thread-safe
anatofuz
parents:
diff changeset
421 implementation will release the mutex acquired by __cxa_guard_acquire after
anatofuz
parents:
diff changeset
422 setting the first byte of the guard object.
anatofuz
parents:
diff changeset
423 </p>
anatofuz
parents:
diff changeset
424 </blockquote>
anatofuz
parents:
diff changeset
425 </td>
anatofuz
parents:
diff changeset
426 <td>&#10003;</td>
anatofuz
parents:
diff changeset
427 <td>&#10003;</td>
anatofuz
parents:
diff changeset
428 <td>&#10003;</td>
anatofuz
parents:
diff changeset
429 </tr>
anatofuz
parents:
diff changeset
430
anatofuz
parents:
diff changeset
431 <tr>
anatofuz
parents:
diff changeset
432 <td>
anatofuz
parents:
diff changeset
433 <p>
anatofuz
parents:
diff changeset
434 <code>void __cxa_guard_abort(uint64_t*);</code>
anatofuz
parents:
diff changeset
435 </p>
anatofuz
parents:
diff changeset
436 <blockquote>
anatofuz
parents:
diff changeset
437 <p>
anatofuz
parents:
diff changeset
438 <i>Effects:</i> This function is called if the initialization terminates by
anatofuz
parents:
diff changeset
439 throwing an exception.
anatofuz
parents:
diff changeset
440 </p>
anatofuz
parents:
diff changeset
441 </blockquote>
anatofuz
parents:
diff changeset
442 </td>
anatofuz
parents:
diff changeset
443 <td>&#10003;</td>
anatofuz
parents:
diff changeset
444 <td>&#10003;</td>
anatofuz
parents:
diff changeset
445 <td>&#10003;</td>
anatofuz
parents:
diff changeset
446 </tr>
anatofuz
parents:
diff changeset
447
anatofuz
parents:
diff changeset
448 <tr>
anatofuz
parents:
diff changeset
449 <td colspan=4 align="center">Vector construction and destruction</td>
anatofuz
parents:
diff changeset
450 </tr>
anatofuz
parents:
diff changeset
451
anatofuz
parents:
diff changeset
452 <tr>
anatofuz
parents:
diff changeset
453 <td>
anatofuz
parents:
diff changeset
454 <p>
anatofuz
parents:
diff changeset
455 <code>void* __cxa_vec_new(size_t element_count,
anatofuz
parents:
diff changeset
456 size_t element_size,
anatofuz
parents:
diff changeset
457 size_t padding_size,
anatofuz
parents:
diff changeset
458 void (*constructor)(void*),
anatofuz
parents:
diff changeset
459 void (*destructor)(void*) );</code>
anatofuz
parents:
diff changeset
460 </p>
anatofuz
parents:
diff changeset
461 <blockquote>
anatofuz
parents:
diff changeset
462 <p>
anatofuz
parents:
diff changeset
463 <i>Effects:</i>
anatofuz
parents:
diff changeset
464 </p>
anatofuz
parents:
diff changeset
465 <p>
anatofuz
parents:
diff changeset
466 <i>Returns:</i>
anatofuz
parents:
diff changeset
467 </p>
anatofuz
parents:
diff changeset
468 </blockquote>
anatofuz
parents:
diff changeset
469 </td>
anatofuz
parents:
diff changeset
470 <td>&#10003;</td>
anatofuz
parents:
diff changeset
471 <td>&#10003;</td>
anatofuz
parents:
diff changeset
472 <td>&#10003;</td>
anatofuz
parents:
diff changeset
473 </tr>
anatofuz
parents:
diff changeset
474
anatofuz
parents:
diff changeset
475 <tr>
anatofuz
parents:
diff changeset
476 <td>
anatofuz
parents:
diff changeset
477 <p>
anatofuz
parents:
diff changeset
478 <code>void* __cxa_vec_new2(size_t element_count,
anatofuz
parents:
diff changeset
479 size_t element_size,
anatofuz
parents:
diff changeset
480 size_t padding_size,
anatofuz
parents:
diff changeset
481 void (*constructor)(void*),
anatofuz
parents:
diff changeset
482 void (*destructor)(void*),
anatofuz
parents:
diff changeset
483 void* (*alloc)(size_t),
anatofuz
parents:
diff changeset
484 void (*dealloc)(void*) );</code>
anatofuz
parents:
diff changeset
485 </p>
anatofuz
parents:
diff changeset
486 <blockquote>
anatofuz
parents:
diff changeset
487 <p>
anatofuz
parents:
diff changeset
488 <i>Effects:</i>
anatofuz
parents:
diff changeset
489 </p>
anatofuz
parents:
diff changeset
490 <p>
anatofuz
parents:
diff changeset
491 <i>Returns:</i>
anatofuz
parents:
diff changeset
492 </p>
anatofuz
parents:
diff changeset
493 </blockquote>
anatofuz
parents:
diff changeset
494 </td>
anatofuz
parents:
diff changeset
495 <td>&#10003;</td>
anatofuz
parents:
diff changeset
496 <td>&#10003;</td>
anatofuz
parents:
diff changeset
497 <td>&#10003;</td>
anatofuz
parents:
diff changeset
498 </tr>
anatofuz
parents:
diff changeset
499
anatofuz
parents:
diff changeset
500 <tr>
anatofuz
parents:
diff changeset
501 <td>
anatofuz
parents:
diff changeset
502 <p>
anatofuz
parents:
diff changeset
503 <code>void* __cxa_vec_new3(size_t element_count,
anatofuz
parents:
diff changeset
504 size_t element_size,
anatofuz
parents:
diff changeset
505 size_t padding_size,
anatofuz
parents:
diff changeset
506 void (*constructor)(void*),
anatofuz
parents:
diff changeset
507 void (*destructor)(void*),
anatofuz
parents:
diff changeset
508 void* (*alloc)(size_t),
anatofuz
parents:
diff changeset
509 void (*dealloc)(void*, size_t) );</code>
anatofuz
parents:
diff changeset
510 </p>
anatofuz
parents:
diff changeset
511 <blockquote>
anatofuz
parents:
diff changeset
512 <p>
anatofuz
parents:
diff changeset
513 <i>Effects:</i>
anatofuz
parents:
diff changeset
514 </p>
anatofuz
parents:
diff changeset
515 <p>
anatofuz
parents:
diff changeset
516 <i>Returns:</i>
anatofuz
parents:
diff changeset
517 </p>
anatofuz
parents:
diff changeset
518 </blockquote>
anatofuz
parents:
diff changeset
519 </td>
anatofuz
parents:
diff changeset
520 <td>&#10003;</td>
anatofuz
parents:
diff changeset
521 <td>&#10003;</td>
anatofuz
parents:
diff changeset
522 <td>&#10003;</td>
anatofuz
parents:
diff changeset
523 </tr>
anatofuz
parents:
diff changeset
524
anatofuz
parents:
diff changeset
525 <tr>
anatofuz
parents:
diff changeset
526 <td>
anatofuz
parents:
diff changeset
527 <p>
anatofuz
parents:
diff changeset
528 <code>void __cxa_vec_ctor(void* array_address,
anatofuz
parents:
diff changeset
529 size_t element_count,
anatofuz
parents:
diff changeset
530 size_t element_size,
anatofuz
parents:
diff changeset
531 void (*constructor)(void*),
anatofuz
parents:
diff changeset
532 void (*destructor)(void*) );</code>
anatofuz
parents:
diff changeset
533 </p>
anatofuz
parents:
diff changeset
534 <blockquote>
anatofuz
parents:
diff changeset
535 <p>
anatofuz
parents:
diff changeset
536 <i>Effects:</i>
anatofuz
parents:
diff changeset
537 </p>
anatofuz
parents:
diff changeset
538 </blockquote>
anatofuz
parents:
diff changeset
539 </td>
anatofuz
parents:
diff changeset
540 <td>&#10003;</td>
anatofuz
parents:
diff changeset
541 <td>&#10003;</td>
anatofuz
parents:
diff changeset
542 <td>&#10003;</td>
anatofuz
parents:
diff changeset
543 </tr>
anatofuz
parents:
diff changeset
544
anatofuz
parents:
diff changeset
545 <tr>
anatofuz
parents:
diff changeset
546 <td>
anatofuz
parents:
diff changeset
547 <p>
anatofuz
parents:
diff changeset
548 <code>void __cxa_vec_dtor(void* array_address,
anatofuz
parents:
diff changeset
549 size_t element_count,
anatofuz
parents:
diff changeset
550 size_t element_size,
anatofuz
parents:
diff changeset
551 void (*destructor)(void*) );</code>
anatofuz
parents:
diff changeset
552 </p>
anatofuz
parents:
diff changeset
553 <blockquote>
anatofuz
parents:
diff changeset
554 <p>
anatofuz
parents:
diff changeset
555 <i>Effects:</i>
anatofuz
parents:
diff changeset
556 </p>
anatofuz
parents:
diff changeset
557 </blockquote>
anatofuz
parents:
diff changeset
558 </td>
anatofuz
parents:
diff changeset
559 <td>&#10003;</td>
anatofuz
parents:
diff changeset
560 <td>&#10003;</td>
anatofuz
parents:
diff changeset
561 <td>&#10003;</td>
anatofuz
parents:
diff changeset
562 </tr>
anatofuz
parents:
diff changeset
563
anatofuz
parents:
diff changeset
564 <tr>
anatofuz
parents:
diff changeset
565 <td>
anatofuz
parents:
diff changeset
566 <p>
anatofuz
parents:
diff changeset
567 <code>void __cxa_vec_cleanup(void* array_address,
anatofuz
parents:
diff changeset
568 size_t element_count,
anatofuz
parents:
diff changeset
569 size_t element_size,
anatofuz
parents:
diff changeset
570 void (*destructor)(void*) );</code>
anatofuz
parents:
diff changeset
571 </p>
anatofuz
parents:
diff changeset
572 <blockquote>
anatofuz
parents:
diff changeset
573 <p>
anatofuz
parents:
diff changeset
574 <i>Effects:</i>
anatofuz
parents:
diff changeset
575 </p>
anatofuz
parents:
diff changeset
576 </blockquote>
anatofuz
parents:
diff changeset
577 </td>
anatofuz
parents:
diff changeset
578 <td>&#10003;</td>
anatofuz
parents:
diff changeset
579 <td>&#10003;</td>
anatofuz
parents:
diff changeset
580 <td>&#10003;</td>
anatofuz
parents:
diff changeset
581 </tr>
anatofuz
parents:
diff changeset
582
anatofuz
parents:
diff changeset
583 <tr>
anatofuz
parents:
diff changeset
584 <td>
anatofuz
parents:
diff changeset
585 <p>
anatofuz
parents:
diff changeset
586 <code>void __cxa_vec_delete(void* array_address,
anatofuz
parents:
diff changeset
587 size_t element_size,
anatofuz
parents:
diff changeset
588 size_t padding_size,
anatofuz
parents:
diff changeset
589 void (*destructor)(void*) );</code>
anatofuz
parents:
diff changeset
590 </p>
anatofuz
parents:
diff changeset
591 <blockquote>
anatofuz
parents:
diff changeset
592 <p>
anatofuz
parents:
diff changeset
593 <i>Effects:</i>
anatofuz
parents:
diff changeset
594 </p>
anatofuz
parents:
diff changeset
595 </blockquote>
anatofuz
parents:
diff changeset
596 </td>
anatofuz
parents:
diff changeset
597 <td>&#10003;</td>
anatofuz
parents:
diff changeset
598 <td>&#10003;</td>
anatofuz
parents:
diff changeset
599 <td>&#10003;</td>
anatofuz
parents:
diff changeset
600 </tr>
anatofuz
parents:
diff changeset
601
anatofuz
parents:
diff changeset
602 <tr>
anatofuz
parents:
diff changeset
603 <td>
anatofuz
parents:
diff changeset
604 <p>
anatofuz
parents:
diff changeset
605 <code>void __cxa_vec_delete2(void* array_address,
anatofuz
parents:
diff changeset
606 size_t element_size,
anatofuz
parents:
diff changeset
607 size_t padding_size,
anatofuz
parents:
diff changeset
608 void (*destructor)(void*),
anatofuz
parents:
diff changeset
609 void (*dealloc)(void*) );</code>
anatofuz
parents:
diff changeset
610 </p>
anatofuz
parents:
diff changeset
611 <blockquote>
anatofuz
parents:
diff changeset
612 <p>
anatofuz
parents:
diff changeset
613 <i>Effects:</i>
anatofuz
parents:
diff changeset
614 </p>
anatofuz
parents:
diff changeset
615 </blockquote>
anatofuz
parents:
diff changeset
616 </td>
anatofuz
parents:
diff changeset
617 <td>&#10003;</td>
anatofuz
parents:
diff changeset
618 <td>&#10003;</td>
anatofuz
parents:
diff changeset
619 <td>&#10003;</td>
anatofuz
parents:
diff changeset
620 </tr>
anatofuz
parents:
diff changeset
621
anatofuz
parents:
diff changeset
622 <tr>
anatofuz
parents:
diff changeset
623 <td>
anatofuz
parents:
diff changeset
624 <p>
anatofuz
parents:
diff changeset
625 <code>void __cxa_vec_delete3(void* __array_address,
anatofuz
parents:
diff changeset
626 size_t element_size,
anatofuz
parents:
diff changeset
627 size_t padding_size,
anatofuz
parents:
diff changeset
628 void (*destructor)(void*),
anatofuz
parents:
diff changeset
629 void (*dealloc) (void*, size_t));</code>
anatofuz
parents:
diff changeset
630 </p>
anatofuz
parents:
diff changeset
631 <blockquote>
anatofuz
parents:
diff changeset
632 <p>
anatofuz
parents:
diff changeset
633 <i>Effects:</i>
anatofuz
parents:
diff changeset
634 </p>
anatofuz
parents:
diff changeset
635 </blockquote>
anatofuz
parents:
diff changeset
636 </td>
anatofuz
parents:
diff changeset
637 <td>&#10003;</td>
anatofuz
parents:
diff changeset
638 <td>&#10003;</td>
anatofuz
parents:
diff changeset
639 <td>&#10003;</td>
anatofuz
parents:
diff changeset
640 </tr>
anatofuz
parents:
diff changeset
641
anatofuz
parents:
diff changeset
642 <tr>
anatofuz
parents:
diff changeset
643 <td>
anatofuz
parents:
diff changeset
644 <p>
anatofuz
parents:
diff changeset
645 <code>void __cxa_vec_cctor(void* dest_array,
anatofuz
parents:
diff changeset
646 void* src_array,
anatofuz
parents:
diff changeset
647 size_t element_count,
anatofuz
parents:
diff changeset
648 size_t element_size,
anatofuz
parents:
diff changeset
649 void (*constructor) (void*, void*),
anatofuz
parents:
diff changeset
650 void (*destructor)(void*) );</code>
anatofuz
parents:
diff changeset
651 </p>
anatofuz
parents:
diff changeset
652 <blockquote>
anatofuz
parents:
diff changeset
653 <p>
anatofuz
parents:
diff changeset
654 <i>Effects:</i>
anatofuz
parents:
diff changeset
655 </p>
anatofuz
parents:
diff changeset
656 </blockquote>
anatofuz
parents:
diff changeset
657 </td>
anatofuz
parents:
diff changeset
658 <td>&#10003;</td>
anatofuz
parents:
diff changeset
659 <td>&#10003;</td>
anatofuz
parents:
diff changeset
660 <td>&#10003;</td>
anatofuz
parents:
diff changeset
661 </tr>
anatofuz
parents:
diff changeset
662
anatofuz
parents:
diff changeset
663 <tr>
anatofuz
parents:
diff changeset
664 <td colspan=4 align="center">Handlers</td>
anatofuz
parents:
diff changeset
665 </tr>
anatofuz
parents:
diff changeset
666
anatofuz
parents:
diff changeset
667 <tr>
anatofuz
parents:
diff changeset
668 <td>
anatofuz
parents:
diff changeset
669 <p>
anatofuz
parents:
diff changeset
670 <code>void (*__cxa_new_handler)();</code>
anatofuz
parents:
diff changeset
671 </p>
anatofuz
parents:
diff changeset
672 <blockquote>
anatofuz
parents:
diff changeset
673 <p>
anatofuz
parents:
diff changeset
674 The currently installed new handler.
anatofuz
parents:
diff changeset
675 </p>
anatofuz
parents:
diff changeset
676 </blockquote>
anatofuz
parents:
diff changeset
677 </td>
anatofuz
parents:
diff changeset
678 <td>&#10003;</td>
anatofuz
parents:
diff changeset
679 <td>&#10003;</td>
anatofuz
parents:
diff changeset
680 <td>&#10003;</td>
anatofuz
parents:
diff changeset
681 </tr>
anatofuz
parents:
diff changeset
682
anatofuz
parents:
diff changeset
683 <tr>
anatofuz
parents:
diff changeset
684 <td>
anatofuz
parents:
diff changeset
685 <p>
anatofuz
parents:
diff changeset
686 <code>void (*__cxa_terminate_handler)();</code>
anatofuz
parents:
diff changeset
687 </p>
anatofuz
parents:
diff changeset
688 <blockquote>
anatofuz
parents:
diff changeset
689 <p>
anatofuz
parents:
diff changeset
690 The currently installed terminate handler.
anatofuz
parents:
diff changeset
691 </p>
anatofuz
parents:
diff changeset
692 </blockquote>
anatofuz
parents:
diff changeset
693 </td>
anatofuz
parents:
diff changeset
694 <td>&#10003;</td>
anatofuz
parents:
diff changeset
695 <td>&#10003;</td>
anatofuz
parents:
diff changeset
696 <td>&#10003;</td>
anatofuz
parents:
diff changeset
697 </tr>
anatofuz
parents:
diff changeset
698
anatofuz
parents:
diff changeset
699 <tr>
anatofuz
parents:
diff changeset
700 <td>
anatofuz
parents:
diff changeset
701 <p>
anatofuz
parents:
diff changeset
702 <code>void (*__cxa_unexpected_handler)();</code>
anatofuz
parents:
diff changeset
703 </p>
anatofuz
parents:
diff changeset
704 <blockquote>
anatofuz
parents:
diff changeset
705 <p>
anatofuz
parents:
diff changeset
706 <i>Effects:</i>
anatofuz
parents:
diff changeset
707 </p>
anatofuz
parents:
diff changeset
708 </blockquote>
anatofuz
parents:
diff changeset
709 </td>
anatofuz
parents:
diff changeset
710 <td>&#10003;</td>
anatofuz
parents:
diff changeset
711 <td>&#10003;</td>
anatofuz
parents:
diff changeset
712 <td>&#10003;</td>
anatofuz
parents:
diff changeset
713 </tr>
anatofuz
parents:
diff changeset
714
anatofuz
parents:
diff changeset
715
anatofuz
parents:
diff changeset
716
anatofuz
parents:
diff changeset
717 <tr>
anatofuz
parents:
diff changeset
718 <td colspan=4 align="center">Utilities</td>
anatofuz
parents:
diff changeset
719 </tr>
anatofuz
parents:
diff changeset
720
anatofuz
parents:
diff changeset
721 <tr>
anatofuz
parents:
diff changeset
722 <td>
anatofuz
parents:
diff changeset
723 <p>
anatofuz
parents:
diff changeset
724 <code>[[noreturn]] void __cxa_bad_cast()</code>
anatofuz
parents:
diff changeset
725 </p>
anatofuz
parents:
diff changeset
726 <blockquote>
anatofuz
parents:
diff changeset
727 <p>
anatofuz
parents:
diff changeset
728 <i>Effects:</i> Throws an exception of type <tt>bad_cast</tt>.
anatofuz
parents:
diff changeset
729 </p>
anatofuz
parents:
diff changeset
730 </blockquote>
anatofuz
parents:
diff changeset
731 </td>
anatofuz
parents:
diff changeset
732 <td>&#10003;</td>
anatofuz
parents:
diff changeset
733 <td>&#10003;</td>
anatofuz
parents:
diff changeset
734 <td>&#10003;</td>
anatofuz
parents:
diff changeset
735 </tr>
anatofuz
parents:
diff changeset
736
anatofuz
parents:
diff changeset
737 <tr>
anatofuz
parents:
diff changeset
738 <td>
anatofuz
parents:
diff changeset
739 <p>
anatofuz
parents:
diff changeset
740 <code>[[noreturn]] void __cxa_bad_typeid();</code>
anatofuz
parents:
diff changeset
741 </p>
anatofuz
parents:
diff changeset
742 <blockquote>
anatofuz
parents:
diff changeset
743 <p>
anatofuz
parents:
diff changeset
744 <i>Effects:</i> Throws an exception of type <tt>bad_typeid</tt>.
anatofuz
parents:
diff changeset
745 </p>
anatofuz
parents:
diff changeset
746 </blockquote>
anatofuz
parents:
diff changeset
747 </td>
anatofuz
parents:
diff changeset
748 <td>&#10003;</td>
anatofuz
parents:
diff changeset
749 <td>&#10003;</td>
anatofuz
parents:
diff changeset
750 <td>&#10003;</td>
anatofuz
parents:
diff changeset
751 </tr>
anatofuz
parents:
diff changeset
752
anatofuz
parents:
diff changeset
753 <tr>
anatofuz
parents:
diff changeset
754 <td>
anatofuz
parents:
diff changeset
755 <p>
anatofuz
parents:
diff changeset
756 <code>void __cxa_pure_virtual(void);</code>
anatofuz
parents:
diff changeset
757 </p>
anatofuz
parents:
diff changeset
758 <blockquote>
anatofuz
parents:
diff changeset
759 <p>
anatofuz
parents:
diff changeset
760 <i>Effects:</i> Called if the user calls a non-overridden pure virtual function,
anatofuz
parents:
diff changeset
761 which has undefined behavior according to the C++ Standard. Ends the program.
anatofuz
parents:
diff changeset
762 </p>
anatofuz
parents:
diff changeset
763 </blockquote>
anatofuz
parents:
diff changeset
764 </td>
anatofuz
parents:
diff changeset
765 <td>&#10003;</td>
anatofuz
parents:
diff changeset
766 <td>&#10003;</td>
anatofuz
parents:
diff changeset
767 <td>&#10003;</td>
anatofuz
parents:
diff changeset
768 </tr>
anatofuz
parents:
diff changeset
769
anatofuz
parents:
diff changeset
770 <tr>
anatofuz
parents:
diff changeset
771 <td>
anatofuz
parents:
diff changeset
772 <p>
anatofuz
parents:
diff changeset
773 <code>void __cxa_call_unexpected (void*) __attribute__((noreturn));</code>
anatofuz
parents:
diff changeset
774 </p>
anatofuz
parents:
diff changeset
775 <blockquote>
anatofuz
parents:
diff changeset
776 <p>
anatofuz
parents:
diff changeset
777 <i>Effects:</i> Handles re-checking the exception specification if
anatofuz
parents:
diff changeset
778 unexpectedHandler throws, and if <tt>bad_exception</tt> needs to be thrown.
anatofuz
parents:
diff changeset
779 Called from the compiler.
anatofuz
parents:
diff changeset
780 </p>
anatofuz
parents:
diff changeset
781 </blockquote>
anatofuz
parents:
diff changeset
782 </td>
anatofuz
parents:
diff changeset
783 <td>&#10003;</td>
anatofuz
parents:
diff changeset
784 <td>&#10003;</td>
anatofuz
parents:
diff changeset
785 <td>&#10003;</td>
anatofuz
parents:
diff changeset
786 </tr>
anatofuz
parents:
diff changeset
787
anatofuz
parents:
diff changeset
788 <tr>
anatofuz
parents:
diff changeset
789 <td>
anatofuz
parents:
diff changeset
790 <p>
anatofuz
parents:
diff changeset
791 <code>char* __cxa_demangle(const char* mangled_name,
anatofuz
parents:
diff changeset
792 char* output_buffer,
anatofuz
parents:
diff changeset
793 size_t* length,
anatofuz
parents:
diff changeset
794 int* status);</code>
anatofuz
parents:
diff changeset
795 </p>
anatofuz
parents:
diff changeset
796 <blockquote>
anatofuz
parents:
diff changeset
797 <p>
anatofuz
parents:
diff changeset
798 <i>Effects:</i>
anatofuz
parents:
diff changeset
799 </p>
anatofuz
parents:
diff changeset
800 <p>
anatofuz
parents:
diff changeset
801 <i>Returns:</i>
anatofuz
parents:
diff changeset
802 </p>
anatofuz
parents:
diff changeset
803 </blockquote>
anatofuz
parents:
diff changeset
804 </td>
anatofuz
parents:
diff changeset
805 <td>&#10003;</td>
anatofuz
parents:
diff changeset
806 <td>&#10003;</td>
anatofuz
parents:
diff changeset
807 <td>&#10003;</td>
anatofuz
parents:
diff changeset
808 </tr>
anatofuz
parents:
diff changeset
809
anatofuz
parents:
diff changeset
810 <tr>
anatofuz
parents:
diff changeset
811 <td>
anatofuz
parents:
diff changeset
812 <p>
anatofuz
parents:
diff changeset
813 <code>void*
anatofuz
parents:
diff changeset
814 __dynamic_cast(const void* __src_ptr,
anatofuz
parents:
diff changeset
815 const __class_type_info* __src_type,
anatofuz
parents:
diff changeset
816 const __class_type_info* __dst_type,
anatofuz
parents:
diff changeset
817 ptrdiff_t __src2dst);</code>
anatofuz
parents:
diff changeset
818 </p>
anatofuz
parents:
diff changeset
819 <blockquote>
anatofuz
parents:
diff changeset
820 <p>
anatofuz
parents:
diff changeset
821 <i>Effects:</i>
anatofuz
parents:
diff changeset
822 </p>
anatofuz
parents:
diff changeset
823 <p>
anatofuz
parents:
diff changeset
824 <i>Returns:</i>
anatofuz
parents:
diff changeset
825 </p>
anatofuz
parents:
diff changeset
826 </blockquote>
anatofuz
parents:
diff changeset
827 </td>
anatofuz
parents:
diff changeset
828 <td>&#10003;</td>
anatofuz
parents:
diff changeset
829 <td>&#10003;</td>
anatofuz
parents:
diff changeset
830 <td>&#10003;</td>
anatofuz
parents:
diff changeset
831 </tr>
anatofuz
parents:
diff changeset
832
anatofuz
parents:
diff changeset
833 </table>
anatofuz
parents:
diff changeset
834
anatofuz
parents:
diff changeset
835 <!--
anatofuz
parents:
diff changeset
836 000000000000d570 (__DATA,__const) external typeinfo for char32_t
anatofuz
parents:
diff changeset
837 000000000000cfd0 (__DATA,__const) external typeinfo for std::nullptr_t
anatofuz
parents:
diff changeset
838 000000000000d520 (__DATA,__const) external typeinfo for char16_t
anatofuz
parents:
diff changeset
839 000000000000d580 (__DATA,__const) external typeinfo for char32_t*
anatofuz
parents:
diff changeset
840 000000000000cfe0 (__DATA,__const) external typeinfo for std::nullptr_t*
anatofuz
parents:
diff changeset
841 000000000000d530 (__DATA,__const) external typeinfo for char16_t*
anatofuz
parents:
diff changeset
842 000000000000d5a0 (__DATA,__const) external typeinfo for char32_t const*
anatofuz
parents:
diff changeset
843 000000000000d000 (__DATA,__const) external typeinfo for std::nullptr_t const*
anatofuz
parents:
diff changeset
844 000000000000d550 (__DATA,__const) external typeinfo for char16_t const*
anatofuz
parents:
diff changeset
845 000000000000d190 (__DATA,__const) external typeinfo for signed char const*
anatofuz
parents:
diff changeset
846 000000000000d050 (__DATA,__const) external typeinfo for bool const*
anatofuz
parents:
diff changeset
847 000000000000d0f0 (__DATA,__const) external typeinfo for char const*
anatofuz
parents:
diff changeset
848 000000000000d4b0 (__DATA,__const) external typeinfo for double const*
anatofuz
parents:
diff changeset
849 000000000000d500 (__DATA,__const) external typeinfo for long double const*
anatofuz
parents:
diff changeset
850 000000000000d460 (__DATA,__const) external typeinfo for float const*
anatofuz
parents:
diff changeset
851 000000000000d140 (__DATA,__const) external typeinfo for unsigned char const*
anatofuz
parents:
diff changeset
852 000000000000d280 (__DATA,__const) external typeinfo for int const*
anatofuz
parents:
diff changeset
853 000000000000d2d0 (__DATA,__const) external typeinfo for unsigned int const*
anatofuz
parents:
diff changeset
854 000000000000d320 (__DATA,__const) external typeinfo for long const*
anatofuz
parents:
diff changeset
855 000000000000d370 (__DATA,__const) external typeinfo for unsigned long const*
anatofuz
parents:
diff changeset
856 000000000000d1e0 (__DATA,__const) external typeinfo for short const*
anatofuz
parents:
diff changeset
857 000000000000d230 (__DATA,__const) external typeinfo for unsigned short const*
anatofuz
parents:
diff changeset
858 000000000000cfb0 (__DATA,__const) external typeinfo for void const*
anatofuz
parents:
diff changeset
859 000000000000d0a0 (__DATA,__const) external typeinfo for wchar_t const*
anatofuz
parents:
diff changeset
860 000000000000d3c0 (__DATA,__const) external typeinfo for long long const*
anatofuz
parents:
diff changeset
861 000000000000d410 (__DATA,__const) external typeinfo for unsigned long long const*
anatofuz
parents:
diff changeset
862 000000000000d170 (__DATA,__const) external typeinfo for signed char*
anatofuz
parents:
diff changeset
863 000000000000d030 (__DATA,__const) external typeinfo for bool*
anatofuz
parents:
diff changeset
864 000000000000d0d0 (__DATA,__const) external typeinfo for char*
anatofuz
parents:
diff changeset
865 000000000000d490 (__DATA,__const) external typeinfo for double*
anatofuz
parents:
diff changeset
866 000000000000d4e0 (__DATA,__const) external typeinfo for long double*
anatofuz
parents:
diff changeset
867 000000000000d440 (__DATA,__const) external typeinfo for float*
anatofuz
parents:
diff changeset
868 000000000000d120 (__DATA,__const) external typeinfo for unsigned char*
anatofuz
parents:
diff changeset
869 000000000000d260 (__DATA,__const) external typeinfo for int*
anatofuz
parents:
diff changeset
870 000000000000d2b0 (__DATA,__const) external typeinfo for unsigned int*
anatofuz
parents:
diff changeset
871 000000000000d300 (__DATA,__const) external typeinfo for long*
anatofuz
parents:
diff changeset
872 000000000000d350 (__DATA,__const) external typeinfo for unsigned long*
anatofuz
parents:
diff changeset
873 000000000000d1c0 (__DATA,__const) external typeinfo for short*
anatofuz
parents:
diff changeset
874 000000000000d210 (__DATA,__const) external typeinfo for unsigned short*
anatofuz
parents:
diff changeset
875 000000000000cf90 (__DATA,__const) external typeinfo for void*
anatofuz
parents:
diff changeset
876 000000000000d080 (__DATA,__const) external typeinfo for wchar_t*
anatofuz
parents:
diff changeset
877 000000000000d3a0 (__DATA,__const) external typeinfo for long long*
anatofuz
parents:
diff changeset
878 000000000000d3f0 (__DATA,__const) external typeinfo for unsigned long long*
anatofuz
parents:
diff changeset
879 000000000000d160 (__DATA,__const) external typeinfo for signed char
anatofuz
parents:
diff changeset
880 000000000000d020 (__DATA,__const) external typeinfo for bool
anatofuz
parents:
diff changeset
881 000000000000d0c0 (__DATA,__const) external typeinfo for char
anatofuz
parents:
diff changeset
882 000000000000d480 (__DATA,__const) external typeinfo for double
anatofuz
parents:
diff changeset
883 000000000000d4d0 (__DATA,__const) external typeinfo for long double
anatofuz
parents:
diff changeset
884 000000000000d430 (__DATA,__const) external typeinfo for float
anatofuz
parents:
diff changeset
885 000000000000d110 (__DATA,__const) external typeinfo for unsigned char
anatofuz
parents:
diff changeset
886 000000000000d250 (__DATA,__const) external typeinfo for int
anatofuz
parents:
diff changeset
887 000000000000d2a0 (__DATA,__const) external typeinfo for unsigned int
anatofuz
parents:
diff changeset
888 000000000000d2f0 (__DATA,__const) external typeinfo for long
anatofuz
parents:
diff changeset
889 000000000000d340 (__DATA,__const) external typeinfo for unsigned long
anatofuz
parents:
diff changeset
890 000000000000d1b0 (__DATA,__const) external typeinfo for short
anatofuz
parents:
diff changeset
891 000000000000d200 (__DATA,__const) external typeinfo for unsigned short
anatofuz
parents:
diff changeset
892 000000000000cf78 (__DATA,__const) external typeinfo for void
anatofuz
parents:
diff changeset
893 000000000000d070 (__DATA,__const) external typeinfo for wchar_t
anatofuz
parents:
diff changeset
894 000000000000d390 (__DATA,__const) external typeinfo for long long
anatofuz
parents:
diff changeset
895 000000000000d3e0 (__DATA,__const) external typeinfo for unsigned long long
anatofuz
parents:
diff changeset
896 00000000000093f9 (__TEXT,__cstring) external typeinfo name for char32_t
anatofuz
parents:
diff changeset
897 0000000000009351 (__TEXT,__cstring) external typeinfo name for std::nullptr_t
anatofuz
parents:
diff changeset
898 00000000000093ed (__TEXT,__cstring) external typeinfo name for char16_t
anatofuz
parents:
diff changeset
899 0000000000009470 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__enum_type_info
anatofuz
parents:
diff changeset
900 0000000000009410 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__array_type_info
anatofuz
parents:
diff changeset
901 0000000000009290 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__class_type_info
anatofuz
parents:
diff changeset
902 00000000000094a0 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__pbase_type_info
anatofuz
parents:
diff changeset
903 00000000000094d0 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__pointer_type_info
anatofuz
parents:
diff changeset
904 0000000000009440 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__function_type_info
anatofuz
parents:
diff changeset
905 00000000000092c0 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__si_class_type_info
anatofuz
parents:
diff changeset
906 00000000000092f0 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__vmi_class_type_info
anatofuz
parents:
diff changeset
907 0000000000009320 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__fundamental_type_info
anatofuz
parents:
diff changeset
908 0000000000009500 (__TEXT,__cstring) external typeinfo name for __cxxabiv1::__pointer_to_member_type_info
anatofuz
parents:
diff changeset
909 00000000000093fc (__TEXT,__cstring) external typeinfo name for char32_t*
anatofuz
parents:
diff changeset
910 0000000000009354 (__TEXT,__cstring) external typeinfo name for std::nullptr_t*
anatofuz
parents:
diff changeset
911 00000000000093f0 (__TEXT,__cstring) external typeinfo name for char16_t*
anatofuz
parents:
diff changeset
912 0000000000009400 (__TEXT,__cstring) external typeinfo name for char32_t const*
anatofuz
parents:
diff changeset
913 0000000000009358 (__TEXT,__cstring) external typeinfo name for std::nullptr_t const*
anatofuz
parents:
diff changeset
914 00000000000093f4 (__TEXT,__cstring) external typeinfo name for char16_t const*
anatofuz
parents:
diff changeset
915 0000000000009386 (__TEXT,__cstring) external typeinfo name for signed char const*
anatofuz
parents:
diff changeset
916 0000000000009362 (__TEXT,__cstring) external typeinfo name for bool const*
anatofuz
parents:
diff changeset
917 0000000000009374 (__TEXT,__cstring) external typeinfo name for char const*
anatofuz
parents:
diff changeset
918 00000000000093e0 (__TEXT,__cstring) external typeinfo name for double const*
anatofuz
parents:
diff changeset
919 00000000000093e9 (__TEXT,__cstring) external typeinfo name for long double const*
anatofuz
parents:
diff changeset
920 00000000000093d7 (__TEXT,__cstring) external typeinfo name for float const*
anatofuz
parents:
diff changeset
921 000000000000937d (__TEXT,__cstring) external typeinfo name for unsigned char const*
anatofuz
parents:
diff changeset
922 00000000000093a1 (__TEXT,__cstring) external typeinfo name for int const*
anatofuz
parents:
diff changeset
923 00000000000093aa (__TEXT,__cstring) external typeinfo name for unsigned int const*
anatofuz
parents:
diff changeset
924 00000000000093b3 (__TEXT,__cstring) external typeinfo name for long const*
anatofuz
parents:
diff changeset
925 00000000000093bc (__TEXT,__cstring) external typeinfo name for unsigned long const*
anatofuz
parents:
diff changeset
926 000000000000938f (__TEXT,__cstring) external typeinfo name for short const*
anatofuz
parents:
diff changeset
927 0000000000009398 (__TEXT,__cstring) external typeinfo name for unsigned short const*
anatofuz
parents:
diff changeset
928 000000000000934d (__TEXT,__cstring) external typeinfo name for void const*
anatofuz
parents:
diff changeset
929 000000000000936b (__TEXT,__cstring) external typeinfo name for wchar_t const*
anatofuz
parents:
diff changeset
930 00000000000093c5 (__TEXT,__cstring) external typeinfo name for long long const*
anatofuz
parents:
diff changeset
931 00000000000093ce (__TEXT,__cstring) external typeinfo name for unsigned long long const*
anatofuz
parents:
diff changeset
932 0000000000009383 (__TEXT,__cstring) external typeinfo name for signed char*
anatofuz
parents:
diff changeset
933 000000000000935f (__TEXT,__cstring) external typeinfo name for bool*
anatofuz
parents:
diff changeset
934 0000000000009371 (__TEXT,__cstring) external typeinfo name for char*
anatofuz
parents:
diff changeset
935 00000000000093dd (__TEXT,__cstring) external typeinfo name for double*
anatofuz
parents:
diff changeset
936 00000000000093e6 (__TEXT,__cstring) external typeinfo name for long double*
anatofuz
parents:
diff changeset
937 00000000000093d4 (__TEXT,__cstring) external typeinfo name for float*
anatofuz
parents:
diff changeset
938 000000000000937a (__TEXT,__cstring) external typeinfo name for unsigned char*
anatofuz
parents:
diff changeset
939 000000000000939e (__TEXT,__cstring) external typeinfo name for int*
anatofuz
parents:
diff changeset
940 00000000000093a7 (__TEXT,__cstring) external typeinfo name for unsigned int*
anatofuz
parents:
diff changeset
941 00000000000093b0 (__TEXT,__cstring) external typeinfo name for long*
anatofuz
parents:
diff changeset
942 00000000000093b9 (__TEXT,__cstring) external typeinfo name for unsigned long*
anatofuz
parents:
diff changeset
943 000000000000938c (__TEXT,__cstring) external typeinfo name for short*
anatofuz
parents:
diff changeset
944 0000000000009395 (__TEXT,__cstring) external typeinfo name for unsigned short*
anatofuz
parents:
diff changeset
945 000000000000934a (__TEXT,__cstring) external typeinfo name for void*
anatofuz
parents:
diff changeset
946 0000000000009368 (__TEXT,__cstring) external typeinfo name for wchar_t*
anatofuz
parents:
diff changeset
947 00000000000093c2 (__TEXT,__cstring) external typeinfo name for long long*
anatofuz
parents:
diff changeset
948 00000000000093cb (__TEXT,__cstring) external typeinfo name for unsigned long long*
anatofuz
parents:
diff changeset
949 0000000000009381 (__TEXT,__cstring) external typeinfo name for signed char
anatofuz
parents:
diff changeset
950 000000000000935d (__TEXT,__cstring) external typeinfo name for bool
anatofuz
parents:
diff changeset
951 000000000000936f (__TEXT,__cstring) external typeinfo name for char
anatofuz
parents:
diff changeset
952 00000000000093db (__TEXT,__cstring) external typeinfo name for double
anatofuz
parents:
diff changeset
953 00000000000093e4 (__TEXT,__cstring) external typeinfo name for long double
anatofuz
parents:
diff changeset
954 00000000000093d2 (__TEXT,__cstring) external typeinfo name for float
anatofuz
parents:
diff changeset
955 0000000000009378 (__TEXT,__cstring) external typeinfo name for unsigned char
anatofuz
parents:
diff changeset
956 000000000000939c (__TEXT,__cstring) external typeinfo name for int
anatofuz
parents:
diff changeset
957 00000000000093a5 (__TEXT,__cstring) external typeinfo name for unsigned int
anatofuz
parents:
diff changeset
958 00000000000093ae (__TEXT,__cstring) external typeinfo name for long
anatofuz
parents:
diff changeset
959 00000000000093b7 (__TEXT,__cstring) external typeinfo name for unsigned long
anatofuz
parents:
diff changeset
960 000000000000938a (__TEXT,__cstring) external typeinfo name for short
anatofuz
parents:
diff changeset
961 0000000000009393 (__TEXT,__cstring) external typeinfo name for unsigned short
anatofuz
parents:
diff changeset
962 0000000000009348 (__TEXT,__cstring) external typeinfo name for void
anatofuz
parents:
diff changeset
963 0000000000009366 (__TEXT,__cstring) external typeinfo name for wchar_t
anatofuz
parents:
diff changeset
964 00000000000093c0 (__TEXT,__cstring) external typeinfo name for long long
anatofuz
parents:
diff changeset
965 00000000000093c9 (__TEXT,__cstring) external typeinfo name for unsigned long long
anatofuz
parents:
diff changeset
966 000000000000ce30 (__DATA,__const) external vtable for __cxxabiv1::__enum_type_info
anatofuz
parents:
diff changeset
967 000000000000cdb0 (__DATA,__const) external vtable for __cxxabiv1::__array_type_info
anatofuz
parents:
diff changeset
968 000000000000cbe0 (__DATA,__const) external vtable for __cxxabiv1::__class_type_info
anatofuz
parents:
diff changeset
969 000000000000ce70 (__DATA,__const) external vtable for __cxxabiv1::__pbase_type_info
anatofuz
parents:
diff changeset
970 000000000000cec0 (__DATA,__const) external vtable for __cxxabiv1::__pointer_type_info
anatofuz
parents:
diff changeset
971 000000000000cdf0 (__DATA,__const) external vtable for __cxxabiv1::__function_type_info
anatofuz
parents:
diff changeset
972 000000000000cc40 (__DATA,__const) external vtable for __cxxabiv1::__si_class_type_info
anatofuz
parents:
diff changeset
973 000000000000cca0 (__DATA,__const) external vtable for __cxxabiv1::__vmi_class_type_info
anatofuz
parents:
diff changeset
974 000000000000cd70 (__DATA,__const) external vtable for __cxxabiv1::__fundamental_type_info
anatofuz
parents:
diff changeset
975 000000000000cf10 (__DATA,__const) external vtable for __cxxabiv1::__pointer_to_member_type_info
anatofuz
parents:
diff changeset
976
anatofuz
parents:
diff changeset
977 (undefined) external ___stack_chk_fail (from libSystem)
anatofuz
parents:
diff changeset
978 (undefined) external ___stack_chk_guard (from libSystem)
anatofuz
parents:
diff changeset
979 (undefined) external ___stderrp (from libSystem)
anatofuz
parents:
diff changeset
980 (undefined) external ___strcat_chk (from libSystem)
anatofuz
parents:
diff changeset
981 (undefined) external _abort (from libSystem)
anatofuz
parents:
diff changeset
982 (undefined) external _calloc (from libSystem)
anatofuz
parents:
diff changeset
983 (undefined) external _dlsym (from libSystem)
anatofuz
parents:
diff changeset
984 (undefined) external _free (from libSystem)
anatofuz
parents:
diff changeset
985 (undefined) external _malloc (from libSystem)
anatofuz
parents:
diff changeset
986 (undefined) external _memcpy (from libSystem)
anatofuz
parents:
diff changeset
987 (undefined) external _pthread_getspecific (from libSystem)
anatofuz
parents:
diff changeset
988 (undefined) external _pthread_key_create (from libSystem)
anatofuz
parents:
diff changeset
989 (undefined) external _pthread_mutex_init (from libSystem)
anatofuz
parents:
diff changeset
990 (undefined) external _pthread_mutex_lock (from libSystem)
anatofuz
parents:
diff changeset
991 (undefined) external _pthread_mutex_unlock (from libSystem)
anatofuz
parents:
diff changeset
992 (undefined) external _pthread_mutexattr_init (from libSystem)
anatofuz
parents:
diff changeset
993 (undefined) external _pthread_mutexattr_settype (from libSystem)
anatofuz
parents:
diff changeset
994 (undefined) external _pthread_once (from libSystem)
anatofuz
parents:
diff changeset
995 (undefined) external _pthread_setspecific (from libSystem)
anatofuz
parents:
diff changeset
996 (undefined) external _realloc (from libSystem)
anatofuz
parents:
diff changeset
997 (undefined) external _strcmp (from libSystem)
anatofuz
parents:
diff changeset
998 (undefined) external _strcpy (from libSystem)
anatofuz
parents:
diff changeset
999 (undefined) external _strlen (from libSystem)
anatofuz
parents:
diff changeset
1000 (undefined) external _strncmp (from libSystem)
anatofuz
parents:
diff changeset
1001 (undefined) external _vasprintf (from libSystem)
anatofuz
parents:
diff changeset
1002 (undefined) external _vfprintf (from libSystem)
anatofuz
parents:
diff changeset
1003 (undefined) external dyld_stub_binder (from libSystem)
anatofuz
parents:
diff changeset
1004 (undefined) external __Unwind_DeleteException (from libSystem)
anatofuz
parents:
diff changeset
1005 (undefined) external __Unwind_GetIP (from libSystem)
anatofuz
parents:
diff changeset
1006 (undefined) external __Unwind_GetLanguageSpecificData (from libSystem)
anatofuz
parents:
diff changeset
1007 (undefined) external __Unwind_GetRegionStart (from libSystem)
anatofuz
parents:
diff changeset
1008 (undefined) external __Unwind_RaiseException (from libSystem)
anatofuz
parents:
diff changeset
1009 (undefined) external __Unwind_Resume_or_Rethrow (from libSystem)
anatofuz
parents:
diff changeset
1010 (undefined) external __Unwind_SetGR (from libSystem)
anatofuz
parents:
diff changeset
1011 (undefined) external __Unwind_SetIP (from libSystem)
anatofuz
parents:
diff changeset
1012 (undefined) external ___bzero (from libSystem)
anatofuz
parents:
diff changeset
1013 -->
anatofuz
parents:
diff changeset
1014
anatofuz
parents:
diff changeset
1015 </body>
anatofuz
parents:
diff changeset
1016 </html>