Changeset cce9429 for src/SymTab

Timestamp:

Dec 13, 2016, 6:42:39 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, 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:

1aa4b71

Parents:

31f379c

Message:

fix function return type in Validate and add single return decl, construct the return decl, fix polymorphic functions to use the return decl

File:

• src/SymTab/Validate.cc (modified) (13 diffs)

src/SymTab/Validate.cc

@@ -86 +86 @@
         };
 
+        /// Fix return types so that every function returns exactly one value
+        class ReturnTypeFixer : public Visitor {
+          public:
+                static void fix( std::list< Declaration * > &translationUnit );
+
+                virtual void visit( FunctionType * ftype );
+        };
+
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
         class EnumAndPointerDecayPass : public Visitor {
@@ -94 +102 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        class Pass2 final : public Indexer {
+        class LinkReferenceToTypes final : public Indexer {
                 typedef Indexer Parent;
           public:
-                Pass2( bool doDebug, const Indexer *indexer );
+                LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
           private:
                 using Indexer::visit;
@@ -193 +201 @@
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 EnumAndPointerDecayPass epc;
-                Pass2 pass2( doDebug, 0 );
+                LinkReferenceToTypes lrt( doDebug, 0 );
                 Pass3 pass3( 0 );
                 CompoundLiteral compoundliteral;
@@ -199 +207 @@
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
+                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
                 acceptAll( translationUnit, epc );
-                acceptAll( translationUnit, pass2 );
+                acceptAll( translationUnit, lrt );
                 ReturnChecker::checkFunctionReturns( translationUnit );
                 compoundliteral.mutateDeclarationList( translationUnit );
@@ -210 +219 @@
         void validateType( Type *type, const Indexer *indexer ) {
                 EnumAndPointerDecayPass epc;
-                Pass2 pass2( false, indexer );
+                LinkReferenceToTypes lrt( false, indexer );
                 Pass3 pass3( indexer );
                 type->accept( epc );
-                type->accept( pass2 );
+                type->accept( lrt );
                 type->accept( pass3 );
         }
@@ -324 +333 @@
         }
 
-        Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+        LinkReferenceToTypes::LinkReferenceToTypes( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
@@ -332 +341 @@
         }
 
-        void Pass2::visit( StructInstType *structInst ) {
+        void LinkReferenceToTypes::visit( StructInstType *structInst ) {
                 Parent::visit( structInst );
                 StructDecl *st = indexer->lookupStruct( structInst->get_name() );
@@ -346 +355 @@
         }
 
-        void Pass2::visit( UnionInstType *unionInst ) {
+        void LinkReferenceToTypes::visit( UnionInstType *unionInst ) {
                 Parent::visit( unionInst );
                 UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
@@ -359 +368 @@
         }
 
-        void Pass2::visit( TraitInstType *contextInst ) {
+        void LinkReferenceToTypes::visit( TraitInstType *contextInst ) {
                 Parent::visit( contextInst );
                 if ( contextInst->get_name() == "sized" ) {
@@ -398 +407 @@
         }
 
-        void Pass2::visit( StructDecl *structDecl ) {
+        void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
                 Parent::visit( structDecl );
@@ -412 +421 @@
         }
 
-        void Pass2::visit( UnionDecl *unionDecl ) {
+        void LinkReferenceToTypes::visit( UnionDecl *unionDecl ) {
                 Parent::visit( unionDecl );
                 if ( ! unionDecl->get_members().empty() ) {
@@ -425 +434 @@
         }
 
-        void Pass2::visit( TypeInstType *typeInst ) {
+        void LinkReferenceToTypes::visit( TypeInstType *typeInst ) {
                 if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
@@ -747 +756 @@
                 return new VariableExpr( newtempvar );
         }
+
+        void ReturnTypeFixer::fix( std::list< Declaration * > &translationUnit ) {
+                ReturnTypeFixer fixer;
+                acceptAll( translationUnit, fixer );
+        }
+
+        void ReturnTypeFixer::visit( FunctionType * ftype ) {
+                static UniqueName tempNamer( "_retval" );
+
+                // xxx - need to handle named return values - this information needs to be saved somehow
+                // so that resolution has access to the names.
+                // Note that this pass needs to happen early so that other passes which look for tuple types
+                // find them in all of the right places, including function return types.
+                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
+                if ( retVals.size() > 1 ) {
+                        // generate a single return parameter which is the tuple of all of the return values
+                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
+                        // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
+                        ObjectDecl * newRet = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+                        deleteAll( retVals );
+                        retVals.clear();
+                        retVals.push_back( newRet );
+                } else if ( retVals.size() == 1 ) {
+                        // ensure other return values have a name
+                        DeclarationWithType * ret = retVals.front();
+                        if ( ret->get_name() == "" ) {
+                                ret->set_name( tempNamer.newName() );
+                        }
+                }
+        }
 } // namespace SymTab