Changes in src/InitTweak/GenInit.cc [cad355a:f9cebb5]

File:

• src/InitTweak/GenInit.cc (modified) (5 diffs)

src/InitTweak/GenInit.cc

@@ -26 +26 @@
 #include "SymTab/Autogen.h"
 #include "GenPoly/PolyMutator.h"
+#include "GenPoly/DeclMutator.h"
 
 namespace InitTweak {
@@ -55 +56 @@
           public:
                 /// create constructor and destructor statements for object declarations.
-                /// Destructors are inserted directly into the code, whereas constructors
-                /// will be added in after the resolver has run so that the initializer expression
-                /// is only removed if a constructor is found
+                /// the actual call statements will be added in after the resolver has run
+                /// so that the initializer expression is only removed if a constructor is found
+                /// and the same destructor call is inserted in all of the appropriate locations.
                 static void generateCtorDtor( std::list< Declaration * > &translationUnit );
-
-                CtorDtor() : inFunction( false ) {}
 
                 virtual DeclarationWithType * mutate( ObjectDecl * );
                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
-                virtual Declaration* mutate( StructDecl *aggregateDecl );
-                virtual Declaration* mutate( UnionDecl *aggregateDecl );
-                virtual Declaration* mutate( EnumDecl *aggregateDecl );
-                virtual Declaration* mutate( TraitDecl *aggregateDecl );
-                virtual TypeDecl* mutate( TypeDecl *typeDecl );
-                virtual Declaration* mutate( TypedefDecl *typeDecl );
-
-                virtual Type * mutate( FunctionType *funcType );
+                // should not traverse into any of these declarations to find objects
+                // that need to be constructed or destructed
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
+                virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
+
+                virtual Type * mutate( FunctionType *funcType ) { return funcType; }
 
           protected:
-                bool inFunction;
+        };
+
+        class HoistArrayDimension : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+
+                /// hoist dimension from array types in object declaration so that it uses a single
+                /// const variable of type size_t, so that side effecting array dimensions are only
+                /// computed once.
+                static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
+
+          private:
+                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+                // should not traverse into any of these declarations to find objects
+                // that need to be constructed or destructed
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
+                virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
+                virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
+
+                virtual Type* mutate( FunctionType *funcType ) { return funcType; }
+
+                void hoist( Type * type );
+
+                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
+                bool inFunction = false;
         };
 
         void genInit( std::list< Declaration * > & translationUnit ) {
                 ReturnFixer::makeReturnTemp( translationUnit );
+                HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
         }
@@ -124 +154 @@
         }
 
+        // precompute array dimension expression, because constructor generation may duplicate it,
+        // which would be incorrect if it is a side-effecting computation.
+        void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
+                HoistArrayDimension hoister;
+                hoister.mutateDeclarationList( translationUnit );
+        }
+
+        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
+                storageclass = objectDecl->get_storageClass();
+                DeclarationWithType * temp = Parent::mutate( objectDecl );
+                hoist( objectDecl->get_type() );
+                storageclass = DeclarationNode::NoStorageClass;
+                return temp;
+        }
+
+        void HoistArrayDimension::hoist( Type * type ) {
+                // if in function, generate const size_t var
+                static UniqueName dimensionName( "_array_dim" );
+
+                // C doesn't allow variable sized arrays at global scope or for static variables,
+                // so don't hoist dimension.
+                if ( ! inFunction ) return;
+                if ( storageclass == DeclarationNode::Static ) return;
+
+                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
+                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
+
+                        // don't need to hoist dimension if it's a constexpr - only need to if there's potential
+                        // for side effects.
+                        if ( isConstExpr( arrayType->get_dimension() ) ) return;
+
+                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
+                        arrayDimension->get_type()->set_isConst( true );
+
+                        arrayType->set_dimension( new VariableExpr( arrayDimension ) );
+                        addDeclaration( arrayDimension );
+
+                        hoist( arrayType->get_base() );
+                        return;
+                }
+        }
+
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                bool oldInFunc = inFunction;
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                inFunction = oldInFunc;
+                return decl;
+        }
 
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
@@ -130 +209 @@
         }
 
-        namespace {
-                Expression * makeCtorDtorExpr( std::string name, ObjectDecl * objDecl, std::list< Expression * > args ) {
-                        UntypedExpr * expr = new UntypedExpr( new NameExpr( name ) );
-                        expr->get_args().push_back( new AddressExpr( new VariableExpr( objDecl ) ) );
-                        expr->get_args().splice( expr->get_args().end(), args );
-                        return expr;
-                }
-        }
-
         DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
-                // hands off if designated or if @=
+                // hands off if designated, if @=, or if extern
                 if ( tryConstruct( objDecl ) ) {
-                        if ( inFunction ) {
-                                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
-                                        // call into makeArrayFunction from validate.cc to generate calls to ctor/dtor for each element of array
-                                        // TODO: walk initializer and generate appropriate copy ctor if element has initializer
-                                        std::list< Expression * > args = makeInitList( objDecl->get_init() );
-                                        if ( args.empty() ) {
-                                                std::list< Statement * > ctor;
-                                                std::list< Statement * > dtor;
-
-                                                SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "?{}", back_inserter( ctor ) );
-                                                SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "^?{}", front_inserter( dtor ), false );
-
-                                                // Currently makeArrayFunction produces a single Statement - a CompoundStmt
-                                                // which  wraps everything that needs to happen. As such, it's technically
-                                                // possible to use a Statement ** in the above calls, but this is inherently
-                                                // unsafe, so instead we take the slightly less efficient route, but will be
-                                                // immediately informed if somehow the above assumption is broken. In this case,
-                                                // we could always wrap the list of statements at this point with a CompoundStmt,
-                                                // but it seems reasonable at the moment for this to be done by makeArrayFunction
-                                                // itself
-                                                assert( ctor.size() == 1 && dynamic_cast< ImplicitCtorDtorStmt * >( ctor.front() ) );
-                                                assert( dtor.size() == 1 && dynamic_cast< ImplicitCtorDtorStmt * >( dtor.front() ) );
-                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
-                                        } else {
-                                                // array came with an initializer list: initialize each element
-                                                // may have more initializers than elements in the array - need to check at each index that
-                                                // we haven't exceeded size. This requires precomputing the size because it might be a side-effecting
-                                                // computation.
-                                                // may have fewer initializers than eleemnts in the array - need to default construct
-                                                // remaining elements.
-                                                // might be able to merge this with the case above.
-                                        }
-                                } else {
-                                        // it's sufficient to attempt to call the ctor/dtor for the given object and its initializer
-                                        Expression * ctor = makeCtorDtorExpr( "?{}", objDecl, makeInitList( objDecl->get_init() ) );
-                                        Expression * dtor = makeCtorDtorExpr( "^?{}", objDecl, std::list< Expression * >() );
-
-                                        // need to remember init expression, in case no ctors exist
-                                        // if ctor does exist, want to use ctor expression instead of init
-                                        // push this decision to the resolver
-                                        ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
-                                        ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
-                                        objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) );
-                                }
+                        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
+                        // for each constructable object
+                        std::list< Statement * > ctor;
+                        std::list< Statement * > dtor;
+
+                        InitExpander srcParam( objDecl->get_init() );
+                        InitExpander nullParam( (Initializer *)NULL );
+                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+                        SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+
+                        // Currently genImplicitCall produces a single Statement - a CompoundStmt
+                        // which  wraps everything that needs to happen. As such, it's technically
+                        // possible to use a Statement ** in the above calls, but this is inherently
+                        // unsafe, so instead we take the slightly less efficient route, but will be
+                        // immediately informed if somehow the above assumption is broken. In this case,
+                        // we could always wrap the list of statements at this point with a CompoundStmt,
+                        // but it seems reasonable at the moment for this to be done by genImplicitCall
+                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
+                        // an array type does not have a dimension). In this case, it's fine to ignore
+                        // the object for the purposes of construction.
+                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
+                        if ( ctor.size() == 1 ) {
+                                // need to remember init expression, in case no ctors exist
+                                // if ctor does exist, want to use ctor expression instead of init
+                                // push this decision to the resolver
+                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
+                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
                         }
                 }
@@ -193 +246 @@
         DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
                 // parameters should not be constructed and destructed, so don't mutate FunctionType
-                bool oldInFunc = inFunction;
                 mutateAll( functionDecl->get_oldDecls(), *this );
-                inFunction = true;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-                inFunction = oldInFunc;
                 return functionDecl;
         }
-
-        // should not traverse into any of these declarations to find objects
-        // that need to be constructed or destructed
-        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
-        Declaration* CtorDtor::mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
-        Declaration* CtorDtor::mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
-        Declaration* CtorDtor::mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
-        TypeDecl* CtorDtor::mutate( TypeDecl *typeDecl ) { return typeDecl; }
-        Declaration* CtorDtor::mutate( TypedefDecl *typeDecl ) { return typeDecl; }
-        Type* CtorDtor::mutate( FunctionType *funcType ) { return funcType; }
-
 } // namespace InitTweak