Changeset 90152a4 for src/Concurrency/Keywords.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (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' into cleanup-dtors

File:

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

src/Concurrency/Keywords.cc

@@ -25 +25 @@
 #include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
-#include "SymTab/AddVisit.h"       // for acceptAndAdd
 #include "SynTree/Constant.h"      // for Constant
 #include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
@@ -54 +53 @@
           public:
 
-                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
-                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, KeywordCastExpr::Target cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
 
                 virtual ~ConcurrentSueKeyword() {}
 
-                void postvisit( StructDecl * decl );
+                Declaration * postmutate( StructDecl * decl );
 
                 void handle( StructDecl * );
@@ -67 +66 @@
 
                 virtual bool is_target( StructDecl * decl ) = 0;
+
+                Expression * postmutate( KeywordCastExpr * cast );
 
           private:
@@ -74 +75 @@
                 const std::string context_error;
                 bool needs_main;
+                KeywordCastExpr::Target cast_target;
 
                 StructDecl* type_decl = nullptr;
@@ -95 +97 @@
                         "__thrd",
                         "get_thread",
-                        "thread keyword requires threads to be in scope, add #include <thread>",
-                        true
+                        "thread keyword requires threads to be in scope, add #include <thread.hfa>",
+                        true,
+                        KeywordCastExpr::Thread
                 )
                 {}
@@ -106 +109 @@
                 static void implement( std::list< Declaration * > & translationUnit ) {
                         PassVisitor< ThreadKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
         };
@@ -126 +129 @@
                         "__cor",
                         "get_coroutine",
-                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
-                        true
+                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>",
+                        true,
+                        KeywordCastExpr::Coroutine
                 )
                 {}
@@ -137 +141 @@
                 static void implement( std::list< Declaration * > & translationUnit ) {
                         PassVisitor< CoroutineKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
         };
@@ -157 +161 @@
                         "__mon",
                         "get_monitor",
-                        "monitor keyword requires monitors to be in scope, add #include <monitor>",
-                        false
+                        "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>",
+                        false,
+                        KeywordCastExpr::Monitor
                 )
                 {}
@@ -168 +173 @@
                 static void implement( std::list< Declaration * > & translationUnit ) {
                         PassVisitor< MonitorKeyword > impl;
-                        acceptAll( translationUnit, impl );
+                        mutateAll( translationUnit, impl );
                 }
         };
@@ -186 +191 @@
                 void postvisit(   StructDecl * decl );
 
-                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
+                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
                 void validate( DeclarationWithType * );
                 void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
@@ -257 +262 @@
         // Generic keyword implementation
         //=============================================================================================
-        void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
+        void fixupGenerics(FunctionType * func, StructDecl * decl) {
+                cloneAll(decl->parameters, func->forall);
+                for ( TypeDecl * td : func->forall ) {
+                        strict_dynamic_cast<StructInstType*>(
+                                func->parameters.front()->get_type()->stripReferences()
+                        )->parameters.push_back(
+                                new TypeExpr( new TypeInstType( noQualifiers, td->name, td ) )
+                        );
+                }
+        }
+
+        Declaration * ConcurrentSueKeyword::postmutate(StructDecl * decl) {
                 if( decl->name == type_name && decl->body ) {
                         assert( !type_decl );
@@ -265 +281 @@
                         handle( decl );
                 }
-
-        }
+                return decl;
+        }
+
+        Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
+                if ( cast_target == cast->target ) {
+                        // convert (thread &)t to (thread_desc &)*get_thread(t), etc.
+                        if( !type_decl ) SemanticError( cast, context_error );
+                        Expression * arg = cast->arg;
+                        cast->arg = nullptr;
+                        delete cast;
+                        return new CastExpr(
+                                UntypedExpr::createDeref(
+                                        new UntypedExpr( new NameExpr( getter_name ), { arg } )
+                                ),
+                                new ReferenceType(
+                                        noQualifiers,
+                                        new StructInstType( noQualifiers, type_decl ) )
+                                );
+                }
+                return cast;
+        }
+
 
         void ConcurrentSueKeyword::handle( StructDecl * decl ) {
                 if( ! decl->body ) return;
 
-                if( !type_decl ) throw SemanticError( context_error, decl );
+                if( !type_decl ) SemanticError( decl, context_error );
 
                 FunctionDecl * func = forwardDeclare( decl );
@@ -301 +337 @@
                 );
 
-                get_type->get_parameters().push_back( this_decl );
+                get_type->get_parameters().push_back( this_decl->clone() );
                 get_type->get_returnVals().push_back(
                         new ObjectDecl(
@@ -318 +354 @@
                         )
                 );
+                fixupGenerics(get_type, decl);
 
                 FunctionDecl * get_decl = new FunctionDecl(
@@ -343 +380 @@
                                 nullptr
                         );
-                }
+                        fixupGenerics(main_type, decl);
+                }
+
+                delete this_decl;
 
                 declsToAddBefore.push_back( forward );
@@ -377 +417 @@
                                         new MemberExpr(
                                                 field,
-                                                UntypedExpr::createDeref( new VariableExpr( func->get_functionType()->get_parameters().front() ) )
+                                                new CastExpr(
+                                                        new VariableExpr( func->get_functionType()->get_parameters().front() ),
+                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone()
+                                                )
                                         )
                                 )
@@ -398 +441 @@
         void MutexKeyword::postvisit(FunctionDecl* decl) {
 
-                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
-                if( mutexArgs.empty() ) return;
-
-                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl );
-
+                bool first = false;
+                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
                 bool isDtor = CodeGen::isDestructor( decl->name );
 
-                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl );
-
+                // Is this function relevant to monitors
+                if( mutexArgs.empty() ) {
+                        // If this is the destructor for a monitor it must be mutex
+                        if(isDtor) {
+                                Type* ty = decl->get_functionType()->get_parameters().front()->get_type();
+
+                                // If it's a copy, it's not a mutex
+                                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
+                                if( ! rty ) return;
+
+                                // If we are not pointing directly to a type, it's not a mutex
+                                Type* base = rty->get_base();
+                                if( dynamic_cast< ReferenceType * >( base ) ) return;
+                                if( dynamic_cast< PointerType * >( base ) ) return;
+
+                                // Check if its a struct
+                                StructInstType * baseStruct = dynamic_cast< StructInstType * >( base );
+                                if( !baseStruct ) return;
+
+                                // Check if its a monitor
+                                if(baseStruct->baseStruct->is_monitor() || baseStruct->baseStruct->is_thread())
+                                        SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters\n" );
+                        }
+                        return;
+                }
+
+                // Monitors can't be constructed with mutual exclusion
+                if( CodeGen::isConstructor(decl->name) && !first ) SemanticError( decl, "constructors cannot have mutex parameters" );
+
+                // It makes no sense to have multiple mutex parameters for the destructor
+                if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
+
+                // Make sure all the mutex arguments are monitors
                 for(auto arg : mutexArgs) {
                         validate( arg );
                 }
 
+                // Check if we need to instrument the body
                 CompoundStmt* body = decl->get_statements();
                 if( ! body ) return;
 
-                if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
-                if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
-                if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
-
+                // Do we have the required headers
+                if( !monitor_decl || !guard_decl || !dtor_guard_decl )
+                        SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor.hfa>\n" );
+
+                // Instrument the body
                 if( isDtor ) {
                         addDtorStatments( decl, body, mutexArgs );
@@ -428 +501 @@
         void MutexKeyword::postvisit(StructDecl* decl) {
 
-                if( decl->name == "monitor_desc" ) {
+                if( decl->name == "monitor_desc" && decl->body ) {
                         assert( !monitor_decl );
                         monitor_decl = decl;
                 }
-                else if( decl->name == "monitor_guard_t" ) {
+                else if( decl->name == "monitor_guard_t" && decl->body ) {
                         assert( !guard_decl );
                         guard_decl = decl;
                 }
-                else if( decl->name == "monitor_dtor_guard_t" ) {
+                else if( decl->name == "monitor_dtor_guard_t" && decl->body ) {
                         assert( !dtor_guard_decl );
                         dtor_guard_decl = decl;
@@ -442 +515 @@
         }
 
-        std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl ) {
+        std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl, bool & first ) {
                 std::list<DeclarationWithType*> mutexArgs;
 
+                bool once = true;
                 for( auto arg : decl->get_functionType()->get_parameters()) {
                         //Find mutex arguments
@@ -450 +524 @@
                         if( ! ty->get_mutex() ) continue;
 
+                        if(once) {first = true;}
+                        once = false;
+
                         //Append it to the list
                         mutexArgs.push_back( arg );
@@ -462 +539 @@
                 //Makes sure it's not a copy
                 ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
-                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
+                if( ! rty ) SemanticError( arg, "Mutex argument must be of reference type " );
 
                 //Make sure the we are pointing directly to a type
                 Type* base = rty->get_base();
-                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
-                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                if( dynamic_cast< ReferenceType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
+                if( dynamic_cast< PointerType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
 
                 //Make sure that typed isn't mutex
-                if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+                if( base->get_mutex() ) SemanticError( arg, "mutex keyword may only appear once per argument " );
         }
 
@@ -608 +685 @@
                 if( type && type->get_baseStruct()->is_thread() ) {
                         if( !thread_decl || !thread_ctor_seen ) {
-                                throw SemanticError("thread keyword requires threads to be in scope, add #include <thread>");
+                                SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread.hfa>");
                         }