Changes in src/GenPoly/Lvalue.cc [f74eb47:a9b1b0c]

File:

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

src/GenPoly/Lvalue.cc

@@ -98 +98 @@
                 };
 
-                struct AddrRef final : public WithGuards, public WithVisitorRef<AddrRef>, public WithShortCircuiting {
+                struct AddrRef final : public WithGuards {
                         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
@@ -213 +208 @@
                                                 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;
@@ -246 +233 @@
 
                 // idea: &&&E: get outer &, inner &
-                // at inner &, record depth D of reference type of argument of &
+                // at inner &, record depth D of reference type
                 // at outer &, add D derefs.
-                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.
+                void AddrRef::premutate( Expression * ) {
                         GuardValue( current );
                         GuardValue( first );
@@ -258 +242 @@
                 }
 
-                void AddrRef::premutate( Expression * expr ) {
-                        handleNonAddr( expr );
-                        GuardValue( addCast );
-                        addCast = false;
-                }
-
                 void AddrRef::premutate( AddressExpr * ) {
                         GuardValue( current );
                         GuardValue( first );
-                        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
+                        current = first;
+                        first = false;
+                        if ( current ) {
                                 GuardValue( refDepth );
-                                refDepth = 0;  // set depth to 0 so that postmutate can find the innermost address-of easily
+                                refDepth = 0;
                         }
                 }
 
                 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();
-                                        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; )
+                                }
+                        }
+                        if ( current ) {
                                 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 ret;
+                        }
                         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 ) {
@@ -431 +376 @@
                                 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;
                         }