Changeset 1ba88a0 for src/InitTweak

Timestamp:

Sep 4, 2016, 3:25:32 PM (9 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, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

b16898e

Parents:

85517ddb

Message:

implement implicit ctor/dtor deletion, track managed types when inserting ConstructorInit? nodes, remove fallbackInit case, update tests

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (1 diff)
• GenInit.cc (modified) (9 diffs)
• InitTweak.cc (modified) (2 diffs)

src/InitTweak/FixInit.cc ¶

@@ -787 +787 @@
                                 // need to iterate through members in reverse in order for
                                 // ctor/dtor statements to come out in the right order
-                                for ( Declaration * member : ReverseIterate( structDecl->get_members() ) ) {
+                                for ( Declaration * member : reverseIterate( structDecl->get_members() ) ) {
                                         DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member );
                                         // skip non-DWT members

src/InitTweak/GenInit.cc ¶

@@ -25 +25 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Autogen.h"
+#include "SymTab/Mangler.h"
 #include "GenPoly/PolyMutator.h"
 #include "GenPoly/DeclMutator.h"
+#include "GenPoly/ScopedSet.h"
 
 namespace InitTweak {
@@ -55 +57 @@
         class CtorDtor : public GenPoly::PolyMutator {
           public:
+                typedef GenPoly::PolyMutator Parent;
+                using Parent::mutate;
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -65 +69 @@
                 // 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( StructDecl *aggregateDecl );
                 virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
                 virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
@@ -74 +78 @@
                 virtual Type * mutate( FunctionType *funcType ) { return funcType; }
 
-          protected:
+                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
+
+          private:
+                // set of mangled type names for which a constructor or destructor exists in the current scope.
+                // these types require a ConstructorInit node to be generated, anything else is a POD type and thus
+                // should not have a ConstructorInit generated.
+
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                GenPoly::ScopedSet< std::string > managedTypes;
+                bool inFunction = false;
         };
 
@@ -142 +156 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                std::list<DeclarationWithType*> oldReturnVals = returnVals;
-                std::string oldFuncName = funcName;
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
+                ValueGuard< std::string > oldFuncName( funcName );
 
                 FunctionType * type = functionDecl->get_functionType();
@@ -149 +163 @@
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
-                returnVals = oldReturnVals;
-                funcName = oldFuncName;
                 return decl;
         }
@@ -197 +209 @@
 
         DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                bool oldInFunc = inFunction;
+                ValueGuard< bool > oldInFunc( inFunction );
                 inFunction = true;
                 DeclarationWithType * decl = Parent::mutate( functionDecl );
-                inFunction = oldInFunc;
                 return decl;
         }
@@ -209 +220 @@
         }
 
+        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+                Type * type = objDecl->get_type();
+                while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
+                        type = at->get_base();
+                }
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
+        }
+
+        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+                // if this function is a user-defined constructor or destructor, mark down the type as "managed"
+                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) {
+                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
+                        assert( ! params.empty() );
+                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
+                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
+                }
+        }
+
         DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
-                // hands off if designated, if @=, or if extern
-                if ( tryConstruct( objDecl ) ) {
+                handleDWT( objDecl );
+                // hands off if @=, extern, builtin, etc.
+                // if global but initializer is not constexpr, always try to construct, since this is not legal C
+                if ( ( tryConstruct( objDecl ) && isManaged( objDecl ) ) || (! inFunction && ! isConstExpr( objDecl->get_init() ) ) ) {
+                        // constructed objects cannot be designated
+                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.", objDecl );
+                        // xxx - constructed objects should not have initializers nested too deeply
+
                         // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
                         // for each constructable object
@@ -241 +276 @@
                         }
                 }
-                return Mutator::mutate( objDecl );
+                return Parent::mutate( objDecl );
         }
 
         DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc = inFunction;
+                inFunction = true;
+
+                handleDWT( functionDecl );
+
+                managedTypes.beginScope();
+                // go through assertions and recursively add seen ctor/dtors
+                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
+                        for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
+                                assertion = assertion->acceptMutator( *this );
+                        }
+                }
                 // parameters should not be constructed and destructed, so don't mutate FunctionType
                 mutateAll( functionDecl->get_oldDecls(), *this );
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+
+                managedTypes.endScope();
                 return functionDecl;
         }
+
+        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        managedTypes.insert( SymTab::Mangler::mangle( aggregateDecl ) );
+                                        break;
+                                }
+                        }
+                }
+                return aggregateDecl;
+        }
+
+        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
+                managedTypes.beginScope();
+                CompoundStmt * stmt = Parent::mutate( compoundStmt );
+                managedTypes.endScope();
+                return stmt;
+        }
+
 } // namespace InitTweak
 

src/InitTweak/InitTweak.cc ¶

@@ -232 +232 @@
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
                         (objDecl->get_init() == NULL ||
-                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) &&
-                        ! isDesignated( objDecl->get_init() )
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
                         && objDecl->get_storageClass() != DeclarationNode::Extern;
         }
@@ -391 +390 @@
                 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( NameExpr *nameExpr ) {
+                        // xxx - temporary hack, because 0 and 1 really should be constexprs, even though they technically aren't in Cforall today
+                        if ( nameExpr->get_name() != "0" && nameExpr->get_name() != "1" ) isConstExpr = false;
+                }
+                // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( AddressExpr *addressExpr ) {
+                        // address of a variable or member expression is constexpr
+                        Expression * arg = addressExpr->get_arg();
+                        if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) 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 );