Changeset 9f10c4b8


Ignore:
Timestamp:
Aug 22, 2017, 5:31:27 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:
d104b02
Parents:
1ae06fa
Message:

Add maybeImpureIgnoreUnique and convert tuple passes to use PassVisitor?

Location:
src/Tuples
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • src/Tuples/TupleExpansion.cc

    r1ae06fa r9f10c4b8  
    4141                };
    4242
    43                 struct UniqueExprExpander final : public GenPoly::DeclMutator {
    44                         typedef GenPoly::DeclMutator Parent;
    45                         using Parent::mutate;
    46 
    47                         virtual Expression * mutate( UniqueExpr * unqExpr ) override;
     43                struct UniqueExprExpander final : public WithDeclsToAdd {
     44                        Expression * postmutate( UniqueExpr * unqExpr );
    4845
    4946                        std::map< int, Expression * > decls; // not vector, because order added may not be increasing order
     
    5653                };
    5754
    58                 struct TupleAssignExpander : public Mutator {
    59                         typedef Mutator Parent;
    60                         using Parent::mutate;
    61 
    62                         virtual Expression * mutate( TupleAssignExpr * tupleExpr );
     55                struct TupleAssignExpander {
     56                        Expression * postmutate( TupleAssignExpr * tupleExpr );
    6357                };
    6458
     
    7771                };
    7872
    79                 struct TupleExprExpander final : public Mutator {
    80                         typedef Mutator Parent;
    81                         using Parent::mutate;
    82 
    83                         virtual Expression * mutate( TupleExpr * tupleExpr ) override;
     73                struct TupleExprExpander final {
     74                        Expression * postmutate( TupleExpr * tupleExpr );
    8475                };
    8576        }
     
    9182
    9283        void expandUniqueExpr( std::list< Declaration * > & translationUnit ) {
    93                 UniqueExprExpander unqExpander;
    94                 unqExpander.mutateDeclarationList( translationUnit );
     84                PassVisitor<UniqueExprExpander> unqExpander;
     85                mutateAll( translationUnit, unqExpander );
    9586        }
    9687
    9788        void expandTuples( std::list< Declaration * > & translationUnit ) {
    98                 TupleAssignExpander assnExpander;
     89                PassVisitor<TupleAssignExpander> assnExpander;
    9990                mutateAll( translationUnit, assnExpander );
    10091
     
    10596                mutateAll( translationUnit, idxExpander );
    10697
    107                 TupleExprExpander exprExpander;
     98                PassVisitor<TupleExprExpander> exprExpander;
    10899                mutateAll( translationUnit, exprExpander );
    109100        }
     
    138129                        // aggregate expressions which might be impure must be wrapped in unique expressions
    139130                        // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
    140                         // if ( Tuples::maybeImpure( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
     131                        // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
    141132                        aggr = new UniqueExpr( aggr );
    142133                        for ( Expression *& expr : tupleExpr->get_exprs() ) {
     
    156147        }
    157148
    158         Expression * UniqueExprExpander::mutate( UniqueExpr * unqExpr ) {
    159                 unqExpr = safe_dynamic_cast< UniqueExpr * > ( Parent::mutate( unqExpr ) );
     149        Expression * UniqueExprExpander::postmutate( UniqueExpr * unqExpr ) {
    160150                const int id = unqExpr->get_id();
    161151
     
    167157                        if ( unqExpr->get_object() ) {
    168158                                // an object was generated to represent this unique expression -- it should be added to the list of declarations now
    169                                 addDeclaration( unqExpr->get_object() );
     159                                declsToAddBefore.push_back( unqExpr->get_object() );
    170160                                unqExpr->set_object( nullptr );
    171161                                // steal the expr from the unqExpr
     
    181171                        ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ),
    182172                                                                                                        new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) );
    183                         addDeclaration( finished );
     173                        declsToAddBefore.push_back( finished );
    184174                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
    185175                        // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
     
    195185        }
    196186
    197         Expression * TupleAssignExpander::mutate( TupleAssignExpr * assnExpr ) {
    198                 assnExpr = safe_dynamic_cast< TupleAssignExpr * >( Parent::mutate( assnExpr ) );
     187        Expression * TupleAssignExpander::postmutate( TupleAssignExpr * assnExpr ) {
    199188                StmtExpr * ret = assnExpr->get_stmtExpr();
    200189                assnExpr->set_stmtExpr( nullptr );
     
    279268        }
    280269
    281         Expression * TupleExprExpander::mutate( TupleExpr * tupleExpr ) {
    282                 // recursively expand sub-tuple-expressions
    283                 tupleExpr = safe_dynamic_cast<TupleExpr *>(Parent::mutate(tupleExpr));
     270        Expression * TupleExprExpander::postmutate( TupleExpr * tupleExpr ) {
    284271                Type * result = tupleExpr->get_result();
    285272                std::list< Expression * > exprs = tupleExpr->get_exprs();
     
    328315                class ImpurityDetector : public Visitor {
    329316                public:
     317                        ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
     318
    330319                        typedef Visitor Parent;
    331320                        virtual void visit( ApplicationExpr * appExpr ) {
     
    341330                                maybeImpure = true;
    342331                        }
    343                         virtual void visit( __attribute__((unused)) UntypedExpr * untypedExpr ) { maybeImpure = true; }
     332                        virtual void visit( UntypedExpr * ) { maybeImpure = true; }
     333                        virtual void visit( UniqueExpr * unq ) {
     334                                if ( ignoreUnique ) {
     335                                        // bottom out at unique expression.
     336                                        // The existence of a unique expression doesn't change the purity of an expression.
     337                                        // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
     338                                        return;
     339                                }
     340                                maybeAccept( unq->expr, *this );
     341                        }
     342
    344343                        bool maybeImpure = false;
     344                        bool ignoreUnique;
    345345                };
    346346        } // namespace
    347347
    348348        bool maybeImpure( Expression * expr ) {
    349                 ImpurityDetector detector;
     349                ImpurityDetector detector( false );
     350                expr->accept( detector );
     351                return detector.maybeImpure;
     352        }
     353
     354        bool maybeImpureIgnoreUnique( Expression * expr ) {
     355                ImpurityDetector detector( true );
    350356                expr->accept( detector );
    351357                return detector.maybeImpure;
  • src/Tuples/Tuples.h

    r1ae06fa r9f10c4b8  
    4646        /// returns true if the expression may contain side-effects.
    4747        bool maybeImpure( Expression * expr );
     48
     49        /// returns true if the expression may contain side-effect, ignoring the presence of unique expressions.
     50        bool maybeImpureIgnoreUnique( Expression * expr );
    4851} // namespace Tuples
    4952
Note: See TracChangeset for help on using the changeset viewer.