Changes in src/Concurrency/Keywords.cc [5b7c8b5:6cebfef]

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;
@@ -323 +322 @@
                 StructDecl* dtor_guard_decl = nullptr;
                 StructDecl* thread_guard_decl = nullptr;
-                StructDecl* lock_guard_decl = nullptr;
 
                 static std::unique_ptr< Type > generic_func;
@@ -465 +463 @@
         }
 
+
         void ConcurrentSueKeyword::handle( StructDecl * decl ) {
                 if( ! decl->body ) return;
@@ -480 +479 @@
                 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 +612 @@
         }
 
-        // 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 +634 @@
 
                 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 +937 @@
                         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;
                 }
         }
@@ -1200 +1081 @@
                                 new PointerType(
                                         noQualifiers,
-                                        new TypeofType( noQualifiers, args.front()->clone() )
+                                        new StructInstType(
+                                                noQualifiers,
+                                                monitor_decl
+                                        )
                                 ),
                                 new ConstantExpr( Constant::from_ulong( args.size() ) ),
@@ -1209 +1093 @@
                                 map_range < std::list<Initializer*> > ( args, [](Expression * var ){
                                         return new SingleInit( new UntypedExpr(
-                                                new NameExpr( "__get_pointer" ),
+                                                new NameExpr( "get_monitor" ),
                                                 { var }
                                         ) );
@@ -1215 +1099 @@
                         )
                 );
-
-                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 :
@@ -1229 +1108 @@
                                 LinkageSpec::Cforall,
                                 nullptr,
-                                lock_guard_struct,
+                                new StructInstType(
+                                        noQualifiers,
+                                        guard_decl
+                                ),
                                 new ListInit(
                                         {