Changeset b03eed6 for src/GenPoly

Timestamp:

Apr 19, 2018, 5:54:41 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

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, with_gc

Children:

8633f060

Parents:

e16294d (diff), da9d79b (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

Location:

src/GenPoly

Files:

• InstantiateGeneric.cc (modified) (3 diffs)
• Lvalue.cc (modified) (5 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -496 +496 @@
         Expression * FixDtypeStatic::fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr ) {
                 // need to cast dtype-static member expressions to their actual type before that type is erased.
+                // NOTE: the casts here have the third argument (isGenerated) set to false so that these casts persist until Box, where they are needed.
                 auto & baseParams = *inst->get_baseParameters();
                 if ( isDtypeStatic( baseParams ) ) {
@@ -515 +516 @@
                                         // Note: this currently creates more temporaries than is strictly necessary, since it does not check for duplicate uses of the same member expression.
                                         static UniqueName tmpNamer( "_dtype_static_member_" );
-                                        Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ) );
+                                        Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ), false );
                                         ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), new ReferenceType( Type::Qualifiers(), concType ), new SingleInit( init ) );
                                         stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
@@ -521 +522 @@
                                 } else {
                                         // can simply add a cast to actual type
-                                        return new CastExpr( memberExpr, concType );
+                                        return new CastExpr( memberExpr, concType, false );
                                 }
                         }

src/GenPoly/Lvalue.cc

@@ -98 +98 @@
                 };
 
-                struct AddrRef final : public WithGuards {
+                struct AddrRef final : public WithGuards, public WithVisitorRef<AddrRef>, public WithShortCircuiting {
                         void premutate( AddressExpr * addrExpr );
                         Expression * postmutate( AddressExpr * addrExpr );
                         void premutate( Expression * expr );
+                        void premutate( ApplicationExpr * appExpr );
+                        void premutate( SingleInit * init );
+
+                        void handleNonAddr( Expression * );
 
                         bool first = true;
                         bool current = false;
                         int refDepth = 0;
+                        bool addCast = false;
                 };
         } // namespace
@@ -208 +213 @@
                                                 if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
                                                         // if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
+
+                                                        // NOTE: previously, this condition fixed
+                                                        //   void f(int *&);
+                                                        //   int & x = ...;
+                                                        //   f(&x);
+                                                        // But now this is taken care of by a reference cast added by AddrRef. Need to find a new
+                                                        // example or remove this branch.
+
                                                         PRINT(
                                                                 std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
@@ -233 +246 @@
 
                 // idea: &&&E: get outer &, inner &
-                // at inner &, record depth D of reference type
+                // at inner &, record depth D of reference type of argument of &
                 // at outer &, add D derefs.
-                void AddrRef::premutate( Expression * ) {
+                void AddrRef::handleNonAddr( Expression * ) {
+                        // non-address-of: reset status variables:
+                        // * current expr is NOT the first address-of expr in an address-of chain
+                        // * next seen address-of expr IS the first in the chain.
                         GuardValue( current );
                         GuardValue( first );
@@ -242 +258 @@
                 }
 
+                void AddrRef::premutate( Expression * expr ) {
+                        handleNonAddr( expr );
+                        GuardValue( addCast );
+                        addCast = false;
+                }
+
                 void AddrRef::premutate( AddressExpr * ) {
                         GuardValue( current );
                         GuardValue( first );
-                        current = first;
-                        first = false;
-                        if ( current ) {
+                        current = first; // is this the first address-of in the chain?
+                        first = false;   // from here out, no longer possible for next address-of to be first in chain
+                        if ( current ) { // this is the outermost address-of in a chain
                                 GuardValue( refDepth );
-                                refDepth = 0;
+                                refDepth = 0;  // set depth to 0 so that postmutate can find the innermost address-of easily
                         }
                 }
 
                 Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
+                        PRINT( std::cerr << "addr ref at " << addrExpr << std::endl; )
                         if ( refDepth == 0 ) {
+                                PRINT( std::cerr << "depth 0, get new depth..." << std::endl; )
+                                // this is the innermost address-of in a chain, record depth D
                                 if ( ! isIntrinsicReference( addrExpr->arg ) ) {
                                         // try to avoid ?[?]
+                                        // xxx - is this condition still necessary? intrinsicReferences should have a cast around them at this point, so I don't think this condition ever fires.
                                         refDepth = addrExpr->arg->result->referenceDepth();
-                                }
-                        }
-                        if ( current ) {
+                                        PRINT( std::cerr << "arg not intrinsic reference, new depth is: " << refDepth << std::endl; )
+                                } else {
+                                        assertf( false, "AddrRef : address-of should not have intrinsic reference argument: %s", toCString( addrExpr->arg ) );
+                                }
+                        }
+                        if ( current ) { // this is the outermost address-of in a chain
+                                PRINT( std::cerr << "current, depth is: " << refDepth << std::endl; )
                                 Expression * ret = addrExpr;
                                 while ( refDepth ) {
+                                        // add one dereference for each
                                         ret = mkDeref( ret );
                                         refDepth--;
                                 }
+
+                                if ( addCast ) {
+                                        PRINT( std::cerr << "adding cast..." << std::endl; )
+                                        return new CastExpr( ret, addrExpr->result->clone() );
+                                }
                                 return ret;
                         }
+                        PRINT( std::cerr << "not current..." << std::endl; )
                         return addrExpr;
                 }
+
+                void AddrRef::premutate( ApplicationExpr * appExpr ) {
+                        visit_children = false;
+                        GuardValue( addCast );
+                        handleNonAddr( appExpr );
+                        for ( Expression *& arg : appExpr->args ) {
+                                // each argument with address-of requires a cast
+                                addCast = true;
+                                arg = arg->acceptMutator( *visitor );
+                        }
+                }
+
+                void AddrRef::premutate( SingleInit * ) {
+                        GuardValue( addCast );
+                        // each initialization context with address-of requires a cast
+                        addCast = true;
+                }
+
 
                 Expression * ReferenceConversions::postmutate( AddressExpr * addrExpr ) {
@@ -376 +431 @@
                                 assert( diff == 0 );
                                 // conversion between references of the same depth
+                                if ( ResolvExpr::typesCompatible( castExpr->result, castExpr->arg->result, SymTab::Indexer() ) && castExpr->isGenerated ) {
+                                        // Remove useless generated casts
+                                        PRINT(
+                                                std::cerr << "types are compatible, removing cast: " << castExpr << std::endl;
+                                                std::cerr << "-- " << castExpr->result << std::endl;
+                                                std::cerr << "-- " << castExpr->arg->result << std::endl;
+                                        )
+                                        Expression * ret = castExpr->arg;
+                                        castExpr->arg = nullptr;
+                                        std::swap( castExpr->env, ret->env );
+                                        delete castExpr;
+                                        return ret;
+                                }
                                 return castExpr;
                         }