Changes in / [8a1d95af:c99a0d1]

Files:

• libcfa/src/concurrency/monitor.cfa (modified) (1 diff)
• libcfa/src/concurrency/monitor.hfa (modified) (1 diff)
• src/AST/Convert.cpp (modified) (2 diffs)
• src/AST/Fwd.hpp (modified) (1 diff)
• src/AST/Node.cpp (modified) (1 diff)
• src/AST/Pass.hpp (modified) (1 diff)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/Print.cpp (modified) (1 diff)
• src/AST/Stmt.hpp (modified) (1 diff)
• src/AST/Visitor.hpp (modified) (1 diff)
• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/CodeGen/CodeGenerator.h (modified) (1 diff)
• src/Common/CodeLocationTools.cpp (modified) (1 diff)
• src/Common/PassVisitor.h (modified) (2 diffs)
• src/Common/PassVisitor.impl.h (modified) (1 diff)
• src/Concurrency/Keywords.cc (modified) (5 diffs)
• src/Parser/ParseNode.h (modified) (1 diff)
• src/Parser/StatementNode.cc (modified) (1 diff)
• src/Parser/parser.yy (modified) (1 diff)
• src/SynTree/Mutator.h (modified) (1 diff)
• src/SynTree/Statement.cc (modified) (1 diff)
• src/SynTree/Statement.h (modified) (1 diff)
• src/SynTree/SynTree.h (modified) (1 diff)
• src/SynTree/Visitor.h (modified) (1 diff)
• tests/concurrent/mutexstmt/.expect/monitors.txt (deleted)
• tests/concurrent/mutexstmt/locks.cfa (deleted)
• tests/concurrent/mutexstmt/monitors.cfa (deleted)
• tests/unified_locking/.expect/lin_backoff.txt (deleted)

libcfa/src/concurrency/monitor.cfa

@@ -367 +367 @@
 
         // __cfaabi_dbg_print_safe( "MGUARD : entered\n" );
-}
-
-void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) {
-        this{ m, count, 0p };
 }
 

libcfa/src/concurrency/monitor.hfa

@@ -48 +48 @@
 
 void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
-void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
 void ^?{}( monitor_guard_t & this );
 

src/AST/Convert.cpp

@@ -606 +606 @@
         }
 
-        const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
-                if ( inCache( node ) ) return nullptr;
-                 auto stmt = new MutexStmt(
-                        get<Statement>().accept1( node->stmt ),
-                        get<Expression>().acceptL( node->mutexObjs )
-                );
-                return stmtPostamble( stmt, node );
-        }
-
         TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
 
@@ -2133 +2124 @@
         }
 
-        virtual void visit( const MutexStmt * old ) override final {
-                if ( inCache( old ) ) return;
-                this->node = new ast::MutexStmt(
-                        old->location,
-                        GET_ACCEPT_1(stmt, Stmt),
-                        GET_ACCEPT_V(mutexObjs, Expr)
-                );
-                cache.emplace( old, this->node );
-        }
-
         // TypeSubstitution shouldn't exist yet in old.
         ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {

src/AST/Fwd.hpp

@@ -60 +60 @@
 class NullStmt;
 class ImplicitCtorDtorStmt;
-class MutexStmt;
 
 class Expr;

src/AST/Node.cpp

@@ -176 +176 @@
 template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::ImplicitCtorDtorStmt, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::MutexStmt, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::Expr, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::Expr, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

@@ -162 +162 @@
         const ast::Stmt *             visit( const ast::DeclStmt             * ) override final;
         const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) override final;
-        const ast::Stmt *             visit( const ast::MutexStmt            * ) override final;
         const ast::Expr *             visit( const ast::ApplicationExpr      * ) override final;
         const ast::Expr *             visit( const ast::UntypedExpr          * ) override final;

src/AST/Pass.impl.hpp

@@ -1039 +1039 @@
 
 //--------------------------------------------------------------------------
-// MutexStmt
-template< typename core_t >
-const ast::Stmt * ast::Pass< core_t >::visit( const ast::MutexStmt * node ) {
-        VISIT_START( node );
-
-        VISIT({
-                // mutex statements introduce a level of scope (for the initialization)
-                guard_symtab guard { *this };
-                maybe_accept( node, &MutexStmt::stmt );
-                maybe_accept( node, &MutexStmt::mutexObjs );
-        })
-
-        VISIT_END( Stmt, node );
-}
-
-//--------------------------------------------------------------------------
 // ApplicationExpr
 template< typename core_t >

src/AST/Print.cpp

@@ -794 +794 @@
                 ++indent;
                 safe_print( node->callStmt );
-                --indent;
-                os << endl;
-
-                return node;
-        }
-
-        virtual const ast::Stmt * visit( const ast::MutexStmt * node ) override final {
-                os << "Mutex Statement" << endl;
-                os << indent << "... with Mutex Parameters: ";
-                ++indent;
-                printAll( node->mutexObjs );
-                --indent;
-                os << indent << "... with Statement: ";
-                ++indent;
-                safe_print( node->stmt );
                 --indent;
                 os << endl;

src/AST/Stmt.hpp

@@ -426 +426 @@
 };
 
-/// Mutex Statement
-class MutexStmt final : public Stmt {
-public:
-        ptr<Stmt> stmt;
-        std::vector<ptr<Expr>> mutexObjs;
-
-        MutexStmt( const CodeLocation & loc, const Stmt * stmt, 
-                std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
-        : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
-
-        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
-        MUTATE_FRIEND
-};
-
 }
 

src/AST/Visitor.hpp

@@ -54 +54 @@
     virtual const ast::Stmt *             visit( const ast::DeclStmt             * ) = 0;
     virtual const ast::Stmt *             visit( const ast::ImplicitCtorDtorStmt * ) = 0;
-    virtual const ast::Stmt *             visit( const ast::MutexStmt            * ) = 0;
     virtual const ast::Expr *             visit( const ast::ApplicationExpr      * ) = 0;
     virtual const ast::Expr *             visit( const ast::UntypedExpr          * ) = 0;

src/CodeGen/CodeGenerator.cc

@@ -1187 +1187 @@
         }
 
-        void CodeGenerator::postvisit( MutexStmt * stmt ) {
-                assertf( ! options.genC, "ImplicitCtorDtorStmts should not reach code generation." );
-                stmt->stmt->accept( *visitor );
-        }
-
         void CodeGenerator::handleStorageClass( DeclarationWithType * decl ) {
                 if ( decl->get_storageClasses().any() ) {

src/CodeGen/CodeGenerator.h

@@ -121 +121 @@
                 void postvisit( DeclStmt * );
                 void postvisit( ImplicitCtorDtorStmt * );
-                void postvisit( MutexStmt * stmt );
 
                 void genAttributes( std::list< Attribute * > & attributes );

src/Common/CodeLocationTools.cpp

@@ -125 +125 @@
     macro(DeclStmt, Stmt) \
     macro(ImplicitCtorDtorStmt, Stmt) \
-    macro(MutexStmt, Stmt) \
     macro(ApplicationExpr, Expr) \
     macro(UntypedExpr, Expr) \

src/Common/PassVisitor.h

@@ -124 +124 @@
         virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
-        virtual void visit( MutexStmt * mutexStmt ) override final;
-        virtual void visit( const MutexStmt * mutexStmt ) override final;
 
         virtual void visit( ApplicationExpr * applicationExpr ) override final;
@@ -293 +291 @@
         virtual Statement * mutate( DeclStmt * declStmt ) override final;
         virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) override final;
-        virtual Statement * mutate( MutexStmt * mutexStmt ) override final;
 
         virtual Expression * mutate( ApplicationExpr * applicationExpr ) override final;

src/Common/PassVisitor.impl.h

@@ -1781 +1781 @@
 
 //--------------------------------------------------------------------------
-// MutexStmt
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( MutexStmt * node ) {
-        VISIT_START( node );
-        // mutex statements introduce a level of scope (for the initialization)
-        maybeAccept_impl( node->mutexObjs, *this );
-        {
-                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                node->stmt = visitStatement( node->stmt );
-        }
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( const MutexStmt * node ) {
-        VISIT_START( node );
-        maybeAccept_impl( node->mutexObjs, *this );
-        {
-                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                visitStatement( node->stmt );
-        }
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-Statement * PassVisitor< pass_type >::mutate( MutexStmt * node ) {
-        MUTATE_START( node );
-        maybeMutate_impl( node->mutexObjs, *this );
-        {
-                auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                node->stmt = mutateStatement( node->stmt );
-        }
-        MUTATE_END( Statement, node );
-}
-
-//--------------------------------------------------------------------------
 // ApplicationExpr
 template< typename pass_type >

src/Concurrency/Keywords.cc

@@ -302 +302 @@
                 void postvisit( FunctionDecl * decl );
                 void postvisit(   StructDecl * decl );
-                Statement * postmutate( MutexStmt * stmt );
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
@@ -308 +307 @@
                 void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
                 void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
-                void addStatements( CompoundStmt * body, const std::list<Expression * > & args );
                 void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
 
@@ -314 +312 @@
                         PassVisitor< MutexKeyword > impl;
                         acceptAll( translationUnit, impl );
-                        mutateAll( translationUnit, impl );
                 }
 
@@ -938 +935 @@
                         thread_guard_decl = decl;
                 }
-        }
-
-        Statement * MutexKeyword::postmutate( MutexStmt * stmt ) {
-                std::list<Statement *> stmtsForCtor;
-                stmtsForCtor.push_back(stmt->stmt);
-                CompoundStmt * body = new CompoundStmt( stmtsForCtor );
-                addStatements( body, stmt->mutexObjs);
-                return body;
         }
 
@@ -1069 +1058 @@
                         ))
                 );
-        }
-
-        void MutexKeyword::addStatements( CompoundStmt * body, const std::list<Expression * > & args ) {
-                ObjectDecl * monitors = new ObjectDecl(
-                        "__monitors",
-                        noStorageClasses,
-                        LinkageSpec::Cforall,
-                        nullptr,
-                        new ArrayType(
-                                noQualifiers,
-                                new PointerType(
-                                        noQualifiers,
-                                        new StructInstType(
-                                                noQualifiers,
-                                                monitor_decl
-                                        )
-                                ),
-                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
-                                false,
-                                false
-                        ),
-                        new ListInit(
-                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
-                                        return new SingleInit( new UntypedExpr(
-                                                new NameExpr( "get_monitor" ),
-                                                { var }
-                                        ) );
-                                })
-                        )
-                );
-
-                // in reverse order :
-                // monitor_guard_t __guard = { __monitors, # };
-                body->push_front(
-                        new DeclStmt( new ObjectDecl(
-                                "__guard",
-                                noStorageClasses,
-                                LinkageSpec::Cforall,
-                                nullptr,
-                                new StructInstType(
-                                        noQualifiers,
-                                        guard_decl
-                                ),
-                                new ListInit(
-                                        {
-                                                new SingleInit( new VariableExpr( monitors ) ),
-                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) )
-                                        },
-                                        noDesignators,
-                                        true
-                                )
-                        ))
-                );
-
-                //monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
-                body->push_front( new DeclStmt( monitors) );
         }
 

src/Parser/ParseNode.h

@@ -437 +437 @@
 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when, StatementNode * else_stmt, ExpressionNode * else_when );
 Statement * build_with( ExpressionNode * exprs, StatementNode * stmt );
-Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt );
 
 //##############################################################################

src/Parser/StatementNode.cc

@@ -374 +374 @@
 } // build_directive
 
-Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
-        std::list< Expression * > expList;
-        buildMoveList( exprs, expList );
-        Statement * body = maybeMoveBuild<Statement>( stmt );
-        return new MutexStmt( body, expList );
-} // build_mutex
-
 // Local Variables: //
 // tab-width: 4 //

src/Parser/parser.yy

@@ -1347 +1347 @@
 mutex_statement:
         MUTEX '(' argument_expression_list_opt ')' statement
-                { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+                { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
         ;
 

src/SynTree/Mutator.h

@@ -58 +58 @@
         virtual Statement * mutate( DeclStmt * declStmt ) = 0;
         virtual Statement * mutate( ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
-        virtual Statement * mutate( MutexStmt * mutexStmt ) = 0;
 
         virtual Expression * mutate( ApplicationExpr * applicationExpr ) = 0;

src/SynTree/Statement.cc

@@ -565 +565 @@
 }
 
-MutexStmt::MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs ) 
-        : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
-
-MutexStmt::MutexStmt( const MutexStmt & other ) : Statement( other ), stmt( maybeClone( other.stmt ) ) {
-        cloneAll( other.mutexObjs, mutexObjs );
-}
-
-MutexStmt::~MutexStmt() {
-        deleteAll( mutexObjs );
-        delete stmt;
-}
-
-void MutexStmt::print( std::ostream & os, Indenter indent ) const {
-        os << "Mutex Statement" << endl;
-        os << indent << "... with Expressions: " << endl;
-        for (auto * obj : mutexObjs) {
-                os << indent+1;
-                obj->print( os, indent+1);
-                os << endl;
-        }
-        os << indent << "... with Statement: " << endl << indent+1;
-        stmt->print( os, indent+1 );
-}
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.h

@@ -535 +535 @@
 };
 
-class MutexStmt : public Statement {
-  public:
-        Statement * stmt;
-        std::list<Expression *> mutexObjs; // list of mutex objects to acquire
-
-        MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs );
-        MutexStmt( const MutexStmt & other );
-        virtual ~MutexStmt();
-
-        virtual MutexStmt * clone() const override { return new MutexStmt( *this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-};
-
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/SynTree.h

@@ -62 +62 @@
 class NullStmt;
 class ImplicitCtorDtorStmt;
-class MutexStmt;
 
 class Expression;

src/SynTree/Visitor.h

@@ -92 +92 @@
         virtual void visit( ImplicitCtorDtorStmt * node ) { visit( const_cast<const ImplicitCtorDtorStmt *>(node) ); }
         virtual void visit( const ImplicitCtorDtorStmt * impCtorDtorStmt ) = 0;
-        virtual void visit( MutexStmt * node ) { visit( const_cast<const MutexStmt *>(node) ); }
-        virtual void visit( const MutexStmt * mutexStmt ) = 0;
 
         virtual void visit( ApplicationExpr * node ) { visit( const_cast<const ApplicationExpr *>(node) ); }