Changeset 2e9b59b for src/InitTweak

Timestamp:

Apr 19, 2022, 3:00:04 PM (4 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

Location:

src/InitTweak

Files:

• FixGlobalInit.cc (modified) (2 diffs)
• FixInitNew.cpp (modified) (16 diffs)
• GenInit.cc (modified) (2 diffs)
• GenInit.h (modified) (2 diffs)
• InitTweak.cc (modified) (2 diffs)

src/InitTweak/FixGlobalInit.cc

@@ -113 +113 @@
                 accept_all(translationUnit, fixer);
 
+                // Say these magic declarations come at the end of the file.
+                CodeLocation const & location = translationUnit.decls.back()->location;
+
                 if ( !fixer.core.initStmts.empty() ) {
                         std::vector<ast::ptr<ast::Expr>> ctorParams;
-                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
-                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.initStmts)), 
-                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("constructor", std::move(ctorParams))});
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int(location, 200));
+                        auto initFunction = new ast::FunctionDecl(location,
+                                "__global_init__", {}, {}, {},
+                                new ast::CompoundStmt(location, std::move(fixer.core.initStmts)),
+                                ast::Storage::Static, ast::Linkage::C,
+                                {new ast::Attribute("constructor", std::move(ctorParams))});
 
                         translationUnit.decls.emplace_back( initFunction );
@@ -124 +130 @@
                 if ( !fixer.core.destroyStmts.empty() ) {
                         std::vector<ast::ptr<ast::Expr>> dtorParams;
-                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
-                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)), 
-                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int(location, 200));
+                        auto destroyFunction = new ast::FunctionDecl( location,
+                                "__global_destroy__", {}, {}, {},
+                                new ast::CompoundStmt(location, std::move(fixer.core.destroyStmts)),
+                                ast::Storage::Static, ast::Linkage::C,
+                                {new ast::Attribute("destructor", std::move(dtorParams))});
 
                         translationUnit.decls.emplace_back(destroyFunction);

src/InitTweak/FixInitNew.cpp

@@ -16 +16 @@
 #include "CodeGen/GenType.h"           // for genPrettyType
 #include "CodeGen/OperatorTable.h"
+#include "Common/CodeLocationTools.hpp"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithStmtsToAdd
 #include "Common/SemanticError.h"      // for SemanticError
@@ -85 +86 @@
         /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
         /// arguments and return value temporaries
-        struct ResolveCopyCtors final : public ast::WithGuards, public ast::WithStmtsToAdd<>, public ast::WithSymbolTable, public ast::WithShortCircuiting, public ast::WithVisitorRef<ResolveCopyCtors> {
+        struct ResolveCopyCtors final : public ast::WithGuards, public ast::WithStmtsToAdd<>, public ast::WithSymbolTable, public ast::WithShortCircuiting, public ast::WithVisitorRef<ResolveCopyCtors>, public ast::WithConstTranslationUnit {
                 const ast::Expr * postvisit( const ast::ImplicitCopyCtorExpr * impCpCtorExpr );
                 const ast::StmtExpr * previsit( const ast::StmtExpr * stmtExpr );
@@ -189 +190 @@
         /// for any member that is missing a corresponding ctor/dtor call.
         /// error if a member is used before constructed
-        struct GenStructMemberCalls final : public ast::WithGuards, public ast::WithShortCircuiting, public ast::WithSymbolTable, public ast::WithVisitorRef<GenStructMemberCalls> {
+        struct GenStructMemberCalls final : public ast::WithGuards, public ast::WithShortCircuiting, public ast::WithSymbolTable, public ast::WithVisitorRef<GenStructMemberCalls>, public ast::WithConstTranslationUnit {
                 void previsit( const ast::FunctionDecl * funcDecl );
                 const ast::DeclWithType * postvisit( const ast::FunctionDecl * funcDecl );
@@ -214 +215 @@
 
         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
-        struct FixCtorExprs final : public ast::WithDeclsToAdd<>, public ast::WithSymbolTable, public ast::WithShortCircuiting {
+        struct FixCtorExprs final : public ast::WithDeclsToAdd<>, public ast::WithSymbolTable, public ast::WithShortCircuiting, public ast::WithConstTranslationUnit {
                 const ast::Expr * postvisit( const ast::ConstructorExpr * ctorExpr );
         };
@@ -509 +510 @@
                 // (VariableExpr and already resolved expression)
                 CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                ast::ptr<ast::Expr> resolved = ResolvExpr::findVoidExpression(untyped, symtab);
+                ast::ptr<ast::Expr> resolved = ResolvExpr::findVoidExpression(untyped, { symtab, transUnit().global } );
                 assert( resolved );
                 if ( resolved->env ) {
@@ -553 +554 @@
                 ast::ptr<ast::Expr> guard = mutArg;
 
-                ast::ptr<ast::ObjectDecl> tmp = new ast::ObjectDecl({}, "__tmp", mutResult, nullptr );
+                ast::ptr<ast::ObjectDecl> tmp = new ast::ObjectDecl(loc, "__tmp", mutResult, nullptr );
 
                 // create and resolve copy constructor
@@ -587 +588 @@
 
         ast::Expr * ResolveCopyCtors::destructRet( const ast::ObjectDecl * ret, const ast::Expr * arg ) {
+                auto global = transUnit().global;
                 // TODO: refactor code for generating cleanup attribute, since it's common and reused in ~3-4 places
                 // check for existing cleanup attribute before adding another(?)
                 // need to add __Destructor for _tmp_cp variables as well
 
-                assertf( ast::dtorStruct, "Destructor generation requires __Destructor definition." );
-                assertf( ast::dtorStruct->members.size() == 2, "__Destructor definition does not have expected fields." );
-                assertf( ast::dtorStructDestroy, "Destructor generation requires __destroy_Destructor." );
+                assertf( global.dtorStruct, "Destructor generation requires __Destructor definition." );
+                assertf( global.dtorStruct->members.size() == 2, "__Destructor definition does not have expected fields." );
+                assertf( global.dtorDestroy, "Destructor generation requires __destroy_Destructor." );
 
                 const CodeLocation loc = ret->location;
@@ -610 +612 @@
                 auto dtorFunc = getDtorFunc( ret, new ast::ExprStmt(loc, dtor ), stmtsToAddBefore );
 
-                auto dtorStructType = new ast::StructInstType(ast::dtorStruct);
+                auto dtorStructType = new ast::StructInstType( global.dtorStruct );
 
                 // what does this do???
@@ -622 +624 @@
                 static UniqueName namer( "_ret_dtor" );
                 auto retDtor = new ast::ObjectDecl(loc, namer.newName(), dtorStructType, new ast::ListInit(loc, { new ast::SingleInit(loc, ast::ConstantExpr::null(loc) ), new ast::SingleInit(loc, new ast::CastExpr( new ast::VariableExpr(loc, dtorFunc ), dtorType ) ) } ) );
-                retDtor->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr(loc, ast::dtorStructDestroy ) } ) );
+                retDtor->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr(loc, global.dtorDestroy ) } ) );
                 stmtsToAddBefore.push_back( new ast::DeclStmt(loc, retDtor ) );
 
                 if ( arg ) {
-                        auto member = new ast::MemberExpr(loc, ast::dtorStruct->members.front().strict_as<ast::DeclWithType>(), new ast::VariableExpr(loc, retDtor ) );
+                        auto member = new ast::MemberExpr(loc, global.dtorStruct->members.front().strict_as<ast::DeclWithType>(), new ast::VariableExpr(loc, retDtor ) );
                         auto object = new ast::CastExpr( new ast::AddressExpr( new ast::VariableExpr(loc, ret ) ), new ast::PointerType(new ast::VoidType() ) );
                         ast::Expr * assign = createBitwiseAssignment( member, object );
@@ -799 +801 @@
         // to prevent warnings ('_unq0' may be used uninitialized in this function),
         // insert an appropriate zero initializer for UniqueExpr temporaries.
-        ast::Init * makeInit( const ast::Type * t ) {
+        ast::Init * makeInit( const ast::Type * t, CodeLocation const & loc ) {
                 if ( auto inst = dynamic_cast< const ast::StructInstType * >( t ) ) {
                         // initizer for empty struct must be empty
-                        if ( inst->base->members.empty() ) return new ast::ListInit({}, {});
+                        if ( inst->base->members.empty() ) {
+                                return new ast::ListInit( loc, {} );
+                        }
                 } else if ( auto inst = dynamic_cast< const ast::UnionInstType * >( t ) ) {
                         // initizer for empty union must be empty
-                        if ( inst->base->members.empty() ) return new ast::ListInit({}, {});
-                }
-
-                return new ast::ListInit( {}, { new ast::SingleInit( {}, ast::ConstantExpr::from_int({}, 0) ) } );
+                        if ( inst->base->members.empty() ) {
+                                return new ast::ListInit( loc, {} );
+                        }
+                }
+
+                return new ast::ListInit( loc, {
+                        new ast::SingleInit( loc, ast::ConstantExpr::from_int( loc, 0 ) )
+                } );
         }
 
@@ -832 +840 @@
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                mutExpr->object = new ast::ObjectDecl( mutExpr->location, toString("_unq", mutExpr->id), mutExpr->result, makeInit( mutExpr->result ) );
+                                mutExpr->object = new ast::ObjectDecl( mutExpr->location, toString("_unq", mutExpr->id), mutExpr->result, makeInit( mutExpr->result, mutExpr->location ) );
                                 mutExpr->var = new ast::VariableExpr( mutExpr->location, mutExpr->object );
                         }
@@ -1172 +1180 @@
                         auto guard = makeFuncGuard( [this]() { symtab.enterScope(); }, [this]() { symtab.leaveScope(); } );
                         symtab.addFunction( function );
+                        auto global = transUnit().global;
 
                         // need to iterate through members in reverse in order for
@@ -1217 +1226 @@
 
                                                         static UniqueName memberDtorNamer = { "__memberDtor" };
-                                                        assertf( ast::dtorStruct, "builtin __Destructor not found." );
-                                                        assertf( ast::dtorStructDestroy, "builtin __destroy_Destructor not found." );
+                                                        assertf( global.dtorStruct, "builtin __Destructor not found." );
+                                                        assertf( global.dtorDestroy, "builtin __destroy_Destructor not found." );
 
                                                         ast::Expr * thisExpr = new ast::CastExpr( new ast::AddressExpr( new ast::VariableExpr(loc, thisParam ) ), new ast::PointerType( new ast::VoidType(), ast::CV::Qualifiers() ) );
@@ -1228 +1237 @@
                                                         auto dtorType = new ast::PointerType( dtorFtype );
 
-                                                        auto destructor = new ast::ObjectDecl(loc, memberDtorNamer.newName(), new ast::StructInstType( ast::dtorStruct ), new ast::ListInit(loc, { new ast::SingleInit(loc, thisExpr ), new ast::SingleInit(loc, new ast::CastExpr( dtorExpr, dtorType ) ) } ) );
-                                                        destructor->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr({}, ast::dtorStructDestroy ) } ) );
+                                                        auto destructor = new ast::ObjectDecl(loc, memberDtorNamer.newName(), new ast::StructInstType( global.dtorStruct ), new ast::ListInit(loc, { new ast::SingleInit(loc, thisExpr ), new ast::SingleInit(loc, new ast::CastExpr( dtorExpr, dtorType ) ) } ) );
+                                                        destructor->attributes.push_back( new ast::Attribute( "cleanup", { new ast::VariableExpr( loc, global.dtorDestroy ) } ) );
                                                         mutStmts->push_front( new ast::DeclStmt(loc, destructor ) );
                                                         mutStmts->kids.splice( mutStmts->kids.begin(), stmtsToAdd );
@@ -1323 +1332 @@
 
         const ast::Expr * GenStructMemberCalls::postvisit( const ast::UntypedExpr * untypedExpr ) {
-                // Expression * newExpr = untypedExpr;
                 // xxx - functions returning ast::ptr seems wrong...
-                auto res = ResolvExpr::findVoidExpression( untypedExpr, symtab );
-                return res.release();
-                // return newExpr;
+                auto res = ResolvExpr::findVoidExpression( untypedExpr, { symtab, transUnit().global } );
+                // Fix CodeLocation (at least until resolver is fixed).
+                auto fix = localFillCodeLocations( untypedExpr->location, res.release() );
+                return strict_dynamic_cast<const ast::Expr *>( fix );
         }
 
@@ -1361 +1370 @@
 
                 // resolve assignment and dispose of new env
-                auto resolved = ResolvExpr::findVoidExpression( assign, symtab );
+                auto resolved = ResolvExpr::findVoidExpression( assign, { symtab, transUnit().global } );
                 auto mut = resolved.get_and_mutate();
                 assertf(resolved.get() == mut, "newly resolved expression must be unique");

src/InitTweak/GenInit.cc

@@ -402 +402 @@
                                         retVal->location, "?{}", retVal, stmt->expr );
                                 assertf( ctorStmt,
-                                        "ReturnFixer: genCtorDtor returned nllptr: %s / %s",
+                                        "ReturnFixer: genCtorDtor returned nullptr: %s / %s",
                                         toString( retVal ).c_str(),
                                         toString( stmt->expr ).c_str() );
-                                        stmtsToAddBefore.push_back( ctorStmt );
+                                stmtsToAddBefore.push_back( ctorStmt );
 
                                 // Return the retVal object.
@@ -421 +421 @@
         void genInit( ast::TranslationUnit & transUnit ) {
                 ast::Pass<HoistArrayDimension_NoResolve_New>::run( transUnit );
+                ast::Pass<ReturnFixer_New>::run( transUnit );
+        }
+
+        void fixReturnStatements( ast::TranslationUnit & transUnit ) {
                 ast::Pass<ReturnFixer_New>::run( transUnit );
         }

src/InitTweak/GenInit.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct 22 16:08:00 2021
-// Update Count     : 6
+// Last Modified On : Fri Mar 18 14:22:00 2022
+// Update Count     : 7
 //
 
@@ -31 +31 @@
         /// Converts return statements into copy constructor calls on the hidden return variable
         void fixReturnStatements( std::list< Declaration * > & translationUnit );
+        void fixReturnStatements( ast::TranslationUnit & translationUnit );
 
         /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument

src/InitTweak/InitTweak.cc

@@ -423 +423 @@
                                 loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
 
-                        std::vector< ast::ptr< ast::Stmt > > branches;
+                        std::vector< ast::ptr< ast::CaseClause > > branches;
                         for ( const ast::Init * init : *listInit ) {
                                 auto condition = ast::ConstantExpr::from_ulong( loc, cond );
@@ -432 +432 @@
                                 stmts.emplace_back(
                                         new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
-                                branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+                                branches.emplace_back( new ast::CaseClause{ loc, condition, std::move( stmts ) } );
                         }
                         out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );