Changeset 4573e3c


Ignore:
Timestamp:
Oct 25, 2017, 4:31:58 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
b226721
Parents:
13a6154
Message:

Fix pointer cast warning

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Box.cc

    r13a6154 r4573e3c  
    734734                                Type * newType = param->clone();
    735735                                if ( env ) env->apply( newType );
    736                                 ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
     736                                ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
    737737                                newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
    738738                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
     
    745745                }
    746746
     747                // find instances of polymorphic type parameters
     748                struct PolyFinder {
     749                        const TyVarMap * tyVars = nullptr;
     750                        bool found = false;
     751
     752                        void previsit( TypeInstType * t ) {
     753                                if ( isPolyType( t, *tyVars ) ) {
     754                                        found = true;
     755                                }
     756                        }
     757                };
     758
     759                // true if there is an instance of a polymorphic type parameter in t
     760                bool hasPolymorphism( Type * t, const TyVarMap &tyVars ) {
     761                        PassVisitor<PolyFinder> finder;
     762                        finder.pass.tyVars = &tyVars;
     763                        maybeAccept( t, finder );
     764                        return finder.pass.found;
     765                }
     766
    747767                /// cast parameters to polymorphic functions so that types are replaced with
    748768                /// void * if they are type parameters in the formal type.
    749769                /// this gets rid of warnings from gcc.
    750770                void addCast( Expression *&actual, Type *formal, const TyVarMap &tyVars ) {
    751                         if ( getFunctionType( formal ) ) {
     771                        // type contains polymorphism, but isn't exactly a polytype, in which case it
     772                        // has some real actual type (e.g. unsigned int) and casting to void * is wrong
     773                        if ( hasPolymorphism( formal, tyVars ) && ! isPolyType( formal, tyVars ) ) {
    752774                                Type * newType = formal->clone();
    753775                                newType = ScrubTyVars::scrub( newType, tyVars );
     
    757779
    758780                void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
    759                         for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
    760                                 assertf( arg != appExpr->get_args().end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
     781                        for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->parameters.end(); ++param, ++arg ) {
     782                                assertf( arg != appExpr->args.end(), "boxParams: missing argument for param %s to %s in %s", toString( *param ).c_str(), toString( function ).c_str(), toString( appExpr ).c_str() );
    761783                                addCast( *arg, (*param)->get_type(), exprTyVars );
    762784                                boxParam( (*param)->get_type(), *arg, exprTyVars );
     
    767789                        std::list< Expression *>::iterator cur = arg;
    768790                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
    769                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
     791                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
    770792                                        InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
    771                                         if ( inferParam == appExpr->get_inferParams().end() ) {
    772                                                 std::cerr << "looking for assertion: " << (*assert) << std::endl << appExpr << std::endl;
    773                                         }
    774                                         assertf( inferParam != appExpr->get_inferParams().end(), "NOTE: Explicit casts of polymorphic functions to compatible monomorphic functions are currently unsupported" );
     793                                        assertf( inferParam != appExpr->get_inferParams().end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
    775794                                        Expression *newExpr = inferParam->second.expr->clone();
    776795                                        addCast( newExpr, (*assert)->get_type(), tyVars );
     
    782801
    783802                void makeRetParm( FunctionType *funcType ) {
    784                         DeclarationWithType *retParm = funcType->get_returnVals().front();
     803                        DeclarationWithType *retParm = funcType->returnVals.front();
    785804
    786805                        // make a new parameter that is a pointer to the type of the old return value
     
    795814                        // actually make the adapter type
    796815                        FunctionType *adapter = adaptee->clone();
    797 //                      if ( ! adapter->get_returnVals().empty() && isPolyType( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
    798816                        if ( isDynRet( adapter, tyVars ) ) {
    799817                                makeRetParm( adapter );
Note: See TracChangeset for help on using the changeset viewer.