Context Navigation

source: src/Concurrency/Keywords.cc @ 0b18db7

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 0b18db7 was 69c5c00, checked in by Andrew Beach <ajbeach@…>, 4 years ago
Rework exceptions mark_exception -> get_exception_vtable and the needed follow up.
Property mode set to `100644`
File size: 33.2 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 : 10
14	//
15
16	#include "Concurrency/Keywords.h"
17
18	#include <cassert> // for assert
19	#include <string> // for string, operator==
20
21	#include <iostream>
22
23	#include "Common/Examine.h" // for isMainFor
24	#include "Common/PassVisitor.h" // for PassVisitor
25	#include "Common/SemanticError.h" // for SemanticError
26	#include "Common/utility.h" // for deleteAll, map_range
27	#include "CodeGen/OperatorTable.h" // for isConstructor
28	#include "ControlStruct/LabelGenerator.h" // for LebelGenerator
29	#include "InitTweak/InitTweak.h" // for getPointerBase
30	#include "SynTree/LinkageSpec.h" // for Cforall
31	#include "SynTree/Constant.h" // for Constant
32	#include "SynTree/Declaration.h" // for StructDecl, FunctionDecl, ObjectDecl
33	#include "SynTree/Expression.h" // for VariableExpr, ConstantExpr, Untype...
34	#include "SynTree/Initializer.h" // for SingleInit, ListInit, Initializer ...
35	#include "SynTree/Label.h" // for Label
36	#include "SynTree/Statement.h" // for CompoundStmt, DeclStmt, ExprStmt
37	#include "SynTree/Type.h" // for StructInstType, Type, PointerType
38	#include "SynTree/Visitor.h" // for Visitor, acceptAll
39	#include "Virtual/Tables.h"
40
41	class Attribute;
42
43	namespace Concurrency {
44	inline static std::string getVTableName( std::string const & exception_name ) {
45	return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
46	}
47
48	//=============================================================================================
49	// Pass declarations
50	//=============================================================================================
51
52	//-----------------------------------------------------------------------------
53	//Handles sue type declarations :
54	// sue MyType { struct MyType {
55	// int data; int data;
56	// a_struct_t more_data; a_struct_t more_data;
57	// => NewField_t newField;
58	// }; };
59	// static inline NewField_t * getter_name( MyType * this ) { return &this->newField; }
60	//
61	class ConcurrentSueKeyword : public WithDeclsToAdd {
62	public:
63
64	ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
65	std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
66	bool needs_main, AggregateDecl::Aggregate cast_target ) :
67	type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
68	context_error( context_error ), exception_name( exception_name ),
69	vtable_name( getVTableName( exception_name ) ),
70	needs_main( needs_main ), cast_target( cast_target ) {}
71
72	virtual ~ConcurrentSueKeyword() {}
73
74	Declaration * postmutate( StructDecl * decl );
75	DeclarationWithType * postmutate( FunctionDecl * decl );
76
77	void handle( StructDecl * );
78	void addVtableForward( StructDecl * );
79	FunctionDecl * forwardDeclare( StructDecl * );
80	ObjectDecl * addField( StructDecl * );
81	void addRoutines( ObjectDecl , FunctionDecl );
82
83	virtual bool is_target( StructDecl * decl ) = 0;
84
85	Expression * postmutate( KeywordCastExpr * cast );
86
87	private:
88	const std::string type_name;
89	const std::string field_name;
90	const std::string getter_name;
91	const std::string context_error;
92	const std::string exception_name;
93	const std::string vtable_name;
94	bool needs_main;
95	AggregateDecl::Aggregate cast_target;
96
97	StructDecl * type_decl = nullptr;
98	FunctionDecl * dtor_decl = nullptr;
99	StructDecl * except_decl = nullptr;
100	StructDecl * vtable_decl = nullptr;
101	};
102
103
104	//-----------------------------------------------------------------------------
105	//Handles thread type declarations :
106	// thread Mythread { struct MyThread {
107	// int data; int data;
108	// a_struct_t more_data; a_struct_t more_data;
109	// => $thread __thrd_d;
110	// }; };
111	// static inline $thread * get_thread( MyThread * this ) { return &this->__thrd_d; }
112	//
113	class ThreadKeyword final : public ConcurrentSueKeyword {
114	public:
115
116	ThreadKeyword() : ConcurrentSueKeyword(
117	"$thread",
118	"__thrd",
119	"get_thread",
120	"thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
121	"",
122	true,
123	AggregateDecl::Thread
124	)
125	{}
126
127	virtual ~ThreadKeyword() {}
128
129	virtual bool is_target( StructDecl * decl ) override final { return decl->is_thread(); }
130
131	static void implement( std::list< Declaration * > & translationUnit ) {
132	PassVisitor< ThreadKeyword > impl;
133	mutateAll( translationUnit, impl );
134	}
135	};
136
137	//-----------------------------------------------------------------------------
138	//Handles coroutine type declarations :
139	// coroutine MyCoroutine { struct MyCoroutine {
140	// int data; int data;
141	// a_struct_t more_data; a_struct_t more_data;
142	// => $coroutine __cor_d;
143	// }; };
144	// static inline $coroutine * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
145	//
146	class CoroutineKeyword final : public ConcurrentSueKeyword {
147	public:
148
149	CoroutineKeyword() : ConcurrentSueKeyword(
150	"$coroutine",
151	"__cor",
152	"get_coroutine",
153	"coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
154	"CoroutineCancelled",
155	true,
156	AggregateDecl::Coroutine
157	)
158	{}
159
160	virtual ~CoroutineKeyword() {}
161
162	virtual bool is_target( StructDecl * decl ) override final { return decl->is_coroutine(); }
163
164	static void implement( std::list< Declaration * > & translationUnit ) {
165	PassVisitor< CoroutineKeyword > impl;
166	mutateAll( translationUnit, impl );
167	}
168	};
169
170
171
172	//-----------------------------------------------------------------------------
173	//Handles monitor type declarations :
174	// monitor MyMonitor { struct MyMonitor {
175	// int data; int data;
176	// a_struct_t more_data; a_struct_t more_data;
177	// => $monitor __mon_d;
178	// }; };
179	// static inline $monitor * get_coroutine( MyMonitor * this ) { return &this->__cor_d; }
180	//
181	class MonitorKeyword final : public ConcurrentSueKeyword {
182	public:
183
184	MonitorKeyword() : ConcurrentSueKeyword(
185	"$monitor",
186	"__mon",
187	"get_monitor",
188	"monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
189	"",
190	false,
191	AggregateDecl::Monitor
192	)
193	{}
194
195	virtual ~MonitorKeyword() {}
196
197	virtual bool is_target( StructDecl * decl ) override final { return decl->is_monitor(); }
198
199	static void implement( std::list< Declaration * > & translationUnit ) {
200	PassVisitor< MonitorKeyword > impl;
201	mutateAll( translationUnit, impl );
202	}
203	};
204
205	//-----------------------------------------------------------------------------
206	//Handles generator type declarations :
207	// generator MyGenerator { struct MyGenerator {
208	// int data; int data;
209	// a_struct_t more_data; a_struct_t more_data;
210	// => int __gen_next;
211	// }; };
212	//
213	class GeneratorKeyword final : public ConcurrentSueKeyword {
214	public:
215
216	GeneratorKeyword() : ConcurrentSueKeyword(
217	"$generator",
218	"__generator_state",
219	"get_generator",
220	"Unable to find builtin type $generator\n",
221	"",
222	true,
223	AggregateDecl::Generator
224	)
225	{}
226
227	virtual ~GeneratorKeyword() {}
228
229	virtual bool is_target( StructDecl * decl ) override final { return decl->is_generator(); }
230
231	static void implement( std::list< Declaration * > & translationUnit ) {
232	PassVisitor< GeneratorKeyword > impl;
233	mutateAll( translationUnit, impl );
234	}
235	};
236
237
238	//-----------------------------------------------------------------------------
239	class SuspendKeyword final : public WithStmtsToAdd, public WithGuards {
240	public:
241	SuspendKeyword() = default;
242	virtual ~SuspendKeyword() = default;
243
244	void premutate( FunctionDecl * );
245	DeclarationWithType * postmutate( FunctionDecl * );
246
247	Statement * postmutate( SuspendStmt * );
248
249	static void implement( std::list< Declaration * > & translationUnit ) {
250	PassVisitor< SuspendKeyword > impl;
251	mutateAll( translationUnit, impl );
252	}
253
254	private:
255	bool is_real_suspend( FunctionDecl * );
256
257	Statement * make_generator_suspend( SuspendStmt * );
258	Statement * make_coroutine_suspend( SuspendStmt * );
259
260	struct LabelPair {
261	Label obj;
262	int idx;
263	};
264
265	LabelPair make_label() {
266	labels.push_back( gen.newLabel("generator") );
267	return { labels.back(), int(labels.size()) };
268	}
269
270	DeclarationWithType * in_generator = nullptr;
271	FunctionDecl * decl_suspend = nullptr;
272	std::vector<Label> labels;
273	ControlStruct::LabelGenerator & gen = *ControlStruct::LabelGenerator::getGenerator();
274	};
275
276	//-----------------------------------------------------------------------------
277	//Handles mutex routines definitions :
278	// void foo( A * mutex a, B * mutex b, int i ) { void foo( A * a, B * b, int i ) {
279	// $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
280	// monitor_guard_t __guard = { __monitors, 2 };
281	// /Some code/ => /Some code/
282	// } }
283	//
284	class MutexKeyword final {
285	public:
286
287	void postvisit( FunctionDecl * decl );
288	void postvisit( StructDecl * decl );
289
290	std::list<DeclarationWithType> findMutexArgs( FunctionDecl, bool & first );
291	void validate( DeclarationWithType * );
292	void addDtorStatments( FunctionDecl* func, CompoundStmt , const std::list<DeclarationWithType > &);
293	void addStatments( FunctionDecl* func, CompoundStmt , const std::list<DeclarationWithType > &);
294
295	static void implement( std::list< Declaration * > & translationUnit ) {
296	PassVisitor< MutexKeyword > impl;
297	acceptAll( translationUnit, impl );
298	}
299
300	private:
301	StructDecl* monitor_decl = nullptr;
302	StructDecl* guard_decl = nullptr;
303	StructDecl* dtor_guard_decl = nullptr;
304
305	static std::unique_ptr< Type > generic_func;
306	};
307
308	std::unique_ptr< Type > MutexKeyword::generic_func = std::unique_ptr< Type >(
309	new FunctionType(
310	noQualifiers,
311	true
312	)
313	);
314
315	//-----------------------------------------------------------------------------
316	//Handles mutex routines definitions :
317	// void foo( A * mutex a, B * mutex b, int i ) { void foo( A * a, B * b, int i ) {
318	// $monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
319	// monitor_guard_t __guard = { __monitors, 2 };
320	// /Some code/ => /Some code/
321	// } }
322	//
323	class ThreadStarter final {
324	public:
325
326	void postvisit( FunctionDecl * decl );
327	void previsit ( StructDecl * decl );
328
329	void addStartStatement( FunctionDecl * decl, DeclarationWithType * param );
330
331	static void implement( std::list< Declaration * > & translationUnit ) {
332	PassVisitor< ThreadStarter > impl;
333	acceptAll( translationUnit, impl );
334	}
335
336	private :
337	bool thread_ctor_seen = false;
338	StructDecl * thread_decl = nullptr;
339	};
340
341	//=============================================================================================
342	// General entry routine
343	//=============================================================================================
344	void applyKeywords( std::list< Declaration * > & translationUnit ) {
345	ThreadKeyword ::implement( translationUnit );
346	CoroutineKeyword ::implement( translationUnit );
347	MonitorKeyword ::implement( translationUnit );
348	GeneratorKeyword ::implement( translationUnit );
349	SuspendKeyword ::implement( translationUnit );
350	}
351
352	void implementMutexFuncs( std::list< Declaration * > & translationUnit ) {
353	MutexKeyword ::implement( translationUnit );
354	}
355
356	void implementThreadStarter( std::list< Declaration * > & translationUnit ) {
357	ThreadStarter ::implement( translationUnit );
358	}
359
360	//=============================================================================================
361	// Generic keyword implementation
362	//=============================================================================================
363	void fixupGenerics(FunctionType * func, StructDecl * decl) {
364	cloneAll(decl->parameters, func->forall);
365	for ( TypeDecl * td : func->forall ) {
366	strict_dynamic_cast<StructInstType*>(
367	func->parameters.front()->get_type()->stripReferences()
368	)->parameters.push_back(
369	new TypeExpr( new TypeInstType( noQualifiers, td->name, td ) )
370	);
371	}
372	}
373
374	Declaration * ConcurrentSueKeyword::postmutate(StructDecl * decl) {
375	if( decl->name == type_name && decl->body ) {
376	assert( !type_decl );
377	type_decl = decl;
378	}
379	else if ( is_target(decl) ) {
380	handle( decl );
381	}
382	else if ( !except_decl && exception_name == decl->name && decl->body ) {
383	except_decl = decl;
384	}
385	else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
386	vtable_decl = decl;
387	}
388	// Might be able to get ride of is target.
389	assert( is_target(decl) == (cast_target == decl->kind) );
390	return decl;
391	}
392
393	DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
394	if ( type_decl && isDestructorFor( decl, type_decl ) )
395	dtor_decl = decl;
396	else if ( vtable_name.empty() )
397	;
398	else if ( auto param = isMainFor( decl, cast_target ) ) {
399	// This should never trigger.
400	assert( vtable_decl );
401	// Should be safe because of isMainFor.
402	StructInstType * struct_type = static_cast<StructInstType *>(
403	static_cast<ReferenceType *>( param->get_type() )->base );
404	assert( struct_type );
405
406	std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
407	ObjectDecl * vtable_object = Virtual::makeVtableInstance(
408	vtable_decl->makeInst( poly_args ), struct_type, nullptr );
409	declsToAddAfter.push_back( vtable_object );
410	declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
411	vtable_object, except_decl->makeInst( std::move( poly_args ) )
412	) );
413	}
414
415	return decl;
416	}
417
418	Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) {
419	if ( cast_target == cast->target ) {
420	// convert (thread &)t to ($thread &)*get_thread(t), etc.
421	if( !type_decl ) SemanticError( cast, context_error );
422	if( !dtor_decl ) SemanticError( cast, context_error );
423	assert( cast->result == nullptr );
424	cast->set_result( new ReferenceType( noQualifiers, new StructInstType( noQualifiers, type_decl ) ) );
425	cast->concrete_target.field = field_name;
426	cast->concrete_target.getter = getter_name;
427	}
428	return cast;
429	}
430
431
432	void ConcurrentSueKeyword::handle( StructDecl * decl ) {
433	if( ! decl->body ) return;
434
435	if( !type_decl ) SemanticError( decl, context_error );
436	if( !dtor_decl ) SemanticError( decl, context_error );
437
438	addVtableForward( decl );
439	FunctionDecl * func = forwardDeclare( decl );
440	ObjectDecl * field = addField( decl );
441	addRoutines( field, func );
442	}
443
444	void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
445	if ( vtable_decl ) {
446	std::list< Expression * > poly_args = {
447	new TypeExpr( new StructInstType( noQualifiers, decl ) ),
448	};
449	declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
450	vtable_decl->makeInst( poly_args ),
451	except_decl->makeInst( poly_args )
452	) );
453	declsToAddBefore.push_back( Virtual::makeVtableForward(
454	vtable_decl->makeInst( move( poly_args ) ) ) );
455	// Its only an error if we want a vtable and don't have one.
456	} else if ( ! vtable_name.empty() ) {
457	SemanticError( decl, context_error );
458	}
459	}
460
461	FunctionDecl * ConcurrentSueKeyword::forwardDeclare( StructDecl * decl ) {
462
463	StructDecl * forward = decl->clone();
464	forward->set_body( false );
465	deleteAll( forward->get_members() );
466	forward->get_members().clear();
467
468	FunctionType * get_type = new FunctionType( noQualifiers, false );
469	ObjectDecl * this_decl = new ObjectDecl(
470	"this",
471	noStorageClasses,
472	LinkageSpec::Cforall,
473	nullptr,
474	new ReferenceType(
475	noQualifiers,
476	new StructInstType(
477	noQualifiers,
478	decl
479	)
480	),
481	nullptr
482	);
483
484	get_type->get_parameters().push_back( this_decl->clone() );
485	get_type->get_returnVals().push_back(
486	new ObjectDecl(
487	"ret",
488	noStorageClasses,
489	LinkageSpec::Cforall,
490	nullptr,
491	new PointerType(
492	noQualifiers,
493	new StructInstType(
494	noQualifiers,
495	type_decl
496	)
497	),
498	nullptr
499	)
500	);
501	fixupGenerics(get_type, decl);
502
503	FunctionDecl * get_decl = new FunctionDecl(
504	getter_name,
505	Type::Static,
506	LinkageSpec::Cforall,
507	get_type,
508	nullptr,
509	{ new Attribute("const") },
510	Type::Inline
511	);
512
513	FunctionDecl * main_decl = nullptr;
514
515	if( needs_main ) {
516	FunctionType * main_type = new FunctionType( noQualifiers, false );
517
518	main_type->get_parameters().push_back( this_decl->clone() );
519
520	main_decl = new FunctionDecl(
521	"main",
522	noStorageClasses,
523	LinkageSpec::Cforall,
524	main_type,
525	nullptr
526	);
527	fixupGenerics(main_type, decl);
528	}
529
530	delete this_decl;
531
532	declsToAddBefore.push_back( forward );
533	if( needs_main ) declsToAddBefore.push_back( main_decl );
534	declsToAddBefore.push_back( get_decl );
535
536	return get_decl;
537	}
538
539	ObjectDecl * ConcurrentSueKeyword::addField( StructDecl * decl ) {
540	ObjectDecl * field = new ObjectDecl(
541	field_name,
542	noStorageClasses,
543	LinkageSpec::Cforall,
544	nullptr,
545	new StructInstType(
546	noQualifiers,
547	type_decl
548	),
549	nullptr
550	);
551
552	decl->get_members().push_back( field );
553
554	return field;
555	}
556
557	void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
558	CompoundStmt * statement = new CompoundStmt();
559	statement->push_back(
560	new ReturnStmt(
561	new AddressExpr(
562	new MemberExpr(
563	field,
564	new CastExpr(
565	new VariableExpr( func->get_functionType()->get_parameters().front() ),
566	func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone(),
567	false
568	)
569	)
570	)
571	)
572	);
573
574	FunctionDecl * get_decl = func->clone();
575
576	get_decl->set_statements( statement );
577
578	declsToAddAfter.push_back( get_decl );
579	}
580
581	//=============================================================================================
582	// Suspend keyword implementation
583	//=============================================================================================
584	bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
585	if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
586	if(func->name != "__cfactx_suspend") return false; // the real suspend has a specific name
587	if(func->type->parameters.size() != 0) return false; // Too many parameters
588	if(func->type->returnVals.size() != 0) return false; // Too many return values
589
590	return true;
591	}
592
593	void SuspendKeyword::premutate( FunctionDecl * func ) {
594	GuardValue(in_generator);
595	in_generator = nullptr;
596
597	// Is this the real suspend?
598	if(is_real_suspend(func)) {
599	decl_suspend = decl_suspend ? decl_suspend : func;
600	return;
601	}
602
603	// Is this the main of a generator?
604	auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
605	if(!param) return;
606
607	if(func->type->returnVals.size() != 0) SemanticError(func->location, "Generator main must return void");
608
609	in_generator = param;
610	GuardValue(labels);
611	labels.clear();
612	}
613
614	DeclarationWithType * SuspendKeyword::postmutate( FunctionDecl * func ) {
615	if( !func->statements ) return func; // Not the actual definition, don't do anything
616	if( !in_generator ) return func; // Not in a generator, don't do anything
617	if( labels.empty() ) return func; // Generator has no states, nothing to do, could throw a warning
618
619	// This is a generator main, we need to add the following code to the top
620	// static void * __generator_labels[] = {&&s0, &&s1, ...};
621	// goto * __generator_labels[gen.__generator_state];
622	const auto & loc = func->location;
623
624	const auto first_label = gen.newLabel("generator");
625
626	// for each label add to declaration
627	std::list<Initializer*> inits = { new SingleInit( new LabelAddressExpr( first_label ) ) };
628	for(const auto & label : labels) {
629	inits.push_back(
630	new SingleInit(
631	new LabelAddressExpr( label )
632	)
633	);
634	}
635	auto init = new ListInit(std::move(inits), noDesignators, true);
636	labels.clear();
637
638	// create decl
639	auto decl = new ObjectDecl(
640	"__generator_labels",
641	Type::StorageClasses( Type::Static ),
642	LinkageSpec::AutoGen,
643	nullptr,
644	new ArrayType(
645	Type::Qualifiers(),
646	new PointerType(
647	Type::Qualifiers(),
648	new VoidType( Type::Qualifiers() )
649	),
650	nullptr,
651	false, false
652	),
653	init
654	);
655
656	// create the goto
657	assert(in_generator);
658
659	auto go_decl = new ObjectDecl(
660	"__generator_label",
661	noStorageClasses,
662	LinkageSpec::AutoGen,
663	nullptr,
664	new PointerType(
665	Type::Qualifiers(),
666	new VoidType( Type::Qualifiers() )
667	),
668	new SingleInit(
669	new UntypedExpr(
670	new NameExpr("?[?]"),
671	{
672	new NameExpr("__generator_labels"),
673	new UntypedMemberExpr(
674	new NameExpr("__generator_state"),
675	new VariableExpr( in_generator )
676	)
677	}
678	)
679	)
680	);
681	go_decl->location = loc;
682
683	auto go = new BranchStmt(
684	new VariableExpr( go_decl ),
685	BranchStmt::Goto
686	);
687	go->location = loc;
688	go->computedTarget->location = loc;
689
690	auto noop = new NullStmt({ first_label });
691	noop->location = loc;
692
693	// wrap everything in a nice compound
694	auto body = new CompoundStmt({
695	new DeclStmt( decl ),
696	new DeclStmt( go_decl ),
697	go,
698	noop,
699	func->statements
700	});
701	body->location = loc;
702	func->statements = body;
703
704	return func;
705	}
706
707	Statement * SuspendKeyword::postmutate( SuspendStmt * stmt ) {
708	SuspendStmt::Type type = stmt->type;
709	if(type == SuspendStmt::None) {
710	// This suspend has a implicit target, find it
711	type = in_generator ? SuspendStmt::Generator : SuspendStmt::Coroutine;
712	}
713
714	// Check that the target makes sense
715	if(!in_generator && type == SuspendStmt::Generator) SemanticError( stmt->location, "'suspend generator' must be used inside main of generator type.");
716
717	// Act appropriately
718	switch(type) {
719	case SuspendStmt::Generator: return make_generator_suspend(stmt);
720	case SuspendStmt::Coroutine: return make_coroutine_suspend(stmt);
721	default: abort();
722	}
723	}
724
725	Statement * SuspendKeyword::make_generator_suspend( SuspendStmt * stmt ) {
726	assert(in_generator);
727	// Target code is :
728	// gen.__generator_state = X;
729	// { THEN }
730	// return;
731	// __gen_X:;
732
733	// Save the location and delete the old statement, we only need the location from this point on
734	auto loc = stmt->location;
735
736	// Build the label and get its index
737	auto label = make_label();
738
739	// Create the context saving statement
740	auto save = new ExprStmt( new UntypedExpr(
741	new NameExpr( "?=?" ),
742	{
743	new UntypedMemberExpr(
744	new NameExpr("__generator_state"),
745	new VariableExpr( in_generator )
746	),
747	new ConstantExpr(
748	Constant::from_int( label.idx )
749	)
750	}
751	));
752	assert(save->expr);
753	save->location = loc;
754	stmtsToAddBefore.push_back( save );
755
756	// if we have a then add it here
757	auto then = stmt->then;
758	stmt->then = nullptr;
759	delete stmt;
760	if(then) stmtsToAddBefore.push_back( then );
761
762	// Create the return statement
763	auto ret = new ReturnStmt( nullptr );
764	ret->location = loc;
765	stmtsToAddBefore.push_back( ret );
766
767	// Create the null statement with the created label
768	auto noop = new NullStmt({ label.obj });
769	noop->location = loc;
770
771	// Return the null statement to take the place of the previous statement
772	return noop;
773	}
774
775	Statement * SuspendKeyword::make_coroutine_suspend( SuspendStmt * stmt ) {
776	if(stmt->then) SemanticError( stmt->location, "Compound statement following coroutines is not implemented.");
777
778	// Save the location and delete the old statement, we only need the location from this point on
779	auto loc = stmt->location;
780	delete stmt;
781
782	// Create the call expression
783	if(!decl_suspend) SemanticError( loc, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>\n");
784	auto expr = new UntypedExpr( VariableExpr::functionPointer( decl_suspend ) );
785	expr->location = loc;
786
787	// Change this statement into a regular expr
788	assert(expr);
789	auto nstmt = new ExprStmt( expr );
790	nstmt->location = loc;
791	return nstmt;
792	}
793
794
795	//=============================================================================================
796	// Mutex keyword implementation
797	//=============================================================================================
798
799	void MutexKeyword::postvisit(FunctionDecl* decl) {
800
801	bool first = false;
802	std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
803	bool isDtor = CodeGen::isDestructor( decl->name );
804
805	// Is this function relevant to monitors
806	if( mutexArgs.empty() ) {
807	// If this is the destructor for a monitor it must be mutex
808	if(isDtor) {
809	Type* ty = decl->get_functionType()->get_parameters().front()->get_type();
810
811	// If it's a copy, it's not a mutex
812	ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
813	if( ! rty ) return;
814
815	// If we are not pointing directly to a type, it's not a mutex
816	Type* base = rty->get_base();
817	if( dynamic_cast< ReferenceType * >( base ) ) return;
818	if( dynamic_cast< PointerType * >( base ) ) return;
819
820	// Check if its a struct
821	StructInstType * baseStruct = dynamic_cast< StructInstType * >( base );
822	if( !baseStruct ) return;
823
824	// Check if its a monitor
825	if(baseStruct->baseStruct->is_monitor() \|\| baseStruct->baseStruct->is_thread())
826	SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters\n" );
827	}
828	return;
829	}
830
831	// Monitors can't be constructed with mutual exclusion
832	if( CodeGen::isConstructor(decl->name) && !first ) SemanticError( decl, "constructors cannot have mutex parameters" );
833
834	// It makes no sense to have multiple mutex parameters for the destructor
835	if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
836
837	// Make sure all the mutex arguments are monitors
838	for(auto arg : mutexArgs) {
839	validate( arg );
840	}
841
842	// Check if we need to instrument the body
843	CompoundStmt* body = decl->get_statements();
844	if( ! body ) return;
845
846	// Do we have the required headers
847	if( !monitor_decl \|\| !guard_decl \|\| !dtor_guard_decl )
848	SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor.hfa>\n" );
849
850	// Instrument the body
851	if( isDtor ) {
852	addDtorStatments( decl, body, mutexArgs );
853	}
854	else {
855	addStatments( decl, body, mutexArgs );
856	}
857	}
858
859	void MutexKeyword::postvisit(StructDecl* decl) {
860
861	if( decl->name == "$monitor" && decl->body ) {
862	assert( !monitor_decl );
863	monitor_decl = decl;
864	}
865	else if( decl->name == "monitor_guard_t" && decl->body ) {
866	assert( !guard_decl );
867	guard_decl = decl;
868	}
869	else if( decl->name == "monitor_dtor_guard_t" && decl->body ) {
870	assert( !dtor_guard_decl );
871	dtor_guard_decl = decl;
872	}
873	}
874
875	std::list<DeclarationWithType> MutexKeyword::findMutexArgs( FunctionDecl decl, bool & first ) {
876	std::list<DeclarationWithType*> mutexArgs;
877
878	bool once = true;
879	for( auto arg : decl->get_functionType()->get_parameters()) {
880	//Find mutex arguments
881	Type* ty = arg->get_type();
882	if( ! ty->get_mutex() ) continue;
883
884	if(once) {first = true;}
885	once = false;
886
887	//Append it to the list
888	mutexArgs.push_back( arg );
889	}
890
891	return mutexArgs;
892	}
893
894	void MutexKeyword::validate( DeclarationWithType * arg ) {
895	Type* ty = arg->get_type();
896
897	//Makes sure it's not a copy
898	ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
899	if( ! rty ) SemanticError( arg, "Mutex argument must be of reference type " );
900
901	//Make sure the we are pointing directly to a type
902	Type* base = rty->get_base();
903	if( dynamic_cast< ReferenceType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
904	if( dynamic_cast< PointerType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
905
906	//Make sure that typed isn't mutex
907	if( base->get_mutex() ) SemanticError( arg, "mutex keyword may only appear once per argument " );
908	}
909
910	void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
911	Type * arg_type = args.front()->get_type()->clone();
912	arg_type->set_mutex( false );
913
914	ObjectDecl * monitors = new ObjectDecl(
915	"__monitor",
916	noStorageClasses,
917	LinkageSpec::Cforall,
918	nullptr,
919	new PointerType(
920	noQualifiers,
921	new StructInstType(
922	noQualifiers,
923	monitor_decl
924	)
925	),
926	new SingleInit( new UntypedExpr(
927	new NameExpr( "get_monitor" ),
928	{ new CastExpr( new VariableExpr( args.front() ), arg_type, false ) }
929	))
930	);
931
932	assert(generic_func);
933
934	//in reverse order :
935	// monitor_dtor_guard_t __guard = { __monitors, func };
936	body->push_front(
937	new DeclStmt( new ObjectDecl(
938	"__guard",
939	noStorageClasses,
940	LinkageSpec::Cforall,
941	nullptr,
942	new StructInstType(
943	noQualifiers,
944	dtor_guard_decl
945	),
946	new ListInit(
947	{
948	new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
949	new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
950	new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
951	},
952	noDesignators,
953	true
954	)
955	))
956	);
957
958	//$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
959	body->push_front( new DeclStmt( monitors) );
960	}
961
962	void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
963	ObjectDecl * monitors = new ObjectDecl(
964	"__monitors",
965	noStorageClasses,
966	LinkageSpec::Cforall,
967	nullptr,
968	new ArrayType(
969	noQualifiers,
970	new PointerType(
971	noQualifiers,
972	new StructInstType(
973	noQualifiers,
974	monitor_decl
975	)
976	),
977	new ConstantExpr( Constant::from_ulong( args.size() ) ),
978	false,
979	false
980	),
981	new ListInit(
982	map_range < std::list<Initializer> > ( args, [](DeclarationWithType var ){
983	Type * type = var->get_type()->clone();
984	type->set_mutex( false );
985	return new SingleInit( new UntypedExpr(
986	new NameExpr( "get_monitor" ),
987	{ new CastExpr( new VariableExpr( var ), type, false ) }
988	) );
989	})
990	)
991	);
992
993	assert(generic_func);
994
995	// in reverse order :
996	// monitor_guard_t __guard = { __monitors, #, func };
997	body->push_front(
998	new DeclStmt( new ObjectDecl(
999	"__guard",
1000	noStorageClasses,
1001	LinkageSpec::Cforall,
1002	nullptr,
1003	new StructInstType(
1004	noQualifiers,
1005	guard_decl
1006	),
1007	new ListInit(
1008	{
1009	new SingleInit( new VariableExpr( monitors ) ),
1010	new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
1011	new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
1012	},
1013	noDesignators,
1014	true
1015	)
1016	))
1017	);
1018
1019	//$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
1020	body->push_front( new DeclStmt( monitors) );
1021	}
1022
1023	//=============================================================================================
1024	// General entry routine
1025	//=============================================================================================
1026	void ThreadStarter::previsit( StructDecl * decl ) {
1027	if( decl->name == "$thread" && decl->body ) {
1028	assert( !thread_decl );
1029	thread_decl = decl;
1030	}
1031	}
1032
1033	void ThreadStarter::postvisit(FunctionDecl * decl) {
1034	if( ! CodeGen::isConstructor(decl->name) ) return;
1035
1036	Type * typeof_this = InitTweak::getTypeofThis(decl->type);
1037	StructInstType * ctored_type = dynamic_cast< StructInstType * >( typeof_this );
1038	if( ctored_type && ctored_type->baseStruct == thread_decl ) {
1039	thread_ctor_seen = true;
1040	}
1041
1042	DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
1043	auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
1044	if( type && type->get_baseStruct()->is_thread() ) {
1045	if( !thread_decl \|\| !thread_ctor_seen ) {
1046	SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread.hfa>");
1047	}
1048
1049	addStartStatement( decl, param );
1050	}
1051	}
1052
1053	void ThreadStarter::addStartStatement( FunctionDecl * decl, DeclarationWithType * param ) {
1054	CompoundStmt * stmt = decl->get_statements();
1055
1056	if( ! stmt ) return;
1057
1058	stmt->push_back(
1059	new ExprStmt(
1060	new UntypedExpr(
1061	new NameExpr( "__thrd_start" ),
1062	{ new VariableExpr( param ), new NameExpr("main") }
1063	)
1064	)
1065	);
1066	}
1067	};
1068
1069	// Local Variables: //
1070	// mode: c //
1071	// tab-width: 4 //
1072	// End: //
1073

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

Download in other formats: