Changeset 1d776fd


Ignore:
Timestamp:
Jul 13, 2017, 3:51:19 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:
9a1e509
Parents:
6b9b047
Message:

Implement reference conversion translation for basic reference conversions

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/GenPoly/Lvalue.cc

    r6b9b047 r1d776fd  
    3434#include "InitTweak/InitTweak.h"
    3535
     36#include "Common/PassVisitor.h"
     37
     38// need to be careful about polymorphic references... e.g. in *? (___operator_deref__A0_1_0_0__Fd0_Pd0_intrinsic___1)
     39// the variable is automatically dereferenced and this causes errors dereferencing void*.
     40
    3641namespace GenPoly {
    3742        namespace {
    38                 /// Replace uses of lvalue returns with appropriate pointers
    39                 class Pass1 : public Mutator {
    40                   public:
    41                         typedef Mutator Parent;
    42                         Pass1();
    43 
    44                         // xxx - should this happen to every expression with reference result type? probably just appexpr and varexpr?
    45                         virtual Type *mutate( ReferenceType * refType );
    46                         virtual Expression *mutate( VariableExpr *varExpr );
    47                         virtual Expression *mutate( ApplicationExpr *appExpr );
    48                         virtual Statement *mutate( ReturnStmt *appExpr );
    49                         virtual DeclarationWithType *mutate( FunctionDecl *funDecl );
    50                   private:
    51                         DeclarationWithType* retval;
    52                 };
    53 
    54                 /// Replace declarations of lvalue returns with appropriate pointers
    55                 class Pass2 : public Visitor {
    56                   public:
    57                         virtual void visit( FunctionType *funType );
    58                   private:
     43                struct ReferenceConversions final {
     44                        Expression * postmutate( CastExpr * castExpr );
     45                };
     46
     47                /// Intrinsic functions that take reference parameters don't REALLY take reference parameters -- their reference arguments must always be implicitly dereferenced.
     48                struct FixIntrinsicArgs final {
     49                        Expression * postmutate( ApplicationExpr *appExpr );
     50                };
     51
     52
     53                /// Replace reference types with pointer types
     54                struct ReferenceTypeElimination final {
     55                        Type * postmutate( ReferenceType * refType );
    5956                };
    6057
    … …  
    6259                /// https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Lvalues.html#Lvalues
    6360                /// Replaces &(a,b) with (a, &b), &(a ? b : c) with (a ? &b : &c)
    64                 class GeneralizedLvalue : public Mutator {
    65                         typedef Mutator Parent;
    66 
    67                         virtual Expression * mutate( AddressExpr * addressExpr );
     61                struct GeneralizedLvalue final {
     62                        Expression * postmutate( AddressExpr * addressExpr );
    6863                };
    6964        } // namespace
    7065
    7166        void convertLvalue( std::list< Declaration* >& translationUnit ) {
    72                 Pass1 p1;
    73                 Pass2 p2;
    74                 GeneralizedLvalue genLval;
    75                 mutateAll( translationUnit, p1 );
    76                 acceptAll( translationUnit, p2 );
     67                std::cerr << "convertLvalue" << std::endl;
     68                PassVisitor<ReferenceConversions> refCvt;
     69                PassVisitor<ReferenceTypeElimination> elim;
     70                PassVisitor<GeneralizedLvalue> genLval;
     71                PassVisitor<FixIntrinsicArgs> fixer;
     72                mutateAll( translationUnit, refCvt );
     73                mutateAll( translationUnit, fixer );
     74                mutateAll( translationUnit, elim );
    7775                mutateAll( translationUnit, genLval );
    7876        }
    … …  
    8280                        if ( function->get_returnVals().empty() ) return 0;
    8381                        Type *ty = function->get_returnVals().front()->get_type();
    84                         return ty->get_lvalue() ? ty : 0;
     82                        return dynamic_cast< ReferenceType * >( ty ) ;
    8583                }
    8684
    … …  
    9391                }
    9492
    95                 Pass1::Pass1() {
    96                 }
    97 
    98                 DeclarationWithType * Pass1::mutate( FunctionDecl *funcDecl ) {
    99                         if ( funcDecl->get_statements() ) {
    100                                 DeclarationWithType* oldRetval = retval;
    101                                 retval = 0;
    102                                 if ( ! LinkageSpec::isBuiltin( funcDecl->get_linkage() ) && isLvalueRet( funcDecl->get_functionType() ) ) {
    103                                         retval = funcDecl->get_functionType()->get_returnVals().front();
    104                                 }
    105                                 // fix expressions and return statements in this function
    106                                 funcDecl->set_statements( funcDecl->get_statements()->acceptMutator( *this ) );
    107                                 retval = oldRetval;
    108                         } // if
    109                         return funcDecl;
    110                 }
    111 
    112                 Type * Pass1::mutate( ReferenceType * refType ) {
     93                bool isDeref( Expression * expr ) {
     94                        if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
     95                                return InitTweak::getFunctionName( untyped ) == "*?";
     96                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
     97                                if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
     98                                        return func->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getFunctionName( appExpr ) == "*?";
     99                                }
     100                        }
     101                        return false;
     102                }
     103
     104                bool isIntrinsicReference( Expression * expr ) {
     105                        if ( isDeref( expr ) ) return true;
     106                        else if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
     107                                return InitTweak::getFunctionName( untyped ) == "?[?]";
     108                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
     109                                if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
     110                                        return func->get_linkage() == LinkageSpec::Intrinsic && InitTweak::getFunctionName( appExpr ) == "?[?]";
     111                                }
     112                        }
     113                        return false;
     114                }
     115
     116                void fixArg( Expression *& arg, Type * formal ) {
     117                        // if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( arg ) ) {
     118                                if ( dynamic_cast<ReferenceType*>( formal ) ) { // xxx - but might be deref, in which case result isn't REALLY a reference, at least not in the sense that we need to add another deref...
     119                                        // doesn't work, for some reason left arg is skipped in assign
     120                                        ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() ) ;
     121                                        std::cerr << "appexpr arg is non-deref/index intrinsic call" << std::endl;
     122                                        std::cerr << arg << std::endl;
     123                                        PointerType * ptrType = new PointerType( Type::Qualifiers(), refType->get_base()->clone() );
     124                                        delete refType;
     125                                        arg->set_result( ptrType );
     126                                        arg = UntypedExpr::createDeref( arg );
     127                                }
     128
     129                        // }
     130                }
     131
     132                Expression * FixIntrinsicArgs::postmutate( ApplicationExpr * appExpr ) {
     133                        if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
     134                                if ( function->get_linkage() == LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references
     135                                        FunctionType * ftype = GenPoly::getFunctionType( function->get_type() );
     136                                        assertf( ftype, "Function declaration does not have function type." );
     137                                        for ( auto p : group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
     138                                                Expression *& arg = std::get<0>( p );
     139                                                DeclarationWithType * formal = std::get<1>( p );
     140                                                std::cerr << "pair<0>: " << arg << std::endl;
     141                                                std::cerr << "pair<1>: " << formal->get_type() << std::endl;
     142                                                if ( isIntrinsicReference( arg ) ) {
     143                                                        std::cerr << "skipping intrinsic reference" << std::endl;
     144                                                        continue;
     145                                                } else {
     146                                                        fixArg( arg, formal->get_type() );
     147                                                }
     148                                        }
     149                                }
     150                        }
     151                        return appExpr;
     152                }
     153
     154                Expression * ReferenceConversions::postmutate( CastExpr * castExpr ) {
     155                        // conversion to reference type
     156                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
     157                                (void)refType;
     158                                if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
     159                                        // nothing to do if casting from reference to reference.
     160                                        (void)otherRef;
     161                                        std::cerr << "convert reference to reference -- nop" << std::endl;
     162                                        if ( isIntrinsicReference( castExpr->get_arg() ) ) {
     163                                                Expression * callExpr = castExpr->get_arg();
     164                                                Expression ** arg = nullptr;
     165                                                Expression *& arg0 = InitTweak::getCallArg( callExpr, 0 );
     166                                                if ( dynamic_cast<PointerType *>( arg0->get_result() ) ) {
     167                                                        arg = &arg0;
     168                                                } else {
     169                                                        arg = &InitTweak::getCallArg( callExpr, 1 );
     170                                                }
     171
     172                                                castExpr->set_arg( *arg );
     173                                                *arg = castExpr;
     174                                                std::cerr << "but arg is deref -- &" << std::endl;
     175                                                std::cerr << callExpr << std::endl;
     176                                                // castExpr->set_arg( new AddressExpr( castExpr->get_arg() ) );
     177
     178                                                // move environment out to new top-level
     179                                                callExpr->set_env( castExpr->get_env() );
     180                                                castExpr->set_env( nullptr );
     181                                                return callExpr;
     182                                        }
     183                                        std::cerr << castExpr << std::endl;
     184                                        return castExpr;
     185                                } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
     186                                        // conversion from lvalue to reference
     187                                        // xxx - keep cast, but turn into pointer cast??
     188                                        // xxx - memory
     189                                        std::cerr << "convert lvalue to reference -- &" << std::endl;
     190                                        std::cerr << castExpr->get_arg() << std::endl;
     191                                        castExpr->set_arg( new AddressExpr( castExpr->get_arg() ) );
     192                                        // return new AddressExpr( castExpr->get_arg() );
     193                                        return castExpr;
     194                                } else {
     195                                        // rvalue to reference conversion -- introduce temporary
     196                                }
     197                                assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
     198                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
     199                                // should be easy, just need to move deref code up here?
     200                                std::cerr << "convert reference to rvalue -- *" << std::endl;
     201                                if ( isIntrinsicReference( castExpr->get_arg() ) ) {
     202                                        std::cerr << "but arg is intrinsic reference -- nop" << std::endl;
     203                                        return castExpr;
     204                                }
     205                                std::cerr << castExpr << std::endl;
     206
     207                                PointerType * ptrType = new PointerType( refType->get_qualifiers(), refType->get_base()->clone() );
     208                                delete castExpr->get_result();
     209                                castExpr->set_result( ptrType );
     210                                Expression * deref = UntypedExpr::createDeref( castExpr );
     211                                deref->set_env( castExpr->get_env() );
     212                                castExpr->set_env( nullptr );
     213                                return deref;
     214                                // assertf( false, "Conversions from reference types are not currently supported." );
     215                        }
     216                        return castExpr;
     217                }
     218
     219                Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
    113220                        Type * base = refType->get_base();
    114221                        refType->set_base( nullptr );
    … …  
    117224                }
    118225
    119                 Expression * Pass1::mutate( VariableExpr *varExpr ) {
    120                         if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( varExpr->get_result() ) ) {
    121                                 varExpr->set_result( refType->acceptMutator( *this ) );
    122                                 return UntypedExpr::createDeref( varExpr );
    123                         }
    124                         return Parent::mutate( varExpr );
    125                 }
    126 
    127                 Expression * Pass1::mutate( ApplicationExpr *appExpr ) {
    128                         appExpr->get_function()->acceptMutator( *this );
    129                         mutateAll( appExpr->get_args(), *this );
    130 
    131                         PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    132                         FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
    133 
    134                         Type *funType = isLvalueRet( function );
    135                         if ( funType && ! isIntrinsicApp( appExpr ) ) {
    136                                 Expression *expr = appExpr;
    137                                 Type *appType = appExpr->get_result();
    138                                 if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
    139                                         // make sure cast for polymorphic type is inside dereference
    140                                         expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) );
    141                                 }
    142                                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    143                                 deref->set_result( appType->clone() );
    144                                 appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
    145                                 deref->get_args().push_back( expr );
    146                                 return deref;
    147                         } else {
    148                                 return appExpr;
    149                         } // if
    150                 }
    151 
    152                 Statement * Pass1::mutate(ReturnStmt *retStmt) {
    153                         if ( retval && retStmt->get_expr() ) {
    154                                 if ( retStmt->get_expr()->get_result()->get_lvalue() ) {
    155                                         // ***** Code Removal ***** because casts may be stripped already
    156 
    157                                         // strip casts because not allowed to take address of cast
    158                                         // while ( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
    159                                         //      retStmt->set_expr( castExpr->get_arg() );
    160                                         //      retStmt->get_expr()->set_env( castExpr->get_env() );
    161                                         //      castExpr->set_env( 0 );
    162                                         //      castExpr->set_arg( 0 );
    163                                         //      delete castExpr;
    164                                         // } // while
    165                                         retStmt->set_expr( new AddressExpr( retStmt->get_expr()->acceptMutator( *this ) ) );
    166                                 } else {
    167                                         throw SemanticError( "Attempt to return non-lvalue from an lvalue-qualified function" );
    168                                 } // if
    169                         } // if
    170                         return retStmt;
    171                 }
    172 
    173                 void Pass2::visit( FunctionType *funType ) {
    174                         std::string typeName;
    175                         if ( isLvalueRet( funType ) ) {
    176                                 DeclarationWithType *retParm = funType->get_returnVals().front();
    177 
    178                                 // make a new parameter that is a pointer to the type of the old return value
    179                                 retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
    180                         } // if
    181 
    182                         Visitor::visit( funType );
    183                 }
    184 
    185                 bool isDeref( Expression * expr ) {
    186                         if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
    187                                 return InitTweak::getFunctionName( untyped ) == "*?";
    188                         } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
    189                                 return InitTweak::getFunctionName( appExpr ) == "*?";
    190                         } else {
    191                                 return false;
    192                         }
    193                 }
    194 
    195                 Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
    196                         addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
     226                Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
    197227                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
    198228                                Expression * arg1 = commaExpr->get_arg1()->clone();
    … …  
    206236                                delete addrExpr;
    207237                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
    208                         } else if ( isDeref( addrExpr->get_arg() ) ) {
    209                                 // xxx - this doesn't belong here -- move it somewhere else
    210                                 Expression *& arg = InitTweak::getCallArg( addrExpr->get_arg(), 0 );
    211                                 Expression * inner = arg;
    212                                 arg = nullptr;
    213                                 delete addrExpr;
    214                                 return inner;
    215238                        }
    216239                        return addrExpr;
Note: See TracChangeset for help on using the changeset viewer.