Changeset 69911c11


Ignore:
Timestamp:
Dec 17, 2015, 12:00:55 PM (6 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, string, with_gc
Children:
c23f807
Parents:
7754cde
Message:

Restore Mangler to closer to previous behaviour

Location:
src
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Box.cc

    r7754cde r69911c11  
    331331                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
    332332                        std::list< Expression* >::const_iterator fnArg = arg;
    333                         std::set< std::string > seenTypes; //< sizeofName for generic types we've seen
     333                        std::set< std::string > seenTypes; //< names for generic types we've seen
    334334                        for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
    335335                                Type *parmType = (*fnParm)->get_type();
  • src/GenPoly/GenPoly.cc

    r7754cde r69911c11  
    166166
    167167        std::string sizeofName( Type *ty ) {
    168                 return std::string( "_sizeof_" ) + SymTab::Mangler::mangle( ty, false, false );
     168                return std::string( "_sizeof_" ) + SymTab::Mangler::mangleType( ty );
    169169        }
    170170
    171171        std::string alignofName( Type *ty ) {
    172                 return std::string( "_alignof_" ) + SymTab::Mangler::mangle( ty, false, false );
     172                return std::string( "_alignof_" ) + SymTab::Mangler::mangleType( ty );
    173173        }
    174174} // namespace GenPoly
  • src/SymTab/Mangler.cc

    r7754cde r69911c11  
    3030
    3131namespace SymTab {
    32         Mangler::Mangler( bool mangleOverridable, bool includeQualifiers )
    33                 : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), includeQualifiers(includeQualifiers) {}
     32        std::string Mangler::mangleType( Type *ty ) {
     33                Mangler mangler( false, true );
     34                maybeAccept( ty, mangler );
     35                return mangler.get_mangleName();
     36        }
     37       
     38        Mangler::Mangler( bool mangleOverridable, bool typeMode )
     39                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
    3440               
    3541        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
     
    3844                isTopLevel = rhs.isTopLevel;
    3945                mangleOverridable = rhs.mangleOverridable;
    40                 includeQualifiers = rhs.includeQualifiers;
     46                typeMode = rhs.typeMode;
    4147        }
    4248
     
    164170                if ( ! params.empty() ) {
    165171                        mangleName << "_";
    166                         std::list< Type* > paramTypes;
    167172                        for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
    168173                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
    169174                                assert(paramType && "Aggregate parameters should be type expressions");
    170                                 paramTypes.push_back( paramType->get_type() );
     175                                maybeAccept( paramType->get_type(), *this );
    171176                        }
    172                         acceptAll( paramTypes, *this );
    173177                        mangleName << "_";
    174178                }
     
    179183
    180184        void Mangler::visit( StructInstType *aggregateUseType ) {
    181                 mangleGenericRef( aggregateUseType, "s" );
     185                if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
     186                else mangleRef( aggregateUseType, "s" );
    182187        }
    183188
    184189        void Mangler::visit( UnionInstType *aggregateUseType ) {
    185                 mangleGenericRef( aggregateUseType, "u" );
     190                if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
     191                else mangleRef( aggregateUseType, "u" );
    186192        }
    187193
     
    233239        void Mangler::printQualifiers( Type *type ) {
    234240                // skip if not including qualifiers
    235                 if ( ! includeQualifiers ) return;
     241                if ( typeMode ) return;
    236242               
    237243                if ( ! type->get_forall().empty() ) {
     
    253259                                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
    254260                                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
    255                                         Mangler sub_mangler( mangleOverridable, includeQualifiers );
     261                                        Mangler sub_mangler( mangleOverridable, typeMode );
    256262                                        sub_mangler.nextVarNum = nextVarNum;
    257263                                        sub_mangler.isTopLevel = false;
  • src/SymTab/Mangler.h

    r7754cde r69911c11  
    2525        class Mangler : public Visitor {
    2626          public:
     27                /// Mangle syntax tree object; primary interface to clients
    2728                template< typename SynTreeClass >
    28             static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool includeQualifiers = true ); // interface to clients
     29            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true );
     30                /// Mangle a type name; secondary interface
     31                static std::string mangleType( Type* ty );
    2932
    3033                virtual void visit( ObjectDecl *declaration );
     
    5154                bool isTopLevel;                ///< Is the Mangler at the top level
    5255                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
    53                 bool includeQualifiers;         ///< Include type qualifiers in mangled name
     56                bool typeMode;                  ///< Produce a unique mangled name for a type
    5457 
    55                 Mangler( bool mangleOverridable, bool includeQualifiers );
     58                Mangler( bool mangleOverridable, bool typeMode );
    5659                Mangler( const Mangler & );
    5760 
     
    6467
    6568        template< typename SynTreeClass >
    66         std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool includeQualifiers ) {
    67                 Mangler mangler( mangleOverridable, includeQualifiers );
     69        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable ) {
     70                Mangler mangler( mangleOverridable, false );
    6871                maybeAccept( decl, mangler );
    6972                return mangler.get_mangleName();
Note: See TracChangeset for help on using the changeset viewer.