Changes in src/GenPoly/Box.cc [4318107:bd85400]

File:

• src/GenPoly/Box.cc (modified) (16 diffs)

src/GenPoly/Box.cc

@@ -73 +73 @@
                         /// Makes a new temporary array holding the offsets of the fields of `type`, and returns a new variable expression referencing it
                         Expression *makeOffsetArray( StructInstType *type );
-                        /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
-                        void passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes );
                         /// passes extra type parameters into a polymorphic function application
-                        void passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
+                        void passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars );
                         /// wraps a function application with a new temporary for the out-parameter return value
                         Expression *addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg );
@@ -400 +398 @@
                 }
 
-                void Pass1::passArgTypeVars( ApplicationExpr *appExpr, Type *parmType, Type *argBaseType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars, std::set< std::string > &seenTypes ) {
-                        Type *polyBase = hasPolyBase( parmType, exprTyVars );
-                        if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
-                                std::string sizeName = sizeofName( polyBase );
-                                if ( seenTypes.count( sizeName ) ) return;
-
-                                arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
-                                arg++;
-                                arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
-                                arg++;
-                                if ( dynamic_cast< StructInstType* >( polyBase ) ) {
-                                        if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
-                                                arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
-                                                arg++;
-                                        } else {
-                                                throw SemanticError( "Cannot pass non-struct type for generic struct" );
-                                        }
-                                }
-
-                                seenTypes.insert( sizeName );
-                        }
-                }
-
-                void Pass1::passTypeVars( ApplicationExpr *appExpr, ReferenceToType *polyRetType, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
                         // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
@@ -449 +424 @@
                         std::list< Expression* >::const_iterator fnArg = arg;
                         std::set< std::string > seenTypes; //< names for generic types we've seen
-
-                        // a polymorphic return type may need to be added to the argument list
-                        if ( polyRetType ) {
-                                Type *concRetType = replaceWithConcrete( appExpr, polyRetType );
-                                passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes );
-                        }
-                        
-                        // add type information args for presently unseen types in parameter list
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
-                                VariableExpr *fnArgBase = getBaseVar( *fnArg );
-                                if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue;
-                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes );
+                                Type *polyBase = hasPolyBase( (*fnParm)->get_type(), exprTyVars );
+                                if ( polyBase && ! dynamic_cast< TypeInstType* >( polyBase ) ) {
+                                        std::string sizeName = sizeofName( polyBase );
+                                        if ( seenTypes.count( sizeName ) ) continue;
+
+                                        VariableExpr *fnArgBase = getBaseVar( *fnArg );
+                                        assert( fnArgBase && ! fnArgBase->get_results().empty() );
+                                        Type *argBaseType = fnArgBase->get_results().front();
+                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( argBaseType->clone() ) );
+                                        arg++;
+                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( argBaseType->clone() ) );
+                                        arg++;
+                                        if ( dynamic_cast< StructInstType* >( polyBase ) ) {
+                                                if ( StructInstType *argBaseStructType = dynamic_cast< StructInstType* >( argBaseType ) ) {
+                                                        arg = appExpr->get_args().insert( arg, makeOffsetArray( argBaseStructType ) );
+                                                        arg++;
+                                                } else {
+                                                        throw SemanticError( "Cannot pass non-struct type for generic struct" );
+                                                }
+                                        }
+
+                                        seenTypes.insert( sizeName );
+                                }
                         }
                 }
@@ -483 +470 @@
                         ObjectDecl *newObj = makeTemporary( retType->clone() );
                         Expression *paramExpr = new VariableExpr( newObj );
-
-                        // If the type of the temporary is not polymorphic, box temporary by taking its address;
-                        // otherwise the temporary is already boxed and can be used directly.
+                        // If the type of the temporary is not polymorphic, box temporary by taking its address; otherwise the
+                        // temporary is already boxed and can be used directly.
                         if ( ! isPolyType( newObj->get_type(), scopeTyVars, env ) ) {
                                 paramExpr = new AddressExpr( paramExpr );
@@ -534 +520 @@
                         assert( env );
                         Type *concrete = replaceWithConcrete( appExpr, polyType );
-                        // add out-parameter for return value   
                         return addRetParam( appExpr, function, concrete, arg );
                 }
@@ -557 +542 @@
                         assert( ! arg->get_results().empty() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_results().front() ) ) {
-                                        // if the argument's type is polymorphic, we don't need to box again!
+                                if ( dynamic_cast< TypeInstType *>( arg->get_results().front() ) ) {
+                                        // if the argument's type is a type parameter, we don't need to box again!
                                         return;
                                 } else if ( arg->get_results().front()->get_isLvalue() ) {
@@ -637 +622 @@
                         assert( arg );
                         if ( isPolyType( realParam->get_type(), tyVars ) ) {
-                                if ( ! isPolyType( arg->get_type() ) ) {
+                                if ( dynamic_cast<TypeInstType *>(arg->get_type()) == NULL ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
@@ -932 +917 @@
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
 
-                        TyVarMap exprTyVars;
-                        makeTyVarMap( function, exprTyVars );
-                        ReferenceToType *polyRetType = 0;
-
-                        if ( polyRetType = isPolyRet( function ) ) {
-                                ret = addPolyRetParam( appExpr, function, polyRetType, arg );
+                        if ( ReferenceToType *polyType = isPolyRet( function ) ) {
+                                ret = addPolyRetParam( appExpr, function, polyType, arg );
                         } else if ( needsAdapter( function, scopeTyVars ) ) {
                                 // std::cerr << "needs adapter: ";
@@ -949 +930 @@
                         arg = appExpr->get_args().begin();
 
-                        passTypeVars( appExpr, polyRetType, arg, exprTyVars );
+                        TyVarMap exprTyVars;
+                        makeTyVarMap( function, exprTyVars );
+
+                        passTypeVars( appExpr, arg, exprTyVars );
                         addInferredParams( appExpr, function, arg, exprTyVars );
 
@@ -1008 +992 @@
                 }
 
-                /// Wraps a function declaration in a new pointer-to-function variable expression
-                VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) {
-                        // line below cloned from FixFunction.cc
-                        ObjectDecl *functionObj = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
-                                                                  new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
-                        functionObj->set_mangleName( functionDecl->get_mangleName() );
-                        return new VariableExpr( functionObj );
-                }
-                
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
@@ -1032 +1007 @@
 
                                 // find assignment operator for (polymorphic) return type
-                                ApplicationExpr *assignExpr = 0;
+                                DeclarationWithType *assignDecl = 0;
                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) {
-                                        // find assignment operator for type variable
                                         std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
                                         if ( assignIter == assignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
                                         } // if
-                                        assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
+                                        assignDecl = assignIter->second;
                                 } else if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( retval->get_type() ) ) {
-                                        // find assignment operator for generic type
                                         ScopedMap< std::string, DeclarationWithType *>::const_iterator assignIter = scopedAssignOps.find( refType->get_name() );
                                         if ( assignIter == scopedAssignOps.end() ) {
                                                 throw SemanticError( "Attempt to return dtype or ftype generic object in ", returnStmt->get_expr() );
                                         }
-
-                                        // wrap it up in an application expression
                                         DeclarationWithType *functionDecl = assignIter->second;
-                                        assignExpr = new ApplicationExpr( wrapFunctionDecl( functionDecl ) );
-                                        assignExpr->set_env( env->clone() );
-
-                                        // find each of its needed secondary assignment operators
-                                        std::list< Expression* > &tyParams = refType->get_parameters();
-                                        std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall();
-                                        std::list< Expression* >::const_iterator tyIt = tyParams.begin();
-                                        std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
-                                        for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
-                                                if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; // skip types with no assign op (ftype/dtype)
-
-                                                std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions();
-                                                assert( ! asserts.empty() && "Type param needs assignment operator assertion" );
-                                                DeclarationWithType *actualDecl = asserts.front();
-                                                ReferenceToType *actualType = isAssignment( actualDecl );
-                                                assert( actualType && "First assertion of type with assertions should be assignment operator" );
-                                                TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt );
-                                                assert( formalTypeExpr && "type parameters must be type expressions" );
-                                                Type *formalType = formalTypeExpr->get_type();
-                                                assignExpr->get_env()->add( actualType->get_name(), formalType );
-                                                
-                                                DeclarationWithType *assertAssign = 0;
-                                                if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) {
-                                                        std::map< std::string, DeclarationWithType *>::const_iterator assertAssignIt = assignOps.find( formalTypeInstType->get_name() );
-                                                        if ( assertAssignIt == assignOps.end() ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalTypeInstType );
-                                                        }
-                                                        assertAssign = assertAssignIt->second;
-                                                        //assignExpr->get_env()->add( formalTypeInstType->get_name(), actualType );
-                                                } else if ( ReferenceToType *formalReferenceType = dynamic_cast< ReferenceToType* >( formalType ) )  {
-                                                        ScopedMap< std::string, DeclarationWithType *>::const_iterator assertAssignIt = scopedAssignOps.find( formalReferenceType->get_name() );
-                                                        if ( assertAssignIt == scopedAssignOps.end() ) {
-                                                                throw SemanticError( "No assignment operation found for ", formalReferenceType );
-                                                        }
-                                                        assertAssign = assertAssignIt->second;
-                                                } else assert( false && "returning polymorphic types with non struct/polymorphic parameters not yet supported" );
-                                                
-
-                                                assignExpr->get_inferParams()[ actualDecl->get_uniqueId() ]
-                                                        = ParamEntry( assertAssign->get_uniqueId(), assertAssign->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertAssign ) );
-                                        }
+                                        // line below cloned from FixFunction.cc
+                                        assignDecl = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0,
+                                                                     new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
+                                        assignDecl->set_mangleName( functionDecl->get_mangleName() );
                                 }
