Context Navigation

source: src/Concurrency/Keywords.cpp@ 0dffe91

Visit:

Last change on this file since 0dffe91 was db19e1d, checked in by Andrew Beach <ajbeach@…>, 13 months ago
Changed the interpritation of () to be no parameters instead of any parameters. This had a lot of little changes because of this and some nearby clean-up. This includes some changes, including changing some generated functions to be fixed-args instead of variable-args, stripping out the place holder void parameter earlier, but it still shows up earlier in some cases that examine the parser directly. Also had to update the function generation tools. Have only tested with one --arch. Hopefully this all works out.
Property mode set to `100644`
File size: 48.7 KB

Rev	Line
[2cf3b87]	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	//
[83fd57d]	7	// Keywords.cpp -- Implement concurrency constructs from their keywords.
[2cf3b87]	8	//
	9	// Author : Andrew Beach
	10	// Created On : Tue Nov 16 9:53:00 2021
[ca9d65e]	11	// Last Modified By : Peter A. Buhr
	12	// Last Modified On : Thu Dec 14 18:02:25 2023
	13	// Update Count : 6
[2cf3b87]	14	//
	15
[c92bdcc]	16	#include "Concurrency/Keywords.hpp"
[2cf3b87]	17
[83fd57d]	18	#include <iostream>
	19
[2cf3b87]	20	#include "AST/Copy.hpp"
	21	#include "AST/Decl.hpp"
[4f6dda0]	22	#include "AST/Expr.hpp"
[e01eb4a]	23	#include "AST/Inspect.hpp"
[2cf3b87]	24	#include "AST/Pass.hpp"
	25	#include "AST/Stmt.hpp"
[4f6dda0]	26	#include "AST/DeclReplacer.hpp"
[2cf3b87]	27	#include "AST/TranslationUnit.hpp"
[c92bdcc]	28	#include "CodeGen/OperatorTable.hpp"
	29	#include "Common/Examine.hpp"
	30	#include "Common/Utility.hpp"
	31	#include "Common/UniqueName.hpp"
[83fd57d]	32	#include "ControlStruct/LabelGenerator.hpp"
[c92bdcc]	33	#include "InitTweak/InitTweak.hpp"
	34	#include "Virtual/Tables.hpp"
[2cf3b87]	35
	36	namespace Concurrency {
	37
	38	namespace {
	39
[4f6dda0]	40	// --------------------------------------------------------------------------
	41	// Loose Helper Functions:
	42
	43	/// Detect threads constructed with the keyword thread.
	44	bool isThread( const ast::DeclWithType * decl ) {
[2cf3b87]	45	auto baseType = decl->get_type()->stripDeclarator();
	46	auto instType = dynamic_cast<const ast::StructInstType *>( baseType );
	47	if ( nullptr == instType ) { return false; }
	48	return instType->base->is_thread();
	49	}
	50
[4f6dda0]	51	/// Get the virtual type id if given a type name.
	52	std::string typeIdType( std::string const & exception_name ) {
	53	return exception_name.empty() ? std::string()
	54	: Virtual::typeIdType( exception_name );
	55	}
	56
	57	/// Get the vtable type name if given a type name.
	58	std::string vtableTypeName( std::string const & exception_name ) {
	59	return exception_name.empty() ? std::string()
	60	: Virtual::vtableTypeName( exception_name );
	61	}
	62
	63	static ast::Type * mutate_under_references( ast::ptr<ast::Type>& type ) {
	64	ast::Type * mutType = type.get_and_mutate();
	65	for ( ast::ReferenceType * mutRef
	66	; (mutRef = dynamic_cast<ast::ReferenceType *>( mutType ))
	67	; mutType = mutRef->base.get_and_mutate() );
	68	return mutType;
	69	}
	70
	71	// Describe that it adds the generic parameters and the uses of the generic
	72	// parameters on the function and first "this" argument.
	73	ast::FunctionDecl * fixupGenerics(
	74	const ast::FunctionDecl * func, const ast::StructDecl * decl ) {
	75	const CodeLocation & location = decl->location;
	76	// We have to update both the declaration
	77	auto mutFunc = ast::mutate( func );
	78	auto mutType = mutFunc->type.get_and_mutate();
	79
	80	if ( decl->params.empty() ) {
	81	return mutFunc;
	82	}
	83
	84	assert( 0 != mutFunc->params.size() );
	85	assert( 0 != mutType->params.size() );
	86
	87	// Add the "forall" clause information.
	88	for ( const ast::ptr<ast::TypeDecl> & typeParam : decl->params ) {
	89	auto typeDecl = ast::deepCopy( typeParam );
	90	mutFunc->type_params.push_back( typeDecl );
[b230091]	91	mutType->forall.push_back( new ast::TypeInstType( typeDecl ) );
[4f6dda0]	92	for ( auto & assertion : typeDecl->assertions ) {
	93	mutFunc->assertions.push_back( assertion );
	94	mutType->assertions.emplace_back(
	95	new ast::VariableExpr( location, assertion ) );
	96	}
	97	typeDecl->assertions.clear();
	98	}
	99
	100	// Even chain_mutate is not powerful enough for this:
	101	ast::ptr<ast::Type>& paramType = strict_dynamic_cast<ast::ObjectDecl *>(
	102	mutFunc->params[0].get_and_mutate() )->type;
	103	auto paramTypeInst = strict_dynamic_cast<ast::StructInstType *>(
	104	mutate_under_references( paramType ) );
	105	auto typeParamInst = strict_dynamic_cast<ast::StructInstType *>(
	106	mutate_under_references( mutType->params[0] ) );
	107
	108	for ( const ast::ptr<ast::TypeDecl> & typeDecl : mutFunc->type_params ) {
	109	paramTypeInst->params.push_back(
[b230091]	110	new ast::TypeExpr( location, new ast::TypeInstType( typeDecl ) ) );
[4f6dda0]	111	typeParamInst->params.push_back(
[b230091]	112	new ast::TypeExpr( location, new ast::TypeInstType( typeDecl ) ) );
[4f6dda0]	113	}
	114
	115	return mutFunc;
	116	}
	117
	118	// --------------------------------------------------------------------------
	119	struct ConcurrentSueKeyword : public ast::WithDeclsToAdd<> {
	120	ConcurrentSueKeyword(
	121	std::string&& type_name, std::string&& field_name,
	122	std::string&& getter_name, std::string&& context_error,
	123	std::string&& exception_name,
	124	bool needs_main, ast::AggregateDecl::Aggregate cast_target
	125	) :
	126	type_name( type_name ), field_name( field_name ),
	127	getter_name( getter_name ), context_error( context_error ),
	128	exception_name( exception_name ),
	129	typeid_name( typeIdType( exception_name ) ),
	130	vtable_name( vtableTypeName( exception_name ) ),
	131	needs_main( needs_main ), cast_target( cast_target )
	132	{}
	133
	134	virtual ~ConcurrentSueKeyword() {}
	135
	136	const ast::Decl * postvisit( const ast::StructDecl * decl );
	137	const ast::DeclWithType * postvisit( const ast::FunctionDecl * decl );
	138	const ast::Expr * postvisit( const ast::KeywordCastExpr * expr );
	139
	140	struct StructAndField {
	141	const ast::StructDecl * decl;
	142	const ast::ObjectDecl * field;
	143	};
	144
	145	const ast::StructDecl * handleStruct( const ast::StructDecl * );
	146	void handleMain( const ast::FunctionDecl , const ast::StructInstType );
	147	void addTypeId( const ast::StructDecl * );
	148	void addVtableForward( const ast::StructDecl * );
	149	const ast::FunctionDecl * forwardDeclare( const ast::StructDecl * );
	150	StructAndField addField( const ast::StructDecl * );
	151	void addGetRoutines( const ast::ObjectDecl , const ast::FunctionDecl );
	152	void addLockUnlockRoutines( const ast::StructDecl * );
	153
	154	private:
	155	const std::string type_name;
	156	const std::string field_name;
	157	const std::string getter_name;
	158	const std::string context_error;
	159	const std::string exception_name;
	160	const std::string typeid_name;
	161	const std::string vtable_name;
	162	const bool needs_main;
	163	const ast::AggregateDecl::Aggregate cast_target;
	164
	165	const ast::StructDecl * type_decl = nullptr;
	166	const ast::FunctionDecl * dtor_decl = nullptr;
	167	const ast::StructDecl * except_decl = nullptr;
	168	const ast::StructDecl * typeid_decl = nullptr;
	169	const ast::StructDecl * vtable_decl = nullptr;
[080d2d7]	170
[4f6dda0]	171	};
	172
	173	// Handles thread type declarations:
	174	//
	175	// thread Mythread { struct MyThread {
	176	// int data; int data;
	177	// a_struct_t more_data; a_struct_t more_data;
	178	// => thread$ __thrd_d;
	179	// }; };
	180	// static inline thread$ * get_thread( MyThread * this ) { return &this->__thrd_d; }
	181	//
	182	struct ThreadKeyword final : public ConcurrentSueKeyword {
	183	ThreadKeyword() : ConcurrentSueKeyword(
	184	"thread$",
	185	"__thrd",
	186	"get_thread",
	187	"thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
	188	"ThreadCancelled",
	189	true,
	190	ast::AggregateDecl::Thread )
	191	{}
	192
	193	virtual ~ThreadKeyword() {}
	194	};
	195
	196	// Handles coroutine type declarations:
	197	//
	198	// coroutine MyCoroutine { struct MyCoroutine {
	199	// int data; int data;
	200	// a_struct_t more_data; a_struct_t more_data;
	201	// => coroutine$ __cor_d;
	202	// }; };
	203	// static inline coroutine$ * get_coroutine( MyCoroutine * this ) { return &this->__cor_d; }
	204	//
	205	struct CoroutineKeyword final : public ConcurrentSueKeyword {
	206	CoroutineKeyword() : ConcurrentSueKeyword(
	207	"coroutine$",
	208	"__cor",
	209	"get_coroutine",
	210	"coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
	211	"CoroutineCancelled",
	212	true,
	213	ast::AggregateDecl::Coroutine )
	214	{}
	215
	216	virtual ~CoroutineKeyword() {}
	217	};
	218
	219	// Handles monitor type declarations:
	220	//
	221	// monitor MyMonitor { struct MyMonitor {
	222	// int data; int data;
	223	// a_struct_t more_data; a_struct_t more_data;
	224	// => monitor$ __mon_d;
	225	// }; };
	226	// static inline monitor$ * get_coroutine( MyMonitor * this ) {
	227	// return &this->__cor_d;
	228	// }
	229	// void lock(MyMonitor & this) {
	230	// lock(get_monitor(this));
	231	// }
	232	// void unlock(MyMonitor & this) {
	233	// unlock(get_monitor(this));
	234	// }
	235	//
	236	struct MonitorKeyword final : public ConcurrentSueKeyword {
	237	MonitorKeyword() : ConcurrentSueKeyword(
	238	"monitor$",
	239	"__mon",
	240	"get_monitor",
	241	"monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
	242	"",
	243	false,
	244	ast::AggregateDecl::Monitor )
	245	{}
	246
	247	virtual ~MonitorKeyword() {}
	248	};
	249
	250	// Handles generator type declarations:
	251	//
	252	// generator MyGenerator { struct MyGenerator {
	253	// int data; int data;
	254	// a_struct_t more_data; a_struct_t more_data;
	255	// => int __generator_state;
	256	// }; };
	257	//
	258	struct GeneratorKeyword final : public ConcurrentSueKeyword {
	259	GeneratorKeyword() : ConcurrentSueKeyword(
	260	"generator$",
	261	"__generator_state",
	262	"get_generator",
	263	"Unable to find builtin type generator$\n",
	264	"",
	265	true,
	266	ast::AggregateDecl::Generator )
	267	{}
	268
	269	virtual ~GeneratorKeyword() {}
	270	};
	271
	272	const ast::Decl * ConcurrentSueKeyword::postvisit(
	273	const ast::StructDecl * decl ) {
	274	if ( !decl->body ) {
	275	return decl;
	276	} else if ( cast_target == decl->kind ) {
	277	return handleStruct( decl );
	278	} else if ( type_name == decl->name ) {
	279	assert( !type_decl );
	280	type_decl = decl;
	281	} else if ( exception_name == decl->name ) {
	282	assert( !except_decl );
	283	except_decl = decl;
	284	} else if ( typeid_name == decl->name ) {
	285	assert( !typeid_decl );
	286	typeid_decl = decl;
	287	} else if ( vtable_name == decl->name ) {
	288	assert( !vtable_decl );
	289	vtable_decl = decl;
	290	}
	291	return decl;
	292	}
	293
	294	// Try to get the full definition, but raise an error on conflicts.
	295	const ast::FunctionDecl * getDefinition(
	296	const ast::FunctionDecl * old_decl,
	297	const ast::FunctionDecl * new_decl ) {
	298	if ( !new_decl->stmts ) {
	299	return old_decl;
	300	} else if ( !old_decl->stmts ) {
	301	return new_decl;
	302	} else {
	303	assert( !old_decl->stmts \|\| !new_decl->stmts );
	304	return nullptr;
	305	}
	306	}
	307
	308	const ast::DeclWithType * ConcurrentSueKeyword::postvisit(
	309	const ast::FunctionDecl * decl ) {
	310	if ( type_decl && isDestructorFor( decl, type_decl ) ) {
	311	// Check for forward declarations, try to get the full definition.
	312	dtor_decl = (dtor_decl) ? getDefinition( dtor_decl, decl ) : decl;
	313	} else if ( !vtable_name.empty() && decl->has_body() ) {
	314	if (const ast::DeclWithType * param = isMainFor( decl, cast_target )) {
	315	if ( !vtable_decl ) {
	316	SemanticError( decl, context_error );
	317	}
	318	// Should be safe because of isMainFor.
	319	const ast::StructInstType * struct_type =
	320	static_cast<const ast::StructInstType *>(
	321	static_cast<const ast::ReferenceType *>(
	322	param->get_type() )->base.get() );
	323
	324	handleMain( decl, struct_type );
	325	}
	326	}
	327	return decl;
	328	}
	329
	330	const ast::Expr * ConcurrentSueKeyword::postvisit(
	331	const ast::KeywordCastExpr * expr ) {
	332	if ( cast_target == expr->target ) {
	333	// Convert `(thread &)ex` to `(thread$ &)*get_thread(ex)`, etc.
	334	if ( !type_decl \|\| !dtor_decl ) {
	335	SemanticError( expr, context_error );
	336	}
	337	assert( nullptr == expr->result );
	338	auto cast = ast::mutate( expr );
	339	cast->result = new ast::ReferenceType( new ast::StructInstType( type_decl ) );
	340	cast->concrete_target.field = field_name;
	341	cast->concrete_target.getter = getter_name;
	342	return cast;
	343	}
	344	return expr;
	345	}
	346
	347	const ast::StructDecl * ConcurrentSueKeyword::handleStruct(
	348	const ast::StructDecl * decl ) {
	349	assert( decl->body );
	350
	351	if ( !type_decl \|\| !dtor_decl ) {
	352	SemanticError( decl, context_error );
	353	}
	354
	355	if ( !exception_name.empty() ) {
	356	if( !typeid_decl \|\| !vtable_decl ) {
	357	SemanticError( decl, context_error );
	358	}
	359	addTypeId( decl );
	360	addVtableForward( decl );
	361	}
	362
	363	const ast::FunctionDecl * func = forwardDeclare( decl );
	364	StructAndField addFieldRet = addField( decl );
	365	decl = addFieldRet.decl;
	366	const ast::ObjectDecl * field = addFieldRet.field;
	367
	368	addGetRoutines( field, func );
	369	// Add routines to monitors for use by mutex stmt.
	370	if ( ast::AggregateDecl::Monitor == cast_target ) {
	371	addLockUnlockRoutines( decl );
	372	}
	373
	374	return decl;
	375	}
	376
	377	void ConcurrentSueKeyword::handleMain(
	378	const ast::FunctionDecl * decl, const ast::StructInstType * type ) {
	379	assert( vtable_decl );
	380	assert( except_decl );
	381
	382	const CodeLocation & location = decl->location;
	383
	384	std::vector<ast::ptr<ast::Expr>> poly_args = {
	385	new ast::TypeExpr( location, type ),
	386	};
	387	ast::ObjectDecl * vtable_object = Virtual::makeVtableInstance(
	388	location,
	389	"_default_vtable_object_declaration",
	390	new ast::StructInstType( vtable_decl, copy( poly_args ) ),
	391	type,
	392	nullptr
	393	);
	394	declsToAddAfter.push_back( vtable_object );
	395	declsToAddAfter.push_back(
	396	new ast::ObjectDecl(
	397	location,
	398	Virtual::concurrentDefaultVTableName(),
	399	new ast::ReferenceType( vtable_object->type, ast::CV::Const ),
	400	new ast::SingleInit( location,
[e8616b6]	401	new ast::VariableExpr( location, vtable_object ) )
[4f6dda0]	402	)
	403	);
	404	declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
	405	location,
	406	vtable_object,
	407	new ast::StructInstType( except_decl, copy( poly_args ) )
	408	) );
	409	}
	410
	411	void ConcurrentSueKeyword::addTypeId( const ast::StructDecl * decl ) {
	412	assert( typeid_decl );
	413	const CodeLocation & location = decl->location;
	414
	415	ast::StructInstType * typeid_type =
	416	new ast::StructInstType( typeid_decl, ast::CV::Const );
	417	typeid_type->params.push_back(
	418	new ast::TypeExpr( location, new ast::StructInstType( decl ) ) );
	419	declsToAddBefore.push_back(
	420	Virtual::makeTypeIdInstance( location, typeid_type ) );
	421	// If the typeid_type is going to be kept, the other reference will have
	422	// been made by now, but we also get to avoid extra mutates.
	423	ast::ptr<ast::StructInstType> typeid_cleanup = typeid_type;
	424	}
	425
	426	void ConcurrentSueKeyword::addVtableForward( const ast::StructDecl * decl ) {
	427	assert( vtable_decl );
	428	const CodeLocation& location = decl->location;
	429
	430	std::vector<ast::ptr<ast::Expr>> poly_args = {
	431	new ast::TypeExpr( location, new ast::StructInstType( decl ) ),
	432	};
	433	declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
	434	location,
	435	new ast::StructInstType( vtable_decl, copy( poly_args ) ),
	436	new ast::StructInstType( except_decl, copy( poly_args ) )
	437	) );
	438	ast::ObjectDecl * vtable_object = Virtual::makeVtableForward(
	439	location,
	440	"_default_vtable_object_declaration",
	441	new ast::StructInstType( vtable_decl, std::move( poly_args ) )
	442	);
	443	declsToAddBefore.push_back( vtable_object );
	444	declsToAddBefore.push_back(
	445	new ast::ObjectDecl(
	446	location,
	447	Virtual::concurrentDefaultVTableName(),
	448	new ast::ReferenceType( vtable_object->type, ast::CV::Const ),
	449	nullptr,
	450	ast::Storage::Extern,
	451	ast::Linkage::Cforall
	452	)
	453	);
	454	}
	455
	456	const ast::FunctionDecl * ConcurrentSueKeyword::forwardDeclare(
	457	const ast::StructDecl * decl ) {
	458	const CodeLocation & location = decl->location;
	459
	460	ast::StructDecl * forward = ast::deepCopy( decl );
	461	{
	462	// If removing members makes ref-count go to zero, do not free.
	463	ast::ptr<ast::StructDecl> forward_ptr = forward;
	464	forward->body = false;
	465	forward->members.clear();
	466	forward_ptr.release();
	467	}
	468
	469	ast::ObjectDecl * this_decl = new ast::ObjectDecl(
	470	location,
	471	"this",
[e8616b6]	472	new ast::ReferenceType( new ast::StructInstType( decl ) )
[4f6dda0]	473	);
	474
	475	ast::ObjectDecl * ret_decl = new ast::ObjectDecl(
	476	location,
	477	"ret",
[e8616b6]	478	new ast::PointerType( new ast::StructInstType( type_decl ) )
[4f6dda0]	479	);
	480
	481	ast::FunctionDecl * get_decl = new ast::FunctionDecl(
	482	location,
	483	getter_name,
	484	{ this_decl }, // params
	485	{ ret_decl }, // returns
	486	nullptr, // stmts
	487	ast::Storage::Static,
	488	ast::Linkage::Cforall,
	489	{ new ast::Attribute( "const" ) },
	490	ast::Function::Inline
	491	);
	492	get_decl = fixupGenerics( get_decl, decl );
	493
	494	ast::FunctionDecl * main_decl = nullptr;
	495	if ( needs_main ) {
	496	// `this_decl` is copied here because the original was used above.
	497	main_decl = new ast::FunctionDecl(
	498	location,
	499	"main",
	500	{ ast::deepCopy( this_decl ) },
	501	{},
	502	nullptr,
	503	ast::Storage::Classes(),
	504	ast::Linkage::Cforall
	505	);
	506	main_decl = fixupGenerics( main_decl, decl );
	507	}
	508
	509	declsToAddBefore.push_back( forward );
	510	if ( needs_main ) declsToAddBefore.push_back( main_decl );
	511	declsToAddBefore.push_back( get_decl );
	512
	513	return get_decl;
	514	}
	515
	516	ConcurrentSueKeyword::StructAndField ConcurrentSueKeyword::addField(
	517	const ast::StructDecl * decl ) {
	518	const CodeLocation & location = decl->location;
	519
	520	ast::ObjectDecl * field = new ast::ObjectDecl(
	521	location,
	522	field_name,
[e8616b6]	523	new ast::StructInstType( type_decl )
[4f6dda0]	524	);
	525
	526	auto mutDecl = ast::mutate( decl );
	527	mutDecl->members.push_back( field );
	528
	529	return {mutDecl, field};
	530	}
	531
	532	void ConcurrentSueKeyword::addGetRoutines(
	533	const ast::ObjectDecl * field, const ast::FunctionDecl * forward ) {
[b2ecd48]	534	// Clone the signature and then build the body.
	535	ast::FunctionDecl * decl = ast::deepCopy( forward );
	536
[4f6dda0]	537	// Say it is generated at the "same" places as the forward declaration.
[b2ecd48]	538	const CodeLocation & location = decl->location;
[4f6dda0]	539
[b2ecd48]	540	const ast::DeclWithType * param = decl->params.front();
[4f6dda0]	541	ast::Stmt * stmt = new ast::ReturnStmt( location,
	542	new ast::AddressExpr( location,
	543	new ast::MemberExpr( location,
	544	field,
	545	new ast::CastExpr( location,
	546	new ast::VariableExpr( location, param ),
	547	ast::deepCopy( param->get_type()->stripReferences() ),
	548	ast::ExplicitCast
	549	)
	550	)
	551	)
	552	);
	553
	554	decl->stmts = new ast::CompoundStmt( location, { stmt } );
	555	declsToAddAfter.push_back( decl );
	556	}
	557
	558	void ConcurrentSueKeyword::addLockUnlockRoutines(
	559	const ast::StructDecl * decl ) {
	560	// This should only be used on monitors.
	561	assert( ast::AggregateDecl::Monitor == cast_target );
	562
	563	const CodeLocation & location = decl->location;
	564
	565	// The parameter for both routines.
	566	ast::ObjectDecl * this_decl = new ast::ObjectDecl(
	567	location,
	568	"this",
[e8616b6]	569	new ast::ReferenceType( new ast::StructInstType( decl ) )
[4f6dda0]	570	);
	571
	572	ast::FunctionDecl * lock_decl = new ast::FunctionDecl(
	573	location,
	574	"lock",
	575	{
	576	// Copy the declaration of this.
	577	ast::deepCopy( this_decl ),
	578	},
	579	{ /* returns */ },
	580	nullptr,
	581	ast::Storage::Static,
	582	ast::Linkage::Cforall,
	583	{ /* attributes */ },
	584	ast::Function::Inline
	585	);
	586	lock_decl = fixupGenerics( lock_decl, decl );
	587
	588	lock_decl->stmts = new ast::CompoundStmt( location, {
	589	new ast::ExprStmt( location,
	590	new ast::UntypedExpr( location,
	591	new ast::NameExpr( location, "lock" ),
	592	{
	593	new ast::UntypedExpr( location,
	594	new ast::NameExpr( location, "get_monitor" ),
	595	{ new ast::VariableExpr( location,
	596	InitTweak::getParamThis( lock_decl ) ) }
	597	)
	598	}
	599	)
	600	)
	601	} );
	602
	603	ast::FunctionDecl * unlock_decl = new ast::FunctionDecl(
	604	location,
	605	"unlock",
	606	{
	607	// Last use, consume the declaration of this.
	608	this_decl,
	609	},
	610	{ /* returns */ },
	611	nullptr,
	612	ast::Storage::Static,
	613	ast::Linkage::Cforall,
	614	{ /* attributes */ },
	615	ast::Function::Inline
	616	);
	617	unlock_decl = fixupGenerics( unlock_decl, decl );
	618
	619	unlock_decl->stmts = new ast::CompoundStmt( location, {
	620	new ast::ExprStmt( location,
	621	new ast::UntypedExpr( location,
	622	new ast::NameExpr( location, "unlock" ),
	623	{
	624	new ast::UntypedExpr( location,
	625	new ast::NameExpr( location, "get_monitor" ),
	626	{ new ast::VariableExpr( location,
	627	InitTweak::getParamThis( unlock_decl ) ) }
	628	)
	629	}
	630	)
	631	)
	632	} );
	633
	634	declsToAddAfter.push_back( lock_decl );
	635	declsToAddAfter.push_back( unlock_decl );
	636	}
	637
	638
	639	// --------------------------------------------------------------------------
	640	struct SuspendKeyword final :
	641	public ast::WithStmtsToAdd<>, public ast::WithGuards {
	642	SuspendKeyword() = default;
	643	virtual ~SuspendKeyword() = default;
	644
	645	void previsit( const ast::FunctionDecl * );
	646	const ast::DeclWithType * postvisit( const ast::FunctionDecl * );
	647	const ast::Stmt * postvisit( const ast::SuspendStmt * );
	648
	649	private:
	650	bool is_real_suspend( const ast::FunctionDecl * );
	651
	652	const ast::Stmt * make_generator_suspend( const ast::SuspendStmt * );
	653	const ast::Stmt * make_coroutine_suspend( const ast::SuspendStmt * );
	654
	655	struct LabelPair {
	656	ast::Label obj;
	657	int idx;
	658	};
	659
	660	LabelPair make_label(const ast::Stmt * stmt ) {
	661	labels.push_back( ControlStruct::newLabel( "generator", stmt ) );
	662	return { labels.back(), int(labels.size()) };
	663	}
	664
	665	const ast::DeclWithType * in_generator = nullptr;
	666	const ast::FunctionDecl * decl_suspend = nullptr;
	667	std::vector<ast::Label> labels;
	668	};
	669
	670	void SuspendKeyword::previsit( const ast::FunctionDecl * decl ) {
	671	GuardValue( in_generator ); in_generator = nullptr;
	672
	673	// If it is the real suspend, grab it if we don't have one already.
	674	if ( is_real_suspend( decl ) ) {
	675	decl_suspend = decl_suspend ? decl_suspend : decl;
	676	return;
	677	}
	678
	679	// Otherwise check if this is a generator main and, if so, handle it.
	680	auto param = isMainFor( decl, ast::AggregateDecl::Generator );
	681	if ( !param ) return;
	682
	683	if ( 0 != decl->returns.size() ) {
[ca9d65e]	684	SemanticError( decl->location, "Generator main must return void." );
[4f6dda0]	685	}
	686
	687	in_generator = param;
	688	GuardValue( labels ); labels.clear();
	689	}
	690
	691	const ast::DeclWithType * SuspendKeyword::postvisit(
	692	const ast::FunctionDecl * decl ) {
	693	// Only modify a full definition of a generator with states.
	694	if ( !decl->stmts \|\| !in_generator \|\| labels.empty() ) return decl;
	695
	696	const CodeLocation & location = decl->location;
	697
	698	// Create a new function body:
	699	// static void * __generator_labels[] = {&&s0, &&s1, ...};
	700	// void * __generator_label = __generator_labels[GEN.__generator_state];
	701	// goto * __generator_label;
	702	// s0: ;
	703	// OLD_BODY
	704
	705	// This is the null statement inserted right before the body.
	706	ast::NullStmt * noop = new ast::NullStmt( location );
	707	noop->labels.push_back( ControlStruct::newLabel( "generator", noop ) );
	708	const ast::Label & first_label = noop->labels.back();
	709
	710	// Add each label to the init, starting with the first label.
	711	std::vector<ast::ptr<ast::Init>> inits = {
	712	new ast::SingleInit( location,
	713	new ast::LabelAddressExpr( location, copy( first_label ) ) ) };
	714	// Then go through all the stored labels, and clear the store.
	715	for ( auto && label : labels ) {
	716	inits.push_back( new ast::SingleInit( label.location,
	717	new ast::LabelAddressExpr( label.location, std::move( label )
	718	) ) );
	719	}
	720	labels.clear();
	721	// Then construct the initializer itself.
	722	auto init = new ast::ListInit( location, std::move( inits ) );
	723
	724	ast::ObjectDecl * generatorLabels = new ast::ObjectDecl(
	725	location,
	726	"__generator_labels",
	727	new ast::ArrayType(
	728	new ast::PointerType( new ast::VoidType() ),
	729	nullptr,
	730	ast::FixedLen,
	731	ast::DynamicDim
	732	),
	733	init,
	734	ast::Storage::Classes(),
	735	ast::Linkage::AutoGen
	736	);
	737
	738	ast::ObjectDecl * generatorLabel = new ast::ObjectDecl(
	739	location,
	740	"__generator_label",
	741	new ast::PointerType( new ast::VoidType() ),
	742	new ast::SingleInit( location,
	743	new ast::UntypedExpr( location,
	744	new ast::NameExpr( location, "?[?]" ),
	745	{
	746	// TODO: Could be a variable expr.
	747	new ast::NameExpr( location, "__generator_labels" ),
	748	new ast::UntypedMemberExpr( location,
	749	new ast::NameExpr( location, "__generator_state" ),
	750	new ast::VariableExpr( location, in_generator )
	751	)
	752	}
	753	)
	754	),
	755	ast::Storage::Classes(),
	756	ast::Linkage::AutoGen
	757	);
	758
	759	ast::BranchStmt * theGoTo = new ast::BranchStmt(
	760	location, new ast::VariableExpr( location, generatorLabel )
	761	);
	762
	763	// The noop goes here in order.
	764
	765	ast::CompoundStmt * body = new ast::CompoundStmt( location, {
	766	{ new ast::DeclStmt( location, generatorLabels ) },
	767	{ new ast::DeclStmt( location, generatorLabel ) },
	768	{ theGoTo },
	769	{ noop },
	770	{ decl->stmts },
	771	} );
	772
	773	auto mutDecl = ast::mutate( decl );
	774	mutDecl->stmts = body;
	775	return mutDecl;
	776	}
	777
	778	const ast::Stmt * SuspendKeyword::postvisit( const ast::SuspendStmt * stmt ) {
[835d6e8]	779	switch ( stmt->kind ) {
[4f6dda0]	780	case ast::SuspendStmt::None:
	781	// Use the context to determain the implicit target.
	782	if ( in_generator ) {
	783	return make_generator_suspend( stmt );
	784	} else {
	785	return make_coroutine_suspend( stmt );
	786	}
	787	case ast::SuspendStmt::Coroutine:
	788	return make_coroutine_suspend( stmt );
	789	case ast::SuspendStmt::Generator:
	790	// Generator suspends must be directly in a generator.
[ca9d65e]	791	if ( !in_generator ) SemanticError( stmt->location, "\"suspend generator\" must be used inside main of generator type." );
[4f6dda0]	792	return make_generator_suspend( stmt );
	793	}
	794	assert( false );
	795	return stmt;
	796	}
	797
	798	/// Find the real/official suspend declaration.
	799	bool SuspendKeyword::is_real_suspend( const ast::FunctionDecl * decl ) {
	800	return ( !decl->linkage.is_mangled
	801	&& 0 == decl->params.size()
	802	&& 0 == decl->returns.size()
	803	&& "__cfactx_suspend" == decl->name );
	804	}
	805
	806	const ast::Stmt * SuspendKeyword::make_generator_suspend(
	807	const ast::SuspendStmt * stmt ) {
	808	assert( in_generator );
	809	// Target code is:
	810	// GEN.__generator_state = X;
	811	// THEN
	812	// return;
	813	// __gen_X:;
	814
	815	const CodeLocation & location = stmt->location;
	816
	817	LabelPair label = make_label( stmt );
	818
	819	// This is the context saving statement.
	820	stmtsToAddBefore.push_back( new ast::ExprStmt( location,
	821	new ast::UntypedExpr( location,
	822	new ast::NameExpr( location, "?=?" ),
	823	{
	824	new ast::UntypedMemberExpr( location,
	825	new ast::NameExpr( location, "__generator_state" ),
	826	new ast::VariableExpr( location, in_generator )
	827	),
	828	ast::ConstantExpr::from_int( location, label.idx ),
	829	}
	830	)
	831	) );
	832
	833	// The THEN component is conditional (return is not).
	834	if ( stmt->then ) {
	835	stmtsToAddBefore.push_back( stmt->then.get() );
	836	}
	837	stmtsToAddBefore.push_back( new ast::ReturnStmt( location, nullptr ) );
	838
	839	// The null statement replaces the old suspend statement.
	840	return new ast::NullStmt( location, { label.obj } );
	841	}
	842
	843	const ast::Stmt * SuspendKeyword::make_coroutine_suspend(
	844	const ast::SuspendStmt * stmt ) {
	845	// The only thing we need from the old statement is the location.
	846	const CodeLocation & location = stmt->location;
	847
	848	if ( !decl_suspend ) {
[ca9d65e]	849	SemanticError( location, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>." );
[4f6dda0]	850	}
	851	if ( stmt->then ) {
	852	SemanticError( location, "Compound statement following coroutines is not implemented." );
	853	}
	854
	855	return new ast::ExprStmt( location,
	856	new ast::UntypedExpr( location,
	857	ast::VariableExpr::functionPointer( location, decl_suspend ) )
	858	);
	859	}
	860
[2cf3b87]	861	// --------------------------------------------------------------------------
[080d2d7]	862	struct MutexKeyword final : public ast::WithDeclsToAdd<> {
[2cf3b87]	863	const ast::FunctionDecl * postvisit( const ast::FunctionDecl * decl );
	864	void postvisit( const ast::StructDecl * decl );
	865	const ast::Stmt * postvisit( const ast::MutexStmt * stmt );
	866
[56f519b]	867	static std::vector<const ast::DeclWithType *> findMutexArgs(
[2cf3b87]	868	const ast::FunctionDecl * decl, bool & first );
[56f519b]	869	static void validate( const ast::DeclWithType * decl );
	870
[2cf3b87]	871	ast::CompoundStmt * addDtorStatements( const ast::FunctionDecl* func, const ast::CompoundStmt , const std::vector<const ast::DeclWithType > &);
	872	ast::CompoundStmt * addStatements( const ast::FunctionDecl* func, const ast::CompoundStmt , const std::vector<const ast::DeclWithType > &);
	873	ast::CompoundStmt * addStatements( const ast::CompoundStmt * body, const std::vector<ast::ptr<ast::Expr>> & args );
	874	ast::CompoundStmt * addThreadDtorStatements( const ast::FunctionDecl* func, const ast::CompoundStmt * body, const std::vector<const ast::DeclWithType *> & args );
[080d2d7]	875	ast::ExprStmt * genVirtLockUnlockExpr( const std::string & fnName, ast::ptr<ast::Expr> expr, const CodeLocation & location, ast::Expr * param);
	876	ast::IfStmt * genTypeDiscrimLockUnlock( const std::string & fnName, const std::vector<ast::ptr<ast::Expr>> & args, const CodeLocation & location, ast::UntypedExpr * thisParam );
[56f519b]	877	private:
[2cf3b87]	878	const ast::StructDecl * monitor_decl = nullptr;
	879	const ast::StructDecl * guard_decl = nullptr;
	880	const ast::StructDecl * dtor_guard_decl = nullptr;
	881	const ast::StructDecl * thread_guard_decl = nullptr;
	882	const ast::StructDecl * lock_guard_decl = nullptr;
	883
	884	static ast::ptr<ast::Type> generic_func;
[080d2d7]	885
	886	UniqueName mutex_func_namer = UniqueName("__lock_unlock_curr");
[2cf3b87]	887	};
	888
	889	const ast::FunctionDecl * MutexKeyword::postvisit(
	890	const ast::FunctionDecl * decl ) {
	891	bool is_first_argument_mutex = false;
	892	const std::vector<const ast::DeclWithType *> mutexArgs =
	893	findMutexArgs( decl, is_first_argument_mutex );
	894	bool const isDtor = CodeGen::isDestructor( decl->name );
	895
	896	// Does this function have any mutex arguments that connect to monitors?
	897	if ( mutexArgs.empty() ) {
	898	// If this is the destructor for a monitor it must be mutex.
	899	if ( isDtor ) {
	900	// This reflects MutexKeyword::validate, but no error messages.
	901	const ast::Type * type = decl->type->params.front();
	902
	903	// If it's a copy, it's not a mutex.
	904	const ast::ReferenceType * refType = dynamic_cast<const ast::ReferenceType *>( type );
	905	if ( nullptr == refType ) {
	906	return decl;
	907	}
	908
	909	// If it is not pointing directly to a type, it's not a mutex.
	910	auto base = refType->base;
	911	if ( base.as<ast::ReferenceType>() ) return decl;
	912	if ( base.as<ast::PointerType>() ) return decl;
	913
	914	// If it is not a struct, it's not a mutex.
	915	auto baseStruct = base.as<ast::StructInstType>();
	916	if ( nullptr == baseStruct ) return decl;
	917
	918	// If it is a monitor, then it is a monitor.
	919	if( baseStruct->base->is_monitor() \|\| baseStruct->base->is_thread() ) {
[ca9d65e]	920	SemanticError( decl, "destructors for structures declared as \"monitor\" must use mutex parameters " );
[2cf3b87]	921	}
	922	}
	923	return decl;
	924	}
	925
	926	// Monitors can't be constructed with mutual exclusion.
[56f519b]	927	if ( CodeGen::isConstructor( decl->name ) && is_first_argument_mutex ) {
[ca9d65e]	928	SemanticError( decl, "constructors cannot have mutex parameters " );
[2cf3b87]	929	}
	930
	931	// It makes no sense to have multiple mutex parameters for the destructor.
	932	if ( isDtor && mutexArgs.size() != 1 ) {
[ca9d65e]	933	SemanticError( decl, "destructors can only have 1 mutex argument " );
[2cf3b87]	934	}
	935
	936	// Make sure all the mutex arguments are monitors.
	937	for ( auto arg : mutexArgs ) {
	938	validate( arg );
	939	}
	940
	941	// Check to see if the body needs to be instrument the body.
	942	const ast::CompoundStmt * body = decl->stmts;
	943	if ( !body ) return decl;
	944
	945	// Check to if the required headers have been seen.
	946	if ( !monitor_decl \|\| !guard_decl \|\| !dtor_guard_decl ) {
[ca9d65e]	947	SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor.hfa>." );
[2cf3b87]	948	}
	949
	950	// Instrument the body.
	951	ast::CompoundStmt * newBody = nullptr;
	952	if ( isDtor && isThread( mutexArgs.front() ) ) {
	953	if ( !thread_guard_decl ) {
[ca9d65e]	954	SemanticError( decl, "thread destructor requires threads to be in scope, add #include <thread.hfa>." );
[2cf3b87]	955	}
	956	newBody = addThreadDtorStatements( decl, body, mutexArgs );
	957	} else if ( isDtor ) {
	958	newBody = addDtorStatements( decl, body, mutexArgs );
	959	} else {
	960	newBody = addStatements( decl, body, mutexArgs );
	961	}
	962	assert( newBody );
	963	return ast::mutate_field( decl, &ast::FunctionDecl::stmts, newBody );
	964	}
	965
	966	void MutexKeyword::postvisit( const ast::StructDecl * decl ) {
	967	if ( !decl->body ) {
	968	return;
	969	} else if ( decl->name == "monitor$" ) {
	970	assert( !monitor_decl );
	971	monitor_decl = decl;
	972	} else if ( decl->name == "monitor_guard_t" ) {
	973	assert( !guard_decl );
	974	guard_decl = decl;
	975	} else if ( decl->name == "monitor_dtor_guard_t" ) {
	976	assert( !dtor_guard_decl );
	977	dtor_guard_decl = decl;
	978	} else if ( decl->name == "thread_dtor_guard_t" ) {
	979	assert( !thread_guard_decl );
	980	thread_guard_decl = decl;
	981	} else if ( decl->name == "__mutex_stmt_lock_guard" ) {
	982	assert( !lock_guard_decl );
	983	lock_guard_decl = decl;
	984	}
	985	}
	986
	987	const ast::Stmt * MutexKeyword::postvisit( const ast::MutexStmt * stmt ) {
[41d3c8d]	988	if ( !lock_guard_decl ) {
[ca9d65e]	989	SemanticError( stmt->location, "mutex stmt requires a header, add #include <mutex_stmt.hfa>." );
[41d3c8d]	990	}
[2cf3b87]	991	ast::CompoundStmt * body =
	992	new ast::CompoundStmt( stmt->location, { stmt->stmt } );
[fc1a3e2]	993
[080d2d7]	994	return addStatements( body, stmt->mutexObjs );;
[2cf3b87]	995	}
	996
	997	std::vector<const ast::DeclWithType *> MutexKeyword::findMutexArgs(
	998	const ast::FunctionDecl * decl, bool & first ) {
	999	std::vector<const ast::DeclWithType *> mutexArgs;
	1000
	1001	bool once = true;
	1002	for ( auto arg : decl->params ) {
	1003	const ast::Type * type = arg->get_type();
[56f519b]	1004	if ( type->is_mutex() ) {
	1005	if ( once ) first = true;
	1006	mutexArgs.push_back( arg.get() );
[2cf3b87]	1007	}
[56f519b]	1008	once = false;
[2cf3b87]	1009	}
	1010	return mutexArgs;
	1011	}
	1012
	1013	void MutexKeyword::validate( const ast::DeclWithType * decl ) {
	1014	const ast::Type * type = decl->get_type();
	1015
	1016	// If it's a copy, it's not a mutex.
	1017	const ast::ReferenceType * refType = dynamic_cast<const ast::ReferenceType *>( type );
	1018	if ( nullptr == refType ) {
	1019	SemanticError( decl, "Mutex argument must be of reference type " );
	1020	}
	1021
	1022	// If it is not pointing directly to a type, it's not a mutex.
	1023	auto base = refType->base;
	1024	if ( base.as<ast::ReferenceType>() \|\| base.as<ast::PointerType>() ) {
	1025	SemanticError( decl, "Mutex argument have exactly one level of indirection " );
	1026	}
	1027
	1028	// If it is not a struct, it's not a mutex.
	1029	auto baseStruct = base.as<ast::StructInstType>();
	1030	if ( nullptr == baseStruct ) return;
	1031
	1032	// Make sure that only the outer reference is mutex.
	1033	if( baseStruct->is_mutex() ) {
	1034	SemanticError( decl, "mutex keyword may only appear once per argument " );
	1035	}
	1036	}
	1037
	1038	ast::CompoundStmt * MutexKeyword::addDtorStatements(
	1039	const ast::FunctionDecl* func, const ast::CompoundStmt * body,
	1040	const std::vector<const ast::DeclWithType *> & args ) {
	1041	ast::Type * argType = ast::shallowCopy( args.front()->get_type() );
	1042	argType->set_mutex( false );
	1043
	1044	ast::CompoundStmt * mutBody = ast::mutate( body );
	1045
	1046	// Generated code goes near the beginning of body:
	1047	const CodeLocation & location = mutBody->location;
	1048
	1049	const ast::ObjectDecl * monitor = new ast::ObjectDecl(
	1050	location,
	1051	"__monitor",
	1052	new ast::PointerType( new ast::StructInstType( monitor_decl ) ),
	1053	new ast::SingleInit(
	1054	location,
	1055	new ast::UntypedExpr(
	1056	location,
	1057	new ast::NameExpr( location, "get_monitor" ),
	1058	{ new ast::CastExpr(
	1059	location,
	1060	new ast::VariableExpr( location, args.front() ),
	1061	argType, ast::ExplicitCast
	1062	) }
	1063	)
[e8616b6]	1064	)
[2cf3b87]	1065	);
	1066
	1067	assert( generic_func );
	1068
	1069	// In reverse order:
	1070	// monitor_dtor_guard_t __guard = { __monitor, func, false };
	1071	mutBody->push_front(
	1072	new ast::DeclStmt( location, new ast::ObjectDecl(
	1073	location,
	1074	"__guard",
	1075	new ast::StructInstType( dtor_guard_decl ),
	1076	new ast::ListInit(
	1077	location,
	1078	{
	1079	new ast::SingleInit( location,
[4f6dda0]	1080	new ast::AddressExpr( location,
[2cf3b87]	1081	new ast::VariableExpr( location, monitor ) ) ),
	1082	new ast::SingleInit( location,
	1083	new ast::CastExpr( location,
	1084	new ast::VariableExpr( location, func ),
	1085	generic_func,
	1086	ast::ExplicitCast ) ),
	1087	new ast::SingleInit( location,
	1088	ast::ConstantExpr::from_bool( location, false ) ),
	1089	},
	1090	{},
	1091	ast::MaybeConstruct
[e8616b6]	1092	)
[2cf3b87]	1093	))
	1094	);
	1095
	1096	// monitor$ * __monitor = get_monitor(a);
	1097	mutBody->push_front( new ast::DeclStmt( location, monitor ) );
	1098
	1099	return mutBody;
	1100	}
	1101
	1102	ast::CompoundStmt * MutexKeyword::addStatements(
	1103	const ast::FunctionDecl* func, const ast::CompoundStmt * body,
	1104	const std::vector<const ast::DeclWithType * > & args ) {
	1105	ast::CompoundStmt * mutBody = ast::mutate( body );
	1106
	1107	// Code is generated near the beginning of the compound statement.
	1108	const CodeLocation & location = mutBody->location;
	1109
	1110	// Make pointer to the monitors.
	1111	ast::ObjectDecl * monitors = new ast::ObjectDecl(
	1112	location,
	1113	"__monitors",
	1114	new ast::ArrayType(
	1115	new ast::PointerType(
	1116	new ast::StructInstType( monitor_decl )
	1117	),
	1118	ast::ConstantExpr::from_ulong( location, args.size() ),
	1119	ast::FixedLen,
	1120	ast::DynamicDim
	1121	),
	1122	new ast::ListInit(
	1123	location,
	1124	map_range<std::vector<ast::ptr<ast::Init>>>(
	1125	args,
	1126	[]( const ast::DeclWithType * decl ) {
	1127	return new ast::SingleInit(
	1128	decl->location,
	1129	new ast::UntypedExpr(
	1130	decl->location,
	1131	new ast::NameExpr( decl->location, "get_monitor" ),
	1132	{
	1133	new ast::CastExpr(
	1134	decl->location,
	1135	new ast::VariableExpr( decl->location, decl ),
	1136	decl->get_type(),
	1137	ast::ExplicitCast
	1138	)
	1139	}
	1140	)
	1141	);
	1142	}
	1143	)
[e8616b6]	1144	)
[2cf3b87]	1145	);
	1146
	1147	assert( generic_func );
	1148
	1149	// In Reverse Order:
	1150	mutBody->push_front(
	1151	new ast::DeclStmt( location, new ast::ObjectDecl(
	1152	location,
	1153	"__guard",
	1154	new ast::StructInstType( guard_decl ),
	1155	new ast::ListInit(
	1156	location,
	1157	{
	1158	new ast::SingleInit( location,
	1159	new ast::VariableExpr( location, monitors ) ),
	1160	new ast::SingleInit( location,
	1161	ast::ConstantExpr::from_ulong( location, args.size() ) ),
	1162	new ast::SingleInit( location, new ast::CastExpr(
	1163	location,
	1164	new ast::VariableExpr( location, func ),
	1165	generic_func,
	1166	ast::ExplicitCast
	1167	) ),
	1168	},
	1169	{},
	1170	ast::MaybeConstruct
[e8616b6]	1171	)
[2cf3b87]	1172	))
	1173	);
	1174
	1175	// monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
	1176	mutBody->push_front( new ast::DeclStmt( location, monitors ) );
	1177
	1178	return mutBody;
	1179	}
	1180
[080d2d7]	1181	// generates a cast to the void ptr to the appropriate lock type and dereferences it before calling lock or unlock on it
[fc1a3e2]	1182	// used to undo the type erasure done by storing all the lock pointers as void
[080d2d7]	1183	ast::ExprStmt * MutexKeyword::genVirtLockUnlockExpr( const std::string & fnName, ast::ptr<ast::Expr> expr, const CodeLocation & location, ast::Expr * param ) {
	1184	return new ast::ExprStmt( location,
	1185	new ast::UntypedExpr( location,
	1186	new ast::NameExpr( location, fnName ), {
	1187	ast::UntypedExpr::createDeref(
	1188	location,
[fc1a3e2]	1189	new ast::CastExpr( location,
[080d2d7]	1190	param,
	1191	new ast::PointerType( new ast::TypeofType( new ast::UntypedExpr(
	1192	expr->location,
	1193	new ast::NameExpr( expr->location, "__get_mutexstmt_lock_type" ),
	1194	{ expr }
	1195	) ) ),
	1196	ast::GeneratedFlag::ExplicitCast
	1197	)
	1198	)
	1199	}
	1200	)
	1201	);
	1202	}
	1203
	1204	ast::IfStmt * MutexKeyword::genTypeDiscrimLockUnlock( const std::string & fnName, const std::vector<ast::ptr<ast::Expr>> & args, const CodeLocation & location, ast::UntypedExpr * thisParam ) {
	1205	ast::IfStmt * outerLockIf = nullptr;
	1206	ast::IfStmt * lastLockIf = nullptr;
	1207
	1208	//adds an if/elif clause for each lock to assign type from void ptr based on ptr address
	1209	for ( long unsigned int i = 0; i < args.size(); i++ ) {
[fc1a3e2]	1210
[080d2d7]	1211	ast::UntypedExpr * ifCond = new ast::UntypedExpr( location,
	1212	new ast::NameExpr( location, "?==?" ), {
	1213	ast::deepCopy( thisParam ),
	1214	new ast::CastExpr( location, new ast::AddressExpr( location, args.at(i) ), new ast::PointerType( new ast::VoidType() ))
	1215	}
	1216	);
	1217
[fc1a3e2]	1218	ast::IfStmt * currLockIf = new ast::IfStmt(
[080d2d7]	1219	location,
	1220	ifCond,
	1221	genVirtLockUnlockExpr( fnName, args.at(i), location, ast::deepCopy( thisParam ) )
	1222	);
[fc1a3e2]	1223
[080d2d7]	1224	if ( i == 0 ) {
	1225	outerLockIf = currLockIf;
	1226	} else {
	1227	// add ifstmt to else of previous stmt
	1228	lastLockIf->else_ = currLockIf;
	1229	}
	1230
	1231	lastLockIf = currLockIf;
	1232	}
	1233	return outerLockIf;
	1234	}
	1235
[d464b79]	1236	void flattenTuple( const ast::UntypedTupleExpr * tuple, std::vector<ast::ptr<ast::Expr>> & output ) {
[fc1a3e2]	1237	for ( auto & expr : tuple->exprs ) {
	1238	const ast::UntypedTupleExpr * innerTuple = dynamic_cast<const ast::UntypedTupleExpr *>(expr.get());
	1239	if ( innerTuple ) flattenTuple( innerTuple, output );
	1240	else output.emplace_back( ast::deepCopy( expr ));
	1241	}
[d464b79]	1242	}
	1243
[2cf3b87]	1244	ast::CompoundStmt * MutexKeyword::addStatements(
	1245	const ast::CompoundStmt * body,
	1246	const std::vector<ast::ptr<ast::Expr>> & args ) {
	1247
	1248	// Code is generated near the beginning of the compound statement.
[080d2d7]	1249	const CodeLocation & location = body->location;
	1250
	1251	// final body to return
	1252	ast::CompoundStmt * newBody = new ast::CompoundStmt( location );
	1253
	1254	// std::string lockFnName = mutex_func_namer.newName();
	1255	// std::string unlockFnName = mutex_func_namer.newName();
[2cf3b87]	1256
[fc1a3e2]	1257	// If any arguments to the mutex stmt are tuples, flatten them
	1258	std::vector<ast::ptr<ast::Expr>> flattenedArgs;
	1259	for ( auto & arg : args ) {
	1260	const ast::UntypedTupleExpr * tuple = dynamic_cast<const ast::UntypedTupleExpr *>(args.at(0).get());
	1261	if ( tuple ) flattenTuple( tuple, flattenedArgs );
	1262	else flattenedArgs.emplace_back( ast::deepCopy( arg ));
	1263	}
[d464b79]	1264
[2cf3b87]	1265	// Make pointer to the monitors.
	1266	ast::ObjectDecl * monitors = new ast::ObjectDecl(
	1267	location,
	1268	"__monitors",
	1269	new ast::ArrayType(
	1270	new ast::PointerType(
[080d2d7]	1271	new ast::VoidType()
[2cf3b87]	1272	),
[d464b79]	1273	ast::ConstantExpr::from_ulong( location, flattenedArgs.size() ),
[2cf3b87]	1274	ast::FixedLen,
	1275	ast::DynamicDim
	1276	),
	1277	new ast::ListInit(
	1278	location,
	1279	map_range<std::vector<ast::ptr<ast::Init>>>(
[d464b79]	1280	flattenedArgs, [](const ast::Expr * expr) {
[2cf3b87]	1281	return new ast::SingleInit(
	1282	expr->location,
	1283	new ast::UntypedExpr(
	1284	expr->location,
[080d2d7]	1285	new ast::NameExpr( expr->location, "__get_mutexstmt_lock_ptr" ),
[2cf3b87]	1286	{ expr }
	1287	)
	1288	);
	1289	}
	1290	)
[e8616b6]	1291	)
[2cf3b87]	1292	);
	1293
	1294	ast::StructInstType * lock_guard_struct =
	1295	new ast::StructInstType( lock_guard_decl );
	1296
[080d2d7]	1297	// use try stmts to lock and finally to unlock
	1298	ast::TryStmt * outerTry = nullptr;
	1299	ast::TryStmt * currentTry;
	1300	ast::CompoundStmt * lastBody = nullptr;
	1301
	1302	// adds a nested try stmt for each lock we are locking
[d464b79]	1303	for ( long unsigned int i = 0; i < flattenedArgs.size(); i++ ) {
[fc1a3e2]	1304	ast::UntypedExpr * innerAccess = new ast::UntypedExpr(
[080d2d7]	1305	location,
	1306	new ast::NameExpr( location,"?[?]" ), {
	1307	new ast::NameExpr( location, "__monitors" ),
	1308	ast::ConstantExpr::from_int( location, i )
	1309	}
	1310	);
	1311
	1312	// make the try body
	1313	ast::CompoundStmt * currTryBody = new ast::CompoundStmt( location );
[d464b79]	1314	ast::IfStmt * lockCall = genTypeDiscrimLockUnlock( "lock", flattenedArgs, location, innerAccess );
[080d2d7]	1315	currTryBody->push_back( lockCall );
	1316
	1317	// make the finally stmt
	1318	ast::CompoundStmt * currFinallyBody = new ast::CompoundStmt( location );
[d464b79]	1319	ast::IfStmt * unlockCall = genTypeDiscrimLockUnlock( "unlock", flattenedArgs, location, innerAccess );
[080d2d7]	1320	currFinallyBody->push_back( unlockCall );
	1321
	1322	// construct the current try
[400b8be]	1323	currentTry = new ast::TryStmt(
	1324	location,
	1325	currTryBody,
	1326	{},
	1327	new ast::FinallyClause( location, currFinallyBody )
[080d2d7]	1328	);
	1329	if ( i == 0 ) outerTry = currentTry;
	1330	else {
	1331	// pushback try into the body of the outer try
	1332	lastBody->push_back( currentTry );
	1333	}
	1334	lastBody = currTryBody;
	1335	}
	1336
	1337	// push body into innermost try body
	1338	if ( lastBody != nullptr ) {
	1339	lastBody->push_back( body );
	1340	newBody->push_front( outerTry );
[400b8be]	1341	}
[2cf3b87]	1342
	1343	// monitor_guard_t __guard = { __monitors, # };
[080d2d7]	1344	newBody->push_front(
[2cf3b87]	1345	new ast::DeclStmt(
	1346	location,
	1347	new ast::ObjectDecl(
	1348	location,
	1349	"__guard",
	1350	lock_guard_struct,
	1351	new ast::ListInit(
	1352	location,
	1353	{
	1354	new ast::SingleInit(
	1355	location,
	1356	new ast::VariableExpr( location, monitors ) ),
	1357	new ast::SingleInit(
	1358	location,
[d464b79]	1359	ast::ConstantExpr::from_ulong( location, flattenedArgs.size() ) ),
[2cf3b87]	1360	},
	1361	{},
	1362	ast::MaybeConstruct
[e8616b6]	1363	)
[2cf3b87]	1364	)
	1365	)
	1366	);
	1367
	1368	// monitor$ * __monitors[] = { get_monitor(a), get_monitor(b) };
[080d2d7]	1369	newBody->push_front( new ast::DeclStmt( location, monitors ) );
	1370
	1371	// // The parameter for both __lock_curr/__unlock_curr routines.
	1372	// ast::ObjectDecl * this_decl = new ast::ObjectDecl(
	1373	// location,
	1374	// "this",
	1375	// new ast::PointerType( new ast::VoidType() ),
	1376	// nullptr,
	1377	// {},
	1378	// ast::Linkage::Cforall
	1379	// );
	1380
	1381	// ast::FunctionDecl * lock_decl = new ast::FunctionDecl(
	1382	// location,
	1383	// lockFnName,
	1384	// { /* forall */ },
	1385	// {
	1386	// // Copy the declaration of this.
	1387	// this_decl,
	1388	// },
	1389	// { /* returns */ },
	1390	// nullptr,
	1391	// 0,
	1392	// ast::Linkage::Cforall,
	1393	// { /* attributes */ },
	1394	// ast::Function::Inline
	1395	// );
	1396
	1397	// ast::FunctionDecl * unlock_decl = new ast::FunctionDecl(
	1398	// location,
	1399	// unlockFnName,
	1400	// { /* forall */ },
	1401	// {
	1402	// // Copy the declaration of this.
	1403	// ast::deepCopy( this_decl ),
	1404	// },
	1405	// { /* returns */ },
	1406	// nullptr,
	1407	// 0,
	1408	// ast::Linkage::Cforall,
	1409	// { /* attributes */ },
	1410	// ast::Function::Inline
	1411	// );
	1412
	1413	// ast::IfStmt * outerLockIf = nullptr;
	1414	// ast::IfStmt * outerUnlockIf = nullptr;
	1415	// ast::IfStmt * lastLockIf = nullptr;
	1416	// ast::IfStmt * lastUnlockIf = nullptr;
	1417
	1418	// //adds an if/elif clause for each lock to assign type from void ptr based on ptr address
	1419	// for ( long unsigned int i = 0; i < args.size(); i++ ) {
	1420	// ast::VariableExpr * thisParam = new ast::VariableExpr( location, InitTweak::getParamThis( lock_decl ) );
	1421	// ast::UntypedExpr * ifCond = new ast::UntypedExpr( location,
	1422	// new ast::NameExpr( location, "?==?" ), {
	1423	// thisParam,
	1424	// new ast::CastExpr( location, new ast::AddressExpr( location, args.at(i) ), new ast::PointerType( new ast::VoidType() ))
	1425	// }
	1426	// );
	1427
[fc1a3e2]	1428	// ast::IfStmt * currLockIf = new ast::IfStmt(
[080d2d7]	1429	// location,
	1430	// ast::deepCopy( ifCond ),
	1431	// genVirtLockUnlockExpr( "lock", args.at(i), location, ast::deepCopy( thisParam ) )
	1432	// );
	1433
[fc1a3e2]	1434	// ast::IfStmt * currUnlockIf = new ast::IfStmt(
[080d2d7]	1435	// location,
	1436	// ifCond,
	1437	// genVirtLockUnlockExpr( "unlock", args.at(i), location, ast::deepCopy( thisParam ) )
	1438	// );
[fc1a3e2]	1439
[080d2d7]	1440	// if ( i == 0 ) {
	1441	// outerLockIf = currLockIf;
	1442	// outerUnlockIf = currUnlockIf;
	1443	// } else {
	1444	// // add ifstmt to else of previous stmt
	1445	// lastLockIf->else_ = currLockIf;
	1446	// lastUnlockIf->else_ = currUnlockIf;
	1447	// }
	1448
	1449	// lastLockIf = currLockIf;
	1450	// lastUnlockIf = currUnlockIf;
	1451	// }
[fc1a3e2]	1452
[080d2d7]	1453	// // add pointer typing if/elifs to body of routines
	1454	// lock_decl->stmts = new ast::CompoundStmt( location, { outerLockIf } );
	1455	// unlock_decl->stmts = new ast::CompoundStmt( location, { outerUnlockIf } );
	1456
	1457	// // add routines to scope
	1458	// declsToAddBefore.push_back( lock_decl );
	1459	// declsToAddBefore.push_back( unlock_decl );
	1460
	1461	// newBody->push_front(new ast::DeclStmt( location, lock_decl ));
	1462	// newBody->push_front(new ast::DeclStmt( location, unlock_decl ));
	1463
	1464	return newBody;
[2cf3b87]	1465	}
	1466
	1467	ast::CompoundStmt * MutexKeyword::addThreadDtorStatements(
	1468	const ast::FunctionDecl, const ast::CompoundStmt body,
	1469	const std::vector<const ast::DeclWithType * > & args ) {
	1470	assert( args.size() == 1 );
	1471	const ast::DeclWithType * arg = args.front();
	1472	const ast::Type * argType = arg->get_type();
	1473	assert( argType->is_mutex() );
	1474
	1475	ast::CompoundStmt * mutBody = ast::mutate( body );
	1476
	1477	// The code is generated near the front of the body.
	1478	const CodeLocation & location = mutBody->location;
	1479
	1480	// thread_dtor_guard_t __guard = { this, intptr( 0 ) };
	1481	mutBody->push_front( new ast::DeclStmt(
	1482	location,
	1483	new ast::ObjectDecl(
	1484	location,
	1485	"__guard",
	1486	new ast::StructInstType( thread_guard_decl ),
	1487	new ast::ListInit(
	1488	location,
	1489	{
	1490	new ast::SingleInit( location,
	1491	new ast::CastExpr( location,
	1492	new ast::VariableExpr( location, arg ), argType ) ),
	1493	new ast::SingleInit(
	1494	location,
	1495	new ast::UntypedExpr(
	1496	location,
	1497	new ast::NameExpr( location, "intptr" ), {
	1498	ast::ConstantExpr::from_int( location, 0 ),
	1499	}
	1500	) ),
	1501	},
	1502	{},
	1503	ast::MaybeConstruct
[e8616b6]	1504	)
[2cf3b87]	1505	)
	1506	));
	1507
	1508	return mutBody;
	1509	}
	1510
	1511	ast::ptr<ast::Type> MutexKeyword::generic_func =
[db19e1d]	1512	new ast::FunctionType( ast::FixedArgs );
[2cf3b87]	1513
	1514	// --------------------------------------------------------------------------
	1515	struct ThreadStarter final {
	1516	void previsit( const ast::StructDecl * decl );
	1517	const ast::FunctionDecl * postvisit( const ast::FunctionDecl * decl );
	1518
	1519	private:
	1520	bool thread_ctor_seen = false;
	1521	const ast::StructDecl * thread_decl = nullptr;
	1522	};
	1523
	1524	void ThreadStarter::previsit( const ast::StructDecl * decl ) {
	1525	if ( decl->body && decl->name == "thread$" ) {
	1526	assert( !thread_decl );
	1527	thread_decl = decl;
	1528	}
	1529	}
	1530
	1531	const ast::FunctionDecl * ThreadStarter::postvisit( const ast::FunctionDecl * decl ) {
	1532	if ( !CodeGen::isConstructor( decl->name ) ) return decl;
	1533
	1534	// Seach for the thread constructor.
	1535	// (Are the "prefixes" of these to blocks the same?)
	1536	const ast::Type * typeof_this = InitTweak::getTypeofThis( decl->type );
	1537	auto ctored_type = dynamic_cast<const ast::StructInstType *>( typeof_this );
	1538	if ( ctored_type && ctored_type->base == thread_decl ) {
	1539	thread_ctor_seen = true;
	1540	}
	1541
	1542	// Modify this declaration, the extra checks to see if we will are first.
	1543	const ast::ptr<ast::DeclWithType> & param = decl->params.front();
	1544	auto type = dynamic_cast<const ast::StructInstType *>(
[e01eb4a]	1545	ast::getPointerBase( param->get_type() ) );
[2cf3b87]	1546	if ( nullptr == type ) return decl;
	1547	if ( !type->base->is_thread() ) return decl;
	1548	if ( !thread_decl \|\| !thread_ctor_seen ) {
[ca9d65e]	1549	SemanticError( type->base->location, "thread keyword requires threads to be in scope, add #include <thread.hfa>." );
[2cf3b87]	1550	}
	1551	const ast::CompoundStmt * stmt = decl->stmts;
	1552	if ( nullptr == stmt ) return decl;
	1553
	1554	// Now do the actual modification:
	1555	ast::CompoundStmt * mutStmt = ast::mutate( stmt );
	1556	const CodeLocation & location = mutStmt->location;
	1557	mutStmt->push_back(
	1558	new ast::ExprStmt(
	1559	location,
	1560	new ast::UntypedExpr(
	1561	location,
	1562	new ast::NameExpr( location, "__thrd_start" ),
	1563	{
	1564	new ast::VariableExpr( location, param ),
	1565	new ast::NameExpr( location, "main" ),
	1566	}
	1567	)
	1568	)
	1569	);
	1570
	1571	return ast::mutate_field( decl, &ast::FunctionDecl::stmts, mutStmt );
	1572	}
	1573
	1574	} // namespace
	1575
	1576	// --------------------------------------------------------------------------
[4f6dda0]	1577	// Interface Functions:
[2cf3b87]	1578
	1579	void implementKeywords( ast::TranslationUnit & translationUnit ) {
[4f6dda0]	1580	ast::Pass<ThreadKeyword>::run( translationUnit );
	1581	ast::Pass<CoroutineKeyword>::run( translationUnit );
	1582	ast::Pass<MonitorKeyword>::run( translationUnit );
	1583	ast::Pass<GeneratorKeyword>::run( translationUnit );
	1584	ast::Pass<SuspendKeyword>::run( translationUnit );
[2cf3b87]	1585	}
	1586
	1587	void implementMutex( ast::TranslationUnit & translationUnit ) {
	1588	ast::Pass<MutexKeyword>::run( translationUnit );
	1589	}
	1590
	1591	void implementThreadStarter( ast::TranslationUnit & translationUnit ) {
	1592	ast::Pass<ThreadStarter>::run( translationUnit );
	1593	}
	1594
	1595	}
	1596
	1597	// Local Variables: //
	1598	// tab-width: 4 //
	1599	// mode: c++ //
	1600	// compile-command: "make install" //
	1601	// End: //

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

Download in other formats: