source: src/SymTab/Mangler.cc@ b117e0c

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since b117e0c was 1346914, checked in by Aaron Moss <a3moss@…>, 6 years ago

Fix Mangler port to new AST
  • Property mode set to 100644
File size: 30.2 KB
RevLine 
[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...
[51b73452]33
[1867c96]34#include "AST/Pass.hpp"
35
[51b73452]36namespace 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
44 void previsit( BaseSyntaxNode * ) { visit_children = false; }
45
46 void postvisit( ObjectDecl * declaration );
47 void postvisit( FunctionDecl * declaration );
48 void postvisit( TypeDecl * declaration );
49
50 void postvisit( VoidType * voidType );
51 void postvisit( BasicType * basicType );
52 void postvisit( PointerType * pointerType );
53 void postvisit( ArrayType * arrayType );
54 void postvisit( ReferenceType * refType );
55 void postvisit( FunctionType * functionType );
56 void postvisit( StructInstType * aggregateUseType );
57 void postvisit( UnionInstType * aggregateUseType );
58 void postvisit( EnumInstType * aggregateUseType );
59 void postvisit( TypeInstType * aggregateUseType );
[f465f0e]60 void postvisit( TraitInstType * inst );
[d7d9a60]61 void postvisit( TupleType * tupleType );
62 void postvisit( VarArgsType * varArgsType );
63 void postvisit( ZeroType * zeroType );
64 void postvisit( OneType * oneType );
[e73becf]65 void postvisit( 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:
[1867c96]81 Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
[052cd71]82 int nextVarNum, const VarMapType& varNums );
[ff5caaf]83
[e1f7eef]84 private:
[d7d9a60]85 void mangleDecl( DeclarationWithType *declaration );
86 void mangleRef( ReferenceToType *refType, std::string prefix );
87
88 void printQualifiers( Type *type );
[1867c96]89 }; // Mangler_old
[d7d9a60]90 } // namespace
91
92 std::string mangle( 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
98 std::string mangleType( Type * ty ) {
[1867c96]99 PassVisitor<Mangler_old> mangler( false, true, true );
[d7d9a60]100 maybeAccept( ty, mangler );
101 return mangler.pass.get_mangleName();
102 }
103
104 std::string mangleConcrete( 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 )
[052cd71]112 : nextVarNum( 0 ), isTopLevel( true ),
[ff5caaf]113 mangleOverridable( mangleOverridable ), typeMode( typeMode ),
114 mangleGenericParams( mangleGenericParams ) {}
115
[1867c96]116 Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
[052cd71]117 int nextVarNum, const VarMapType& varNums )
118 : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
[ff5caaf]119 mangleOverridable( mangleOverridable ), typeMode( typeMode ),
120 mangleGenericParams( mangleGenericParams ) {}
[d7d9a60]121
[1867c96]122 void Mangler_old::mangleDecl( 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
[1867c96]152 void Mangler_old::postvisit( ObjectDecl * declaration ) {
[d7d9a60]153 mangleDecl( declaration );
154 }
155
[1867c96]156 void Mangler_old::postvisit( FunctionDecl * declaration ) {
[d7d9a60]157 mangleDecl( declaration );
158 }
159
[1867c96]160 void Mangler_old::postvisit( VoidType * voidType ) {
[d7d9a60]161 printQualifiers( voidType );
[7804e2a]162 mangleName << Encoding::void_t;
[d7d9a60]163 }
164
[1867c96]165 void Mangler_old::postvisit( BasicType * basicType ) {
[d7d9a60]166 printQualifiers( basicType );
[0e73845]167 assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
[642bc83]168 mangleName << Encoding::basicTypes[ basicType->get_kind() ];
[d7d9a60]169 }
170
[1867c96]171 void Mangler_old::postvisit( 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
[1867c96]178 void Mangler_old::postvisit( 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
[1867c96]185 void Mangler_old::postvisit( 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
[1867c96]204 void Mangler_old::postvisit( 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
[1867c96]221 void Mangler_old::mangleRef( ReferenceToType * refType, std::string prefix ) {
[d7d9a60]222 printQualifiers( refType );
223
[642bc83]224 mangleName << prefix << refType->name.length() << refType->name;
[d7d9a60]225
226 if ( mangleGenericParams ) {
[96812c0]227 std::list< Expression* >& params = refType->parameters;
[d7d9a60]228 if ( ! params.empty() ) {
229 mangleName << "_";
230 for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
231 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
[96812c0]232 assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
233 maybeAccept( paramType->type, *visitor );
[d7d9a60]234 }
235 mangleName << "_";
236 }
[e35f30a]237 }
[d7d9a60]238 }
239
[1867c96]240 void Mangler_old::postvisit( StructInstType * aggregateUseType ) {
[7804e2a]241 mangleRef( aggregateUseType, Encoding::struct_t );
[d7d9a60]242 }
243
[1867c96]244 void Mangler_old::postvisit( UnionInstType * aggregateUseType ) {
[7804e2a]245 mangleRef( aggregateUseType, Encoding::union_t );
[d7d9a60]246 }
247
[1867c96]248 void Mangler_old::postvisit( EnumInstType * aggregateUseType ) {
[7804e2a]249 mangleRef( aggregateUseType, Encoding::enum_t );
[d7d9a60]250 }
251
[1867c96]252 void Mangler_old::postvisit( 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
[1867c96]268 void Mangler_old::postvisit( TraitInstType * inst ) {
[f465f0e]269 printQualifiers( inst );
[642bc83]270 mangleName << inst->name.size() << inst->name;
[f465f0e]271 }
272
[1867c96]273 void Mangler_old::postvisit( TupleType * tupleType ) {
[d7d9a60]274 printQualifiers( tupleType );
[642bc83]275 mangleName << Encoding::tuple << tupleType->types.size();
[d7d9a60]276 acceptAll( tupleType->types, *visitor );
[8360977]277 }
[d7d9a60]278
[1867c96]279 void Mangler_old::postvisit( 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
[1867c96]285 void Mangler_old::postvisit( ZeroType * ) {
[642bc83]286 mangleName << Encoding::zero;
[d7d9a60]287 }
288
[1867c96]289 void Mangler_old::postvisit( OneType * ) {
[642bc83]290 mangleName << Encoding::one;
[d7d9a60]291 }
292
[1867c96]293 void Mangler_old::postvisit( 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
[1867c96]309 void Mangler_old::postvisit( 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));
[0e73845]316 assertf( decl->get_kind() < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->get_kind() );
317 mangleName << Encoding::typeVariables[ decl->get_kind() ] << ( decl->name.length() ) << decl->name;
[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
[1867c96]326 void Mangler_old::printQualifiers( Type * type ) {
[d7d9a60]327 // skip if not including qualifiers
328 if ( typeMode ) return;
329 if ( ! type->get_forall().empty() ) {
330 std::list< std::string > assertionNames;
[0e73845]331 int dcount = 0, fcount = 0, vcount = 0, acount = 0;
332 mangleName << Encoding::forall;
[d7d9a60]333 for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
334 switch ( (*i)->get_kind() ) {
335 case TypeDecl::Dtype:
336 dcount++;
337 break;
338 case TypeDecl::Ftype:
339 fcount++;
340 break;
341 case TypeDecl::Ttype:
342 vcount++;
343 break;
344 default:
345 assert( false );
346 } // switch
[052cd71]347 varNums[ (*i)->name ] = std::make_pair( nextVarNum, (int)(*i)->get_kind() );
[d7d9a60]348 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
[1867c96]349 PassVisitor<Mangler_old> sub_mangler(
[052cd71]350 mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
[d7d9a60]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]394namespace 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:
438 Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
439 int nextVarNum, const VarMapType& varNums );
440 friend class ast::Pass<Mangler_new>;
441
442 private:
[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 )
459 : nextVarNum( 0 ), isTopLevel( true ),
460 mangleOverridable ( ! mode.no_overrideable ),
461 typeMode ( mode.type ),
462 mangleGenericParams( ! mode.no_generic_params ) {}
463
464 Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
465 int nextVarNum, const VarMapType& varNums )
466 : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
467 mangleOverridable( mangleOverridable ), typeMode( typeMode ),
468 mangleGenericParams( mangleGenericParams ) {}
469
[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 ) {
[1867c96]695 ast::Pass<Mangler_new> sub_mangler(
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.