source: doc/working/exception/impl/exception.c @ e4e9173

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since e4e9173 was e4e9173, checked in by Andrew Beach <ajbeach@…>, 4 years ago

Wrote out more tests for the new exception.h/c files.

  • Property mode set to 100644
File size: 12.2 KB
Line 
1#include "exception.h"
2
3// Implementation of the secret header.
4
5#include <stdlib.h>
6#include <stdio.h>
7#include <unwind.h>
8
9#include "lsda.h"
10
11struct shared_stack_t shared_stack;
12
13
14// This macro should be the only thing that needs to change across machines.
15// Used in the personality function, way down in termination.
16// struct _Unwind_Context * -> _Unwind_Reason_Code(*)()
17#define MATCHER_FROM_CONTEXT(ptr_to_context) \
18        (*(_Unwind_Reason_Code(**)())(_Unwind_GetCFA(ptr_to_context) + 8))
19
20
21// RESUMPTION ================================================================
22
23void __throw_resume(exception except) {
24
25        // DEBUG
26        printf("Throwing resumption exception %d\n", except);
27
28        struct __try_resume_node * original_head = shared_stack.current_resume;
29        struct __try_resume_node * current =
30                (original_head) ? original_head->next : shared_stack.top_resume;
31
32        for ( ; current ; current = current->next) {
33                shared_stack.current_resume = current;
34                if (current->try_to_handle(except)) {
35                        shared_stack.current_resume = original_head;
36                        return;
37                }
38        }
39
40        printf("Unhandled exception %d\n", except);
41        shared_stack.current_resume = original_head;
42
43        // Fall back to termination:
44        __throw_terminate(except);
45        // TODO: Default handler for resumption.
46}
47
48
49// TERMINATION ===============================================================
50
51// Requires -fexceptions to work.
52
53// Global which defines the current exception
54// Currently an int just to make matching easier
55//int this_exception; (became shared_stack.current_exception)
56
57// We need a piece of storage to raise the exception
58struct _Unwind_Exception this_exception_storage;
59
60// Function needed by force unwind
61// It basically says to unwind the whole stack and then exit when we reach the end of the stack
62static _Unwind_Reason_Code _Stop_Fn(
63                int version,
64                _Unwind_Action actions,
65                _Unwind_Exception_Class exceptionClass,
66                struct _Unwind_Exception * unwind_exception,
67                struct _Unwind_Context * context,
68                void * some_param) {
69        if( actions & _UA_END_OF_STACK  ) exit(1);
70        if( actions & _UA_CLEANUP_PHASE ) return _URC_NO_REASON;
71
72        return _URC_FATAL_PHASE2_ERROR;
73}
74
75// Example throw routine
76void __throw_terminate( int val ) {
77        // Store the current exception
78        shared_stack.current_exception = val;
79
80        // DEBUG
81        printf("Throwing termination exception %d\n", val);
82
83        // Call stdlibc to raise the exception
84        _Unwind_Reason_Code ret = _Unwind_RaiseException( &this_exception_storage );
85
86        // If we reach here it means something happened
87        // For resumption to work we need to find a way to return back to here
88        // Most of them will probably boil down to setting a global flag and making the phase 1 either stop or fail.
89        // Causing an error on purpose may help avoiding unnecessary work but it might have some weird side effects.
90        // If we just pretend no handler was found that would work but may be expensive for no reason since we will always
91        // search the whole stack
92
93        if( ret == _URC_END_OF_STACK ) {
94                // No proper handler was found
95                // This can be handled in several way
96                // C++ calls std::terminate
97                // Here we force unwind the stack, basically raising a cancellation
98                printf("Uncaught exception %p\n", &this_exception_storage);
99
100                ret = _Unwind_ForcedUnwind( &this_exception_storage, _Stop_Fn, (void*)0x22 );
101                printf("UNWIND ERROR %d after force unwind\n", ret);
102                abort();
103        }
104
105        // We did not simply reach the end of the stack without finding a handler,
106        // Something wen't wrong
107        printf("UNWIND ERROR %d after raise exception\n", ret);
108        abort();
109}
110
111// This is our personality routine
112// For every stack frame anotated with ".cfi_personality 0x3,__gcfa_personality_v0"
113// This function will be called twice when unwinding
114// Once in the search phased and once in the cleanup phase
115_Unwind_Reason_Code __gcfa_personality_v0 (
116                int version, _Unwind_Action actions, unsigned long long exceptionClass,
117                struct _Unwind_Exception* unwind_exception,
118                struct _Unwind_Context* context)
119{
120
121        // DEBUG
122        //printf("CFA: 0x%lx\n", _Unwind_GetCFA(context));
123        printf("Personality function (%d, %x, %llu, %p, %p):", version, actions, exceptionClass, unwind_exception, context);
124
125        // If we've reached the end of the stack then there is nothing much we can do...
126        if( actions & _UA_END_OF_STACK ) return _URC_END_OF_STACK;
127
128        // DEBUG
129        if (actions & _UA_SEARCH_PHASE) {
130                printf(" lookup phase");
131        }
132        // DEBUG
133        else if (actions & _UA_CLEANUP_PHASE) {
134                printf(" cleanup phase");
135        }
136        // Just in case, probably can't actually happen
137        else {
138                printf(" error\n");
139                return _URC_FATAL_PHASE1_ERROR;
140        }
141
142        // Get a pointer to the language specific data from which we will read what we need
143        const unsigned char * lsd = (const unsigned char*) _Unwind_GetLanguageSpecificData( context );
144
145        if( !lsd ) {    //Nothing to do, keep unwinding
146                printf(" no LSD");
147                goto UNWIND;
148        }
149
150        // Get the instuction pointer and a reading pointer into the exception table
151        lsda_header_info lsd_info;
152        const unsigned char * cur_ptr = parse_lsda_header( context, lsd, &lsd_info);
153        _Unwind_Ptr instruction_ptr = _Unwind_GetIP( context );
154
155        // Linearly search the table for stuff to do
156        while( cur_ptr < lsd_info.action_table ) {
157                _Unwind_Ptr callsite_start;
158                _Unwind_Ptr callsite_len;
159                _Unwind_Ptr callsite_landing_pad;
160                _uleb128_t  callsite_action;
161
162                // Decode the common stuff we have in here
163                cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_start);
164                cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_len);
165                cur_ptr = read_encoded_value (0, lsd_info.call_site_encoding, cur_ptr, &callsite_landing_pad);
166                cur_ptr = read_uleb128 (cur_ptr, &callsite_action);
167
168                // Have we reach the correct frame info yet?
169                if( lsd_info.Start + callsite_start + callsite_len < instruction_ptr ) {
170                        //DEBUG BEGIN
171                        void * ls = (void*)lsd_info.Start;
172                        void * cs = (void*)callsite_start;
173                        void * cl = (void*)callsite_len;
174                        void * bp = (void*)lsd_info.Start + callsite_start;
175                        void * ep = (void*)lsd_info.Start + callsite_start + callsite_len;
176                        void * ip = (void*)instruction_ptr;
177                        printf("\nfound %p - %p (%p, %p, %p), looking for %p\n", bp, ep, ls, cs, cl, ip);
178                        //DEBUG END
179                        continue;
180                }
181
182                // Have we gone too far
183                if( lsd_info.Start + callsite_start > instruction_ptr ) {
184                        printf(" gone too far");
185                        break;
186                }
187
188                // Something to do?
189                if( callsite_landing_pad ) {
190                        // Which phase are we in
191                        if (actions & _UA_SEARCH_PHASE) {
192                                // Search phase, this means we probably found a potential handler and must check if it is a match
193
194                                // If we have arbitrarily decided that 0 means nothing to do and 1 means there is a potential handler
195                                // This doesn't seem to conflict the gcc default behavior
196                                if (callsite_action != 0) {
197                                        // Now we want to run some code to see if the handler matches
198                                        // This is the tricky part where we want to the power to run arbitrary code
199                                        // However, generating a new exception table entry and try routine every time
200                                        // is way more expansive than we might like
201                                        // The information we have is :
202                                        //  - The GR (Series of registers)
203                                        //    GR1=GP Global Pointer of frame ref by context
204                                        //  - The instruction pointer
205                                        //  - The instruction pointer info (???)
206                                        //  - The CFA (Canonical Frame Address)
207                                        //  - The BSP (Probably the base stack pointer)
208
209
210                                        // The current apprach uses one exception table entry per try block
211                                        _uleb128_t imatcher;
212                                        // Get the relative offset to the
213                                        cur_ptr = read_uleb128 (cur_ptr, &imatcher);
214
215                                        // Get a function pointer from the relative offset and call it
216                                        // _Unwind_Reason_Code (*matcher)() = (_Unwind_Reason_Code (*)())lsd_info.LPStart + imatcher;                                   
217
218                                        _Unwind_Reason_Code (*matcher)() =
219                                                MATCHER_FROM_CONTEXT(context);
220                                        int index = matcher(shared_stack.current_exception);
221                                        _Unwind_Reason_Code ret = (0 == index)
222                                                ? _URC_CONTINUE_UNWIND : _URC_HANDLER_FOUND;
223                                        shared_stack.current_handler_index = index;
224
225
226                                        // Based on the return value, check if we matched the exception
227                                        if( ret == _URC_HANDLER_FOUND) printf(" handler found\n");
228                                        else printf(" no handler\n");
229                                        return ret;
230                                }
231
232                                // This is only a cleanup handler, ignore it
233                                printf(" no action");
234                        }
235                        else if (actions & _UA_CLEANUP_PHASE) {
236
237                                if( (callsite_action != 0) && !(actions & _UA_HANDLER_FRAME) ){
238                                        // If this is a potential exception handler
239                                        // but not the one that matched the exception in the seach phase,
240                                        // just ignore it
241                                        goto UNWIND;
242                                }
243
244                                // We need to run some clean-up or a handler
245                                // These statment do the right thing but I don't know any specifics at all
246                                _Unwind_SetGR( context, __builtin_eh_return_data_regno(0), (_Unwind_Ptr) unwind_exception );
247                                _Unwind_SetGR( context, __builtin_eh_return_data_regno(1), 0 );
248
249                                // I assume this sets the instruction pointer to the adress of the landing pad
250                                // It doesn't actually set it, it only state the value that needs to be set once we return _URC_INSTALL_CONTEXT
251                                _Unwind_SetIP( context, lsd_info.LPStart + callsite_landing_pad );
252
253                                // DEBUG
254                                printf(" action\n");
255
256                                // Return have some action to run
257                                return _URC_INSTALL_CONTEXT;
258                        }
259                }
260
261                // Nothing to do, move along
262                printf(" no landing pad");
263        }
264        // No handling found
265        printf(" table end reached\n");
266
267        // DEBUG
268        UNWIND:
269        printf(" unwind\n");
270
271        // Keep unwinding the stack
272        return _URC_CONTINUE_UNWIND;
273}
274
275// Try statements are hoisted out see comments for details
276// With this could probably be unique and simply linked from
277// libcfa but there is one problem left, see the exception table
278// for details
279__attribute__((noinline))
280void __try_terminate(void (*try_block)(),
281                void (*catch_block)(int index, exception except),
282                __attribute__((unused)) int (*match_block)(exception except)) {
283        //! volatile int xy = 0;
284        //! printf("%p %p %p %p\n", &try_block, &catch_block, &match_block, &xy);
285
286        // Setup statments
287        // These 2 statments won't actually result in any code,
288        // they only setup global tables.
289        // However, they clobber gcc cancellation support from gcc.
290        // We can replace the personality routine but replacing the exception
291        // table gcc generates is not really doable, it generates labels based
292        // on how the assembly works.
293        // Setup the personality routine
294        asm volatile (".cfi_personality 0x3,__gcfa_personality_v0");
295        // Setup the exception table
296        asm volatile (".cfi_lsda 0x3, .LLSDACFA2");
297
298        // Label which defines the start of the area for which the handler is setup
299        asm volatile (".TRYSTART:");
300
301        // The actual statements of the try blocks
302        try_block();
303
304        // asm statement to prevent deadcode removal
305        asm volatile goto ("" : : : : CATCH );
306
307        // Normal return
308        return;
309
310        // Exceptionnal path
311        CATCH : __attribute__(( unused ));
312        // Label which defines the end of the area for which the handler is setup
313        asm volatile (".TRYEND:");
314        // Label which defines the start of the exception landing pad
315        // basically what will be called when the exception is caught
316        // Note, if multiple handlers are given, the multiplexing should be done
317        // by the generated code, not the exception runtime
318        asm volatile (".CATCH:");
319
320        // Exception handler
321        catch_block(shared_stack.current_handler_index,
322                    shared_stack.current_exception);
323}
324
325// Exception table data we need to generate
326// While this is almost generic, the custom data refers to
327// foo_try_match try match, which is no way generic
328// Some more works need to be done if we want to have a single
329// call to the try routine
330asm (
331        //HEADER
332        ".LFECFA1:\n"
333        "       .globl  __gcfa_personality_v0\n"
334        "       .section        .gcc_except_table,\"a\",@progbits\n"
335        ".LLSDACFA2:\n"                                                 //TABLE header
336        "       .byte   0xff\n"
337        "       .byte   0xff\n"
338        "       .byte   0x1\n"
339        "       .uleb128 .LLSDACSECFA2-.LLSDACSBCFA2\n"         // BODY length
340        // Body uses language specific data and therefore could be modified arbitrarily
341        ".LLSDACSBCFA2:\n"                                              // BODY start
342        "       .uleb128 .TRYSTART-__try_terminate\n"           // Handled area start  (relative to start of function)
343        "       .uleb128 .TRYEND-.TRYSTART\n"                           // Handled area length
344        "       .uleb128 .CATCH-__try_terminate\n"                              // Hanlder landing pad adress  (relative to start of function)
345        "       .uleb128 1\n"                                           // Action code, gcc seems to use always 0
346        ".LLSDACSECFA2:\n"                                              // BODY end
347        "       .text\n"                                                        // TABLE footer
348        "       .size   __try_terminate, .-__try_terminate\n"
349        "       .ident  \"GCC: (Ubuntu 6.2.0-3ubuntu11~16.04) 6.2.0 20160901\"\n"
350//      "       .section        .note.GNU-stack,\"x\",@progbits\n"
351);
Note: See TracBrowser for help on using the repository browser.