Context Navigation

source: src/SymTab/Mangler.cc @ f53afafb

ADTast-experimentalenumpthread-emulationqualifiedEnum

Last change on this file since f53afafb was b66d14a, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago
add new type kinds DStype and ALtype
Property mode set to `100644`
File size: 30.3 KB

Line
1	//
2	// Cforall Version 1.0.0 Copyright (C) 2015 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	// Mangler.cc --
8	//
9	// Author : Richard C. Bilson
10	// Created On : Sun May 17 21:40:29 2015
11	// Last Modified By : Peter A. Buhr
12	// Last Modified On : Mon Jan 11 21:56:06 2021
13	// Update Count : 74
14	//
15	#include "Mangler.h"
16
17	#include <algorithm> // for copy, transform
18	#include <cassert> // for assert, assertf
19	#include <functional> // for const_mem_fun_t, mem_fun
20	#include <iterator> // for ostream_iterator, back_insert_ite...
21	#include <list> // for _List_iterator, list, _List_const...
22	#include <string> // for string, char_traits, operator<<
23
24	#include "CodeGen/OperatorTable.h" // for OperatorInfo, operatorLookup
25	#include "Common/PassVisitor.h"
26	#include "Common/SemanticError.h" // for SemanticError
27	#include "Common/utility.h" // for toString
28	#include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment
29	#include "SynTree/LinkageSpec.h" // for Spec, isOverridable, AutoGen, Int...
30	#include "SynTree/Declaration.h" // for TypeDecl, DeclarationWithType
31	#include "SynTree/Expression.h" // for TypeExpr, Expression, operator<<
32	#include "SynTree/Type.h" // for Type, ReferenceToType, Type::Fora...
33
34	#include "AST/Pass.hpp"
35
36	namespace SymTab {
37	namespace Mangler {
38	namespace {
39	/// Mangles names to a unique C identifier
40	struct Mangler_old : public WithShortCircuiting, public WithVisitorRef<Mangler_old>, public WithGuards {
41	Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
42	Mangler_old( const Mangler_old & ) = delete;
43
44	void previsit( const BaseSyntaxNode * ) { visit_children = false; }
45
46	void postvisit( const ObjectDecl * declaration );
47	void postvisit( const FunctionDecl * declaration );
48	void postvisit( const TypeDecl * declaration );
49
50	void postvisit( const VoidType * voidType );
51	void postvisit( const BasicType * basicType );
52	void postvisit( const PointerType * pointerType );
53	void postvisit( const ArrayType * arrayType );
54	void postvisit( const ReferenceType * refType );
55	void postvisit( const FunctionType * functionType );
56	void postvisit( const StructInstType * aggregateUseType );
57	void postvisit( const UnionInstType * aggregateUseType );
58	void postvisit( const EnumInstType * aggregateUseType );
59	void postvisit( const TypeInstType * aggregateUseType );
60	void postvisit( const TraitInstType * inst );
61	void postvisit( const TupleType * tupleType );
62	void postvisit( const VarArgsType * varArgsType );
63	void postvisit( const ZeroType * zeroType );
64	void postvisit( const OneType * oneType );
65	void postvisit( const QualifiedType * qualType );
66
67	std::string get_mangleName() { return mangleName; }
68	private:
69	std::string mangleName; ///< Mangled name being constructed
70	typedef std::map< std::string, std::pair< int, int > > VarMapType;
71	VarMapType varNums; ///< Map of type variables to indices
72	int nextVarNum; ///< Next type variable index
73	bool isTopLevel; ///< Is the Mangler at the top level
74	bool mangleOverridable; ///< Specially mangle overridable built-in methods
75	bool typeMode; ///< Produce a unique mangled name for a type
76	bool mangleGenericParams; ///< Include generic parameters in name mangling if true
77	bool inFunctionType = false; ///< Include type qualifiers if false.
78	bool inQualifiedType = false; ///< Add start/end delimiters around qualified type
79
80	public:
81	Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
82	int nextVarNum, const VarMapType& varNums );
83
84	private:
85	void mangleDecl( const DeclarationWithType * declaration );
86	void mangleRef( const ReferenceToType * refType, std::string prefix );
87
88	void printQualifiers( const Type *type );
89	}; // Mangler_old
90	} // namespace
91
92	std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
93	PassVisitor<Mangler_old> mangler( mangleOverridable, typeMode, mangleGenericParams );
94	maybeAccept( decl, mangler );
95	return mangler.pass.get_mangleName();
96	}
97
98	std::string mangleType( const Type * ty ) {
99	PassVisitor<Mangler_old> mangler( false, true, true );
100	maybeAccept( ty, mangler );
101	return mangler.pass.get_mangleName();
102	}
103
104	std::string mangleConcrete( const Type * ty ) {
105	PassVisitor<Mangler_old> mangler( false, false, false );
106	maybeAccept( ty, mangler );
107	return mangler.pass.get_mangleName();
108	}
109
110	namespace {
111	Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
112	: nextVarNum( 0 ), isTopLevel( true ),
113	mangleOverridable( mangleOverridable ), typeMode( typeMode ),
114	mangleGenericParams( mangleGenericParams ) {}
115
116	Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
117	int nextVarNum, const VarMapType& varNums )
118	: varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
119	mangleOverridable( mangleOverridable ), typeMode( typeMode ),
120	mangleGenericParams( mangleGenericParams ) {}
121
122	void Mangler_old::mangleDecl( const DeclarationWithType * declaration ) {
123	bool wasTopLevel = isTopLevel;
124	if ( isTopLevel ) {
125	varNums.clear();
126	nextVarNum = 0;
127	isTopLevel = false;
128	} // if
129	mangleName += Encoding::manglePrefix;
130	const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
131	if ( opInfo ) {
132	mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
133	} else {
134	mangleName += std::to_string( declaration->name.size() ) + declaration->name;
135	} // if
136	maybeAccept( declaration->get_type(), *visitor );
137	if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
138	// want to be able to override autogenerated and intrinsic routines,
139	// so they need a different name mangling
140	if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
141	mangleName += Encoding::autogen;
142	} else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
143	mangleName += Encoding::intrinsic;
144	} else {
145	// if we add another kind of overridable function, this has to change
146	assert( false && "unknown overrideable linkage" );
147	} // if
148	}
149	isTopLevel = wasTopLevel;
150	}
151
152	void Mangler_old::postvisit( const ObjectDecl * declaration ) {
153	mangleDecl( declaration );
154	}
155
156	void Mangler_old::postvisit( const FunctionDecl * declaration ) {
157	mangleDecl( declaration );
158	}
159
160	void Mangler_old::postvisit( const VoidType * voidType ) {
161	printQualifiers( voidType );
162	mangleName += Encoding::void_t;
163	}
164
165	void Mangler_old::postvisit( const BasicType * basicType ) {
166	printQualifiers( basicType );
167	assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
168	mangleName += Encoding::basicTypes[ basicType->kind ];
169	}
170
171	void Mangler_old::postvisit( const PointerType * pointerType ) {
172	printQualifiers( pointerType );
173	// mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
174	if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName += Encoding::pointer;
175	maybeAccept( pointerType->base, *visitor );
176	}
177
178	void Mangler_old::postvisit( const ArrayType * arrayType ) {
179	// TODO: encode dimension
180	printQualifiers( arrayType );
181	mangleName += Encoding::array + "0";
182	maybeAccept( arrayType->base, *visitor );
183	}
184
185	void Mangler_old::postvisit( const ReferenceType * refType ) {
186	// don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
187	// Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
188	// by pretending every reference type is a function parameter.
189	GuardValue( inFunctionType );
190	inFunctionType = true;
191	printQualifiers( refType );
192	maybeAccept( refType->base, *visitor );
193	}
194
195	namespace {
196	inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
197	std::list< Type* > ret;
198	std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
199	std::mem_fun( &DeclarationWithType::get_type ) );
200	return ret;
201	}
202	}
203
204	void Mangler_old::postvisit( const FunctionType * functionType ) {
205	printQualifiers( functionType );
206	mangleName += Encoding::function;
207	// turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
208	// since qualifiers on outermost parameter type do not differentiate function types, e.g.,
209	// void ()(const int) and void ()(int) are the same type, but void ()(const int ) and void ()(int ) are different
210	GuardValue( inFunctionType );
211	inFunctionType = true;
212	std::list< Type* > returnTypes = getTypes( functionType->returnVals );
213	if (returnTypes.empty()) mangleName += Encoding::void_t;
214	else acceptAll( returnTypes, *visitor );
215	mangleName += "_";
216	std::list< Type* > paramTypes = getTypes( functionType->parameters );
217	acceptAll( paramTypes, *visitor );
218	mangleName += "_";
219	}
220
221	void Mangler_old::mangleRef( const ReferenceToType * refType, std::string prefix ) {
222	printQualifiers( refType );
223
224	mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
225
226	if ( mangleGenericParams ) {
227	const std::list< Expression* > & params = refType->parameters;
228	if ( ! params.empty() ) {
229	mangleName += "_";
230	for ( const Expression * param : params ) {
231	const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param );
232	assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
233	maybeAccept( paramType->type, *visitor );
234	}
235	mangleName += "_";
236	}
237	}
238	}
239
240	void Mangler_old::postvisit( const StructInstType * aggregateUseType ) {
241	mangleRef( aggregateUseType, Encoding::struct_t );
242	}
243
244	void Mangler_old::postvisit( const UnionInstType * aggregateUseType ) {
245	mangleRef( aggregateUseType, Encoding::union_t );
246	}
247
248	void Mangler_old::postvisit( const EnumInstType * aggregateUseType ) {
249	mangleRef( aggregateUseType, Encoding::enum_t );
250	}
251
252	void Mangler_old::postvisit( const TypeInstType * typeInst ) {
253	VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
254	if ( varNum == varNums.end() ) {
255	mangleRef( typeInst, Encoding::type );
256	} else {
257	printQualifiers( typeInst );
258	// Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
259	// forall(dtype T) void f(T);
260	// forall(dtype S) void f(S);
261	// are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
262	// are first found and prefixing with the appropriate encoding for the type class.
263	assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
264	mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
265	} // if
266	}
267
268	void Mangler_old::postvisit( const TraitInstType * inst ) {
269	printQualifiers( inst );
270	mangleName += std::to_string( inst->name.size() ) + inst->name;
271	}
272
273	void Mangler_old::postvisit( const TupleType * tupleType ) {
274	printQualifiers( tupleType );
275	mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
276	acceptAll( tupleType->types, *visitor );
277	}
278
279	void Mangler_old::postvisit( const VarArgsType * varArgsType ) {
280	printQualifiers( varArgsType );
281	static const std::string vargs = "__builtin_va_list";
282	mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
283	}
284
285	void Mangler_old::postvisit( const ZeroType * ) {
286	mangleName += Encoding::zero;
287	}
288
289	void Mangler_old::postvisit( const OneType * ) {
290	mangleName += Encoding::one;
291	}
292
293	void Mangler_old::postvisit( const QualifiedType * qualType ) {
294	bool inqual = inQualifiedType;
295	if (! inqual ) {
296	// N marks the start of a qualified type
297	inQualifiedType = true;
298	mangleName += Encoding::qualifiedTypeStart;
299	}
300	maybeAccept( qualType->parent, *visitor );
301	maybeAccept( qualType->child, *visitor );
302	if ( ! inqual ) {
303	// E marks the end of a qualified type
304	inQualifiedType = false;
305	mangleName += Encoding::qualifiedTypeEnd;
306	}
307	}
308
309	void Mangler_old::postvisit( const TypeDecl * decl ) {
310	// TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
311	// fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
312	// Note: The current scheme may already work correctly for this case, I have not thought about this deeply
313	// and the case has not yet come up in practice. Alternatively, if not then this code can be removed
314	// aside from the assert false.
315	assertf( false, "Mangler_old should not visit typedecl: %s", toCString(decl));
316	assertf( decl->kind < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
317	mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
318	}
319
320	__attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
321	for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
322	os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
323	} // for
324	}
325
326	void Mangler_old::printQualifiers( const Type * type ) {
327	// skip if not including qualifiers
328	if ( typeMode ) return;
329	if ( ! type->forall.empty() ) {
330	std::list< std::string > assertionNames;
331	int dcount = 0, fcount = 0, vcount = 0, acount = 0;
332	mangleName += Encoding::forall;
333	for ( const TypeDecl * i : type->forall ) {
334	switch ( i->kind ) {
335	case TypeDecl::Dtype:
336	dcount++;
337	break;
338	case TypeDecl::Ftype:
339	fcount++;
340	break;
341	case TypeDecl::Ttype:
342	vcount++;
343	break;
344	default:
345	assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[i->kind].c_str() );
346	} // switch
347	varNums[ i->name ] = std::make_pair( nextVarNum, (int)i->kind );
348	for ( const DeclarationWithType * assert : i->assertions ) {
349	PassVisitor<Mangler_old> sub_mangler(
350	mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
351	assert->accept( sub_mangler );
352	assertionNames.push_back( sub_mangler.pass.get_mangleName() );
353	acount++;
354	} // for
355	} // for
356	mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
357	for(const auto & a : assertionNames) mangleName += a;
358	// std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
359	mangleName += "_";
360	} // if
361	if ( ! inFunctionType ) {
362	// these qualifiers do not distinguish the outermost type of a function parameter
363	if ( type->get_const() ) {
364	mangleName += Encoding::qualifiers.at(Type::Const);
365	} // if
366	if ( type->get_volatile() ) {
367	mangleName += Encoding::qualifiers.at(Type::Volatile);
368	} // if
369	// Removed due to restrict not affecting function compatibility in GCC
370	// if ( type->get_isRestrict() ) {
371	// mangleName += "E";
372	// } // if
373	if ( type->get_atomic() ) {
374	mangleName += Encoding::qualifiers.at(Type::Atomic);
375	} // if
376	}
377	if ( type->get_mutex() ) {
378	mangleName += Encoding::qualifiers.at(Type::Mutex);
379	} // if
380	if ( inFunctionType ) {
381	// turn off inFunctionType so that types can be differentiated for nested qualifiers
382	GuardValue( inFunctionType );
383	inFunctionType = false;
384	}
385	}
386	} // namespace
387	} // namespace Mangler
388	} // namespace SymTab
389
390	namespace Mangle {
391	namespace {
392	/// Mangles names to a unique C identifier
393	struct Mangler_new : public ast::WithShortCircuiting, public ast::WithVisitorRef<Mangler_new>, public ast::WithGuards {
394	Mangler_new( Mangle::Mode mode );
395	Mangler_new( const Mangler_new & ) = delete;
396
397	void previsit( const ast::Node * ) { visit_children = false; }
398
399	void postvisit( const ast::ObjectDecl * declaration );
400	void postvisit( const ast::FunctionDecl * declaration );
401	void postvisit( const ast::TypeDecl * declaration );
402
403	void postvisit( const ast::VoidType * voidType );
404	void postvisit( const ast::BasicType * basicType );
405	void postvisit( const ast::PointerType * pointerType );
406	void postvisit( const ast::ArrayType * arrayType );
407	void postvisit( const ast::ReferenceType * refType );
408	void postvisit( const ast::FunctionType * functionType );
409	void postvisit( const ast::StructInstType * aggregateUseType );
410	void postvisit( const ast::UnionInstType * aggregateUseType );
411	void postvisit( const ast::EnumInstType * aggregateUseType );
412	void postvisit( const ast::TypeInstType * aggregateUseType );
413	void postvisit( const ast::TraitInstType * inst );
414	void postvisit( const ast::TupleType * tupleType );
415	void postvisit( const ast::VarArgsType * varArgsType );
416	void postvisit( const ast::ZeroType * zeroType );
417	void postvisit( const ast::OneType * oneType );
418	void postvisit( const ast::QualifiedType * qualType );
419
420	std::string get_mangleName() { return mangleName; }
421	private:
422	std::string mangleName; ///< Mangled name being constructed
423	typedef std::map< std::string, std::pair< int, int > > VarMapType;
424	VarMapType varNums; ///< Map of type variables to indices
425	int nextVarNum; ///< Next type variable index
426	bool isTopLevel; ///< Is the Mangler at the top level
427	bool mangleOverridable; ///< Specially mangle overridable built-in methods
428	bool typeMode; ///< Produce a unique mangled name for a type
429	bool mangleGenericParams; ///< Include generic parameters in name mangling if true
430	bool inFunctionType = false; ///< Include type qualifiers if false.
431	bool inQualifiedType = false; ///< Add start/end delimiters around qualified type
432
433	private:
434	Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
435	int nextVarNum, const VarMapType& varNums );
436	friend class ast::Pass<Mangler_new>;
437
438	private:
439	void mangleDecl( const ast::DeclWithType *declaration );
440	void mangleRef( const ast::BaseInstType *refType, std::string prefix );
441
442	void printQualifiers( const ast::Type *type );
443	}; // Mangler_new
444	} // namespace
445
446
447	std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
448	ast::Pass<Mangler_new> mangler( mode );
449	maybeAccept( decl, mangler );
450	return mangler.core.get_mangleName();
451	}
452
453	namespace {
454	Mangler_new::Mangler_new( Mangle::Mode mode )
455	: nextVarNum( 0 ), isTopLevel( true ),
456	mangleOverridable ( ! mode.no_overrideable ),
457	typeMode ( mode.type ),
458	mangleGenericParams( ! mode.no_generic_params ) {}
459
460	Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
461	int nextVarNum, const VarMapType& varNums )
462	: varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
463	mangleOverridable( mangleOverridable ), typeMode( typeMode ),
464	mangleGenericParams( mangleGenericParams ) {}
465
466	void Mangler_new::mangleDecl( const ast::DeclWithType * decl ) {
467	bool wasTopLevel = isTopLevel;
468	if ( isTopLevel ) {
469	varNums.clear();
470	nextVarNum = 0;
471	isTopLevel = false;
472	} // if
473	mangleName += Encoding::manglePrefix;
474	const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name );
475	if ( opInfo ) {
476	mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
477	} else {
478	mangleName += std::to_string( decl->name.size() ) + decl->name;
479	} // if
480	maybeAccept( decl->get_type(), *visitor );
481	if ( mangleOverridable && decl->linkage.is_overrideable ) {
482	// want to be able to override autogenerated and intrinsic routines,
483	// so they need a different name mangling
484	if ( decl->linkage == ast::Linkage::AutoGen ) {
485	mangleName += Encoding::autogen;
486	} else if ( decl->linkage == ast::Linkage::Intrinsic ) {
487	mangleName += Encoding::intrinsic;
488	} else {
489	// if we add another kind of overridable function, this has to change
490	assert( false && "unknown overrideable linkage" );
491	} // if
492	}
493	isTopLevel = wasTopLevel;
494	}
495
496	void Mangler_new::postvisit( const ast::ObjectDecl * decl ) {
497	mangleDecl( decl );
498	}
499
500	void Mangler_new::postvisit( const ast::FunctionDecl * decl ) {
501	mangleDecl( decl );
502	}
503
504	void Mangler_new::postvisit( const ast::VoidType * voidType ) {
505	printQualifiers( voidType );
506	mangleName += Encoding::void_t;
507	}
508
509	void Mangler_new::postvisit( const ast::BasicType * basicType ) {
510	printQualifiers( basicType );
511	assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
512	mangleName += Encoding::basicTypes[ basicType->kind ];
513	}
514
515	void Mangler_new::postvisit( const ast::PointerType * pointerType ) {
516	printQualifiers( pointerType );
517	// mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
518	if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName += Encoding::pointer;
519	maybe_accept( pointerType->base.get(), *visitor );
520	}
521
522	void Mangler_new::postvisit( const ast::ArrayType * arrayType ) {
523	// TODO: encode dimension
524	printQualifiers( arrayType );
525	mangleName += Encoding::array + "0";
526	maybeAccept( arrayType->base.get(), *visitor );
527	}
528
529	void Mangler_new::postvisit( const ast::ReferenceType * refType ) {
530	// don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
531	// Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
532	// by pretending every reference type is a function parameter.
533	GuardValue( inFunctionType );
534	inFunctionType = true;
535	printQualifiers( refType );
536	maybeAccept( refType->base.get(), *visitor );
537	}
538
539	inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
540	std::vector< ast::ptr< ast::Type > > ret;
541	std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
542	std::mem_fun( &ast::DeclWithType::get_type ) );
543	return ret;
544	}
545
546	void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
547	printQualifiers( functionType );
548	mangleName += Encoding::function;
549	// turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
550	// since qualifiers on outermost parameter type do not differentiate function types, e.g.,
551	// void ()(const int) and void ()(int) are the same type, but void ()(const int ) and void ()(int ) are different
552	GuardValue( inFunctionType );
553	inFunctionType = true;
554	if (functionType->returns.empty()) mangleName += Encoding::void_t;
555	else accept_each( functionType->returns, *visitor );
556	mangleName += "_";
557	accept_each( functionType->params, *visitor );
558	mangleName += "_";
559	}
560
561	void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
562	printQualifiers( refType );
563
564	mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
565
566	if ( mangleGenericParams ) {
567	if ( ! refType->params.empty() ) {
568	mangleName += "_";
569	for ( const ast::Expr * param : refType->params ) {
570	auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
571	assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
572	maybeAccept( paramType->type.get(), *visitor );
573	}
574	mangleName += "_";
575	}
576	}
577	}
578
579	void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) {
580	mangleRef( aggregateUseType, Encoding::struct_t );
581	}
582
583	void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) {
584	mangleRef( aggregateUseType, Encoding::union_t );
585	}
586
587	void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) {
588	mangleRef( aggregateUseType, Encoding::enum_t );
589	}
590
591	void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) {
592	VarMapType::iterator varNum = varNums.find( typeInst->name );
593	if ( varNum == varNums.end() ) {
594	mangleRef( typeInst, Encoding::type );
595	} else {
596	printQualifiers( typeInst );
597	// Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
598	// forall(dtype T) void f(T);
599	// forall(dtype S) void f(S);
600	// are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
601	// are first found and prefixing with the appropriate encoding for the type class.
602	assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
603	mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
604	} // if
605	}
606
607	void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
608	printQualifiers( inst );
609	mangleName += std::to_string( inst->name.size() ) + inst->name;
610	}
611
612	void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
613	printQualifiers( tupleType );
614	mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
615	accept_each( tupleType->types, *visitor );
616	}
617
618	void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) {
619	printQualifiers( varArgsType );
620	static const std::string vargs = "__builtin_va_list";
621	mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
622	}
623
624	void Mangler_new::postvisit( const ast::ZeroType * ) {
625	mangleName += Encoding::zero;
626	}
627
628	void Mangler_new::postvisit( const ast::OneType * ) {
629	mangleName += Encoding::one;
630	}
631
632	void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
633	bool inqual = inQualifiedType;
634	if (! inqual ) {
635	// N marks the start of a qualified type
636	inQualifiedType = true;
637	mangleName += Encoding::qualifiedTypeStart;
638	}
639	maybeAccept( qualType->parent.get(), *visitor );
640	maybeAccept( qualType->child.get(), *visitor );
641	if ( ! inqual ) {
642	// E marks the end of a qualified type
643	inQualifiedType = false;
644	mangleName += Encoding::qualifiedTypeEnd;
645	}
646	}
647
648	void Mangler_new::postvisit( const ast::TypeDecl * decl ) {
649	// TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
650	// fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
651	// Note: The current scheme may already work correctly for this case, I have not thought about this deeply
652	// and the case has not yet come up in practice. Alternatively, if not then this code can be removed
653	// aside from the assert false.
654	assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
655	assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
656	mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
657	}
658
659	__attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
660	for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
661	os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
662	} // for
663	}
664
665	void Mangler_new::printQualifiers( const ast::Type * type ) {
666	// skip if not including qualifiers
667	if ( typeMode ) return;
668	if ( auto ptype = dynamic_cast< const ast::FunctionType * >(type) ) {
669	if ( ! ptype->forall.empty() ) {
670	std::list< std::string > assertionNames;
671	int dcount = 0, fcount = 0, vcount = 0, acount = 0;
672	mangleName += Encoding::forall;
673	for ( auto & decl : ptype->forall ) {
674	switch ( decl->kind ) {
675	case ast::TypeDecl::Kind::Dtype:
676	dcount++;
677	break;
678	case ast::TypeDecl::Kind::Ftype:
679	fcount++;
680	break;
681	case ast::TypeDecl::Kind::Ttype:
682	vcount++;
683	break;
684	default:
685	assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[decl->kind].c_str() );
686	} // switch
687	varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
688	} // for
689	for ( auto & assert : ptype->assertions ) {
690	ast::Pass<Mangler_new> sub_mangler(
691	mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
692	assert->var->accept( sub_mangler );
693	assertionNames.push_back( sub_mangler.core.get_mangleName() );
694	acount++;
695	} // for
696	mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
697	for(const auto & a : assertionNames) mangleName += a;
698	// std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
699	mangleName += "_";
700	} // if
701	} // if
702	if ( ! inFunctionType ) {
703	// these qualifiers do not distinguish the outermost type of a function parameter
704	if ( type->is_const() ) {
705	mangleName += Encoding::qualifiers.at(Type::Const);
706	} // if
707	if ( type->is_volatile() ) {
708	mangleName += Encoding::qualifiers.at(Type::Volatile);
709	} // if
710	// Removed due to restrict not affecting function compatibility in GCC
711	// if ( type->get_isRestrict() ) {
712	// mangleName += "E";
713	// } // if
714	if ( type->is_atomic() ) {
715	mangleName += Encoding::qualifiers.at(Type::Atomic);
716	} // if
717	}
718	if ( type->is_mutex() ) {
719	mangleName += Encoding::qualifiers.at(Type::Mutex);
720	} // if
721	if ( inFunctionType ) {
722	// turn off inFunctionType so that types can be differentiated for nested qualifiers
723	GuardValue( inFunctionType );
724	inFunctionType = false;
725	}
726	}
727	} // namespace
728	} // namespace Mangle
729
730	// Local Variables: //
731	// tab-width: 4 //
732	// mode: c++ //
733	// compile-command: "make install" //
734	// End: //

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

Download in other formats: