Changeset a554e5f4 for src/ControlStruct

Timestamp:

Feb 9, 2022, 3:33:42 PM (4 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

850aff1

Parents:

21a99cc (diff), c4f81702 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/ControlStruct

Files:

• ExceptTranslate.h (modified) (1 diff)
• ExceptTranslateNew.cpp (modified) (2 diffs)
• MLEMutator.cc (modified) (3 diffs)
• MultiLevelExit.cpp (modified) (21 diffs)

src/ControlStruct/ExceptTranslate.h

@@ -31 +31 @@
 
         void translateTries( std::list< Declaration *> & translationUnit );
+        void translateTries( ast::TranslationUnit & transUnit );
         /* Replaces all try blocks (and their many clauses) with function definitions and calls.
          * This uses the exception built-ins to produce typed output and should take place after

src/ControlStruct/ExceptTranslateNew.cpp

@@ -20 +20 @@
 #include "AST/Stmt.hpp"
 #include "AST/TranslationUnit.hpp"
+#include "AST/DeclReplacer.hpp"
 
 namespace ControlStruct {
+
+namespace {
+
+        typedef std::list<ast::CatchStmt*> CatchList;
+
+        void split( CatchList& allHandlers, CatchList& terHandlers,
+                                CatchList& resHandlers ) {
+                while ( !allHandlers.empty() ) {
+                        ast::CatchStmt * stmt = allHandlers.front();
+                        allHandlers.pop_front();
+                        if (stmt->kind == ast::ExceptionKind::Terminate) {
+                                terHandlers.push_back(stmt);
+                        } else {
+                                resHandlers.push_back(stmt);
+                        }
+                }
+        }
+
+        void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
+                block->push_back(new ast::DeclStmt(block->location, item));
+        }
 
 class TranslateThrowsCore : public ast::WithGuards {
@@ -126 +148 @@
 }
 
+
+class TryMutatorCore {
+        // The built in types used in translation.
+        const ast::StructDecl * except_decl;
+        const ast::StructDecl * node_decl;
+        const ast::StructDecl * hook_decl;
+
+        // The many helper functions for code/syntree generation.
+        ast::CompoundStmt * take_try_block( ast::TryStmt * tryStmt );
+        ast::FunctionDecl * create_try_wrapper( const ast::CompoundStmt * body );
+        ast::FunctionDecl * create_terminate_catch( CatchList &handlers );
+        ast::CompoundStmt * create_single_matcher(
+                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler );
+        ast::FunctionDecl * create_terminate_match( CatchList &handlers );
+        ast::CompoundStmt * create_terminate_caller( CodeLocation loc, ast::FunctionDecl * try_wrapper,
+                ast::FunctionDecl * terminate_catch, ast::FunctionDecl * terminate_match );
+        ast::FunctionDecl * create_resume_handler( CatchList &handlers );
+        ast::CompoundStmt * create_resume_wrapper(
+                const ast::Stmt * wraps, const ast::FunctionDecl * resume_handler );
+        ast::FunctionDecl * create_finally_wrapper( ast::TryStmt * tryStmt );
+        ast::ObjectDecl * create_finally_hook( ast::FunctionDecl * finally_wrapper );
+        ast::Stmt * create_resume_rethrow( const ast::ThrowStmt * throwStmt );
+
+        // Types used in translation, make sure to use clone.
+        // void (*function)();
+        ast::FunctionDecl * try_func_t;
+        // void (*function)(int, exception);
+        ast::FunctionDecl * catch_func_t;
+        // int (*function)(exception);
+        ast::FunctionDecl * match_func_t;
+        // bool (*function)(exception);
+        ast::FunctionDecl * handle_func_t;
+        // void (*function)(__attribute__((unused)) void *);
+        ast::FunctionDecl * finally_func_t;
+
+        ast::StructInstType * create_except_type() {
+                assert( except_decl );
+                return new ast::StructInstType( except_decl );
+        }
+        void init_func_types();
+
+public:
+        TryMutatorCore() :
+                except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr )
+        {}
+
+        void previsit( const ast::StructDecl *structDecl );
+        ast::Stmt * postvisit( const ast::TryStmt *tryStmt );
+        ast::Stmt * postvisit( const ast::ThrowStmt *throwStmt );
+};
+
+void TryMutatorCore::init_func_types() {
+        assert( except_decl );
+
+        ast::ObjectDecl index_obj(
+                {},
+                "__handler_index",
+                new ast::BasicType(ast::BasicType::SignedInt)
+                );
+        ast::ObjectDecl exception_obj(
+                {},
+                "__exception_inst",
+                new ast::PointerType(
+                        new ast::StructInstType( except_decl )
+                        ),
+                NULL
+                );
+        ast::ObjectDecl bool_obj(
+                {},
+                "__ret_bool",
+                new ast::BasicType( ast::BasicType::Bool ),
+                nullptr, //init
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall,
+                nullptr, //width
+                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
+                );
+        ast::ObjectDecl voidptr_obj(
+                {},
+                "__hook",
+                new ast::PointerType(
+                        new ast::VoidType()
+                ),
+                nullptr, //init
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall,
+                nullptr, //width
+                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
+                );
+
+        ast::ObjectDecl unused_index_obj(
+                {},
+                "__handler_index",
+                new ast::BasicType(ast::BasicType::SignedInt),
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall,
+                nullptr, //width
+                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
+        );
+        //unused_index_obj->attributes.push_back( new Attribute( "unused" ) );
+
+        try_func_t = new ast::FunctionDecl(
+                {},
+                "try",
+                {}, //forall
+                {}, //no param
+                {}, //no return
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+        );
+
+        catch_func_t = new ast::FunctionDecl(
+                {},
+                "catch",
+                {}, //forall
+                {ast::deepCopy(&index_obj), ast::deepCopy(&exception_obj)},//param
+                {}, //return void
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+        );
+
+        match_func_t = new ast::FunctionDecl(
+                {},
+                "match",
+                {}, //forall
+                {ast::deepCopy(&exception_obj)},
+                {ast::deepCopy(&unused_index_obj)},
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+        );
+
+        handle_func_t = new ast::FunctionDecl(
+                {},
+                "handle",
+                {}, //forall
+                {ast::deepCopy(&exception_obj)},
+                {ast::deepCopy(&bool_obj)},
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+        );
+
+        finally_func_t = new ast::FunctionDecl(
+                {},
+                "finally",
+                {}, //forall
+                {ast::deepCopy(&voidptr_obj)},
+                {}, //return void
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+        );
+
+        //catch_func_t.get_parameters().push_back( index_obj.clone() );
+        //catch_func_t.get_parameters().push_back( exception_obj.clone() );
+        //match_func_t.get_returnVals().push_back( unused_index_obj );
+        //match_func_t.get_parameters().push_back( exception_obj.clone() );
+        //handle_func_t.get_returnVals().push_back( bool_obj.clone() );
+        //handle_func_t.get_parameters().push_back( exception_obj.clone() );
+        //finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
+}
+
+// TryStmt Mutation Helpers
+
+/*
+ast::CompoundStmt * TryMutatorCore::take_try_block( ast::TryStmt *tryStmt ) {
+        ast::CompoundStmt * block = tryStmt->body;
+        tryStmt->body = nullptr;
+        return block;
+}
+*/
+
+ast::FunctionDecl * TryMutatorCore::create_try_wrapper(
+                const ast::CompoundStmt *body ) {
+
+        ast::FunctionDecl * ret = ast::deepCopy(try_func_t);
+        ret->stmts = body;
+        return ret;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_terminate_catch(
+                CatchList &handlers ) {
+        std::vector<ast::ptr<ast::Stmt>> handler_wrappers;
+
+        assert (!handlers.empty());
+        const CodeLocation loc = handlers.front()->location;
+
+        ast::FunctionDecl * func_t = ast::deepCopy(catch_func_t);
+        const ast::DeclWithType * index_obj = func_t->params.front();
+        const ast::DeclWithType * except_obj = func_t->params.back();
+
+        // Index 1..{number of handlers}
+        int index = 0;
+        CatchList::iterator it = handlers.begin();
+        for ( ; it != handlers.end() ; ++it ) {
+                ++index;
+                ast::CatchStmt * handler = *it;
+                const CodeLocation loc = handler->location;
+
+                // case `index`:
+                // {
+                //     `handler.decl` = { (virtual `decl.type`)`except` };
+                //     `handler.body`;
+                // }
+                // return;
+                ast::CompoundStmt * block = new ast::CompoundStmt(loc);
+
+                // Just copy the exception value. (Post Validation)
+                const ast::ObjectDecl * handler_decl =
+                        handler->decl.strict_as<ast::ObjectDecl>();
+                ast::ObjectDecl * local_except = ast::deepCopy(handler_decl);
+                ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
+                        new ast::VariableExpr( loc, except_obj ),
+                        local_except->get_type()
+                        );
+                vcex->location = handler->location;
+                local_except->init = new ast::ListInit(loc, { new ast::SingleInit( loc, vcex ) });
+                block->push_back( new ast::DeclStmt( loc, local_except ) );
+
+                // Add the cleanup attribute.
+                local_except->attributes.push_back( new ast::Attribute(
+                        "cleanup",
+                        { new ast::NameExpr( loc, "__cfaehm_cleanup_terminate" ) }
+                        ) );
+
+                ast::DeclReplacer::DeclMap mapping;
+                mapping[handler_decl] = local_except;
+                const ast::Stmt * mutBody = strict_dynamic_cast<const ast::Stmt *>(
+                        ast::DeclReplacer::replace(handler->body, mapping));
+
+
+                block->push_back( mutBody );
+                // handler->body = nullptr;
+
+                handler_wrappers.push_back( new ast::CaseStmt(loc, 
+                        ast::ConstantExpr::from_int(loc, index) ,
+                        { block, new ast::ReturnStmt( loc, nullptr ) }
+                        ));
+        }
+        // TODO: Some sort of meaningful error on default perhaps?
+
+        /*
+        std::list<Statement*> stmt_handlers;
+        while ( !handler_wrappers.empty() ) {
+                stmt_handlers.push_back( handler_wrappers.front() );
+                handler_wrappers.pop_front();
+        }
+        */
+
+        ast::SwitchStmt * handler_lookup = new ast::SwitchStmt(loc, 
+                new ast::VariableExpr( loc, index_obj ),
+                std::move(handler_wrappers)
+                );
+        ast::CompoundStmt * body = new ast::CompoundStmt(loc, 
+                {handler_lookup});
+
+        func_t->stmts = body;
+        return func_t;
+}
+
+// Create a single check from a moddified handler.
+// except_obj is referenced, modded_handler will be freed.
+ast::CompoundStmt * TryMutatorCore::create_single_matcher(
+                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler ) {
+        // {
+        //     `modded_handler.decl`
+        //     if ( `decl.name = (virtual `decl.type`)`except`
+        //             [&& `modded_handler.cond`] ) {
+        //         `modded_handler.body`
+        //     }
+        // }
+
+        const CodeLocation loc = modded_handler->location;
+        ast::CompoundStmt * block = new ast::CompoundStmt(loc);
+
+        // Local Declaration
+        const ast::ObjectDecl * local_except =
+                modded_handler->decl.strict_as<ast::ObjectDecl>();
+        block->push_back( new ast::DeclStmt( loc,  local_except ) );
+
+        // Check for type match.
+        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc, 
+                new ast::VariableExpr(loc, except_obj ),
+                local_except->get_type()
+                );
+        ast::Expr * cond = ast::UntypedExpr::createAssign(loc,
+                new ast::VariableExpr(loc, local_except ), vcex );
+
+        // Add the check on the conditional if it is provided.
+        if ( modded_handler->cond ) {
+                cond = new ast::LogicalExpr( loc, cond, modded_handler->cond, ast::LogicalFlag::AndExpr );
+        }
+        // Construct the match condition.
+        block->push_back( new ast::IfStmt(loc, 
+                cond, modded_handler->body, nullptr ) );
+
+        // xxx - how does this work in new ast
+        //modded_handler->set_decl( nullptr );
+        //modded_handler->set_cond( nullptr );
+        //modded_handler->set_body( nullptr );
+        //delete modded_handler;
+        return block;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_terminate_match(
+                CatchList &handlers ) {
+        // int match(exception * except) {
+        //     HANDLER WRAPPERS { return `index`; }
+        // }
+
+        assert (!handlers.empty());
+        const CodeLocation loc = handlers.front()->location;
+
+        ast::CompoundStmt * body = new ast::CompoundStmt(loc);
+
+        ast::FunctionDecl * func_t = ast::deepCopy(match_func_t);
+        const ast::DeclWithType * except_obj = func_t->params.back();
+
+        // Index 1..{number of handlers}
+        int index = 0;
+        CatchList::iterator it;
+        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
+                ++index;
+                ast::CatchStmt * handler = *it;
+
+                // Body should have been taken by create_terminate_catch.
+                // xxx - just ignore it?
+                // assert( nullptr == handler->get_body() );
+
+                // Create new body.
+                handler->body = new ast::ReturnStmt( handler->location,
+                        ast::ConstantExpr::from_int( handler->location, index ) );
+
+                // Create the handler.
+                body->push_back( create_single_matcher( except_obj, handler ) );
+                *it = nullptr;
+        }
+
+        body->push_back( new ast::ReturnStmt(loc, 
+                ast::ConstantExpr::from_int( loc, 0 ) ));
+
+        func_t->stmts = body;
+
+        return func_t;
+}
+
+ast::CompoundStmt * TryMutatorCore::create_terminate_caller(
+                CodeLocation loc,
+                ast::FunctionDecl * try_wrapper,
+                ast::FunctionDecl * terminate_catch,
+                ast::FunctionDecl * terminate_match ) {
+        // { __cfaehm_try_terminate(`try`, `catch`, `match`); }
+
+        ast::UntypedExpr * caller = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
+                "__cfaehm_try_terminate" ) );
+        caller->args.push_back( new ast::VariableExpr(loc, try_wrapper ) );
+        caller->args.push_back( new ast::VariableExpr(loc, terminate_catch ) );
+        caller->args.push_back( new ast::VariableExpr(loc, terminate_match ) );
+
+        ast::CompoundStmt * callStmt = new ast::CompoundStmt(loc);
+        callStmt->push_back( new ast::ExprStmt( loc, caller ) );
+        return callStmt;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_resume_handler(
+                CatchList &handlers ) {
+        // bool handle(exception * except) {
+        //     HANDLER WRAPPERS { `hander->body`; return true; }
+        // }
+        assert (!handlers.empty());
+        const CodeLocation loc = handlers.front()->location;
+        ast::CompoundStmt * body = new ast::CompoundStmt(loc);
+
+        ast::FunctionDecl * func_t = ast::deepCopy(handle_func_t);
+        const ast::DeclWithType * except_obj = func_t->params.back();
+
+        CatchList::iterator it;
+        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
+                ast::CatchStmt * handler = *it;
+                const CodeLocation loc = handler->location;
+                // Modifiy body.
+                ast::CompoundStmt * handling_code;
+                if (handler->body.as<ast::CompoundStmt>()) {
+                        handling_code = 
+                        strict_dynamic_cast<ast::CompoundStmt*>( handler->body.get_and_mutate() );
+                } else {
+                        handling_code = new ast::CompoundStmt(loc);
+                        handling_code->push_back( handler->body );
+                }
+                handling_code->push_back( new ast::ReturnStmt(loc,
+                        ast::ConstantExpr::from_bool(loc, true ) ) );
+                handler->body = handling_code;
+
+                // Create the handler.
+                body->push_back( create_single_matcher( except_obj, handler ) );
+                *it = nullptr;
+        }
+
+        body->push_back( new ast::ReturnStmt(loc,
+                ast::ConstantExpr::from_bool(loc, false ) ) );
+        func_t->stmts = body;
+
+        return func_t;
+}
+
+ast::CompoundStmt * TryMutatorCore::create_resume_wrapper(
+                const ast::Stmt * wraps,
+                const ast::FunctionDecl * resume_handler ) {
+        const CodeLocation loc = wraps->location;
+        ast::CompoundStmt * body = new ast::CompoundStmt(loc);
+
+        // struct __try_resume_node __resume_node
+        //      __attribute__((cleanup( __cfaehm_try_resume_cleanup )));
+        // ** unwinding of the stack here could cause problems **
+        // ** however I don't think that can happen currently **
+        // __cfaehm_try_resume_setup( &__resume_node, resume_handler );
+
+        ast::ObjectDecl * obj = new ast::ObjectDecl(
+                loc,
+                "__resume_node",
+                new ast::StructInstType(
+                        node_decl
+                        ),
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall,
+                nullptr,
+                {new ast::Attribute("cleanup", {new ast::NameExpr(loc, "__cfaehm_try_resume_cleanup")})}
+                );
+        appendDeclStmt( body, obj );
+
+        ast::UntypedExpr *setup = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
+                "__cfaehm_try_resume_setup" ) );
+        setup->args.push_back( new ast::AddressExpr( loc, new ast::VariableExpr(loc, obj ) ) );
+        setup->args.push_back( new ast::VariableExpr( loc, resume_handler ) );
+
+        body->push_back( new ast::ExprStmt(loc, setup ) );
+
+        body->push_back( wraps );
+        return body;
+}
+
+ast::FunctionDecl * TryMutatorCore::create_finally_wrapper(
+                ast::TryStmt * tryStmt ) {
+        // void finally() { `finally->block` }
+        const ast::FinallyStmt * finally = tryStmt->finally;
+        const ast::CompoundStmt * body = finally->body;
+
+        ast::FunctionDecl * func_t = ast::deepCopy(finally_func_t);
+        func_t->stmts = body;
+
+        // finally->set_block( nullptr );
+        // delete finally;
+        tryStmt->finally = nullptr;
+
+
+        return func_t;
+}
+
+ast::ObjectDecl * TryMutatorCore::create_finally_hook(
+                ast::FunctionDecl * finally_wrapper ) {
+        // struct __cfaehm_cleanup_hook __finally_hook
+        //      __attribute__((cleanup( `finally_wrapper` )));
+
+        const CodeLocation loc = finally_wrapper->location;
+        // Make Cleanup Attribute.
+        /*
+        std::list< ast::Attribute * > attributes;
+        {
+                std::list<  > attr_params;
+                attr_params.push_back( nameOf( finally_wrapper ) );
+                attributes.push_back( new Attribute( "cleanup", attr_params ) );
+        }
+        */
+
+        return new ast::ObjectDecl(
+                loc,
+                "__finally_hook",
+                new ast::StructInstType(
+                        hook_decl
+                        ),
+                nullptr,
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall,
+                nullptr,
+                {new ast::Attribute("cleanup", {new ast::VariableExpr{loc, finally_wrapper}})}
+                );
+}
+
+ast::Stmt * TryMutatorCore::create_resume_rethrow( const ast::ThrowStmt *throwStmt ) {
+        // return false;
+        const CodeLocation loc = throwStmt->location;
+        ast::Stmt * result = new ast::ReturnStmt(loc, 
+                ast::ConstantExpr::from_bool( loc, false )
+                );
+        result->labels = throwStmt->labels;
+        // delete throwStmt; done by postvisit
+        return result;
+}
+
+// Visiting/Mutating Functions
+void TryMutatorCore::previsit( const ast::StructDecl *structDecl ) {
+        if ( !structDecl->body ) {
+                // Skip children?
+                return;
+        } else if ( structDecl->name == "__cfaehm_base_exception_t" ) {
+                assert( nullptr == except_decl );
+                except_decl = structDecl;
+                init_func_types();
+        } else if ( structDecl->name == "__cfaehm_try_resume_node" ) {
+                assert( nullptr == node_decl );
+                node_decl = structDecl;
+        } else if ( structDecl->name == "__cfaehm_cleanup_hook" ) {
+                assert( nullptr == hook_decl );
+                hook_decl = structDecl;
+        }
+}
+
+ast::Stmt * TryMutatorCore::postvisit( const ast::TryStmt *tryStmt ) {
+        assert( except_decl );
+        assert( node_decl );
+        assert( hook_decl );
+
+        const CodeLocation loc = tryStmt->location;
+        ast::TryStmt * mutStmt = mutate(tryStmt);
+        // Generate a prefix for the function names?
+
+        ast::CompoundStmt * block = new ast::CompoundStmt( loc );
+        // ast::CompoundStmt * inner = take_try_block( mutStmt );
+        // this is never mutated so let node deletion do its job?
+        const ast::CompoundStmt * inner = mutStmt->body;
+
+        if ( mutStmt->finally ) {
+                // Define the helper function.
+                ast::FunctionDecl * finally_block =
+                        create_finally_wrapper( mutStmt );
+                appendDeclStmt( block, finally_block );
+                // Create and add the finally cleanup hook.
+                appendDeclStmt( block, create_finally_hook( finally_block ) );
+        }
+
+        CatchList termination_handlers;
+        CatchList resumption_handlers;
+
+        for (auto & handler: mutStmt->handlers) {
+                // xxx - should always be unique? mutate as safe const-cast
+                assert(handler->unique());
+                if (handler->kind == ast::ExceptionKind::Resume) {
+                        resumption_handlers.push_back(handler.get_and_mutate());
+                }
+                else {
+                        termination_handlers.push_back(handler.get_and_mutate());
+                }
+        }
+        // split( mutStmt->handlers,
+        //              termination_handlers, resumption_handlers );
+
+        if ( resumption_handlers.size() ) {
+                // Define the helper function.
+                ast::FunctionDecl * resume_handler =
+                        create_resume_handler( resumption_handlers );
+                appendDeclStmt( block, resume_handler );
+                // Prepare hooks
+                inner = create_resume_wrapper( inner, resume_handler );
+        }
+
+        if ( termination_handlers.size() ) {
+                // Define the three helper functions.
+                ast::FunctionDecl * try_wrapper = create_try_wrapper( inner );
+                appendDeclStmt( block, try_wrapper );
+                ast::FunctionDecl * terminate_catch =
+                        create_terminate_catch( termination_handlers );
+                appendDeclStmt( block, terminate_catch );
+                ast::FunctionDecl * terminate_match =
+                        create_terminate_match( termination_handlers );
+                appendDeclStmt( block, terminate_match );
+                // Build the call to the try wrapper.
+                inner = create_terminate_caller(inner->location,
+                        try_wrapper, terminate_catch, terminate_match );
+        }
+
+        // Embed the try block.
+        block->push_back( inner );
+
+        return block;
+}
+
+ast::Stmt * TryMutatorCore::postvisit( const ast::ThrowStmt *throwStmt ) {
+        // Only valid `throwResume;` statements should remain. (2/3 checks)
+        assert( ast::ExceptionKind::Resume == throwStmt->kind && ! throwStmt->expr );
+        return create_resume_rethrow( throwStmt );
+}
+
+} // namespace
+
 void translateThrows( ast::TranslationUnit & transUnit ) {
         ast::Pass<TranslateThrowsCore>::run( transUnit );
+}
+
+void translateTries( ast::TranslationUnit & transUnit ) {
+        ast::Pass<TryMutatorCore>::run(transUnit);
 }
 

src/ControlStruct/MLEMutator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  1 09:26:28 2022
-// Update Count     : 225
+// Last Modified On : Wed Feb  2 20:18:57 2022
+// Update Count     : 227
 //
 
@@ -136 +136 @@
                         }
                 }
-                assertf( false, "Could not find label '%s' on statement %s",
+                assertf( false, "CFA internal error: could not find label '%s' on statement %s",
                         originalTarget.get_name().c_str(), toString( stmt ).c_str() );
         }
@@ -395 +395 @@
                 }
                 assert( ! enclosingControlStructures.empty() );
-                assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ), "Control structure enclosing a case clause must be a switch, but is: %s", toCString( enclosingControlStructures.back().get_controlStructure() ) );
+                assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ),
+                                 "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
+                                 toCString( enclosingControlStructures.back().get_controlStructure() ) );
                 if ( caseStmt->isDefault() ) {
                         if ( enclosingControlStructures.back().isFallDefaultUsed() ) {

src/ControlStruct/MultiLevelExit.cpp

@@ -10 +10 @@
 // Created On       : Mon Nov  1 13:48:00 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb  1 18:48:47 2022
-// Update Count     : 29
+// Last Modified On : Wed Feb  2 23:07:54 2022
+// Update Count     : 33
 //
 
@@ -49 +49 @@
                 return target.label;
         }
-
   public:
         Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
@@ -168 +167 @@
 
         // if the stmt is labelled then generate a label to check in postvisit if the label is used
-        bool isLabeled = !stmt->labels.empty();
+        bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
                 Label breakLabel = newLabel( "blockBreak", stmt );
@@ -180 +179 @@
 
         if ( isLabeled ) {
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 Entry & entry = enclosing_control_structures.back();
-                if ( !entry.useBreakExit().empty() ) {
+                if ( ! entry.useBreakExit().empty() ) {
                         break_label = entry.useBreakExit();
                 }
@@ -206 +205 @@
                 }
         }
-        assertf( false, "Could not find label '%s' on statement %s",
+        assertf( false, "CFA internal error: could not find label '%s' on statement %s",
                          originalTarget.name.c_str(), toString( stmt ).c_str() );
 }
@@ -254 +253 @@
                   }
                   // Ensure that selected target is valid.
