Changes in / [cde1bf9:af333e3]


Ignore:
Files:
1 deleted
4 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/andrew_beach_MMath/Makefile

    rcde1bf9 raf333e3  
    3131        ${GLOSSARY} ${BUILD}/${BASE}
    3232        ${LATEX} ${BASE}
     33        ${LATEX} ${BASE}
    3334
    3435${DOC}: ${BUILD}/${DOC}
  • doc/theses/andrew_beach_MMath/cfalab.sty

    rcde1bf9 raf333e3  
    2727% Cforall with the forall symbol.
    2828\newsymbolcmd\CFA{\textsf{C}\raisebox{\depth}{\rotatebox{180}{\textsf{A}}}}
    29 % C++ with kerning. (No standard number support.)
    30 \newsymbolcmd\CPP{\textrm{C}\kern-.1em\hbox{+\kern-.25em+}}
    31 
    32 % This is executed very early in the \begin{document} code.
    33 \AtEndPreamble{
    34   \@ifpackageloaded{hyperref}{
    35     % Convert symbols to pdf compatable forms when required.
    36     \pdfstringdefDisableCommands{
    37       \def\CFA{CFA}
    38       \def\CPP{C++}
    39     }
    40   }{}
    41 }
    4229
    4330% The CFA listings language. Based off of ANCI C and including GCC extensions.
     
    8572    \renewcommand\textunderscore{\csuse{cfalab@textunderscore@#1}}}
    8673
     74% This is executed very early in the \begin{document} code.
     75\AtEndPreamble{
     76  \@ifpackageloaded{hyperref}{
     77    % Convert symbols to pdf compatable forms when required.
     78    \pdfstringdefDisableCommands{
     79      \def\CFA{CFA}
     80    }
     81  }{}
     82}
     83
    8784\endinput
  • doc/theses/andrew_beach_MMath/thesis.tex

    rcde1bf9 raf333e3  
    5050% MAIN BODY
    5151%----------------------------------------------------------------------
    52 \input{existing}
    53 \input{features}
    5452\input{unwinding}
    55 \input{future}
    5653
    5754%======================================================================
  • src/SymTab/Mangler.cc

    rcde1bf9 raf333e3  
    1010// Created On       : Sun May 17 21:40:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Nov 18 12:01:38 2020
    13 // Update Count     : 64
     12// Last Modified On : Sat Feb 15 13:55:12 2020
     13// Update Count     : 33
    1414//
    1515#include "Mangler.h"
     
    6565                                void postvisit( const QualifiedType * qualType );
    6666
    67                                 std::string get_mangleName() { return mangleName; }
     67                                std::string get_mangleName() { return mangleName.str(); }
    6868                          private:
    69                                 std::string mangleName;         ///< Mangled name being constructed
     69                                std::ostringstream mangleName;  ///< Mangled name being constructed
    7070                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
    7171                                VarMapType varNums;             ///< Map of type variables to indices
     
    127127                                        isTopLevel = false;
    128128                                } // if
    129                                 mangleName += Encoding::manglePrefix;
     129                                mangleName << Encoding::manglePrefix;
    130130                                const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
    131131                                if ( opInfo ) {
    132                                         mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
     132                                        mangleName << opInfo->outputName.size() << opInfo->outputName;
    133133                                } else {
    134                                         mangleName += std::to_string( declaration->name.size() ) + declaration->name;
     134                                        mangleName << declaration->name.size() << declaration->name;
    135135                                } // if
    136136                                maybeAccept( declaration->get_type(), *visitor );
     
    139139                                        // so they need a different name mangling
    140140                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
    141                                                 mangleName += Encoding::autogen;
     141                                                mangleName << Encoding::autogen;
    142142                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
    143                                                 mangleName += Encoding::intrinsic;
     143                                                mangleName << Encoding::intrinsic;
    144144                                        } else {
    145145                                                // if we add another kind of overridable function, this has to change
     
    160160                        void Mangler_old::postvisit( const VoidType * voidType ) {
    161161                                printQualifiers( voidType );
    162                                 mangleName += Encoding::void_t;
     162                                mangleName << Encoding::void_t;
    163163                        }
    164164
     
    166166                                printQualifiers( basicType );
    167167                                assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
    168                                 mangleName += Encoding::basicTypes[ basicType->kind ];
     168                                mangleName << Encoding::basicTypes[ basicType->kind ];
    169169                        }
    170170
     
    172172                                printQualifiers( pointerType );
    173173                                // 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;
     174                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << Encoding::pointer;
    175175                                maybeAccept( pointerType->base, *visitor );
    176176                        }
     
    179179                                // TODO: encode dimension
    180180                                printQualifiers( arrayType );
    181                                 mangleName += Encoding::array + "0";
     181                                mangleName << Encoding::array << "0";
    182182                                maybeAccept( arrayType->base, *visitor );
    183183                        }
     
    204204                        void Mangler_old::postvisit( const FunctionType * functionType ) {
    205205                                printQualifiers( functionType );
    206                                 mangleName += Encoding::function;
     206                                mangleName << Encoding::function;
    207207                                // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
    208208                                // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
     
    211211                                inFunctionType = true;
    212212                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
    213                                 if (returnTypes.empty()) mangleName += Encoding::void_t;
     213                                if (returnTypes.empty()) mangleName << Encoding::void_t;
    214214                                else acceptAll( returnTypes, *visitor );
    215                                 mangleName += "_";
     215                                mangleName << "_";
    216216                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
    217217                                acceptAll( paramTypes, *visitor );
    218                                 mangleName += "_";
     218                                mangleName << "_";
    219219                        }
    220220
     
    222222                                printQualifiers( refType );
    223223
    224                                 mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
     224                                mangleName << prefix << refType->name.length() << refType->name;
    225225
    226226                                if ( mangleGenericParams ) {
    227227                                        const std::list< Expression* > & params = refType->parameters;
    228228                                        if ( ! params.empty() ) {
    229                                                 mangleName += "_";
     229                                                mangleName << "_";
    230230                                                for ( const Expression * param : params ) {
    231231                                                        const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param );
     
    233233                                                        maybeAccept( paramType->type, *visitor );
    234234                                                }
    235                                                 mangleName += "_";
     235                                                mangleName << "_";
    236236                                        }
    237237                                }
     
    262262                                        // are first found and prefixing with the appropriate encoding for the type class.
    263263                                        assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
    264                                         mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
     264                                        mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
    265265                                } // if
    266266                        }
     
    268268                        void Mangler_old::postvisit( const TraitInstType * inst ) {
    269269                                printQualifiers( inst );
    270                                 mangleName += std::to_string( inst->name.size() ) + inst->name;
     270                                mangleName << inst->name.size() << inst->name;
    271271                        }
    272272
    273273                        void Mangler_old::postvisit( const TupleType * tupleType ) {
    274274                                printQualifiers( tupleType );
    275                                 mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
     275                                mangleName << Encoding::tuple << tupleType->types.size();
    276276                                acceptAll( tupleType->types, *visitor );
    277277                        }
     
    280280                                printQualifiers( varArgsType );
    281281                                static const std::string vargs = "__builtin_va_list";
    282                                 mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
     282                                mangleName << Encoding::type << vargs.size() << vargs;
    283283                        }
    284284
    285285                        void Mangler_old::postvisit( const ZeroType * ) {
    286                                 mangleName += Encoding::zero;
     286                                mangleName << Encoding::zero;
    287287                        }
    288288
    289289                        void Mangler_old::postvisit( const OneType * ) {
    290                                 mangleName += Encoding::one;
     290                                mangleName << Encoding::one;
    291291                        }
    292292
     
    296296                                        // N marks the start of a qualified type
    297297                                        inQualifiedType = true;
    298                                         mangleName += Encoding::qualifiedTypeStart;
     298                                        mangleName << Encoding::qualifiedTypeStart;
    299299                                }
    300300                                maybeAccept( qualType->parent, *visitor );
     
    303303                                        // E marks the end of a qualified type
    304304                                        inQualifiedType = false;
    305                                         mangleName += Encoding::qualifiedTypeEnd;
     305                                        mangleName << Encoding::qualifiedTypeEnd;
    306306                                }
    307307                        }
     
    315315                                assertf(false, "Mangler_old should not visit typedecl: %s", toCString(decl));
    316316                                assertf( decl->kind < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
    317                                 mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
     317                                mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
    318318                        }
    319319
     
    330330                                        std::list< std::string > assertionNames;
    331331                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
    332                                         mangleName += Encoding::forall;
     332                                        mangleName << Encoding::forall;
    333333                                        for ( const TypeDecl * i : type->forall ) {
    334334                                                switch ( i->kind ) {
     
    354354                                                } // for
    355355                                        } // for
    356                                         mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
    357                                         for(const auto & a : assertionNames) mangleName += a;
    358 //                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    359                                         mangleName += "_";
     356                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
     357                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
     358                                        mangleName << "_";
    360359                                } // if
    361360                                if ( ! inFunctionType ) {
    362361                                        // these qualifiers do not distinguish the outermost type of a function parameter
    363362                                        if ( type->get_const() ) {
    364                                                 mangleName += Encoding::qualifiers.at(Type::Const);
     363                                                mangleName << Encoding::qualifiers.at(Type::Const);
    365364                                        } // if
    366365                                        if ( type->get_volatile() ) {
    367                                                 mangleName += Encoding::qualifiers.at(Type::Volatile);
     366                                                mangleName << Encoding::qualifiers.at(Type::Volatile);
    368367                                        } // if
    369368                                        // Removed due to restrict not affecting function compatibility in GCC
    370369                                        // if ( type->get_isRestrict() ) {
    371                                         //      mangleName += "E";
     370                                        //      mangleName << "E";
    372371                                        // } // if
    373372                                        if ( type->get_atomic() ) {
    374                                                 mangleName += Encoding::qualifiers.at(Type::Atomic);
     373                                                mangleName << Encoding::qualifiers.at(Type::Atomic);
    375374                                        } // if
    376375                                }
    377376                                if ( type->get_mutex() ) {
    378                                         mangleName += Encoding::qualifiers.at(Type::Mutex);
     377                                        mangleName << Encoding::qualifiers.at(Type::Mutex);
    379378                                } // if
    380379                                if ( inFunctionType ) {
     
    384383                                }
    385384                        }
    386                 } // namespace
     385                }       // namespace
    387386        } // namespace Mangler
    388387} // namespace SymTab
     
    418417                        void postvisit( const ast::QualifiedType * qualType );
    419418
    420                         std::string get_mangleName() { return mangleName; }
     419                        std::string get_mangleName() { return mangleName.str(); }
    421420                  private:
    422                         std::string mangleName;         ///< Mangled name being constructed
     421                        std::ostringstream mangleName;  ///< Mangled name being constructed
    423422                        typedef std::map< std::string, std::pair< int, int > > VarMapType;
    424423                        VarMapType varNums;             ///< Map of type variables to indices
     
    471470                                isTopLevel = false;
    472471                        } // if
    473                         mangleName += Encoding::manglePrefix;
     472                        mangleName << Encoding::manglePrefix;
    474473                        const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name );
    475474                        if ( opInfo ) {
    476                                 mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
     475                                mangleName << opInfo->outputName.size() << opInfo->outputName;
    477476                        } else {
    478                                 mangleName += std::to_string( decl->name.size() ) + decl->name;
     477                                mangleName << decl->name.size() << decl->name;
    479478                        } // if
    480479                        maybeAccept( decl->get_type(), *visitor );
     
    483482                                // so they need a different name mangling
    484483                                if ( decl->linkage == ast::Linkage::AutoGen ) {
    485                                         mangleName += Encoding::autogen;
     484                                        mangleName << Encoding::autogen;
    486485                                } else if ( decl->linkage == ast::Linkage::Intrinsic ) {
    487                                         mangleName += Encoding::intrinsic;
     486                                        mangleName << Encoding::intrinsic;
    488487                                } else {
    489488                                        // if we add another kind of overridable function, this has to change
     
    504503                void Mangler_new::postvisit( const ast::VoidType * voidType ) {
    505504                        printQualifiers( voidType );
    506                         mangleName += Encoding::void_t;
     505                        mangleName << Encoding::void_t;
    507506                }
    508507
     
    510509                        printQualifiers( basicType );
    511510                        assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
    512                         mangleName += Encoding::basicTypes[ basicType->kind ];
     511                        mangleName << Encoding::basicTypes[ basicType->kind ];
    513512                }
    514513
     
    516515                        printQualifiers( pointerType );
    517516                        // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
    518                         if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName += Encoding::pointer;
     517                        if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName << Encoding::pointer;
    519518                        maybe_accept( pointerType->base.get(), *visitor );
    520519                }
     
    523522                        // TODO: encode dimension
    524523                        printQualifiers( arrayType );
    525                         mangleName += Encoding::array + "0";
     524                        mangleName << Encoding::array << "0";
    526525                        maybeAccept( arrayType->base.get(), *visitor );
    527526                }
     
    546545                void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
    547546                        printQualifiers( functionType );
    548                         mangleName += Encoding::function;
     547                        mangleName << Encoding::function;
    549548                        // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
    550549                        // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
     
    552551                        GuardValue( inFunctionType );
    553552                        inFunctionType = true;
    554                         if (functionType->returns.empty()) mangleName += Encoding::void_t;
     553                        if (functionType->returns.empty()) mangleName << Encoding::void_t;
    555554                        else accept_each( functionType->returns, *visitor );
    556                         mangleName += "_";
     555                        mangleName << "_";
    557556                        accept_each( functionType->params, *visitor );
    558                         mangleName += "_";
     557                        mangleName << "_";
    559558                }
    560559
     
    562561                        printQualifiers( refType );
    563562
    564                         mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
     563                        mangleName << prefix << refType->name.length() << refType->name;
    565564
    566565                        if ( mangleGenericParams ) {
    567566                                if ( ! refType->params.empty() ) {
    568                                         mangleName += "_";
     567                                        mangleName << "_";
    569568                                        for ( const ast::Expr * param : refType->params ) {
    570569                                                auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
     
    572571                                                maybeAccept( paramType->type.get(), *visitor );
    573572                                        }
    574                                         mangleName += "_";
     573                                        mangleName << "_";
    575574                                }
    576575                        }
     
    601600                                // are first found and prefixing with the appropriate encoding for the type class.
    602601                                assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
    603                                 mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
     602                                mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
    604603                        } // if
    605604                }
     
    607606                void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
    608607                        printQualifiers( inst );
    609                         mangleName += std::to_string( inst->name.size() ) + inst->name;
     608                        mangleName << inst->name.size() << inst->name;
    610609                }
    611610
    612611                void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
    613612                        printQualifiers( tupleType );
    614                         mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
     613                        mangleName << Encoding::tuple << tupleType->types.size();
    615614                        accept_each( tupleType->types, *visitor );
    616615                }
     
    619618                        printQualifiers( varArgsType );
    620619                        static const std::string vargs = "__builtin_va_list";
    621                         mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
     620                        mangleName << Encoding::type << vargs.size() << vargs;
    622621                }
    623622
    624623                void Mangler_new::postvisit( const ast::ZeroType * ) {
    625                         mangleName += Encoding::zero;
     624                        mangleName << Encoding::zero;
    626625                }
    627626
    628627                void Mangler_new::postvisit( const ast::OneType * ) {
    629                         mangleName += Encoding::one;
     628                        mangleName << Encoding::one;
    630629                }
    631630
     
    635634                                // N marks the start of a qualified type
    636635                                inQualifiedType = true;
    637                                 mangleName += Encoding::qualifiedTypeStart;
     636                                mangleName << Encoding::qualifiedTypeStart;
    638637                        }
    639638                        maybeAccept( qualType->parent.get(), *visitor );
     
    642641                                // E marks the end of a qualified type
    643642                                inQualifiedType = false;
    644                                 mangleName += Encoding::qualifiedTypeEnd;
     643                                mangleName << Encoding::qualifiedTypeEnd;
    645644                        }
    646645                }
     
    654653                        assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
    655654                        assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
    656                         mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
     655                        mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
    657656                }
    658657
     
    670669                                        std::list< std::string > assertionNames;
    671670                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
    672                                         mangleName += Encoding::forall;
     671                                        mangleName << Encoding::forall;
    673672                                        for ( const ast::TypeDecl * decl : ptype->forall ) {
    674673                                                switch ( decl->kind ) {
     
    694693                                                } // for
    695694                                        } // for
    696                                         mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
    697                                         for(const auto & a : assertionNames) mangleName += a;
    698 //                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    699                                         mangleName += "_";
     695                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
     696                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
     697                                        mangleName << "_";
    700698                                } // if
    701699                        } // if
     
    703701                                // these qualifiers do not distinguish the outermost type of a function parameter
    704702                                if ( type->is_const() ) {
    705                                         mangleName += Encoding::qualifiers.at(Type::Const);
     703                                        mangleName << Encoding::qualifiers.at(Type::Const);
    706704                                } // if
    707705                                if ( type->is_volatile() ) {
    708                                         mangleName += Encoding::qualifiers.at(Type::Volatile);
     706                                        mangleName << Encoding::qualifiers.at(Type::Volatile);
    709707                                } // if
    710708                                // Removed due to restrict not affecting function compatibility in GCC
    711709                                // if ( type->get_isRestrict() ) {
    712                                 //      mangleName += "E";
     710                                //      mangleName << "E";
    713711                                // } // if
    714712                                if ( type->is_atomic() ) {
    715                                         mangleName += Encoding::qualifiers.at(Type::Atomic);
     713                                        mangleName << Encoding::qualifiers.at(Type::Atomic);
    716714                                } // if
    717715                        }
    718716                        if ( type->is_mutex() ) {
    719                                 mangleName += Encoding::qualifiers.at(Type::Mutex);
     717                                mangleName << Encoding::qualifiers.at(Type::Mutex);
    720718                        } // if
    721719                        if ( inFunctionType ) {
Note: See TracChangeset for help on using the changeset viewer.