Changeset da7fe39 for src/GenPoly/Lvalue.cc

Timestamp:

Apr 23, 2018, 12:57:46 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

57acae0

Parents:

ba89e9b7 (diff), c8ad5d9 (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' into references

File:

• src/GenPoly/Lvalue.cc (modified) (5 diffs)

src/GenPoly/Lvalue.cc

@@ -99 +99 @@
                 };
 
-                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
@@ -215 +220 @@
                                                 )
                                                 // TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
-                                                // 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
-                                                //      // PRINT(
-                                                //              std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
-                                                //      // )
-                                                //      arg = new AddressExpr( arg );
-                                                // } else
-                                                // if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
-                                                if ( function->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getPointerBase( arg->result ) ) {
-
+
+                                                if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
                                                         // needed for definition of prelude functions, etc.
-
+                                                        // 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;
+                                                        )
+                                                        arg = new AddressExpr( arg );
+                                                // } else if ( function->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getPointerBase( arg->result ) ) {
+                                                } else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
                                                         // argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
                                                         PRINT(
@@ -247 +258 @@
 
                 // 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 );
@@ -256 +270 @@
                 }
 
+                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 ) {
@@ -391 +444 @@
                                 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;
                         }