-                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
+                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && ! isContinueTarget( *targetEntry ) ) ) {
                           SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
                                                         " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
@@ -268 +267 @@
                           SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
                   }
-                  if ( !stmt->target.empty() ) {
+                  if ( ! stmt->target.empty() ) {
                           // Labelled fallthrough: target must be a valid fallthough label.
-                          if ( !fallthrough_labels.count( stmt->target ) ) {
+                          if ( ! fallthrough_labels.count( stmt->target ) ) {
                                   SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
                                                                                                                    stmt->originalTarget ) );
                           }
-                          return new BranchStmt(
-                                  stmt->location, BranchStmt::Goto, stmt->originalTarget );
+                          return new BranchStmt( stmt->location, BranchStmt::Goto, stmt->originalTarget );
                   }
                   break;
@@ -307 +305 @@
         }
 
-        // Branch error checks: get the appropriate label name:
-        // (This label is always replaced.)
+        // Branch error checks: get the appropriate label name, which is always replaced.
         Label exitLabel( CodeLocation(), "" );
         switch ( stmt->kind ) {
           case BranchStmt::Break:
-                assert( !targetEntry->useBreakExit().empty() );
+                assert( ! targetEntry->useBreakExit().empty() );
                 exitLabel = targetEntry->useBreakExit();
                 break;
           case BranchStmt::Continue:
-                assert( !targetEntry->useContExit().empty() );
+                assert( ! targetEntry->useContExit().empty() );
                 exitLabel = targetEntry->useContExit();
                 break;
           case BranchStmt::FallThrough:
-                assert( !targetEntry->useFallExit().empty() );
+                assert( ! targetEntry->useFallExit().empty() );
                 exitLabel = targetEntry->useFallExit();
                 break;
           case BranchStmt::FallThroughDefault:
-                assert( !targetEntry->useFallDefaultExit().empty() );
+                assert( ! targetEntry->useFallDefaultExit().empty() );
                 exitLabel = targetEntry->useFallDefaultExit();
                 // Check that fallthrough default comes before the default clause.
-                if ( !targetEntry->isFallDefaultValid() ) {
+                if ( ! targetEntry->isFallDefaultValid() ) {
                         SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
                 }
@@ -373 +370 @@
         // If default, mark seen.
         if ( stmt->isDefault() ) {
-                assert( !enclosing_control_structures.empty() );
+                assert( ! enclosing_control_structures.empty() );
                 enclosing_control_structures.back().seenDefault();
         }
@@ -399 +396 @@
                 Entry & entry = enclosing_control_structures.back();
                 if ( entry.isFallUsed() ) {
-                        mutStmt->stmts.push_back(
-                                labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
+                        mutStmt->stmts.push_back( labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
                 }
         }
@@ -406 +402 @@
         Entry & entry = enclosing_control_structures.back();
         assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
-                         "Control structure enclosing a case clause must be a switch, but is: %s",
+                         "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
                          toString( entry.stmt ).c_str() );
         if ( mutStmt->isDefault() ) {
                 if ( entry.isFallDefaultUsed() ) {
                         // Add fallthrough default label if necessary.
-                        push_front( mutStmt->stmts, labelledNullStmt(
-                                                        stmt->location, entry.useFallDefaultExit()
-                                                        ) );
+                        push_front( mutStmt->stmts, labelledNullStmt( stmt->location, entry.useFallDefaultExit() ) );
                 }
         }
@@ -420 +414 @@
 
 void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
-        bool labeledBlock = !stmt->labels.empty();
+        bool labeledBlock = ! stmt->labels.empty();
         if ( labeledBlock ) {
                 Label breakLabel = newLabel( "blockBreak", stmt );
@@ -429 +423 @@
 
 const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
-        bool labeledBlock = !stmt->labels.empty();
+        bool labeledBlock = ! stmt->labels.empty();
         if ( labeledBlock ) {
                 auto this_label = enclosing_control_structures.back().useBreakExit();
-                if ( !this_label.empty() ) {
+                if ( ! this_label.empty() ) {
                         break_label = this_label;
                 }
@@ -448 +442 @@
         auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
 
-        const CaseStmt * defaultCase = it != stmt->stmts.rend()
-                ? (it)->strict_as<CaseStmt>() : nullptr;
-        Label defaultLabel = defaultCase
-                ? newLabel( "fallThroughDefault", defaultCase )
-                : Label( stmt->location, "" );
+        const CaseStmt * defaultCase = it != stmt->stmts.rend() ? (it)->strict_as<CaseStmt>() : nullptr;
+        Label defaultLabel = defaultCase ? newLabel( "fallThroughDefault", defaultCase ) : Label( stmt->location, "" );
         enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
         GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
 
-        // Collect valid labels for fallthrough. It starts with all labels at
-        // this level, then remove as each is seen during traversal.
+        // Collect valid labels for fallthrough. It starts with all labels at this level, then remove as each is seen during
+        // traversal.
         for ( const Stmt * stmt : stmt->stmts ) {
                 auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
@@ -471 +462 @@
 
 const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
-        assert( !enclosing_control_structures.empty() );
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
         assert( entry.stmt == stmt );
@@ -477 +468 @@
         // Only run to generate the break label.
         if ( entry.isBreakUsed() ) {
-                // To keep the switch statements uniform (all direct children of a
-                // SwitchStmt should be CastStmts), append the exit label and break
-                // to the last case, create a default case is there are no cases.
+                // To keep the switch statements uniform (all direct children of a SwitchStmt should be CastStmts), append the
+                // exit label and break to the last case, create a default case if no cases.
                 SwitchStmt * mutStmt = mutate( stmt );
                 if ( mutStmt->stmts.empty() ) {
-                        mutStmt->stmts.push_back( new CaseStmt(
-                                                                                  mutStmt->location, nullptr, {} ));
+                        mutStmt->stmts.push_back( new CaseStmt( mutStmt->location, nullptr, {} ) );
                 }
 
@@ -507 +496 @@
 
 void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
-        bool isLabeled = !stmt->labels.empty();
+        bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
                 Label breakLabel = newLabel( "blockBreak", stmt );
@@ -516 +505 @@
 
 void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
-        bool isLabeled = !stmt->labels.empty();
+        bool isLabeled = ! stmt->labels.empty();
         if ( isLabeled ) {
                 auto this_label = enclosing_control_structures.back().useBreakExit();
-                if ( !this_label.empty() ) {
+                if ( ! this_label.empty() ) {
                         break_label = this_label;
                 }
@@ -526 +515 @@
 
 void MultiLevelExitCore::previsit( const FinallyStmt * ) {
-        GuardAction([this, old = move(enclosing_control_structures)](){
-                                        enclosing_control_structures = move(old);
-                                });
+        GuardAction([this, old = move( enclosing_control_structures)](){ enclosing_control_structures = move(old); });
         enclosing_control_structures = vector<Entry>();
         GuardValue( inFinally ) = true;
@@ -575 +562 @@
 template<typename LoopNode>
 const LoopNode * MultiLevelExitCore::posthandleLoopStmt( const LoopNode * loopStmt ) {
-        assert( !enclosing_control_structures.empty() );
+        assert( ! enclosing_control_structures.empty() );
         Entry & entry = enclosing_control_structures.back();
         assert( entry.stmt == loopStmt );
 
         // Now check if the labels are used and add them if so.
-        return mutate_field(
-                loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
+        return mutate_field( loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
         // this call to mutate_field compares loopStmt->body and the result of mutateLoop
         //              if they are the same the node isn't mutated, if they differ then the new mutated node is returned
@@ -609 +595 @@
                 }
 
-                if ( !break_label.empty() ) {
-                        ret.push_back(
-                                labelledNullStmt( ret.back()->location, break_label ) );
+                if ( ! break_label.empty() ) {
+                        ret.push_back( labelledNullStmt( ret.back()->location, break_label ) );
                         break_label = Label( CodeLocation(), "" );
                 }
         }
 
-        if ( !errors.isEmpty() ) {
+        if ( ! errors.isEmpty() ) {
                 throw errors;
         }