Changeset cde1bf9


Ignore:
Timestamp:
Nov 26, 2020, 5:20:30 PM (10 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
Children:
849de65
Parents:
af333e3 (diff), 6e7b969 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/andrew_beach_MMath/Makefile

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

    raf333e3 rcde1bf9  
    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}
    2942
    3043% The CFA listings language. Based off of ANCI C and including GCC extensions.
     
    7285    \renewcommand\textunderscore{\csuse{cfalab@textunderscore@#1}}}
    7386
    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 
    8487\endinput
  • doc/theses/andrew_beach_MMath/thesis.tex

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

    raf333e3 rcde1bf9  
    1010// Created On       : Sun May 17 21:40:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Feb 15 13:55:12 2020
    13 // Update Count     : 33
     12// Last Modified On : Wed Nov 18 12:01:38 2020
     13// Update Count     : 64
    1414//
    1515#include "Mangler.h"
     
    6565                                void postvisit( const QualifiedType * qualType );
    6666
    67                                 std::string get_mangleName() { return mangleName.str(); }
     67                                std::string get_mangleName() { return mangleName; }
    6868                          private:
    69                                 std::ostringstream mangleName;  ///< Mangled name being constructed
     69                                std::string 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 << opInfo->outputName.size() << opInfo->outputName;
     132                                        mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
    133133                                } else {
    134                                         mangleName << declaration->name.size() << declaration->name;
     134                                        mangleName += std::to_string( 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 << refType->name.length() << refType->name;
     224                                mangleName += prefix + std::to_string( 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] << varNum->second.first;
     264                                        mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
    265265                                } // if
    266266                        }
     
    268268                        void Mangler_old::postvisit( const TraitInstType * inst ) {
    269269                                printQualifiers( inst );
    270                                 mangleName << inst->name.size() << inst->name;
     270                                mangleName += std::to_string( inst->name.size() ) + inst->name;
    271271                        }
    272272
    273273                        void Mangler_old::postvisit( const TupleType * tupleType ) {
    274274                                printQualifiers( tupleType );
    275                                 mangleName << Encoding::tuple << tupleType->types.size();
     275                                mangleName += Encoding::tuple + std::to_string( 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 << vargs.size() << vargs;
     282                                mangleName += Encoding::type + std::to_string( 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 ] << ( decl->name.length() ) << decl->name;
     317                                mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( 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 << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
    357                                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    358                                         mangleName << "_";
     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 += "_";
    359360                                } // if
    360361                                if ( ! inFunctionType ) {
    361362                                        // these qualifiers do not distinguish the outermost type of a function parameter
    362363                                        if ( type->get_const() ) {
    363                                                 mangleName << Encoding::qualifiers.at(Type::Const);
     364                                                mangleName += Encoding::qualifiers.at(Type::Const);
    364365                                        } // if
    365366                                        if ( type->get_volatile() ) {
    366                                                 mangleName << Encoding::qualifiers.at(Type::Volatile);
     367                                                mangleName += Encoding::qualifiers.at(Type::Volatile);
    367368                                        } // if
    368369                                        // Removed due to restrict not affecting function compatibility in GCC
    369370                                        // if ( type->get_isRestrict() ) {
    370                                         //      mangleName << "E";
     371                                        //      mangleName += "E";
    371372                                        // } // if
    372373                                        if ( type->get_atomic() ) {
    373                                                 mangleName << Encoding::qualifiers.at(Type::Atomic);
     374                                                mangleName += Encoding::qualifiers.at(Type::Atomic);
    374375                                        } // if
    375376                                }
    376377                                if ( type->get_mutex() ) {
    377                                         mangleName << Encoding::qualifiers.at(Type::Mutex);
     378                                        mangleName += Encoding::qualifiers.at(Type::Mutex);
    378379                                } // if
    379380                                if ( inFunctionType ) {
     
    383384                                }
    384385                        }
    385                 }       // namespace
     386                } // namespace
    386387        } // namespace Mangler
    387388} // namespace SymTab
     
    417418                        void postvisit( const ast::QualifiedType * qualType );
    418419
    419                         std::string get_mangleName() { return mangleName.str(); }
     420                        std::string get_mangleName() { return mangleName; }
    420421                  private:
    421                         std::ostringstream mangleName;  ///< Mangled name being constructed
     422                        std::string mangleName;         ///< Mangled name being constructed
    422423                        typedef std::map< std::string, std::pair< int, int > > VarMapType;
    423424                        VarMapType varNums;             ///< Map of type variables to indices
     
    470471                                isTopLevel = false;
    471472                        } // if
    472                         mangleName << Encoding::manglePrefix;
     473                        mangleName += Encoding::manglePrefix;
    473474                        const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name );
    474475                        if ( opInfo ) {
    475                                 mangleName << opInfo->outputName.size() << opInfo->outputName;
     476                                mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
    476477                        } else {
    477                                 mangleName << decl->name.size() << decl->name;
     478                                mangleName += std::to_string( decl->name.size() ) + decl->name;
    478479                        } // if
    479480                        maybeAccept( decl->get_type(), *visitor );
     
    482483                                // so they need a different name mangling
    483484                                if ( decl->linkage == ast::Linkage::AutoGen ) {
    484                                         mangleName << Encoding::autogen;
     485                                        mangleName += Encoding::autogen;
    485486                                } else if ( decl->linkage == ast::Linkage::Intrinsic ) {
    486                                         mangleName << Encoding::intrinsic;
     487                                        mangleName += Encoding::intrinsic;
    487488                                } else {
    488489                                        // if we add another kind of overridable function, this has to change
     
    503504                void Mangler_new::postvisit( const ast::VoidType * voidType ) {
    504505                        printQualifiers( voidType );
    505                         mangleName << Encoding::void_t;
     506                        mangleName += Encoding::void_t;
    506507                }
    507508
     
    509510                        printQualifiers( basicType );
    510511                        assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
    511                         mangleName << Encoding::basicTypes[ basicType->kind ];
     512                        mangleName += Encoding::basicTypes[ basicType->kind ];
    512513                }
    513514
     
    515516                        printQualifiers( pointerType );
    516517                        // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
    517                         if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName << Encoding::pointer;
     518                        if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName += Encoding::pointer;
    518519                        maybe_accept( pointerType->base.get(), *visitor );
    519520                }
     
    522523                        // TODO: encode dimension
    523524                        printQualifiers( arrayType );
    524                         mangleName << Encoding::array << "0";
     525                        mangleName += Encoding::array + "0";
    525526                        maybeAccept( arrayType->base.get(), *visitor );
    526527                }
     
    545546                void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
    546547                        printQualifiers( functionType );
    547                         mangleName << Encoding::function;
     548                        mangleName += Encoding::function;
    548549                        // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
    549550                        // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
     
    551552                        GuardValue( inFunctionType );
    552553                        inFunctionType = true;
    553                         if (functionType->returns.empty()) mangleName << Encoding::void_t;
     554                        if (functionType->returns.empty()) mangleName += Encoding::void_t;
    554555                        else accept_each( functionType->returns, *visitor );
    555                         mangleName << "_";
     556                        mangleName += "_";
    556557                        accept_each( functionType->params, *visitor );
    557                         mangleName << "_";
     558                        mangleName += "_";
    558559                }
    559560
     
    561562                        printQualifiers( refType );
    562563
    563                         mangleName << prefix << refType->name.length() << refType->name;
     564                        mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
    564565
    565566                        if ( mangleGenericParams ) {
    566567                                if ( ! refType->params.empty() ) {
    567                                         mangleName << "_";
     568                                        mangleName += "_";
    568569                                        for ( const ast::Expr * param : refType->params ) {
    569570                                                auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
     
    571572                                                maybeAccept( paramType->type.get(), *visitor );
    572573                                        }
    573                                         mangleName << "_";
     574                                        mangleName += "_";
    574575                                }
    575576                        }
     
    600601                                // are first found and prefixing with the appropriate encoding for the type class.
    601602                                assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
    602                                 mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
     603                                mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
    603604                        } // if
    604605                }
     
    606607                void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
    607608                        printQualifiers( inst );
    608                         mangleName << inst->name.size() << inst->name;
     609                        mangleName += std::to_string( inst->name.size() ) + inst->name;
    609610                }
    610611
    611612                void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
    612613                        printQualifiers( tupleType );
    613                         mangleName << Encoding::tuple << tupleType->types.size();
     614                        mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
    614615                        accept_each( tupleType->types, *visitor );
    615616                }
     
    618619                        printQualifiers( varArgsType );
    619620                        static const std::string vargs = "__builtin_va_list";
    620                         mangleName << Encoding::type << vargs.size() << vargs;
     621                        mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
    621622                }
    622623
    623624                void Mangler_new::postvisit( const ast::ZeroType * ) {
    624                         mangleName << Encoding::zero;
     625                        mangleName += Encoding::zero;
    625626                }
    626627
    627628                void Mangler_new::postvisit( const ast::OneType * ) {
    628                         mangleName << Encoding::one;
     629                        mangleName += Encoding::one;
    629630                }
    630631
     
    634635                                // N marks the start of a qualified type
    635636                                inQualifiedType = true;
    636                                 mangleName << Encoding::qualifiedTypeStart;
     637                                mangleName += Encoding::qualifiedTypeStart;
    637638                        }
    638639                        maybeAccept( qualType->parent.get(), *visitor );
     
    641642                                // E marks the end of a qualified type
    642643                                inQualifiedType = false;
    643                                 mangleName << Encoding::qualifiedTypeEnd;
     644                                mangleName += Encoding::qualifiedTypeEnd;
    644645                        }
    645646                }
     
    653654                        assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
    654655                        assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
    655                         mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
     656                        mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
    656657                }
    657658
     
    669670                                        std::list< std::string > assertionNames;
    670671                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
    671                                         mangleName << Encoding::forall;
     672                                        mangleName += Encoding::forall;
    672673                                        for ( const ast::TypeDecl * decl : ptype->forall ) {
    673674                                                switch ( decl->kind ) {
     
    693694                                                } // for
    694695                                        } // for
    695                                         mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
    696                                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
    697                                         mangleName << "_";
     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 += "_";
    698700                                } // if
    699701                        } // if
     
    701703                                // these qualifiers do not distinguish the outermost type of a function parameter
    702704                                if ( type->is_const() ) {
    703                                         mangleName << Encoding::qualifiers.at(Type::Const);
     705                                        mangleName += Encoding::qualifiers.at(Type::Const);
    704706                                } // if
    705707                                if ( type->is_volatile() ) {
    706                                         mangleName << Encoding::qualifiers.at(Type::Volatile);
     708                                        mangleName += Encoding::qualifiers.at(Type::Volatile);
    707709                                } // if
    708710                                // Removed due to restrict not affecting function compatibility in GCC
    709711                                // if ( type->get_isRestrict() ) {
    710                                 //      mangleName << "E";
     712                                //      mangleName += "E";
    711713                                // } // if
    712714                                if ( type->is_atomic() ) {
    713                                         mangleName << Encoding::qualifiers.at(Type::Atomic);
     715                                        mangleName += Encoding::qualifiers.at(Type::Atomic);
    714716                                } // if
    715717                        }
    716718                        if ( type->is_mutex() ) {
    717                                 mangleName << Encoding::qualifiers.at(Type::Mutex);
     719                                mangleName += Encoding::qualifiers.at(Type::Mutex);
    718720                        } // if
    719721                        if ( inFunctionType ) {
Note: See TracChangeset for help on using the changeset viewer.