Changeset 5600747 for src/GenPoly/Box.cc

Timestamp:

Mar 8, 2018, 9:23:32 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

4c11fce, ab0203df

Parents:

e5d4e5c (diff), fb11446e (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• src/GenPoly/Box.cc (modified) (9 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 );
@@ -193 +195 @@
                         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?
                 };
 
@@ -1174 +1177 @@
                         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 +1190 @@
                 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 +1209 @@
                         // 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 +1253 @@
 
                 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 +1274 @@
 
                 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;
                                 }
                         }
@@ -1584 +1587 @@
                         assert( newMemberExpr );
 
-                        Type *memberType = memberExpr->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 +1603 @@
                         }
 
+                        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;
                 }