Changeset 2e9b59b for src/ControlStruct/ExceptTranslateNew.cpp

Timestamp:

Apr 19, 2022, 3:00:04 PM (3 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

5b84a321

Parents:

ba897d21 (diff), bb7c77d (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:

added benchmark and evaluations chapter to thesis

File:

• src/ControlStruct/ExceptTranslateNew.cpp (modified) (29 diffs)

src/ControlStruct/ExceptTranslateNew.cpp

@@ -9 +9 @@
 // Author           : Andrew Beach
 // Created On       : Mon Nov  8 11:53:00 2021
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan 31 18:49:58 2022
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 11 17:51:00 2022
+// Update Count     : 2
 //
 
@@ -26 +26 @@
 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);
-                        }
-                }
-        }
+        typedef std::list<ast::CatchClause*> CatchList;
 
         void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
@@ -58 +45 @@
         {}
 
-        void previsit( const ast::CatchStmt * stmt );
+        void previsit( const ast::CatchClause * stmt );
         const ast::Stmt * postvisit( const ast::ThrowStmt * stmt );
 };
@@ -101 +88 @@
 }
 
-void TranslateThrowsCore::previsit( const ast::CatchStmt * stmt ) {
+void TranslateThrowsCore::previsit( const ast::CatchClause * stmt ) {
         // Validate the statement's form.
         const ast::ObjectDecl * decl = stmt->decl.as<ast::ObjectDecl>();
@@ -160 +147 @@
         ast::FunctionDecl * create_terminate_catch( CatchList &handlers );
         ast::CompoundStmt * create_single_matcher(
-                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler );
+                const ast::DeclWithType * except_obj, ast::CatchClause * modded_handler );
         ast::FunctionDecl * create_terminate_match( CatchList &handlers );
         ast::CompoundStmt * create_terminate_caller( CodeLocation loc, ast::FunctionDecl * try_wrapper,
@@ -171 +158 @@
         ast::Stmt * create_resume_rethrow( const ast::ThrowStmt * throwStmt );
 
-        // Types used in translation, make sure to use clone.
+        // Types used in translation, first group are internal.
+        ast::ObjectDecl * make_index_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_exception_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_bool_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_voidptr_object( CodeLocation const & ) const;
+        ast::ObjectDecl * make_unused_index_object( CodeLocation const & ) const;
         // void (*function)();
-        ast::FunctionDecl * try_func_t;
+        ast::FunctionDecl * make_try_function( CodeLocation const & ) const;
         // void (*function)(int, exception);
-        ast::FunctionDecl * catch_func_t;
+        ast::FunctionDecl * make_catch_function( CodeLocation const & ) const;
         // int (*function)(exception);
-        ast::FunctionDecl * match_func_t;
+        ast::FunctionDecl * make_match_function( CodeLocation const & ) const;
         // bool (*function)(exception);
-        ast::FunctionDecl * handle_func_t;
+        ast::FunctionDecl * make_handle_function( CodeLocation const & ) const;
         // 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();
+        ast::FunctionDecl * make_finally_function( CodeLocation const & ) const;
 
 public:
@@ -199 +185 @@
 };
 
-void TryMutatorCore::init_func_types() {
+ast::ObjectDecl * TryMutatorCore::make_index_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
+                "__handler_index",
+                new ast::BasicType(ast::BasicType::SignedInt),
+                nullptr, //init
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+                );
+}
+
+ast::ObjectDecl * TryMutatorCore::make_exception_object(
+                CodeLocation const & location ) const {
         assert( except_decl );
-
-        ast::ObjectDecl index_obj(
-                {},
-                "__handler_index",
-                new ast::BasicType(ast::BasicType::SignedInt)
-                );
-        ast::ObjectDecl exception_obj(
-                {},
+        return new ast::ObjectDecl(
+                location,
                 "__exception_inst",
                 new ast::PointerType(
                         new ast::StructInstType( except_decl )
                         ),
-                NULL
-                );
-        ast::ObjectDecl bool_obj(
-                {},
+                nullptr, //init
+                ast::Storage::Classes{},
+                ast::Linkage::Cforall
+                );
+}
+
+ast::ObjectDecl * TryMutatorCore::make_bool_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
                 "__ret_bool",
                 new ast::BasicType( ast::BasicType::Bool ),
@@ -225 +224 @@
                 std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
                 );
-        ast::ObjectDecl voidptr_obj(
-                {},
+}
+
+ast::ObjectDecl * TryMutatorCore::make_voidptr_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
                 "__hook",
                 new ast::PointerType(
@@ -237 +240 @@
                 std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
                 );
-
-        ast::ObjectDecl unused_index_obj(
-                {},
+}
+
+ast::ObjectDecl * TryMutatorCore::make_unused_index_object(
+                CodeLocation const & location ) const {
+        return new ast::ObjectDecl(
+                location,
                 "__handler_index",
                 new ast::BasicType(ast::BasicType::SignedInt),
@@ -248 +254 @@
                 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(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_try_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "try",
                 {}, //forall
@@ -260 +268 @@
                 ast::Linkage::Cforall
         );
-
-        catch_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_catch_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "catch",
                 {}, //forall
-                {ast::deepCopy(&index_obj), ast::deepCopy(&exception_obj)},//param
+                { make_index_object( location ), make_exception_object( location ) },
                 {}, //return void
                 nullptr,
@@ -271 +282 @@
                 ast::Linkage::Cforall
         );
-
-        match_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_match_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "match",
                 {}, //forall
-                {ast::deepCopy(&exception_obj)},
-                {ast::deepCopy(&unused_index_obj)},
+                { make_exception_object( location ) },
+                { make_unused_index_object( location ) },
                 nullptr,
                 ast::Storage::Classes{},
                 ast::Linkage::Cforall
         );
-
-        handle_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_handle_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "handle",
                 {}, //forall
-                {ast::deepCopy(&exception_obj)},
-                {ast::deepCopy(&bool_obj)},
+                { make_exception_object( location ) },
+                { make_bool_object( location ) },
                 nullptr,
                 ast::Storage::Classes{},
                 ast::Linkage::Cforall
         );
-
-        finally_func_t = new ast::FunctionDecl(
-                {},
+}
+
+ast::FunctionDecl * TryMutatorCore::make_finally_function(
+                CodeLocation const & location ) const {
+        return new ast::FunctionDecl(
+                location,
                 "finally",
                 {}, //forall
-                {ast::deepCopy(&voidptr_obj)},
+                { make_voidptr_object( location ) },
                 {}, //return void
                 nullptr,
@@ -304 +324 @@
                 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);
+        ast::FunctionDecl * ret = make_try_function( body->location );
         ret->stmts = body;
         return ret;
@@ -334 +338 @@
 ast::FunctionDecl * TryMutatorCore::create_terminate_catch(
                 CatchList &handlers ) {
-        std::vector<ast::ptr<ast::Stmt>> handler_wrappers;
+        std::vector<ast::ptr<ast::CaseClause>> handler_wrappers;
 
         assert (!handlers.empty());
         const CodeLocation loc = handlers.front()->location;
 
-        ast::FunctionDecl * func_t = ast::deepCopy(catch_func_t);
+        ast::FunctionDecl * func_t = make_catch_function( loc );
         const ast::DeclWithType * index_obj = func_t->params.front();
         const ast::DeclWithType * except_obj = func_t->params.back();
@@ -348 +352 @@
         for ( ; it != handlers.end() ; ++it ) {
                 ++index;
-                ast::CatchStmt * handler = *it;
+                ast::CatchClause * handler = *it;
                 const CodeLocation loc = handler->location;
 
@@ -386 +390 @@
                 // handler->body = nullptr;
 
-                handler_wrappers.push_back( new ast::CaseStmt(loc, 
+                handler_wrappers.push_back( new ast::CaseClause(loc,
                         ast::ConstantExpr::from_int(loc, index) ,
                         { block, new ast::ReturnStmt( loc, nullptr ) }
@@ -393 +397 @@
         // 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, 
+        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});
+        ast::CompoundStmt * body = new ast::CompoundStmt( loc, {handler_lookup} );
 
         func_t->stmts = body;
@@ -415 +410 @@
 // except_obj is referenced, modded_handler will be freed.
 ast::CompoundStmt * TryMutatorCore::create_single_matcher(
-                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler ) {
+                const ast::DeclWithType * except_obj, ast::CatchClause * modded_handler ) {
         // {
         //     `modded_handler.decl`
@@ -433 +428 @@
 
         // Check for type match.
-        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc, 
+        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
                 new ast::VariableExpr(loc, except_obj ),
                 local_except->get_type()
@@ -445 +440 @@
         }
         // Construct the match condition.
-        block->push_back( new ast::IfStmt(loc, 
+        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;
 }
@@ -467 +457 @@
         ast::CompoundStmt * body = new ast::CompoundStmt(loc);
 
-        ast::FunctionDecl * func_t = ast::deepCopy(match_func_t);
+        ast::FunctionDecl * func_t = make_match_function( loc );
         const ast::DeclWithType * except_obj = func_t->params.back();
 
@@ -475 +465 @@
         for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
                 ++index;
-                ast::CatchStmt * handler = *it;
+                ast::CatchClause * handler = *it;
 
                 // Body should have been taken by create_terminate_catch.
@@ -490 +480 @@
         }
 
-        body->push_back( new ast::ReturnStmt(loc, 
+        body->push_back( new ast::ReturnStmt(loc,
                 ast::ConstantExpr::from_int( loc, 0 ) ));
 
@@ -525 +515 @@
         ast::CompoundStmt * body = new ast::CompoundStmt(loc);
 
-        ast::FunctionDecl * func_t = ast::deepCopy(handle_func_t);
+        ast::FunctionDecl * func_t = make_handle_function( loc );
         const ast::DeclWithType * except_obj = func_t->params.back();
 
         CatchList::iterator it;
         for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
-                ast::CatchStmt * handler = *it;
+                ast::CatchClause * 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() );
+                        handling_code = strict_dynamic_cast<ast::CompoundStmt*>(
+                                handler->body.get_and_mutate() );
                 } else {
                         handling_code = new ast::CompoundStmt(loc);
@@ -597 +587 @@
                 ast::TryStmt * tryStmt ) {
         // void finally() { `finally->block` }
-        const ast::FinallyStmt * finally = tryStmt->finally;
+        const ast::FinallyClause * finally = tryStmt->finally;
         const ast::CompoundStmt * body = finally->body;
 
-        ast::FunctionDecl * func_t = ast::deepCopy(finally_func_t);
+        ast::FunctionDecl * func_t = make_finally_function( tryStmt->location );
         func_t->stmts = body;
 
-        // finally->set_block( nullptr );
-        // delete finally;
         tryStmt->finally = nullptr;
-
 
         return func_t;
@@ -617 +604 @@
 
         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,
@@ -644 +621 @@
         // return false;
         const CodeLocation loc = throwStmt->location;
-        ast::Stmt * result = new ast::ReturnStmt(loc, 
+        ast::Stmt * result = new ast::ReturnStmt(loc,
                 ast::ConstantExpr::from_bool( loc, false )
                 );
         result->labels = throwStmt->labels;
-        // delete throwStmt; done by postvisit
         return result;
 }
@@ -660 +636 @@
                 assert( nullptr == except_decl );
                 except_decl = structDecl;
-                init_func_types();
         } else if ( structDecl->name == "__cfaehm_try_resume_node" ) {
                 assert( nullptr == node_decl );
@@ -706 +681 @@
                 }
         }
-        // split( mutStmt->handlers,
-        //              termination_handlers, resumption_handlers );
 
         if ( resumption_handlers.size() ) {