Context Navigation

source: src/SymTab/Mangler.cc @ 2c8c314

ADTast-experimental

Last change on this file since 2c8c314 was 2c8c314, checked in by Andrew Beach <ajbeach@…>, 16 months ago
Clean-up in the name mangler.
Property mode set to `100644`
File size: 29.8 KB

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

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

Download in other formats: