source: src/Concurrency/Keywords.cc@ ee61248

ADT aaron-thesis arm-eh ast-experimental cleanup-dtors deferred_resn demangler enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr new-env no_list persistent-indexer pthread-emulation qualifiedEnum resolv-new with_gc
Last change on this file since ee61248 was a16764a6, checked in by Thierry Delisle <tdelisle@…>, 8 years ago

Changed warning system to prepare for toggling warnings
  • Property mode set to 100644
File size: 19.9 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/PassVisitor.h" // for PassVisitor
22#include "Common/SemanticError.h" // for SemanticError
23#include "Common/utility.h" // for deleteAll, map_range
24#include "CodeGen/OperatorTable.h" // for isConstructor
25#include "InitTweak/InitTweak.h" // for getPointerBase
26#include "Parser/LinkageSpec.h" // for Cforall
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 // Pass declarations
41 //=============================================================================================
42
43 //-----------------------------------------------------------------------------
44 //Handles sue type declarations :
45 // sue MyType { struct MyType {
46 // int data; int data;
47 // a_struct_t more_data; a_struct_t more_data;
48 // => NewField_t newField;
49 // }; };
50 // static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
51 //
52 class ConcurrentSueKeyword : public WithDeclsToAdd {
53 public:
54
55 ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) :
56 type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {}
57
58 virtual ~ConcurrentSueKeyword() {}
59
60 void postvisit( StructDecl * decl );
61
62 void handle( StructDecl * );
63 FunctionDecl * forwardDeclare( StructDecl * );
64 ObjectDecl * addField( StructDecl * );
65 void addRoutines( ObjectDecl *, FunctionDecl * );
66
67 virtual bool is_target( StructDecl * decl ) = 0;
68
69 private:
70 const std::string type_name;
71 const std::string field_name;
72 const std::string getter_name;
73 const std::string context_error;
74 bool needs_main;
75
76 StructDecl* type_decl = nullptr;
77 };
78
79
80 //-----------------------------------------------------------------------------
81 //Handles thread type declarations :
82 // thread Mythread { struct MyThread {
83 // int data; int data;
84 // a_struct_t more_data; a_struct_t more_data;
85 // => thread_desc __thrd_d;
86 // }; };
87 // static inline thread_desc * get_thread( MyThread * this ) { return &this->__thrd_d; }
88 //
89 class ThreadKeyword final : public ConcurrentSueKeyword {
90 public:
91
92 ThreadKeyword() : ConcurrentSueKeyword(
93 "thread_desc",
94 "__thrd",
95 "get_thread",
96 "thread keyword requires threads to be in scope, add #include <thread>",
97 true
98 )
99 {}
100
101 virtual ~ThreadKeyword() {}
102
103 virtual bool is_target( StructDecl * decl ) override final { return decl->is_thread(); }
104
105 static void implement( std::list< Declaration * > & translationUnit ) {
106 PassVisitor< ThreadKeyword > impl;
107 acceptAll( translationUnit, impl );
108 }
109 };
110
111 //-----------------------------------------------------------------------------
112 //Handles coroutine type declarations :
113 // coroutine MyCoroutine { struct MyCoroutine {
114 // int data; int data;
115 // a_struct_t more_data; a_struct_t more_data;
116 // => coroutine_desc __cor_d;
117 // }; };
118 // static inline coroutine_desc * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
119 //
120 class CoroutineKeyword final : public ConcurrentSueKeyword {
121 public:
122
123 CoroutineKeyword() : ConcurrentSueKeyword(
124 "coroutine_desc",
125 "__cor",
126 "get_coroutine",
127 "coroutine keyword requires coroutines to be in scope, add #include <coroutine>",
128 true
129 )
130 {}
131
132 virtual ~CoroutineKeyword() {}
133
134 virtual bool is_target( StructDecl * decl ) override final { return decl->is_coroutine(); }
135
136 static void implement( std::list< Declaration * > & translationUnit ) {
137 PassVisitor< CoroutineKeyword > impl;
138 acceptAll( translationUnit, impl );
139 }
140 };
141
142 //-----------------------------------------------------------------------------
143 //Handles monitor type declarations :
144 // monitor MyMonitor { struct MyMonitor {
145 // int data; int data;
146 // a_struct_t more_data; a_struct_t more_data;
147 // => monitor_desc __mon_d;
148 // }; };
149 // static inline monitor_desc * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
150 //
151 class MonitorKeyword final : public ConcurrentSueKeyword {
152 public:
153
154 MonitorKeyword() : ConcurrentSueKeyword(
155 "monitor_desc",
156 "__mon",
157 "get_monitor",
158 "monitor keyword requires monitors to be in scope, add #include <monitor>",
159 false
160 )
161 {}
162
163 virtual ~MonitorKeyword() {}
164
165 virtual bool is_target( StructDecl * decl ) override final { return decl->is_monitor(); }
166
167 static void implement( std::list< Declaration * > & translationUnit ) {
168 PassVisitor< MonitorKeyword > impl;
169 acceptAll( translationUnit, impl );
170 }
171 };
172
173 //-----------------------------------------------------------------------------
174 //Handles mutex routines definitions :
175 // void foo( A * mutex a, B * mutex b, int i ) { void foo( A * a, B * b, int i ) {
176 // monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
177 // monitor_guard_t __guard = { __monitors, 2 };
178 // /*Some code*/ => /*Some code*/
179 // } }
180 //
181 class MutexKeyword final {
182 public:
183
184 void postvisit( FunctionDecl * decl );
185 void postvisit( StructDecl * decl );
186
187 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl* );
188 void validate( DeclarationWithType * );
189 void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
190 void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
191
192 static void implement( std::list< Declaration * > & translationUnit ) {
193 PassVisitor< MutexKeyword > impl;
194 acceptAll( translationUnit, impl );
195 }
196
197 private:
198 StructDecl* monitor_decl = nullptr;
199 StructDecl* guard_decl = nullptr;
200 StructDecl* dtor_guard_decl = nullptr;
201
202 static std::unique_ptr< Type > generic_func;
203 };
204
205 std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
206 new FunctionType(
207 noQualifiers,
208 true
209 )
210 );
211
212 //-----------------------------------------------------------------------------
213 //Handles mutex routines definitions :
214 // void foo( A * mutex a, B * mutex b, int i ) { void foo( A * a, B * b, int i ) {
215 // monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
216 // monitor_guard_t __guard = { __monitors, 2 };
217 // /*Some code*/ => /*Some code*/
218 // } }
219 //
220 class ThreadStarter final {
221 public:
222
223 void postvisit( FunctionDecl * decl );
224 void previsit ( StructDecl * decl );
225
226 void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
227
228 static void implement( std::list< Declaration * > & translationUnit ) {
229 PassVisitor< ThreadStarter > impl;
230 acceptAll( translationUnit, impl );
231 }
232
233 private :
234 bool thread_ctor_seen = false;
235 StructDecl * thread_decl = nullptr;
236 };
237
238 //=============================================================================================
239 // General entry routine
240 //=============================================================================================
241 void applyKeywords( std::list< Declaration * > & translationUnit ) {
242 ThreadKeyword ::implement( translationUnit );
243 CoroutineKeyword ::implement( translationUnit );
244 MonitorKeyword ::implement( translationUnit );
245 }
246
247 void implementMutexFuncs( std::list< Declaration * > & translationUnit ) {
248 MutexKeyword ::implement( translationUnit );
249 }
250
251 void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
252 ThreadStarter ::implement( translationUnit );
253 }
254
255 //=============================================================================================
256 // Generic keyword implementation
257 //=============================================================================================
258 void fixupGenerics(FunctionType * func, StructDecl * decl) {
259 cloneAll(decl->parameters, func->forall);
260 for ( TypeDecl * td : func->forall ) {
261 strict_dynamic_cast<StructInstType*>(
262 func->parameters.front()->get_type()->stripReferences()
263 )->parameters.push_back(
264 new TypeExpr( new TypeInstType( noQualifiers, td->name, td ) )
265 );
266 }
267 }
268
269 void ConcurrentSueKeyword::postvisit(StructDecl * decl) {
270 if( decl->name == type_name && decl->body ) {
271 assert( !type_decl );
272 type_decl = decl;
273 }
274 else if ( is_target(decl) ) {
275 handle( decl );
276 }
277 }
278
279 void ConcurrentSueKeyword::handle( StructDecl * decl ) {
280 if( ! decl->body ) return;
281
282 if( !type_decl ) SemanticError( decl, context_error );
283
284 FunctionDecl * func = forwardDeclare( decl );
285 ObjectDecl * field = addField( decl );
286 addRoutines( field, func );
287 }
288
289 FunctionDecl * ConcurrentSueKeyword::forwardDeclare( StructDecl * decl ) {
290
291 StructDecl * forward = decl->clone();
292 forward->set_body( false );
293 deleteAll( forward->get_members() );
294 forward->get_members().clear();
295
296 FunctionType * get_type = new FunctionType( noQualifiers, false );
297 ObjectDecl * this_decl = new ObjectDecl(
298 "this",
299 noStorageClasses,
300 LinkageSpec::Cforall,
301 nullptr,
302 new ReferenceType(
303 noQualifiers,
304 new StructInstType(
305 noQualifiers,
306 decl
307 )
308 ),
309 nullptr
310 );
311
312 get_type->get_parameters().push_back( this_decl->clone() );
313 get_type->get_returnVals().push_back(
314 new ObjectDecl(
315 "ret",
316 noStorageClasses,
317 LinkageSpec::Cforall,
318 nullptr,
319 new PointerType(
320 noQualifiers,
321 new StructInstType(
322 noQualifiers,
323 type_decl
324 )
325 ),
326 nullptr
327 )
328 );
329 fixupGenerics(get_type, decl);
330
331 FunctionDecl * get_decl = new FunctionDecl(
332 getter_name,
333 Type::Static,
334 LinkageSpec::Cforall,
335 get_type,
336 nullptr,
337 noAttributes,
338 Type::Inline
339 );
340
341 FunctionDecl * main_decl = nullptr;
342
343 if( needs_main ) {
344 FunctionType * main_type = new FunctionType( noQualifiers, false );
345
346 main_type->get_parameters().push_back( this_decl->clone() );
347
348 main_decl = new FunctionDecl(
349 "main",
350 noStorageClasses,
351 LinkageSpec::Cforall,
352 main_type,
353 nullptr
354 );
355 fixupGenerics(main_type, decl);
356 }
357
358 delete this_decl;
359
360 declsToAddBefore.push_back( forward );
361 if( needs_main ) declsToAddBefore.push_back( main_decl );
362 declsToAddBefore.push_back( get_decl );
363
364 return get_decl;
365 }
366
367 ObjectDecl * ConcurrentSueKeyword::addField( StructDecl * decl ) {
368 ObjectDecl * field = new ObjectDecl(
369 field_name,
370 noStorageClasses,
371 LinkageSpec::Cforall,
372 nullptr,
373 new StructInstType(
374 noQualifiers,
375 type_decl
376 ),
377 nullptr
378 );
379
380 decl->get_members().push_back( field );
381
382 return field;
383 }
384
385 void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
386 CompoundStmt * statement = new CompoundStmt();
387 statement->push_back(
388 new ReturnStmt(
389 new AddressExpr(
390 new MemberExpr(
391 field,
392 new CastExpr(
393 new VariableExpr( func->get_functionType()->get_parameters().front() ),
394 func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone()
395 )
396 )
397 )
398 )
399 );
400
401 FunctionDecl * get_decl = func->clone();
402
403 get_decl->set_statements( statement );
404
405 declsToAddAfter.push_back( get_decl );
406
407 // get_decl->fixUniqueId();
408 }
409
410 //=============================================================================================
411 // Mutex keyword implementation
412 //=============================================================================================
413
414 void MutexKeyword::postvisit(FunctionDecl* decl) {
415
416 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
417 if( mutexArgs.empty() ) return;
418
419 if( CodeGen::isConstructor(decl->name) ) SemanticError( decl, "constructors cannot have mutex parameters" );
420
421 bool isDtor = CodeGen::isDestructor( decl->name );
422
423 if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
424
425 for(auto arg : mutexArgs) {
426 validate( arg );
427 }
428
429 CompoundStmt* body = decl->get_statements();
430 if( ! body ) return;
431
432 if( !monitor_decl || !guard_decl || !dtor_guard_decl )
433 SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
434
435 if( isDtor ) {
436 addDtorStatments( decl, body, mutexArgs );
437 }
438 else {
439 addStatments( decl, body, mutexArgs );
440 }
441 }
442
443 void MutexKeyword::postvisit(StructDecl* decl) {
444
445 if( decl->name == "monitor_desc" ) {
446 assert( !monitor_decl );
447 monitor_decl = decl;
448 }
449 else if( decl->name == "monitor_guard_t" ) {
450 assert( !guard_decl );
451 guard_decl = decl;
452 }
453 else if( decl->name == "monitor_dtor_guard_t" ) {
454 assert( !dtor_guard_decl );
455 dtor_guard_decl = decl;
456 }
457 }
458
459 std::list<DeclarationWithType*> MutexKeyword::findMutexArgs( FunctionDecl* decl ) {
460 std::list<DeclarationWithType*> mutexArgs;
461
462 for( auto arg : decl->get_functionType()->get_parameters()) {
463 //Find mutex arguments
464 Type* ty = arg->get_type();
465 if( ! ty->get_mutex() ) continue;
466
467 //Append it to the list
468 mutexArgs.push_back( arg );
469 }
470
471 return mutexArgs;
472 }
473
474 void MutexKeyword::validate( DeclarationWithType * arg ) {
475 Type* ty = arg->get_type();
476
477 //Makes sure it's not a copy
478 ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
479 if( ! rty ) SemanticError( arg, "Mutex argument must be of reference type " );
480
481 //Make sure the we are pointing directly to a type
482 Type* base = rty->get_base();
483 if( dynamic_cast< ReferenceType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
484 if( dynamic_cast< PointerType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
485
486 //Make sure that typed isn't mutex
487 if( base->get_mutex() ) SemanticError( arg, "mutex keyword may only appear once per argument " );
488 }
489
490 void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
491 Type * arg_type = args.front()->get_type()->clone();
492 arg_type->set_mutex( false );
493
494 ObjectDecl * monitors = new ObjectDecl(
495 "__monitor",
496 noStorageClasses,
497 LinkageSpec::Cforall,
498 nullptr,
499 new PointerType(
500 noQualifiers,
501 new StructInstType(
502 noQualifiers,
503 monitor_decl
504 )
505 ),
506 new SingleInit( new UntypedExpr(
507 new NameExpr( "get_monitor" ),
508 { new CastExpr( new VariableExpr( args.front() ), arg_type ) }
509 ))
510 );
511
512 assert(generic_func);
513
514 //in reverse order :
515 // monitor_guard_t __guard = { __monitors, #, func };
516 body->push_front(
517 new DeclStmt( new ObjectDecl(
518 "__guard",
519 noStorageClasses,
520 LinkageSpec::Cforall,
521 nullptr,
522 new StructInstType(
523 noQualifiers,
524 dtor_guard_decl
525 ),
526 new ListInit(
527 {
528 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
529 new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
530 },
531 noDesignators,
532 true
533 )
534 ))
535 );
536
537 //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
538 body->push_front( new DeclStmt( monitors) );
539 }
540
541 void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
542 ObjectDecl * monitors = new ObjectDecl(
543 "__monitors",
544 noStorageClasses,
545 LinkageSpec::Cforall,
546 nullptr,
547 new ArrayType(
548 noQualifiers,
549 new PointerType(
550 noQualifiers,
551 new StructInstType(
552 noQualifiers,
553 monitor_decl
554 )
555 ),
556 new ConstantExpr( Constant::from_ulong( args.size() ) ),
557 false,
558 false
559 ),
560 new ListInit(
561 map_range < std::list<Initializer*> > ( args, [](DeclarationWithType * var ){
562 Type * type = var->get_type()->clone();
563 type->set_mutex( false );
564 return new SingleInit( new UntypedExpr(
565 new NameExpr( "get_monitor" ),
566 { new CastExpr( new VariableExpr( var ), type ) }
567 ) );
568 })
569 )
570 );
571
572 assert(generic_func);
573
574 //in reverse order :
575 // monitor_guard_t __guard = { __monitors, #, func };
576 body->push_front(
577 new DeclStmt( new ObjectDecl(
578 "__guard",
579 noStorageClasses,
580 LinkageSpec::Cforall,
581 nullptr,
582 new StructInstType(
583 noQualifiers,
584 guard_decl
585 ),
586 new ListInit(
587 {
588 new SingleInit( new VariableExpr( monitors ) ),
589 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
590 new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
591 },
592 noDesignators,
593 true
594 )
595 ))
596 );
597
598 //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
599 body->push_front( new DeclStmt( monitors) );
600 }
601
602 //=============================================================================================
603 // General entry routine
604 //=============================================================================================
605 void ThreadStarter::previsit( StructDecl * decl ) {
606 if( decl->name == "thread_desc" && decl->body ) {
607 assert( !thread_decl );
608 thread_decl = decl;
609 }
610 }
611
612 void ThreadStarter::postvisit(FunctionDecl * decl) {
613 if( ! CodeGen::isConstructor(decl->name) ) return;
614
615 Type * typeof_this = InitTweak::getTypeofThis(decl->type);
616 StructInstType * ctored_type = dynamic_cast< StructInstType * >( typeof_this );
617 if( ctored_type && ctored_type->baseStruct == thread_decl ) {
618 thread_ctor_seen = true;
619 }
620
621 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
622 auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
623 if( type && type->get_baseStruct()->is_thread() ) {
624 if( !thread_decl || !thread_ctor_seen ) {
625 SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
626 }
627
628 addStartStatement( decl, param );
629 }
630 }
631
632 void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
633 CompoundStmt * stmt = decl->get_statements();
634
635 if( ! stmt ) return;
636
637 stmt->push_back(
638 new ExprStmt(
639 new UntypedExpr(
640 new NameExpr( "__thrd_start" ),
641 { new VariableExpr( param ) }
642 )
643 )
644 );
645 }
646};
647
648// Local Variables: //
649// mode: c //
650// tab-width: 4 //
651// End: //
Note: See TracBrowser for help on using the repository browser.