Changes in src/InitTweak/FixGlobalInit.cc [f9cebb5:ca35c51]

File:

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

src/InitTweak/FixGlobalInit.cc

@@ -46 +46 @@
                 FunctionDecl * destroyFunction;
         };
+
+        class ConstExprChecker : public Visitor {
+        public:
+                ConstExprChecker() : isConstExpr( true ) {}
+
+                virtual void visit( ApplicationExpr *applicationExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedExpr *untypedExpr ) { isConstExpr = false; }
+                virtual void visit( NameExpr *nameExpr ) { isConstExpr = false; }
+                virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( LabelAddressExpr *labAddressExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedMemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( MemberExpr *memberExpr ) { isConstExpr = false; }
+                virtual void visit( VariableExpr *variableExpr ) { isConstExpr = false; }
+                virtual void visit( ConstantExpr *constantExpr ) { /* bottom out */ }
+                // these might be okay?
+                // virtual void visit( SizeofExpr *sizeofExpr );
+                // virtual void visit( AlignofExpr *alignofExpr );
+                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetPackExpr *offsetPackExpr );
+                // virtual void visit( AttrExpr *attrExpr );
+                // virtual void visit( CommaExpr *commaExpr );
+                // virtual void visit( LogicalExpr *logicalExpr );
+                // virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
+                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
+                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
+                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
+
+                bool isConstExpr;
+        };
+
+        bool isConstExpr( Initializer * init ) {
+                if ( init ) {
+                        ConstExprChecker checker;
+                        init->accept( checker );
+                        return checker.isConstExpr;
+                } // if
+                // for all intents and purposes, no initializer means const expr
+                return true;
+        }
 
         void fixGlobalInit( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ) {
@@ -97 +140 @@
                 std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
 
+                if ( ! tryConstruct( objDecl ) ) return; // don't construct @= or designated objects
+                if ( objDecl->get_storageClass() == DeclarationNode::Extern ) return;
                 // C allows you to initialize objects with constant expressions
                 // xxx - this is an optimization. Need to first resolve constructors before we decide
@@ -102 +147 @@
                 // if ( isConstExpr( objDecl->get_init() ) ) return;
 
-                if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
-                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
-                        assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
+                if ( dynamic_cast< ArrayType * > ( objDecl->get_type() ) ) {
+                        // xxx - initialize each element of the array
+                } else {
+                        // steal initializer from object and attach it to a new temporary
+                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, objDecl->get_type()->clone(), objDecl->get_init() );
+                        objDecl->set_init( NULL );
+                        initStatements.push_back( new DeclStmt( noLabels, newObj ) );
 
-                        Statement * dtor = ctorInit->get_dtor();
-                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
-                                // don't need to call intrinsic dtor, because it does nothing, but
-                                // non-intrinsic dtors must be called
-                                destroyStatements.push_front( dtor );
-                                ctorInit->set_dtor( NULL );
-                        } // if
-                        if ( Statement * ctor = ctorInit->get_ctor() ) {
-                                initStatements.push_back( ctor );
-                                objDecl->set_init( NULL );
-                                ctorInit->set_ctor( NULL );
-                        } else if ( Initializer * init = ctorInit->get_init() ) {
-                                objDecl->set_init( init );
-                                ctorInit->set_init( NULL );
-                        } else {
-                                // no constructor and no initializer, which is okay
-                                objDecl->set_init( NULL );
-                        } // if
-                        delete ctorInit;
+                        // copy construct objDecl using temporary
+                        UntypedExpr * init = new UntypedExpr( new NameExpr( "?{}" ) );
+                        init->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
+                        init->get_args().push_back( new VariableExpr( newObj ) );
+                        initStatements.push_back( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, init ) ) );
+
+                        // add destructor calls to global destroy function
+                        UntypedExpr * destroy = new UntypedExpr( new NameExpr( "^?{}" ) );
+                        destroy->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
+                        destroyStatements.push_front( new ImplicitCtorDtorStmt( new ExprStmt( noLabels, destroy ) ) );
                 } // if
         }