Changeset 6840e7c for src/InitTweak/GenInit.cc

Timestamp:

Oct 19, 2017, 12:01:04 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

837ce06

Parents:

b96ec83 (diff), a15b72c (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 branch 'master' into cleanup-dtors

File:

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

src/InitTweak/GenInit.cc

@@ -85 +85 @@
                 // should not have a ConstructorInit generated.
 
-                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
-                bool isManaged( Type * type ) const; // determine if type is managed
-                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
-                GenPoly::ScopedSet< std::string > managedTypes;
+                ManagedTypes managedTypes;
                 bool inFunction = false;
         };
@@ -129 +126 @@
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
-                        assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
-
-                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
+                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
+
+                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
+                                // return statement has already been mutated - don't need to do it again
+                                if ( varExpr->var == retVal ) return;
+                        }
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
 
                         // return the retVal object
-                        returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
+                        returnStmt->expr = new VariableExpr( returnVals.front() );
                 } // if
         }
@@ -199 +201 @@
         }
 
-        bool CtorDtor::isManaged( Type * type ) const {
+        bool ManagedTypes::isManaged( Type * type ) const {
                 // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
@@ -215 +217 @@
         }
 
-        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
@@ -223 +225 @@
         }
 
-        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+        void ManagedTypes::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() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
@@ -233 +235 @@
                 }
         }
+
+        void ManagedTypes::handleStruct( 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 ) ) {
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
+        void ManagedTypes::endScope() { managedTypes.endScope(); }
 
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
@@ -277 +296 @@
 
         void CtorDtor::previsit( ObjectDecl * objDecl ) {
-                handleDWT( objDecl );
+                managedTypes.handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
-                if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
+                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! 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 @=.\n", objDecl );
@@ -295 +314 @@
                 inFunction = true;
 
-                handleDWT( functionDecl );
+                managedTypes.handleDWT( functionDecl );
 
                 GuardScope( managedTypes );
@@ -301 +320 @@
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                handleDWT( assertion );
+                                managedTypes.handleDWT( assertion );
                         }
                 }
@@ -311 +330 @@
                 visit_children = false; // do not try to construct and destruct aggregate members
 
-                // 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 ) ) {
-                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
-                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
-                                        break;
-                                }
-                        }
-                }
+                managedTypes.handleStruct( aggregateDecl );
         }