Changeset 8e18b8e for src


Ignore:
Timestamp:
May 31, 2018, 4:24:49 PM (6 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
new-env, with_gc
Children:
0182bfa, 1d7b0a8
Parents:
75308bcc
Message:

stop eagerly copying EqvClass? on lookup

Location:
src/ResolvExpr
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • src/ResolvExpr/AdjustExprType.cc

    r75308bcc r8e18b8e  
    7474
    7575        Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
    76                 EqvClass eqvClass;
    77                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    78                         if ( eqvClass.data.kind == TypeDecl::Ftype ) {
     76                if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) {
     77                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
    7978                                return new PointerType{ Type::Qualifiers(), typeInst };
    8079                        }

  • src/ResolvExpr/AlternativeFinder.cc

    r75308bcc r8e18b8e  
    11091109                                        }
    11101110                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
    1111                                         EqvClass eqvClass;
    1112                                         if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
    1113                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
     1111                                        if ( const EqvClass *eqvClass = func->env.lookup( typeInst->get_name() ) ) {
     1112                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass->type ) ) {
    11141113                                                        Alternative newFunc( *func );
    11151114                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );

  • src/ResolvExpr/CastCost.cc

    r75308bcc r8e18b8e  
    4343        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4444                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    45                         EqvClass eqvClass;
    46                         NamedTypeDecl *namedType;
    47                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
    48                                 if ( eqvClass.type ) {
    49                                         return castCost( src, eqvClass.type, indexer, env );
     45                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     46                                if ( eqvClass->type ) {
     47                                        return castCost( src, eqvClass->type, indexer, env );
    5048                                } else {
    5149                                        return Cost::infinity;
    5250                                }
    53                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
     51                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
    5452                                // all typedefs should be gone by this point
    5553                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );

  • src/ResolvExpr/ConversionCost.cc

    r75308bcc r8e18b8e  
    4343        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4444                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    45                         EqvClass eqvClass;
    46                         NamedTypeDecl *namedType;
    4745                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
    48                         if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
    49                                 if ( eqvClass.type ) {
    50                                         return conversionCost( src, eqvClass.type, indexer, env );
     46                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) {
     47                                if ( eqvClass->type ) {
     48                                        return conversionCost( src, eqvClass->type, indexer, env );
    5149                                } else {
    5250                                        return Cost::infinity;
    5351                                }
    54                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
     52                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) {
    5553                                PRINT( std::cerr << " found" << std::endl; )
    5654                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    … …  
    362360
    363361        void ConversionCost::postvisit( TypeInstType *inst ) {
    364                 EqvClass eqvClass;
    365                 NamedTypeDecl *namedType;
    366                 if ( env.lookup( inst->name, eqvClass ) ) {
    367                         cost = costFunc( eqvClass.type, dest, indexer, env );
     362                if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) {
     363                        cost = costFunc( eqvClass->type, dest, indexer, env );
    368364                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    369365                        if ( inst->name == destAsInst->name ) {
    370366                                cost = Cost::zero;
    371367                        }
    372                 } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
     368                } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) {
    373369                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    374370                        // all typedefs should be gone by this point

  • src/ResolvExpr/Occurs.cc

    r75308bcc r8e18b8e  
    3838
    3939        Occurs::Occurs( std::string varName, const TypeEnvironment & env ) : result( false ), tenv( env ) {
    40                 EqvClass eqvClass;
    41                 if ( tenv.lookup( varName, eqvClass ) ) {
    42                         eqvVars = eqvClass.vars;
     40                if ( const EqvClass *eqvClass = tenv.lookup( varName ) ) {
     41                        eqvVars = eqvClass->vars;
    4342                } else {
    4443                        eqvVars.insert( varName );
    … …  
    4746
    4847        void Occurs::previsit( TypeInstType * typeInst ) {
    49                 EqvClass eqvClass;
    50 ///   std::cerr << "searching for vars: ";
     48                ///   std::cerr << "searching for vars: ";
    5149///   std::copy( eqvVars.begin(), eqvVars.end(), std::ostream_iterator< std::string >( std::cerr, " " ) );
    5250///   std::cerr << std::endl;
    5351                if ( eqvVars.find( typeInst->get_name() ) != eqvVars.end() ) {
    5452                        result = true;
    55                 } else if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
    56                         if ( eqvClass.type ) {
     53                } else if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
     54                        if ( eqvClass->type ) {
    5755///       std::cerr << typeInst->get_name() << " is bound to";
    5856///       eqvClass.type->print( std::cerr );
    5957///       std::cerr << std::endl;
    60                                 eqvClass.type->accept( *visitor );
     58                                eqvClass->type->accept( *visitor );
    6159                        } // if
    6260                } // if

  • src/ResolvExpr/PolyCost.cc

    r75308bcc r8e18b8e  
    3939
    4040        void PolyCost::previsit(TypeInstType * typeInst) {
    41                 EqvClass eqvClass;
    42                 if ( tenv.lookup( typeInst->name, eqvClass ) ) {
    43                         if ( eqvClass.type ) {
    44                                 if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass.type ) ) {
     41                if ( const EqvClass *eqvClass = tenv.lookup( typeInst->name ) ) {
     42                        if ( eqvClass->type ) {
     43                                if ( TypeInstType * otherTypeInst = dynamic_cast< TypeInstType* >( eqvClass->type ) ) {
    4544                                        if ( indexer.lookupType( otherTypeInst->name ) ) {
    4645                                                // bound to opaque type

  • src/ResolvExpr/PtrsAssignable.cc

    r75308bcc r8e18b8e  
    5151                // std::cerr << "assignable: " << src << " | " << dest << std::endl;
    5252                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    53                         EqvClass eqvClass;
    54                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
    55                                 return ptrsAssignable( src, eqvClass.type, env );
     53                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
     54                                return ptrsAssignable( src, eqvClass->type, env );
    5655                        } // if
    5756                } // if
    … …  
    9594        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
    9695        void PtrsAssignable::postvisit( TypeInstType *inst ) {
    97                 EqvClass eqvClass;
    98                 if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
    99                         // T * = S * for any S depends on the type bound to T
    100                         result = ptrsAssignable( eqvClass.type, dest, env );
     96                if ( const EqvClass *eqvClass = env.lookup( inst->get_name() ) ) {
     97                        if ( eqvClass->type ) {
     98                                // T * = S * for any S depends on the type bound to T
     99                                result = ptrsAssignable( eqvClass->type, dest, env );
     100                        }
    101101                } // if
    102102        }

  • src/ResolvExpr/PtrsCastable.cc

    r75308bcc r8e18b8e  
    5757                                return -1;
    5858                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( src ) ) {
    59                                 EqvClass eqvClass;
    6059                                if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    6160                                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    … …  
    6463                                                } // if
    6564                                        } //if
    66                                 } else if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    67                                         if ( eqvClass.data.kind == TypeDecl::Ftype ) {
     65                                } else if ( const EqvClass *eqvClass = env.lookup( typeInst->get_name() ) ) {
     66                                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
    6867                                                return -1;
    6968                                        } // if
    … …  
    7978        int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
    8079                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    81                         EqvClass eqvClass;
    82                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
     80                        if ( const EqvClass *eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
    8381                                // xxx - should this be ptrsCastable?
    84                                 return ptrsAssignable( src, eqvClass.type, env );
     82                                return ptrsAssignable( src, eqvClass->type, env );
    8583                        } // if
    8684                } // if

  • src/ResolvExpr/TypeEnvironment.cc

    r75308bcc r8e18b8e  
    1717#include <algorithm>                   // for copy, set_intersection
    1818#include <iterator>                    // for ostream_iterator, insert_iterator
    19 #include <utility>                     // for pair
     19#include <utility>                     // for pair, move
    2020
    2121#include "Common/PassVisitor.h"        // for PassVisitor<GcTracer>
    … …  
    7979        }
    8080
    81         bool TypeEnvironment::lookup( const std::string &var, EqvClass &eqvClass ) const {
     81        const EqvClass* TypeEnvironment::lookup( const std::string &var ) const {
    8282                for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
    8383                        if ( i->vars.find( var ) != i->vars.end() ) {
    8484///       std::cout << var << " is in class ";
    8585///       i->print( std::cout );
    86                                 eqvClass = *i;
    87                                 return true;
     86                                return &*i;
    8887                        }
    8988///     std::cout << var << " is not in class ";
    9089///     i->print( std::cout );
    9190                } // for
    92                 return false;
     91                return nullptr;
     92        }
     93
     94        /// Removes any class from env that intersects eqvClass
     95        void filterOverlappingClasses( std::list<EqvClass> &env, const EqvClass &eqvClass ) {
     96                for ( auto i = env.begin(); i != env.end(); ) {
     97                        auto next = i;
     98                        ++next;
     99                        std::set<std::string> intersection;
     100                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(),
     101                                std::inserter( intersection, intersection.begin() ) );
     102                        if ( ! intersection.empty() ) { env.erase( i ); }
     103                        i = next;
     104                }
    93105        }
    94106
    95107        void TypeEnvironment::add( const EqvClass &eqvClass ) {
    96                 std::list< EqvClass >::iterator i = env.begin();
    97                 while ( i != env.end() ) {
    98                         std::list< EqvClass >::iterator next = i;
    99                         next++;
    100                         std::set< std::string > intersection;
    101                         std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), std::inserter( intersection, intersection.begin() ) );
    102                         if ( ! intersection.empty() ) {
    103                                 env.erase( i );
    104                         } // if
    105                         i = next;
    106                 } // while
    107                 env.insert( env.end(), eqvClass );
     108                filterOverlappingClasses( env, eqvClass );
     109                env.push_back( eqvClass );
     110        }
     111
     112        void TypeEnvironment::add( EqvClass &&eqvClass ) {
     113                filterOverlappingClasses( env, eqvClass );
     114                env.push_back( std::move(eqvClass) );
    108115        }
    109116

  • src/ResolvExpr/TypeEnvironment.h

    r75308bcc r8e18b8e  
    8585        class TypeEnvironment {
    8686          public:
    87                 bool lookup( const std::string &var, EqvClass &eqvClass ) const;
     87                const EqvClass* lookup( const std::string &var ) const;
    8888                void add( const EqvClass &eqvClass );
     89                void add( EqvClass &&eqvClass  );
    8990                void add( const Type::ForallList &tyDecls );
    9091                void add( const TypeSubstitution & sub );

  • src/ResolvExpr/Unify.cc

    r75308bcc r8e18b8e  
    1919#include <set>                    // for set
    2020#include <string>                 // for string, operator==, operator!=, bas...
    21 #include <utility>                // for pair
     21#include <utility>                // for pair, move
    2222
    2323#include "Common/PassVisitor.h"   // for PassVisitor
    … …  
    159159                        return false;
    160160                } // if
    161                 EqvClass curClass;
    162                 if ( env.lookup( typeInst->get_name(), curClass ) ) {
    163                         if ( curClass.type ) {
     161                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
     162                        if ( curClass->type ) {
    164163                                Type *common = 0;
    165164                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
    166                                 Type* newType = curClass.type->clone();
     165                                Type* newType = curClass->type->clone();
    167166                                newType->get_qualifiers() = typeInst->get_qualifiers();
    168                                 if ( unifyInexact( newType, other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
     167                                if ( unifyInexact( newType, other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
    169168                                        if ( common ) {
    170169                                                common->get_qualifiers() = Type::Qualifiers();
    171                                                 curClass.type = common;
    172                                                 env.add( curClass );
     170                                                EqvClass newClass = *curClass;
     171                                                newClass.type = common;
     172                                                env.add( std::move(newClass) );
    173173                                        } // if
    174174                                        return true;
    … …  
    177177                                } // if
    178178                        } else {
    179                                 curClass.type = other->clone();
    180                                 curClass.type->get_qualifiers() = Type::Qualifiers();
    181                                 curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
    182                                 env.add( curClass );
     179                                EqvClass newClass = *curClass;
     180                                newClass.type = other->clone();
     181                                newClass.type->get_qualifiers() = Type::Qualifiers();
     182                                newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
     183                                env.add( std::move(newClass) );
    183184                        } // if
    184185                } else {
    … …  
    196197        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, const TypeDecl::Data & data, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
    197198                bool result = true;
    198                 EqvClass class1, class2;
    199                 bool hasClass1 = false, hasClass2 = false;
     199                const EqvClass *class1 = env.lookup( var1->get_name() );
     200                const EqvClass *class2 = env.lookup( var2->get_name() );
    200201                bool widen1 = false, widen2 = false;
    201                 Type *type1 = 0, *type2 = 0;
    202 
    203                 if ( env.lookup( var1->get_name(), class1 ) ) {
    204                         hasClass1 = true;
    205                         if ( class1.type ) {
    206                                 if ( occurs( class1.type, var2->get_name(), env ) ) {
     202                Type *type1 = nullptr, *type2 = nullptr;
     203
     204                if ( class1 ) {
     205                        if ( class1->type ) {
     206                                if ( occurs( class1->type, var2->get_name(), env ) ) {
    207207                                        return false;
    208208                                } // if
    209                                 type1 = class1.type->clone();
    210                         } // if
    211                         widen1 = widenMode.widenFirst && class1.allowWidening;
    212                 } // if
    213                 if ( env.lookup( var2->get_name(), class2 ) ) {
    214                         hasClass2 = true;
    215                         if ( class2.type ) {
    216                                 if ( occurs( class2.type, var1->get_name(), env ) ) {
     209                                type1 = class1->type->clone();
     210                        } // if
     211                        widen1 = widenMode.widenFirst && class1->allowWidening;
     212                } // if
     213                if ( class2 ) {
     214                        if ( class2->type ) {
     215                                if ( occurs( class2->type, var1->get_name(), env ) ) {
    217216                                        return false;
    218217                                } // if
    219                                 type2 = class2.type->clone();
    220                         } // if
    221                         widen2 = widenMode.widenSecond && class2.allowWidening;
     218                                type2 = class2->type->clone();
     219                        } // if
     220                        widen2 = widenMode.widenSecond && class2->allowWidening;
    222221                } // if
    223222
    … …  
    227226                        Type *common = 0;
    228227                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
    229                                 class1.vars.insert( class2.vars.begin(), class2.vars.end() );
    230                                 class1.allowWidening = widen1 && widen2;
     228                                EqvClass newClass1 = *class1;
     229                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     230                                newClass1.allowWidening = widen1 && widen2;
    231231                                if ( common ) {
    232232                                        common->get_qualifiers() = Type::Qualifiers();
    233                                         class1.type = common;
     233                                        newClass1.type = common;
    234234                                } // if
    235                                 env.add( class1 );
     235                                env.add( std::move(newClass1) );
    236236                        } else {
    237237                                result = false;
    238238                        } // if
    239                 } else if ( hasClass1 && hasClass2 ) {
     239                } else if ( class1 && class2 ) {
    240240                        if ( type1 ) {
    241                                 class1.vars.insert( class2.vars.begin(), class2.vars.end() );
    242                                 class1.allowWidening = widen1;
    243                                 env.add( class1 );
     241                                EqvClass newClass1 = *class1;
     242                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     243                                newClass1.allowWidening = widen1;
     244                                env.add( std::move(newClass1) );
    244245                        } else {
    245                                 class2.vars.insert( class1.vars.begin(), class1.vars.end() );
    246                                 class2.allowWidening = widen2;
    247                                 env.add( class2 );
    248                         } // if
    249                 } else if ( hasClass1 ) {
    250                         class1.vars.insert( var2->get_name() );
    251                         class1.allowWidening = widen1;
    252                         env.add( class1 );
    253                 } else if ( hasClass2 ) {
    254                         class2.vars.insert( var1->get_name() );
    255                         class2.allowWidening = widen2;
    256                         env.add( class2 );
     246                                EqvClass newClass2 = *class2;
     247                                newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
     248                                newClass2.allowWidening = widen2;
     249                                env.add( std::move(newClass2) );
     250                        } // if
     251                } else if ( class1 ) {
     252                        EqvClass newClass1 = *class1;
     253                        newClass1.vars.insert( var2->get_name() );
     254                        newClass1.allowWidening = widen1;
     255                        env.add( std::move(newClass1) );
     256                } else if ( class2 ) {
     257                        EqvClass newClass2 = *class2;
     258                        newClass2.vars.insert( var1->get_name() );
     259                        newClass2.allowWidening = widen2;
     260                        env.add( std::move(newClass2) );
    257261                } else {
    258262                        EqvClass newClass;
    … …  
    521525                void premutate( TypeInstType * ) { visit_children = false; }
    522526                Type * postmutate( TypeInstType * typeInst ) {
    523                         EqvClass eqvClass;
    524                         if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
    525                                 if ( eqvClass.data.kind == TypeDecl::Ttype ) {
    526                                         // expand ttype parameter into its actual type
    527                                         if ( eqvClass.type ) {
    528                                                 return eqvClass.type->clone();
    529                                         }
     527                        if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
     528                                // expand ttype parameter into its actual type
     529                                if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
     530                                        return eqvClass->type->clone();
    530531                                }
    531532                        }
Note: See TracChangeset for help on using the changeset viewer.