Changeset 8a6cf7e

Timestamp:

Jul 26, 2017, 4:26:08 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:

2afec66

Parents:

d335627

Message:

Fix various reference features.

• Eliminate multiple address-ofs resulting from &(T&) [address-of reference-cast].
• Keep rvalue cast if reference base type is incompatible with rvalue type.
• Keep pointer qualifiers when eliminating reference types.
• Add VariableExpr::functionPointer helper function to create variable expressions with function pointer type.
• Change ConstructorExpr? translation so that it temporarily generates a 'fake' assignment operator rather than use UntypedExpr?, so that the correct transformations occur in the Lvalue pass. This is a hack that can be fixed once PassVisitor? properly supports Indexer.

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• GenPoly/Lvalue.cc (modified) (5 diffs)
• InitTweak/FixInit.cc (modified) (1 diff)
• SymTab/Autogen.h (modified) (1 diff)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Expression.h (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -661 +661 @@
                 extension( commaExpr );
                 output << "(";
+                if ( genC ) {
+                        // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
+                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
+                }
                 commaExpr->get_arg1()->accept( *this );
                 output << " , ";
@@ -724 +728 @@
                 for ( Statement * stmt : stmts ) {
                         output << lineDirective( stmt ) << indent;
-            output << printLabels( stmt->get_labels() );
+                        output << printLabels( stmt->get_labels() );
                         if ( i+1 == numStmts ) {
                                 // last statement in a statement expression needs to be handled specially -
@@ -769 +773 @@
         void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                Expression * expr = exprStmt->get_expr();
                 if ( genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
-                        expr = new CastExpr( expr );
-                }
-                expr->accept( *this );
+                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
+                }
+                exprStmt->get_expr()->accept( *this );
                 output << ";";
         }

src/GenPoly/Lvalue.cc

@@ -66 +66 @@
                 struct ReferenceConversions final {
                         Expression * postmutate( CastExpr * castExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
                 };
 
@@ -102 +103 @@
                 mutateAll( translationUnit, refCvt );
                 mutateAll( translationUnit, fixer );
-                mutateAll( translationUnit, elim );
                 mutateAll( translationUnit, genLval );
                 mutateAll( translationUnit, collapser );
+                mutateAll( translationUnit, elim );  // last because other passes need reference types to work
         }
 
         namespace {
-                Type* isLvalueRet( FunctionType *function ) {
-                        if ( function->get_returnVals().empty() ) return 0;
-                        Type *ty = function->get_returnVals().front()->get_type();
-                        return dynamic_cast< ReferenceType * >( ty ) ;
-                }
-
-                bool isIntrinsicApp( ApplicationExpr *appExpr ) {
-                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
-                                return varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic;
-                        } else {
-                                return false;
-                        } // if
-                }
-
-                bool isDeref( Expression * expr ) {
+                // true for intrinsic function calls that return a reference
+                bool isIntrinsicReference( Expression * expr ) {
                         if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
-                                return InitTweak::getFunctionName( untyped ) == "*?";
+                                std::string fname = InitTweak::getFunctionName( untyped );
+                                // known intrinsic-reference prelude functions
+                                return fname == "*?" || fname == "?[?]";
                         } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
                                 if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
-                                        return func->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getFunctionName( appExpr ) == "*?";
-                                }
-                        }
-                        return false;
-                }
-
-                bool isIntrinsicReference( Expression * expr ) {
-                        if ( isDeref( expr ) ) return true;
-                        else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
-                                return InitTweak::getFunctionName( untyped ) == "?[?]";
-                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
-                                if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
-                                        return func->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getFunctionName( appExpr ) == "?[?]";
+                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
+                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
+                                        Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
+                                        return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
                                 }
                         }
@@ -186 +167 @@
                 }
 
+                Expression * ReferenceConversions::postmutate( AddressExpr * addrExpr ) {
+                        // Inner expression may have been lvalue to reference conversion, which becomes an address expression.
+                        // In this case, remove the outer address expression and return the argument.
+                        // TODO: It's possible that this might catch too much and require a more sophisticated check.
+                        if ( dynamic_cast<AddressExpr*>( addrExpr->get_arg() ) ) {
+                                Expression * arg = addrExpr->get_arg();
+                                arg->set_env( addrExpr->get_env() );
+                                addrExpr->set_arg( nullptr );
+                                addrExpr->set_env( nullptr );
+                                delete addrExpr;
+                                return arg;
+                        }
+                        return addrExpr;
+                }
+
                 Expression * ReferenceConversions::postmutate( CastExpr * castExpr ) {
                         // xxx - is it possible to convert directly between reference types with a different base? E.g.,
@@ -244 +240 @@
                                 (void)refType;
                                 // conversion from reference to rvalue
-                                PRINT( std::cerr << "convert reference to rvalue -- *" << std::endl; )
-                                PRINT( std::cerr << "was = " << castExpr << std::endl; )
+                                PRINT(
+                                        std::cerr << "convert reference to rvalue -- *" << std::endl;
+                                        std::cerr << "was = " << castExpr << std::endl;
+                                )
                                 Expression * ret = castExpr->get_arg();
+                                TypeSubstitution * env = castExpr->get_env();
+                                castExpr->set_env( nullptr );
                                 if ( ! isIntrinsicReference( ret ) ) {
                                         // dereference if not already dereferenced
                                         ret = mkDeref( ret );
                                 }
-                                ret->set_env( castExpr->get_env() );
-                                castExpr->set_arg( nullptr );
-                                castExpr->set_env( nullptr );
-                                delete castExpr;
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
+                                        // can remove cast if types are compatible
+                                        castExpr->set_arg( nullptr );
+                                        delete castExpr;
+                                } else {
+                                        // must keep cast if types are different
+                                        castExpr->set_arg( ret );
+                                        ret = castExpr;
+                                }
+                                ret->set_env( env );
                                 PRINT( std::cerr << "now: " << ret << std::endl; )
                                 return ret;
@@ -263 +269 @@
                 Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
                         Type * base = refType->get_base();
+                        Type::Qualifiers qualifiers = refType->get_qualifiers();
                         refType->set_base( nullptr );
                         delete refType;
-                        return new PointerType( Type::Qualifiers(), base );
+                        return new PointerType( qualifiers, base );
                 }
 

src/InitTweak/FixInit.cc

@@ -1182 +1182 @@
                         ctorExpr->set_callExpr( nullptr );
                         ctorExpr->set_env( nullptr );
+                        delete ctorExpr;
 
                         Expression *& firstArg = callExpr->get_args().front();
-                        UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                        assign->get_args().push_back( new VariableExpr( tmp ) );
-                        assign->get_args().push_back( firstArg );
-                        assign->set_result( ctorExpr->get_result()->clone() );
-                        firstArg = assign;
-
-                        CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) );
+
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        firstArg = new VariableExpr( tmp );
+
+                        // for constructor expr:
+                        //   T x;
+                        //   x{};
+                        // results in:
+                        //   T x;
+                        //   T & tmp;
+                        //   &tmp = &x, ?{}(tmp), tmp
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
-                        delete ctorExpr;
                         return commaExpr;
                 }

src/SymTab/Autogen.h

@@ -38 +38 @@
         /// Useful for creating dereference ApplicationExprs without a full resolver pass.
         extern FunctionDecl * dereferenceOperator;
+
+        // temporary
+        FunctionType * genAssignType( Type * paramType );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.

src/SynTree/Expression.cc

@@ -92 +92 @@
 }
 
+VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
+        VariableExpr * funcExpr = new VariableExpr( func );
+        funcExpr->set_result( new PointerType( Type::Qualifiers(), funcExpr->get_result() ) );
+        return funcExpr;
+}
+
 void VariableExpr::print( std::ostream &os, int indent ) const {
         os << "Variable Expression: ";

src/SynTree/Expression.h

@@ -259 +259 @@
         void set_var( DeclarationWithType * newValue ) { var = newValue; }
 
+        static VariableExpr * functionPointer( FunctionDecl * decl );
+
         virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }