Context Navigation

source: src/Concurrency/Keywords.cc @ 777ed2b

ADTaaron-thesisarm-ehast-experimentalcleanup-dtorsdeferred_resndemanglerenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprno_listpersistent-indexerpthread-emulationqualifiedEnum

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: