Changes in src/Concurrency/Keywords.cc [bbe3719:e84ab3d]

File:

• src/Concurrency/Keywords.cc (modified) (11 diffs)

src/Concurrency/Keywords.cc

@@ -93 +93 @@
                 ObjectDecl * addField( StructDecl * );
                 void addRoutines( ObjectDecl *, FunctionDecl * );
-                void addLockUnlockRoutines( StructDecl * );
 
                 virtual bool is_target( StructDecl * decl ) = 0;
@@ -303 +302 @@
                 void postvisit( FunctionDecl * decl );
                 void postvisit(   StructDecl * decl );
-                Statement * postmutate( MutexStmt * stmt );
 
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
@@ -309 +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 );
 
@@ -315 +312 @@
                         PassVisitor< MutexKeyword > impl;
                         acceptAll( translationUnit, impl );
-                        mutateAll( translationUnit, impl );
                 }
 
@@ -323 +319 @@
                 StructDecl* dtor_guard_decl = nullptr;
                 StructDecl* thread_guard_decl = nullptr;
-                StructDecl* lock_guard_decl = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
@@ -465 +460 @@
         }
 
+
         void ConcurrentSueKeyword::handle( StructDecl * decl ) {
                 if( ! decl->body ) return;
@@ -480 +476 @@
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
-
-                // add get_.* routine
                 addRoutines( field, func );
-                // add lock/unlock routines to monitors for use by mutex stmt
-                addLockUnlockRoutines( decl );
         }
 
@@ -617 +609 @@
         }
 
-        // This function adds the get_.* routine body for coroutines, monitors etc
-        //              after their corresponding struct has been made
         void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
                 CompoundStmt * statement = new CompoundStmt();
@@ -641 +631 @@
 
                 declsToAddAfter.push_back( get_decl );
-        }
-
-        // Generates lock/unlock routines for monitors to be used by mutex stmts
-        void ConcurrentSueKeyword::addLockUnlockRoutines( StructDecl * decl ) {
-                // this routine will be called for all ConcurrentSueKeyword children so only continue if we are a monitor
-                if ( !decl->is_monitor() ) return;
-
-                FunctionType * lock_fn_type = new FunctionType( noQualifiers, false );
-                FunctionType * unlock_fn_type = new FunctionType( noQualifiers, false );
-
-                // create this ptr parameter for both routines
-                ObjectDecl * this_decl = new ObjectDecl(
-                        "this",
-                        noStorageClasses,
-                        LinkageSpec::Cforall,
-                        nullptr,
-                        new ReferenceType(
-                                noQualifiers,
-                                new StructInstType(
-                                        noQualifiers,
-                                        decl
-                                )
-                        ),
-                        nullptr
-                );
-
-                lock_fn_type->get_parameters().push_back( this_decl->clone() );
-                unlock_fn_type->get_parameters().push_back( this_decl->clone() );
-                fixupGenerics(lock_fn_type, decl);
-                fixupGenerics(unlock_fn_type, decl);
-
-                delete this_decl;
-
-
-                //////////////////////////////////////////////////////////////////////
-                // The following generates this lock routine for all monitors
-                /*
-                        void lock (monitor_t & this) {
-                                lock(get_monitor(this));
-                        }       
-                */
-                FunctionDecl * lock_decl = new FunctionDecl(
-                        "lock",
-                        Type::Static,
-                        LinkageSpec::Cforall,
-                        lock_fn_type,
-                        nullptr,
-                        { },
-                        Type::Inline
-                );
-
-                UntypedExpr * get_monitor_lock =  new UntypedExpr (
-                        new NameExpr( "get_monitor" ),
-                        { new VariableExpr( lock_fn_type->get_parameters().front() ) }
-                );
-
-                CompoundStmt * lock_statement = new CompoundStmt();
-                lock_statement->push_back(
-                        new ExprStmt( 
-                                new UntypedExpr (
-                                        new NameExpr( "lock" ),
-                                        {
-                                                get_monitor_lock
-                                        }
-                                )
-                        )
-                );
-                lock_decl->set_statements( lock_statement );
-
-                //////////////////////////////////////////////////////////////////
-                // The following generates this routine for all monitors
-                /*
-                        void unlock (monitor_t & this) {
-                                unlock(get_monitor(this));
-                        }       
-                */
-                FunctionDecl * unlock_decl = new FunctionDecl(
-                        "unlock",
-                        Type::Static,
-                        LinkageSpec::Cforall,
-                        unlock_fn_type,
-                        nullptr,
-                        { },
-                        Type::Inline
-                );
-
-                CompoundStmt * unlock_statement = new CompoundStmt();
-
-                UntypedExpr * get_monitor_unlock =  new UntypedExpr (
-                        new NameExpr( "get_monitor" ),
-                        { new VariableExpr( unlock_fn_type->get_parameters().front() ) }
-                );
-
-                unlock_statement->push_back(
-                        new ExprStmt( 
-                                new UntypedExpr(
-                                        new NameExpr( "unlock" ),
-                                        {
-                                                get_monitor_unlock
-                                        }
-                                )
-                        )
-                );
-                unlock_decl->set_statements( unlock_statement );
-                
-                // pushes routines to declsToAddAfter to add at a later time
-                declsToAddAfter.push_back( lock_decl );
-                declsToAddAfter.push_back( unlock_decl );
         }
 
@@ -1052 +934 @@
                         assert( !thread_guard_decl );
                         thread_guard_decl = decl;
-                } 
-                else if ( decl->name == "__mutex_stmt_lock_guard" && decl->body ) {
-                        assert( !lock_guard_decl );
-                        lock_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;
+                }
         }
 
@@ -1188 +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 TypeofType( noQualifiers, args.front()->clone() )
-                                ),
-                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
-                                false,
-                                false
-                        ),
-                        new ListInit(
-                                map_range < std::list<Initializer*> > ( args, [](Expression * var ){
-                                        return new SingleInit( new AddressExpr( var ) );
-                                })
-                        )
-                );
-
-                StructInstType * lock_guard_struct = new StructInstType( noQualifiers, lock_guard_decl );
-                TypeExpr * lock_type_expr = new TypeExpr( new TypeofType( noQualifiers, args.front()->clone() ) );
-
-                lock_guard_struct->parameters.push_back( lock_type_expr ) ;
-
-                // in reverse order :
-                // monitor_guard_t __guard = { __monitors, # };
-                body->push_front(
-                        new DeclStmt( new ObjectDecl(
-                                "__guard",
-                                noStorageClasses,
-                                LinkageSpec::Cforall,
-                                nullptr,
-                                lock_guard_struct,
-                                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) );
         }