source: src/ControlStruct/ExceptTranslate.cc @ 86d5ba7c

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

Added the memory management calls to the exception control flow.

  • Property mode set to 100644
File size: 20.4 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 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// ExceptVisitor.cc --
8//
9// Author           : Andrew Beach
10// Created On       : Wed Jun 14 16:49:00 2017
11// Last Modified By : Andrew Beach
12// Last Modified On : Fri Jul 28 14:03:00 2017
13// Update Count     : 5
14//
15
16#include "ExceptTranslate.h"
17#include "Common/PassVisitor.h"
18#include "SynTree/Statement.h"
19#include "SynTree/Declaration.h"
20#include "SynTree/Expression.h"
21#include "SynTree/Type.h"
22#include "SynTree/Attribute.h"
23#include "SynTree/VarExprReplacer.h"
24
25namespace ControlStruct {
26
27        // void (*function)();
28        static FunctionType try_func_t(noQualifiers, false);
29        // void (*function)(int, exception);
30        static FunctionType catch_func_t(noQualifiers, false);
31        // int (*function)(exception);
32        static FunctionType match_func_t(noQualifiers, false);
33        // bool (*function)(exception);
34        static FunctionType handle_func_t(noQualifiers, false);
35        // void (*function)(__attribute__((unused)) void *);
36        static FunctionType finally_func_t(noQualifiers, false);
37
38        static void init_func_types() {
39                static bool init_complete = false;
40                if (init_complete) {
41                        return;
42                }
43                ObjectDecl index_obj(
44                        "__handler_index",
45                        Type::StorageClasses(),
46                        LinkageSpec::Cforall,
47                        /*bitfieldWidth*/ NULL,
48                        new BasicType( noQualifiers, BasicType::SignedInt ),
49                        /*init*/ NULL
50                        );
51                ObjectDecl exception_obj(
52                        "__exception_inst",
53                        Type::StorageClasses(),
54                        LinkageSpec::Cforall,
55                        /*bitfieldWidth*/ NULL,
56                        new PointerType(
57                                noQualifiers,
58                                new BasicType( noQualifiers, BasicType::SignedInt )
59                                ),
60                        /*init*/ NULL
61                        );
62                ObjectDecl bool_obj(
63                        "__ret_bool",
64                        Type::StorageClasses(),
65                        LinkageSpec::Cforall,
66                        /*bitfieldWidth*/ NULL,
67                        new BasicType(noQualifiers, BasicType::Bool),
68                        /*init*/ NULL
69                        );
70                ObjectDecl voidptr_obj(
71                        "__hook",
72                        Type::StorageClasses(),
73                        LinkageSpec::Cforall,
74                        NULL,
75                        new PointerType(
76                                noQualifiers,
77                                new VoidType(
78                                        noQualifiers
79                                        ),
80                                std::list<Attribute *>{new Attribute("unused")}
81                                ),
82                        NULL
83                        );
84
85                catch_func_t.get_parameters().push_back( index_obj.clone() );
86                catch_func_t.get_parameters().push_back( exception_obj.clone() );
87                match_func_t.get_returnVals().push_back( index_obj.clone() );
88                match_func_t.get_parameters().push_back( exception_obj.clone() );
89                handle_func_t.get_returnVals().push_back( bool_obj.clone() );
90                handle_func_t.get_parameters().push_back( exception_obj.clone() );
91                finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
92
93                init_complete = true;
94        }
95
96        // Buricratic Helpers (Not having to do with the paritular operation.)
97
98        typedef std::list<CatchStmt*> CatchList;
99
100        void split( CatchList& allHandlers, CatchList& terHandlers,
101                                CatchList& resHandlers ) {
102                while ( !allHandlers.empty() ) {
103                        CatchStmt * stmt = allHandlers.front();
104                        allHandlers.pop_front();
105                        if (CatchStmt::Terminate == stmt->get_kind()) {
106                                terHandlers.push_back(stmt);
107                        } else {
108                                resHandlers.push_back(stmt);
109                        }
110                }
111        }
112
113        void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
114                block->push_back(new DeclStmt(noLabels, item));
115        }
116
117        Expression * nameOf( DeclarationWithType * decl ) {
118                return new VariableExpr( decl );
119        }
120
121        // ThrowStmt Mutation Helpers
122
123        Statement * create_given_throw(
124                        const char * throwFunc, ThrowStmt * throwStmt ) {
125                // There is an extra copy here we might be able to remove with
126                // references.
127                // { int NAME = EXPR; throwFunc( &NAME ); }
128                CompoundStmt * result = new CompoundStmt( noLabels );
129                ObjectDecl * local = new ObjectDecl(
130                        "__local_exception_copy",
131                        Type::StorageClasses(),
132                        LinkageSpec::Cforall,
133                        NULL,
134                        new BasicType( noQualifiers, BasicType::SignedInt ),
135                        new SingleInit( throwStmt->get_expr() )
136                        );
137                appendDeclStmt( result, local );
138                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
139                call->get_args().push_back( new AddressExpr( nameOf( local ) ) );
140                result->push_back( new ExprStmt( throwStmt->get_labels(), call ) );
141                throwStmt->set_expr( nullptr );
142                delete throwStmt;
143                return result;
144        }
145
146        Statement * create_terminate_throw( ThrowStmt *throwStmt ) {
147                // { int NAME = EXPR; __throw_terminate( &NAME ); }
148                return create_given_throw( "__cfaehm__throw_terminate", throwStmt );
149        }
150
151        Statement * create_terminate_rethrow( ThrowStmt *throwStmt,
152                        ObjectDecl *handler_except_decl ) {
153                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
154                assert( nullptr == throwStmt->get_expr() );
155                assert( handler_except_decl );
156
157                CompoundStmt * result = new CompoundStmt( throwStmt->get_labels() );
158                result->push_back( new ExprStmt( noLabels, UntypedExpr::createAssign(
159                        nameOf( handler_except_decl ),
160                        new ConstantExpr( Constant::null(
161                                new PointerType(
162                                        noQualifiers,
163                                        handler_except_decl->get_type()->clone()
164                                        )
165                                ) )
166                        ) ) );
167                result->push_back( new ExprStmt(
168                        noLabels,
169                        new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
170                        ) );
171                delete throwStmt;
172                return result;
173        }
174
175        Statement * create_resume_throw( ThrowStmt *throwStmt ) {
176                // __throw_resume( EXPR );
177                return create_given_throw( "__cfaehm__throw_resume", throwStmt );
178        }
179
180        Statement * create_resume_rethrow( ThrowStmt *throwStmt ) {
181                // return false;
182                Statement * result = new ReturnStmt(
183                        throwStmt->get_labels(),
184                        new ConstantExpr( Constant::from_bool( false ) )
185                        );
186                delete throwStmt;
187                return result;
188        }
189
190        // TryStmt Mutation Helpers
191
192        CompoundStmt * take_try_block( TryStmt *tryStmt ) {
193                CompoundStmt * block = tryStmt->get_block();
194                tryStmt->set_block( nullptr );
195                return block;
196        }
197        FunctionDecl * create_try_wrapper( CompoundStmt *body ) {
198
199                return new FunctionDecl( "try", Type::StorageClasses(),
200                        LinkageSpec::Cforall, try_func_t.clone(), body );
201        }
202
203        FunctionDecl * create_terminate_catch( CatchList &handlers ) {
204                std::list<CaseStmt *> handler_wrappers;
205
206                FunctionType *func_type = catch_func_t.clone();
207                DeclarationWithType * index_obj = func_type->get_parameters().front();
208                DeclarationWithType * except_obj = func_type->get_parameters().back();
209
210                // Index 1..{number of handlers}
211                int index = 0;
212                CatchList::iterator it = handlers.begin();
213                for ( ; it != handlers.end() ; ++it ) {
214                        ++index;
215                        CatchStmt * handler = *it;
216
217                        // INTEGERconstant Version
218                        // case `index`:
219                        // {
220                        //     `handler.decl` {inserted} = { except_obj };
221                        //     `handler.body`
222                        // }
223                        // return;
224                        CompoundStmt * block = new CompoundStmt( noLabels );
225
226                        // Just copy the exception value.
227                        // TODO: Or just store an ObjectDecl?
228                        ObjectDecl * handler_decl =
229                                dynamic_cast<ObjectDecl*>( handler->get_decl() );
230                        assert( handler_decl );
231                        ObjectDecl * local_except = handler_decl->clone();
232                        local_except->set_init(
233                                new ListInit({ new SingleInit( nameOf( except_obj ) ) }) );
234#if 0
235                        // Virtual Exception Vision
236                        // case `index`:
237                        // {
238                        //     `handler.decl` = { (virtual `decl.type`)`except` };
239                        //     `handler.body`;
240                        // }
241                        // return;
242
243                        // Save a cast copy of the exception (should always succeed).
244                        ObjectDecl * local_except = handler->get_decl()->clone();
245                        local_except.set_init(
246                                new ListInit({ new SingleInit(
247                                        new VirtualCastExpr( nameOf( except_obj ),
248                                                local_except->get_type()
249                                                )
250                                        ) }) );
251#endif
252                        block->push_back( new DeclStmt( noLabels, local_except ) );
253
254                        // Add the cleanup attribute.
255                        local_except->get_attributes().push_back( new Attribute(
256                                "cleanup",
257                                { new NameExpr( "__cfaehm__cleanup_terminate" ) }
258                                ) );
259
260                        // Update variables in the body to point to this local copy.
261                        {
262                                VarExprReplacer::DeclMap mapping;
263                                mapping[ handler_decl ] = local_except;
264                                VarExprReplacer mapper( mapping );
265                                handler->get_body()->accept( mapper );
266                        }
267
268                        block->push_back( handler->get_body() );
269                        handler->set_body( nullptr );
270
271                        std::list<Statement *> caseBody
272                                        { block, new ReturnStmt( noLabels, nullptr ) };
273                        handler_wrappers.push_back( new CaseStmt(
274                                noLabels,
275                                new ConstantExpr( Constant::from_int( index ) ),
276                                caseBody
277                                ) );
278                }
279                // TODO: Some sort of meaningful error on default perhaps?
280
281                std::list<Statement*> stmt_handlers;
282                while ( !handler_wrappers.empty() ) {
283                        stmt_handlers.push_back( handler_wrappers.front() );
284                        handler_wrappers.pop_front();
285                }
286
287                SwitchStmt * handler_lookup = new SwitchStmt(
288                        noLabels,
289                        nameOf( index_obj ),
290                        stmt_handlers
291                        );
292                CompoundStmt * body = new CompoundStmt( noLabels );
293                body->push_back( handler_lookup );
294
295                return new FunctionDecl("catch", Type::StorageClasses(),
296                        LinkageSpec::Cforall, func_type, body);
297        }
298
299        // Create a single check from a moddified handler.
300        // except_obj is referenced, modded_handler will be freed.
301        CompoundStmt *create_single_matcher(
302                        DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
303                CompoundStmt * block = new CompoundStmt( noLabels );
304
305                ObjectDecl * local_except =
306                        dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
307                assert( local_except );
308                block->push_back( new DeclStmt( noLabels, local_except ) );
309#if 0
310                // Virtual Exception Version
311                // {
312                //     `modded_handler.decl`
313                //     if ( `decl.name = (virtual)`except`
314                //             [&& `modded_handler.cond`] ) {
315                //         `modded_handler.body`
316                //     }
317                // }
318
319                // Check for type match.
320                Expression * cond = UntypedExpr::createAssign( nameOf( local_except ),
321                        new VirtualCastExpr( nameOf( except_obj ),
322                                local_except->get_type()->clone() ) );
323#endif
324
325                // INTEGERconstant Version
326                // {
327                //     `modded_handler.decl` = *`except`
328                //     if ( `decl.name` == `modded_handler.cond` ) {
329                //         `modded_handler.body`
330                //     }
331                // }
332                ConstantExpr * number =
333                        dynamic_cast<ConstantExpr*>( modded_handler->get_cond() );
334                assert( number );
335                modded_handler->set_cond( nullptr );
336
337                Expression * cond;
338                {
339                        std::list<Expression *> args;
340                        args.push_back( number );
341
342                        std::list<Expression *> rhs_args;
343                        rhs_args.push_back( nameOf( except_obj ) );
344                        Expression * rhs = new UntypedExpr(
345                                new NameExpr( "*?" ), rhs_args );
346                        args.push_back( rhs );
347
348                        cond = new UntypedExpr( new NameExpr( "?==?" /*???*/), args );
349                }
350
351                // Add the check on the conditional if it is provided.
352                if ( modded_handler->get_cond() ) {
353                        cond = new LogicalExpr( cond, modded_handler->get_cond() );
354                }
355                // Construct the match condition.
356                block->push_back( new IfStmt( noLabels,
357                        cond, modded_handler->get_body(), nullptr ) );
358
359                modded_handler->set_decl( nullptr );
360                modded_handler->set_cond( nullptr );
361                modded_handler->set_body( nullptr );
362                delete modded_handler;
363                return block;
364        }
365
366        FunctionDecl * create_terminate_match( CatchList &handlers ) {
367                // int match(exception * except) {
368                //     HANDLER WRAPPERS { return `index`; }
369                // }
370
371                CompoundStmt * body = new CompoundStmt( noLabels );
372
373                FunctionType * func_type = match_func_t.clone();
374                DeclarationWithType * except_obj = func_type->get_parameters().back();
375
376                // Index 1..{number of handlers}
377                int index = 0;
378                CatchList::iterator it;
379                for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
380                        ++index;
381                        CatchStmt * handler = *it;
382
383                        // Body should have been taken by create_terminate_catch.
384                        assert( nullptr == handler->get_body() );
385
386                        // Create new body.
387                        handler->set_body( new ReturnStmt( noLabels,
388                                new ConstantExpr( Constant::from_int( index ) ) ) );
389
390                        // Create the handler.
391                        body->push_back( create_single_matcher( except_obj, handler ) );
392                        *it = nullptr;
393                }
394
395                body->push_back( new ReturnStmt( noLabels, new ConstantExpr(
396                        Constant::from_int( 0 ) ) ) );
397
398                return new FunctionDecl("match", Type::StorageClasses(),
399                        LinkageSpec::Cforall, func_type, body);
400        }
401
402        CompoundStmt * create_terminate_caller(
403                        FunctionDecl * try_wrapper,
404                        FunctionDecl * terminate_catch,
405                        FunctionDecl * terminate_match) {
406                // { __cfaehm__try_terminate(`try`, `catch`, `match`); }
407
408                UntypedExpr * caller = new UntypedExpr( new NameExpr(
409                        "__cfaehm__try_terminate" ) );
410                std::list<Expression *>& args = caller->get_args();
411                args.push_back( nameOf( try_wrapper ) );
412                args.push_back( nameOf( terminate_catch ) );
413                args.push_back( nameOf( terminate_match ) );
414
415                CompoundStmt * callStmt = new CompoundStmt( noLabels );
416                callStmt->push_back( new ExprStmt( noLabels, caller ) );
417                return callStmt;
418        }
419
420        FunctionDecl * create_resume_handler( CatchList &handlers ) {
421                // bool handle(exception * except) {
422                //     HANDLER WRAPPERS { `hander->body`; return true; }
423                // }
424                CompoundStmt * body = new CompoundStmt( noLabels );
425
426                FunctionType * func_type = match_func_t.clone();
427                DeclarationWithType * except_obj = func_type->get_parameters().back();
428
429                CatchList::iterator it;
430                for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
431                        CatchStmt * handler = *it;
432
433                        // Modifiy body.
434                        CompoundStmt * handling_code =
435                                dynamic_cast<CompoundStmt*>( handler->get_body() );
436                        if ( ! handling_code ) {
437                                handling_code = new CompoundStmt( noLabels );
438                                handling_code->push_back( handler->get_body() );
439                        }
440                        handling_code->push_back( new ReturnStmt( noLabels,
441                                new ConstantExpr( Constant::from_bool( true ) ) ) );
442                        handler->set_body( handling_code );
443
444                        // Create the handler.
445                        body->push_back( create_single_matcher( except_obj, handler ) );
446                        *it = nullptr;
447                }
448
449                body->push_back( new ReturnStmt( noLabels, new ConstantExpr(
450                        Constant::from_bool( false ) ) ) );
451
452                return new FunctionDecl("handle", Type::StorageClasses(),
453                        LinkageSpec::Cforall, func_type, body);
454        }
455
456        CompoundStmt * create_resume_wrapper(
457                        StructDecl * node_decl,
458                        Statement * wraps,
459                        FunctionDecl * resume_handler ) {
460                CompoundStmt * body = new CompoundStmt( noLabels );
461
462                // struct __try_resume_node __resume_node
463                //      __attribute__((cleanup( __cfaehm__try_resume_cleanup )));
464                // ** unwinding of the stack here could cause problems **
465                // ** however I don't think that can happen currently **
466                // __cfaehm__try_resume_setup( &__resume_node, resume_handler );
467
468                std::list< Attribute * > attributes;
469                {
470                        std::list< Expression * > attr_params;
471                        attr_params.push_back( new NameExpr(
472                                "__cfaehm__try_resume_cleanup" ) );
473                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
474                }
475
476                ObjectDecl * obj = new ObjectDecl(
477                        "__resume_node",
478                        Type::StorageClasses(),
479                        LinkageSpec::Cforall,
480                        nullptr,
481                        new StructInstType(
482                                Type::Qualifiers(),
483                                node_decl
484                                ),
485                        nullptr,
486                        attributes
487                        );
488                appendDeclStmt( body, obj );
489
490                UntypedExpr *setup = new UntypedExpr( new NameExpr(
491                        "__cfaehm__try_resume_setup" ) );
492                setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
493                setup->get_args().push_back( nameOf( resume_handler ) );
494
495                body->push_back( new ExprStmt( noLabels, setup ) );
496
497                body->push_back( wraps );
498                return body;
499        }
500
501        FunctionDecl * create_finally_wrapper( TryStmt * tryStmt ) {
502                // void finally() { <finally code> }
503                FinallyStmt * finally = tryStmt->get_finally();
504                CompoundStmt * body = finally->get_block();
505                finally->set_block( nullptr );
506                delete finally;
507                tryStmt->set_finally( nullptr );
508
509                return new FunctionDecl("finally", Type::StorageClasses(),
510                        LinkageSpec::Cforall, finally_func_t.clone(), body);
511        }
512
513        ObjectDecl * create_finally_hook(
514                        StructDecl * hook_decl, FunctionDecl * finally_wrapper ) {
515                // struct __cfaehm__cleanup_hook __finally_hook
516                //      __attribute__((cleanup( finally_wrapper )));
517
518                // Make Cleanup Attribute.
519                std::list< Attribute * > attributes;
520                {
521                        std::list< Expression * > attr_params;
522                        attr_params.push_back( nameOf( finally_wrapper ) );
523                        attributes.push_back( new Attribute( "cleanup", attr_params ) );
524                }
525
526                return new ObjectDecl(
527                        "__finally_hook",
528                        Type::StorageClasses(),
529                        LinkageSpec::Cforall,
530                        nullptr,
531                        new StructInstType(
532                                noQualifiers,
533                                hook_decl
534                                ),
535                        nullptr,
536                        attributes
537                        );
538        }
539
540
541        class ExceptionMutatorCore : public WithGuards {
542                enum Context { NoHandler, TerHandler, ResHandler };
543
544                // Also need to handle goto, break & continue.
545                // They need to be cut off in a ResHandler, until we enter another
546                // loop, switch or the goto stays within the function.
547
548                Context cur_context;
549
550                // The current (innermost) termination handler exception declaration.
551                ObjectDecl * handler_except_decl;
552
553                // We might not need this, but a unique base for each try block's
554                // generated functions might be nice.
555                //std::string curFunctionName;
556                //unsigned int try_count = 0;
557
558                StructDecl *node_decl;
559                StructDecl *hook_decl;
560
561        public:
562                ExceptionMutatorCore() :
563                        cur_context(NoHandler),
564                        handler_except_decl( nullptr ),
565                        node_decl( nullptr ), hook_decl( nullptr )
566                {}
567
568                void premutate( CatchStmt *catchStmt );
569                void premutate( StructDecl *structDecl );
570                Statement * postmutate( ThrowStmt *throwStmt );
571                Statement * postmutate( TryStmt *tryStmt );
572        };
573
574        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
575                // Currently, we make up the declaration, as there isn't one for
576                // integers.
577                ObjectDecl * tmp = new ObjectDecl(
578                        "_hidden_local",
579                        Type::StorageClasses(),
580                        LinkageSpec::Cforall,
581                        nullptr,
582                        new PointerType(
583                                noQualifiers,
584                                new BasicType( noQualifiers, BasicType::SignedInt )
585                                ),
586                        nullptr
587                        );
588                catchStmt->set_decl( tmp );
589
590                GuardValue( cur_context );
591                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
592                        cur_context = TerHandler;
593
594                        GuardValue( handler_except_decl );
595                        handler_except_decl = tmp;
596                        //handler_except_decl = catchStmt->get_decl();
597                } else {
598                        cur_context = ResHandler;
599                }
600        }
601
602        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
603                if ( !structDecl->has_body() ) {
604                        // Skip children?
605                        return;
606                } else if ( structDecl->get_name() == "__cfaehm__try_resume_node" ) {
607                        assert( nullptr == node_decl );
608                        node_decl = structDecl;
609                } else if ( structDecl->get_name() == "__cfaehm__cleanup_hook" ) {
610                        assert( nullptr == hook_decl );
611                        hook_decl = structDecl;
612                }
613                // Later we might get the exception type as well.
614        }
615
616        Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
617                // Ignoring throwStmt->get_target() for now.
618                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
619                        if ( throwStmt->get_expr() ) {
620                                return create_terminate_throw( throwStmt );
621                        } else if ( TerHandler == cur_context ) {
622                                return create_terminate_rethrow(
623                                        throwStmt, handler_except_decl );
624                        } else {
625                                assertf(false, "Invalid throw in %s at %i\n",
626                                        throwStmt->location.filename.c_str(),
627                                        throwStmt->location.linenumber);
628                                return nullptr;
629                        }
630                } else {
631                        if ( throwStmt->get_expr() ) {
632                                return create_resume_throw( throwStmt );
633                        } else if ( ResHandler == cur_context ) {
634                                return create_resume_rethrow( throwStmt );
635                        } else {
636                                assertf(false, "Invalid throwResume in %s at %i\n",
637                                        throwStmt->location.filename.c_str(),
638                                        throwStmt->location.linenumber);
639                                return nullptr;
640                        }
641                }
642        }
643
644        Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
645                assert( node_decl );
646                assert( hook_decl );
647
648                // Generate a prefix for the function names?
649
650                CompoundStmt * block = new CompoundStmt( noLabels );
651                CompoundStmt * inner = take_try_block( tryStmt );
652
653                if ( tryStmt->get_finally() ) {
654                        // Define the helper function.
655                        FunctionDecl * finally_block =
656                                create_finally_wrapper( tryStmt );
657                        appendDeclStmt( block, finally_block );
658                        // Create and add the finally cleanup hook.
659                        appendDeclStmt( block,
660                                create_finally_hook( hook_decl, finally_block ) );
661                }
662
663                CatchList termination_handlers;
664                CatchList resumption_handlers;
665                split( tryStmt->get_catchers(),
666                           termination_handlers, resumption_handlers );
667
668                if ( resumption_handlers.size() ) {
669                        // Define the helper function.
670                        FunctionDecl * resume_handler =
671                                create_resume_handler( resumption_handlers );
672                        appendDeclStmt( block, resume_handler );
673                        // Prepare hooks
674                        inner = create_resume_wrapper( node_decl, inner, resume_handler );
675                }
676
677                if ( termination_handlers.size() ) {
678                        // Define the three helper functions.
679                        FunctionDecl * try_wrapper = create_try_wrapper( inner );
680                        appendDeclStmt( block, try_wrapper );
681                        FunctionDecl * terminate_catch =
682                                create_terminate_catch( termination_handlers );
683                        appendDeclStmt( block, terminate_catch );
684                        FunctionDecl * terminate_match =
685                                create_terminate_match( termination_handlers );
686                        appendDeclStmt( block, terminate_match );
687                        // Build the call to the try wrapper.
688                        inner = create_terminate_caller(
689                                try_wrapper, terminate_catch, terminate_match );
690                }
691
692                // Embed the try block.
693                block->push_back( inner );
694
695                return block;
696        }
697
698        void translateEHM( std::list< Declaration *> & translationUnit ) {
699                init_func_types();
700
701                PassVisitor<ExceptionMutatorCore> translator;
702                mutateAll( translationUnit, translator );
703        }
704}
Note: See TracBrowser for help on using the repository browser.