Changeset 78a0b88 for src/ResolvExpr

Timestamp:

Sep 1, 2017, 3:33:25 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

bc3127d

Parents:

e8ccca3 (diff), a01f7c94 (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 plg2:software/cfa/cfa-cc

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (2 diffs)
• RenameVars.cc (modified) (1 diff)
• TypeEnvironment.cc (modified) (1 diff)
• TypeEnvironment.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -749 +749 @@
                                 if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->get_result()->stripReferences() ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
-                                                referenceToRvalueConversion( func->expr );
+                                                Alternative newFunc( *func );
+                                                referenceToRvalueConversion( newFunc.expr );
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                         // XXX
                                                         //Designators::check_alternative( function, *actualAlt );
-                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                        makeFunctionAlternatives( newFunc, function, *actualAlt, std::back_inserter( candidates ) );
                                                 }
                                         }
                                 } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
-                                        referenceToRvalueConversion( func->expr );
                                         EqvClass eqvClass;
                                         if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                        Alternative newFunc( *func );
+                                                        referenceToRvalueConversion( newFunc.expr );
                                                         for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                                makeFunctionAlternatives( newFunc, function, *actualAlt, std::back_inserter( candidates ) );
                                                         } // for
                                                 } // if
@@ -773 +775 @@
                                         if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
                                                 if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
-                                                        referenceToRvalueConversion( funcOp->expr );
+                                                        Alternative newFunc( *funcOp );
+                                                        referenceToRvalueConversion( newFunc.expr );
                                                         for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                                 AltList currentAlt;
                                                                 currentAlt.push_back( *func );
                                                                 currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
-                                                                makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
+                                                                makeFunctionAlternatives( newFunc, function, currentAlt, std::back_inserter( candidates ) );
                                                         } // for
                                                 } // if

src/ResolvExpr/RenameVars.cc

@@ -88 +88 @@
                 typeBefore( aggregateUseType );
                 acceptAll( aggregateUseType->get_parameters(), *this );
-                acceptAll( aggregateUseType->get_members(), *this );
                 typeAfter( aggregateUseType );
         }

src/ResolvExpr/TypeEnvironment.cc

@@ -25 +25 @@
 
 namespace ResolvExpr {
-        // adding this comparison operator significantly improves assertion resolution run time for
-        // some cases. The current resolution algorithm's speed partially depends on the order of
-        // assertions. Assertions which have fewer possible matches should appear before
-        // assertions which have more possible matches. This seems to imply that this could
-        // be further improved by providing an indexer as an additional argument and ordering based
-        // on the number of matches of the same kind (object, function) for the names of the
-        // declarations.
-        //
-        // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
-        bool AssertCompare::operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
-                        // Objects are always less than functions
-                        if ( ObjectDecl * objectDecl1 = dynamic_cast< ObjectDecl * >( d1 ) ) {
-                                if ( ObjectDecl * objectDecl2 = dynamic_cast< ObjectDecl * >( d2 ) ) {
-                                        // objects are ordered by name then type pointer, in that order
-                                        int cmp = objectDecl1->get_name().compare( objectDecl2->get_name() );
-                                        return cmp < 0 ||
-                                                ( cmp == 0 && objectDecl1->get_type() < objectDecl2->get_type() );
-                                } else {
-                                        return true;
-                                }
-                        } else if ( FunctionDecl * funcDecl1 = dynamic_cast< FunctionDecl * >( d1 ) ) {
-                                if ( FunctionDecl * funcDecl2 = dynamic_cast< FunctionDecl * >( d2 ) ) {
-                                        // functions are ordered by name, # parameters, # returnVals, type pointer in that order
-                                        FunctionType * ftype1 = funcDecl1->get_functionType();
-                                        FunctionType * ftype2 = funcDecl2->get_functionType();
-                                        int numThings1 = ftype1->get_parameters().size() + ftype1->get_returnVals().size();
-                                        int numThings2 = ftype2->get_parameters().size() + ftype2->get_returnVals().size();
-                                        if ( numThings1 < numThings2 ) return true;
-                                        if ( numThings1 > numThings2 ) return false;
-
-                                        // if ( ftype1->get_parameters().size() < ftype2->get_parameters().size() ) return true;
-                                        // else if ( ftype1->get_parameters().size() > ftype2->get_parameters().size() ) return false;
-                                        // // same number of parameters
-                                        // if ( ftype1->get_returnVals().size() < ftype2->get_returnVals().size() ) return true;
-                                        // else if ( ftype1->get_returnVals().size() > ftype2->get_returnVals().size() ) return false;
-                                        // same number of return vals
-                                        // int cmp = funcDecl1->get_name().compare( funcDecl2->get_name() );
-                                        // if ( cmp < 0 ) return true;
-                                        // else if ( cmp > 0 ) return false;
-                                        // // same name
-                                        return ftype1 < ftype2;
-                                } else {
-                                        return false;
-                                }
-                        } else {
-                                assert( false );
-                        }
-                }
-
         void printAssertionSet( const AssertionSet &assertions, std::ostream &os, int indent ) {
                 for ( AssertionSet::const_iterator i = assertions.begin(); i != assertions.end(); ++i ) {

src/ResolvExpr/TypeEnvironment.h

@@ -28 +28 @@
 
 namespace ResolvExpr {
+        // adding this comparison operator significantly improves assertion resolution run time for
+        // some cases. The current resolution algorithm's speed partially depends on the order of
+        // assertions. Assertions which have fewer possible matches should appear before
+        // assertions which have more possible matches. This seems to imply that this could
+        // be further improved by providing an indexer as an additional argument and ordering based
+        // on the number of matches of the same kind (object, function) for the names of the
+        // declarations.
+        //
+        // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
         struct AssertCompare {
-                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const;
+                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
+                        int cmp = d1->get_name().compare( d2->get_name() );
+                        return cmp < 0 ||
+                                ( cmp == 0 && d1->get_type() < d2->get_type() );
+                }
         };
         struct AssertionSetValue {