Changeset 78dd0da


Ignore:
Timestamp:
Dec 15, 2015, 2:56:43 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:
4389966, ffad73a
Parents:
5e92fee
Message:

Switched size/align parameters over to use SymTab::Mangler in preparation for addition of generic types

Location:
src
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/GenPoly/Box.cc

    r5e92fee r78dd0da  
    640640                }
    641641
    642                 Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr ) {
     642                Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, Type *polyType, bool isIncr ) {
    643643                        NameExpr *opExpr;
    644644                        if ( isIncr ) {
     
    653653                                addAssign->get_args().push_back( appExpr->get_args().front() );
    654654                        } // if
    655                         addAssign->get_args().push_back( new NameExpr( std::string("_sizeof_") + polyName ) );
     655                        addAssign->get_args().push_back( new NameExpr( sizeofName( polyType ) ) );
    656656                        addAssign->get_results().front() = appExpr->get_results().front()->clone();
    657657                        if ( appExpr->get_env() ) {
     
    680680                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    681681                                                        multiply->get_args().push_back( appExpr->get_args().back() );
    682                                                         multiply->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst1->get_name() ) );
     682                                                        multiply->get_args().push_back( new NameExpr( sizeofName( typeInst1 ) ) );
    683683                                                        ret->get_args().push_back( appExpr->get_args().front() );
    684684                                                        ret->get_args().push_back( multiply );
     
    686686                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    687687                                                        multiply->get_args().push_back( appExpr->get_args().front() );
    688                                                         multiply->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst2->get_name() ) );
     688                                                        multiply->get_args().push_back( new NameExpr( sizeofName( typeInst2 ) ) );
    689689                                                        ret->get_args().push_back( multiply );
    690690                                                        ret->get_args().push_back( appExpr->get_args().back() );
     
    732732                                                                assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
    733733                                                        } // if
    734                                                         CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) );
     734                                                        CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst, varExpr->get_var()->get_name() == "?++" ) );
    735735                                                        return new CommaExpr( firstComma, tempExpr );
    736736                                                } // if
     
    739739                                                assert( appExpr->get_args().size() == 1 );
    740740                                                if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
    741                                                         return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" );
     741                                                        return makeIncrDecrExpr( appExpr, typeInst, varExpr->get_var()->get_name() == "++?" );
    742742                                                } // if
    743743                                        } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
     
    749749                                                        UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
    750750                                                        divide->get_args().push_back( appExpr );
    751                                                         divide->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst1->get_name() ) );
     751                                                        divide->get_args().push_back( new NameExpr( sizeofName( typeInst1 ) ) );
    752752                                                        divide->get_results().push_front( appExpr->get_results().front()->clone() );
    753753                                                        if ( appExpr->get_env() ) {
     
    759759                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    760760                                                        multiply->get_args().push_back( appExpr->get_args().back() );
    761                                                         multiply->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst1->get_name() ) );
     761                                                        multiply->get_args().push_back( new NameExpr( sizeofName( typeInst1 ) ) );
    762762                                                        appExpr->get_args().back() = multiply;
    763763                                                } else if ( typeInst2 ) {
    764764                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    765765                                                        multiply->get_args().push_back( appExpr->get_args().front() );
    766                                                         multiply->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst2->get_name() ) );
     766                                                        multiply->get_args().push_back( new NameExpr( sizeofName( typeInst2 ) ) );
    767767                                                        appExpr->get_args().front() = multiply;
    768768                                                } // if
     
    774774                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    775775                                                        multiply->get_args().push_back( appExpr->get_args().back() );
    776                                                         multiply->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst->get_name() ) );
     776                                                        multiply->get_args().push_back( new NameExpr( sizeofName( typeInst ) ) );
    777777                                                        appExpr->get_args().back() = multiply;
    778778                                                } // if
     
    10091009                        std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
    10101010                        std::list< DeclarationWithType *> inferredParams;
    1011                         ObjectDecl *newObj = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
     1011                        ObjectDecl newObj( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
    10121012//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
    10131013                        for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
     
    10151015                                // add all size and alignment parameters to parameter list
    10161016                                if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
    1017                                         sizeParm = newObj->clone();
    1018                                         sizeParm->set_name( std::string("_sizeof_") + (*tyParm)->get_name() );
     1017                                        TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
     1018                                       
     1019                                        sizeParm = newObj.clone();
     1020                                        sizeParm->set_name( sizeofName( &parmType ) );
    10191021                                        last = funcType->get_parameters().insert( last, sizeParm );
    10201022                                        ++last;
    1021                                         alignParm = newObj->clone();
    1022                                         alignParm->set_name( std::string("_alignof_") + (*tyParm)->get_name() );
     1023
     1024                                        alignParm = newObj.clone();
     1025                                        alignParm->set_name( alignofName( &parmType ) );
    10231026                                        last = funcType->get_parameters().insert( last, alignParm );
    10241027                                        ++last;
     
    10311034                                (*tyParm)->get_assertions().clear();
    10321035                        }
    1033                         delete newObj;
    10341036                        funcType->get_parameters().splice( last, inferredParams );
    10351037                        addAdapters( funcType );
     
    11081110                                        assert( typeInst );
    11091111                                        UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
    1110                                         alloc->get_args().push_back( new NameExpr( std::string("_sizeof_") + typeInst->get_name() ) );
     1112                                        alloc->get_args().push_back( new NameExpr( sizeofName( typeInst ) ) );
    11111113
    11121114                                        delete objectDecl->get_init();
  • src/GenPoly/ScrubTyVars.cc

    r5e92fee r78dd0da  
    1414//
    1515
     16#include <sstream>
    1617#include <string>
    1718
    1819#include "GenPoly.h"
    1920#include "ScrubTyVars.h"
     21
     22#include "SymTab/Mangler.h"
    2023
    2124#include "SynTree/Mutator.h"
     
    4649                // sizeof( T ) => _sizeof_T parameter, which is the size of T
    4750                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( szeof->get_type() ) ) {
    48                         Expression *expr = new NameExpr( std::string("_sizeof_") + typeInst->get_name() );
     51                        Expression *expr = new NameExpr( sizeofName( typeInst ) );
    4952                        return expr;
    5053                } else {
     
    5659                // alignof( T ) => _alignof_T parameter, which is the alignment of T
    5760                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( algnof->get_type() ) ) {
    58                         Expression *expr = new NameExpr( std::string("_alignof_") + typeInst->get_name() );
     61                        Expression *expr = new NameExpr( alignofName( typeInst ) );
    5962                        return expr;
    6063                } else {
     
    7578                return Mutator::mutate( pointer );
    7679        }
     80       
     81        std::string sizeofName( Type *ty ) {
     82                return std::string( "_sizeof_" ) + SymTab::Mangler::mangle( ty, false, false );
     83        }
     84
     85        std::string alignofName( Type *ty ) {
     86                return std::string( "_alignof_" ) + SymTab::Mangler::mangle( ty, false, false );
     87        }
    7788} // namespace GenPoly
    7889
  • src/GenPoly/ScrubTyVars.h

    r5e92fee r78dd0da  
    1616#ifndef _SCRUBTYVARS_H
    1717#define _SCRUBTYVARS_H
     18
     19#include <string>
    1820
    1921#include "GenPoly.h"
     
    5759                return static_cast< SynTreeClass* >( target->acceptMutator( scrubber ) );
    5860        }
     61
     62        /// Gets the name of the sizeof parameter for the type
     63        std::string sizeofName( Type *ty );
     64
     65        /// Gets the name of the alignof parameter for the type
     66        std::string alignofName( Type *ty );
    5967} // namespace GenPoly
    6068
  • src/SymTab/Mangler.cc

    r5e92fee r78dd0da  
    3030
    3131namespace SymTab {
    32         Mangler::Mangler( bool mangleOverridable ) : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ) {
    33         }
    34 
    35 //Mangler::Mangler( const Mangler & )
    36 //  : mangleName(), varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( isTopLevel )
    37 //{
    38 //}
     32        Mangler::Mangler( bool mangleOverridable, bool includeQualifiers )
     33                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), includeQualifiers(includeQualifiers) {}
     34               
    3935        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
    4036                varNums = rhs.varNums;
     
    4238                isTopLevel = rhs.isTopLevel;
    4339                mangleOverridable = rhs.mangleOverridable;
     40                includeQualifiers = rhs.includeQualifiers;
    4441        }
    4542
     
    209206
    210207        void Mangler::printQualifiers( Type *type ) {
     208                // skip if not including qualifiers
     209                if ( ! includeQualifiers ) return;
     210               
    211211                if ( ! type->get_forall().empty() ) {
    212212                        std::list< std::string > assertionNames;
     
    227227                                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
    228228                                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
    229                                         Mangler sub_mangler( mangleOverridable );
     229                                        Mangler sub_mangler( mangleOverridable, includeQualifiers );
    230230                                        sub_mangler.nextVarNum = nextVarNum;
    231231                                        sub_mangler.isTopLevel = false;
  • src/SymTab/Mangler.h

    r5e92fee r78dd0da  
    2222
    2323namespace SymTab {
     24        /// Mangles names to a unique C identifier
    2425        class Mangler : public Visitor {
    2526          public:
    2627                template< typename SynTreeClass >
    27             static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true ); // interface to clients
     28            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool includeQualifiers = true ); // interface to clients
    2829
    29 ///   using Visitor::visit;
    3030                virtual void visit( ObjectDecl *declaration );
    3131                virtual void visit( FunctionDecl *declaration );
     
    4545                std::string get_mangleName() { return mangleName.str(); }
    4646          private:
    47                 std::ostringstream mangleName;
     47                std::ostringstream mangleName;  ///< Mangled name being constructed
    4848                typedef std::map< std::string, std::pair< int, int > > VarMapType;
    49                 VarMapType varNums;
    50                 int nextVarNum;
    51                 bool isTopLevel;
    52                 bool mangleOverridable;
     49                VarMapType varNums;             ///< Map of type variables to indices
     50                int nextVarNum;                 ///< Next type variable index
     51                bool isTopLevel;                ///< Is the Mangler at the top level
     52                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
     53                bool includeQualifiers;         ///< Include type qualifiers in mangled name
    5354 
    54                 Mangler( bool mangleOverridable );
     55                Mangler( bool mangleOverridable, bool includeQualifiers );
    5556                Mangler( const Mangler & );
    5657 
     
    6263
    6364        template< typename SynTreeClass >
    64         std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable ) {
    65                 Mangler mangler( mangleOverridable );
     65        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool includeQualifiers ) {
     66                Mangler mangler( mangleOverridable, includeQualifiers );
    6667                maybeAccept( decl, mangler );
    6768                return mangler.get_mangleName();
Note: See TracChangeset for help on using the changeset viewer.