1 | // |
---|
2 | // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo |
---|
3 | // |
---|
4 | // The contents of this file are covered under the licence agreement in the |
---|
5 | // file "LICENCE" distributed with Cforall. |
---|
6 | // |
---|
7 | // exception.c -- |
---|
8 | // |
---|
9 | // Author : Andrew Beach |
---|
10 | // Created On : Mon Jun 26 15:13:00 2017 |
---|
11 | // Last Modified By : Peter A. Buhr |
---|
12 | // Last Modified On : Fri Feb 9 14:41:55 2018 |
---|
13 | // Update Count : 8 |
---|
14 | // |
---|
15 | |
---|
16 | #include <stddef.h> // for size_t |
---|
17 | |
---|
18 | #include "exception.h" |
---|
19 | |
---|
20 | // Implementation of the secret header. |
---|
21 | |
---|
22 | #include <stdlib.h> |
---|
23 | #include <stdio.h> |
---|
24 | #include <unwind.h> |
---|
25 | #include <bits/debug.h> |
---|
26 | |
---|
27 | // FIX ME: temporary hack to keep ARM build working |
---|
28 | #ifndef _URC_FATAL_PHASE1_ERROR |
---|
29 | #define _URC_FATAL_PHASE1_ERROR 2 |
---|
30 | #endif // ! _URC_FATAL_PHASE1_ERROR |
---|
31 | #ifndef _URC_FATAL_PHASE2_ERROR |
---|
32 | #define _URC_FATAL_PHASE2_ERROR 2 |
---|
33 | #endif // ! _URC_FATAL_PHASE2_ERROR |
---|
34 | |
---|
35 | #include "lsda.h" |
---|
36 | |
---|
37 | |
---|
38 | // Base exception vtable is abstract, you should not have base exceptions. |
---|
39 | struct __cfaabi_ehm__base_exception_t_vtable |
---|
40 | ___cfaabi_ehm__base_exception_t_vtable_instance = { |
---|
41 | .parent = NULL, |
---|
42 | .size = 0, |
---|
43 | .copy = NULL, |
---|
44 | .free = NULL, |
---|
45 | .msg = NULL |
---|
46 | }; |
---|
47 | |
---|
48 | |
---|
49 | // Temperary global exception context. Does not work with concurency. |
---|
50 | struct exception_context_t { |
---|
51 | struct __cfaabi_ehm__try_resume_node * top_resume; |
---|
52 | struct __cfaabi_ehm__try_resume_node * current_resume; |
---|
53 | |
---|
54 | exception * current_exception; |
---|
55 | int current_handler_index; |
---|
56 | } shared_stack = {NULL, NULL, 0, 0}; |
---|
57 | |
---|
58 | // Get the current exception context. |
---|
59 | // There can be a single global until multithreading occurs, then each stack |
---|
60 | // needs its own. It will have to be updated to handle that. |
---|
61 | struct exception_context_t * this_exception_context() { |
---|
62 | return &shared_stack; |
---|
63 | } |
---|
64 | //#define SAVE_EXCEPTION_CONTEXT(to_name) |
---|
65 | //struct exception_context_t * to_name = this_exception_context(); |
---|
66 | //exception * this_exception() { |
---|
67 | // return this_exception_context()->current_exception; |
---|
68 | //} |
---|
69 | |
---|
70 | |
---|
71 | // This macro should be the only thing that needs to change across machines. Used in the personality function, way down |
---|
72 | // in termination. |
---|
73 | // struct _Unwind_Context * -> _Unwind_Reason_Code(*)(exception *) |
---|
74 | #define MATCHER_FROM_CONTEXT(ptr_to_context) \ |
---|
75 | (*(_Unwind_Reason_Code(**)(exception*))(_Unwind_GetCFA(ptr_to_context) + 8)) |
---|
76 | |
---|
77 | |
---|
78 | // RESUMPTION ================================================================ |
---|
79 | |
---|
80 | void __cfaabi_ehm__throw_resume(exception * except) { |
---|
81 | |
---|
82 | __cfaabi_dbg_print_safe("Throwing resumption exception\n"); |
---|
83 | |
---|
84 | struct __cfaabi_ehm__try_resume_node * original_head = shared_stack.current_resume; |
---|
85 | struct __cfaabi_ehm__try_resume_node * current = |
---|
86 | (original_head) ? original_head->next : shared_stack.top_resume; |
---|
87 | |
---|
88 | for ( ; current ; current = current->next) { |
---|
89 | shared_stack.current_resume = current; |
---|
90 | if (current->handler(except)) { |
---|
91 | shared_stack.current_resume = original_head; |
---|
92 | return; |
---|
93 | } |
---|
94 | } |
---|
95 | |
---|
96 | __cfaabi_dbg_print_safe("Unhandled exception\n"); |
---|
97 | shared_stack.current_resume = original_head; |
---|
98 | |
---|
99 | // Fall back to termination: |
---|
100 | __cfaabi_ehm__throw_terminate(except); |
---|
101 | // TODO: Default handler for resumption. |
---|
102 | } |
---|
103 | |
---|
104 | // Do we control where exceptions get thrown even with concurency? If not these are not quite thread safe, the cleanup |
---|
105 | // hook has to be added after the node is built but before it is made the top node. |
---|
106 | |
---|
107 | void __cfaabi_ehm__try_resume_setup(struct __cfaabi_ehm__try_resume_node * node, |
---|
108 | _Bool (*handler)(exception * except)) { |
---|
109 | node->next = shared_stack.top_resume; |
---|
110 | node->handler = handler; |
---|
111 | shared_stack.top_resume = node; |
---|
112 | } |
---|
113 | |
---|
114 | void __cfaabi_ehm__try_resume_cleanup(struct __cfaabi_ehm__try_resume_node * node) { |
---|
115 | shared_stack.top_resume = node->next; |
---|
116 | } |
---|
117 | |
---|
118 | |
---|
119 | // TERMINATION =============================================================== |
---|
120 | |
---|
121 | // MEMORY MANAGEMENT (still for integers) |
---|
122 | // May have to move to cfa for constructors and destructors (references). |
---|
123 | |
---|
124 | struct __cfaabi_ehm__node { |
---|
125 | struct __cfaabi_ehm__node * next; |
---|
126 | }; |
---|
127 | |
---|
128 | #define NODE_TO_EXCEPT(node) ((exception *)(1 + (node))) |
---|
129 | #define EXCEPT_TO_NODE(except) ((struct __cfaabi_ehm__node *)(except) - 1) |
---|
130 | |
---|
131 | // Creates a copy of the indicated exception and sets current_exception to it. |
---|
132 | static void __cfaabi_ehm__allocate_exception( exception * except ) { |
---|
133 | struct exception_context_t * context = this_exception_context(); |
---|
134 | |
---|
135 | // Allocate memory for the exception. |
---|
136 | struct __cfaabi_ehm__node * store = malloc( |
---|
137 | sizeof( struct __cfaabi_ehm__node ) + except->virtual_table->size ); |
---|
138 | |
---|
139 | if ( ! store ) { |
---|
140 | // Failure: cannot allocate exception. Terminate thread. |
---|
141 | abort(); // <- Although I think it might be the process. |
---|
142 | } |
---|
143 | |
---|
144 | // Add the node to the list: |
---|
145 | store->next = EXCEPT_TO_NODE(context->current_exception); |
---|
146 | context->current_exception = NODE_TO_EXCEPT(store); |
---|
147 | |
---|
148 | // Copy the exception to storage. |
---|
149 | except->virtual_table->copy( context->current_exception, except ); |
---|
150 | } |
---|
151 | |
---|
152 | // Delete the provided exception, unsetting current_exception if relivant. |
---|
153 | static void __cfaabi_ehm__delete_exception( exception * except ) { |
---|
154 | struct exception_context_t * context = this_exception_context(); |
---|
155 | |
---|
156 | __cfaabi_dbg_print_safe("Deleting Exception\n"); |
---|
157 | |
---|
158 | // Remove the exception from the list. |
---|
159 | struct __cfaabi_ehm__node * to_free = EXCEPT_TO_NODE(except); |
---|
160 | struct __cfaabi_ehm__node * node; |
---|
161 | |
---|
162 | if ( context->current_exception == except ) { |
---|
163 | node = to_free->next; |
---|
164 | context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0; |
---|
165 | } else { |
---|
166 | node = EXCEPT_TO_NODE(context->current_exception); |
---|
167 | // It may always be in the first or second position. |
---|
168 | while( to_free != node->next ) { |
---|
169 | node = node->next; |
---|
170 | } |
---|
171 | node->next = to_free->next; |
---|
172 | } |
---|
173 | |
---|
174 | // Free the old exception node. |
---|
175 | except->virtual_table->free( except ); |
---|
176 | free( to_free ); |
---|
177 | } |
---|
178 | |
---|
179 | // If this isn't a rethrow (*except==0), delete the provided exception. |
---|
180 | void __cfaabi_ehm__cleanup_terminate( void * except ) { |
---|
181 | if ( *(void**)except ) __cfaabi_ehm__delete_exception( *(exception**)except ); |
---|
182 | } |
---|
183 | |
---|
184 | |
---|
185 | // We need a piece of storage to raise the exception |
---|
186 | struct _Unwind_Exception this_exception_storage; |
---|
187 | |
---|
188 | // Function needed by force unwind |
---|
189 | // It basically says to unwind the whole stack and then exit when we reach the end of the stack |
---|
190 | static _Unwind_Reason_Code _Stop_Fn( |
---|
191 | int version, |
---|
192 | _Unwind_Action actions, |
---|
193 | _Unwind_Exception_Class exceptionClass, |
---|
194 | struct _Unwind_Exception * unwind_exception, |
---|
195 | struct _Unwind_Context * context, |
---|
196 | void * some_param) { |
---|
197 | if( actions & _UA_END_OF_STACK ) exit(1); |
---|
198 | if( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON; |
---|
199 | |
---|
200 | return _URC_FATAL_PHASE2_ERROR; |
---|
201 | } |
---|
202 | |
---|
203 | // The exception that is being thrown must already be stored. |
---|
204 | __attribute__((noreturn)) void __cfaabi_ehm__begin_unwind(void) { |
---|
205 | if ( ! this_exception_context()->current_exception ) { |
---|
206 | printf("UNWIND ERROR missing exception in begin unwind\n"); |
---|
207 | abort(); |
---|
208 | } |
---|
209 | |
---|
210 | |
---|
211 | // Call stdlibc to raise the exception |
---|
212 | _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage ); |
---|
213 | |
---|
214 | // If we reach here it means something happened. For resumption to work we need to find a way to return back to |
---|
215 | // here. Most of them will probably boil down to setting a global flag and making the phase 1 either stop or |
---|
216 | // fail. Causing an error on purpose may help avoiding unnecessary work but it might have some weird side |
---|
217 | // effects. If we just pretend no handler was found that would work but may be expensive for no reason since we |
---|
218 | // will always search the whole stack. |
---|
219 | |
---|
220 | if( ret == _URC_END_OF_STACK ) { |
---|
221 | // No proper handler was found. This can be handled in several way. C++ calls std::terminate Here we |
---|
222 | // force unwind the stack, basically raising a cancellation. |
---|
223 | printf("Uncaught exception %p\n", &this_exception_storage); |
---|
224 | |
---|
225 | ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 ); |
---|
226 | printf("UNWIND ERROR %d after force unwind\n", ret); |
---|
227 | abort(); |
---|
228 | } |
---|
229 | |
---|
230 | // We did not simply reach the end of the stack without finding a handler. Something wen't wrong |
---|
231 | printf("UNWIND ERROR %d after raise exception\n", ret); |
---|
232 | abort(); |
---|
233 | } |
---|
234 | |
---|
235 | void __cfaabi_ehm__throw_terminate( exception * val ) { |
---|
236 | __cfaabi_dbg_print_safe("Throwing termination exception\n"); |
---|
237 | |
---|
238 | __cfaabi_ehm__allocate_exception( val ); |
---|
239 | __cfaabi_ehm__begin_unwind(); |
---|
240 | } |
---|
241 | |
---|
242 | void __cfaabi_ehm__rethrow_terminate(void) { |
---|
243 | __cfaabi_dbg_print_safe("Rethrowing termination exception\n"); |
---|
244 | |
---|
245 | __cfaabi_ehm__begin_unwind(); |
---|
246 | } |
---|
247 | |
---|
248 | // This is our personality routine. For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0". |
---|
249 | // This function will be called twice when unwinding. Once in the search phased and once in the cleanup phase. |
---|
250 | _Unwind_Reason_Code __gcfa_personality_v0 ( |
---|
251 | int version, _Unwind_Action actions, unsigned long long exceptionClass, |
---|
252 | struct _Unwind_Exception* unwind_exception, |
---|
253 | struct _Unwind_Context* context) |
---|
254 | { |
---|
255 | |
---|
256 | //__cfaabi_dbg_print_safe("CFA: 0x%lx\n", _Unwind_GetCFA(context)); |
---|
257 | __cfaabi_dbg_print_safe("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context); |
---|
258 | |
---|
259 | // If we've reached the end of the stack then there is nothing much we can do... |
---|
260 | if( actions & _UA_END_OF_STACK ) return _URC_END_OF_STACK; |
---|
261 | |
---|
262 | if (actions & _UA_SEARCH_PHASE) { |
---|
263 | __cfaabi_dbg_print_safe(" lookup phase"); |
---|
264 | } |
---|
265 | else if (actions & _UA_CLEANUP_PHASE) { |
---|
266 | __cfaabi_dbg_print_safe(" cleanup phase"); |
---|
267 | } |
---|
268 | // Just in case, probably can't actually happen |
---|
269 | else { |
---|
270 | printf(" error\n"); |
---|
271 | return _URC_FATAL_PHASE1_ERROR; |
---|
272 | } |
---|
273 | |
---|
274 | // Get a pointer to the language specific data from which we will read what we need |
---|
275 | const unsigned char * lsd = (const unsigned char*) _Unwind_GetLanguageSpecificData( context ); |
---|
276 | |
---|
277 | if( !lsd ) { //Nothing to do, keep unwinding |
---|
278 | printf(" no LSD"); |
---|
279 | goto UNWIND; |
---|
280 | } |
---|
281 | |
---|
282 | // Get the instuction pointer and a reading pointer into the exception table |
---|
283 | lsda_header_info lsd_info; |
---|
284 | const unsigned char * cur_ptr = parse_lsda_header( context, lsd, &lsd_info); |
---|
285 | _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context ); |
---|
286 | |
---|
287 | // Linearly search the table for stuff to do |
---|
288 | while( cur_ptr < lsd_info.action_table ) { |
---|
289 | _Unwind_Ptr callsite_start; |
---|
290 | _Unwind_Ptr callsite_len; |
---|
291 | _Unwind_Ptr callsite_landing_pad; |
---|
292 | _uleb128_t callsite_action; |
---|
293 | |
---|
294 | // Decode the common stuff we have in here |
---|
295 | cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_start); |
---|
296 | cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_len); |
---|
297 | cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad); |
---|
298 | cur_ptr = read_uleb128 (cur_ptr, &callsite_action); |
---|
299 | |
---|
300 | // Have we reach the correct frame info yet? |
---|
301 | if( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) { |
---|
302 | #ifdef __CFA_DEBUG_PRINT__ |
---|
303 | void * ls = (void*)lsd_info.Start; |
---|
304 | void * cs = (void*)callsite_start; |
---|
305 | void * cl = (void*)callsite_len; |
---|
306 | void * bp = (void*)lsd_info.Start + callsite_start; |
---|
307 | void * ep = (void*)lsd_info.Start + callsite_start + callsite_len; |
---|
308 | void * ip = (void*)instruction_ptr; |
---|
309 | __cfaabi_dbg_print_safe("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip); |
---|
310 | #endif // __CFA_DEBUG_PRINT__ |
---|
311 | continue; |
---|
312 | } |
---|
313 | |
---|
314 | // Have we gone too far |
---|
315 | if( lsd_info.Start + callsite_start > instruction_ptr ) { |
---|
316 | printf(" gone too far"); |
---|
317 | break; |
---|
318 | } |
---|
319 | |
---|
320 | // Something to do? |
---|
321 | if( callsite_landing_pad ) { |
---|
322 | // Which phase are we in |
---|
323 | if (actions & _UA_SEARCH_PHASE) { |
---|
324 | // Search phase, this means we probably found a potential handler and must check if it is a match |
---|
325 | |
---|
326 | // If we have arbitrarily decided that 0 means nothing to do and 1 means there is a potential handler |
---|
327 | // This doesn't seem to conflict the gcc default behavior |
---|
328 | if (callsite_action != 0) { |
---|
329 | // Now we want to run some code to see if the handler matches |
---|
330 | // This is the tricky part where we want to the power to run arbitrary code |
---|
331 | // However, generating a new exception table entry and try routine every time |
---|
332 | // is way more expansive than we might like |
---|
333 | // The information we have is : |
---|
334 | // - The GR (Series of registers) |
---|
335 | // GR1=GP Global Pointer of frame ref by context |
---|
336 | // - The instruction pointer |
---|
337 | // - The instruction pointer info (???) |
---|
338 | // - The CFA (Canonical Frame Address) |
---|
339 | // - The BSP (Probably the base stack pointer) |
---|
340 | |
---|
341 | |
---|
342 | // The current apprach uses one exception table entry per try block |
---|
343 | _uleb128_t imatcher; |
---|
344 | // Get the relative offset to the |
---|
345 | cur_ptr = read_uleb128 (cur_ptr, &imatcher); |
---|
346 | |
---|
347 | // Get a function pointer from the relative offset and call it |
---|
348 | // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher; |
---|
349 | |
---|
350 | _Unwind_Reason_Code (*matcher)(exception *) = |
---|
351 | MATCHER_FROM_CONTEXT(context); |
---|
352 | int index = matcher(shared_stack.current_exception); |
---|
353 | _Unwind_Reason_Code ret = (0 == index) |
---|
354 | ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND; |
---|
355 | shared_stack.current_handler_index = index; |
---|
356 | |
---|
357 | // Based on the return value, check if we matched the exception |
---|
358 | if( ret == _URC_HANDLER_FOUND) { |
---|
359 | __cfaabi_dbg_print_safe(" handler found\n"); |
---|
360 | } else { |
---|
361 | __cfaabi_dbg_print_safe(" no handler\n"); |
---|
362 | } |
---|
363 | return ret; |
---|
364 | } |
---|
365 | |
---|
366 | // This is only a cleanup handler, ignore it |
---|
367 | __cfaabi_dbg_print_safe(" no action"); |
---|
368 | } |
---|
369 | else if (actions & _UA_CLEANUP_PHASE) { |
---|
370 | |
---|
371 | if( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){ |
---|
372 | // If this is a potential exception handler |
---|
373 | // but not the one that matched the exception in the seach phase, |
---|
374 | // just ignore it |
---|
375 | goto UNWIND; |
---|
376 | } |
---|
377 | |
---|
378 | // We need to run some clean-up or a handler |
---|
379 | // These statment do the right thing but I don't know any specifics at all |
---|
380 | _Unwind_SetGR( context, __builtin_eh_return_data_regno(0), (_Unwind_Ptr) unwind_exception ); |
---|
381 | _Unwind_SetGR( context, __builtin_eh_return_data_regno(1), 0 ); |
---|
382 | |
---|
383 | // I assume this sets the instruction pointer to the adress of the landing pad |
---|
384 | // It doesn't actually set it, it only state the value that needs to be set once we return _URC_INSTALL_CONTEXT |
---|
385 | _Unwind_SetIP( context, ((lsd_info.LPStart) + (callsite_landing_pad)) ); |
---|
386 | |
---|
387 | __cfaabi_dbg_print_safe(" action\n"); |
---|
388 | |
---|
389 | // Return have some action to run |
---|
390 | return _URC_INSTALL_CONTEXT; |
---|
391 | } |
---|
392 | } |
---|
393 | |
---|
394 | // Nothing to do, move along |
---|
395 | __cfaabi_dbg_print_safe(" no landing pad"); |
---|
396 | } |
---|
397 | // No handling found |
---|
398 | __cfaabi_dbg_print_safe(" table end reached\n"); |
---|
399 | |
---|
400 | UNWIND: |
---|
401 | __cfaabi_dbg_print_safe(" unwind\n"); |
---|
402 | |
---|
403 | // Keep unwinding the stack |
---|
404 | return _URC_CONTINUE_UNWIND; |
---|
405 | } |
---|
406 | |
---|
407 | // Try statements are hoisted out see comments for details. With this could probably be unique and simply linked from |
---|
408 | // libcfa but there is one problem left, see the exception table for details |
---|
409 | __attribute__((noinline)) |
---|
410 | void __cfaabi_ehm__try_terminate(void (*try_block)(), |
---|
411 | void (*catch_block)(int index, exception * except), |
---|
412 | __attribute__((unused)) int (*match_block)(exception * except)) { |
---|
413 | //! volatile int xy = 0; |
---|
414 | //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy); |
---|
415 | |
---|
416 | // Setup statments: These 2 statments won't actually result in any code, they only setup global tables. |
---|
417 | // However, they clobber gcc cancellation support from gcc. We can replace the personality routine but |
---|
418 | // replacing the exception table gcc generates is not really doable, it generates labels based on how the |
---|
419 | // assembly works. |
---|
420 | |
---|
421 | // Setup the personality routine |
---|
422 | asm volatile (".cfi_personality 0x3,__gcfa_personality_v0"); |
---|
423 | // Setup the exception table |
---|
424 | asm volatile (".cfi_lsda 0x3, .LLSDACFA2"); |
---|
425 | |
---|
426 | // Label which defines the start of the area for which the handler is setup. |
---|
427 | asm volatile (".TRYSTART:"); |
---|
428 | |
---|
429 | // The actual statements of the try blocks |
---|
430 | try_block(); |
---|
431 | |
---|
432 | // asm statement to prevent deadcode removal |
---|
433 | asm volatile goto ("" : : : : CATCH ); |
---|
434 | |
---|
435 | // Normal return |
---|
436 | return; |
---|
437 | |
---|
438 | // Exceptionnal path |
---|
439 | CATCH : __attribute__(( unused )); |
---|
440 | // Label which defines the end of the area for which the handler is setup. |
---|
441 | asm volatile (".TRYEND:"); |
---|
442 | // Label which defines the start of the exception landing pad. Basically what is called when the exception is |
---|
443 | // caught. Note, if multiple handlers are given, the multiplexing should be done by the generated code, not the |
---|
444 | // exception runtime. |
---|
445 | asm volatile (".CATCH:"); |
---|
446 | |
---|
447 | // Exception handler |
---|
448 | catch_block( shared_stack.current_handler_index, |
---|
449 | shared_stack.current_exception ); |
---|
450 | } |
---|
451 | |
---|
452 | // Exception table data we need to generate. While this is almost generic, the custom data refers to foo_try_match try |
---|
453 | // match, which is no way generic. Some more works need to be done if we want to have a single call to the try routine. |
---|
454 | |
---|
455 | #if defined( __i386 ) || defined( __x86_64 ) |
---|
456 | asm ( |
---|
457 | //HEADER |
---|
458 | ".LFECFA1:\n" |
---|
459 | " .globl __gcfa_personality_v0\n" |
---|
460 | " .section .gcc_except_table,\"a\",@progbits\n" |
---|
461 | ".LLSDACFA2:\n" //TABLE header |
---|
462 | " .byte 0xff\n" |
---|
463 | " .byte 0xff\n" |
---|
464 | " .byte 0x1\n" |
---|
465 | " .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n" // BODY length |
---|
466 | // Body uses language specific data and therefore could be modified arbitrarily |
---|
467 | ".LLSDACSBCFA2:\n" // BODY start |
---|
468 | " .uleb128 .TRYSTART-__cfaabi_ehm__try_terminate\n" // Handled area start (relative to start of function) |
---|
469 | " .uleb128 .TRYEND-.TRYSTART\n" // Handled area length |
---|
470 | " .uleb128 .CATCH-__cfaabi_ehm__try_terminate\n" // Hanlder landing pad adress (relative to start of function) |
---|
471 | " .uleb128 1\n" // Action code, gcc seems to use always 0 |
---|
472 | ".LLSDACSECFA2:\n" // BODY end |
---|
473 | " .text\n" // TABLE footer |
---|
474 | " .size __cfaabi_ehm__try_terminate, .-__cfaabi_ehm__try_terminate\n" |
---|
475 | " .ident \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n" |
---|
476 | // " .section .note.GNU-stack,\"x\",@progbits\n" |
---|
477 | ); |
---|
478 | #endif // __i386 || __x86_64 |
---|