Changeset de8dfac2


Ignore:
Timestamp:
Jun 4, 2019, 4:45:07 PM (3 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
9a19608
Parents:
ee574a2 (diff), 98a8290 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/FixInit.cc

    ree574a2 rde8dfac2  
    7272                };
    7373
     74                struct StmtExprResult {
     75                        static void link( std::list< Declaration * > & translationUnit );
     76
     77                        void previsit( StmtExpr * stmtExpr );
     78                };
     79
    7480                struct InsertImplicitCalls : public WithConstTypeSubstitution {
    7581                        /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
     
    226232                acceptAll( translationUnit, checker );
    227233
     234                // fixes StmtExpr to properly link to their resulting expression
     235                StmtExprResult::link( translationUnit );
     236
    228237                // fixes ConstructorInit for global variables. should happen before fixInitializers.
    229238                InitTweak::fixGlobalInit( translationUnit, inLibrary );
     
    299308
    300309                        return dtorFunc;
     310                }
     311
     312                void StmtExprResult::link( std::list< Declaration * > & translationUnit ) {
     313                        PassVisitor<StmtExprResult> linker;
     314                        acceptAll( translationUnit, linker );
    301315                }
    302316
     
    349363                        PassVisitor<FixCtorExprs> fixer;
    350364                        mutateAll( translationUnit, fixer );
     365                }
     366
     367                void StmtExprResult::previsit( StmtExpr * stmtExpr ) {
     368                        // we might loose the result expression here so add a pointer to trace back
     369                        assert( stmtExpr->result );
     370                        Type * result = stmtExpr->result;
     371                        if ( ! result->isVoid() ) {
     372                                CompoundStmt * body = stmtExpr->statements;
     373                                assert( ! body->kids.empty() );
     374                                stmtExpr->resultExpr = strict_dynamic_cast< ExprStmt * >( body->kids.back() );
     375                        }
    351376                }
    352377
     
    655680                        // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
    656681                        // since temporaries can be shared across sub-expressions, e.g.
    657                         //   [A, A] f();
    658                         //   g([A] x, [A] y);
    659                         //   g(f());
     682                        //   [A, A] f();       // decl
     683                        //   g([A] x, [A] y);  // decl
     684                        //   g(f());           // call
    660685                        // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
    661686                        // Explicitly mutating children instead of mutating the inner compound statement forces the temporaries to be added
     
    665690                        assert( env );
    666691
     692                        indexer.enterScope();
    667693                        // visit all statements
    668694                        std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
     
    670696                                stmt = stmt->acceptMutator( *visitor );
    671697                        } // for
     698                        indexer.leaveScope();
    672699
    673700                        assert( stmtExpr->result );
     
    688715                                stmtsToAddBefore.push_back( new DeclStmt( ret ) );
    689716
    690                                 // must have a non-empty body, otherwise it wouldn't have a result
    691                                 CompoundStmt * body = stmtExpr->statements;
    692                                 assert( ! body->kids.empty() );
    693                                 // must be an ExprStmt, otherwise it wouldn't have a result
    694                                 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->kids.back() );
    695                                 last->expr = makeCtorDtor( "?{}", ret, last->expr );
     717                                if(!stmtExpr->resultExpr) {
     718                                        SemanticError(stmtExpr, "Statment-Expression should have a resulting expression");
     719                                }
     720                                ExprStmt * last = stmtExpr->resultExpr;
     721                                try {
     722                                        last->expr = makeCtorDtor( "?{}", ret, last->expr );
     723                                } catch(...) {
     724                                        std::cerr << "=======================" << std::endl;
     725                                        std::cerr << "ERROR, can't resolve" << std::endl;
     726                                        ret->print(std::cerr);
     727                                        std::cerr << std::endl << "---" << std::endl;
     728                                        last->expr->print(std::cerr);
     729
     730                                        abort();
     731                                }
    696732
    697733                                // add destructors after current statement
  • src/SynTree/Expression.cc

    ree574a2 rde8dfac2  
    610610        computeResult();
    611611}
    612 StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ) {
     612StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ), resultExpr( other.resultExpr ) {
    613613        cloneAll( other.returnDecls, returnDecls );
    614614        cloneAll( other.dtors, dtors );
  • src/SynTree/Expression.h

    ree574a2 rde8dfac2  
    6262        InferredParams inferParams;       ///< Post-resolution inferred parameter slots
    6363        std::vector<UniqueId> resnSlots;  ///< Pre-resolution inferred parameter slots
    64        
     64
    6565        // xxx - should turn inferParams+resnSlots into a union to save some memory
    6666
     
    744744        std::list< Expression * > dtors; // destructor(s) for return variable(s)
    745745
     746        // readonly
     747        ExprStmt * resultExpr = nullptr;
     748
    746749        StmtExpr( CompoundStmt * statements );
    747750        StmtExpr( const StmtExpr & other );
Note: See TracChangeset for help on using the changeset viewer.