source: src/ControlStruct/ExceptTranslate.cc@ 184557e

new-env
Last change on this file since 184557e was 1cdfa82, checked in by Aaron Moss <a3moss@…>, 7 years ago

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