Changeset 579263a for src/GenPoly

Timestamp:

Jun 26, 2017, 4:48:35 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:

bb1cd95

Parents:

e4d829b (diff), 2a7b3ca (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 designations

Conflicts:

src/InitTweak/FixInit.cc
src/SymTab/Autogen.h
src/SynTree/Initializer.cc
src/SynTree/Initializer.h
src/Tuples/TupleExpansion.cc

Location:

src/GenPoly

Files:

• Box.cc (modified) (12 diffs)
• DeclMutator.cc (modified) (2 diffs)
• InstantiateGeneric.cc (modified) (11 diffs)
• PolyMutator.cc (modified) (2 diffs)
• Specialize.cc (modified) (3 diffs)

src/GenPoly/Box.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 13 09:26:38 2017
-// Update Count     : 341
+// Last Modified On : Wed Jun 21 15:49:59 2017
+// Update Count     : 346
 //
 
@@ -108 +108 @@
                         Type *replaceWithConcrete( ApplicationExpr *appExpr, Type *type, bool doClone = true );
                         /// wraps a function application returning a polymorphic type with a new temporary for the out-parameter return value
-                        Expression *addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *polyType, std::list< Expression *>::iterator &arg );
+                        Expression *addDynRetParam( ApplicationExpr *appExpr, Type *polyType, std::list< Expression *>::iterator &arg );
                         Expression *applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         void boxParam( Type *formal, Expression *&arg, const TyVarMap &exprTyVars );
@@ -341 +341 @@
         Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
                 // check that the lhs is zeroed out to the level of rhs
-                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) );
+                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 // if not aligned, increment to alignment
                 Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
@@ -384 +384 @@
 
                 // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size)
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 0 ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 unsigned long n_members = 0;
                 bool firstMember = true;
@@ -441 +441 @@
 
                 // calculate union layout in function body
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
+                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant::from_ulong( 1 ) ) ) );
                 for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
                         DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
@@ -504 +504 @@
                 DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
+                                // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
                                 doBeginScope();
                                 scopeTyVars.beginScope();
@@ -548 +549 @@
                                 retval = oldRetval;
                                 doEndScope();
+                                // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
                         return functionDecl;
@@ -726 +728 @@
                 }
 
-                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *dynType, std::list< Expression *>::iterator &arg ) {
+                Expression *Pass1::addDynRetParam( ApplicationExpr *appExpr, Type *dynType, std::list< Expression *>::iterator &arg ) {
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, dynType );
@@ -1116 +1118 @@
 
                 Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
-                        // std::cerr << "mutate appExpr: ";
+                        // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
                         //      std::cerr << i->first << " ";
@@ -1141 +1143 @@
                         ReferenceToType *dynRetType = isDynRet( function, exprTyVars );
 
+                        // std::cerr << function << std::endl;
+                        // std::cerr << "scopeTyVars: ";
+                        // printTyVarMap( std::cerr, scopeTyVars );
+                        // std::cerr << "exprTyVars: ";
+                        // printTyVarMap( std::cerr, exprTyVars );
+                        // std::cerr << "env: " << *env << std::endl;
+                        // std::cerr << needsAdapter( function, scopeTyVars ) << ! needsAdapter( function, exprTyVars) << std::endl;
+
                         // NOTE: addDynRetParam needs to know the actual (generated) return type so it can make a temp variable, so pass the result type from the appExpr
                         // passTypeVars needs to know the program-text return type (i.e. the distinction between _conc_T30 and T3(int))
                         // concRetType may not be a good name in one or both of these places. A more appropriate name change is welcome.
                         if ( dynRetType ) {
+                                // std::cerr << "dynRetType: " << dynRetType << std::endl;
                                 Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();
-                                ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
+                                ret = addDynRetParam( appExpr, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType
                         } else if ( needsAdapter( function, scopeTyVars ) && ! needsAdapter( function, exprTyVars) ) { // xxx - exprTyVars is used above...?
                                 // xxx - the ! needsAdapter check may be incorrect. It seems there is some situation where an adapter is applied where it shouldn't be, and this fixes it for some cases. More investigation is needed.
@@ -1564 +1575 @@
                 /// Returns an index expression into the offset array for a type
                 Expression *makeOffsetIndex( Type *objectType, long i ) {
-                        std::stringstream offset_namer;
-                        offset_namer << i;
-                        ConstantExpr *fieldIndex = new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), offset_namer.str() ) );
+                        ConstantExpr *fieldIndex = new ConstantExpr( Constant::from_ulong( i ) );
                         UntypedExpr *fieldOffset = new UntypedExpr( new NameExpr( "?[?]" ) );
                         fieldOffset->get_args().push_back( new NameExpr( offsetofName( mangleType( objectType ) ) ) );
@@ -1779 +1788 @@
                                 // all union members are at offset zero
                                 delete offsetofExpr;
-                                return new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "0" ) );
+                                return new ConstantExpr( Constant::from_ulong( 0 ) );
                         } else return offsetofExpr;
                 }

src/GenPoly/DeclMutator.cc

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Fri Nov 27 14:44:00 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:16:43 2016
-// Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:49:00 2017
+// Update Count     : 4
 //
 
@@ -178 +178 @@
         Statement* DeclMutator::mutate(CatchStmt *catchStmt) {
                 catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+                catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) );
                 catchStmt->set_body( mutateStatement( catchStmt->get_body() ) );
                 return catchStmt;

src/GenPoly/InstantiateGeneric.cc

@@ -22 +22 @@
 #include "InstantiateGeneric.h"
 
-#include "DeclMutator.h"
 #include "GenPoly.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
-#include "PolyMutator.h"
+
+#include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
+#include "Common/UniqueName.h"
+#include "Common/utility.h"
 
 #include "ResolvExpr/typeops.h"
@@ -34 +37 @@
 #include "SynTree/Type.h"
 
-#include "Common/ScopedMap.h"
-#include "Common/UniqueName.h"
-#include "Common/utility.h"
+
+#include "InitTweak/InitTweak.h"
+
 
 namespace GenPoly {
@@ -153 +156 @@
         }
 
-        // collect the environments of each TypeInstType so that type variables can be replaced
-        // xxx - possibly temporary solution. Access to type environments is required in GenericInstantiator, but it needs to be a DeclMutator which does not provide easy access to the type environments.
-        class EnvFinder final : public GenPoly::PolyMutator {
-        public:
-                using GenPoly::PolyMutator::mutate;
-                virtual Type * mutate( TypeInstType * inst ) override {
-                        if ( env ) envMap[inst] = env;
-                        return inst;
-                }
-
-                // don't want to associate an environment with TypeInstTypes that occur in function types - this may actually only apply to function types belonging to DeclarationWithTypes (or even just FunctionDecl)?
-                virtual Type * mutate( FunctionType * ftype ) override {
-                        return ftype;
-                }
-                std::unordered_map< ReferenceToType *, TypeSubstitution * > envMap;
-        };
-
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-        class GenericInstantiator final : public DeclMutator {
+        struct GenericInstantiator final : public WithTypeSubstitution, public WithDeclsToAdd, public WithVisitorRef<GenericInstantiator>, public WithGuards {
                 /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
@@ -178 +164 @@
                 /// Namer for concrete types
                 UniqueName typeNamer;
-                /// Reference to mapping of environments
-                const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap;
-        public:
-                GenericInstantiator( const std::unordered_map< ReferenceToType *, TypeSubstitution * > & envMap ) : DeclMutator(), instantiations(), dtypeStatics(), typeNamer("_conc_"), envMap( envMap ) {}
-
-                using DeclMutator::mutate;
-                virtual Type* mutate( StructInstType *inst ) override;
-                virtual Type* mutate( UnionInstType *inst ) override;
-
-                virtual void doBeginScope() override;
-                virtual void doEndScope() override;
+                /// Should not make use of type environment to replace types of function parameter and return values.
+                bool inFunctionType = false;
+                GenericInstantiator() : instantiations(), dtypeStatics(), typeNamer("_conc_") {}
+
+                Type* postmutate( StructInstType *inst );
+                Type* postmutate( UnionInstType *inst );
+
+                void premutate( FunctionType * ftype ) {
+                        GuardValue( inFunctionType );
+                        inFunctionType = true;
+                }
+
+                void beginScope();
+                void endScope();
         private:
                 /// Wrap instantiation lookup for structs
@@ -207 +196 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
-                EnvFinder finder;
-                mutateAll( translationUnit, finder );
-                GenericInstantiator instantiator( finder.envMap );
-                instantiator.mutateDeclarationList( translationUnit );
+                PassVisitor<GenericInstantiator> instantiator;
+                mutateAll( translationUnit, instantiator );
         }
 
@@ -306 +293 @@
         Type *GenericInstantiator::replaceWithConcrete( Type *type, bool doClone ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
-                        if ( envMap.count( typeInst ) ) {
-                                TypeSubstitution * env = envMap.at( typeInst );
+                        if ( env && ! inFunctionType ) {
                                 Type *concrete = env->lookup( typeInst->get_name() );
                                 if ( concrete ) {
@@ -331 +317 @@
 
 
-        Type* GenericInstantiator::mutate( StructInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< StructInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( StructInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -368 +349 @@
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
-                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -388 +369 @@
         }
 
-        Type* GenericInstantiator::mutate( UnionInstType *inst ) {
-                // mutate subtypes
-                Type *mutated = Mutator::mutate( inst );
-                inst = dynamic_cast< UnionInstType* >( mutated );
-                if ( ! inst ) return mutated;
-
+        Type* GenericInstantiator::postmutate( UnionInstType *inst ) {
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
@@ -423 +399 @@
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
                                 insert( inst, typeSubs, concDecl ); // must insert before recursion
-                                concDecl->acceptMutator( *this ); // recursively instantiate members
-                                DeclMutator::addDeclaration( concDecl ); // must occur before declaration is added so that member instantiations appear first
+                                concDecl->acceptMutator( *visitor ); // recursively instantiate members
+                                declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
                         }
                         UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
@@ -442 +418 @@
         }
 
-        void GenericInstantiator::doBeginScope() {
-                DeclMutator::doBeginScope();
+        void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
                 dtypeStatics.beginScope();
         }
 
-        void GenericInstantiator::doEndScope() {
-                DeclMutator::doEndScope();
+        void GenericInstantiator::endScope() {
                 instantiations.endScope();
                 dtypeStatics.endScope();

src/GenPoly/PolyMutator.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug  4 11:26:22 2016
-// Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jun 22 13:47:00 2017
+// Update Count     : 17
 //
 
@@ -123 +123 @@
 
         Statement * PolyMutator::mutate(TryStmt *tryStmt) {
-                tryStmt->set_block(  maybeMutate( tryStmt->get_block(), *this ) );
+                tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
                 mutateAll( tryStmt->get_catchers(), *this );
+                tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) );
                 return tryStmt;
         }
 
         Statement * PolyMutator::mutate(CatchStmt *cathStmt) {
-                cathStmt->set_body(  mutateStatement( cathStmt->get_body() ) );
-                cathStmt->set_decl(  maybeMutate( cathStmt->get_decl(), *this ) );
+                cathStmt->set_body( mutateStatement( cathStmt->get_body() ) );
+                cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) );
+                cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) );
                 return cathStmt;
         }

src/GenPoly/Specialize.cc

@@ -93 +93 @@
         }
 
-        bool needsTupleSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
+        bool needsTupleSpecialization( Type *formalType, Type *actualType ) {
                 // Needs tuple specialization if the structure of the formal type and actual type do not match.
                 // This is the case if the formal type has ttype polymorphism, or if the structure  of tuple types
@@ -99 +99 @@
                 if ( FunctionType * fftype = getFunctionType( formalType ) ) {
                         if ( fftype->isTtype() ) return true;
+                        // conversion of 0 (null) to function type does not require tuple specialization
+                        if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );
@@ -112 +114 @@
 
         bool needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env ) {
-                return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType, env );
+                return needsPolySpecialization( formalType, actualType, env ) || needsTupleSpecialization( formalType, actualType );
         }