Context Navigation

source: src/SymTab/Mangler.cc @ 6f096d2

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

Last change on this file since 6f096d2 was 6f096d2, checked in by Thierry Delisle <tdelisle@…>, 5 years ago
Resolver now uses constant interface
Property mode set to `100644`
File size: 30.2 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
[201aeb9]	11	// Last Modified By : Peter A. Buhr
	12	// Last Modified On : Mon Sep 25 15:49:26 2017
	13	// Update Count : 23
[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 "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...
[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
	67	std::string get_mangleName() { return mangleName.str(); }
	68	private:
	69	std::ostringstream 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
[642bc83]	129	mangleName << Encoding::manglePrefix;
[d7d9a60]	130	CodeGen::OperatorInfo opInfo;
	131	if ( operatorLookup( declaration->get_name(), opInfo ) ) {
[642bc83]	132	mangleName << opInfo.outputName.size() << opInfo.outputName;
[d7d9a60]	133	} else {
[642bc83]	134	mangleName << 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 ) {
[642bc83]	141	mangleName << Encoding::autogen;
[d7d9a60]	142	} else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
[642bc83]	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 );
[7804e2a]	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 );
	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
[642bc83]	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 );
[642bc83]	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 );
[642bc83]	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 );
[7804e2a]	213	if (returnTypes.empty()) mangleName << Encoding::void_t;
[d1e0979]	214	else acceptAll( returnTypes, *visitor );
[d7d9a60]	215	mangleName << "_";
[96812c0]	216	std::list< Type* > paramTypes = getTypes( functionType->parameters );
[d7d9a60]	217	acceptAll( paramTypes, *visitor );
[e35f30a]	218	mangleName << "_";
[d7d9a60]	219	}
	220
[6f096d2]	221	void Mangler_old::mangleRef( const ReferenceToType * refType, std::string prefix ) {
[d7d9a60]	222	printQualifiers( refType );
	223
[642bc83]	224	mangleName << prefix << refType->name.length() << refType->name;
[d7d9a60]	225
	226	if ( mangleGenericParams ) {
[6f096d2]	227	const std::list< Expression* > & params = refType->parameters;
[d7d9a60]	228	if ( ! params.empty() ) {
	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	}
	235	mangleName << "_";
	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 );
[0e761e40]	264	mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
[d7d9a60]	265	} // if
	266	}
	267
[6f096d2]	268	void Mangler_old::postvisit( const TraitInstType * inst ) {
[f465f0e]	269	printQualifiers( inst );
[642bc83]	270	mangleName << inst->name.size() << inst->name;
[f465f0e]	271	}
	272
[6f096d2]	273	void Mangler_old::postvisit( const TupleType * tupleType ) {
[d7d9a60]	274	printQualifiers( tupleType );
[642bc83]	275	mangleName << Encoding::tuple << 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";
[d8cb7df]	282	mangleName << Encoding::type << vargs.size() << vargs;
[d7d9a60]	283	}
	284
[6f096d2]	285	void Mangler_old::postvisit( const ZeroType * ) {
[642bc83]	286	mangleName << Encoding::zero;
[d7d9a60]	287	}
	288
[6f096d2]	289	void Mangler_old::postvisit( const OneType * ) {
[642bc83]	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;
	298	mangleName << Encoding::qualifiedTypeStart;
	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;
	305	mangleName << Encoding::qualifiedTypeEnd;
	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.
[1867c96]	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 );
	317	mangleName << Encoding::typeVariables[ decl->kind ] << ( 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;
	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:
	345	assert( false );
	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
[0e73845]	356	mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
[d7d9a60]	357	std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
	358	mangleName << "_";
	359	} // if
[c0453ca3]	360	if ( ! inFunctionType ) {
	361	// these qualifiers do not distinguish the outermost type of a function parameter
	362	if ( type->get_const() ) {
[642bc83]	363	mangleName << Encoding::qualifiers.at(Type::Const);
[c0453ca3]	364	} // if
	365	if ( type->get_volatile() ) {
[642bc83]	366	mangleName << Encoding::qualifiers.at(Type::Volatile);
[c0453ca3]	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() ) {
[642bc83]	373	mangleName << Encoding::qualifiers.at(Type::Atomic);
[c0453ca3]	374	} // if
	375	}
[d7d9a60]	376	if ( type->get_mutex() ) {
[642bc83]	377	mangleName << Encoding::qualifiers.at(Type::Mutex);
[d7d9a60]	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
[642bc83]	381	mangleName << Encoding::qualifiers.at(Type::Lvalue);
[d7d9a60]	382	}
[c0453ca3]	383
	384	if ( inFunctionType ) {
	385	// turn off inFunctionType so that types can be differentiated for nested qualifiers
	386	GuardValue( inFunctionType );
	387	inFunctionType = false;
	388	}
[d7d9a60]	389	}
	390	} // namespace
	391	} // namespace Mangler
[0dd3a2f]	392	} // namespace SymTab
	393
[d76c588]	394	namespace Mangle {
[1867c96]	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
[1346914]	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 );
[1867c96]	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:
[6f096d2]	438	Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
[1867c96]	439	int nextVarNum, const VarMapType& varNums );
	440	friend class ast::Pass<Mangler_new>;
	441
	442	private:
[1346914]	443	void mangleDecl( const ast::DeclWithType *declaration );
	444	void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
[1867c96]	445
[1346914]	446	void printQualifiers( const ast::Type *type );
[1867c96]	447	}; // Mangler_new
	448	} // namespace
	449
	450
[d76c588]	451	std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
[1867c96]	452	ast::Pass<Mangler_new> mangler( mode );
	453	maybeAccept( decl, mangler );
	454	return mangler.pass.get_mangleName();
[d76c588]	455	}
[1867c96]	456
	457	namespace {
	458	Mangler_new::Mangler_new( Mangle::Mode mode )
[6f096d2]	459	: nextVarNum( 0 ), isTopLevel( true ),
[1867c96]	460	mangleOverridable ( ! mode.no_overrideable ),
[6f096d2]	461	typeMode ( mode.type ),
[1867c96]	462	mangleGenericParams( ! mode.no_generic_params ) {}
[6f096d2]	463
	464	Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
[1867c96]	465	int nextVarNum, const VarMapType& varNums )
[6f096d2]	466	: varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
	467	mangleOverridable( mangleOverridable ), typeMode( typeMode ),
[1867c96]	468	mangleGenericParams( mangleGenericParams ) {}
	469
[1346914]	470	void Mangler_new::mangleDecl( const ast::DeclWithType * decl ) {
[1867c96]	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
[1346914]	500	void Mangler_new::postvisit( const ast::ObjectDecl * decl ) {
[1867c96]	501	mangleDecl( decl );
	502	}
	503
[1346914]	504	void Mangler_new::postvisit( const ast::FunctionDecl * decl ) {
[1867c96]	505	mangleDecl( decl );
	506	}
	507
[1346914]	508	void Mangler_new::postvisit( const ast::VoidType * voidType ) {
[1867c96]	509	printQualifiers( voidType );
	510	mangleName << Encoding::void_t;
	511	}
	512
[1346914]	513	void Mangler_new::postvisit( const ast::BasicType * basicType ) {
[1867c96]	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
[1346914]	519	void Mangler_new::postvisit( const ast::PointerType * pointerType ) {
[1867c96]	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
[1346914]	526	void Mangler_new::postvisit( const ast::ArrayType * arrayType ) {
[1867c96]	527	// TODO: encode dimension
	528	printQualifiers( arrayType );
	529	mangleName << Encoding::array << "0";
	530	maybeAccept( arrayType->base.get(), *visitor );
	531	}
	532
[1346914]	533	void Mangler_new::postvisit( const ast::ReferenceType * refType ) {
[1867c96]	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
[1346914]	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;
[1867c96]	548	}
	549
[1346914]	550	void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
[1867c96]	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;
[1346914]	560	else accept_each( returnTypes, *visitor );
[1867c96]	561	mangleName << "_";
	562	std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
[1346914]	563	accept_each( paramTypes, *visitor );
[1867c96]	564	mangleName << "_";
	565	}
	566
[1346914]	567	void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
[1867c96]	568	printQualifiers( refType );
	569
	570	mangleName << prefix << refType->name.length() << refType->name;
	571
	572	if ( mangleGenericParams ) {
[1346914]	573	if ( ! refType->params.empty() ) {
[1867c96]	574	mangleName << "_";
[1346914]	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));
[1867c96]	578	maybeAccept( paramType->type.get(), *visitor );
	579	}
	580	mangleName << "_";
	581	}
	582	}
	583	}
	584
[1346914]	585	void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) {
[1867c96]	586	mangleRef( aggregateUseType, Encoding::struct_t );
	587	}
	588
[1346914]	589	void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) {
[1867c96]	590	mangleRef( aggregateUseType, Encoding::union_t );
	591	}
	592
[1346914]	593	void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) {
[1867c96]	594	mangleRef( aggregateUseType, Encoding::enum_t );
	595	}
	596
[1346914]	597	void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) {
[1867c96]	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
[1346914]	613	void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
[1867c96]	614	printQualifiers( inst );
	615	mangleName << inst->name.size() << inst->name;
	616	}
	617
[1346914]	618	void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
[1867c96]	619	printQualifiers( tupleType );
	620	mangleName << Encoding::tuple << tupleType->types.size();
[1346914]	621	accept_each( tupleType->types, *visitor );
[1867c96]	622	}
	623
[1346914]	624	void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) {
[1867c96]	625	printQualifiers( varArgsType );
	626	static const std::string vargs = "__builtin_va_list";
	627	mangleName << Encoding::type << vargs.size() << vargs;
	628	}
	629
[1346914]	630	void Mangler_new::postvisit( const ast::ZeroType * ) {
[1867c96]	631	mangleName << Encoding::zero;
	632	}
	633
[1346914]	634	void Mangler_new::postvisit( const ast::OneType * ) {
[1867c96]	635	mangleName << Encoding::one;
	636	}
	637
[1346914]	638	void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
[1867c96]	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
[1346914]	654	void Mangler_new::postvisit( const ast::TypeDecl * decl ) {
[1867c96]	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
[1346914]	671	void Mangler_new::printQualifiers( const ast::Type * type ) {
[1867c96]	672	// skip if not including qualifiers
	673	if ( typeMode ) return;
[1346914]	674	if ( auto ptype = dynamic_cast< const ast::ParameterizedType * >(type) ) {
[1867c96]	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;
[1346914]	679	for ( const ast::TypeDecl * decl : ptype->forall ) {
	680	switch ( decl->kind ) {
	681	case ast::TypeVar::Kind::Dtype:
[1867c96]	682	dcount++;
	683	break;
[1346914]	684	case ast::TypeVar::Kind::Ftype:
[1867c96]	685	fcount++;
	686	break;
[1346914]	687	case ast::TypeVar::Kind::Ttype:
[1867c96]	688	vcount++;
	689	break;
[1346914]	690	default:
[1867c96]	691	assert( false );
	692	} // switch
[1346914]	693	varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
	694	for ( const ast::DeclWithType * assert : decl->assertions ) {
[6f096d2]	695	ast::Pass<Mangler_new> sub_mangler(
[1867c96]	696	mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
[1346914]	697	assert->accept( sub_mangler );
[1867c96]	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
[d76c588]	738	} // namespace Mangle
	739
[0dd3a2f]	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: