Changeset 00ac42e


Ignore:
Timestamp:
Jun 1, 2018, 2:54:55 PM (4 years ago)
Author:
Aaron Moss <a3moss@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, with_gc
Children:
262bd63
Parents:
41e16b1
git-author:
Aaron Moss <a3moss@…> (05/31/18 16:24:49)
git-committer:
Aaron Moss <a3moss@…> (06/01/18 14:54:55)
Message:

stop eagerly copying EqvClass? on lookup

Location:
src
Files:
12 edited

Legend:

Unmodified
Added
Removed
  • src/ResolvExpr/AdjustExprType.cc

    r41e16b1 r00ac42e  
    6666
    6767        Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
    68                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
     68                PointerType *pointerType = new PointerType{ arrayType->get_qualifiers(), arrayType->base };
    6969                arrayType->base = nullptr;
    7070                delete arrayType;
     
    7373
    7474        Type * AdjustExprType::postmutate( FunctionType * functionType ) {
    75                 return new PointerType( Type::Qualifiers(), functionType );
     75                return new PointerType{ Type::Qualifiers(), functionType };
    7676        }
    7777
    7878        Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
    79                 EqvClass eqvClass;
    80                 if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
    81                         if ( eqvClass.data.kind == TypeDecl::Ftype ) {
    82                                 PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
    83                                 return pointerType;
     79                if ( const EqvClass* eqvClass = env.lookup( typeInst->get_name() ) ) {
     80                        if ( eqvClass->data.kind == TypeDecl::Ftype ) {
     81                                return new PointerType{ Type::Qualifiers(), typeInst };
    8482                        }
    8583                } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
    8684                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
    8785                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
    88                                         PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
    89                                         return pointerType;
     86                                        return new PointerType{ Type::Qualifiers(), typeInst };
    9087                                } // if
    9188                        } // if
  • src/ResolvExpr/AlternativeFinder.cc

    r41e16b1 r00ac42e  
    102102                void addAnonConversions( const Alternative & alt );
    103103                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    104                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
     104                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
    105105                /// Adds alternatives for member expressions where the left side has tuple type
    106106                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
     
    307307
    308308                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->result ) ) {
    309                         NameExpr nameExpr( "" );
    310                         addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
     309                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
    311310                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) {
    312                         NameExpr nameExpr( "" );
    313                         addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
     311                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
    314312                } // if
    315313        }
    316314
    317315        template< typename StructOrUnionType >
    318         void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    319                 // by this point, member must be a name expr
    320                 NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
    321                 if ( ! nameExpr ) return;
    322                 const std::string & name = nameExpr->name;
     316        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
    323317                std::list< Declaration* > members;
    324318                aggInst->lookup( name, members );
     
    472466        }
    473467
    474         // /// Map of declaration uniqueIds (intended to be the assertions in an AssertionSet) to their parents and the number of times they've been included
    475         //typedef std::unordered_map< UniqueId, std::unordered_map< UniqueId, unsigned > > AssertionParentSet;
    476 
    477468        static const int recursionLimit = /*10*/ 4;  ///< Limit to depth of recursion satisfaction
    478         //static const unsigned recursionParentLimit = 1;  ///< Limit to the number of times an assertion can recursively use itself
    479469
    480470        void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
     
    487477
    488478        template< typename ForwardIterator, typename OutputIterator >
    489         void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, /*const AssertionParentSet &needParents,*/
    490                                                  int level, const SymTab::Indexer &indexer, OutputIterator out ) {
     479        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, int level, const SymTab::Indexer &indexer, OutputIterator out ) {
    491480                if ( begin == end ) {
    492481                        if ( newNeed.empty() ) {
     
    506495                                        printAssertionSet( newNeed, std::cerr, 8 );
    507496                                )
    508                                 inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, /*needParents,*/ level+1, indexer, out );
     497                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
    509498                                return;
    510499                        }
     
    513502                ForwardIterator cur = begin++;
    514503                if ( ! cur->second.isUsed ) {
    515                         inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
     504                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
    516505                        return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
    517506                }
     
    566555                                }
    567556
    568                                 //AssertionParentSet newNeedParents( needParents );
    569                                 // skip repeatingly-self-recursive assertion satisfaction
    570                                 // DOESN'T WORK: grandchild nodes conflict with their cousins
    571                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
    572 
    573557                                Expression *varExpr = data.combine( newerAlt.cvtCost );
    574558                                delete varExpr->get_result();
     
    588572                                // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
    589573                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
    590                                 inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
     574                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
    591575                        } else {
    592576                                delete adjType;
     
    610594                addToIndexer( have, decls );
    611595                AssertionSet newNeed;
    612                 //AssertionParentSet needParents;
    613596                PRINT(
    614597                        std::cerr << "env is: " << std::endl;
     
    617600                )
    618601
    619                 inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
     602                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
    620603//      PRINT(
    621604//          std::cerr << "declaration 14 is ";
     
    10961079                AlternativeFinder funcOpFinder( indexer, env );
    10971080                // it's ok if there aren't any defined function ops
    1098                 funcOpFinder.maybeFind( opExpr);
     1081                funcOpFinder.maybeFind( opExpr );
    10991082                PRINT(
    11001083                        std::cerr << "known function ops:" << std::endl;
     
    11331116                                        }
    11341117                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->result->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
    1135                                         EqvClass eqvClass;
    1136                                         if ( func->env.lookup( typeInst->name, eqvClass ) && eqvClass.type ) {
    1137                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
     1118                                        if ( const EqvClass *eqvClass = func->env.lookup( typeInst->name ) ) {
     1119                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass->type ) ) {
    11381120                                                        Alternative newFunc( *func );
    11391121                                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
     
    13501332        }
    13511333
     1334        namespace {
     1335                /// Gets name from untyped member expression (member must be NameExpr)
     1336                const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
     1337                        NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
     1338                        assert( nameExpr );
     1339                        return nameExpr->get_name();
     1340                }
     1341        }
     1342
    13521343        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
    13531344                AlternativeFinder funcFinder( indexer, env );
     
    13621353                        // find member of the given type
    13631354                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
    1364                                 addAggMembers( structInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
     1355                                addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
    13651356                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
    1366                                 addAggMembers( unionInst, aggrExpr, cost, agg->env, memberExpr->get_member() );
     1357                                addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
    13671358                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
    13681359                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
  • src/ResolvExpr/CastCost.cc

    r41e16b1 r00ac42e  
    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

    r41e16b1 r00ac42e  
    4242        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
    4343                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
    44                         EqvClass eqvClass;
    45                         NamedTypeDecl *namedType;
    4644                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
    47                         if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
    48                                 if ( eqvClass.type ) {
    49                                         return conversionCost( src, eqvClass.type, indexer, env );
     45                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->name ) ) {
     46                                if ( eqvClass->type ) {
     47                                        return conversionCost( src, eqvClass->type, indexer, env );
    5048                                } else {
    5149                                        return Cost::infinity;
    5250                                }
    53                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
     51                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->name ) ) {
    5452                                PRINT( std::cerr << " found" << std::endl; )
    5553                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
     
    369367
    370368        void ConversionCost::postvisit( TypeInstType *inst ) {
    371                 EqvClass eqvClass;
    372                 NamedTypeDecl *namedType;
    373                 if ( env.lookup( inst->name, eqvClass ) ) {
    374                         cost = costFunc( eqvClass.type, dest, indexer, env );
     369                if ( const EqvClass *eqvClass = env.lookup( inst->name ) ) {
     370                        cost = costFunc( eqvClass->type, dest, indexer, env );
    375371                } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
    376372                        if ( inst->name == destAsInst->name ) {
    377373                                cost = Cost::zero;
    378374                        }
    379                 } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
     375                } else if ( NamedTypeDecl *namedType = indexer.lookupType( inst->name ) ) {
    380376                        TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
    381377                        // all typedefs should be gone by this point
  • src/ResolvExpr/Occurs.cc

    r41e16b1 r00ac42e  
    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

    r41e16b1 r00ac42e  
    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

    r41e16b1 r00ac42e  
    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

    r41e16b1 r00ac42e  
    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

    r41e16b1 r00ac42e  
    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/utility.h"            // for maybeClone
     
    4444
    4545        void EqvClass::initialize( const EqvClass &src, EqvClass &dest ) {
     46                initialize( src, dest, src.type );
     47        }
     48
     49        void EqvClass::initialize( const EqvClass &src, EqvClass &dest, const Type *ty ) {
    4650                dest.vars = src.vars;
    47                 dest.type = maybeClone( src.type );
     51                dest.type = maybeClone( ty );
    4852                dest.allowWidening = src.allowWidening;
    4953                dest.data = src.data;
     
    5559        EqvClass::EqvClass( const EqvClass &other ) {
    5660                initialize( other, *this );
     61        }
     62
     63        EqvClass::EqvClass( const EqvClass &other, const Type *ty ) {
     64                initialize( other, *this, ty );
    5765        }
    5866
     
    8290        }
    8391
    84         bool TypeEnvironment::lookup( const std::string &var, EqvClass &eqvClass ) const {
     92        const EqvClass* TypeEnvironment::lookup( const std::string &var ) const {
    8593                for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
    8694                        if ( i->vars.find( var ) != i->vars.end() ) {
    8795///       std::cout << var << " is in class ";
    8896///       i->print( std::cout );
    89                                 eqvClass = *i;
    90                                 return true;
     97                                return &*i;
    9198                        }
    9299///     std::cout << var << " is not in class ";
    93100///     i->print( std::cout );
    94101                } // for
    95                 return false;
     102                return nullptr;
     103        }
     104
     105        /// Removes any class from env that intersects eqvClass
     106        void filterOverlappingClasses( std::list<EqvClass> &env, const EqvClass &eqvClass ) {
     107                for ( auto i = env.begin(); i != env.end(); ) {
     108                        auto next = i;
     109                        ++next;
     110                        std::set<std::string> intersection;
     111                        std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(),
     112                                std::inserter( intersection, intersection.begin() ) );
     113                        if ( ! intersection.empty() ) { env.erase( i ); }
     114                        i = next;
     115                }
    96116        }
    97117
    98118        void TypeEnvironment::add( const EqvClass &eqvClass ) {
    99                 std::list< EqvClass >::iterator i = env.begin();
    100                 while ( i != env.end() ) {
    101                         std::list< EqvClass >::iterator next = i;
    102                         next++;
    103                         std::set< std::string > intersection;
    104                         std::set_intersection( i->vars.begin(), i->vars.end(), eqvClass.vars.begin(), eqvClass.vars.end(), std::inserter( intersection, intersection.begin() ) );
    105                         if ( ! intersection.empty() ) {
    106                                 env.erase( i );
    107                         } // if
    108                         i = next;
    109                 } // while
    110                 env.insert( env.end(), eqvClass );
     119                filterOverlappingClasses( env, eqvClass );
     120                env.push_back( eqvClass );
     121        }
     122
     123        void TypeEnvironment::add( EqvClass &&eqvClass ) {
     124                filterOverlappingClasses( env, eqvClass );
     125                env.push_back( std::move(eqvClass) );
    111126        }
    112127
  • src/ResolvExpr/TypeEnvironment.h

    r41e16b1 r00ac42e  
    7373
    7474                void initialize( const EqvClass &src, EqvClass &dest );
     75                void initialize( const EqvClass &src, EqvClass &dest, const Type *ty );
    7576                EqvClass();
    7677                EqvClass( const EqvClass &other );
     78                EqvClass( const EqvClass &other, const Type *ty );
    7779                EqvClass &operator=( const EqvClass &other );
    7880                ~EqvClass();
     
    8284        class TypeEnvironment {
    8385          public:
    84                 bool lookup( const std::string &var, EqvClass &eqvClass ) const;
     86                const EqvClass* lookup( const std::string &var ) const;
    8587                void add( const EqvClass &eqvClass );
     88                void add( EqvClass &&eqvClass  );
    8689                void add( const Type::ForallList &tyDecls );
    8790                void add( const TypeSubstitution & sub );
  • src/ResolvExpr/Unify.cc

    r41e16b1 r00ac42e  
    2020#include <set>                    // for set
    2121#include <string>                 // for string, operator==, operator!=, bas...
    22 #include <utility>                // for pair
     22#include <utility>                // for pair, move
    2323
    2424#include "Common/PassVisitor.h"   // for PassVisitor
     
    166166                        return false;
    167167                } // if
    168                 EqvClass curClass;
    169                 if ( env.lookup( typeInst->get_name(), curClass ) ) {
    170                         if ( curClass.type ) {
     168                if ( const EqvClass *curClass = env.lookup( typeInst->get_name() ) ) {
     169                        if ( curClass->type ) {
    171170                                Type *common = 0;
    172171                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
    173                                 std::unique_ptr< Type > newType( curClass.type->clone() );
     172                                std::unique_ptr< Type > newType( curClass->type->clone() );
    174173                                newType->get_qualifiers() = typeInst->get_qualifiers();
    175                                 if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
     174                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass->allowWidening, true ), indexer, common ) ) {
    176175                                        if ( common ) {
    177176                                                common->get_qualifiers() = Type::Qualifiers();
    178                                                 delete curClass.type;
    179                                                 curClass.type = common;
    180                                                 env.add( curClass );
     177                                                env.add( EqvClass{ *curClass, common } );
    181178                                        } // if
    182179                                        return true;
     
    185182                                } // if
    186183                        } else {
    187                                 curClass.type = other->clone();
    188                                 curClass.type->get_qualifiers() = Type::Qualifiers();
    189                                 curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
    190                                 env.add( curClass );
     184                                EqvClass newClass { *curClass, other };
     185                                newClass.type->get_qualifiers() = Type::Qualifiers();
     186                                newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
     187                                env.add( std::move(newClass) );
    191188                        } // if
    192189                } else {
     
    204201        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 ) {
    205202                bool result = true;
    206                 EqvClass class1, class2;
    207                 bool hasClass1 = false, hasClass2 = false;
     203                const EqvClass *class1 = env.lookup( var1->get_name() );
     204                const EqvClass *class2 = env.lookup( var2->get_name() );
    208205                bool widen1 = false, widen2 = false;
    209                 Type *type1 = 0, *type2 = 0;
    210 
    211                 if ( env.lookup( var1->get_name(), class1 ) ) {
    212                         hasClass1 = true;
    213                         if ( class1.type ) {
    214                                 if ( occurs( class1.type, var2->get_name(), env ) ) {
     206                Type *type1 = nullptr, *type2 = nullptr;
     207
     208                if ( class1 ) {
     209                        if ( class1->type ) {
     210                                if ( occurs( class1->type, var2->get_name(), env ) ) {
    215211                                        return false;
    216212                                } // if
    217                                 type1 = class1.type->clone();
    218                         } // if
    219                         widen1 = widenMode.widenFirst && class1.allowWidening;
    220                 } // if
    221                 if ( env.lookup( var2->get_name(), class2 ) ) {
    222                         hasClass2 = true;
    223                         if ( class2.type ) {
    224                                 if ( occurs( class2.type, var1->get_name(), env ) ) {
     213                                type1 = class1->type->clone();
     214                        } // if
     215                        widen1 = widenMode.widenFirst && class1->allowWidening;
     216                } // if
     217                if ( class2 ) {
     218                        if ( class2->type ) {
     219                                if ( occurs( class2->type, var1->get_name(), env ) ) {
    225220                                        return false;
    226221                                } // if
    227                                 type2 = class2.type->clone();
    228                         } // if
    229                         widen2 = widenMode.widenSecond && class2.allowWidening;
     222                                type2 = class2->type->clone();
     223                        } // if
     224                        widen2 = widenMode.widenSecond && class2->allowWidening;
    230225                } // if
    231226
     
    235230                        Type *common = 0;
    236231                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
    237                                 class1.vars.insert( class2.vars.begin(), class2.vars.end() );
    238                                 class1.allowWidening = widen1 && widen2;
     232                                EqvClass newClass1 = *class1;
     233                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     234                                newClass1.allowWidening = widen1 && widen2;
    239235                                if ( common ) {
    240236                                        common->get_qualifiers() = Type::Qualifiers();
    241                                         delete class1.type;
    242                                         class1.type = common;
     237                                        delete newClass1.type;
     238                                        newClass1.type = common;
    243239                                } // if
    244                                 env.add( class1 );
     240                                env.add( std::move(newClass1) );
    245241                        } else {
    246242                                result = false;
    247243                        } // if
    248                 } else if ( hasClass1 && hasClass2 ) {
     244                } else if ( class1 && class2 ) {
    249245                        if ( type1 ) {
    250                                 class1.vars.insert( class2.vars.begin(), class2.vars.end() );
    251                                 class1.allowWidening = widen1;
    252                                 env.add( class1 );
     246                                EqvClass newClass1 = *class1;
     247                                newClass1.vars.insert( class2->vars.begin(), class2->vars.end() );
     248                                newClass1.allowWidening = widen1;
     249                                env.add( std::move(newClass1) );
    253250                        } else {
    254                                 class2.vars.insert( class1.vars.begin(), class1.vars.end() );
    255                                 class2.allowWidening = widen2;
    256                                 env.add( class2 );
    257                         } // if
    258                 } else if ( hasClass1 ) {
    259                         class1.vars.insert( var2->get_name() );
    260                         class1.allowWidening = widen1;
    261                         env.add( class1 );
    262                 } else if ( hasClass2 ) {
    263                         class2.vars.insert( var1->get_name() );
    264                         class2.allowWidening = widen2;
    265                         env.add( class2 );
     251                                EqvClass newClass2 = *class2;
     252                                newClass2.vars.insert( class1->vars.begin(), class1->vars.end() );
     253                                newClass2.allowWidening = widen2;
     254                                env.add( std::move(newClass2) );
     255                        } // if
     256                } else if ( class1 ) {
     257                        EqvClass newClass1 = *class1;
     258                        newClass1.vars.insert( var2->get_name() );
     259                        newClass1.allowWidening = widen1;
     260                        env.add( std::move(newClass1) );
     261                } else if ( class2 ) {
     262                        EqvClass newClass2 = *class2;
     263                        newClass2.vars.insert( var1->get_name() );
     264                        newClass2.allowWidening = widen2;
     265                        env.add( std::move(newClass2) );
    266266                } else {
    267267                        EqvClass newClass;
     
    539539                void premutate( TypeInstType * ) { visit_children = false; }
    540540                Type * postmutate( TypeInstType * typeInst ) {
    541                         EqvClass eqvClass;
    542                         if ( tenv.lookup( typeInst->get_name(), eqvClass ) ) {
    543                                 if ( eqvClass.data.kind == TypeDecl::Ttype ) {
    544                                         // expand ttype parameter into its actual type
    545                                         if ( eqvClass.type ) {
    546                                                 delete typeInst;
    547                                                 return eqvClass.type->clone();
    548                                         }
     541                        if ( const EqvClass *eqvClass = tenv.lookup( typeInst->get_name() ) ) {
     542                                // expand ttype parameter into its actual type
     543                                if ( eqvClass->data.kind == TypeDecl::Ttype && eqvClass->type ) {
     544                                        delete typeInst;
     545                                        return eqvClass->type->clone();
    549546                                }
    550547                        }
  • src/benchmark/Makefile.in

    r41e16b1 r00ac42e  
    682682
    683683compile-io$(EXEEXT):
    684         @${CC} -quiet -fsyntax-only -w ../tests/io.c                                    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     684        @${CC} -quiet -fsyntax-only -w ../tests/io1.c                           @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    685685
    686686compile-monitor$(EXEEXT):
    687         @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c            @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     687        @${CC} -quiet -fsyntax-only -w ../tests/concurrent/monitor.c    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    688688
    689689compile-operators$(EXEEXT):
     
    694694
    695695compile-typeof$(EXEEXT):
    696         @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
     696        @${CC} -quiet -fsyntax-only -w ../tests/typeof.c                        @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
    697697
    698698# Tell versions [3.59,3.63) of GNU make to not export all variables.
Note: See TracChangeset for help on using the changeset viewer.