Context Navigation

source: src/SymTab/Mangler.cc @ 7cf8006

ADTast-experimental

Last change on this file since 7cf8006 was 0026d67, checked in by Andrew Beach <ajbeach@…>, 2 years ago
Replaced Mangle::typeMode() with Mangle::mangleType(...), as it is how typeMode() was always used and it is shorter. Various other clean-up in the Mangler files.
Property mode set to `100644`
File size: 30.3 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 );
[98e8b3b]	441	void mangleRef( const ast::BaseInstType *refType, 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
[c19edd1]	537	__attribute__((unused))
[1346914]	538	inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
	539	std::vector< ast::ptr< ast::Type > > ret;
	540	std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
	541	std::mem_fun( &ast::DeclWithType::get_type ) );
	542	return ret;
[1867c96]	543	}
	544
[1346914]	545	void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
[1867c96]	546	printQualifiers( functionType );
[22b5b87]	547	mangleName += Encoding::function;
[1867c96]	548	// turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
	549	// since qualifiers on outermost parameter type do not differentiate function types, e.g.,
	550	// void ()(const int) and void ()(int) are the same type, but void ()(const int ) and void ()(int ) are different
	551	GuardValue( inFunctionType );
	552	inFunctionType = true;
[22b5b87]	553	if (functionType->returns.empty()) mangleName += Encoding::void_t;
[954c954]	554	else accept_each( functionType->returns, *visitor );
[22b5b87]	555	mangleName += "_";
[954c954]	556	accept_each( functionType->params, *visitor );
[22b5b87]	557	mangleName += "_";
[1867c96]	558	}
	559
[98e8b3b]	560	void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
[1867c96]	561	printQualifiers( refType );
	562
[22b5b87]	563	mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
[1867c96]	564
	565	if ( mangleGenericParams ) {
[1346914]	566	if ( ! refType->params.empty() ) {
[22b5b87]	567	mangleName += "_";
[1346914]	568	for ( const ast::Expr * param : refType->params ) {
	569	auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
	570	assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
[1867c96]	571	maybeAccept( paramType->type.get(), *visitor );
	572	}
[22b5b87]	573	mangleName += "_";
[1867c96]	574	}
	575	}
	576	}
	577
[1346914]	578	void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) {
[1867c96]	579	mangleRef( aggregateUseType, Encoding::struct_t );
	580	}
	581
[1346914]	582	void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) {
[1867c96]	583	mangleRef( aggregateUseType, Encoding::union_t );
	584	}
	585
[1346914]	586	void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) {
[1867c96]	587	mangleRef( aggregateUseType, Encoding::enum_t );
	588	}
	589
[1346914]	590	void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) {
[1867c96]	591	VarMapType::iterator varNum = varNums.find( typeInst->name );
	592	if ( varNum == varNums.end() ) {
	593	mangleRef( typeInst, Encoding::type );
	594	} else {
	595	printQualifiers( typeInst );
	596	// Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
	597	// forall(dtype T) void f(T);
	598	// forall(dtype S) void f(S);
	599	// are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
	600	// are first found and prefixing with the appropriate encoding for the type class.
	601	assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
[22b5b87]	602	mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
[1867c96]	603	} // if
	604	}
	605
[1346914]	606	void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
[1867c96]	607	printQualifiers( inst );
[22b5b87]	608	mangleName += std::to_string( inst->name.size() ) + inst->name;
[1867c96]	609	}
	610
[1346914]	611	void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
[1867c96]	612	printQualifiers( tupleType );
[22b5b87]	613	mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
[1346914]	614	accept_each( tupleType->types, *visitor );
[1867c96]	615	}
	616
[1346914]	617	void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) {
[1867c96]	618	printQualifiers( varArgsType );
	619	static const std::string vargs = "__builtin_va_list";
[22b5b87]	620	mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
[1867c96]	621	}
	622
[1346914]	623	void Mangler_new::postvisit( const ast::ZeroType * ) {
[22b5b87]	624	mangleName += Encoding::zero;
[1867c96]	625	}
	626
[1346914]	627	void Mangler_new::postvisit( const ast::OneType * ) {
[22b5b87]	628	mangleName += Encoding::one;
[1867c96]	629	}
	630
[1346914]	631	void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
[1867c96]	632	bool inqual = inQualifiedType;
	633	if (! inqual ) {
	634	// N marks the start of a qualified type
	635	inQualifiedType = true;
[22b5b87]	636	mangleName += Encoding::qualifiedTypeStart;
[1867c96]	637	}
	638	maybeAccept( qualType->parent.get(), *visitor );
	639	maybeAccept( qualType->child.get(), *visitor );
	640	if ( ! inqual ) {
	641	// E marks the end of a qualified type
	642	inQualifiedType = false;
[22b5b87]	643	mangleName += Encoding::qualifiedTypeEnd;
[1867c96]	644	}
	645	}
	646
[1346914]	647	void Mangler_new::postvisit( const ast::TypeDecl * decl ) {
[1867c96]	648	// TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
	649	// fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
	650	// Note: The current scheme may already work correctly for this case, I have not thought about this deeply
	651	// and the case has not yet come up in practice. Alternatively, if not then this code can be removed
	652	// aside from the assert false.
	653	assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
[07de76b]	654	assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
[22b5b87]	655	mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
[1867c96]	656	}
	657
	658	__attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
	659	for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
	660	os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
	661	} // for
	662	}
	663
[1346914]	664	void Mangler_new::printQualifiers( const ast::Type * type ) {
[1867c96]	665	// skip if not including qualifiers
	666	if ( typeMode ) return;
[361bf01]	667	if ( auto ptype = dynamic_cast< const ast::FunctionType * >(type) ) {
[1867c96]	668	if ( ! ptype->forall.empty() ) {
	669	std::list< std::string > assertionNames;
	670	int dcount = 0, fcount = 0, vcount = 0, acount = 0;
[22b5b87]	671	mangleName += Encoding::forall;
[3e5dd913]	672	for ( auto & decl : ptype->forall ) {
[1346914]	673	switch ( decl->kind ) {
[b66d14a]	674	case ast::TypeDecl::Kind::Dtype:
[1867c96]	675	dcount++;
	676	break;
[b66d14a]	677	case ast::TypeDecl::Kind::Ftype:
[1867c96]	678	fcount++;
	679	break;
[b66d14a]	680	case ast::TypeDecl::Kind::Ttype:
[1867c96]	681	vcount++;
	682	break;
[b66d14a]	683	default:
	684	assertf( false, "unimplemented kind for type variable %s", SymTab::Mangler::Encoding::typeVariables[decl->kind].c_str() );
[1867c96]	685	} // switch
[1346914]	686	varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
[3e5dd913]	687	} // for
	688	for ( auto & assert : ptype->assertions ) {
[0026d67]	689	assertionNames.push_back( ast::Pass<Mangler_new>::read(
	690	assert->var.get(),
	691	mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums ) );
[3e5dd913]	692	acount++;
[1867c96]	693	} // for
[22b5b87]	694	mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
	695	for(const auto & a : assertionNames) mangleName += a;
	696	// std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
	697	mangleName += "_";
[1867c96]	698	} // if
	699	} // if
	700	if ( ! inFunctionType ) {
	701	// these qualifiers do not distinguish the outermost type of a function parameter
	702	if ( type->is_const() ) {
[22b5b87]	703	mangleName += Encoding::qualifiers.at(Type::Const);
[1867c96]	704	} // if
	705	if ( type->is_volatile() ) {
[22b5b87]	706	mangleName += Encoding::qualifiers.at(Type::Volatile);
[1867c96]	707	} // if
	708	// Removed due to restrict not affecting function compatibility in GCC
	709	// if ( type->get_isRestrict() ) {
[22b5b87]	710	// mangleName += "E";
[1867c96]	711	// } // if
	712	if ( type->is_atomic() ) {
[22b5b87]	713	mangleName += Encoding::qualifiers.at(Type::Atomic);
[1867c96]	714	} // if
	715	}
	716	if ( type->is_mutex() ) {
[22b5b87]	717	mangleName += Encoding::qualifiers.at(Type::Mutex);
[1867c96]	718	} // if
	719	if ( inFunctionType ) {
	720	// turn off inFunctionType so that types can be differentiated for nested qualifiers
	721	GuardValue( inFunctionType );
	722	inFunctionType = false;
	723	}
	724	}
	725	} // namespace
[d76c588]	726	} // namespace Mangle
	727
[0dd3a2f]	728	// Local Variables: //
	729	// tab-width: 4 //
	730	// mode: c++ //
	731	// compile-command: "make install" //
	732	// End: //

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

Download in other formats: