Changeset 4e2b9710 for src/ResolvExpr

Timestamp:

Aug 25, 2016, 9:14:18 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, 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:

a839867

Parents:

c1c1112 (diff), 486341f (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) (5 diffs)
• Resolver.cc (modified) (2 diffs)
• TypeEnvironment.cc (modified) (2 diffs)
• TypeEnvironment.h (modified) (4 diffs)
• Unify.cc (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -244 +244 @@
                 for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
                         if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                                alternatives.push_back( Alternative( new MemberExpr( dwt->clone(), expr->clone() ), env, newCost ) );
+                                alternatives.push_back( Alternative( new MemberExpr( dwt, expr->clone() ), env, newCost ) );
                                 renameTypes( alternatives.back().expr );
                         } else {
@@ -418 +418 @@
         // /// Map of declaration uniqueIds (intended to be the assertions in an AssertionSet) to their parents and the number of times they've been included
         //typedef std::unordered_map< UniqueId, std::unordered_map< UniqueId, unsigned > > AssertionParentSet;
-        
+
         static const int recursionLimit = /*10*/ 4;  ///< Limit to depth of recursion satisfaction
         //static const unsigned recursionParentLimit = 1;  ///< Limit to the number of times an assertion can recursively use itself
@@ -429 +429 @@
                 }
         }
-        
+
         template< typename ForwardIterator, typename OutputIterator >
-        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, /*const AssertionParentSet &needParents,*/ 
+        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, /*const AssertionParentSet &needParents,*/
                                                  int level, const SymTab::Indexer &indexer, OutputIterator out ) {
                 if ( begin == end ) {
@@ -469 +469 @@
                                 std::cerr << std::endl;
                         )
-                        
+
                         AssertionSet newHave, newerNeed( newNeed );
                         TypeEnvironment newEnv( newAlt.env );
@@ -847 +847 @@
                 for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
                         if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                                alternatives.push_back( Alternative( new OffsetofExpr( aggInst->clone(), dwt->clone() ), env, Cost::zero ) );
+                                alternatives.push_back( Alternative( new OffsetofExpr( aggInst->clone(), dwt ), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } else {

src/ResolvExpr/Resolver.cc

@@ -446 +446 @@
                 } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
                         resolveAggrInit( st->get_baseStruct(), iter, end );
-                } else if ( UnionInstType *st = dynamic_cast< UnionInstType * >( initContext ) ) {
+                } else if ( UnionInstType * st = dynamic_cast< UnionInstType * >( initContext ) ) {
                         resolveAggrInit( st->get_baseUnion(), iter, end );
+                } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
+                        Type * base = tt->get_baseType()->get_base();
+                        if ( base ) {
+                                // know the implementation type, so try using that as the initContext
+                                initContext = base;
+                                visit( listInit );
+                        } else {
+                                // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
+                                Visitor::visit( listInit );
+                        }
                 } else {
+                        assert( dynamic_cast< BasicType * >( initContext ) || dynamic_cast< PointerType * >( initContext ) );
                         // basic types are handled here
                         Visitor::visit( listInit );
@@ -539 +550 @@
                 }
 
-                // xxx - todo
-                // if ( InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
-                //      // can reduce the constructor down to a SingleInit using the
-                //      // second argument from the ctor call
-                // }
-
                 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
                         delete ctorInit->get_dtor();
                         ctorInit->set_dtor( NULL );
                 }
+
+                // xxx - todo -- what about arrays?
+                // if ( dtor == NULL && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                //      // can reduce the constructor down to a SingleInit using the
+                //      // second argument from the ctor call, since
+                //      delete ctorInit->get_ctor();
+                //      ctorInit->set_ctor( NULL );
+
+                //      Expression * arg =
+                //      ctorInit->set_init( new SingleInit( arg ) );
+                // }
         }
 } // namespace ResolvExpr

src/ResolvExpr/TypeEnvironment.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeEnvironment.cc -- 
+// TypeEnvironment.cc --
 //
 // Author           : Richard C. Bilson
@@ -23 +23 @@
 
 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 ) {
+                        // 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

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TypeEnvironment.h -- 
+// TypeEnvironment.h --
 //
 // Author           : Richard C. Bilson
@@ -28 +28 @@
 
 namespace ResolvExpr {
-        typedef std::map< DeclarationWithType*, bool > AssertionSet;
+        struct AssertCompare {
+                bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 );
+        };
+        typedef std::map< DeclarationWithType*, bool, AssertCompare > AssertionSet;
         typedef std::map< std::string, TypeDecl::Kind > OpenVarSet;
 
@@ -39 +42 @@
                 bool allowWidening;
                 TypeDecl::Kind kind;
-  
+
                 void initialize( const EqvClass &src, EqvClass &dest );
                 EqvClass();
@@ -62 +65 @@
                 void extractOpenVars( OpenVarSet &openVars ) const;
                 TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
-  
+
                 typedef std::list< EqvClass >::iterator iterator;
                 iterator begin() { return env.begin(); }

src/ResolvExpr/Unify.cc

@@ -484 +484 @@
                 FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
                 if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
-
-                        if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-
-                                if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-
-                                        markAssertions( haveAssertions, needAssertions, functionType );
-                                        markAssertions( haveAssertions, needAssertions, otherFunction );
-
-                                        result = true;
+                        if ( functionType->get_parameters().size() == otherFunction->get_parameters().size() && functionType->get_returnVals().size() == otherFunction->get_returnVals().size() ) {
+                                if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                        if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+
+                                                markAssertions( haveAssertions, needAssertions, functionType );
+                                                markAssertions( haveAssertions, needAssertions, otherFunction );
+
+                                                result = true;
+                                        } // if
                                 } // if
                         } // if