Changes in / [c99a0d1:8a1d95a]


Ignore:
Files:
4 added
24 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/monitor.cfa

    rc99a0d1 r8a1d95a  
    367367
    368368        // __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
     369}
     370
     371void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) {
     372        this{ m, count, 0p };
    369373}
    370374
  • libcfa/src/concurrency/monitor.hfa

    rc99a0d1 r8a1d95a  
    4848
    4949void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
     50void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
    5051void ^?{}( monitor_guard_t & this );
    5152
  • src/AST/Convert.cpp

    rc99a0d1 r8a1d95a  
    606606        }
    607607
     608        const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
     609                if ( inCache( node ) ) return nullptr;
     610                 auto stmt = new MutexStmt(
     611                        get<Statement>().accept1( node->stmt ),
     612                        get<Expression>().acceptL( node->mutexObjs )
     613                );
     614                return stmtPostamble( stmt, node );
     615        }
     616
    608617        TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
    609618
     
    21242133        }
    21252134
     2135        virtual void visit( const MutexStmt * old ) override final {
     2136                if ( inCache( old ) ) return;
     2137                this->node = new ast::MutexStmt(
     2138                        old->location,
     2139                        GET_ACCEPT_1(stmt, Stmt),
     2140                        GET_ACCEPT_V(mutexObjs, Expr)
     2141                );
     2142                cache.emplace( old, this->node );
     2143        }
     2144
    21262145        // TypeSubstitution shouldn't exist yet in old.
    21272146        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
  • src/AST/Fwd.hpp

    rc99a0d1 r8a1d95a  
    6060class NullStmt;
    6161class ImplicitCtorDtorStmt;
     62class MutexStmt;
    6263
    6364class Expr;
  • src/AST/Node.cpp

    rc99a0d1 r8a1d95a  
    176176template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::weak >;
    177177template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::strong >;
     178template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::weak >;
     179template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::strong >;
    178180template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >;
    179181template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >;
  • src/AST/Pass.hpp

    rc99a0d1 r8a1d95a  
    162162        const ast::Stmt *             visit( const ast::DeclStmt             * ) override final;
    163163        const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) override final;
     164        const ast::Stmt *             visit( const ast::MutexStmt            * ) override final;
    164165        const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
    165166        const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;
  • src/AST/Pass.impl.hpp

    rc99a0d1 r8a1d95a  
    10391039
    10401040//--------------------------------------------------------------------------
     1041// MutexStmt
     1042template< typename core_t >
     1043const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
     1044        VISIT_START( node );
     1045
     1046        VISIT({
     1047                // mutex statements introduce a level of scope (for the initialization)
     1048                guard_symtab guard { *this };
     1049                maybe_accept( node, &MutexStmt::stmt );
     1050                maybe_accept( node, &MutexStmt::mutexObjs );
     1051        })
     1052
     1053        VISIT_END( Stmt, node );
     1054}
     1055
     1056//--------------------------------------------------------------------------
    10411057// ApplicationExpr
    10421058template< typename core_t >
  • src/AST/Print.cpp

    rc99a0d1 r8a1d95a  
    794794                ++indent;
    795795                safe_print( node->callStmt );
     796                --indent;
     797                os << endl;
     798
     799                return node;
     800        }
     801
     802        virtual const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
     803                os << "Mutex Statement" << endl;
     804                os << indent << "... with Mutex Parameters: ";
     805                ++indent;
     806                printAll( node->mutexObjs );
     807                --indent;
     808                os << indent << "... with Statement: ";
     809                ++indent;
     810                safe_print( node->stmt );
    796811                --indent;
    797812                os << endl;
  • src/AST/Stmt.hpp

    rc99a0d1 r8a1d95a  
    426426};
    427427
     428/// Mutex Statement
     429class MutexStmt final : public Stmt {
     430public:
     431        ptr<Stmt> stmt;
     432        std::vector<ptr<Expr>> mutexObjs;
     433
     434        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
     435                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
     436        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
     437
     438        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     439private:
     440        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
     441        MUTATE_FRIEND
     442};
     443
    428444}
    429445
  • src/AST/Visitor.hpp

    rc99a0d1 r8a1d95a  
    5454    virtual const ast::Stmt *             visit( const ast::DeclStmt             * ) = 0;
    5555    virtual const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) = 0;
     56    virtual const ast::Stmt *             visit( const ast::MutexStmt            * ) = 0;
    5657    virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) = 0;
    5758    virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;
  • src/CodeGen/CodeGenerator.cc

    rc99a0d1 r8a1d95a  
    11871187        }
    11881188
     1189        void CodeGenerator::postvisit( MutexStmt * stmt ) {
     1190                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
     1191                stmt->stmt->accept( *visitor );
     1192        }
     1193
    11891194        void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
    11901195                if ( decl->get_storageClasses().any() ) {
  • src/CodeGen/CodeGenerator.h

    rc99a0d1 r8a1d95a  
    121121                void postvisit( DeclStmt * );
    122122                void postvisit( ImplicitCtorDtorStmt * );
     123                void postvisit( MutexStmt * stmt );
    123124
    124125                void genAttributes( std::list< Attribute * > & attributes );
  • src/Common/CodeLocationTools.cpp

    rc99a0d1 r8a1d95a  
    125125    macro(DeclStmt, Stmt) \
    126126    macro(ImplicitCtorDtorStmt, Stmt) \
     127    macro(MutexStmt, Stmt) \
    127128    macro(ApplicationExpr, Expr) \
    128129    macro(UntypedExpr, Expr) \
  • src/Common/PassVisitor.h

    rc99a0d1 r8a1d95a  
    124124        virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
    125125        virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
     126        virtual void visit( MutexStmt * mutexStmt ) override final;
     127        virtual void visit( const MutexStmt * mutexStmt ) override final;
    126128
    127129        virtual void visit( ApplicationExpr * applicationExpr ) override final;
     
    291293        virtual Statement * mutate( DeclStmt * declStmt ) override final;
    292294        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
     295        virtual Statement * mutate( MutexStmt * mutexStmt ) override final;
    293296
    294297        virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final;
  • src/Common/PassVisitor.impl.h

    rc99a0d1 r8a1d95a  
    17811781
    17821782//--------------------------------------------------------------------------
     1783// MutexStmt
     1784template< typename pass_type >
     1785void PassVisitor< pass_type >::visit( MutexStmt * node ) {
     1786        VISIT_START( node );
     1787        // mutex statements introduce a level of scope (for the initialization)
     1788        maybeAccept_impl( node->mutexObjs, *this );
     1789        {
     1790                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1791                node->stmt = visitStatement( node->stmt );
     1792        }
     1793        VISIT_END( node );
     1794}
     1795
     1796template< typename pass_type >
     1797void PassVisitor< pass_type >::visit( const MutexStmt * node ) {
     1798        VISIT_START( node );
     1799        maybeAccept_impl( node->mutexObjs, *this );
     1800        {
     1801                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1802                visitStatement( node->stmt );
     1803        }
     1804        VISIT_END( node );
     1805}
     1806
     1807template< typename pass_type >
     1808Statement * PassVisitor< pass_type >::mutate( MutexStmt * node ) {
     1809        MUTATE_START( node );
     1810        maybeMutate_impl( node->mutexObjs, *this );
     1811        {
     1812                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
     1813                node->stmt = mutateStatement( node->stmt );
     1814        }
     1815        MUTATE_END( Statement, node );
     1816}
     1817
     1818//--------------------------------------------------------------------------
    17831819// ApplicationExpr
    17841820template< typename pass_type >
  • src/Concurrency/Keywords.cc

    rc99a0d1 r8a1d95a  
    302302                void postvisit( FunctionDecl * decl );
    303303                void postvisit(   StructDecl * decl );
     304                Statement * postmutate( MutexStmt * stmt );
    304305
    305306                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
     
    307308                void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
    308309                void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
     310                void addStatements( CompoundStmt * body, const std::list<Expression * > & args );
    309311                void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
    310312
     
    312314                        PassVisitor< MutexKeyword > impl;
    313315                        acceptAll( translationUnit, impl );
     316                        mutateAll( translationUnit, impl );
    314317                }
    315318
     
    935938                        thread_guard_decl = decl;
    936939                }
     940        }
     941
     942        Statement * MutexKeyword::postmutate( MutexStmt * stmt ) {
     943                std::list<Statement *> stmtsForCtor;
     944                stmtsForCtor.push_back(stmt->stmt);
     945                CompoundStmt * body = new CompoundStmt( stmtsForCtor );
     946                addStatements( body, stmt->mutexObjs);
     947                return body;
    937948        }
    938949
     
    10581069                        ))
    10591070                );
     1071        }
     1072
     1073        void MutexKeyword::addStatements( CompoundStmt * body, const std::list<Expression * > & args ) {
     1074                ObjectDecl * monitors = new ObjectDecl(
     1075                        "__monitors",
     1076                        noStorageClasses,
     1077                        LinkageSpec::Cforall,
     1078                        nullptr,
     1079                        new ArrayType(
     1080                                noQualifiers,
     1081                                new PointerType(
     1082                                        noQualifiers,
     1083                                        new StructInstType(
     1084                                                noQualifiers,
     1085                                                monitor_decl
     1086                                        )
     1087                                ),
     1088                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
     1089                                false,
     1090                                false
     1091                        ),
     1092                        new ListInit(
     1093                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
     1094                                        return new SingleInit( new UntypedExpr(
     1095                                                new NameExpr( "get_monitor" ),
     1096                                                { var }
     1097                                        ) );
     1098                                })
     1099                        )
     1100                );
     1101
     1102                // in reverse order :
     1103                // monitor_guard_t __guard = { __monitors, # };
     1104                body->push_front(
     1105                        new DeclStmt( new ObjectDecl(
     1106                                "__guard",
     1107                                noStorageClasses,
     1108                                LinkageSpec::Cforall,
     1109                                nullptr,
     1110                                new StructInstType(
     1111                                        noQualifiers,
     1112                                        guard_decl
     1113                                ),
     1114                                new ListInit(
     1115                                        {
     1116                                                new SingleInit( new VariableExpr( monitors ) ),
     1117                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
     1118                                        },
     1119                                        noDesignators,
     1120                                        true
     1121                                )
     1122                        ))
     1123                );
     1124
     1125                //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
     1126                body->push_front( new DeclStmt( monitors) );
    10601127        }
    10611128
  • src/Parser/ParseNode.h

    rc99a0d1 r8a1d95a  
    437437WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
    438438Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
     439Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
    439440
    440441//##############################################################################
  • src/Parser/StatementNode.cc

    rc99a0d1 r8a1d95a  
    374374} // build_directive
    375375
     376Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
     377        std::list< Expression * > expList;
     378        buildMoveList( exprs, expList );
     379        Statement * body = maybeMoveBuild<Statement>( stmt );
     380        return new MutexStmt( body, expList );
     381} // build_mutex
     382
    376383// Local Variables: //
    377384// tab-width: 4 //
  • src/Parser/parser.yy

    rc99a0d1 r8a1d95a  
    13471347mutex_statement:
    13481348        MUTEX '(' argument_expression_list_opt ')' statement
    1349                 { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
     1349                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
    13501350        ;
    13511351
  • src/SynTree/Mutator.h

    rc99a0d1 r8a1d95a  
    5858        virtual Statement * mutate( DeclStmt * declStmt ) = 0;
    5959        virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     60        virtual Statement * mutate( MutexStmt * mutexStmt ) = 0;
    6061
    6162        virtual Expression * mutate( ApplicationExpr * applicationExpr ) = 0;
  • src/SynTree/Statement.cc

    rc99a0d1 r8a1d95a  
    565565}
    566566
     567MutexStmt::MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs )
     568        : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
     569
     570MutexStmt::MutexStmt( const MutexStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
     571        cloneAll( other.mutexObjs, mutexObjs );
     572}
     573
     574MutexStmt::~MutexStmt() {
     575        deleteAll( mutexObjs );
     576        delete stmt;
     577}
     578
     579void MutexStmt::print( std::ostream & os, Indenter indent ) const {
     580        os << "Mutex Statement" << endl;
     581        os << indent << "... with Expressions: " << endl;
     582        for (auto * obj : mutexObjs) {
     583                os << indent+1;
     584                obj->print( os, indent+1);
     585                os << endl;
     586        }
     587        os << indent << "... with Statement: " << endl << indent+1;
     588        stmt->print( os, indent+1 );
     589}
     590
    567591// Local Variables: //
    568592// tab-width: 4 //
  • src/SynTree/Statement.h

    rc99a0d1 r8a1d95a  
    535535};
    536536
     537class MutexStmt : public Statement {
     538  public:
     539        Statement * stmt;
     540        std::list<Expression *> mutexObjs; // list of mutex objects to acquire
     541
     542        MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs );
     543        MutexStmt( const MutexStmt & other );
     544        virtual ~MutexStmt();
     545
     546        virtual MutexStmt * clone() const override { return new MutexStmt( *this ); }
     547        virtual void accept( Visitor & v ) override { v.visit( this ); }
     548        virtual void accept( Visitor & v ) const override { v.visit( this ); }
     549        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
     550        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
     551};
     552
    537553// Local Variables: //
    538554// tab-width: 4 //
  • src/SynTree/SynTree.h

    rc99a0d1 r8a1d95a  
    6262class NullStmt;
    6363class ImplicitCtorDtorStmt;
     64class MutexStmt;
    6465
    6566class Expression;
  • src/SynTree/Visitor.h

    rc99a0d1 r8a1d95a  
    9292        virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
    9393        virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
     94        virtual void visit( MutexStmt * node ) { visit( const_cast<const MutexStmt *>(node) ); }
     95        virtual void visit( const MutexStmt * mutexStmt ) = 0;
    9496
    9597        virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }
Note: See TracChangeset for help on using the changeset viewer.