source: src/Concurrency/Keywords.cc @ 6b224a5

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 6b224a5 was 6b224a5, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

  • Property mode set to 100644
File size: 17.6 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Keywords.cc --
8//
9// Author           : Thierry Delisle
10// Created On       : Mon Mar 13 12:41:22 2017
11// Last Modified By :
12// Last Modified On :
13// Update Count     : 5
14//
15
16#include "Concurrency/Keywords.h"
17
18#include <cassert>                 // for assert
19#include <string>                  // for string, operator==
20
21#include "Common/SemanticError.h"  // for SemanticError
22#include "Common/utility.h"        // for deleteAll, map_range
23#include "CodeGen/OperatorTable.h" // for isConstructor
24#include "InitTweak/InitTweak.h"   // for getPointerBase
25#include "Parser/LinkageSpec.h"    // for Cforall
26#include "SymTab/AddVisit.h"       // for acceptAndAdd
27#include "SynTree/Constant.h"      // for Constant
28#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
29#include "SynTree/Expression.h"    // for VariableExpr, ConstantExpr, Untype...
30#include "SynTree/Initializer.h"   // for SingleInit, ListInit, Initializer ...
31#include "SynTree/Label.h"         // for Label
32#include "SynTree/Statement.h"     // for CompoundStmt, DeclStmt, ExprStmt
33#include "SynTree/Type.h"          // for StructInstType, Type, PointerType
34#include "SynTree/Visitor.h"       // for Visitor, acceptAll
35
36class Attribute;
37
38namespace Concurrency {
39
40        namespace {
41                const std::list<Label> noLabels;
42                const std::list< Attribute * > noAttributes;
43                Type::StorageClasses noStorage;
44                Type::Qualifiers noQualifiers;
45        }
46
47        //=============================================================================================
48        // Visitors declaration
49        //=============================================================================================
50
51        //-----------------------------------------------------------------------------
52        //Handles sue type declarations :
53        // sue MyType {                             struct MyType {
54        //      int data;                                  int data;
55        //      a_struct_t more_data;                      a_struct_t more_data;
56        //                                =>             NewField_t newField;
57        // };                                        };
58        //                                           static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
59        //
60        class ConcurrentSueKeyword : public Visitor {
61          protected:
62            template< typename Visitor >
63            friend void SymTab::acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
64          public:
65
66                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
67                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
68
69                virtual ~ConcurrentSueKeyword() {}
70
71                using Visitor::visit;
72                virtual void visit( StructDecl * decl ) override final;
73
74                void handle( StructDecl * );
75                FunctionDecl * forwardDeclare( StructDecl * );
76                ObjectDecl * addField( StructDecl * );
77                void addRoutines( ObjectDecl *, FunctionDecl * );
78
79                virtual bool is_target( StructDecl * decl ) = 0;
80
81          private:
82                const std::string type_name;
83                const std::string field_name;
84                const std::string getter_name;
85                const std::string context_error;
86                bool needs_main;
87
88                std::list< Declaration * > declsToAdd, declsToAddAfter;
89                StructDecl* type_decl = nullptr;
90        };
91
92
93        //-----------------------------------------------------------------------------
94        //Handles thread type declarations :
95        // thread Mythread {                         struct MyThread {
96        //      int data;                                  int data;
97        //      a_struct_t more_data;                      a_struct_t more_data;
98        //                                =>             thread_desc __thrd_d;
99        // };                                        };
100        //                                           static inline thread_desc * get_thread( MyThread * this ) { return &this->__thrd_d; }
101        //
102        class ThreadKeyword final : public ConcurrentSueKeyword {
103          public:
104
105                ThreadKeyword() : ConcurrentSueKeyword(
106                        "thread_desc",
107                        "__thrd",
108                        "get_thread",
109                        "thread keyword requires threads to be in scope, add #include <thread>",
110                        true
111                )
112                {}
113
114                virtual ~ThreadKeyword() {}
115
116                virtual bool is_target( StructDecl * decl ) override final { return decl->is_thread(); }
117
118                static void implement( std::list< Declaration * > & translationUnit ) {
119                        ThreadKeyword impl;
120                        SymTab::acceptAndAdd( translationUnit, impl );
121                }
122        };
123
124        //-----------------------------------------------------------------------------
125        //Handles coroutine type declarations :
126        // coroutine MyCoroutine {                   struct MyCoroutine {
127        //      int data;                                  int data;
128        //      a_struct_t more_data;                      a_struct_t more_data;
129        //                                =>             coroutine_desc __cor_d;
130        // };                                        };
131        //                                           static inline coroutine_desc * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
132        //
133        class CoroutineKeyword final : public ConcurrentSueKeyword {
134          public:
135
136                CoroutineKeyword() : ConcurrentSueKeyword(
137                        "coroutine_desc",
138                        "__cor",
139                        "get_coroutine",
140                        "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
141                        true
142                )
143                {}
144
145                virtual ~CoroutineKeyword() {}
146
147                virtual bool is_target( StructDecl * decl ) override final { return decl->is_coroutine(); }
148
149                static void implement( std::list< Declaration * > & translationUnit ) {
150                        CoroutineKeyword impl;
151                        SymTab::acceptAndAdd( translationUnit, impl );
152                }
153        };
154
155        //-----------------------------------------------------------------------------
156        //Handles monitor type declarations :
157        // monitor MyMonitor {                       struct MyMonitor {
158        //      int data;                                  int data;
159        //      a_struct_t more_data;                      a_struct_t more_data;
160        //                                =>             monitor_desc __mon_d;
161        // };                                        };
162        //                                           static inline monitor_desc * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
163        //
164        class MonitorKeyword final : public ConcurrentSueKeyword {
165          public:
166
167                MonitorKeyword() : ConcurrentSueKeyword(
168                        "monitor_desc",
169                        "__mon",
170                        "get_monitor",
171                        "monitor keyword requires monitors to be in scope, add #include <monitor>",
172                        false
173                )
174                {}
175
176                virtual ~MonitorKeyword() {}
177
178                virtual bool is_target( StructDecl * decl ) override final { return decl->is_monitor(); }
179
180                static void implement( std::list< Declaration * > & translationUnit ) {
181                        MonitorKeyword impl;
182                        SymTab::acceptAndAdd( translationUnit, impl );
183                }
184        };
185
186        //-----------------------------------------------------------------------------
187        //Handles mutex routines definitions :
188        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
189        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
190        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
191        //    /*Some code*/                                       =>           /*Some code*/
192        // }                                                               }
193        //
194        class MutexKeyword final : public Visitor {
195          public:
196
197                using Visitor::visit;
198                virtual void visit( FunctionDecl * decl ) override final;
199                virtual void visit(   StructDecl * decl ) override final;
200
201                std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
202                void validate( DeclarationWithType * );
203                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
204
205                static void implement( std::list< Declaration * > & translationUnit ) {
206                        MutexKeyword impl;
207                        acceptAll( translationUnit, impl );
208                }
209
210          private:
211                StructDecl* monitor_decl = nullptr;
212                StructDecl* guard_decl = nullptr;
213
214                static std::unique_ptr< Type > generic_func;
215        };
216
217        std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
218                new FunctionType(
219                        noQualifiers,
220                        true
221                )
222        );
223
224        //-----------------------------------------------------------------------------
225        //Handles mutex routines definitions :
226        // void foo( A * mutex a, B * mutex b,  int i ) {                  void foo( A * a, B * b,  int i ) {
227        //                                                                       monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
228        //                                                                       monitor_guard_t __guard = { __monitors, 2 };
229        //    /*Some code*/                                       =>           /*Some code*/
230        // }                                                               }
231        //
232        class ThreadStarter final : public Visitor {
233          public:
234
235                using Visitor::visit;
236                virtual void visit( FunctionDecl * decl ) override final;
237
238                void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
239
240                static void implement( std::list< Declaration * > & translationUnit ) {
241                        ThreadStarter impl;
242                        acceptAll( translationUnit, impl );
243                }
244        };
245
246        //=============================================================================================
247        // General entry routine
248        //=============================================================================================
249        void applyKeywords( std::list< Declaration * > & translationUnit ) {
250                ThreadKeyword   ::implement( translationUnit );
251                CoroutineKeyword        ::implement( translationUnit );
252                MonitorKeyword  ::implement( translationUnit );
253        }
254
255        void implementMutexFuncs( std::list< Declaration * > & translationUnit ) {
256                MutexKeyword    ::implement( translationUnit );
257        }
258
259        void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
260                ThreadStarter   ::implement( translationUnit );
261        }
262
263        //=============================================================================================
264        // Generic keyword implementation
265        //=============================================================================================
266        void ConcurrentSueKeyword::visit(StructDecl * decl) {
267                Visitor::visit(decl);
268                if( decl->get_name() == type_name && decl->has_body() ) {
269                        assert( !type_decl );
270                        type_decl = decl;
271                }
272                else if ( is_target(decl) ) {
273                        handle( decl );
274                }
275
276        }
277
278        void ConcurrentSueKeyword::handle( StructDecl * decl ) {
279                if( ! decl->has_body() ) return;
280
281                if( !type_decl ) throw SemanticError( context_error, decl );
282
283                FunctionDecl * func = forwardDeclare( decl );
284                ObjectDecl * field = addField( decl );
285                addRoutines( field, func );
286        }
287
288        FunctionDecl * ConcurrentSueKeyword::forwardDeclare( StructDecl * decl ) {
289
290                StructDecl * forward = decl->clone();
291                forward->set_body( false );
292                deleteAll( forward->get_members() );
293                forward->get_members().clear();
294
295                FunctionType * get_type = new FunctionType( noQualifiers, false );
296                ObjectDecl * this_decl = new ObjectDecl(
297                        "this",
298                        noStorage,
299                        LinkageSpec::Cforall,
300                        nullptr,
301                        new ReferenceType(
302                                noQualifiers,
303                                new StructInstType(
304                                        noQualifiers,
305                                        decl
306                                )
307                        ),
308                        nullptr
309                );
310
311                get_type->get_parameters().push_back( this_decl );
312                get_type->get_returnVals().push_back(
313                        new ObjectDecl(
314                                "ret",
315                                noStorage,
316                                LinkageSpec::Cforall,
317                                nullptr,
318                                new PointerType(
319                                        noQualifiers,
320                                        new StructInstType(
321                                                noQualifiers,
322                                                type_decl
323                                        )
324                                ),
325                                nullptr
326                        )
327                );
328
329                FunctionDecl * get_decl = new FunctionDecl(
330                        getter_name,
331                        Type::Static,
332                        LinkageSpec::Cforall,
333                        get_type,
334                        nullptr,
335                        noAttributes,
336                        Type::Inline
337                );
338
339                FunctionDecl * main_decl = nullptr;
340
341                if( needs_main ) {
342                        FunctionType * main_type = new FunctionType( noQualifiers, false );
343
344                        main_type->get_parameters().push_back( this_decl->clone() );
345
346                        main_decl = new FunctionDecl(
347                                "main",
348                                noStorage,
349                                LinkageSpec::Cforall,
350                                main_type,
351                                nullptr
352                        );
353                }
354
355                declsToAdd.push_back( forward );
356                if( needs_main ) declsToAdd.push_back( main_decl );
357                declsToAdd.push_back( get_decl );
358
359                return get_decl;
360        }
361
362        ObjectDecl * ConcurrentSueKeyword::addField( StructDecl * decl ) {
363                ObjectDecl * field = new ObjectDecl(
364                        field_name,
365                        noStorage,
366                        LinkageSpec::Cforall,
367                        nullptr,
368                        new StructInstType(
369                                noQualifiers,
370                                type_decl
371                        ),
372                        nullptr
373                );
374
375                decl->get_members().push_back( field );
376
377                return field;
378        }
379
380        void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
381                CompoundStmt * statement = new CompoundStmt( noLabels );
382                statement->push_back(
383                        new ReturnStmt(
384                                noLabels,
385                                new AddressExpr(
386                                        new MemberExpr(
387                                                field,
388                                                UntypedExpr::createDeref( new VariableExpr( func->get_functionType()->get_parameters().front() ) )
389                                        )
390                                )
391                        )
392                );
393
394                FunctionDecl * get_decl = func->clone();
395
396                get_decl->set_statements( statement );
397
398                declsToAddAfter.push_back( get_decl );
399
400                // get_decl->fixUniqueId();
401        }
402
403        //=============================================================================================
404        // Mutex keyword implementation
405        //=============================================================================================
406
407        void MutexKeyword::visit(FunctionDecl* decl) {
408                Visitor::visit(decl);
409
410                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
411                if( mutexArgs.empty() ) return;
412
413                for(auto arg : mutexArgs) {
414                        validate( arg );
415                }
416
417                CompoundStmt* body = decl->get_statements();
418                if( ! body ) return;
419
420                if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
421                if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
422
423                addStatments( decl, body, mutexArgs );
424        }
425
426        void MutexKeyword::visit(StructDecl* decl) {
427                Visitor::visit(decl);
428
429                if( decl->get_name() == "monitor_desc" ) {
430                        assert( !monitor_decl );
431                        monitor_decl = decl;
432                }
433                else if( decl->get_name() == "monitor_guard_t" ) {
434                        assert( !guard_decl );
435                        guard_decl = decl;
436                }
437        }
438
439        std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl ) {
440                std::list<DeclarationWithType*> mutexArgs;
441
442                for( auto arg : decl->get_functionType()->get_parameters()) {
443                        //Find mutex arguments
444                        Type* ty = arg->get_type();
445                        if( ! ty->get_mutex() ) continue;
446
447                        //Append it to the list
448                        mutexArgs.push_back( arg );
449                }
450
451                return mutexArgs;
452        }
453
454        void MutexKeyword::validate( DeclarationWithType * arg ) {
455                Type* ty = arg->get_type();
456
457                //Makes sure it's not a copy
458                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
459                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
460
461                //Make sure the we are pointing directly to a type
462                Type* base = rty->get_base();
463                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
464                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
465
466                //Make sure that typed isn't mutex
467                if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
468        }
469
470        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
471                ObjectDecl * monitors = new ObjectDecl(
472                        "__monitors",
473                        noStorage,
474                        LinkageSpec::Cforall,
475                        nullptr,
476                        new ArrayType(
477                                noQualifiers,
478                                new PointerType(
479                                        noQualifiers,
480                                        new StructInstType(
481                                                noQualifiers,
482                                                monitor_decl
483                                        )
484                                ),
485                                new ConstantExpr( Constant::from_ulong( args.size() ) ),
486                                false,
487                                false
488                        ),
489                        new ListInit(
490                                map_range < std::list<Initializer*> > ( args, [this](DeclarationWithType * var ){
491                                        Type * type = var->get_type()->clone();
492                                        type->set_mutex( false );
493                                        return new SingleInit( new UntypedExpr(
494                                                new NameExpr( "get_monitor" ),
495                                                {  new CastExpr( new VariableExpr( var ), type ) }
496                                        ) );
497                                })
498                        )
499                );
500
501                assert(generic_func);
502
503                //in reverse order :
504                // monitor_guard_t __guard = { __monitors, #, func };
505                body->push_front(
506                        new DeclStmt( noLabels, new ObjectDecl(
507                                "__guard",
508                                noStorage,
509                                LinkageSpec::Cforall,
510                                nullptr,
511                                new StructInstType(
512                                        noQualifiers,
513                                        guard_decl
514                                ),
515                                new ListInit(
516                                        {
517                                                new SingleInit( new VariableExpr( monitors ) ),
518                                                new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
519                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
520                                        },
521                                        noDesignators,
522                                        true
523                                )
524                        ))
525                );
526
527                //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
528                body->push_front( new DeclStmt( noLabels, monitors) );
529        }
530
531        //=============================================================================================
532        // General entry routine
533        //=============================================================================================
534        void ThreadStarter::visit(FunctionDecl * decl) {
535                Visitor::visit(decl);
536
537                if( ! CodeGen::isConstructor(decl->get_name()) ) return;
538
539                DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
540                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
541                // if( type ) std::cerr << "FRED2" << std::endl;
542                if( type && type->get_baseStruct()->is_thread() ) {
543                        addStartStatement( decl, param );
544                }
545        }
546
547        void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
548                CompoundStmt * stmt = decl->get_statements();
549
550                if( ! stmt ) return;
551
552                stmt->push_back(
553                        new ExprStmt(
554                                noLabels,
555                                new UntypedExpr(
556                                        new NameExpr( "__thrd_start" ),
557                                        { new VariableExpr( param ) }
558                                )
559                        )
560                );
561        }
562};
563
564// Local Variables: //
565// mode: c //
566// tab-width: 4 //
567// End: //
Note: See TracBrowser for help on using the repository browser.