Changes in src/GenPoly/Box.cc [ba3706f:e16294d]

File:

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

src/GenPoly/Box.cc

@@ -163 +163 @@
                         void premutate( DeclStmt *declStmt );
                         Expression *postmutate( MemberExpr *memberExpr );
+                        void premutate( AddressExpr *addrExpr );
+                        Expression *postmutate( AddressExpr *addrExpr );
                         Expression *postmutate( SizeofExpr *sizeofExpr );
                         Expression *postmutate( AlignofExpr *alignofExpr );
@@ -182 +184 @@
                         /// change the type of generic aggregate members to char[]
                         void mutateMembers( AggregateDecl * aggrDecl );
+                        /// returns the calculated sizeof expression for ty, or nullptr for use C sizeof()
+                        Expression* genSizeof( Type* ty );
 
                         /// Enters a new scope for type-variables, adding the type variables from ty
@@ -193 +197 @@
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
+                        Expression * addrMember = nullptr;             ///< AddressExpr argument is MemberExpr?
                 };
 
@@ -215 +220 @@
         inline void mutateTranslationUnit( std::list< Declaration* > &translationUnit, MutatorType &mutator ) {
                 bool seenIntrinsic = false;
-                SemanticError errors;
+                SemanticErrorException errors;
                 for ( typename std::list< Declaration* >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                         try {
@@ -228 +233 @@
                                         assert( *i );
                                 } // if
-                        } catch( SemanticError &e ) {
-                                e.set_location( (*i)->location );
+                        } catch( SemanticErrorException &e ) {
                                 errors.append( e );
                         } // try
@@ -302 +306 @@
         Expression *makeOp( const std::string &name, Expression *arg ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( arg );
+                expr->args.push_back( arg );
                 return expr;
         }
@@ -309 +313 @@
         Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( lhs );
-                expr->get_args().push_back( rhs );
+                expr->args.push_back( lhs );
+                expr->args.push_back( rhs );
                 return expr;
         }
@@ -316 +320 @@
         /// Returns the dereference of a local pointer variable
         Expression *derefVar( ObjectDecl *var ) {
-                return makeOp( "*?", new VariableExpr( var ) );
+                return UntypedExpr::createDeref( new VariableExpr( var ) );
         }
 
@@ -380 +384 @@
                 unsigned long n_members = 0;
                 bool firstMember = true;
-                for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
+                for ( Declaration* member : structDecl->get_members() ) {
+                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( member );
                         assert( dwt );
                         Type *memberType = dwt->get_type();
@@ -576 +580 @@
                                                 }
                                         } else {
-                                                throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType );
+                                                SemanticError( argBaseType, "Cannot pass non-struct type for generic struct: " );
                                         }
                                 }
@@ -598 +602 @@
                                         } else {
                                                 // xxx - should this be an assertion?
-                                                throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr );
+                                                SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
                                         } // if
                                 } // if
@@ -831 +835 @@
                                 if ( ! isPolyType( arg->get_type() ) ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->set_result( arg->get_type()->clone() );
+                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                        deref->result = arg->get_type()->clone();
+                                        deref->result->set_lvalue( true );
                                         return deref;
                                 } // if
@@ -987 +992 @@
 
                 Expression *Pass1::handleIntrinsics( ApplicationExpr *appExpr ) {
-                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->get_function() ) ) {
-                                if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
-                                        if ( varExpr->get_var()->get_name() == "?[?]" ) {
+                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr *>( appExpr->function ) ) {
+                                if ( varExpr->var->linkage == LinkageSpec::Intrinsic ) {
+                                        if ( varExpr->var->name == "?[?]" ) {
                                                 assert( appExpr->result );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
-                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->args.front()->result, scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->args.back()->result, scopeTyVars, env );
                                                 assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
                                                 UntypedExpr *ret = 0;
@@ -1174 +1179 @@
                         if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
-                                        if ( name->get_name() == "*?" ) {
+                                        if ( name->name == "*?" ) {
                                                 Expression *ret = expr->args.front();
                                                 expr->args.clear();
@@ -1187 +1192 @@
                 void Pass1::premutate( AddressExpr * ) { visit_children = false; }
                 Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
-                        assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() );
+                        assert( addrExpr->arg->result && ! addrExpr->arg->result->isVoid() );
 
                         bool needs = false;
-                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
-                                if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
-                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
-                                                if ( name->get_name() == "*?" ) {
-                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
-                                                                assert( appExpr->get_function()->result );
-                                                                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->arg ) ) {
+                                if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
+                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
+                                                if ( name->name == "*?" ) {
+                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->args.front() ) ) {
+                                                                assert( appExpr->function->result );
+                                                                FunctionType *function = getFunctionType( appExpr->function->result );
                                                                 assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
@@ -1206 +1211 @@
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
-                        addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor );
+                        addrExpr->arg = addrExpr->arg->acceptMutator( *visitor );
                         // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
-                        bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
+                        bool polytype = isPolyType( addrExpr->arg->result, scopeTyVars, env );
                         if ( polytype || needs ) {
-                                Expression *ret = addrExpr->get_arg();
-                                delete ret->get_result();
-                                ret->set_result( addrExpr->get_result()->clone() );
-                                addrExpr->set_arg( 0 );
+                                Expression *ret = addrExpr->arg;
+                                delete ret->result;
+                                ret->result = addrExpr->result->clone();
+                                addrExpr->arg = nullptr;
                                 delete addrExpr;
                                 return ret;
@@ -1250 +1255 @@
 
                 void Pass2::addAdapters( FunctionType *functionType ) {
-                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
+                        std::list< DeclarationWithType *> &paramList = functionType->parameters;
                         std::list< FunctionType *> functions;
                         for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
@@ -1271 +1276 @@
 
                 DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
-                        FunctionType * ftype = functionDecl->get_functionType();
-                        if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
-                                if ( ! isPrefix( functionDecl->get_name(), "_thunk" ) && ! isPrefix( functionDecl->get_name(), "_adapter" ) ) { // xxx - remove check for prefix once thunks properly use ctor/dtors
-                                        assert( ftype->get_returnVals().size() == 1 );
-                                        DeclarationWithType * retval = ftype->get_returnVals().front();
-                                        if ( retval->get_name() == "" ) {
-                                                retval->set_name( "_retval" );
+                        FunctionType * ftype = functionDecl->type;
+                        if ( ! ftype->returnVals.empty() && functionDecl->statements ) {
+                                if ( ! isPrefix( functionDecl->name, "_thunk" ) && ! isPrefix( functionDecl->name, "_adapter" ) ) { // xxx - remove check for prefix once thunks properly use ctor/dtors
+                                        assert( ftype->returnVals.size() == 1 );
+                                        DeclarationWithType * retval = ftype->returnVals.front();
+                                        if ( retval->name == "" ) {
+                                                retval->name = "_retval";
                                         }
-                                        functionDecl->get_statements()->get_kids().push_front( new DeclStmt( retval ) );
+                                        functionDecl->statements->kids.push_front( new DeclStmt( retval ) );
                                         DeclarationWithType * newRet = retval->clone(); // for ownership purposes
-                                        ftype->get_returnVals().front() = newRet;
+                                        ftype->returnVals.front() = newRet;
                                 }
                         }
                         // errors should have been caught by this point, remove initializers from parameters to allow correct codegen of default arguments
-                        for ( Declaration * param : functionDecl->get_functionType()->get_parameters() ) {
+                        for ( Declaration * param : functionDecl->type->parameters ) {
                                 if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( param ) ) {
-                                        delete obj->get_init();
-                                        obj->set_init( nullptr );
+                                        delete obj->init;
+                                        obj->init = nullptr;
                                 }
                         }
@@ -1554 +1559 @@
                         // only mutate member expressions for polymorphic types
                         int tyDepth;
-                        Type *objectType = hasPolyBase( memberExpr->get_aggregate()->get_result(), scopeTyVars, &tyDepth );
+                        Type *objectType = hasPolyBase( memberExpr->aggregate->result, scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
                         findGeneric( objectType ); // ensure layout for this type is available
 
                         // replace member expression with dynamically-computed layout expression
-                        Expression *newMemberExpr = 0;
+                        Expression *newMemberExpr = nullptr;
                         if ( StructInstType *structType = dynamic_cast< StructInstType* >( objectType ) ) {
                                 // look up offset index
-                                long i = findMember( memberExpr->get_member(), structType->get_baseStruct()->get_members() );
+                                long i = findMember( memberExpr->member, structType->baseStruct->members );
                                 if ( i == -1 ) return memberExpr;
 
                                 // replace member expression with pointer to base plus offset
                                 UntypedExpr *fieldLoc = new UntypedExpr( new NameExpr( "?+?" ) );
-                                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 );
+                                Expression * aggr = memberExpr->aggregate->clone();
+                                delete aggr->env; // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it
+                                aggr->env = nullptr;
                                 fieldLoc->get_args().push_back( aggr );
                                 fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) );
-                                fieldLoc->set_result( memberExpr->get_result()->clone() );
+                                fieldLoc->set_result( memberExpr->result->clone() );
                                 newMemberExpr = fieldLoc;
                         } else if ( dynamic_cast< UnionInstType* >( objectType ) ) {
                                 // union members are all at offset zero, so just use the aggregate expr
-                                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 );
+                                Expression * aggr = memberExpr->aggregate->clone();
+                                delete aggr->env; // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it
+                                aggr->env= nullptr;
                                 newMemberExpr = aggr;
-                                newMemberExpr->set_result( memberExpr->get_result()->clone() );
+                                newMemberExpr->result = memberExpr->result->clone();
                         } else return memberExpr;
                         assert( newMemberExpr );
 
-                        Type *memberType = memberExpr->get_member()->get_type();
+                        // Must apply the generic substitution to the member type to handle cases where the member is a generic parameter substituted by a known concrete type, e.g.
+                        //   forall(otype T) struct Box { T x; }
+                        //   forall(otype T) f() {
+                        //     Box(T *) b; b.x;
+                        //   }
+                        // TODO: memberExpr->result should be exactly memberExpr->member->get_type() after substitution, so it doesn't seem like it should be necessary to apply the substitution manually. For some reason this is not currently the case. This requires more investigation.
+                        Type *memberType = memberExpr->member->get_type()->clone();
+                        TypeSubstitution sub = objectType->genericSubstitution();
+                        sub.apply( memberType );
                         if ( ! isPolyType( memberType, scopeTyVars ) ) {
                                 // Not all members of a polymorphic type are themselves of polymorphic type; in this case the member expression should be wrapped and dereferenced to form an lvalue
@@ -1592 +1605 @@
                         }
 
+                        delete memberType;
                         delete memberExpr;
                         return newMemberExpr;
                 }
 
+                void PolyGenericCalculator::premutate( AddressExpr * addrExpr ) {
+                        GuardValue( addrMember );
+                        // is the argument a MemberExpr before mutating?
+                        addrMember = dynamic_cast< MemberExpr * >( addrExpr->arg );
+                }
+
+                Expression * PolyGenericCalculator::postmutate( AddressExpr * addrExpr ) {
+                        if ( addrMember && addrMember != addrExpr->arg ) {
+                                // arg was a MemberExpr and has been mutated
+                                if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( addrExpr->arg ) ) {
+                                        if ( InitTweak::getFunctionName( untyped ) == "?+?" ) {
+                                                // MemberExpr was converted to pointer+offset, and it is not valid C to take the address of an addition, so strip the address-of
+                                                // TODO: should  addrExpr->arg->result be changed to addrExpr->result?
+                                                Expression * ret = addrExpr->arg;
+                                                addrExpr->arg = nullptr;
+                                                std::swap( addrExpr->env, ret->env );
+                                                delete addrExpr;
+                                                return ret;
+                                        }
+                                }
+                        }
+                        return addrExpr;
+                }
+
                 ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
-                        ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
+                        ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, nullptr, type, init );
                         stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
                         return newObj;
@@ -1711 +1749 @@
                 }
 
+                Expression * PolyGenericCalculator::genSizeof( Type* ty ) {
+                        if ( ArrayType * aty = dynamic_cast<ArrayType *>(ty) ) {
+                                // generate calculated size for possibly generic array
+                                Expression * sizeofBase = genSizeof( aty->get_base() );
+                                if ( ! sizeofBase ) return nullptr;
+                                Expression * dim = aty->get_dimension();
+                                aty->set_dimension( nullptr );
+                                return makeOp( "?*?", sizeofBase, dim );
+                        } else if ( findGeneric( ty ) ) {
+                                // generate calculated size for generic type
+                                return new NameExpr( sizeofName( mangleType( ty ) ) );
+                        } else return nullptr;
+                }
+
                 Expression *PolyGenericCalculator::postmutate( SizeofExpr *sizeofExpr ) {
-                        Type *ty = sizeofExpr->get_isType() ? sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
-                        if ( findGeneric( ty ) ) {
-                                Expression *ret = new NameExpr( sizeofName( mangleType( ty ) ) );
+                        Type *ty = sizeofExpr->get_isType() ? 
+                                sizeofExpr->get_type() : sizeofExpr->get_expr()->get_result();
+                        
+                        Expression * gen = genSizeof( ty );
+                        if ( gen ) {
                                 delete sizeofExpr;
-                                return ret;
-                        }
-                        return sizeofExpr;
+                                return gen;
+                        } else return sizeofExpr;
                 }