Changes in src/InitTweak/FixInit.cc [f9cebb5:4e06c1e]

File:

• src/InitTweak/FixInit.cc (modified) (11 diffs)

src/InitTweak/FixInit.cc

@@ -18 +18 @@
 #include <iterator>
 #include <algorithm>
+#include "FixInit.h"
 #include "InitTweak.h"
-#include "FixInit.h"
-#include "FixGlobalInit.h"
 #include "ResolvExpr/Resolver.h"
 #include "ResolvExpr/typeops.h"
@@ -26 +25 @@
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Attribute.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
@@ -85 +83 @@
                 };
 
-                // debug
                 struct printSet {
                         typedef ObjDeclCollector::ObjectSet ObjectSet;
@@ -162 +159 @@
 
                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
-
-                        std::list< Declaration * > staticDtorDecls;
                 };
 
@@ -176 +171 @@
         } // namespace
 
-        void fix( std::list< Declaration * > & translationUnit, const std::string & filename, bool inLibrary ) {
-                // fixes ConstructorInit for global variables. should happen before fixInitializers.
-                InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
-
+        void fix( std::list< Declaration * > & translationUnit ) {
                 InsertImplicitCalls::insert( translationUnit );
                 ResolveCopyCtors::resolveImplicitCalls( translationUnit );
@@ -202 +194 @@
                 void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) {
                         FixInit fixer;
-
-                        // can't use mutateAll, because need to insert declarations at top-level
-                        // can't use DeclMutator, because sometimes need to insert IfStmt, etc.
-                        SemanticError errors;
-                        for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
-                                try {
-                                        *i = maybeMutate( *i, fixer );
-                                        translationUnit.splice( i, fixer.staticDtorDecls );
-                                } catch( SemanticError &e ) {
-                                        errors.append( e );
-                                } // try
-                        } // for
-                        if ( ! errors.isEmpty() ) {
-                                throw errors;
-                        } // if
+                        mutateAll( translationUnit, fixer );
                 }
 
@@ -444 +422 @@
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
                                         if ( objDecl->get_storageClass() == DeclarationNode::Static ) {
-                                                // originally wanted to take advantage of gcc nested functions, but
-                                                // we get memory errors with this approach. To remedy this, the static
-                                                // variable is hoisted when the destructor needs to be called.
-                                                //
                                                 // generate:
-                                                // static T __objName_static_varN;
-                                                // void __objName_dtor_atexitN() {
-                                                //   __dtor__...;
+                                                // static bool __objName_uninitialized = true;
+                                                // if (__objName_uninitialized) {
+                                                //   __ctor(__objName);
+                                                //   void dtor_atexit() {
+                                                //     __dtor(__objName);
+                                                //   }
+                                                //   on_exit(dtorOnExit, &__objName);
+                                                //   __objName_uninitialized = false;
                                                 // }
-                                                // int f(...) {
-                                                //   ...
-                                                //   static bool __objName_uninitialized = true;
-                                                //   if (__objName_uninitialized) {
-                                                //     __ctor(__objName);
-                                                //     __objName_uninitialized = false;
-                                                //     atexit(__objName_dtor_atexitN);
-                                                //   }
-                                                //   ...
-                                                // }
-
-                                                static UniqueName dtorCallerNamer( "_dtor_atexit" );
-
-                                                // static bool __objName_uninitialized = true
+
+                                                // generate first line
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
@@ -472 +439 @@
                                                 isUninitializedVar->fixUniqueId();
 
+                                                // void dtor_atexit(...) {...}
+                                                FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + "_dtor_atexit", DeclarationNode::NoStorageClass, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
+                                                dtorCaller->fixUniqueId();
+                                                dtorCaller->get_statements()->get_kids().push_back( ctorInit->get_dtor()->clone() );
+
+                                                // on_exit(dtor_atexit);
+                                                UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) );
+                                                callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
+
                                                 // __objName_uninitialized = false;
                                                 UntypedExpr * setTrue = new UntypedExpr( new NameExpr( "?=?" ) );
@@ -481 +457 @@
                                                 std::list< Statement * > & body = initStmts->get_kids();
                                                 body.push_back( ctor );
+                                                body.push_back( new DeclStmt( noLabels, dtorCaller ) );
+                                                body.push_back( new ExprStmt( noLabels, callAtexit ) );
                                                 body.push_back( new ExprStmt( noLabels, setTrue ) );
 
@@ -487 +465 @@
                                                 stmtsToAddAfter.push_back( new DeclStmt( noLabels, isUninitializedVar ) );
                                                 stmtsToAddAfter.push_back( ifStmt );
-
-                                                if ( ctorInit->get_dtor() ) {
-                                                        // if the object has a non-trivial destructor, have to
-                                                        // hoist it and the object into the global space and
-                                                        // call the destructor function with atexit.
-
-                                                        Statement * dtorStmt = ctorInit->get_dtor()->clone();
-
-                                                        // void __objName_dtor_atexitN(...) {...}
-                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), DeclarationNode::Static, LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ), false, false );
-                                                        dtorCaller->fixUniqueId();
-                                                        dtorCaller->get_statements()->get_kids().push_back( dtorStmt );
-
-                                                        // atexit(dtor_atexit);
-                                                        UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) );
-                                                        callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
-
-                                                        body.push_back( new ExprStmt( noLabels, callAtexit ) );
-
-                                                        // hoist variable and dtor caller decls to list of decls that will be added into global scope
-                                                        staticDtorDecls.push_back( objDecl );
-                                                        staticDtorDecls.push_back( dtorCaller );
-
-                                                        // need to rename object uniquely since it now appears
-                                                        // at global scope and there could be multiple function-scoped
-                                                        // static variables with the same name in different functions.
-                                                        static UniqueName staticNamer( "_static_var" );
-                                                        objDecl->set_mangleName( objDecl->get_mangleName() + staticNamer.newName() );
-
-                                                        objDecl->set_init( NULL );
-                                                        ctorInit->set_ctor( NULL );
-                                                        delete ctorInit;
-
-                                                        // xxx - temporary hack: need to return a declaration, but want to hoist the current object out of this scope
-                                                        // create a new object which is never used
-                                                        static UniqueName dummyNamer( "_dummy" );
-                                                        ObjectDecl * dummy = new ObjectDecl( dummyNamer.newName(), DeclarationNode::Static, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), 0, std::list< Attribute * >{ new Attribute("unused") } );
-                                                        return dummy;
-                                                }
                                         } else {
                                                 stmtsToAddAfter.push_back( ctor );
@@ -585 +524 @@
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
-                                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                        if ( dtor && ! isInstrinsicSingleArgCallStmt( dtor ) ) {
                                                 // don't need to call intrinsic dtor, because it does nothing, but
                                                 // non-intrinsic dtors must be called