Ignore:
Timestamp:
Sep 26, 2017, 11:27:38 PM (4 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
5dc26f5
Parents:
201aeb9
Message:

merge

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/SymTab/Mangler.cc

    r201aeb9 rd67cdb7  
    3131
    3232namespace SymTab {
    33         std::string Mangler::mangleType( Type *ty ) {
     33        std::string Mangler::mangleType( Type * ty ) {
    3434                Mangler mangler( false, true );
    3535                maybeAccept( ty, mangler );
     
    4848        }
    4949
    50         void Mangler::mangleDecl( DeclarationWithType *declaration ) {
     50        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
    5151                bool wasTopLevel = isTopLevel;
    5252                if ( isTopLevel ) {
     
    7979        }
    8080
    81         void Mangler::visit( ObjectDecl *declaration ) {
     81        void Mangler::visit( ObjectDecl * declaration ) {
    8282                mangleDecl( declaration );
    8383        }
    8484
    85         void Mangler::visit( FunctionDecl *declaration ) {
     85        void Mangler::visit( FunctionDecl * declaration ) {
    8686                mangleDecl( declaration );
    8787        }
    8888
    89         void Mangler::visit( VoidType *voidType ) {
     89        void Mangler::visit( VoidType * voidType ) {
    9090                printQualifiers( voidType );
    9191                mangleName << "v";
    9292        }
    9393
    94         void Mangler::visit( BasicType *basicType ) {
     94        void Mangler::visit( BasicType * basicType ) {
    9595                static const char *btLetter[] = {
    9696                        "b",    // Bool
     
    123123        }
    124124
    125         void Mangler::visit( PointerType *pointerType ) {
     125        void Mangler::visit( PointerType * pointerType ) {
    126126                printQualifiers( pointerType );
    127127                mangleName << "P";
     
    129129        }
    130130
    131         void Mangler::visit( ArrayType *arrayType ) {
     131        void Mangler::visit( ArrayType * arrayType ) {
    132132                // TODO: encode dimension
    133133                printQualifiers( arrayType );
     
    136136        }
    137137
    138         void Mangler::visit( ReferenceType *refType ) {
     138        void Mangler::visit( ReferenceType * refType ) {
    139139                printQualifiers( refType );
    140140                mangleName << "R";
     
    151151        }
    152152
    153         void Mangler::visit( FunctionType *functionType ) {
     153        void Mangler::visit( FunctionType * functionType ) {
    154154                printQualifiers( functionType );
    155155                mangleName << "F";
     
    162162        }
    163163
    164         void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
     164        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
    165165                printQualifiers( refType );
    166166
     
    168168        }
    169169
    170         void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
     170        void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) {
    171171                printQualifiers( refType );
    172172
     
    191191        }
    192192
    193         void Mangler::visit( StructInstType *aggregateUseType ) {
     193        void Mangler::visit( StructInstType * aggregateUseType ) {
    194194                if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
    195195                else mangleRef( aggregateUseType, "s" );
    196196        }
    197197
    198         void Mangler::visit( UnionInstType *aggregateUseType ) {
     198        void Mangler::visit( UnionInstType * aggregateUseType ) {
    199199                if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
    200200                else mangleRef( aggregateUseType, "u" );
    201201        }
    202202
    203         void Mangler::visit( EnumInstType *aggregateUseType ) {
     203        void Mangler::visit( EnumInstType * aggregateUseType ) {
    204204                mangleRef( aggregateUseType, "e" );
    205205        }
    206206
    207         void Mangler::visit( TypeInstType *typeInst ) {
     207        void Mangler::visit( TypeInstType * typeInst ) {
    208208                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
    209209                if ( varNum == varNums.end() ) {
     
    233233        }
    234234
    235         void Mangler::visit( TupleType *tupleType ) {
     235        void Mangler::visit( TupleType * tupleType ) {
    236236                printQualifiers( tupleType );
    237237                mangleName << "T";
    238                 acceptAll( tupleType->get_types(), *this );
     238                acceptAll( tupleType->types, *this );
    239239                mangleName << "_";
    240240        }
    241241
    242         void Mangler::visit( VarArgsType *varArgsType ) {
     242        void Mangler::visit( VarArgsType * varArgsType ) {
    243243                printQualifiers( varArgsType );
    244244                mangleName << "VARGS";
    245245        }
    246246
    247         void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
     247        void Mangler::visit( ZeroType * ) {
    248248                mangleName << "Z";
    249249        }
    250250
    251         void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
     251        void Mangler::visit( OneType * ) {
    252252                mangleName << "O";
    253253        }
    254254
    255         void Mangler::visit( TypeDecl *decl ) {
     255        void Mangler::visit( TypeDecl * decl ) {
    256256                static const char *typePrefix[] = { "BT", "BD", "BF" };
    257                 mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
     257                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
    258258        }
    259259
     
    264264        }
    265265
    266         void Mangler::printQualifiers( Type *type ) {
     266        void Mangler::printQualifiers( Type * type ) {
    267267                // skip if not including qualifiers
    268268                if ( typeMode ) return;
     
    272272                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
    273273                        mangleName << "A";
    274                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     274                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
    275275                                switch ( (*i)->get_kind() ) {
    276276                                  case TypeDecl::Any:
     
    289289                                        assert( false );
    290290                                } // switch
    291                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
    292                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
     291                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
     292                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
    293293                                        Mangler sub_mangler( mangleOverridable, typeMode );
    294294                                        sub_mangler.nextVarNum = nextVarNum;
     
    309309                        mangleName << "V";
    310310                } // if
     311                if ( type->get_mutex() ) {
     312                        mangleName << "M";
     313                } // if
    311314                // Removed due to restrict not affecting function compatibility in GCC
    312315//              if ( type->get_isRestrict() ) {
     
    314317//              } // if
    315318                if ( type->get_lvalue() ) {
     319                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
    316320                        mangleName << "L";
    317                 } // if
     321                }
    318322                if ( type->get_atomic() ) {
    319323                        mangleName << "A";
Note: See TracChangeset for help on using the changeset viewer.