source: libcfa/src/exception.c @ 67ca73e

arm-ehjacob/cs343-translationnew-ast-unique-expr
Last change on this file since 67ca73e was 67ca73e, checked in by Peter A. Buhr <pabuhr@…>, 16 months ago

temporary exception hack for ARM 64-bit

  • Property mode set to 100644
File size: 20.9 KB
Line 
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 : Sat Aug 15 07:17:19 2020
13// Update Count     : 26
14//
15
16// Normally we would get this from the CFA prelude.
17#include <stddef.h> // for size_t
18
19#include "exception.h"
20
21// Implementation of the secret header is hardware dependent.
22#if !( defined( __x86_64 ) || defined( __i386 ) )
23#elif defined( __ARM_ARCH )
24#warning FIX ME: check if anything needed for ARM
25#else
26#warning Exception Handling: No known architecture detected.
27#endif
28
29#include <stdlib.h>
30#include <stdio.h>
31#include <unwind.h>
32#include <bits/debug.hfa>
33#include "stdhdr/assert.h"
34
35// FIX ME: temporary hack to keep ARM build working
36#ifndef _URC_FATAL_PHASE1_ERROR
37#define _URC_FATAL_PHASE1_ERROR 3
38#endif // ! _URC_FATAL_PHASE1_ERROR
39#ifndef _URC_FATAL_PHASE2_ERROR
40#define _URC_FATAL_PHASE2_ERROR 2
41#endif // ! _URC_FATAL_PHASE2_ERROR
42
43#include "lsda.h"
44
45/* The exception class for our exceptions. Because of the vendor component
46 * its value would not be standard.
47 * Vendor: UWPL
48 * Language: CFA\0
49 */
50const _Unwind_Exception_Class __cfaehm_exception_class = 0x4c50575500414643;
51
52// Base exception vtable is abstract, you should not have base exceptions.
53struct __cfaehm_base_exception_t_vtable
54                ___cfaehm_base_exception_t_vtable_instance = {
55        .parent = NULL,
56        .size = 0,
57        .copy = NULL,
58        .free = NULL,
59        .msg = NULL
60};
61
62
63// Temperary global exception context. Does not work with concurency.
64struct exception_context_t {
65        struct __cfaehm_try_resume_node * top_resume;
66
67        exception_t * current_exception;
68        int current_handler_index;
69} static shared_stack = {NULL, NULL, 0};
70
71// Get the current exception context.
72// There can be a single global until multithreading occurs, then each stack
73// needs its own. It will have to be updated to handle that.
74struct exception_context_t * this_exception_context() {
75        return &shared_stack;
76}
77
78
79// RESUMPTION ================================================================
80
81static void reset_top_resume(struct __cfaehm_try_resume_node ** store) {
82        this_exception_context()->top_resume = *store;
83}
84
85void __cfaehm_throw_resume(exception_t * except, void (*defaultHandler)(exception_t *)) {
86        struct exception_context_t * context = this_exception_context();
87
88        __cfadbg_print_safe(exception, "Throwing resumption exception\n");
89
90        {
91                __attribute__((cleanup(reset_top_resume)))
92                struct __cfaehm_try_resume_node * original_head = context->top_resume;
93                struct __cfaehm_try_resume_node * current = context->top_resume;
94
95                for ( ; current ; current = current->next) {
96                        context->top_resume = current->next;
97                        if (current->handler(except)) {
98                                return;
99                        }
100                }
101        } // End the search and return to the top of the stack.
102
103        // No handler found, fall back to the default operation.
104        __cfadbg_print_safe(exception, "Unhandled exception\n");
105        defaultHandler(except);
106}
107
108// Do we control where exceptions get thrown even with concurency?
109// If not these are not quite thread safe, the cleanup hook has to
110// be added after the node is built but before it is made the top node.
111
112void __cfaehm_try_resume_setup(struct __cfaehm_try_resume_node * node,
113                        _Bool (*handler)(exception_t * except)) {
114        struct exception_context_t * context = this_exception_context();
115        node->next = context->top_resume;
116        node->handler = handler;
117        context->top_resume = node;
118}
119
120void __cfaehm_try_resume_cleanup(struct __cfaehm_try_resume_node * node) {
121        struct exception_context_t * context = this_exception_context();
122        context->top_resume = node->next;
123}
124
125
126// MEMORY MANAGEMENT =========================================================
127
128// How to clean up an exception in various situations.
129static void __cfaehm_exception_cleanup(
130                _Unwind_Reason_Code reason,
131                struct _Unwind_Exception * exception) {
132        switch (reason) {
133        case _URC_FOREIGN_EXCEPTION_CAUGHT:
134                // This one we could clean-up to allow cross-language exceptions.
135        case _URC_FATAL_PHASE1_ERROR:
136        case _URC_FATAL_PHASE2_ERROR:
137        default:
138                abort();
139        }
140}
141
142// We need a piece of storage to raise the exception, for now its a single
143// piece.
144static struct _Unwind_Exception this_exception_storage;
145
146struct __cfaehm_node {
147        struct __cfaehm_node * next;
148};
149
150#define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))
151#define EXCEPT_TO_NODE(except) ((struct __cfaehm_node *)(except) - 1)
152
153// Creates a copy of the indicated exception and sets current_exception to it.
154static void __cfaehm_allocate_exception( exception_t * except ) {
155        struct exception_context_t * context = this_exception_context();
156
157        // Allocate memory for the exception.
158        struct __cfaehm_node * store = malloc(
159                sizeof( struct __cfaehm_node ) + except->virtual_table->size );
160
161        if ( ! store ) {
162                // Failure: cannot allocate exception. Terminate thread.
163                abort(); // <- Although I think it might be the process.
164        }
165
166        // Add the node to the list:
167        store->next = EXCEPT_TO_NODE(context->current_exception);
168        context->current_exception = NODE_TO_EXCEPT(store);
169
170        // Copy the exception to storage.
171        except->virtual_table->copy( context->current_exception, except );
172
173        // Set up the exception storage.
174        this_exception_storage.exception_class = __cfaehm_exception_class;
175        this_exception_storage.exception_cleanup = __cfaehm_exception_cleanup;
176}
177
178// Delete the provided exception, unsetting current_exception if relivant.
179static void __cfaehm_delete_exception( exception_t * except ) {
180        struct exception_context_t * context = this_exception_context();
181
182        __cfadbg_print_safe(exception, "Deleting Exception\n");
183
184        // Remove the exception from the list.
185        struct __cfaehm_node * to_free = EXCEPT_TO_NODE(except);
186        struct __cfaehm_node * node;
187
188        if ( context->current_exception == except ) {
189                node = to_free->next;
190                context->current_exception = (node) ? NODE_TO_EXCEPT(node) : 0;
191        } else {
192                node = EXCEPT_TO_NODE(context->current_exception);
193                // It may always be in the first or second position.
194                while ( to_free != node->next ) {
195                        node = node->next;
196                }
197                node->next = to_free->next;
198        }
199
200        // Free the old exception node.
201        except->virtual_table->free( except );
202        free( to_free );
203}
204
205// CANCELLATION ==============================================================
206
207// Function needed by force unwind
208// It basically says to unwind the whole stack and then exit when we reach the end of the stack
209static _Unwind_Reason_Code _Stop_Fn(
210                int version,
211                _Unwind_Action actions,
212                _Unwind_Exception_Class exception_class,
213                struct _Unwind_Exception * unwind_exception,
214                struct _Unwind_Context * unwind_context,
215                void * stop_param) {
216        // Verify actions follow the rules we expect.
217        verify((actions & _UA_CLEANUP_PHASE) && (actions & _UA_FORCE_UNWIND));
218        verify(!(actions & (_UA_SEARCH_PHASE | _UA_HANDER_FRAME)));
219
220        if ( actions & _UA_END_OF_STACK ) {
221                exit(1);
222        } else {
223                return _URC_NO_REASON;
224        }
225}
226
227// Cancel the current stack, prefroming approprate clean-up and messaging.
228void __cfaehm_cancel_stack( exception_t * exception ) {
229        // TODO: Detect current stack and pick a particular stop-function.
230        _Unwind_Reason_Code ret;
231        ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 );
232        printf("UNWIND ERROR %d after force unwind\n", ret);
233        abort();
234}
235
236
237// TERMINATION ===============================================================
238
239// If this isn't a rethrow (*except==0), delete the provided exception.
240void __cfaehm_cleanup_terminate( void * except ) {
241        if ( *(void**)except ) __cfaehm_delete_exception( *(exception_t **)except );
242}
243
244static void __cfaehm_cleanup_default( exception_t ** except ) {
245        __cfaehm_delete_exception( *except );
246        *except = NULL;
247}
248
249// The exception that is being thrown must already be stored.
250static void __cfaehm_begin_unwind(void(*defaultHandler)(exception_t *)) {
251        struct exception_context_t * context = this_exception_context();
252        struct _Unwind_Exception * storage = &this_exception_storage;
253        if ( NULL == context->current_exception ) {
254                printf("UNWIND ERROR missing exception in begin unwind\n");
255                abort();
256        }
257
258        // Call stdlibc to raise the exception
259        __cfadbg_print_safe(exception, "Begin unwinding (storage &p, context %p)\n", storage, context);
260        _Unwind_Reason_Code ret = _Unwind_RaiseException( storage );
261
262        // If we reach here it means something happened. For resumption to work we need to find a way
263        // to return back to here. Most of them will probably boil down to setting a global flag and
264        // making the phase 1 either stop or fail. Causing an error on purpose may help avoiding
265        // unnecessary work but it might have some weird side effects. If we just pretend no handler
266        // was found that would work but may be expensive for no reason since we will always search
267        // the whole stack.
268
269        // We did not simply reach the end of the stack without finding a handler. This is an error.
270        if ( ret != _URC_END_OF_STACK ) {
271                printf("UNWIND ERROR %d after raise exception\n", ret);
272                abort();
273        }
274
275        // No handler found, go to the default operation.
276        __cfadbg_print_safe(exception, "Uncaught exception %p\n", storage);
277
278        __attribute__((cleanup(__cfaehm_cleanup_default)))
279        exception_t * exception = context->current_exception;
280        defaultHandler( exception );
281}
282
283void __cfaehm_throw_terminate( exception_t * val, void (*defaultHandler)(exception_t *) ) {
284        __cfadbg_print_safe(exception, "Throwing termination exception\n");
285
286        __cfaehm_allocate_exception( val );
287        __cfaehm_begin_unwind( defaultHandler );
288}
289
290static __attribute__((noreturn)) void __cfaehm_rethrow_adapter( exception_t * except ) {
291        // TODO: Print some error message.
292        (void)except;
293        abort();
294}
295
296void __cfaehm_rethrow_terminate(void) {
297        __cfadbg_print_safe(exception, "Rethrowing termination exception\n");
298
299        __cfaehm_begin_unwind( __cfaehm_rethrow_adapter );
300        abort();
301}
302#if 0
303// This is our personality routine. For every stack frame annotated with
304// ".cfi_personality 0x3,__gcfa_personality_v0" this function will be called twice when unwinding.
305//  Once in the search phase and once in the cleanup phase.
306_Unwind_Reason_Code __gcfa_personality_v0(
307                int version,
308                _Unwind_Action actions,
309                unsigned long long exception_class,
310                struct _Unwind_Exception * unwind_exception,
311                struct _Unwind_Context * unwind_context)
312{
313
314        //__cfadbg_print_safe(exception, "CFA: 0x%lx\n", _Unwind_GetCFA(context));
315        __cfadbg_print_safe(exception, "Personality function (%d, %x, %llu, %p, %p):",
316                        version, actions, exception_class, unwind_exception, unwind_context);
317
318        // Verify that actions follow the rules we expect.
319        // This function should never be called at the end of the stack.
320        verify(!(actions & _UA_END_OF_STACK));
321        // Either only the search phase flag is set or...
322        if (actions & _UA_SEARCH_PHASE) {
323                verify(actions == _UA_SEARCH_PHASE);
324                __cfadbg_print_safe(exception, " lookup phase");
325        // ... we are in clean-up phase.
326        } else {
327                verify(actions & _UA_CLEANUP_PHASE);
328                __cfadbg_print_safe(exception, " cleanup phase");
329                // We shouldn't be the handler frame during forced unwind.
330                if (actions & _UA_HANDLER_FRAME) {
331                        verify(!(actions & _UA_FORCE_UNWIND));
332                        __cfadbg_print_safe(exception, " (handler frame)");
333                } else if (actions & _UA_FORCE_UNWIND) {
334                        __cfadbg_print_safe(exception, " (force unwind)");
335                }
336        }
337
338        // Get a pointer to the language specific data from which we will read what we need
339        const unsigned char * lsd = _Unwind_GetLanguageSpecificData( unwind_context );
340
341        if ( !lsd ) {   //Nothing to do, keep unwinding
342                printf(" no LSD");
343                goto UNWIND;
344        }
345
346        // Get the instuction pointer and a reading pointer into the exception table
347        lsda_header_info lsd_info;
348        const unsigned char * cur_ptr = parse_lsda_header(unwind_context, lsd, &lsd_info);
349        _Unwind_Ptr instruction_ptr = _Unwind_GetIP(unwind_context);
350
351        struct exception_context_t * context = this_exception_context();
352
353        // Linearly search the table for stuff to do
354        while ( cur_ptr < lsd_info.action_table ) {
355                _Unwind_Ptr callsite_start;
356                _Unwind_Ptr callsite_len;
357                _Unwind_Ptr callsite_landing_pad;
358                _uleb128_t  callsite_action;
359
360                // Decode the common stuff we have in here
361                cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_start);
362                cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_len);
363                cur_ptr = read_encoded_value(0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad);
364                cur_ptr = read_uleb128(cur_ptr, &callsite_action);
365
366                // Have we reach the correct frame info yet?
367                if ( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) {
368#ifdef __CFA_DEBUG_PRINT__
369                        void * ls = (void*)lsd_info.Start;
370                        void * cs = (void*)callsite_start;
371                        void * cl = (void*)callsite_len;
372                        void * bp = (void*)lsd_info.Start + callsite_start;
373                        void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
374                        void * ip = (void*)instruction_ptr;
375                        __cfadbg_print_safe(exception, "\nfound %p - %p (%p, %p, %p), looking for %p\n",
376                                        bp, ep, ls, cs, cl, ip);
377#endif // __CFA_DEBUG_PRINT__
378                        continue;
379                }
380
381                // Have we gone too far?
382                if ( lsd_info.Start + callsite_start > instruction_ptr ) {
383                        printf(" gone too far");
384                        break;
385                }
386
387                // Check for what we must do:
388                if ( 0 == callsite_landing_pad ) {
389                        // Nothing to do, move along
390                        __cfadbg_print_safe(exception, " no landing pad");
391                } else if (actions & _UA_SEARCH_PHASE) {
392                        // In search phase, these means we found a potential handler we must check.
393
394                        // We have arbitrarily decided that 0 means nothing to do and 1 means there is
395                        // a potential handler. This doesn't seem to conflict the gcc default behavior.
396                        if (callsite_action != 0) {
397                                // Now we want to run some code to see if the handler matches
398                                // This is the tricky part where we want to the power to run arbitrary code
399                                // However, generating a new exception table entry and try routine every time
400                                // is way more expansive than we might like
401                                // The information we have is :
402                                //  - The GR (Series of registers)
403                                //    GR1=GP Global Pointer of frame ref by context
404                                //  - The instruction pointer
405                                //  - The instruction pointer info (???)
406                                //  - The CFA (Canonical Frame Address)
407                                //  - The BSP (Probably the base stack pointer)
408
409                                // The current apprach uses one exception table entry per try block
410                                _uleb128_t imatcher;
411                                // Get the relative offset to the {...}?
412                                cur_ptr = read_uleb128(cur_ptr, &imatcher);
413
414                                _Unwind_Word match_pos =
415#                               if defined( __x86_64 )
416                                    _Unwind_GetCFA(unwind_context) + 8;
417#                               elif defined( __i386 )
418                                    _Unwind_GetCFA(unwind_context) + 24;
419#                               elif defined( __ARM_ARCH )
420#                                   warning FIX ME: check if anything needed for ARM
421                                    42;
422#                               endif
423                                int (*matcher)(exception_t *) = *(int(**)(exception_t *))match_pos;
424
425                                int index = matcher(context->current_exception);
426                                _Unwind_Reason_Code ret = (0 == index)
427                                        ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
428                                context->current_handler_index = index;
429
430                                // Based on the return value, check if we matched the exception
431                                if (ret == _URC_HANDLER_FOUND) {
432                                        __cfadbg_print_safe(exception, " handler found\n");
433                                } else {
434                                        __cfadbg_print_safe(exception, " no handler\n");
435                                }
436                                return ret;
437                        }
438
439                        // This is only a cleanup handler, ignore it
440                        __cfadbg_print_safe(exception, " no action");
441                } else {
442                        // In clean-up phase, no destructors here but this could be the handler.
443
444                        if ( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){
445                                // If this is a potential exception handler
446                                // but not the one that matched the exception in the seach phase,
447                                // just ignore it
448                                goto UNWIND;
449                        }
450
451                        // We need to run some clean-up or a handler
452                        // These statment do the right thing but I don't know any specifics at all
453                        _Unwind_SetGR( unwind_context, __builtin_eh_return_data_regno(0),
454                                (_Unwind_Ptr)unwind_exception );
455                        _Unwind_SetGR( unwind_context, __builtin_eh_return_data_regno(1), 0 );
456
457                        // I assume this sets the instruction pointer to the adress of the landing pad
458                        // It doesn't actually set it, it only state the value that needs to be set once we
459                        // return _URC_INSTALL_CONTEXT
460                        _Unwind_SetIP( unwind_context, ((lsd_info.LPStart) + (callsite_landing_pad)) );
461
462                        __cfadbg_print_safe(exception, " action\n");
463
464                        // Return have some action to run
465                        return _URC_INSTALL_CONTEXT;
466                }
467        }
468        // No handling found
469        __cfadbg_print_safe(exception, " table end reached");
470
471        UNWIND:
472        __cfadbg_print_safe(exception, " unwind\n");
473
474        // Keep unwinding the stack
475        return _URC_CONTINUE_UNWIND;
476}
477
478#pragma GCC push_options
479#pragma GCC optimize(0)
480
481// Try statements are hoisted out see comments for details. While this could probably be unique
482// and simply linked from libcfa but there is one problem left, see the exception table for details
483__attribute__((noinline))
484void __cfaehm_try_terminate(void (*try_block)(),
485                void (*catch_block)(int index, exception_t * except),
486                __attribute__((unused)) int (*match_block)(exception_t * except)) {
487        //! volatile int xy = 0;
488        //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
489
490        // Setup the personality routine and exception table.
491        // Unforturnately these clobber gcc cancellation support which means we can't get access to
492        // the attribute cleanup tables at the same time. We would have to inspect the assembly to
493        // create a new set ourselves.
494#ifdef __PIC__
495        asm volatile (".cfi_personality 0x9b,CFA.ref.__gcfa_personality_v0");
496        asm volatile (".cfi_lsda 0x1b, .LLSDACFA2");
497#else
498        asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
499        asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
500#endif
501
502        // Label which defines the start of the area for which the handler is setup.
503        asm volatile (".TRYSTART:");
504
505        // The actual statements of the try blocks
506        try_block();
507
508        // asm statement to prevent deadcode removal
509        asm volatile goto ("" : : : : CATCH );
510
511        // Normal return for when there is no throw.
512        return;
513
514        // Exceptionnal path
515        CATCH : __attribute__(( unused ));
516        // Label which defines the end of the area for which the handler is setup.
517        asm volatile (".TRYEND:");
518        // Label which defines the start of the exception landing pad. Basically what is called when
519        // the exception is caught. Note, if multiple handlers are given, the multiplexing should be
520        // done by the generated code, not the exception runtime.
521        asm volatile (".CATCH:");
522
523        // Exception handler
524        // Note: Saving the exception context on the stack breaks termination exceptions.
525        catch_block( this_exception_context()->current_handler_index,
526                     this_exception_context()->current_exception );
527}
528
529// Exception table data we need to generate. While this is almost generic, the custom data refers
530// to {*}try_terminate, which is no way generic. Some more works need to be done if we want to
531// have a single call to the try routine.
532
533#ifdef __PIC__
534asm (
535        // HEADER
536        ".LFECFA1:\n"
537        "       .globl  __gcfa_personality_v0\n"
538        "       .section        .gcc_except_table,\"a\",@progbits\n"
539        // TABLE HEADER (important field is the BODY length at the end)
540        ".LLSDACFA2:\n"
541        "       .byte   0xff\n"
542        "       .byte   0xff\n"
543        "       .byte   0x1\n"
544        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
545        // BODY (language specific data)
546        // This uses language specific data and can be modified arbitrarily
547        // We use handled area offset, handled area length,
548        // handler landing pad offset and 1 (action code, gcc seems to use 0).
549        ".LLSDACSBCFA2:\n"
550        "       .uleb128 .TRYSTART-__cfaehm_try_terminate\n"
551        "       .uleb128 .TRYEND-.TRYSTART\n"
552        "       .uleb128 .CATCH-__cfaehm_try_terminate\n"
553        "       .uleb128 1\n"
554        ".LLSDACSECFA2:\n"
555        // TABLE FOOTER
556        "       .text\n"
557        "       .size   __cfaehm_try_terminate, .-__cfaehm_try_terminate\n"
558);
559
560// Somehow this piece of helps with the resolution of debug symbols.
561__attribute__((unused)) static const int dummy = 0;
562
563asm (
564        // Add a hidden symbol which points at the function.
565        "       .hidden CFA.ref.__gcfa_personality_v0\n"
566        "       .weak   CFA.ref.__gcfa_personality_v0\n"
567        // No clue what this does specifically
568        "       .section        .data.rel.local.CFA.ref.__gcfa_personality_v0,\"awG\",@progbits,CFA.ref.__gcfa_personality_v0,comdat\n"
569        "       .align 8\n"
570        "       .type CFA.ref.__gcfa_personality_v0, @object\n"
571        "       .size CFA.ref.__gcfa_personality_v0, 8\n"
572        "CFA.ref.__gcfa_personality_v0:\n"
573#if defined( __x86_64 )
574        "       .quad __gcfa_personality_v0\n"
575#else // then __i386
576        "       .long __gcfa_personality_v0\n"
577#endif
578);
579#else // __PIC__
580asm (
581        // HEADER
582        ".LFECFA1:\n"
583        "       .globl  __gcfa_personality_v0\n"
584        "       .section        .gcc_except_table,\"a\",@progbits\n"
585        // TABLE HEADER (important field is the BODY length at the end)
586        ".LLSDACFA2:\n"
587        "       .byte   0xff\n"
588        "       .byte   0xff\n"
589        "       .byte   0x1\n"
590        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"
591        // BODY (language specific data)
592        ".LLSDACSBCFA2:\n"
593        //      Handled area start (relative to start of function)
594        "       .uleb128 .TRYSTART-__cfaehm_try_terminate\n"
595        //      Handled area length
596        "       .uleb128 .TRYEND-.TRYSTART\n"
597        //      Handler landing pad address (relative to start of function)
598        "       .uleb128 .CATCH-__cfaehm_try_terminate\n"
599        //      Action code, gcc seems to always use 0.
600        "       .uleb128 1\n"
601        // TABLE FOOTER
602        ".LLSDACSECFA2:\n"
603        "       .text\n"
604        "       .size   __cfaehm_try_terminate, .-__cfaehm_try_terminate\n"
605        "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
606        "       .section        .note.GNU-stack,\"x\",@progbits\n"
607);
608#endif // __PIC__
609
610#pragma GCC pop_options
611#endif // 0
Note: See TracBrowser for help on using the repository browser.