Changes in src/InitTweak/FixGlobalInit.cc [6fbe9a5:490fb92e]

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(std::list<ast::ptr<ast::Decl>> & 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.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.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 ) {
-                                // Translation 1: Add this attribute on the global declaration:
-                                //    __attribute__((section (".data#")))
-                                // which makes gcc put the global in the data section,
-                                // so that the global is writeable (via a const cast) in the init function.
-                                // The trailing # is an injected assembly comment, to suppress the "a" in
-                                //    .section .data,"a"
-                                //    .section .data#,"a"
-                                // to avoid assembler warning "ignoring changed section attributes for .data"
-                                Type *strLitT = new PointerType( Type::Qualifiers( ),
-                                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
-                                std::list< Expression * > attr_params;
-                                attr_params.push_back( 
-                                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
-                                objDecl->attributes.push_back(new Attribute("section", attr_params));
-                                // Translation 2: Move the initizliation off the global declaration,
-                                // into the startup function.
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;
@@ -142 +167 @@
         }
 
+        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 ) {
+                                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; }