Changeset a465caf

Timestamp:

Aug 8, 2016, 4:20:29 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, 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:

0853178

Parents:

242d458

Message:

generate a field constructor for union types and some refactoring

Location:

src

Files:

• InitTweak/InitTweak.cc (modified) (2 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (3 diffs)

src/InitTweak/InitTweak.cc

@@ -291 +291 @@
         }
 
+        namespace {
+                template <typename Predicate>
+                bool allofCtorDtor( Statement * stmt, const Predicate & pred ) {
+                        std::list< Expression * > callExprs;
+                        collectCtorDtorCalls( stmt, callExprs );
+                        // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
+                        return std::all_of( callExprs.begin(), callExprs.end(), pred);
+                }
+        }
+
         bool isIntrinsicSingleArgCallStmt( Statement * stmt ) {
-                std::list< Expression * > callExprs;
-                collectCtorDtorCalls( stmt, callExprs );
-                // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
-                return std::all_of( callExprs.begin(), callExprs.end(), []( Expression * callExpr ){
+                return allofCtorDtor( stmt, []( Expression * callExpr ){
                         if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
                                 assert( ! appExpr->get_function()->get_results().empty() );
@@ -303 +310 @@
                         }
                         return false;
+                });
+        }
+
+        bool isIntrinsicCallStmt( Statement * stmt ) {
+                return allofCtorDtor( stmt, []( Expression * callExpr ) {
+                        return isIntrinsicCallExpr( callExpr );
                 });
         }

src/InitTweak/InitTweak.h

@@ -41 +41 @@
         /// Intended to be used for default ctor/dtor calls, but might have use elsewhere.
         /// Currently has assertions that make it less than fully general.
-        bool isIntrinsicSingleArgCallStmt( Statement * expr );
+        bool isIntrinsicSingleArgCallStmt( Statement * stmt );
+
+        /// True if stmt is a call statement where the function called is intrinsic.
+        bool isIntrinsicCallStmt( Statement * stmt );
 
         /// get all Ctor/Dtor call expressions from a Statement

src/ResolvExpr/Resolver.cc

@@ -550 +550 @@
                 }
 
-                // xxx - todo
-                // if ( InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
-                //      // can reduce the constructor down to a SingleInit using the
-                //      // second argument from the ctor call
-                // }
-
                 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
                         delete ctorInit->get_dtor();
                         ctorInit->set_dtor( NULL );
                 }
+
+                // xxx - todo -- what about arrays?
+                // if ( dtor == NULL && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                //      // can reduce the constructor down to a SingleInit using the
+                //      // second argument from the ctor call, since
+                //      delete ctorInit->get_ctor();
+                //      ctorInit->set_ctor( NULL );
+
+                //      Expression * arg =
+                //      ctorInit->set_init( new SingleInit( arg ) );
+                // }
         }
 } // namespace ResolvExpr

src/SymTab/Autogen.cc

@@ -68 +68 @@
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
                 copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
-                copy->get_args().push_back( new SizeofExpr( unionType ) );
+                copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
 
                 *out++ = new ExprStmt( noLabels, copy );
@@ -421 +421 @@
                 makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
                 if ( isGeneric ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
-
-                if ( ! isGeneric ) assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                else assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
 
                 // body of assignment and copy ctor is the same
                 copyCtorDecl->set_statements( assignDecl->get_statements()->clone() );
+
+                // create a constructor which takes the first member type as a parameter.
+                // for example, for Union A { int x; double y; }; generate
+                // void ?{}(A *, int)
+                // This is to mimic C's behaviour which initializes the first member of the union.
+                std::list<Declaration *> memCtors;
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
+                                ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
+
+                                FunctionType * memCtorType = ctorType->clone();
+                                memCtorType->get_parameters().push_back( srcParam );
+                                FunctionDecl * ctor = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, memCtorType, new CompoundStmt( noLabels ), true, false );
+                                ctor->fixUniqueId();
+
+                                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( ctor->get_statements()->get_kids() ) );
+                                memCtors.push_back( ctor );
+                                // only generate a ctor for the first field
+                                break;
+                        }
+                }
 
                 declsToAdd.push_back( assignDecl );
@@ -431 +451 @@
                 declsToAdd.push_back( copyCtorDecl );
                 declsToAdd.push_back( dtorDecl );
+                declsToAdd.splice( declsToAdd.end(), memCtors );
         }