source: src/SymTab/Mangler.cc @ 1346914

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 1346914 was 1346914, checked in by Aaron Moss <a3moss@…>, 3 years ago

Fix Mangler port to new AST

  • Property mode set to 100644
File size: 30.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Mangler.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 21:40:29 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Mon Sep 25 15:49:26 2017
13// Update Count     : 23
14//
15#include "Mangler.h"
16
17#include <algorithm>                     // for copy, transform
18#include <cassert>                       // for assert, assertf
19#include <functional>                    // for const_mem_fun_t, mem_fun
20#include <iterator>                      // for ostream_iterator, back_insert_ite...
21#include <list>                          // for _List_iterator, list, _List_const...
22#include <string>                        // for string, char_traits, operator<<
23
24#include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
25#include "Common/PassVisitor.h"
26#include "Common/SemanticError.h"        // for SemanticError
27#include "Common/utility.h"              // for toString
28#include "Parser/LinkageSpec.h"          // for Spec, isOverridable, AutoGen, Int...
29#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
30#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
31#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
32#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
33
34#include "AST/Pass.hpp"
35
36namespace SymTab {
37        namespace Mangler {
38                namespace {
39                        /// Mangles names to a unique C identifier
40                        struct Mangler_old : public WithShortCircuiting, public WithVisitorRef<Mangler_old>, public WithGuards {
41                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
42                                Mangler_old( const Mangler_old & ) = delete;
43
44                                void previsit( BaseSyntaxNode * ) { visit_children = false; }
45
46                                void postvisit( ObjectDecl * declaration );
47                                void postvisit( FunctionDecl * declaration );
48                                void postvisit( TypeDecl * declaration );
49
50                                void postvisit( VoidType * voidType );
51                                void postvisit( BasicType * basicType );
52                                void postvisit( PointerType * pointerType );
53                                void postvisit( ArrayType * arrayType );
54                                void postvisit( ReferenceType * refType );
55                                void postvisit( FunctionType * functionType );
56                                void postvisit( StructInstType * aggregateUseType );
57                                void postvisit( UnionInstType * aggregateUseType );
58                                void postvisit( EnumInstType * aggregateUseType );
59                                void postvisit( TypeInstType * aggregateUseType );
60                                void postvisit( TraitInstType * inst );
61                                void postvisit( TupleType * tupleType );
62                                void postvisit( VarArgsType * varArgsType );
63                                void postvisit( ZeroType * zeroType );
64                                void postvisit( OneType * oneType );
65                                void postvisit( QualifiedType * qualType );
66
67                                std::string get_mangleName() { return mangleName.str(); }
68                          private:
69                                std::ostringstream mangleName;  ///< Mangled name being constructed
70                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
71                                VarMapType varNums;             ///< Map of type variables to indices
72                                int nextVarNum;                 ///< Next type variable index
73                                bool isTopLevel;                ///< Is the Mangler at the top level
74                                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
75                                bool typeMode;                  ///< Produce a unique mangled name for a type
76                                bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
77                                bool inFunctionType = false;    ///< Include type qualifiers if false.
78                                bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
79
80                          public:
81                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
82                                        int nextVarNum, const VarMapType& varNums );
83
84                          private:
85                                void mangleDecl( DeclarationWithType *declaration );
86                                void mangleRef( ReferenceToType *refType, std::string prefix );
87
88                                void printQualifiers( Type *type );
89                        }; // Mangler_old
90                } // namespace
91
92                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
93                        PassVisitor<Mangler_old> mangler( mangleOverridable, typeMode, mangleGenericParams );
94                        maybeAccept( decl, mangler );
95                        return mangler.pass.get_mangleName();
96                }
97
98                std::string mangleType( Type * ty ) {
99                        PassVisitor<Mangler_old> mangler( false, true, true );
100                        maybeAccept( ty, mangler );
101                        return mangler.pass.get_mangleName();
102                }
103
104                std::string mangleConcrete( Type * ty ) {
105                        PassVisitor<Mangler_old> mangler( false, false, false );
106                        maybeAccept( ty, mangler );
107                        return mangler.pass.get_mangleName();
108                }
109
110                namespace {
111                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
112                                : nextVarNum( 0 ), isTopLevel( true ), 
113                                mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
114                                mangleGenericParams( mangleGenericParams ) {}
115                       
116                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
117                                int nextVarNum, const VarMapType& varNums )
118                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ), 
119                                mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
120                                mangleGenericParams( mangleGenericParams ) {}
121
122                        void Mangler_old::mangleDecl( DeclarationWithType * declaration ) {
123                                bool wasTopLevel = isTopLevel;
124                                if ( isTopLevel ) {
125                                        varNums.clear();
126                                        nextVarNum = 0;
127                                        isTopLevel = false;
128                                } // if
129                                mangleName << Encoding::manglePrefix;
130                                CodeGen::OperatorInfo opInfo;
131                                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
132                                        mangleName << opInfo.outputName.size() << opInfo.outputName;
133                                } else {
134                                        mangleName << declaration->name.size() << declaration->name;
135                                } // if
136                                maybeAccept( declaration->get_type(), *visitor );
137                                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
138                                        // want to be able to override autogenerated and intrinsic routines,
139                                        // so they need a different name mangling
140                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
141                                                mangleName << Encoding::autogen;
142                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
143                                                mangleName << Encoding::intrinsic;
144                                        } else {
145                                                // if we add another kind of overridable function, this has to change
146                                                assert( false && "unknown overrideable linkage" );
147                                        } // if
148                                }
149                                isTopLevel = wasTopLevel;
150                        }
151
152                        void Mangler_old::postvisit( ObjectDecl * declaration ) {
153                                mangleDecl( declaration );
154                        }
155
156                        void Mangler_old::postvisit( FunctionDecl * declaration ) {
157                                mangleDecl( declaration );
158                        }
159
160                        void Mangler_old::postvisit( VoidType * voidType ) {
161                                printQualifiers( voidType );
162                                mangleName << Encoding::void_t;
163                        }
164
165                        void Mangler_old::postvisit( BasicType * basicType ) {
166                                printQualifiers( basicType );
167                                assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
168                                mangleName << Encoding::basicTypes[ basicType->get_kind() ];
169                        }
170
171                        void Mangler_old::postvisit( PointerType * pointerType ) {
172                                printQualifiers( pointerType );
173                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
174                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << Encoding::pointer;
175                                maybeAccept( pointerType->base, *visitor );
176                        }
177
178                        void Mangler_old::postvisit( ArrayType * arrayType ) {
179                                // TODO: encode dimension
180                                printQualifiers( arrayType );
181                                mangleName << Encoding::array << "0";
182                                maybeAccept( arrayType->base, *visitor );
183                        }
184
185                        void Mangler_old::postvisit( ReferenceType * refType ) {
186                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
187                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
188                                // by pretending every reference type is a function parameter.
189                                GuardValue( inFunctionType );
190                                inFunctionType = true;
191                                printQualifiers( refType );
192                                maybeAccept( refType->base, *visitor );
193                        }
194
195                        namespace {
196                                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
197                                        std::list< Type* > ret;
198                                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
199                                                                        std::mem_fun( &DeclarationWithType::get_type ) );
200                                        return ret;
201                                }
202                        }
203
204                        void Mangler_old::postvisit( FunctionType * functionType ) {
205                                printQualifiers( functionType );
206                                mangleName << Encoding::function;
207                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
208                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
209                                // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
210                                GuardValue( inFunctionType );
211                                inFunctionType = true;
212                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
213                                if (returnTypes.empty()) mangleName << Encoding::void_t;
214                                else acceptAll( returnTypes, *visitor );
215                                mangleName << "_";
216                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
217                                acceptAll( paramTypes, *visitor );
218                                mangleName << "_";
219                        }
220
221                        void Mangler_old::mangleRef( ReferenceToType * refType, std::string prefix ) {
222                                printQualifiers( refType );
223
224                                mangleName << prefix << refType->name.length() << refType->name;
225
226                                if ( mangleGenericParams ) {
227                                        std::list< Expression* >& params = refType->parameters;
228                                        if ( ! params.empty() ) {
229                                                mangleName << "_";
230                                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
231                                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
232                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
233                                                        maybeAccept( paramType->type, *visitor );
234                                                }
235                                                mangleName << "_";
236                                        }
237                                }
238                        }
239
240                        void Mangler_old::postvisit( StructInstType * aggregateUseType ) {
241                                mangleRef( aggregateUseType, Encoding::struct_t );
242                        }
243
244                        void Mangler_old::postvisit( UnionInstType * aggregateUseType ) {
245                                mangleRef( aggregateUseType, Encoding::union_t );
246                        }
247
248                        void Mangler_old::postvisit( EnumInstType * aggregateUseType ) {
249                                mangleRef( aggregateUseType, Encoding::enum_t );
250                        }
251
252                        void Mangler_old::postvisit( TypeInstType * typeInst ) {
253                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
254                                if ( varNum == varNums.end() ) {
255                                        mangleRef( typeInst, Encoding::type );
256                                } else {
257                                        printQualifiers( typeInst );
258                                        // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
259                                        //   forall(dtype T) void f(T);
260                                        //   forall(dtype S) void f(S);
261                                        // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
262                                        // are first found and prefixing with the appropriate encoding for the type class.
263                                        assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
264                                        mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
265                                } // if
266                        }
267
268                        void Mangler_old::postvisit( TraitInstType * inst ) {
269                                printQualifiers( inst );
270                                mangleName << inst->name.size() << inst->name;
271                        }
272
273                        void Mangler_old::postvisit( TupleType * tupleType ) {
274                                printQualifiers( tupleType );
275                                mangleName << Encoding::tuple << tupleType->types.size();
276                                acceptAll( tupleType->types, *visitor );
277                        }
278
279                        void Mangler_old::postvisit( VarArgsType * varArgsType ) {
280                                printQualifiers( varArgsType );
281                                static const std::string vargs = "__builtin_va_list";
282                                mangleName << Encoding::type << vargs.size() << vargs;
283                        }
284
285                        void Mangler_old::postvisit( ZeroType * ) {
286                                mangleName << Encoding::zero;
287                        }
288
289                        void Mangler_old::postvisit( OneType * ) {
290                                mangleName << Encoding::one;
291                        }
292
293                        void Mangler_old::postvisit( QualifiedType * qualType ) {
294                                bool inqual = inQualifiedType;
295                                if (! inqual ) {
296                                        // N marks the start of a qualified type
297                                        inQualifiedType = true;
298                                        mangleName << Encoding::qualifiedTypeStart;
299                                }
300                                maybeAccept( qualType->parent, *visitor );
301                                maybeAccept( qualType->child, *visitor );
302                                if ( ! inqual ) {
303                                        // E marks the end of a qualified type
304                                        inQualifiedType = false;
305                                        mangleName << Encoding::qualifiedTypeEnd;
306                                }
307                        }
308
309                        void Mangler_old::postvisit( TypeDecl * decl ) {
310                                // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
311                                // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
312                                // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
313                                // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
314                                // aside from the assert false.
315                                assertf(false, "Mangler_old should not visit typedecl: %s", toCString(decl));
316                                assertf( decl->get_kind() < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->get_kind() );
317                                mangleName << Encoding::typeVariables[ decl->get_kind() ] << ( decl->name.length() ) << decl->name;
318                        }
319
320                        __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
321                                for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
322                                        os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
323                                } // for
324                        }
325
326                        void Mangler_old::printQualifiers( Type * type ) {
327                                // skip if not including qualifiers
328                                if ( typeMode ) return;
329                                if ( ! type->get_forall().empty() ) {
330                                        std::list< std::string > assertionNames;
331                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
332                                        mangleName << Encoding::forall;
333                                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
334                                                switch ( (*i)->get_kind() ) {
335                                                  case TypeDecl::Dtype:
336                                                        dcount++;
337                                                        break;
338                                                  case TypeDecl::Ftype:
339                                                        fcount++;
340                                                        break;
341                                                  case TypeDecl::Ttype:
342                                                        vcount++;
343                                                        break;
344                                                  default:
345                                                        assert( false );
346                                                } // switch
347                                                varNums[ (*i)->name ] = std::make_pair( nextVarNum, (int)(*i)->get_kind() );
348                                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
349                                                        PassVisitor<Mangler_old> sub_mangler( 
350                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
351                                                        (*assert)->accept( sub_mangler );
352                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
353                                                        acount++;
354                                                } // for
355                                        } // for
356                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
357                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
358                                        mangleName << "_";
359                                } // if
360                                if ( ! inFunctionType ) {
361                                        // these qualifiers do not distinguish the outermost type of a function parameter
362                                        if ( type->get_const() ) {
363                                                mangleName << Encoding::qualifiers.at(Type::Const);
364                                        } // if
365                                        if ( type->get_volatile() ) {
366                                                mangleName << Encoding::qualifiers.at(Type::Volatile);
367                                        } // if
368                                        // Removed due to restrict not affecting function compatibility in GCC
369                                        // if ( type->get_isRestrict() ) {
370                                        //      mangleName << "E";
371                                        // } // if
372                                        if ( type->get_atomic() ) {
373                                                mangleName << Encoding::qualifiers.at(Type::Atomic);
374                                        } // if
375                                }
376                                if ( type->get_mutex() ) {
377                                        mangleName << Encoding::qualifiers.at(Type::Mutex);
378                                } // if
379                                if ( type->get_lvalue() ) {
380                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
381                                        mangleName << Encoding::qualifiers.at(Type::Lvalue);
382                                }
383
384                                if ( inFunctionType ) {
385                                        // turn off inFunctionType so that types can be differentiated for nested qualifiers
386                                        GuardValue( inFunctionType );
387                                        inFunctionType = false;
388                                }
389                        }
390                }       // namespace
391        } // namespace Mangler
392} // namespace SymTab
393
394namespace Mangle {
395        namespace {
396                /// Mangles names to a unique C identifier
397                struct Mangler_new : public ast::WithShortCircuiting, public ast::WithVisitorRef<Mangler_new>, public ast::WithGuards {
398                        Mangler_new( Mangle::Mode mode );
399                        Mangler_new( const Mangler_new & ) = delete;
400
401                        void previsit( const ast::Node * ) { visit_children = false; }
402
403                        void postvisit( const ast::ObjectDecl * declaration );
404                        void postvisit( const ast::FunctionDecl * declaration );
405                        void postvisit( const ast::TypeDecl * declaration );
406
407                        void postvisit( const ast::VoidType * voidType );
408                        void postvisit( const ast::BasicType * basicType );
409                        void postvisit( const ast::PointerType * pointerType );
410                        void postvisit( const ast::ArrayType * arrayType );
411                        void postvisit( const ast::ReferenceType * refType );
412                        void postvisit( const ast::FunctionType * functionType );
413                        void postvisit( const ast::StructInstType * aggregateUseType );
414                        void postvisit( const ast::UnionInstType * aggregateUseType );
415                        void postvisit( const ast::EnumInstType * aggregateUseType );
416                        void postvisit( const ast::TypeInstType * aggregateUseType );
417                        void postvisit( const ast::TraitInstType * inst );
418                        void postvisit( const ast::TupleType * tupleType );
419                        void postvisit( const ast::VarArgsType * varArgsType );
420                        void postvisit( const ast::ZeroType * zeroType );
421                        void postvisit( const ast::OneType * oneType );
422                        void postvisit( const ast::QualifiedType * qualType );
423
424                        std::string get_mangleName() { return mangleName.str(); }
425                  private:
426                        std::ostringstream mangleName;  ///< Mangled name being constructed
427                        typedef std::map< std::string, std::pair< int, int > > VarMapType;
428                        VarMapType varNums;             ///< Map of type variables to indices
429                        int nextVarNum;                 ///< Next type variable index
430                        bool isTopLevel;                ///< Is the Mangler at the top level
431                        bool mangleOverridable;         ///< Specially mangle overridable built-in methods
432                        bool typeMode;                  ///< Produce a unique mangled name for a type
433                        bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
434                        bool inFunctionType = false;    ///< Include type qualifiers if false.
435                        bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
436
437                  private:
438                        Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
439                                int nextVarNum, const VarMapType& varNums );
440                        friend class ast::Pass<Mangler_new>;
441
442                  private:
443                        void mangleDecl( const ast::DeclWithType *declaration );
444                        void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
445
446                        void printQualifiers( const ast::Type *type );
447                }; // Mangler_new
448        } // namespace
449
450
451        std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
452                ast::Pass<Mangler_new> mangler( mode );
453                maybeAccept( decl, mangler );
454                return mangler.pass.get_mangleName();
455        }
456
457        namespace {
458                Mangler_new::Mangler_new( Mangle::Mode mode )
459                        : nextVarNum( 0 ), isTopLevel( true ), 
460                        mangleOverridable  ( ! mode.no_overrideable   ),
461                        typeMode           (   mode.type              ), 
462                        mangleGenericParams( ! mode.no_generic_params ) {}
463               
464                Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
465                        int nextVarNum, const VarMapType& varNums )
466                        : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ), 
467                        mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
468                        mangleGenericParams( mangleGenericParams ) {}
469
470                void Mangler_new::mangleDecl( const ast::DeclWithType * decl ) {
471                        bool wasTopLevel = isTopLevel;
472                        if ( isTopLevel ) {
473                                varNums.clear();
474                                nextVarNum = 0;
475                                isTopLevel = false;
476                        } // if
477                        mangleName << Encoding::manglePrefix;
478                        CodeGen::OperatorInfo opInfo;
479                        if ( operatorLookup( decl->name, opInfo ) ) {
480                                mangleName << opInfo.outputName.size() << opInfo.outputName;
481                        } else {
482                                mangleName << decl->name.size() << decl->name;
483                        } // if
484                        maybeAccept( decl->get_type(), *visitor );
485                        if ( mangleOverridable && decl->linkage.is_overrideable ) {
486                                // want to be able to override autogenerated and intrinsic routines,
487                                // so they need a different name mangling
488                                if ( decl->linkage == ast::Linkage::AutoGen ) {
489                                        mangleName << Encoding::autogen;
490                                } else if ( decl->linkage == ast::Linkage::Intrinsic ) {
491                                        mangleName << Encoding::intrinsic;
492                                } else {
493                                        // if we add another kind of overridable function, this has to change
494                                        assert( false && "unknown overrideable linkage" );
495                                } // if
496                        }
497                        isTopLevel = wasTopLevel;
498                }
499
500                void Mangler_new::postvisit( const ast::ObjectDecl * decl ) {
501                        mangleDecl( decl );
502                }
503
504                void Mangler_new::postvisit( const ast::FunctionDecl * decl ) {
505                        mangleDecl( decl );
506                }
507
508                void Mangler_new::postvisit( const ast::VoidType * voidType ) {
509                        printQualifiers( voidType );
510                        mangleName << Encoding::void_t;
511                }
512
513                void Mangler_new::postvisit( const ast::BasicType * basicType ) {
514                        printQualifiers( basicType );
515                        assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
516                        mangleName << Encoding::basicTypes[ basicType->kind ];
517                }
518
519                void Mangler_new::postvisit( const ast::PointerType * pointerType ) {
520                        printQualifiers( pointerType );
521                        // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
522                        if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName << Encoding::pointer;
523                        maybe_accept( pointerType->base.get(), *visitor );
524                }
525
526                void Mangler_new::postvisit( const ast::ArrayType * arrayType ) {
527                        // TODO: encode dimension
528                        printQualifiers( arrayType );
529                        mangleName << Encoding::array << "0";
530                        maybeAccept( arrayType->base.get(), *visitor );
531                }
532
533                void Mangler_new::postvisit( const ast::ReferenceType * refType ) {
534                        // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
535                        // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
536                        // by pretending every reference type is a function parameter.
537                        GuardValue( inFunctionType );
538                        inFunctionType = true;
539                        printQualifiers( refType );
540                        maybeAccept( refType->base.get(), *visitor );
541                }
542
543                inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
544                        std::vector< ast::ptr< ast::Type > > ret;
545                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
546                                                        std::mem_fun( &ast::DeclWithType::get_type ) );
547                        return ret;
548                }
549
550                void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
551                        printQualifiers( functionType );
552                        mangleName << Encoding::function;
553                        // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
554                        // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
555                        // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
556                        GuardValue( inFunctionType );
557                        inFunctionType = true;
558                        std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
559                        if (returnTypes.empty()) mangleName << Encoding::void_t;
560                        else accept_each( returnTypes, *visitor );
561                        mangleName << "_";
562                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
563                        accept_each( paramTypes, *visitor );
564                        mangleName << "_";
565                }
566
567                void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
568                        printQualifiers( refType );
569
570                        mangleName << prefix << refType->name.length() << refType->name;
571
572                        if ( mangleGenericParams ) {
573                                if ( ! refType->params.empty() ) {
574                                        mangleName << "_";
575                                        for ( const ast::Expr * param : refType->params ) {
576                                                auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
577                                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
578                                                maybeAccept( paramType->type.get(), *visitor );
579                                        }
580                                        mangleName << "_";
581                                }
582                        }
583                }
584
585                void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) {
586                        mangleRef( aggregateUseType, Encoding::struct_t );
587                }
588
589                void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) {
590                        mangleRef( aggregateUseType, Encoding::union_t );
591                }
592
593                void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) {
594                        mangleRef( aggregateUseType, Encoding::enum_t );
595                }
596
597                void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) {
598                        VarMapType::iterator varNum = varNums.find( typeInst->name );
599                        if ( varNum == varNums.end() ) {
600                                mangleRef( typeInst, Encoding::type );
601                        } else {
602                                printQualifiers( typeInst );
603                                // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
604                                //   forall(dtype T) void f(T);
605                                //   forall(dtype S) void f(S);
606                                // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
607                                // are first found and prefixing with the appropriate encoding for the type class.
608                                assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
609                                mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
610                        } // if
611                }
612
613                void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
614                        printQualifiers( inst );
615                        mangleName << inst->name.size() << inst->name;
616                }
617
618                void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
619                        printQualifiers( tupleType );
620                        mangleName << Encoding::tuple << tupleType->types.size();
621                        accept_each( tupleType->types, *visitor );
622                }
623
624                void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) {
625                        printQualifiers( varArgsType );
626                        static const std::string vargs = "__builtin_va_list";
627                        mangleName << Encoding::type << vargs.size() << vargs;
628                }
629
630                void Mangler_new::postvisit( const ast::ZeroType * ) {
631                        mangleName << Encoding::zero;
632                }
633
634                void Mangler_new::postvisit( const ast::OneType * ) {
635                        mangleName << Encoding::one;
636                }
637
638                void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
639                        bool inqual = inQualifiedType;
640                        if (! inqual ) {
641                                // N marks the start of a qualified type
642                                inQualifiedType = true;
643                                mangleName << Encoding::qualifiedTypeStart;
644                        }
645                        maybeAccept( qualType->parent.get(), *visitor );
646                        maybeAccept( qualType->child.get(), *visitor );
647                        if ( ! inqual ) {
648                                // E marks the end of a qualified type
649                                inQualifiedType = false;
650                                mangleName << Encoding::qualifiedTypeEnd;
651                        }
652                }
653
654                void Mangler_new::postvisit( const ast::TypeDecl * decl ) {
655                        // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
656                        // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
657                        // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
658                        // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
659                        // aside from the assert false.
660                        assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
661                        assertf( decl->kind < ast::TypeVar::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
662                        mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
663                }
664
665                __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
666                        for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
667                                os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
668                        } // for
669                }
670
671                void Mangler_new::printQualifiers( const ast::Type * type ) {
672                        // skip if not including qualifiers
673                        if ( typeMode ) return;
674                        if ( auto ptype = dynamic_cast< const ast::ParameterizedType * >(type) ) {
675                                if ( ! ptype->forall.empty() ) {
676                                        std::list< std::string > assertionNames;
677                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
678                                        mangleName << Encoding::forall;
679                                        for ( const ast::TypeDecl * decl : ptype->forall ) {
680                                                switch ( decl->kind ) {
681                                                case ast::TypeVar::Kind::Dtype:
682                                                        dcount++;
683                                                        break;
684                                                case ast::TypeVar::Kind::Ftype:
685                                                        fcount++;
686                                                        break;
687                                                case ast::TypeVar::Kind::Ttype:
688                                                        vcount++;
689                                                        break;
690                                                default:
691                                                        assert( false );
692                                                } // switch
693                                                varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
694                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
695                                                        ast::Pass<Mangler_new> sub_mangler( 
696                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
697                                                        assert->accept( sub_mangler );
698                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
699                                                        acount++;
700                                                } // for
701                                        } // for
702                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
703                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
704                                        mangleName << "_";
705                                } // if
706                        } // if
707                        if ( ! inFunctionType ) {
708                                // these qualifiers do not distinguish the outermost type of a function parameter
709                                if ( type->is_const() ) {
710                                        mangleName << Encoding::qualifiers.at(Type::Const);
711                                } // if
712                                if ( type->is_volatile() ) {
713                                        mangleName << Encoding::qualifiers.at(Type::Volatile);
714                                } // if
715                                // Removed due to restrict not affecting function compatibility in GCC
716                                // if ( type->get_isRestrict() ) {
717                                //      mangleName << "E";
718                                // } // if
719                                if ( type->is_atomic() ) {
720                                        mangleName << Encoding::qualifiers.at(Type::Atomic);
721                                } // if
722                        }
723                        if ( type->is_mutex() ) {
724                                mangleName << Encoding::qualifiers.at(Type::Mutex);
725                        } // if
726                        if ( type->is_lvalue() ) {
727                                // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
728                                mangleName << Encoding::qualifiers.at(Type::Lvalue);
729                        }
730
731                        if ( inFunctionType ) {
732                                // turn off inFunctionType so that types can be differentiated for nested qualifiers
733                                GuardValue( inFunctionType );
734                                inFunctionType = false;
735                        }
736                }
737        }       // namespace
738} // namespace Mangle
739
740// Local Variables: //
741// tab-width: 4 //
742// mode: c++ //
743// compile-command: "make install" //
744// End: //
Note: See TracBrowser for help on using the repository browser.