-                                assert( assignExpr );
+                                assert( assignDecl );
 
                                 // replace return statement with appropriate assignment to out parameter
+                                ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignDecl ) );
                                 Expression *retParm = new NameExpr( retval->get_name() );
                                 retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
@@ -1245 +1180 @@
                         }
 
-                        // add size/align for generic parameter types to parameter list
+                        // add size/align for generic types to parameter list
                         std::set< std::string > seenTypes; // sizeofName for generic types we've seen
                         for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
@@ -1360 +1295 @@
 
                                 if ( DeclarationWithType *declWithType = dynamic_cast< DeclarationWithType* >( *decl ) ) {
-                                        if ( memberDecl->get_mangleName().empty() || declWithType->get_mangleName().empty()
-                                             || memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i;
+                                        if ( memberDecl->get_mangleName() == declWithType->get_mangleName() ) return i;
                                         else continue;
                                 } else return i;
@@ -1407 +1341 @@
                         if ( ! objectType ) return memberExpr;
 
-                        Expression *newMemberExpr = 0;
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) {
                                 // look up offset index
@@ -1417 +1350 @@
                                 fieldLoc->get_args().push_back( makeDerefdVar( varExpr->clone(), varDepth ) );
                                 fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) );
-                                newMemberExpr = fieldLoc;
-                        } else if ( dynamic_cast< UnionInstType* >( objectType ) ) {
+
+                                delete memberExpr;
+                                return fieldLoc;
+                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType ) ) {
                                 // union members are all at offset zero, so build appropriately-dereferenced variable
-                                newMemberExpr = makeDerefdVar( varExpr->clone(), varDepth );
+                                Expression *derefdVar = makeDerefdVar( varExpr->clone(), varDepth );
+                                delete memberExpr;
+                                return derefdVar;
                         } else return memberExpr;
-                        assert( newMemberExpr );
-
-                        // wrap pointer members in appropriate cast
-                        if ( dynamic_cast< PointerType* >( memberExpr->get_member()->get_type() ) ) {
-                                CastExpr *ptrCastExpr = new CastExpr( newMemberExpr, new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ) ) );
-                                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                                derefExpr->get_args().push_back( ptrCastExpr );
-                                newMemberExpr = derefExpr;
-                        }
-
-                        delete memberExpr;
-                        return newMemberExpr;
                 }
 
@@ -1454 +1379 @@
                                 delete offsetofExpr;
                                 return offsetInd;
-                        } else if ( dynamic_cast< UnionInstType* >( ty ) ) {
+                        } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( ty ) ) {
                                 // all union members are at offset zero
                                 delete offsetofExpr;