Changeset f80e0218 for src/ResolvExpr

Timestamp:

Jun 30, 2016, 4:32:56 PM (10 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

ea29e73

Parents:

1b5c81ed (diff), 84d4d6f (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' into gc_noraii

Conflicts:

Jenkinsfile
src/SymTab/Validate.cc

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (14 diffs)
• AlternativeFinder.h (modified) (3 diffs)
• CommonType.cc (modified) (3 diffs)
• ConversionCost.cc (modified) (2 diffs)
• RenameVars.cc (modified) (4 diffs)
• Resolver.cc (modified) (18 diffs)
• Resolver.h (modified) (2 diffs)
• typeops.h (modified) (1 diff)

src/ResolvExpr/AlternativeFinder.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:52:08 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Feb 10 17:00:04 2016
-// Update Count     : 24
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon Jun 13 16:13:54 2016
+// Update Count     : 25
 //
 
@@ -19 +19 @@
 #include <functional>
 #include <cassert>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 
 #include "AlternativeFinder.h"
@@ -39 +42 @@
 #include "Tuples/NameMatcher.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 extern bool resolvep;
@@ -407 +411 @@
         }
 
-        static const int recursionLimit = 10;
+        // /// 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
 
         void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
@@ -416 +424 @@
                 }
         }
-
+        
         template< typename ForwardIterator, typename OutputIterator >
-        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 ) {
+        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 ) {
                         if ( newNeed.empty() ) {
@@ -431 +440 @@
                                         printAssertionSet( newNeed, std::cerr, 8 );
                                 )
-                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
+                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, /*needParents,*/ level+1, indexer, out );
                                 return;
                         }
@@ -438 +447 @@
                 ForwardIterator cur = begin++;
                 if ( ! cur->second ) {
-                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
+                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
                 }
                 DeclarationWithType *curDecl = cur->first;
@@ -455 +464 @@
                                 std::cerr << std::endl;
                         )
+                        
                         AssertionSet newHave, newerNeed( newNeed );
                         TypeEnvironment newEnv( newAlt.env );
@@ -477 +487 @@
                                 newerAlt.env = newEnv;
                                 assert( (*candidate)->get_uniqueId() );
-                                Expression *varExpr = new VariableExpr( static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) ) );
+                                DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
+                                //AssertionParentSet newNeedParents( needParents );
+                                // skip repeatingly-self-recursive assertion satisfaction
+                                // DOESN'T WORK: grandchild nodes conflict with their cousins
+                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
+                                Expression *varExpr = new VariableExpr( candDecl );
                                 deleteAll( varExpr->get_results() );
                                 varExpr->get_results().clear();
@@ -491 +506 @@
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
                                 appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
-                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
+                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
                         } else {
                                 delete adjType;
@@ -513 +528 @@
                 addToIndexer( have, decls );
                 AssertionSet newNeed;
-                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
+                //AssertionParentSet needParents;
+                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, /*needParents,*/ 0, indexer, out );
 //      PRINT(
 //          std::cerr << "declaration 14 is ";
@@ -546 +562 @@
 
                 {
-                        NameExpr *fname = 0;;
-                        if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
-                                 && ( fname->get_name() == std::string("&&")) ) {
+                        std::string fname = InitTweak::getFunctionName( untypedExpr );
+                        if ( fname == "&&" ) {
                                 VoidType v = Type::Qualifiers();                // resolve to type void *
                                 PointerType pt( Type::Qualifiers(), v.clone() );
@@ -757 +772 @@
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
+                        newExpr.set_extension( nameExpr->get_extension() );
                         alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
                         PRINT(
@@ -982 +998 @@
                 } // for
         }
+
+        void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AlternativeFinder.h -- 
+// AlternativeFinder.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:56:12 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 16 23:58:43 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Apr 19 11:44:53 2016
 // Update Count     : 2
-// 
+//
 
 #ifndef ALTERNATIVEFINDER_H
@@ -54 +54 @@
                 virtual void visit( NameExpr *variableExpr );
                 virtual void visit( VariableExpr *variableExpr );
-                virtual void visit( ConstantExpr *constantExpr ); 
+                virtual void visit( ConstantExpr *constantExpr );
                 virtual void visit( SizeofExpr *sizeofExpr );
                 virtual void visit( AlignofExpr *alignofExpr );
@@ -65 +65 @@
                 virtual void visit( CommaExpr *commaExpr );
                 virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
           public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
                 template< typename InputIterator, typename OutputIterator >

src/ResolvExpr/CommonType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CommonType.cc -- 
+// CommonType.cc --
 //
 // Author           : Richard C. Bilson
@@ -134 +134 @@
                                 result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
                         } // if
+                } else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
+                        // use signed int in lieu of the enum type
+                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
+                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+                        } // if
                 } // if
         }
@@ -183 +189 @@
         }
 
-        void CommonType::visit( EnumInstType *aggregateUseType ) {
+        void CommonType::visit( EnumInstType *enumInstType ) {
+                if ( dynamic_cast< BasicType * >( type2 ) ) {
+                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
+                        Type * temp = type2;
+                        type2 = enumInstType;
+                        temp->accept( *this );
+                        type2 = temp;
+                } // if
         }
 

src/ResolvExpr/ConversionCost.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ConversionCost.cc -- 
+// ConversionCost.cc --
 //
 // Author           : Richard C. Bilson
@@ -157 +157 @@
                                 cost = Cost( 0, 0, tableResult );
                         } // if
-                } // if
+                } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
+                        // xxx - not positive this is correct, but appears to allow casting int => enum
+                        cost = Cost( 1, 0, 0 );
+    } // if
         }
 

src/ResolvExpr/RenameVars.cc

@@ -45 +45 @@
         void RenameVars::visit( PointerType *pointerType ) {
                 typeBefore( pointerType );
-///   std::cout << "do pointer" << std::endl;
                 maybeAccept( pointerType->get_base(), *this );
-///   std::cout << "done pointer" << std::endl;
                 typeAfter( pointerType );
         }
@@ -60 +58 @@
         void RenameVars::visit( FunctionType *functionType ) {
                 typeBefore( functionType );
-///   std::cout << "return vals" << std::endl;
                 acceptAll( functionType->get_returnVals(), *this );
-///   std::cout << functionType->get_parameters().size() << " parameters" << std::endl;
                 acceptAll( functionType->get_parameters(), *this );
-///   std::cout << "done function" << std::endl;
                 typeAfter( functionType );
         }
@@ -95 +90 @@
         void RenameVars::visit( TypeInstType *instType ) {
                 typeBefore( instType );
-///   std::cout << "instance of type " << instType->get_name() << std::endl;
                 std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->get_name() );
                 if ( i != mapStack.front().end() ) {
-///     std::cout << "found name " << i->second << std::endl;
                         instType->set_name( i->second );
                 } else {
-///     std::cout << "no name found" << std::endl;
                 } // if
                 acceptAll( instType->get_parameters(), *this );
@@ -120 +112 @@
         void RenameVars::typeBefore( Type *type ) {
                 if ( ! type->get_forall().empty() ) {
-///     std::cout << "type with forall: ";
-///     type->print( std::cout );
-///     std::cout << std::endl;
                         // copies current name mapping into new mapping
                         mapStack.push_front( mapStack.front() );

src/ResolvExpr/Resolver.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Resolver.cc -- 
+// Resolver.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 24 16:43:11 2016
-// Update Count     : 181
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri May 13 11:36:40 2016
+// Update Count     : 203
 //
 
@@ -25 +25 @@
 #include "SymTab/Indexer.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 #include <iostream>
@@ -33 +34 @@
           public:
                 Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
-  
+
                 virtual void visit( FunctionDecl *functionDecl );
                 virtual void visit( ObjectDecl *functionDecl );
                 virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( EnumDecl * enumDecl );
 
                 virtual void visit( ArrayType * at );
@@ -51 +53 @@
                 virtual void visit( BranchStmt *branchStmt );
                 virtual void visit( ReturnStmt *returnStmt );
+                virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
                 virtual void visit( SingleInit *singleInit );
                 virtual void visit( ListInit *listInit );
+                virtual void visit( ConstructorInit *ctorInit );
           private:
         typedef std::list< Initializer * >::iterator InitIterator;
@@ -59 +63 @@
           void resolveAggrInit( AggregateDecl *, InitIterator &, InitIterator & );
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
-
+          void fallbackInit( ConstructorInit * ctorInit );
                 std::list< Type * > functionReturn;
                 Type *initContext;
                 Type *switchType;
+                bool inEnumDecl = false;
         };
 
@@ -82 +87 @@
         }
 
+
         namespace {
                 void finishExpr( Expression *expr, const TypeEnvironment &env ) {
@@ -87 +93 @@
                         env.makeSubstitution( *expr->get_env() );
                 }
-
-                Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
-                        global_renamer.reset();
-                        TypeEnvironment env;
-                        Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
-                        finishExpr( newExpr, env );
-                        return newExpr;
-                }
-  
+        } // namespace
+
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
+                global_renamer.reset();
+                TypeEnvironment env;
+                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                finishExpr( newExpr, env );
+                return newExpr;
+        }
+
+        namespace {
                 Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -126 +134 @@
                         } // if
                 }
-  
+
                 Expression *findIntegralExpression( Expression *untyped, const SymTab::Indexer &indexer ) {
                         TypeEnvironment env;
@@ -159 +167 @@
                         return newExpr;
                 }
-  
-        }
-  
+
+        }
+
         void Resolver::visit( ObjectDecl *objectDecl ) {
                 Type *new_type = resolveTypeof( objectDecl->get_type(), *this );
@@ -172 +180 @@
                 Type *temp = initContext;
                 initContext = new_type;
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                        // enumerator initializers should not use the enum type to initialize, since
+                        // the enum type is still incomplete at this point. Use signed int instead.
+                        initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+                }
                 SymTab::Indexer::visit( objectDecl );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+                        // delete newly created signed int type
+                        delete initContext;
+                }
                 initContext = temp;
         }
@@ -212 +229 @@
         }
 
+        void Resolver::visit( EnumDecl * enumDecl ) {
+                // in case we decide to allow nested enums
+                bool oldInEnumDecl = inEnumDecl;
+                inEnumDecl = true;
+                SymTab::Indexer::visit( enumDecl );
+                inEnumDecl = oldInEnumDecl;
+        }
+
         void Resolver::visit( ExprStmt *exprStmt ) {
                 if ( exprStmt->get_expr() ) {
@@ -258 +283 @@
                         forStmt->set_condition( newExpr );
                 } // if
-                
+
                 if ( forStmt->get_increment() ) {
                         Expression * newExpr = findVoidExpression( forStmt->get_increment(), *this );
@@ -272 +297 @@
                 delete switchStmt->get_condition();
                 switchStmt->set_condition( newExpr );
-  
+
                 visitor.Visitor::visit( switchStmt );
         }
@@ -314 +339 @@
         bool isCharType( T t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
-                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar || 
+                        return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
                                 bt->get_kind() == BasicType::UnsignedChar;
                 }
@@ -326 +351 @@
                                 string n = ne->get_name();
                                 if (n == "0") {
-                                        initContext = new BasicType(Type::Qualifiers(), 
+                                        initContext = new BasicType(Type::Qualifiers(),
                                                                                                 BasicType::SignedInt);
                                 } else {
@@ -332 +357 @@
                                         initContext = decl->get_type();
                                 }
-                        } else if (ConstantExpr * e = 
+                        } else if (ConstantExpr * e =
                                            dynamic_cast<ConstantExpr*>(singleInit->get_value())) {
                                 Constant *c = e->get_constant();
@@ -355 +380 @@
                                                         singleInit->set_value( ce->get_arg() );
                                                         ce->set_arg( NULL );
-                                                        delete ce;                                                                      
+                                                        delete ce;
                                                 }
                                         }
@@ -471 +496 @@
 #endif
         }
+
+        // ConstructorInit - fall back on C-style initializer
+        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
+                // could not find valid constructor, or found an intrinsic constructor
+                // fall back on C-style initializer
+                delete ctorInit->get_ctor();
+                ctorInit->set_ctor( NULL );
+                delete ctorInit->get_dtor();
+                ctorInit->set_dtor( NULL );
+                maybeAccept( ctorInit->get_init(), *this );
+        }
+
+        void Resolver::visit( ConstructorInit *ctorInit ) {
+                try {
+                        maybeAccept( ctorInit->get_ctor(), *this );
+                        maybeAccept( ctorInit->get_dtor(), *this );
+                } catch ( SemanticError ) {
+                        // no alternatives for the constructor initializer - fallback on C-style initializer
+                        // xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
+                        fallbackInit( ctorInit );
+                        return;
+                }
+
+                // found a constructor - can get rid of C-style initializer
+                delete ctorInit->get_init();
+                ctorInit->set_init( NULL );
+
+                // intrinsic single parameter constructors and destructors do nothing. Since this was
+                // implicitly generated, there's no way for it to have side effects, so get rid of it
+                // to clean up generated code.
+                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                        delete ctorInit->get_ctor();
+                        ctorInit->set_ctor( NULL );
+                }
+                if ( InitTweak::isInstrinsicSingleArgCallStmt( ctorInit->get_ctor() ) ) {
+                        delete ctorInit->get_dtor();
+                        ctorInit->set_dtor( NULL );
+                }
+        }
+
+        void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
+                // before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed).
+                // Do this through a cast expression to greatly simplify the code.
+                Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
+                assert( callExpr );
+                Expression *& constructee = InitTweak::getCallArg( callExpr, 0 );
+                Type * type = 0;
+
+                // need to find the type of the first argument, which is unfortunately not uniform since array construction
+                // includes an untyped '+' expression.
+                if ( UntypedExpr * plusExpr = dynamic_cast< UntypedExpr * >( constructee ) ) {
+                        // constructee is <array>+<index>
+                        // get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
+                        Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
+                        assert( dynamic_cast< VariableExpr * >( arr ) );
+                        assert( arr && arr->get_results().size() == 1 );
+                        type = arr->get_results().front()->clone();
+                } else {
+                        // otherwise, constructing a plain object, which means the object's address is being taken.
+                        // Need to get the type of the VariableExpr object, because the AddressExpr is rebuilt and uses the
+                        // type of the VariableExpr to do so.
+                        assert( constructee->get_results().size() == 1 );
+                        AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
+                        assert( addrExpr && addrExpr->get_results().size() == 1);
+                        type = addrExpr->get_results().front()->clone();
+                }
+                // cast to T* with qualifiers removed.
+                // unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+                // must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+                // remove lvalue as a qualifier, this can change to
+                //   type->get_qualifiers() = Type::Qualifiers();
+                Type * base = InitTweak::getPointerBase( type );
+                assert( base );
+                base->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
+                // if pointer has lvalue qualifier, cast won't appear in output
+                type->set_isLvalue( false );
+                constructee = new CastExpr( constructee, type );
+
+                // finally, resolve the ctor/dtor
+                impCtorDtorStmt->get_callStmt()->accept( *this );
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Resolver.h -- 
+// Resolver.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:18:34 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 12:19:32 2015
+// Last Modified By : Rob Schluntz
+// Last Modified On : Thu Apr 14 15:06:53 2016
 // Update Count     : 2
 //
@@ -24 +24 @@
         void resolve( std::list< Declaration * > translationUnit );
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
+        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -54 +54 @@
   
         // in AdjustExprType.cc
+        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
         void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer );