Changeset 58fe85a for src/InitTweak/FixGlobalInit.cc

Timestamp:

Jan 7, 2021, 3:27:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

2b4daf2, 64aeca0

Parents:

3c64c668 (diff), eef8dfb (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' into park_unpark

File:

• src/InitTweak/FixGlobalInit.cc (modified) (5 diffs)

src/InitTweak/FixGlobalInit.cc

@@ -34 +34 @@
 #include "SynTree/Visitor.h"       // for acceptAll, Visitor
 
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+
 namespace InitTweak {
         class GlobalFixer : public WithShortCircuiting {
@@ -50 +54 @@
                 FunctionDecl * initFunction;
                 FunctionDecl * destroyFunction;
+        };
+
+        class GlobalFixer_new : public ast::WithShortCircuiting {
+        public:
+                void previsit (const ast::ObjectDecl *);
+                void previsit (const ast::FunctionDecl *) { visit_children = false; }
+                void previsit (const ast::StructDecl *) { visit_children = false; }
+                void previsit (const ast::UnionDecl *) { visit_children = false; }
+                void previsit (const ast::EnumDecl *) { visit_children = false; }
+                void previsit (const ast::TraitDecl *) { visit_children = false; }
+                void previsit (const ast::TypeDecl *) { visit_children = false; }
+
+                std::list< ast::ptr<ast::Stmt> > initStmts;
+                std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
 
@@ -91 +109 @@
         }
 
+        void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) {
+                ast::Pass<GlobalFixer_new> fixer;
+                accept_all(translationUnit, fixer);
+
+                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))});
+
+                        translationUnit.decls.emplace_back( initFunction );
+                } // if
+
+                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))});
+
+                        translationUnit.decls.emplace_back(destroyFunction);
+                } // if
+        }
+
         void GlobalFixer::previsit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
@@ -112 +153 @@
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
+                                addDataSectonAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;
@@ -126 +168 @@
         }
 
+        void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
+                auto mutDecl = mutate(objDecl);
+                assertf(mutDecl == objDecl, "Global object decl must be unique");
+                if ( auto ctorInit = objDecl->init.as<ast::ConstructorInit>() ) {
+                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                        assert( ! ctorInit->ctor || ! ctorInit->init );
+
+                        const ast::Stmt * dtor = ctorInit->dtor;
+                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                // don't need to call intrinsic dtor, because it does nothing, but
+                                // non-intrinsic dtors must be called
+                                destroyStmts.push_front( dtor );
+                                // ctorInit->dtor = nullptr;
+                        } // if
+                        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                                addDataSectionAttribute(mutDecl);
+                                initStmts.push_back( ctor );
+                                mutDecl->init = nullptr;
+                                // ctorInit->ctor = nullptr;
+                        } else if ( const ast::Init * init = ctorInit->init ) {
+                                mutDecl->init = init;
+                                // ctorInit->init = nullptr;
+                        } else {
+                                // no constructor and no initializer, which is okay
+                                mutDecl->init = nullptr;
+                        } // if
+                        // delete ctorInit;
+                } // if
+        }
+
         // only modify global variables
         void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }