Changeset c331406 for src/InitTweak/FixInit.cc

Timestamp:

Aug 5, 2016, 11:03:04 AM (8 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

a2f920f

Parents:

5070fe4 (diff), 1b0020a (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 changes from master

File:

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

src/InitTweak/FixInit.cc

@@ -18 +18 @@
 #include <iterator>
 #include <algorithm>
+#include "InitTweak.h"
 #include "FixInit.h"
-#include "InitTweak.h"
+#include "FixGlobalInit.h"
 #include "ResolvExpr/Resolver.h"
 #include "ResolvExpr/typeops.h"
@@ -25 +26 @@
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
+#include "SynTree/Attribute.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
@@ -83 +85 @@
                 };
 
+                // debug
                 struct printSet {
                         typedef ObjDeclCollector::ObjectSet ObjectSet;
@@ -159 +162 @@
 
                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
+
+                        std::list< Declaration * > staticDtorDecls;
                 };
 
@@ -171 +176 @@
         } // namespace
 
-        void fix( std::list< Declaration * > & translationUnit ) {
+        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 );
+
                 InsertImplicitCalls::insert( translationUnit );
                 ResolveCopyCtors::resolveImplicitCalls( translationUnit );
@@ -194 +202 @@
                 void FixInit::fixInitializers( std::list< Declaration * > & translationUnit ) {
                         FixInit fixer;
-                        mutateAll( translationUnit, 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
                 }
 
@@ -422 +444 @@
                                 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 bool __objName_uninitialized = true;
-                                                // if (__objName_uninitialized) {
-                                                //   __ctor(__objName);
-                                                //   void dtor_atexit() {
-                                                //     __dtor(__objName);
+                                                // static T __objName_static_varN;
+                                                // void __objName_dtor_atexitN() {
+                                                //   __dtor__...;
+                                                // }
+                                                // int f(...) {
+                                                //   ...
+                                                //   static bool __objName_uninitialized = true;
+                                                //   if (__objName_uninitialized) {
+                                                //     __ctor(__objName);
+                                                //     __objName_uninitialized = false;
+                                                //     atexit(__objName_dtor_atexitN);
                                                 //   }
-                                                //   on_exit(dtorOnExit, &__objName);
-                                                //   __objName_uninitialized = false;
+                                                //   ...
                                                 // }
 
-                                                // generate first line
+                                                static UniqueName dtorCallerNamer( "_dtor_atexit" );
+
+                                                // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
@@ -439 +472 @@
                                                 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( "?=?" ) );
@@ -457 +481 @@
                                                 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 ) );
 
@@ -465 +487 @@
                                                 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 );
@@ -524 +585 @@
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
-                                        if ( dtor && ! isInstrinsicSingleArgCallStmt( dtor ) ) {
+                                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
                                                 // don't need to call intrinsic dtor, because it does nothing, but
                                                 // non-intrinsic dtors must be called