Changeset 9cb8e88d

Timestamp:

Dec 18, 2015, 2:36:53 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, with_gc

Children:

267cb3d

Parents:

0ddb713

Message:

validate constructors and destructors - ensure they return nothing, have at least one parameter, and take a pointer as the first parameter

Location:

src

Files:

• SymTab/Validate.cc (modified) (25 diffs)
• initialization.txt (modified) (1 diff)

src/SymTab/Validate.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Validate.cc -- 
+// Validate.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Fri Nov 20 16:33:52 2015
-// Update Count     : 201
+// Last Modified On : Fri Dec 18 14:32:59 2015
+// Update Count     : 268
 //
 
@@ -63 +63 @@
                 /// Flattens nested struct types
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
-  
+
                 std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-  
+
                 virtual void visit( StructDecl *aggregateDecl );
                 virtual void visit( UnionDecl *aggregateDecl );
@@ -107 +107 @@
 
                 const Indexer *indexer;
-  
+
                 typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
                 typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
@@ -132 +132 @@
 
                 std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-  
+
                 virtual void visit( EnumDecl *enumDecl );
                 virtual void visit( StructDecl *structDecl );
@@ -142 +142 @@
                 virtual void visit( FunctionType *ftype );
                 virtual void visit( PointerType *ftype );
-  
+
                 virtual void visit( CompoundStmt *compoundStmt );
                 virtual void visit( IfStmt *ifStmt );
@@ -155 +155 @@
           private:
                 template< typename StmtClass > void visitStatement( StmtClass *stmt );
-  
+
                 std::list< Declaration * > declsToAdd;
                 std::set< std::string > structsDone;
@@ -188 +188 @@
         };
 
+        class VerifyCtorDtor : public Visitor {
+        public:
+                /// ensure that constructors and destructors have at least one
+                /// parameter, the first of which must be a pointer, and no
+                /// return values.
+                static void verify( std::list< Declaration * > &translationUnit );
+
+                // VerifyCtorDtor() {}
+
+                virtual void visit( FunctionDecl *funcDecl );
+        private:
+        };
+
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 Pass1 pass1;
@@ -198 +211 @@
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
-        }
-        
+                VerifyCtorDtor::verify( translationUnit );
+        }
+
         void validateType( Type *type, const Indexer *indexer ) {
                 Pass1 pass1;
@@ -307 +321 @@
         void Pass1::visit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
-  
+
                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
                         ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
@@ -331 +345 @@
                                 ++i;
                                 func->get_parameters().erase( j );
-                                if ( i != end ) { 
+                                if ( i != end ) {
                                         throw SemanticError( "invalid type void in function type ", func );
                                 } // if
@@ -512 +526 @@
 
                 UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
-  
+
                 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
                 derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
-  
+
                 // do something special for unnamed members
                 Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
                 assignExpr->get_args().push_back( dstselect );
-  
+
                 Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
                 assignExpr->get_args().push_back( srcselect );
-  
+
                 *out++ = new ExprStmt( noLabels, assignExpr );
         }
@@ -529 +543 @@
         void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
                 static UniqueName indexName( "_index" );
-  
+
                 // for a flexible array member nothing is done -- user must define own assignment
                 if ( ! array->get_dimension() ) return;
-  
+
                 ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
                 *out++ = new DeclStmt( noLabels, index );
-  
+
                 UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
                 init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
@@ -542 +556 @@
                 std::list<Statement *> initList;
                 initList.push_back( initStmt );
-  
+
                 UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
                 cond->get_args().push_back( new VariableExpr( index ) );
                 cond->get_args().push_back( array->get_dimension()->clone() );
-  
+
                 UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
                 inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
-  
+
                 UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
-  
+
                 UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
                 derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
-  
+
                 Expression *dstselect = new MemberExpr( member, derefExpr );
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
@@ -560 +574 @@
                 dstIndex->get_args().push_back( new VariableExpr( index ) );
                 assignExpr->get_args().push_back( dstIndex );
-  
+
                 Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
                 UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
@@ -566 +580 @@
                 srcIndex->get_args().push_back( new VariableExpr( index ) );
                 assignExpr->get_args().push_back( srcIndex );
-  
+
                 *out++ = new ForStmt( noLabels, initList, cond, inc, new ExprStmt( noLabels, assignExpr ) );
         }
 
-        //E ?=?(E volatile*, int), 
+        //E ?=?(E volatile*, int),
         //  ?=?(E _Atomic volatile*, int);
         void makeEnumAssignment( EnumDecl *enumDecl, EnumInstType *refType, unsigned int functionNesting, std::list< Declaration * > &declsToAdd ) {
                 FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
-  
+
                 ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
                 assignType->get_returnVals().push_back( returnVal );
@@ -593 +607 @@
                 // E ?=?(E volatile *, int)
                 assignType2->get_parameters().push_back( dstParam->clone() );
-                BasicType * paramType = new BasicType(Type::Qualifiers(), BasicType::SignedInt); 
+                BasicType * paramType = new BasicType(Type::Qualifiers(), BasicType::SignedInt);
                 ObjectDecl *srcParam2 = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, paramType, 0 );
                 assignType2->get_parameters().push_back( srcParam2 );
@@ -645 +659 @@
                         structParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
                 }
-  
+
                 ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
                 assignType->get_returnVals().push_back( returnVal );
-  
+
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, structParams ) ), 0 );
                 assignType->get_parameters().push_back( dstParam );
-  
+
                 ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, structParams ), 0 );
                 assignType->get_parameters().push_back( srcParam );
@@ -659 +673 @@
                 FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true, false );
                 assignDecl->fixUniqueId();
-  
+
                 for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
                         if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
-                                // query the type qualifiers of this field and skip assigning it if it is marked const. 
+                                // query the type qualifiers of this field and skip assigning it if it is marked const.
                                 // If it is an array type, we need to strip off the array layers to find its qualifiers.
                                 Type * type = dwt->get_type();
@@ -682 +696 @@
                 } // for
                 assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-  
+
                 return assignDecl;
         }
@@ -697 +711 @@
                         unionParams.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeParam->get_name(), typeParam ) ) );
                 }
-  
+
                 ObjectDecl *returnVal = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
                 assignType->get_returnVals().push_back( returnVal );
-  
+
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), cloneWithParams( refType, unionParams ) ), 0 );
                 assignType->get_parameters().push_back( dstParam );
-  
+
                 ObjectDecl *srcParam = new ObjectDecl( "_src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, cloneWithParams( refType, unionParams ), 0 );
                 assignType->get_parameters().push_back( srcParam );
-  
+
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
                 // because each unit generates copies of the default routines for each aggregate.
                 FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true, false );
                 assignDecl->fixUniqueId();
-  
+
                 UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
@@ -719 +733 @@
                 assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
                 assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
-  
+
                 return assignDecl;
         }
@@ -727 +741 @@
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
                         // enumInst->set_baseEnum( enumDecl );
-                        // declsToAdd.push_back( 
+                        // declsToAdd.push_back(
                         makeEnumAssignment( enumDecl, enumInst, functionNesting, declsToAdd );
                 }
@@ -847 +861 @@
 
         Type *EliminateTypedef::mutate( TypeInstType * typeInst ) {
-                // instances of typedef types will come here. If it is an instance 
+                // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
                 TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
@@ -871 +885 @@
                 Declaration *ret = Mutator::mutate( tyDecl );
                 if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
-                        // typedef to the same name from the same scope 
+                        // typedef to the same name from the same scope
                         // must be from the same type
 
@@ -993 +1007 @@
         }
 
+        void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
+                VerifyCtorDtor verifier;
+                acceptAll( translationUnit, verifier );
+        }
+
+        void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) {
+                FunctionType * funcType = funcDecl->get_functionType();
+                std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
+                std::list< DeclarationWithType * > &params = funcType->get_parameters();
+
+                if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) {
+                        if ( params.size() == 0 ) {
+                                throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl );
+                        }
+                        if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) {
+                                throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl );
+                        }
+                        if ( returnVals.size() != 0 ) {
+                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                        }
+                }
+
+                Visitor::visit( funcDecl );
+                // original idea: modify signature of ctor/dtors and insert appropriate return statements
+                // to cause desired behaviour
+                // new idea: add comma exprs to every ctor call to produce first parameter.
+                // this requires some memoization of the first parameter, because it can be a
+                // complicated expression with side effects (see: malloc). idea: add temporary variable
+                // that is assigned address of constructed object in ctor argument position and
+                // return the temporary. It should also be done after all implicit ctors are
+                // added, so not in this pass!
+        }
 } // namespace SymTab
 

src/initialization.txt

@@ -34 +34 @@
 sure that resolved initializers for all declarations are being
 generated.
+
+
+------
+
+More recent email: (I am quoted; Richard is the responder)
+> As far as I'm aware, the only way that I could currently get the correct
+> results from the unification engine is by feeding it an expression that
+> looks like "?=?( ((struct Y)x.y).a, 10 )", then picking out the pieces that
+> I need (namely the correct choice for a). Does this seem like a reasonable
+> approach to solve this problem?
+
+No, unfortunately. Initialization isn't being rewritten as assignment,
+so you shouldn't allow the particular selection of assignment
+operators that happen to be in scope (and which may include
+user-defined operators) to guide the type resolution.
+
+I don't think there is any way to rewrite an initializer as a single
+expression and have the resolver just do the right thing. I see the
+algorithm as:
+
+For each alternative interpretation of the designator:
+  Construct an expression that casts the initializer to the type of
+    the designator
+  Construct an AlternativeFinder and use it to find the lowest cost
+    interpretation of the expression
+  Add this interpretation to a list of possibilities
+Go through the list of possibilities and pick the lowest cost
+
+As with many things in the resolver, it's conceptually simple but the
+implementation may be a bit of a pain. It fits in with functions like
+findSingleExpression, findIntegralExpression in Resolver.cc, although
+it will be significantly more complicated than any of the existing
+ones.
+
+
+