Context Navigation

source: src/SymTab/Mangler.cc @ 1f1c102

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

Last change on this file since 1f1c102 was 1346914, checked in by Aaron Moss <a3moss@…>, 5 years ago
Fix Mangler port to new AST
Property mode set to `100644`
File size: 30.2 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 Sep 25 15:49:26 2017
13	// Update Count : 23
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 "Parser/LinkageSpec.h" // for Spec, isOverridable, AutoGen, Int...
29	#include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment
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( BaseSyntaxNode * ) { visit_children = false; }
45
46	void postvisit( ObjectDecl * declaration );
47	void postvisit( FunctionDecl * declaration );
48	void postvisit( TypeDecl * declaration );
49
50	void postvisit( VoidType * voidType );
51	void postvisit( BasicType * basicType );
52	void postvisit( PointerType * pointerType );
53	void postvisit( ArrayType * arrayType );
54	void postvisit( ReferenceType * refType );
55	void postvisit( FunctionType * functionType );
56	void postvisit( StructInstType * aggregateUseType );
57	void postvisit( UnionInstType * aggregateUseType );
58	void postvisit( EnumInstType * aggregateUseType );
59	void postvisit( TypeInstType * aggregateUseType );
60	void postvisit( TraitInstType * inst );
61	void postvisit( TupleType * tupleType );
62	void postvisit( VarArgsType * varArgsType );
63	void postvisit( ZeroType * zeroType );
64	void postvisit( OneType * oneType );
65	void postvisit( QualifiedType * qualType );
66
67	std::string get_mangleName() { return mangleName.str(); }
68	private:
69	std::ostringstream 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( DeclarationWithType *declaration );
86	void mangleRef( ReferenceToType *refType, std::string prefix );
87
88	void printQualifiers( Type *type );
89	}; // Mangler_old
90	} // namespace
91
92	std::string mangle( 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( 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( 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( 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	CodeGen::OperatorInfo opInfo;
131	if ( operatorLookup( declaration->get_name(), opInfo ) ) {
132	mangleName << opInfo.outputName.size() << opInfo.outputName;
133	} else {
134	mangleName << 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( ObjectDecl * declaration ) {
153	mangleDecl( declaration );
154	}
155
156	void Mangler_old::postvisit( FunctionDecl * declaration ) {
157	mangleDecl( declaration );
158	}
159
160	void Mangler_old::postvisit( VoidType * voidType ) {
161	printQualifiers( voidType );
162	mangleName << Encoding::void_t;
163	}
164
165	void Mangler_old::postvisit( BasicType * basicType ) {
166	printQualifiers( basicType );
167	assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
168	mangleName << Encoding::basicTypes[ basicType->get_kind() ];
169	}
170
171	void Mangler_old::postvisit( 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( 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( 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( 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( ReferenceToType * refType, std::string prefix ) {
222	printQualifiers( refType );
223
224	mangleName << prefix << refType->name.length() << refType->name;
225
226	if ( mangleGenericParams ) {
227	std::list< Expression* >& params = refType->parameters;
228	if ( ! params.empty() ) {
229	mangleName << "_";
230	for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
231	TypeExpr paramType = dynamic_cast< 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( StructInstType * aggregateUseType ) {
241	mangleRef( aggregateUseType, Encoding::struct_t );
242	}
243
244	void Mangler_old::postvisit( UnionInstType * aggregateUseType ) {
245	mangleRef( aggregateUseType, Encoding::union_t );
246	}
247
248	void Mangler_old::postvisit( EnumInstType * aggregateUseType ) {
249	mangleRef( aggregateUseType, Encoding::enum_t );
250	}
251
252	void Mangler_old::postvisit( 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] << varNum->second.first;
265	} // if
266	}
267
268	void Mangler_old::postvisit( TraitInstType * inst ) {
269	printQualifiers( inst );
270	mangleName << inst->name.size() << inst->name;
271	}
272
273	void Mangler_old::postvisit( TupleType * tupleType ) {
274	printQualifiers( tupleType );
275	mangleName << Encoding::tuple << tupleType->types.size();
276	acceptAll( tupleType->types, *visitor );
277	}
278
279	void Mangler_old::postvisit( VarArgsType * varArgsType ) {
280	printQualifiers( varArgsType );
281	static const std::string vargs = "__builtin_va_list";
282	mangleName << Encoding::type << vargs.size() << vargs;
283	}
284
285	void Mangler_old::postvisit( ZeroType * ) {
286	mangleName << Encoding::zero;
287	}
288
289	void Mangler_old::postvisit( OneType * ) {
290	mangleName << Encoding::one;
291	}
292
293	void Mangler_old::postvisit( 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( 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->get_kind() < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->get_kind() );
317	mangleName << Encoding::typeVariables[ decl->get_kind() ] << ( 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( Type * type ) {
327	// skip if not including qualifiers
328	if ( typeMode ) return;
329	if ( ! type->get_forall().empty() ) {
330	std::list< std::string > assertionNames;
331	int dcount = 0, fcount = 0, vcount = 0, acount = 0;
332	mangleName << Encoding::forall;
333	for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
334	switch ( (*i)->get_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	assert( false );
346	} // switch
347	varNums[ (i)->name ] = std::make_pair( nextVarNum, (int)(i)->get_kind() );
348	for ( std::list< DeclarationWithType* >::iterator assert = (i)->assertions.begin(); assert != (i)->assertions.end(); ++assert ) {
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 << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
357	std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
358	mangleName << "_";
359	} // if
360	if ( ! inFunctionType ) {
361	// these qualifiers do not distinguish the outermost type of a function parameter
362	if ( type->get_const() ) {
363	mangleName << Encoding::qualifiers.at(Type::Const);
364	} // if
365	if ( type->get_volatile() ) {
366	mangleName << Encoding::qualifiers.at(Type::Volatile);
367	} // if
368	// Removed due to restrict not affecting function compatibility in GCC
369	// if ( type->get_isRestrict() ) {
370	// mangleName << "E";
371	// } // if
372	if ( type->get_atomic() ) {
373	mangleName << Encoding::qualifiers.at(Type::Atomic);
374	} // if
375	}
376	if ( type->get_mutex() ) {
377	mangleName << Encoding::qualifiers.at(Type::Mutex);
378	} // if
379	if ( type->get_lvalue() ) {
380	// mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
381	mangleName << Encoding::qualifiers.at(Type::Lvalue);
382	}
383
384	if ( inFunctionType ) {
385	// turn off inFunctionType so that types can be differentiated for nested qualifiers
386	GuardValue( inFunctionType );
387	inFunctionType = false;
388	}
389	}
390	} // namespace
391	} // namespace Mangler
392	} // namespace SymTab
393
394	namespace Mangle {
395	namespace {
396	/// Mangles names to a unique C identifier
397	struct Mangler_new : public ast::WithShortCircuiting, public ast::WithVisitorRef<Mangler_new>, public ast::WithGuards {
398	Mangler_new( Mangle::Mode mode );
399	Mangler_new( const Mangler_new & ) = delete;
400
401	void previsit( const ast::Node * ) { visit_children = false; }
402
403	void postvisit( const ast::ObjectDecl * declaration );
404	void postvisit( const ast::FunctionDecl * declaration );
405	void postvisit( const ast::TypeDecl * declaration );
406
407	void postvisit( const ast::VoidType * voidType );
408	void postvisit( const ast::BasicType * basicType );
409	void postvisit( const ast::PointerType * pointerType );
410	void postvisit( const ast::ArrayType * arrayType );
411	void postvisit( const ast::ReferenceType * refType );
412	void postvisit( const ast::FunctionType * functionType );
413	void postvisit( const ast::StructInstType * aggregateUseType );
414	void postvisit( const ast::UnionInstType * aggregateUseType );
415	void postvisit( const ast::EnumInstType * aggregateUseType );
416	void postvisit( const ast::TypeInstType * aggregateUseType );
417	void postvisit( const ast::TraitInstType * inst );
418	void postvisit( const ast::TupleType * tupleType );
419	void postvisit( const ast::VarArgsType * varArgsType );
420	void postvisit( const ast::ZeroType * zeroType );
421	void postvisit( const ast::OneType * oneType );
422	void postvisit( const ast::QualifiedType * qualType );
423
424	std::string get_mangleName() { return mangleName.str(); }
425	private:
426	std::ostringstream mangleName; ///< Mangled name being constructed
427	typedef std::map< std::string, std::pair< int, int > > VarMapType;
428	VarMapType varNums; ///< Map of type variables to indices
429	int nextVarNum; ///< Next type variable index
430	bool isTopLevel; ///< Is the Mangler at the top level
431	bool mangleOverridable; ///< Specially mangle overridable built-in methods
432	bool typeMode; ///< Produce a unique mangled name for a type
433	bool mangleGenericParams; ///< Include generic parameters in name mangling if true
434	bool inFunctionType = false; ///< Include type qualifiers if false.
435	bool inQualifiedType = false; ///< Add start/end delimiters around qualified type
436
437	private:
438	Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
439	int nextVarNum, const VarMapType& varNums );
440	friend class ast::Pass<Mangler_new>;
441
442	private:
443	void mangleDecl( const ast::DeclWithType *declaration );
444	void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
445
446	void printQualifiers( const ast::Type *type );
447	}; // Mangler_new
448	} // namespace
449
450
451	std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
452	ast::Pass<Mangler_new> mangler( mode );
453	maybeAccept( decl, mangler );
454	return mangler.pass.get_mangleName();
455	}
456
457	namespace {
458	Mangler_new::Mangler_new( Mangle::Mode mode )
459	: nextVarNum( 0 ), isTopLevel( true ),
460	mangleOverridable ( ! mode.no_overrideable ),
461	typeMode ( mode.type ),
462	mangleGenericParams( ! mode.no_generic_params ) {}
463
464	Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
465	int nextVarNum, const VarMapType& varNums )
466	: varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
467	mangleOverridable( mangleOverridable ), typeMode( typeMode ),
468	mangleGenericParams( mangleGenericParams ) {}
469
470	void Mangler_new::mangleDecl( const ast::DeclWithType * decl ) {
471	bool wasTopLevel = isTopLevel;
472	if ( isTopLevel ) {
473	varNums.clear();
474	nextVarNum = 0;
475	isTopLevel = false;
476	} // if
477	mangleName << Encoding::manglePrefix;
478	CodeGen::OperatorInfo opInfo;
479	if ( operatorLookup( decl->name, opInfo ) ) {
480	mangleName << opInfo.outputName.size() << opInfo.outputName;
481	} else {
482	mangleName << decl->name.size() << decl->name;
483	} // if
484	maybeAccept( decl->get_type(), *visitor );
485	if ( mangleOverridable && decl->linkage.is_overrideable ) {
486	// want to be able to override autogenerated and intrinsic routines,
487	// so they need a different name mangling
488	if ( decl->linkage == ast::Linkage::AutoGen ) {
489	mangleName << Encoding::autogen;
490	} else if ( decl->linkage == ast::Linkage::Intrinsic ) {
491	mangleName << Encoding::intrinsic;
492	} else {
493	// if we add another kind of overridable function, this has to change
494	assert( false && "unknown overrideable linkage" );
495	} // if
496	}
497	isTopLevel = wasTopLevel;
498	}
499
500	void Mangler_new::postvisit( const ast::ObjectDecl * decl ) {
501	mangleDecl( decl );
502	}
503
504	void Mangler_new::postvisit( const ast::FunctionDecl * decl ) {
505	mangleDecl( decl );
506	}
507
508	void Mangler_new::postvisit( const ast::VoidType * voidType ) {
509	printQualifiers( voidType );
510	mangleName << Encoding::void_t;
511	}
512
513	void Mangler_new::postvisit( const ast::BasicType * basicType ) {
514	printQualifiers( basicType );
515	assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
516	mangleName << Encoding::basicTypes[ basicType->kind ];
517	}
518
519	void Mangler_new::postvisit( const ast::PointerType * pointerType ) {
520	printQualifiers( pointerType );
521	// mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
522	if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName << Encoding::pointer;
523	maybe_accept( pointerType->base.get(), *visitor );
524	}
525
526	void Mangler_new::postvisit( const ast::ArrayType * arrayType ) {
527	// TODO: encode dimension
528	printQualifiers( arrayType );
529	mangleName << Encoding::array << "0";
530	maybeAccept( arrayType->base.get(), *visitor );
531	}
532
533	void Mangler_new::postvisit( const ast::ReferenceType * refType ) {
534	// don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
535	// Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
536	// by pretending every reference type is a function parameter.
537	GuardValue( inFunctionType );
538	inFunctionType = true;
539	printQualifiers( refType );
540	maybeAccept( refType->base.get(), *visitor );
541	}
542
543	inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
544	std::vector< ast::ptr< ast::Type > > ret;
545	std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
546	std::mem_fun( &ast::DeclWithType::get_type ) );
547	return ret;
548	}
549
550	void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
551	printQualifiers( functionType );
552	mangleName << Encoding::function;
553	// turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
554	// since qualifiers on outermost parameter type do not differentiate function types, e.g.,
555	// void ()(const int) and void ()(int) are the same type, but void ()(const int ) and void ()(int ) are different
556	GuardValue( inFunctionType );
557	inFunctionType = true;
558	std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
559	if (returnTypes.empty()) mangleName << Encoding::void_t;
560	else accept_each( returnTypes, *visitor );
561	mangleName << "_";
562	std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
563	accept_each( paramTypes, *visitor );
564	mangleName << "_";
565	}
566
567	void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
568	printQualifiers( refType );
569
570	mangleName << prefix << refType->name.length() << refType->name;
571
572	if ( mangleGenericParams ) {
573	if ( ! refType->params.empty() ) {
574	mangleName << "_";
575	for ( const ast::Expr * param : refType->params ) {
576	auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
577	assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
578	maybeAccept( paramType->type.get(), *visitor );
579	}
580	mangleName << "_";
581	}
582	}
583	}
584
585	void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) {
586	mangleRef( aggregateUseType, Encoding::struct_t );
587	}
588
589	void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) {
590	mangleRef( aggregateUseType, Encoding::union_t );
591	}
592
593	void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) {
594	mangleRef( aggregateUseType, Encoding::enum_t );
595	}
596
597	void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) {
598	VarMapType::iterator varNum = varNums.find( typeInst->name );
599	if ( varNum == varNums.end() ) {
600	mangleRef( typeInst, Encoding::type );
601	} else {
602	printQualifiers( typeInst );
603	// Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
604	// forall(dtype T) void f(T);
605	// forall(dtype S) void f(S);
606	// are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
607	// are first found and prefixing with the appropriate encoding for the type class.
608	assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
609	mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
610	} // if
611	}
612
613	void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
614	printQualifiers( inst );
615	mangleName << inst->name.size() << inst->name;
616	}
617
618	void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
619	printQualifiers( tupleType );
620	mangleName << Encoding::tuple << tupleType->types.size();
621	accept_each( tupleType->types, *visitor );
622	}
623
624	void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) {
625	printQualifiers( varArgsType );
626	static const std::string vargs = "__builtin_va_list";
627	mangleName << Encoding::type << vargs.size() << vargs;
628	}
629
630	void Mangler_new::postvisit( const ast::ZeroType * ) {
631	mangleName << Encoding::zero;
632	}
633
634	void Mangler_new::postvisit( const ast::OneType * ) {
635	mangleName << Encoding::one;
636	}
637
638	void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
639	bool inqual = inQualifiedType;
640	if (! inqual ) {
641	// N marks the start of a qualified type
642	inQualifiedType = true;
643	mangleName << Encoding::qualifiedTypeStart;
644	}
645	maybeAccept( qualType->parent.get(), *visitor );
646	maybeAccept( qualType->child.get(), *visitor );
647	if ( ! inqual ) {
648	// E marks the end of a qualified type
649	inQualifiedType = false;
650	mangleName << Encoding::qualifiedTypeEnd;
651	}
652	}
653
654	void Mangler_new::postvisit( const ast::TypeDecl * decl ) {
655	// TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
656	// fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
657	// Note: The current scheme may already work correctly for this case, I have not thought about this deeply
658	// and the case has not yet come up in practice. Alternatively, if not then this code can be removed
659	// aside from the assert false.
660	assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
661	assertf( decl->kind < ast::TypeVar::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
662	mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
663	}
664
665	__attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
666	for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
667	os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
668	} // for
669	}
670
671	void Mangler_new::printQualifiers( const ast::Type * type ) {
672	// skip if not including qualifiers
673	if ( typeMode ) return;
674	if ( auto ptype = dynamic_cast< const ast::ParameterizedType * >(type) ) {
675	if ( ! ptype->forall.empty() ) {
676	std::list< std::string > assertionNames;
677	int dcount = 0, fcount = 0, vcount = 0, acount = 0;
678	mangleName << Encoding::forall;
679	for ( const ast::TypeDecl * decl : ptype->forall ) {
680	switch ( decl->kind ) {
681	case ast::TypeVar::Kind::Dtype:
682	dcount++;
683	break;
684	case ast::TypeVar::Kind::Ftype:
685	fcount++;
686	break;
687	case ast::TypeVar::Kind::Ttype:
688	vcount++;
689	break;
690	default:
691	assert( false );
692	} // switch
693	varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
694	for ( const ast::DeclWithType * assert : decl->assertions ) {
695	ast::Pass<Mangler_new> sub_mangler(
696	mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
697	assert->accept( sub_mangler );
698	assertionNames.push_back( sub_mangler.pass.get_mangleName() );
699	acount++;
700	} // for
701	} // for
702	mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
703	std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
704	mangleName << "_";
705	} // if
706	} // if
707	if ( ! inFunctionType ) {
708	// these qualifiers do not distinguish the outermost type of a function parameter
709	if ( type->is_const() ) {
710	mangleName << Encoding::qualifiers.at(Type::Const);
711	} // if
712	if ( type->is_volatile() ) {
713	mangleName << Encoding::qualifiers.at(Type::Volatile);
714	} // if
715	// Removed due to restrict not affecting function compatibility in GCC
716	// if ( type->get_isRestrict() ) {
717	// mangleName << "E";
718	// } // if
719	if ( type->is_atomic() ) {
720	mangleName << Encoding::qualifiers.at(Type::Atomic);
721	} // if
722	}
723	if ( type->is_mutex() ) {
724	mangleName << Encoding::qualifiers.at(Type::Mutex);
725	} // if
726	if ( type->is_lvalue() ) {
727	// mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
728	mangleName << Encoding::qualifiers.at(Type::Lvalue);
729	}
730
731	if ( inFunctionType ) {
732	// turn off inFunctionType so that types can be differentiated for nested qualifiers
733	GuardValue( inFunctionType );
734	inFunctionType = false;
735	}
736	}
737	} // namespace
738	} // namespace Mangle
739
740	// Local Variables: //
741	// tab-width: 4 //
742	// mode: c++ //
743	// compile-command: "make install" //
744	// End: //

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

Download in other formats: