Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 1aa4b712079414c5564f7303ac0f872c241ee810) +++ src/GenPoly/Box.cc (revision 5802a4f31015077b7a4161befcee3c8e98f2d693) @@ -54,4 +54,6 @@ #include "Common/UniqueName.h" #include "Common/utility.h" + +#include "InitTweak/InitTweak.h" #include // temporary @@ -113,5 +115,4 @@ void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ); /// Stores assignment operators from assertion list in local map of assignment operations - void findTypeOps( const Type::ForallList &forall ); void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars ); FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars ); @@ -121,12 +122,4 @@ ObjectDecl *makeTemporary( Type *type ); - ScopedMap< std::string, DeclarationWithType* > assignOps; ///< Currently known type variable assignment operators - ScopedMap< std::string, DeclarationWithType* > ctorOps; ///< Currently known type variable constructors - ScopedMap< std::string, DeclarationWithType* > copyOps; ///< Currently known type variable copy constructors - ScopedMap< std::string, DeclarationWithType* > dtorOps; ///< Currently known type variable destructors - ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps; ///< Currently known assignment operators - ResolvExpr::TypeMap< DeclarationWithType > scopedCtorOps; ///< Currently known assignment operators - ResolvExpr::TypeMap< DeclarationWithType > scopedCopyOps; ///< Currently known assignment operators - ResolvExpr::TypeMap< DeclarationWithType > scopedDtorOps; ///< Currently known assignment operators ScopedMap< std::string, DeclarationWithType* > adapters; ///< Set of adapter functions in the current scope @@ -500,170 +493,8 @@ Pass1::Pass1() : tempNamer( "_temp" ) {} - /// Returns T if the given declaration is a function with parameter (T*) for some TypeInstType T, NULL otherwise - TypeInstType *isTypeInstPtrFn( DeclarationWithType *decl ) { - if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) { - if ( funType->get_parameters().size() == 1 ) { - if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) { - if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) { - return refType; - } // if - } // if - } // if - } // if - return 0; - } - - /// Returns T if the given declaration is a function with parameters (T*, T) for some TypeInstType T, NULL otherwise - TypeInstType *isTypeInstPtrValFn( DeclarationWithType *decl ) { - if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) { - if ( funType->get_parameters().size() == 2 ) { - if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) { - if ( TypeInstType *refType = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) { - if ( TypeInstType *refType2 = dynamic_cast< TypeInstType *>( funType->get_parameters().back()->get_type() ) ) { - if ( refType->get_name() == refType2->get_name() ) { - return refType; - } // if - } // if - } // if - } // if - } // if - } // if - return 0; - } - - /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise - TypeInstType *isTypeInstAssignment( DeclarationWithType *decl ) { - return decl->get_name() == "?=?" ? isTypeInstPtrValFn( decl ) : 0; - } - - /// Returns T if the given declaration is (*?{})(T *) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise - TypeInstType *isTypeInstCtor( DeclarationWithType *decl ) { - return decl->get_name() == "?{}" ? isTypeInstPtrFn( decl ) : 0; - } - - /// Returns T if the given declaration is (*?{})(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise - TypeInstType *isTypeInstCopy( DeclarationWithType *decl ) { - return decl->get_name() == "?{}" ? isTypeInstPtrValFn( decl ) : 0; - } - - /// Returns T if the given declaration is (*^?{})(T *) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise - TypeInstType *isTypeInstDtor( DeclarationWithType *decl ) { - return decl->get_name() == "^?{}" ? isTypeInstPtrFn( decl ) : 0; - } - - /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified, - /// NULL otherwise - Type *isNoCvPtrFn( DeclarationWithType *decl ) { - if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) { - if ( funType->get_parameters().size() == 1 ) { - Type::Qualifiers defaultQualifiers; - Type *paramType = funType->get_parameters().front()->get_type(); - if ( paramType->get_qualifiers() != defaultQualifiers ) return 0; - - if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType ) ) { - Type *baseType = pointerType->get_base(); - if ( baseType->get_qualifiers() == defaultQualifiers ) { - return baseType; - } // if - } // if - } // if - } // if - return 0; - } - - /// Returns T if the given declaration is a function with parameters (T*, T) for some type T, where neither parameter is cv-qualified, - /// NULL otherwise - Type *isNoCvPtrValFn( DeclarationWithType *decl ) { - if ( FunctionType *funType = getFunctionType( decl->get_type() ) ) { - if ( funType->get_parameters().size() == 2 ) { - Type::Qualifiers defaultQualifiers; - Type *paramType1 = funType->get_parameters().front()->get_type(); - if ( paramType1->get_qualifiers() != defaultQualifiers ) return 0; - Type *paramType2 = funType->get_parameters().back()->get_type(); - if ( paramType2->get_qualifiers() != defaultQualifiers ) return 0; - - if ( PointerType *pointerType = dynamic_cast< PointerType* >( paramType1 ) ) { - Type *baseType1 = pointerType->get_base(); - if ( baseType1->get_qualifiers() != defaultQualifiers ) return 0; - SymTab::Indexer dummy; - if ( ResolvExpr::typesCompatible( baseType1, paramType2, dummy ) ) { - return baseType1; - } // if - } // if - } // if - } // if - return 0; - } - - /// returns T if the given declaration is: (*?=?)(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise - /// Only picks assignments where neither parameter is cv-qualified - Type *isAssignment( DeclarationWithType *decl ) { - return decl->get_name() == "?=?" ? isNoCvPtrValFn( decl ) : 0; - } - - /// returns T if the given declaration is: (*?{})(T *) for some type T, NULL otherwise - /// Only picks ctors where the parameter is not cv-qualified - Type *isCtor( DeclarationWithType *decl ) { - return decl->get_name() == "?{}" ? isNoCvPtrFn( decl ) : 0; - } - - /// returns T if the given declaration is: (*?{})(T *, T) for some type T (return not checked, but maybe should be), NULL otherwise - /// Only picks copy constructors where neither parameter is cv-qualified - Type *isCopy( DeclarationWithType *decl ) { - return decl->get_name() == "?{}" ? isNoCvPtrValFn( decl ) : 0; - } - - /// returns T if the given declaration is: (*?{})(T *) for some type T, NULL otherwise - /// Only picks ctors where the parameter is not cv-qualified - Type *isDtor( DeclarationWithType *decl ) { - return decl->get_name() == "^?{}" ? isNoCvPtrFn( decl ) : 0; - } - - void Pass1::findTypeOps( const Type::ForallList &forall ) { - // what if a nested function uses an assignment operator? - // assignOps.clear(); - for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) { - for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) { - std::string typeName; - if ( TypeInstType *typeInst = isTypeInstAssignment( *assert ) ) { - assignOps[ typeInst->get_name() ] = *assert; - } else if ( TypeInstType *typeInst = isTypeInstCtor( *assert ) ) { - ctorOps[ typeInst->get_name() ] = *assert; - } else if ( TypeInstType *typeInst = isTypeInstCopy( *assert ) ) { - copyOps[ typeInst->get_name() ] = *assert; - } else if ( TypeInstType *typeInst = isTypeInstDtor( *assert ) ) { - dtorOps[ typeInst->get_name() ] = *assert; - } // if - } // for - } // for - } - DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) { - // if this is a assignment function, put it in the map for this scope - if ( Type *paramType = isAssignment( functionDecl ) ) { - if ( ! dynamic_cast< TypeInstType* >( paramType ) ) { - scopedAssignOps.insert( paramType, functionDecl ); - } - } else if ( Type *paramType = isCtor( functionDecl ) ) { - if ( ! dynamic_cast< TypeInstType* >( paramType ) ) { - scopedCtorOps.insert( paramType, functionDecl ); - } - } else if ( Type *paramType = isCopy( functionDecl ) ) { - if ( ! dynamic_cast< TypeInstType* >( paramType ) ) { - scopedCopyOps.insert( paramType, functionDecl ); - } - } else if ( Type *paramType = isDtor( functionDecl ) ) { - if ( ! dynamic_cast< TypeInstType* >( paramType ) ) { - scopedDtorOps.insert( paramType, functionDecl ); - } - } - if ( functionDecl->get_statements() ) { // empty routine body ? doBeginScope(); scopeTyVars.beginScope(); - assignOps.beginScope(); - ctorOps.beginScope(); - copyOps.beginScope(); - dtorOps.beginScope(); DeclarationWithType *oldRetval = retval; @@ -683,5 +514,4 @@ FunctionType *functionType = functionDecl->get_functionType(); makeTyVarMap( functionDecl->get_functionType(), scopeTyVars ); - findTypeOps( functionDecl->get_functionType()->get_forall() ); std::list< DeclarationWithType *> ¶mList = functionType->get_parameters(); @@ -707,8 +537,4 @@ scopeTyVars.endScope(); - assignOps.endScope(); - ctorOps.endScope(); - copyOps.endScope(); - dtorOps.endScope(); retval = oldRetval; doEndScope(); @@ -811,11 +637,12 @@ Type *concRetType = replaceWithConcrete( appExpr, polyRetType ); passArgTypeVars( appExpr, polyRetType, concRetType, arg, exprTyVars, seenTypes ); + ++fnArg; // skip the return parameter in the argument list } // 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 ) continue; // xxx - previously had check for non-empty fnArgBase results - passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_result(), arg, exprTyVars, seenTypes ); + if ( ! (*fnArg)->get_result() ) continue; + Type * argType = (*fnArg)->get_result(); + passArgTypeVars( appExpr, (*fnParm)->get_type(), argType, arg, exprTyVars, seenTypes ); } } @@ -967,5 +794,8 @@ for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) { InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() ); - assert( inferParam != appExpr->get_inferParams().end() && "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" ); + if ( inferParam == appExpr->get_inferParams().end() ) { + std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl; + } + assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" ); Expression *newExpr = inferParam->second.expr->clone(); addCast( newExpr, (*assert)->get_type(), tyVars ); @@ -1295,11 +1125,13 @@ TyVarMap exprTyVars( TypeDecl::Data{} ); - makeTyVarMap( function, exprTyVars ); + makeTyVarMap( function, exprTyVars ); // xxx - should this take into account the variables already bound in scopeTyVars (i.e. remove them from exprTyVars?) ReferenceToType *dynRetType = isDynRet( function, exprTyVars ); - Type *concRetType = appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name? + Type *concRetType = appExpr->get_result()->isVoid() ? nullptr : appExpr->get_result();// ?: dynRetType; // xxx - is concRetType a good name? if ( dynRetType ) { ret = addDynRetParam( appExpr, function, concRetType, arg ); // xxx - used to use dynRetType instead of concRetType - } else if ( needsAdapter( function, scopeTyVars ) ) { + } 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. + // std::cerr << "needs adapter: "; // printTyVarMap( std::cerr, scopeTyVars ); @@ -1310,5 +1142,5 @@ arg = appExpr->get_args().begin(); - passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType + passTypeVars( appExpr, concRetType, arg, exprTyVars ); // xxx - used to use dynRetType instead of concRetType; this changed so that the correct type paramaters are passed for return types (it should be the concrete type's parameters, not the formal type's) addInferredParams( appExpr, function, arg, exprTyVars ); @@ -1369,124 +1201,15 @@ } - /// Wraps a function declaration in a new pointer-to-function variable expression - VariableExpr *wrapFunctionDecl( DeclarationWithType *functionDecl ) { - // line below cloned from FixFunction.cc - // xxx - functionObj is never added to a list of declarations... - // alternatively, this function could return a new VariableExpr( functionDecl ) and change the result type of the new expression - 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() ); - functionObj->set_scopeLevel( functionDecl->get_scopeLevel() ); - return new VariableExpr( functionObj ); - } - - /// Finds the operation declaration for a given type in one of the two maps - DeclarationWithType* findOpForType( Type *formalType, const ScopedMap< std::string, DeclarationWithType* >& ops, ResolvExpr::TypeMap< DeclarationWithType >& scopedOps ) { - if ( TypeInstType *formalTypeInstType = dynamic_cast< TypeInstType* >( formalType ) ) { - ScopedMap< std::string, DeclarationWithType *>::const_iterator opIt = ops.find( formalTypeInstType->get_name() ); - return opIt == ops.end() ? 0 : opIt->second; - } else { - return scopedOps.find( formalType ); - } - } - - /// Adds an assertion parameter to the application expression for the actual assertion declaration valued with the assert op - void addAssertionFor( ApplicationExpr *appExpr, DeclarationWithType *actualDecl, DeclarationWithType *assertOp ) { - appExpr->get_inferParams()[ actualDecl->get_uniqueId() ] - = ParamEntry( assertOp->get_uniqueId(), assertOp->get_type()->clone(), actualDecl->get_type()->clone(), wrapFunctionDecl( assertOp ) ); - } - Statement * Pass1::mutate( ReturnStmt *returnStmt ) { + // maybe need access to the env when mutating the expr + if ( Expression * expr = returnStmt->get_expr() ) { + if ( expr->get_env() ) { + env = expr->get_env(); + } + } + if ( retval && returnStmt->get_expr() ) { assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() ); - // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous. - // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) { - // by this point, a cast expr on a polymorphic return value is redundant - while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( returnStmt->get_expr() ) ) { - returnStmt->set_expr( castExpr->get_arg() ); - returnStmt->get_expr()->set_env( castExpr->get_env() ); - castExpr->set_env( 0 ); - castExpr->set_arg( 0 ); - delete castExpr; - } //while - - // find assignment operator for (polymorphic) return type - ApplicationExpr *assignExpr = 0; - if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() ) ) { - // find assignment operator for type variable - ScopedMap< 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 ) ); - } else if ( ReferenceToType *refType = dynamic_cast< ReferenceToType *>( retval->get_type() ) ) { - // find assignment operator for generic type - DeclarationWithType *functionDecl = scopedAssignOps.find( refType ); - if ( ! functionDecl ) { - throw SemanticError( "Attempt to return dtype or ftype generic object in ", returnStmt->get_expr() ); - } - - // wrap it up in an application expression - 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(); - Type::ForallList &forallParams = functionDecl->get_type()->get_forall(); - std::list< Expression* >::const_iterator tyIt = tyParams.begin(); - Type::ForallList::const_iterator forallIt = forallParams.begin(); - for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) { - // Add appropriate mapping to assignment expression environment - TypeExpr *formalTypeExpr = dynamic_cast< TypeExpr* >( *tyIt ); - assert( formalTypeExpr && "type parameters must be type expressions" ); - Type *formalType = formalTypeExpr->get_type(); - assignExpr->get_env()->add( (*forallIt)->get_name(), formalType ); - - // skip non-otype parameters (ftype/dtype) - // xxx - should this check whether the type is complete instead? - if ( (*forallIt)->get_kind() != TypeDecl::Any ) continue; - - // find otype operators for formal type - DeclarationWithType *assertAssign = findOpForType( formalType, assignOps, scopedAssignOps ); - if ( ! assertAssign ) throw SemanticError( "No assignment operation found for ", formalType ); - - DeclarationWithType *assertCtor = findOpForType( formalType, ctorOps, scopedCtorOps ); - if ( ! assertCtor ) throw SemanticError( "No default constructor found for ", formalType ); - - DeclarationWithType *assertCopy = findOpForType( formalType, copyOps, scopedCopyOps ); - if ( ! assertCopy ) throw SemanticError( "No copy constructor found for ", formalType ); - - DeclarationWithType *assertDtor = findOpForType( formalType, dtorOps, scopedDtorOps ); - if ( ! assertDtor ) throw SemanticError( "No destructor found for ", formalType ); - - // add inferred parameters for otype operators to assignment expression - // NOTE: Code here assumes that first four assertions are assign op, ctor, copy ctor, dtor, in that order - std::list< DeclarationWithType* > &asserts = (*forallIt)->get_assertions(); - assert( asserts.size() >= 4 && "Type param needs otype operator assertions" ); - - std::list< DeclarationWithType* >::iterator actualIt = asserts.begin(); - addAssertionFor( assignExpr, *actualIt, assertAssign ); - ++actualIt; - addAssertionFor( assignExpr, *actualIt, assertCtor ); - ++actualIt; - addAssertionFor( assignExpr, *actualIt, assertCopy ); - ++actualIt; - addAssertionFor( assignExpr, *actualIt, assertDtor ); - - } - } - assert( assignExpr ); - - // replace return statement with appropriate assignment to out parameter - Expression *retParm = new NameExpr( retval->get_name() ); - retParm->set_result( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) ); - assignExpr->get_args().push_back( retParm ); - assignExpr->get_args().push_back( returnStmt->get_expr() ); - stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) ); - // } else { - // useRetval = true; - // stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( returnStmt->get_expr() ) ) ); - // useRetval = false; - // } // if + delete returnStmt->get_expr(); returnStmt->set_expr( 0 ); } else { @@ -1518,16 +1241,8 @@ void Pass1::doBeginScope() { adapters.beginScope(); - scopedAssignOps.beginScope(); - scopedCtorOps.beginScope(); - scopedCopyOps.beginScope(); - scopedDtorOps.beginScope(); } void Pass1::doEndScope() { adapters.endScope(); - scopedAssignOps.endScope(); - scopedCtorOps.endScope(); - scopedCopyOps.endScope(); - scopedDtorOps.endScope(); } @@ -1569,7 +1284,4 @@ DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) { - if ( ! LinkageSpec::isBuiltin( functionDecl->get_linkage() ) ) { - // std::cerr << "mutating function: " << functionDecl->get_name() << std::endl; - } functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl, functionDecl->get_functionType() ) ); FunctionType * ftype = functionDecl->get_functionType(); @@ -1861,5 +1573,8 @@ // replace member expression with pointer to base plus offset UntypedExpr *fieldLoc = new UntypedExpr( new NameExpr( "?+?" ) ); - fieldLoc->get_args().push_back( makeDerefdVar( varExpr->clone(), varDepth ) ); + Expression * aggr = memberExpr->get_aggregate()->clone(); + delete aggr->get_env(); // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it + aggr->set_env( nullptr ); + fieldLoc->get_args().push_back( aggr ); fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) ); newMemberExpr = fieldLoc;