Changeset acd7c5dd

Timestamp:

Aug 8, 2017, 2:49:47 PM (7 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, resolv-new, with_gc

Children:

c92c09c

Parents:

56e49b0

Message:

Apply generalized lvalue pass to MemberExpr?

Location:

src/GenPoly

Files:

• Box.cc (modified) (3 diffs)
• Lvalue.cc (modified) (4 diffs)
• Lvalue.h (modified) (2 diffs)

src/GenPoly/Box.cc

@@ -27 +27 @@
 #include "Box.h"
 #include "DeclMutator.h"
+#include "Lvalue.h"
+#include "FindFunction.h"
 #include "PolyMutator.h"
-#include "FindFunction.h"
 #include "ScopedSet.h"
 #include "ScrubTyVars.h"
@@ -755 +756 @@
 
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assert( arg->has_result() );
+                        assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_result() ) ) {
+                                Type * newType = arg->get_result()->clone();
+                                if ( env ) env->apply( newType );
+                                std::auto_ptr<Type> manager( newType );
+                                if ( isPolyType( newType ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
                                 } else if ( arg->get_result()->get_lvalue() ) {
-                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
-                                        // xxx - need to test that this code is still reachable
-                                        if ( CommaExpr *commaArg = dynamic_cast< CommaExpr* >( arg ) ) {
-                                                commaArg->set_arg2( new AddressExpr( commaArg->get_arg2() ) );
-                                        } else {
-                                                arg = new AddressExpr( arg );
-                                        }
+                                        // argument expression may be CFA lvalue, but not C lvalue -- apply generalizedLvalue transformations.
+                                        arg =  generalizedLvalue( new AddressExpr( arg ) );
                                         if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
                                                 // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
@@ -1879 +1878 @@
                         return structDecl;
                 }
-                
+
                 Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
                         stripGenericMembers( unionDecl );

src/GenPoly/Lvalue.cc

@@ -27 +27 @@
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
+
 #include "ResolvExpr/Resolver.h"
+#include "ResolvExpr/TypeEnvironment.h"
 #include "ResolvExpr/typeops.h"
+#include "ResolvExpr/Unify.h"
 
 #include "Common/UniqueName.h"
@@ -60 +63 @@
                         typedef Mutator Parent;
 
+                        virtual Expression * mutate( MemberExpr * memExpr );
                         virtual Expression * mutate( AddressExpr * addressExpr );
+
+                        template<typename Func>
+                        Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
         } // namespace
@@ -71 +78 @@
                 acceptAll( translationUnit, p2 );
                 mutateAll( translationUnit, genLval );
+        }
+
+        Expression * generalizedLvalue( Expression * expr ) {
+                GeneralizedLvalue genLval;
+                return expr->acceptMutator( genLval );
         }
 
@@ -163 +175 @@
                 }
 
-                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
-                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
-                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
+                template<typename Func>
+                Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
+                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
                                 Expression * arg1 = commaExpr->get_arg1()->clone();
                                 Expression * arg2 = commaExpr->get_arg2()->clone();
-                                delete addrExpr;
-                                return new CommaExpr( arg1, new AddressExpr( arg2 ) );
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+                                return ret->acceptMutator( *this );
+                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
                                 Expression * arg1 = condExpr->get_arg1()->clone();
                                 Expression * arg2 = condExpr->get_arg2()->clone();
                                 Expression * arg3 = condExpr->get_arg3()->clone();
-                                delete addrExpr;
-                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+                                ret->set_env( expr->get_env() );
+                                expr->set_env( nullptr );
+                                delete expr;
+
+                                // conditional expr type may not be either of the argument types, need to unify
+                                using namespace ResolvExpr;
+                                Type* commonType = nullptr;
+                                TypeEnvironment newEnv;
+                                AssertionSet needAssertions, haveAssertions;
+                                OpenVarSet openVars;
+                                unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+                                ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
+                                return ret->acceptMutator( *this );
                         }
-                        return addrExpr;
+                        return expr;
+                }
+
+                Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+                        Parent::mutate( memExpr );
+                        return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                        return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
                 }
         } // namespace

src/GenPoly/Lvalue.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Lvalue.h -- 
+// Lvalue.h --
 //
 // Author           : Richard C. Bilson
@@ -23 +23 @@
         /// replaces return type of `lvalue T` with `T*`, along with appropriate address-of and dereference operators
         void convertLvalue( std::list< Declaration* >& translationUnit );
+
+        /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
+        Expression * generalizedLvalue( Expression * expr );
 } // namespace GenPoly