Changeset 08da53d


Ignore:
Timestamp:
Oct 10, 2017, 3:17:45 PM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
c366ec6
Parents:
ded5f07
Message:

Refactor findSingleExpr and remove unnecessary resolver-generated casts

Location:
src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/Concurrency/Waitfor.cc

    rded5f07 r08da53d  
    190190
    191191                Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) {
    192                         std::unique_ptr< Expression > expr( makeOpAssign(
     192                        Expression * expr = makeOpAssign(
    193193                                makeOpMember(
    194194                                        makeOpIndex(
     
    199199                                ),
    200200                                value
    201                         ) );
    202 
    203                         return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) );
     201                        );
     202
     203                        ResolvExpr::findVoidExpression( expr, indexer );
     204
     205                        return new ExprStmt( noLabels, expr );
    204206                }
    205207
     
    313315                stmt->push_back( new DeclStmt( noLabels, acceptables) );
    314316
    315                 UntypedExpr * set = new UntypedExpr(
     317                Expression * set = new UntypedExpr(
    316318                        new NameExpr( "__builtin_memset" ),
    317319                        {
     
    322324                );
    323325
    324                 Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer );
    325                 delete set;
    326 
    327                 stmt->push_back( new ExprStmt( noLabels, resolved_set ) );
     326                ResolvExpr::findVoidExpression( set, indexer );
     327
     328                stmt->push_back( new ExprStmt( noLabels, set ) );
    328329
    329330                return acceptables;
     
    346347
    347348        Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) {
    348                 Expression * untyped = new UntypedExpr(
     349                Expression * expr = new UntypedExpr(
    349350                        new NameExpr( "?=?" ),
    350351                        {
     
    354355                );
    355356
    356                 Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer );
    357                 delete untyped;
     357                ResolvExpr::findVoidExpression( expr, indexer );
    358358
    359359                return new ExprStmt( noLabels, expr );
     
    379379                        new ListInit(
    380380                                map_range < std::list<Initializer*> > ( clause.target.arguments, [this](Expression * expr ){
    381                                         Expression * untyped = new CastExpr(
     381                                        Expression * init = new CastExpr(
    382382                                                new UntypedExpr(
    383383                                                        new NameExpr( "get_monitor" ),
     
    393393                                        );
    394394
    395                                         Expression * init = ResolvExpr::findSingleExpression( untyped, indexer );
    396                                         delete untyped;
     395                                        ResolvExpr::findSingleExpression( init, indexer );
    397396                                        return new SingleInit( init );
    398397                                })
  • src/InitTweak/FixInit.cc

    rded5f07 r08da53d  
    367367                        ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
    368368                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
    369                         Expression * untyped = exprStmt->get_expr();
     369                        Expression * resolved = exprStmt->expr;
     370                        exprStmt->expr = nullptr; // take ownership of expr
    370371
    371372                        // resolve copy constructor
    372373                        // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
    373374                        // (VariableExpr and already resolved expression)
    374                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
    375                         Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
     375                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; )
     376                        ResolvExpr::findVoidExpression( resolved, indexer );
    376377                        assert( resolved );
    377378                        if ( resolved->get_env() ) {
     
    381382                                resolved->set_env( nullptr );
    382383                        } // if
    383 
    384384                        delete stmt;
    385385                        return resolved;
     
    11121112                }
    11131113
    1114                 DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
     1114                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
    11151115                        // add object to the indexer assumes that there will be no name collisions
    11161116                        // in generated code. If this changes, add mutate methods for entities with
     
    11201120                }
    11211121
    1122                 Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
    1123                         return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
     1122                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
     1123                        Expression * newExpr = untypedExpr;
     1124                        ResolvExpr::findVoidExpression( newExpr, indexer );
     1125                        return newExpr;
    11241126                }
    11251127
     
    11461148
    11471149                        // resolve assignment and dispose of new env
    1148                         Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
    1149                         delete resolvedAssign->env;
    1150                         resolvedAssign->env = nullptr;
    1151                         delete assign;
     1150                        ResolvExpr::findVoidExpression( assign, indexer );
     1151                        delete assign->env;
     1152                        assign->env = nullptr;
    11521153
    11531154                        // for constructor expr:
     
    11581159                        //   T & tmp;
    11591160                        //   &tmp = &x, ?{}(tmp), tmp
    1160                         CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
     1161                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
    11611162                        commaExpr->set_env( env );
    11621163                        return commaExpr;
  • src/ResolvExpr/Resolver.cc

    rded5f07 r08da53d  
    115115        } // namespace
    116116
    117         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
     117        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
    118118                global_renamer.reset();
    119119                TypeEnvironment env;
    120120                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
    121121                finishExpr( newExpr, env, untyped->env );
    122                 return newExpr;
    123         }
    124 
    125         Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
     122                delete untyped;
     123                untyped = newExpr;
     124        }
     125
     126        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
     127                if ( ! untyped ) return;
    126128                TypeEnvironment env;
    127129                AlternativeFinder finder( indexer, env );
     
    141143                Expression *newExpr = choice.expr->clone();
    142144                finishExpr( newExpr, choice.env, untyped->env );
    143                 return newExpr;
     145                delete untyped;
     146                untyped = newExpr;
     147        }
     148
     149        void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
     150                assert( untyped && type );
     151                untyped = new CastExpr( untyped, type );
     152                findSingleExpression( untyped, indexer );
     153                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( untyped ) ) {
     154                        if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
     155                                // cast is to the same type as its argument, so it's unnecessary -- remove it
     156                                untyped = castExpr->arg;
     157                                castExpr->arg = nullptr;
     158                                delete castExpr;
     159                        }
     160                }
    144161        }
    145162
     
    157174                }
    158175
    159                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
     176                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
    160177                        TypeEnvironment env;
    161178                        AlternativeFinder finder( indexer, env );
     
    187204                        } // if
    188205                        finishExpr( newExpr, *newEnv, untyped->env );
    189                         return newExpr;
     206                        delete untyped;
     207                        untyped = newExpr;
    190208                }
    191209
     
    212230        void Resolver::handlePtrType( PtrType * type ) {
    213231                if ( type->get_dimension() ) {
    214                         CastExpr *castExpr = new CastExpr( type->get_dimension(), SymTab::SizeType->clone() );
    215                         Expression *newExpr = findSingleExpression( castExpr, indexer );
    216                         delete type->get_dimension();
    217                         type->set_dimension( newExpr );
     232                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
    218233                }
    219234        }
     
    268283        void Resolver::previsit( ExprStmt *exprStmt ) {
    269284                visit_children = false;
    270                 assertf( exprStmt->get_expr(), "ExprStmt has null Expression in resolver" );
    271                 Expression *newExpr = findVoidExpression( exprStmt->get_expr(), indexer );
    272                 delete exprStmt->get_expr();
    273                 exprStmt->set_expr( newExpr );
     285                assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
     286                findVoidExpression( exprStmt->expr, indexer );
    274287        }
    275288
    276289        void Resolver::previsit( AsmExpr *asmExpr ) {
    277290                visit_children = false;
    278                 Expression *newExpr = findVoidExpression( asmExpr->get_operand(), indexer );
    279                 delete asmExpr->get_operand();
    280                 asmExpr->set_operand( newExpr );
     291                findVoidExpression( asmExpr->operand, indexer );
    281292                if ( asmExpr->get_inout() ) {
    282                         newExpr = findVoidExpression( asmExpr->get_inout(), indexer );
    283                         delete asmExpr->get_inout();
    284                         asmExpr->set_inout( newExpr );
     293                        findVoidExpression( asmExpr->inout, indexer );
    285294                } // if
    286295        }
     
    293302
    294303        void Resolver::previsit( IfStmt *ifStmt ) {
    295                 Expression *newExpr = findSingleExpression( ifStmt->get_condition(), indexer );
    296                 delete ifStmt->get_condition();
    297                 ifStmt->set_condition( newExpr );
     304                findSingleExpression( ifStmt->condition, indexer );
    298305        }
    299306
    300307        void Resolver::previsit( WhileStmt *whileStmt ) {
    301                 Expression *newExpr = findSingleExpression( whileStmt->get_condition(), indexer );
    302                 delete whileStmt->get_condition();
    303                 whileStmt->set_condition( newExpr );
     308                findSingleExpression( whileStmt->condition, indexer );
    304309        }
    305310
    306311        void Resolver::previsit( ForStmt *forStmt ) {
    307                 if ( forStmt->get_condition() ) {
    308                         Expression * newExpr = findSingleExpression( forStmt->get_condition(), indexer );
    309                         delete forStmt->get_condition();
    310                         forStmt->set_condition( newExpr );
     312                if ( forStmt->condition ) {
     313                        findSingleExpression( forStmt->condition, indexer );
    311314                } // if
    312315
    313                 if ( forStmt->get_increment() ) {
    314                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), indexer );
    315                         delete forStmt->get_increment();
    316                         forStmt->set_increment( newExpr );
     316                if ( forStmt->increment ) {
     317                        findVoidExpression( forStmt->increment, indexer );
    317318                } // if
    318319        }
     
    320321        void Resolver::previsit( SwitchStmt *switchStmt ) {
    321322                GuardValue( currentObject );
    322                 Expression *newExpr;
    323                 newExpr = findIntegralExpression( switchStmt->get_condition(), indexer );
    324                 delete switchStmt->get_condition();
    325                 switchStmt->set_condition( newExpr );
    326 
    327                 currentObject = CurrentObject( newExpr->get_result() );
     323                findIntegralExpression( switchStmt->condition, indexer );
     324
     325                currentObject = CurrentObject( switchStmt->condition->result );
    328326        }
    329327
     
    332330                        std::list< InitAlternative > initAlts = currentObject.getOptions();
    333331                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
    334                         CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
    335                         Expression * newExpr = findSingleExpression( castExpr, indexer );
    336                         castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
    337                         caseStmt->set_condition( castExpr->get_arg() );
    338                         castExpr->set_arg( nullptr );
     332                        // must remove cast from case statement because RangeExpr cannot be cast.
     333                        Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
     334                        findSingleExpression( newExpr, indexer );
     335                        CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
     336                        caseStmt->condition = castExpr->arg;
     337                        castExpr->arg = nullptr;
    339338                        delete castExpr;
    340339                }
     
    345344                // must resolve the argument for a computed goto
    346345                if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
    347                         if ( Expression * arg = branchStmt->get_computedTarget() ) {
    348                                 VoidType v = Type::Qualifiers();                // cast to void * for the alternative finder
    349                                 PointerType pt( Type::Qualifiers(), v.clone() );
    350                                 CastExpr * castExpr = new CastExpr( arg, pt.clone() );
    351                                 Expression * newExpr = findSingleExpression( castExpr, indexer ); // find best expression
    352                                 branchStmt->set_target( newExpr );
     346                        if ( branchStmt->computedTarget ) {
     347                                // computed goto argument is void *
     348                                findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
    353349                        } // if
    354350                } // if
     
    357353        void Resolver::previsit( ReturnStmt *returnStmt ) {
    358354                visit_children = false;
    359                 if ( returnStmt->get_expr() ) {
    360                         CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
    361                         Expression *newExpr = findSingleExpression( castExpr, indexer );
    362                         delete castExpr;
    363                         returnStmt->set_expr( newExpr );
     355                if ( returnStmt->expr ) {
     356                        findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
    364357                } // if
    365358        }
     
    372365                                indexer.lookupStruct( "__cfaehm__base_exception_t" );
    373366                        assert( exception_decl );
    374                         Expression * wrapped = new CastExpr(
    375                                 throwStmt->get_expr(),
    376                                 new PointerType(
    377                                         noQualifiers,
    378                                         new StructInstType(
    379                                                 noQualifiers,
    380                                                 exception_decl
    381                                                 )
    382                                         )
    383                                 );
    384                         Expression * newExpr = findSingleExpression( wrapped, indexer );
    385                         throwStmt->set_expr( newExpr );
     367                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
     368                        findSingleExpression( throwStmt->expr, exceptType, indexer );
    386369                }
    387370        }
    388371
    389372        void Resolver::previsit( CatchStmt *catchStmt ) {
    390                 if ( catchStmt->get_cond() ) {
    391                         Expression * wrapped = new CastExpr(
    392                                 catchStmt->get_cond(),
    393                                 new BasicType( noQualifiers, BasicType::Bool )
    394                                 );
    395                         catchStmt->set_cond( findSingleExpression( wrapped, indexer ) );
    396                 }
    397         }
    398 
    399         inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) {
    400                 if( !expr ) return;
    401                 Expression * newExpr = findSingleExpression( expr, indexer );
    402                 delete expr;
    403                 expr = newExpr;
    404         }
    405 
    406         inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) {
    407                 if( !expr ) return;
    408                 Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer );
    409                 delete expr;
    410                 expr = newExpr;
     373                if ( catchStmt->cond ) {
     374                        findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
     375                }
    411376        }
    412377
     
    578543                        // Resolve the conditions as if it were an IfStmt
    579544                        // Resolve the statments normally
    580                         resolveAsIf( clause.condition, this->indexer );
     545                        findSingleExpression( clause.condition, this->indexer );
    581546                        clause.statement->accept( *visitor );
    582547                }
     
    587552                        // Resolve the conditions as if it were an IfStmt
    588553                        // Resolve the statments normally
    589                         resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
    590                         resolveAsIf  ( stmt->timeout.condition, this->indexer );
     554                        findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
     555                        findSingleExpression( stmt->timeout.condition, this->indexer );
    591556                        stmt->timeout.statement->accept( *visitor );
    592557                }
     
    595560                        // Resolve the conditions as if it were an IfStmt
    596561                        // Resolve the statments normally
    597                         resolveAsIf( stmt->orelse.condition, this->indexer );
     562                        findSingleExpression( stmt->orelse.condition, this->indexer );
    598563                        stmt->orelse.statement->accept( *visitor );
    599564                }
     
    612577                visit_children = false;
    613578                // resolve initialization using the possibilities as determined by the currentObject cursor
    614                 UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
    615                 Expression * newExpr = findSingleExpression( untyped, indexer );
     579                Expression * newExpr = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
     580                findSingleExpression( newExpr, indexer );
    616581                InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
    617582
     
    620585
    621586                // discard InitExpr wrapper and retain relevant pieces
    622                 newExpr = initExpr->get_expr();
    623                 newExpr->set_env( initExpr->get_env() );
    624                 initExpr->set_expr( nullptr );
    625                 initExpr->set_env( nullptr );
     587                newExpr = initExpr->expr;
     588                initExpr->expr = nullptr;
     589                std::swap( initExpr->env, newExpr->env );
    626590                delete initExpr;
    627591
  • src/ResolvExpr/Resolver.h

    rded5f07 r08da53d  
    3030        void resolve( std::list< Declaration * > translationUnit );
    3131        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
    32         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
    33         Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
    34         Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
     32        Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer &indexer );
     33        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer );
     34        void findSingleExpression( Expression *& untyped, const SymTab::Indexer &indexer );
    3535        void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
    3636        void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
Note: See TracChangeset for help on using the changeset viewer.