Context Navigation

source: src/Concurrency/Keywords.cc @ 9f2012f

new-envwith_gc

Last change on this file since 9f2012f was bd06384, checked in by Aaron Moss <a3moss@…>, 6 years ago
Add static roots to GC; fix some static GC_Objects
Property mode set to `100644`
File size: 19.8 KB

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

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

Download in other formats: