Changeset 1867c96


Ignore:
Timestamp:
Jun 4, 2019, 4:48:59 PM (3 years ago)
Author:
Michael Brooks <mlbrooks@…>
Branches:
arm-eh, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
9a19608
Parents:
98a8290
Message:

name mangler AST conversion implemented

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/SymTab/Mangler.cc

    r98a8290 r1867c96  
    3232#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
    3333
     34#include "AST/Pass.hpp"
     35
    3436namespace SymTab {
    3537        namespace Mangler {
    3638                namespace {
    3739                        /// Mangles names to a unique C identifier
    38                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
    39                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
    40                                 Mangler( const Mangler & ) = delete;
     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;
    4143
    4244                                void previsit( BaseSyntaxNode * ) { visit_children = false; }
     
    7779
    7880                          public:
    79                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
     81                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
    8082                                        int nextVarNum, const VarMapType& varNums );
    8183
     
    8587
    8688                                void printQualifiers( Type *type );
    87                         }; // Mangler
     89                        }; // Mangler_old
    8890                } // namespace
    8991
    9092                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
    91                         PassVisitor<Mangler> mangler( mangleOverridable, typeMode, mangleGenericParams );
     93                        PassVisitor<Mangler_old> mangler( mangleOverridable, typeMode, mangleGenericParams );
    9294                        maybeAccept( decl, mangler );
    9395                        return mangler.pass.get_mangleName();
     
    9597
    9698                std::string mangleType( Type * ty ) {
    97                         PassVisitor<Mangler> mangler( false, true, true );
     99                        PassVisitor<Mangler_old> mangler( false, true, true );
    98100                        maybeAccept( ty, mangler );
    99101                        return mangler.pass.get_mangleName();
     
    101103
    102104                std::string mangleConcrete( Type * ty ) {
    103                         PassVisitor<Mangler> mangler( false, false, false );
     105                        PassVisitor<Mangler_old> mangler( false, false, false );
    104106                        maybeAccept( ty, mangler );
    105107                        return mangler.pass.get_mangleName();
     
    107109
    108110                namespace {
    109                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
     111                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
    110112                                : nextVarNum( 0 ), isTopLevel( true ),
    111113                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
    112114                                mangleGenericParams( mangleGenericParams ) {}
    113115                       
    114                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
     116                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
    115117                                int nextVarNum, const VarMapType& varNums )
    116118                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
     
    118120                                mangleGenericParams( mangleGenericParams ) {}
    119121
    120                         void Mangler::mangleDecl( DeclarationWithType * declaration ) {
     122                        void Mangler_old::mangleDecl( DeclarationWithType * declaration ) {
    121123                                bool wasTopLevel = isTopLevel;
    122124                                if ( isTopLevel ) {
     
    148150                        }
    149151
    150                         void Mangler::postvisit( ObjectDecl * declaration ) {
     152                        void Mangler_old::postvisit( ObjectDecl * declaration ) {
    151153                                mangleDecl( declaration );
    152154                        }
    153155
    154                         void Mangler::postvisit( FunctionDecl * declaration ) {
     156                        void Mangler_old::postvisit( FunctionDecl * declaration ) {
    155157                                mangleDecl( declaration );
    156158                        }
    157159
    158                         void Mangler::postvisit( VoidType * voidType ) {
     160                        void Mangler_old::postvisit( VoidType * voidType ) {
    159161                                printQualifiers( voidType );
    160162                                mangleName << Encoding::void_t;
    161163                        }
    162164
    163                         void Mangler::postvisit( BasicType * basicType ) {
     165                        void Mangler_old::postvisit( BasicType * basicType ) {
    164166                                printQualifiers( basicType );
    165167                                assertf( basicType->get_kind() < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->get_kind() );
     
    167169                        }
    168170
    169                         void Mangler::postvisit( PointerType * pointerType ) {
     171                        void Mangler_old::postvisit( PointerType * pointerType ) {
    170172                                printQualifiers( pointerType );
    171173                                // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
     
    174176                        }
    175177
    176                         void Mangler::postvisit( ArrayType * arrayType ) {
     178                        void Mangler_old::postvisit( ArrayType * arrayType ) {
    177179                                // TODO: encode dimension
    178180                                printQualifiers( arrayType );
     
    181183                        }
    182184
    183                         void Mangler::postvisit( ReferenceType * refType ) {
     185                        void Mangler_old::postvisit( ReferenceType * refType ) {
    184186                                // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
    185187                                // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
     
    200202                        }
    201203
    202                         void Mangler::postvisit( FunctionType * functionType ) {
     204                        void Mangler_old::postvisit( FunctionType * functionType ) {
    203205                                printQualifiers( functionType );
    204206                                mangleName << Encoding::function;
     
    217219                        }
    218220
    219                         void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
     221                        void Mangler_old::mangleRef( ReferenceToType * refType, std::string prefix ) {
    220222                                printQualifiers( refType );
    221223
     
    236238                        }
    237239
    238                         void Mangler::postvisit( StructInstType * aggregateUseType ) {
     240                        void Mangler_old::postvisit( StructInstType * aggregateUseType ) {
    239241                                mangleRef( aggregateUseType, Encoding::struct_t );
    240242                        }
    241243
    242                         void Mangler::postvisit( UnionInstType * aggregateUseType ) {
     244                        void Mangler_old::postvisit( UnionInstType * aggregateUseType ) {
    243245                                mangleRef( aggregateUseType, Encoding::union_t );
    244246                        }
    245247
    246                         void Mangler::postvisit( EnumInstType * aggregateUseType ) {
     248                        void Mangler_old::postvisit( EnumInstType * aggregateUseType ) {
    247249                                mangleRef( aggregateUseType, Encoding::enum_t );
    248250                        }
    249251
    250                         void Mangler::postvisit( TypeInstType * typeInst ) {
     252                        void Mangler_old::postvisit( TypeInstType * typeInst ) {
    251253                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
    252254                                if ( varNum == varNums.end() ) {
     
    264266                        }
    265267
    266                         void Mangler::postvisit( TraitInstType * inst ) {
     268                        void Mangler_old::postvisit( TraitInstType * inst ) {
    267269                                printQualifiers( inst );
    268270                                mangleName << inst->name.size() << inst->name;
    269271                        }
    270272
    271                         void Mangler::postvisit( TupleType * tupleType ) {
     273                        void Mangler_old::postvisit( TupleType * tupleType ) {
    272274                                printQualifiers( tupleType );
    273275                                mangleName << Encoding::tuple << tupleType->types.size();
     
    275277                        }
    276278
    277                         void Mangler::postvisit( VarArgsType * varArgsType ) {
     279                        void Mangler_old::postvisit( VarArgsType * varArgsType ) {
    278280                                printQualifiers( varArgsType );
    279281                                static const std::string vargs = "__builtin_va_list";
     
    281283                        }
    282284
    283                         void Mangler::postvisit( ZeroType * ) {
     285                        void Mangler_old::postvisit( ZeroType * ) {
    284286                                mangleName << Encoding::zero;
    285287                        }
    286288
    287                         void Mangler::postvisit( OneType * ) {
     289                        void Mangler_old::postvisit( OneType * ) {
    288290                                mangleName << Encoding::one;
    289291                        }
    290292
    291                         void Mangler::postvisit( QualifiedType * qualType ) {
     293                        void Mangler_old::postvisit( QualifiedType * qualType ) {
    292294                                bool inqual = inQualifiedType;
    293295                                if (! inqual ) {
     
    305307                        }
    306308
    307                         void Mangler::postvisit( TypeDecl * decl ) {
     309                        void Mangler_old::postvisit( TypeDecl * decl ) {
    308310                                // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
    309311                                // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
     
    311313                                // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
    312314                                // aside from the assert false.
    313                                 assertf(false, "Mangler should not visit typedecl: %s", toCString(decl));
     315                                assertf(false, "Mangler_old should not visit typedecl: %s", toCString(decl));
    314316                                assertf( decl->get_kind() < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->get_kind() );
    315317                                mangleName << Encoding::typeVariables[ decl->get_kind() ] << ( decl->name.length() ) << decl->name;
     
    322324                        }
    323325
    324                         void Mangler::printQualifiers( Type * type ) {
     326                        void Mangler_old::printQualifiers( Type * type ) {
    325327                                // skip if not including qualifiers
    326328                                if ( typeMode ) return;
     
    345347                                                varNums[ (*i)->name ] = std::make_pair( nextVarNum, (int)(*i)->get_kind() );
    346348                                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
    347                                                         PassVisitor<Mangler> sub_mangler(
     349                                                        PassVisitor<Mangler_old> sub_mangler(
    348350                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
    349351                                                        (*assert)->accept( sub_mangler );
     
    391393
    392394namespace 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( ast::Node * ) { visit_children = false; }
     402
     403                        void postvisit( ast::ObjectDecl * declaration );
     404                        void postvisit( ast::FunctionDecl * declaration );
     405                        void postvisit( ast::TypeDecl * declaration );
     406
     407                        void postvisit( ast::VoidType * voidType );
     408                        void postvisit( ast::BasicType * basicType );
     409                        void postvisit( ast::PointerType * pointerType );
     410                        void postvisit( ast::ArrayType * arrayType );
     411                        void postvisit( ast::ReferenceType * refType );
     412                        void postvisit( ast::FunctionType * functionType );
     413                        void postvisit( ast::StructInstType * aggregateUseType );
     414                        void postvisit( ast::UnionInstType * aggregateUseType );
     415                        void postvisit( ast::EnumInstType * aggregateUseType );
     416                        void postvisit( ast::TypeInstType * aggregateUseType );
     417                        void postvisit( ast::TraitInstType * inst );
     418                        void postvisit( ast::TupleType * tupleType );
     419                        void postvisit( ast::VarArgsType * varArgsType );
     420                        void postvisit( ast::ZeroType * zeroType );
     421                        void postvisit( ast::OneType * oneType );
     422                        void postvisit( 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( ast::DeclWithType *declaration );
     444                        void mangleRef( ast::ReferenceToType *refType, std::string prefix );
     445
     446                        void printQualifiers( ast::Type *type );
     447                }; // Mangler_new
     448        } // namespace
     449
     450
    393451        std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
    394                 #warning unimplemented
    395                 assert( decl && mode.val && false );
    396                 return "";
     452                ast::Pass<Mangler_new> mangler( mode );
     453                maybeAccept( decl, mangler );
     454                return mangler.pass.get_mangleName();
    397455        }
     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( 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( ast::ObjectDecl * decl ) {
     501                        mangleDecl( decl );
     502                }
     503
     504                void Mangler_new::postvisit( ast::FunctionDecl * decl ) {
     505                        mangleDecl( decl );
     506                }
     507
     508                void Mangler_new::postvisit( ast::VoidType * voidType ) {
     509                        printQualifiers( voidType );
     510                        mangleName << Encoding::void_t;
     511                }
     512
     513                void Mangler_new::postvisit( 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( 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( 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( 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                namespace {
     544                        inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
     545                                std::vector< ast::ptr< ast::Type > > ret;
     546                                std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
     547                                                                std::mem_fun( &ast::DeclWithType::get_type ) );
     548                                return ret;
     549                        }
     550                }
     551
     552                void Mangler_new::postvisit( ast::FunctionType * functionType ) {
     553                        printQualifiers( functionType );
     554                        mangleName << Encoding::function;
     555                        // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
     556                        // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
     557                        // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
     558                        GuardValue( inFunctionType );
     559                        inFunctionType = true;
     560                        std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
     561                        if (returnTypes.empty()) mangleName << Encoding::void_t;
     562                        else acceptAll( returnTypes, *visitor );
     563                        mangleName << "_";
     564                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
     565                        acceptAll( paramTypes, *visitor );
     566                        mangleName << "_";
     567                }
     568
     569                void Mangler_new::mangleRef( ast::ReferenceToType * refType, std::string prefix ) {
     570                        printQualifiers( refType );
     571
     572                        mangleName << prefix << refType->name.length() << refType->name;
     573
     574                        if ( mangleGenericParams ) {
     575                                std::vector< ast::ptr< ast::Expr > >& params = refType->params;
     576                                if ( ! params.empty() ) {
     577                                        mangleName << "_";
     578                                        for ( std::vector< ast::ptr< ast::Expr > >::const_iterator param = params.begin(); param != params.end(); ++param ) {
     579                                                const ast::TypeExpr *paramType = param->as< ast::TypeExpr >();
     580                                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
     581                                                maybeAccept( paramType->type.get(), *visitor );
     582                                        }
     583                                        mangleName << "_";
     584                                }
     585                        }
     586                }
     587
     588                void Mangler_new::postvisit( ast::StructInstType * aggregateUseType ) {
     589                        mangleRef( aggregateUseType, Encoding::struct_t );
     590                }
     591
     592                void Mangler_new::postvisit( ast::UnionInstType * aggregateUseType ) {
     593                        mangleRef( aggregateUseType, Encoding::union_t );
     594                }
     595
     596                void Mangler_new::postvisit( ast::EnumInstType * aggregateUseType ) {
     597                        mangleRef( aggregateUseType, Encoding::enum_t );
     598                }
     599
     600                void Mangler_new::postvisit( ast::TypeInstType * typeInst ) {
     601                        VarMapType::iterator varNum = varNums.find( typeInst->name );
     602                        if ( varNum == varNums.end() ) {
     603                                mangleRef( typeInst, Encoding::type );
     604                        } else {
     605                                printQualifiers( typeInst );
     606                                // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
     607                                //   forall(dtype T) void f(T);
     608                                //   forall(dtype S) void f(S);
     609                                // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
     610                                // are first found and prefixing with the appropriate encoding for the type class.
     611                                assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
     612                                mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
     613                        } // if
     614                }
     615
     616                void Mangler_new::postvisit( ast::TraitInstType * inst ) {
     617                        printQualifiers( inst );
     618                        mangleName << inst->name.size() << inst->name;
     619                }
     620
     621                void Mangler_new::postvisit( ast::TupleType * tupleType ) {
     622                        printQualifiers( tupleType );
     623                        mangleName << Encoding::tuple << tupleType->types.size();
     624                        acceptAll( tupleType->types, *visitor );
     625                }
     626
     627                void Mangler_new::postvisit( ast::VarArgsType * varArgsType ) {
     628                        printQualifiers( varArgsType );
     629                        static const std::string vargs = "__builtin_va_list";
     630                        mangleName << Encoding::type << vargs.size() << vargs;
     631                }
     632
     633                void Mangler_new::postvisit( ast::ZeroType * ) {
     634                        mangleName << Encoding::zero;
     635                }
     636
     637                void Mangler_new::postvisit( ast::OneType * ) {
     638                        mangleName << Encoding::one;
     639                }
     640
     641                void Mangler_new::postvisit( ast::QualifiedType * qualType ) {
     642                        bool inqual = inQualifiedType;
     643                        if (! inqual ) {
     644                                // N marks the start of a qualified type
     645                                inQualifiedType = true;
     646                                mangleName << Encoding::qualifiedTypeStart;
     647                        }
     648                        maybeAccept( qualType->parent.get(), *visitor );
     649                        maybeAccept( qualType->child.get(), *visitor );
     650                        if ( ! inqual ) {
     651                                // E marks the end of a qualified type
     652                                inQualifiedType = false;
     653                                mangleName << Encoding::qualifiedTypeEnd;
     654                        }
     655                }
     656
     657                void Mangler_new::postvisit( ast::TypeDecl * decl ) {
     658                        // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
     659                        // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
     660                        // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
     661                        // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
     662                        // aside from the assert false.
     663                        assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
     664                        assertf( decl->kind < ast::TypeVar::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
     665                        mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
     666                }
     667
     668                __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
     669                        for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
     670                                os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
     671                        } // for
     672                }
     673
     674                void Mangler_new::printQualifiers( ast::Type * type ) {
     675                        // skip if not including qualifiers
     676                        if ( typeMode ) return;
     677                        if ( ast::ParameterizedType * ptype = dynamic_cast< ast::ParameterizedType * >(type) ) {
     678                                if ( ! ptype->forall.empty() ) {
     679                                        std::list< std::string > assertionNames;
     680                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
     681                                        mangleName << Encoding::forall;
     682                                        for ( ast::ParameterizedType::ForallList::iterator i = ptype->forall.begin(); i != ptype->forall.end(); ++i ) {
     683                                                switch ( (*i)->kind ) {
     684                                                        case ast::TypeVar::Kind::Dtype:
     685                                                        dcount++;
     686                                                        break;
     687                                                        case ast::TypeVar::Kind::Ftype:
     688                                                        fcount++;
     689                                                        break;
     690                                                        case ast::TypeVar::Kind::Ttype:
     691                                                        vcount++;
     692                                                        break;
     693                                                        default:
     694                                                        assert( false );
     695                                                } // switch
     696                                                varNums[ (*i)->name ] = std::make_pair( nextVarNum, (int)(*i)->kind );
     697                                                for ( std::vector< ast::ptr< ast::DeclWithType > >::const_iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
     698                                                        ast::Pass<Mangler_new> sub_mangler(
     699                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
     700                                                        (*assert)->accept( sub_mangler );
     701                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
     702                                                        acount++;
     703                                                } // for
     704                                        } // for
     705                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
     706                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
     707                                        mangleName << "_";
     708                                } // if
     709                        } // if
     710                        if ( ! inFunctionType ) {
     711                                // these qualifiers do not distinguish the outermost type of a function parameter
     712                                if ( type->is_const() ) {
     713                                        mangleName << Encoding::qualifiers.at(Type::Const);
     714                                } // if
     715                                if ( type->is_volatile() ) {
     716                                        mangleName << Encoding::qualifiers.at(Type::Volatile);
     717                                } // if
     718                                // Removed due to restrict not affecting function compatibility in GCC
     719                                // if ( type->get_isRestrict() ) {
     720                                //      mangleName << "E";
     721                                // } // if
     722                                if ( type->is_atomic() ) {
     723                                        mangleName << Encoding::qualifiers.at(Type::Atomic);
     724                                } // if
     725                        }
     726                        if ( type->is_mutex() ) {
     727                                mangleName << Encoding::qualifiers.at(Type::Mutex);
     728                        } // if
     729                        if ( type->is_lvalue() ) {
     730                                // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
     731                                mangleName << Encoding::qualifiers.at(Type::Lvalue);
     732                        }
     733
     734                        if ( inFunctionType ) {
     735                                // turn off inFunctionType so that types can be differentiated for nested qualifiers
     736                                GuardValue( inFunctionType );
     737                                inFunctionType = false;
     738                        }
     739                }
     740        }       // namespace
    398741} // namespace Mangle
    399742
Note: See TracChangeset for help on using the changeset viewer.