Changeset 72e9222

Timestamp:

Jul 22, 2016, 3:55:51 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

aedfd91

Parents:

ccb447e

Message:

change codegen for function-scoped static variable destruction to eliminate memory errors

Location:

src

Files:

• InitTweak/FixInit.cc (modified) (6 diffs)
• tests/init_once.c (modified) (2 diffs)

src/InitTweak/FixInit.cc

@@ -161 +161 @@
 
                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl );
+
+                        std::list< Declaration * > staticDtorDecls;
                 };
 
@@ -199 +201 @@
                 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 );
+                                        // if (! fixer.staticDtorDecls.empty() ) {
+                                                translationUnit.splice( i, fixer.staticDtorDecls );
+                                        // }
+                                } catch( SemanticError &e ) {
+                                        errors.append( e );
+                                } // try
+                        } // for
+                        if ( ! errors.isEmpty() ) {
+                                throw errors;
+                        } // if
                 }
 
@@ -427 +445 @@
                                 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, create a
+                                                // global static pointer that is set to refer to the object and make
+                                                // the dtor-caller function global so that.
+                                                //
                                                 // generate:
-                                                // static bool __objName_uninitialized = true;
-                                                // if (__objName_uninitialized) {
-                                                //   __ctor(__objName);
-                                                //   void dtor_atexit() {
-                                                //     __dtor(__objName);
+                                                // T * __objName_static_ptrN;
+                                                // void __objName_dtor_atexitN() {
+                                                //   __dtor(__objName_static_ptrN);
+                                                // }
+                                                // int f(...) {
+                                                //   ...
+                                                //   static T __objName;
+                                                //   static bool __objName_uninitialized = true;
+                                                //   if (__objName_uninitialized) {
+                                                //     __objName_ptr = &__objName;
+                                                //     __ctor(__objName);
+                                                //     on_exit(__objName_dtor_atexitN, &__objName);
+                                                //     __objName_uninitialized = false;
                                                 //   }
-                                                //   on_exit(dtorOnExit, &__objName);
-                                                //   __objName_uninitialized = false;
+                                                //   ...
                                                 // }
 
-                                                // generate first line
+                                                static UniqueName ptrNamer( "_static_ptr" );
+                                                static UniqueName dtorCallerNamer( "_dtor_atexit" );
+
+                                                // T * __objName_ptrN
+                                                ObjectDecl * objPtr = new ObjectDecl( objDecl->get_mangleName() + ptrNamer.newName(), DeclarationNode::Static, LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), objDecl->get_type()->clone() ), 0 );
+                                                objPtr->fixUniqueId();
+
+                                                // void __objName_dtor_atexitN(...) {...}
+                                                // need to modify dtor call so that it refers to objPtr, since function will be global
+                                                Statement * dtorStmt = ctorInit->get_dtor()->clone();
+                                                ApplicationExpr * dtor = dynamic_cast< ApplicationExpr * >( InitTweak::getCtorDtorCall( dtorStmt ) );
+                                                assert( dtor );
+                                                delete dtor->get_args().front();
+                                                dtor->get_args().front() = new VariableExpr( objPtr );
+
+                                                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 );
+
+                                                // static bool __objName_uninitialized = true
                                                 BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
                                                 SingleInit * boolInitExpr = new SingleInit( new ConstantExpr( Constant( boolType->clone(), "1" ) ), noDesignators );
@@ -444 +493 @@
                                                 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);
+                                                // __objName_static_ptrN = &__objName;
+                                                UntypedExpr * ptrAssign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                                ptrAssign->get_args().push_back( new VariableExpr( objPtr ) );
+                                                ptrAssign->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
+
+                                                // atexit(dtor_atexit);
                                                 UntypedExpr * callAtexit = new UntypedExpr( new NameExpr( "atexit" ) );
                                                 callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
@@ -462 +511 @@
                                                 std::list< Statement * > & body = initStmts->get_kids();
                                                 body.push_back( ctor );
-                                                body.push_back( new DeclStmt( noLabels, dtorCaller ) );
+                                                body.push_back( new ExprStmt( noLabels, ptrAssign ) );
                                                 body.push_back( new ExprStmt( noLabels, callAtexit ) );
                                                 body.push_back( new ExprStmt( noLabels, setTrue ) );
@@ -470 +519 @@
                                                 stmtsToAddAfter.push_back( new DeclStmt( noLabels, isUninitializedVar ) );
                                                 stmtsToAddAfter.push_back( ifStmt );
+
+                                                // add pointer and dtor caller decls to list of decls that will be added into global scope
+                                                staticDtorDecls.push_back( objPtr );
+                                                staticDtorDecls.push_back( dtorCaller );
                                         } else {
                                                 stmtsToAddAfter.push_back( ctor );

src/tests/init_once.c

@@ -92 +92 @@
 init_once y = x;
 
+void static_variable() {
+        static init_once x;
+}
+
 int main() {
         // local variables
@@ -179 +183 @@
                 }
         }
+
+        // function-scoped static variable
+        for (int i = 0; i < 10; i++) {
+                static_variable();
+        }
 }