Changes in / [c1c1112:4e2b9710]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeGen/CodeGenerator.h (modified) (3 diffs)
• CodeGen/GenType.cc (modified) (8 diffs)
• CodeGen/GenType.h (modified) (2 diffs)
• Common/utility.h (modified) (2 diffs)
• InitTweak/FixInit.cc (modified) (8 diffs)
• InitTweak/InitTweak.cc (modified) (3 diffs)
• InitTweak/InitTweak.h (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/LinkageSpec.cc (modified) (7 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (1 diff)
• Parser/TypeData.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (5 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.h (modified) (4 diffs)
• ResolvExpr/Unify.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (5 diffs)
• SynTree/AggregateDecl.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (3 diffs)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/TypeSubstitution.h (modified) (1 diff)
• tests/.expect/32/extension.txt (modified) (2 diffs)
• tests/.expect/64/extension.txt (modified) (2 diffs)
• tests/.expect/ctorWarnings.txt (added)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/ctorWarnings.c (added)

src/CodeGen/CodeGenerator.cc

@@ -83 +83 @@
         }
 
-        CodeGenerator::CodeGenerator( std::ostream & os ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ) {}
+        CodeGenerator::CodeGenerator( std::ostream & os, bool mangle ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), mangle( mangle ) {}
 
         CodeGenerator::CodeGenerator( std::ostream & os, std::string init, int indentation, bool infunp )
@@ -95 +95 @@
         }
 
-        string mangleName( DeclarationWithType * decl ) {
+        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
+                if ( ! mangle ) return decl->get_name();
                 if ( decl->get_mangleName() != "" ) {
                         // need to incorporate scope level in order to differentiate names for destructors
@@ -311 +312 @@
                                                         Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
                                                         assert( type );
-                                                        newExpr->get_results().push_back( type );
+                                                        newExpr->get_results().push_back( type->clone() );
                                                         *arg = newExpr;
                                                 } // if

src/CodeGen/CodeGenerator.h

@@ -30 +30 @@
                 static int tabsize;
 
-                CodeGenerator( std::ostream &os );
+                CodeGenerator( std::ostream &os, bool mangle = true );
                 CodeGenerator( std::ostream &os, std::string, int indent = 0, bool infun = false );
                 CodeGenerator( std::ostream &os, char *, int indent = 0, bool infun = false );
@@ -114 +114 @@
                 std::ostream &output;
                 LabelPrinter printLabels;
+                bool mangle = true;
 
                 void printDesignators( std::list< Expression * > & );
@@ -119 +120 @@
                 void handleAggregate( AggregateDecl *aggDecl );
                 void handleTypedef( NamedTypeDecl *namedType );
+                std::string mangleName( DeclarationWithType * decl );
         }; // CodeGenerator
 

src/CodeGen/GenType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// GenType.cc -- 
+// GenType.cc --
 //
 // Author           : Richard C. Bilson
@@ -28 +28 @@
         class GenType : public Visitor {
           public:
-                GenType( const std::string &typeString );
+                GenType( const std::string &typeString, bool mangle = true );
                 std::string get_typeString() const { return typeString; }
                 void set_typeString( const std::string &newValue ) { typeString = newValue; }
-  
+
                 virtual void visit( FunctionType *funcType );
                 virtual void visit( VoidType *voidType );
@@ -42 +42 @@
                 virtual void visit( TypeInstType *typeInst );
                 virtual void visit( VarArgsType *varArgsType );
-  
+
           private:
                 void handleQualifiers( Type *type );
                 void genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
-  
+
                 std::string typeString;
+                bool mangle = true;
         };
 
-        std::string genType( Type *type, const std::string &baseString ) {
-                GenType gt( baseString );
+        std::string genType( Type *type, const std::string &baseString, bool mangle ) {
+                GenType gt( baseString, mangle );
                 type->accept( gt );
                 return gt.get_typeString();
         }
 
-        GenType::GenType( const std::string &typeString ) : typeString( typeString ) {}
+        GenType::GenType( const std::string &typeString, bool mangle ) : typeString( typeString ), mangle( mangle ) {}
 
         void GenType::visit( VoidType *voidType ) {
@@ -100 +101 @@
                 } // if
                 if ( dimension != 0 ) {
-                        CodeGenerator cg( os );
+                        CodeGenerator cg( os, mangle );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
@@ -109 +110 @@
 
                 typeString = os.str();
-  
+
                 base->accept( *this );
         }
@@ -142 +143 @@
                         } // if
                 } // if
-  
+
                 /************* parameters ***************/
 
@@ -154 +155 @@
                         } // if
                 } else {
-                        CodeGenerator cg( os );
+                        CodeGenerator cg( os, mangle );
                         os << "(" ;
 
@@ -164 +165 @@
                         os << ")";
                 } // if
-  
+
                 typeString = os.str();
 

src/CodeGen/GenType.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// GenType.h -- 
+// GenType.h --
 //
 // Author           : Richard C. Bilson
@@ -21 +21 @@
 
 namespace CodeGen {
-        std::string genType( Type *type, const std::string &baseString );
+        std::string genType( Type *type, const std::string &baseString, bool mangle = true );
 } // namespace CodeGen
 

src/Common/utility.h

@@ -144 +144 @@
 
 template < typename T >
-std::string toString ( T value ) {
+void toString_single ( std::ostream & os, const T & value ) {
+        os << value;
+}
+
+template < typename T, typename... Params >
+void toString_single ( std::ostream & os, const T & value, const Params & ... params ) {
+        os << value;
+        toString_single( os, params ... );
+}
+
+template < typename ... Params >
+std::string toString ( const Params & ... params ) {
         std::ostringstream os;
-        os << value; // << std::ends;
+        toString_single( os, params... );
         return os.str();
 }
@@ -218 +229 @@
 }
 
+template< typename T >
+void warn_single( const T & arg ) {
+        std::cerr << arg << std::endl;
+}
+
+template< typename T, typename... Params >
+void warn_single(const T & arg, const Params & ... params ) {
+        std::cerr << arg;
+        warn_single( params... );
+}
+
+template< typename... Params >
+void warn( const Params & ... params ) {
+        std::cerr << "Warning: ";
+        warn_single( params... );
+}
+
 #endif // _UTILITY_H
 

src/InitTweak/FixInit.cc

@@ -33 +33 @@
 #include "GenPoly/PolyMutator.h"
 #include "SynTree/AddStmtVisitor.h"
+#include "CodeGen/GenType.h"  // for warnings
 
 bool ctordtorp = false;
@@ -174 +175 @@
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr );
                 };
+
+                class WarnStructMembers : public Visitor {
+                  public:
+                        typedef Visitor Parent;
+                        /// warn if a user-defined constructor or destructor is missing calls for
+                        /// a struct member or if a member is used before constructed
+                        static void warnings( std::list< Declaration * > & translationUnit );
+
+                        virtual void visit( FunctionDecl * funcDecl );
+
+                        virtual void visit( MemberExpr * memberExpr );
+                        virtual void visit( ApplicationExpr * appExpr );
+
+                  private:
+                        void handleFirstParam( Expression * firstParam );
+
+                        FunctionDecl * function = 0;
+                        std::set< DeclarationWithType * > unhandled;
+                        ObjectDecl * thisParam = 0;
+                };
         } // namespace
 
@@ -187 +208 @@
                 // FixCopyCtors must happen after FixInit, so that destructors are placed correctly
                 FixCopyCtors::fixCopyCtors( translationUnit );
+
+                WarnStructMembers::warnings( translationUnit );
         }
 
@@ -231 +254 @@
                 }
 
+                void WarnStructMembers::warnings( std::list< Declaration * > & translationUnit ) {
+                        if ( true ) { // fix this condition to skip this pass if warnings aren't enabled
+                                WarnStructMembers warner;
+                                acceptAll( translationUnit, warner );
+                        }
+                }
+
                 Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
                         appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
@@ -242 +272 @@
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
-                                        if ( (funcDecl->get_name() == "?{}" || funcDecl->get_name() == "?=?") && ftype->get_parameters().size() == 2 ) {
+                                        if ( (isConstructor( funcDecl->get_name() ) || funcDecl->get_name() == "?=?") && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
@@ -253 +283 @@
                                                         return appExpr;
                                                 } // if
-                                        } else if ( funcDecl->get_name() == "^?{}" ) {
+                                        } else if ( isDestructor( funcDecl->get_name() ) ) {
                                                 // correctness: never copy construct arguments to a destructor
                                                 return appExpr;
@@ -284 +314 @@
                         UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
                         untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) );
-                        if (cpArg) untyped->get_args().push_back( cpArg );
+                        if (cpArg) untyped->get_args().push_back( cpArg->clone() );
 
                         // resolve copy constructor
@@ -670 +700 @@
                         } // switch
                 }
+
+                bool checkWarnings( FunctionDecl * funcDecl ) {
+                        // only check for warnings if the current function is a user-defined
+                        // constructor or destructor
+                        if ( ! funcDecl ) return false;
+                        if ( ! funcDecl->get_statements() ) return false;
+                        return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                }
+
+                void WarnStructMembers::visit( FunctionDecl * funcDecl ) {
+                        WarnStructMembers old = *this;
+                        *this = WarnStructMembers();
+
+                        function = funcDecl;
+                        if ( checkWarnings( funcDecl ) ) {
+                                FunctionType * type = funcDecl->get_functionType();
+                                assert( ! type->get_parameters().empty() );
+                                thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
+                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( thisParam->get_type() );
+                                StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
+                                if ( structType ) {
+                                        StructDecl * structDecl = structType->get_baseStruct();
+                                        for ( Declaration * member : structDecl->get_members() ) {
+                                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                                        // record all of the struct type's members that need to be constructed or
+                                                        // destructed by the end of the function
+                                                        unhandled.insert( field );
+                                                }
+                                        }
+                                }
+                        }
+                        Parent::visit( funcDecl );
+
+                        for ( DeclarationWithType * member : unhandled ) {
+                                // emit a warning for each unhandled member
+                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", member->get_name(), " may not have been ", isConstructor( funcDecl->get_name() ) ? "constructed" : "destructed" );
+                        }
+
+                        *this = old;
+                }
+
+                void WarnStructMembers::visit( ApplicationExpr * appExpr ) {
+                        if ( ! checkWarnings( function ) ) return;
+
+                        std::string fname = getFunctionName( appExpr );
+                        if ( fname == function->get_name() ) {
+                                // call to same kind of function
+                                Expression * firstParam = appExpr->get_args().front();
+
+                                if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) {
+                                        // if calling another constructor on thisParam, assume that function handles
+                                        // all members - if it doesn't a warning will appear in that function.
+                                        if ( varExpr->get_var() == thisParam ) {
+                                                unhandled.clear();
+                                        }
+                                } else {
+                                        // if first parameter is a member expression then
+                                        // remove the member from unhandled set.
+                                        handleFirstParam( firstParam );
+                                }
+                        } else if ( fname == "?=?" && isIntrinsicCallExpr( appExpr ) ) {
+                                // forgive use of intrinsic assignment to construct, since instrinsic constructors
+                                // codegen as assignment anyway.
+                                assert( appExpr->get_args().size() == 2 );
+                                handleFirstParam( appExpr->get_args().front() );
+                        }
+
+                        Parent::visit( appExpr );
+                }
+
+                void WarnStructMembers::handleFirstParam( Expression * firstParam ) {
+                        using namespace std;
+                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
+                                if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( addrExpr->get_arg() ) ) {
+                                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
+                                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
+                                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
+                                                                if ( varExpr->get_var() == thisParam ) {
+                                                                        unhandled.erase( memberExpr->get_member() );
+                                                                }
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                void WarnStructMembers::visit( MemberExpr * memberExpr ) {
+                        if ( ! checkWarnings( function ) ) return;
+                        if ( ! isConstructor( function->get_name() ) ) return;
+
+                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
+                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
+                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
+                                                if ( varExpr->get_var() == thisParam ) {
+                                                        if ( unhandled.count( memberExpr->get_member() ) ) {
+                                                                // emit a warning because a member was used before it was constructed
+                                                                warn( "in ", CodeGen::genType( function->get_functionType(), function->get_name(), false ), ", member ", memberExpr->get_member()->get_name(), " used before being constructed" );
+                                                        }
+                                                }
+                                        }
+                                }
+                        }
+                        Parent::visit( memberExpr );
+                }
         } // namespace
 } // namespace InitTweak

src/InitTweak/InitTweak.cc

@@ -291 +291 @@
         }
 
+        namespace {
+                template <typename Predicate>
+                bool allofCtorDtor( Statement * stmt, const Predicate & pred ) {
+                        std::list< Expression * > callExprs;
+                        collectCtorDtorCalls( stmt, callExprs );
+                        // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
+                        return std::all_of( callExprs.begin(), callExprs.end(), pred);
+                }
+        }
+
         bool isIntrinsicSingleArgCallStmt( Statement * stmt ) {
-                std::list< Expression * > callExprs;
-                collectCtorDtorCalls( stmt, callExprs );
-                // if ( callExprs.empty() ) return false; // xxx - do I still need this check?
-                return std::all_of( callExprs.begin(), callExprs.end(), []( Expression * callExpr ){
+                return allofCtorDtor( stmt, []( Expression * callExpr ){
                         if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
                                 assert( ! appExpr->get_function()->get_results().empty() );
@@ -303 +310 @@
                         }
                         return false;
+                });
+        }
+
+        bool isIntrinsicCallStmt( Statement * stmt ) {
+                return allofCtorDtor( stmt, []( Expression * callExpr ) {
+                        return isIntrinsicCallExpr( callExpr );
                 });
         }
@@ -420 +433 @@
         }
 
+        bool isConstructor( const std::string & str ) { return str == "?{}"; }
+        bool isDestructor( const std::string & str ) { return str == "^?{}"; }
+        bool isCtorDtor( const std::string & str ) { return isConstructor( str ) || isDestructor( str ); }
 }

src/InitTweak/InitTweak.h

@@ -26 +26 @@
 // helper functions for initialization
 namespace InitTweak {
+        bool isConstructor( const std::string & );
+        bool isDestructor( const std::string & );
+        bool isCtorDtor( const std::string & );
+
         /// transform Initializer into an argument list that can be passed to a call expression
         std::list< Expression * > makeInitList( Initializer * init );
@@ -41 +45 @@
         /// Intended to be used for default ctor/dtor calls, but might have use elsewhere.
         /// Currently has assertions that make it less than fully general.
-        bool isIntrinsicSingleArgCallStmt( Statement * expr );
+        bool isIntrinsicSingleArgCallStmt( Statement * stmt );
+
+        /// True if stmt is a call statement where the function called is intrinsic.
+        bool isIntrinsicCallStmt( Statement * stmt );
 
         /// get all Ctor/Dtor call expressions from a Statement

src/Parser/DeclarationNode.cc

@@ -50 +50 @@
         newnode->isInline = isInline;
         newnode->isNoreturn = isNoreturn;
-        newnode->bitfieldWidth = bitfieldWidth;
+        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
         newnode->hasEllipsis = hasEllipsis;
-        newnode->initializer = initializer;
+        newnode->initializer = maybeClone( initializer );
         newnode->set_next( maybeClone( get_next() ) );
         newnode->linkage = linkage;
@@ -823 +823 @@
                                         *out++ = decl;
                                 } // if
+                                delete extr;
                         } // if
                         Declaration *decl = cur->build();

src/Parser/LinkageSpec.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// LinkageSpec.cc -- 
-// 
+// LinkageSpec.cc --
+//
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:22:09 2015
@@ -12 +12 @@
 // Last Modified On : Sun Aug 21 12:32:53 2016
 // Update Count     : 17
-// 
+//
 
 #include <string>
@@ -32 +32 @@
 
 std::string LinkageSpec::toString( LinkageSpec::Spec linkage ) {
+        assert( linkage >= 0 && linkage < LinkageSpec::NoOfSpecs );
         static const char *linkageKinds[LinkageSpec::NoOfSpecs] = {
                 "intrinsic", "Cforall", "C", "automatically generated", "compiler built-in",
@@ -39 +40 @@
 
 bool LinkageSpec::isDecoratable( Spec spec ) {
+        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
         static bool decoratable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
-                        true,           true,           false,  true,           false, 
+                        true,           true,           false,  true,           false,
         };
         return decoratable[spec];
@@ -47 +49 @@
 
 bool LinkageSpec::isGeneratable( Spec spec ) {
+        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
         static bool generatable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
-                        true,           true,           true,   true,           false, 
+                        true,           true,           true,   true,           false,
         };
         return generatable[spec];
@@ -55 +58 @@
 
 bool LinkageSpec::isOverridable( Spec spec ) {
+        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
         static bool overridable[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
-                        true,           false,          false,  true,           false, 
+                        true,           false,          false,  true,           false,
         };
         return overridable[spec];
@@ -63 +67 @@
 
 bool LinkageSpec::isBuiltin( Spec spec ) {
+        assert( spec >= 0 && spec < LinkageSpec::NoOfSpecs );
         static bool builtin[LinkageSpec::NoOfSpecs] = {
                 //      Intrinsic,      Cforall,        C,              AutoGen,        Compiler
-                        true,           false,          false,  false,          true, 
+                        true,           false,          false,  false,          true,
         };
         return builtin[spec];

src/Parser/ParseNode.h

@@ -109 +109 @@
         ExpressionNode( const ExpressionNode &other );
         virtual ~ExpressionNode() {}
-        virtual ExpressionNode *clone() const { assert( false ); return nullptr; }
+        virtual ExpressionNode *clone() const { return expr ? new ExpressionNode( expr->clone() ) : nullptr; }
 
         bool get_extension() const { return extension; }

src/Parser/StatementNode.cc

@@ -44 +44 @@
                         agg = decl;
                 } // if
-                stmt.reset( new DeclStmt( noLabels, maybeBuild< Declaration >(agg) ) );
+                stmt.reset( new DeclStmt( noLabels, maybeMoveBuild< Declaration >(agg) ) );
         } else {
                 assert( false );

src/Parser/TypeData.cc

@@ -182 +182 @@
                 break;
           case Array:
-                newtype->array->dimension = array->dimension;
+                newtype->array->dimension = maybeClone( array->dimension );
                 newtype->array->isVarLen = array->isVarLen;
                 newtype->array->isStatic = array->isStatic;

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

src/SymTab/Autogen.cc

@@ -68 +68 @@
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
                 copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
-                copy->get_args().push_back( new SizeofExpr( unionType ) );
+                copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
 
                 *out++ = new ExprStmt( noLabels, copy );
@@ -420 +420 @@
                 copyCtorDecl->set_statements( assignDecl->get_statements()->clone() );
 
+                // create a constructor which takes the first member type as a parameter.
+                // for example, for Union A { int x; double y; }; generate
+                // void ?{}(A *, int)
+                // This is to mimic C's behaviour which initializes the first member of the union.
+                std::list<Declaration *> memCtors;
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( DeclarationWithType * field = dynamic_cast< DeclarationWithType * >( member ) ) {
+                                ObjectDecl * srcParam = new ObjectDecl( "src", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, field->get_type()->clone(), 0 );
+
+                                FunctionType * memCtorType = ctorType->clone();
+                                memCtorType->get_parameters().push_back( srcParam );
+                                FunctionDecl * ctor = new FunctionDecl( "?{}", functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, memCtorType, new CompoundStmt( noLabels ), true, false );
+                                ctor->fixUniqueId();
+
+                                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( ctor->get_statements()->get_kids() ) );
+                                memCtors.push_back( ctor );
+                                // only generate a ctor for the first field
+                                break;
+                        }
+                }
+
                 declsToAdd.push_back( assignDecl );
                 declsToAdd.push_back( ctorDecl );
                 declsToAdd.push_back( copyCtorDecl );
                 declsToAdd.push_back( dtorDecl );
+                declsToAdd.splice( declsToAdd.end(), memCtors );
         }
 

src/SymTab/Validate.cc

@@ -58 +58 @@
 #include "Autogen.h"
 #include "ResolvExpr/typeops.h"
+#include <algorithm>
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -162 +163 @@
 
                 typedef std::map< std::string, std::pair< TypedefDecl *, int > > TypedefMap;
+                typedef std::map< std::string, TypeDecl * > TypeDeclMap;
                 TypedefMap typedefNames;
+                TypeDeclMap typedeclNames;
                 int scopeLevel;
         };
@@ -370 +373 @@
                 } // if
 
-                applySubstitution( ctx->get_parameters().begin(), ctx->get_parameters().end(), contextInst->get_parameters().begin(), ctx->get_members().begin(), ctx->get_members().end(), back_inserter( contextInst->get_members() ) );
+                // need to clone members of the context for ownership purposes
+                std::list< Declaration * > members;
+                std::transform( ctx->get_members().begin(), ctx->get_members().end(), back_inserter( members ), [](Declaration * dwt) { return dwt->clone(); } );
+
+                applySubstitution( ctx->get_parameters().begin(), ctx->get_parameters().end(), contextInst->get_parameters().begin(), members.begin(), members.end(), back_inserter( contextInst->get_members() ) );
         }
 
@@ -521 +528 @@
                         delete typeInst;
                         return ret;
+                } else {
+                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
+                        assert( base != typedeclNames.end() );
+                        typeInst->set_baseType( base->second->clone() );
                 } // if
                 return typeInst;
@@ -565 +576 @@
                         typedefNames.erase( i ) ;
                 } // if
+
+                typedeclNames[ typeDecl->get_name() ] = typeDecl;
                 return typeDecl;
         }

src/SynTree/AggregateDecl.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AggregateDecl.cc -- 
+// AggregateDecl.cc --
 //
 // Author           : Richard C. Bilson

src/SynTree/Expression.cc

@@ -200 +200 @@
 
 OffsetofExpr::OffsetofExpr( const OffsetofExpr &other ) :
-        Expression( other ), type( maybeClone( other.type ) ), member( maybeClone( other.member ) ) {}
+        Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
 OffsetofExpr::~OffsetofExpr() {
         delete type;
-        delete member;
 }
 
@@ -359 +358 @@
         assert( member );
         os << std::string( indent + 2, ' ' );
+        os << (void*)member << " ";
         member->print( os, indent + 2 );
         os << std::endl;
@@ -385 +385 @@
 UntypedExpr::~UntypedExpr() {
         delete function;
-        // deleteAll( args );  //TODO FIXME the arguments are leaked but they seem to be shared in some way
+        deleteAll( args );
 }
 

src/SynTree/Initializer.cc

@@ -43 +43 @@
 
 SingleInit::~SingleInit() {
+        delete value;
         deleteAll(designators);
 }

src/SynTree/TypeSubstitution.h

@@ -169 +169 @@
         TypeSubstitution sub = TypeSubstitution( formalBegin, formalEnd, actual );
         for ( std::list< Declaration* >::iterator i = memberBegin; i != memberEnd; ++i ) {
-                Declaration *newdecl = (*i)->clone();
-                sub.apply( newdecl );
-                *out++ = newdecl;
+                sub.apply( *i );
+                *out++ = *i;
         } // for
 }

src/tests/.expect/32/extension.txt

@@ -70 +70 @@
 static inline void ___destructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
 }
+static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){
+    void *_tmp_cp_ret2;
+    ((void)((_tmp_cp_ret2=__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&__src__i_1)), sizeof(int ))) , _tmp_cp_ret2));
+    ((void)(_tmp_cp_ret2) /* ^?{} */);
+}
 __extension__ enum E {
     __R__C2eE_1,
@@ -89 +94 @@
     __extension__ int __c__i_2;
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
-    int _tmp_cp_ret2;
-    ((void)((_tmp_cp_ret2=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret2));
-    ((void)(_tmp_cp_ret2) /* ^?{} */);
+    int _tmp_cp_ret3;
+    ((void)((_tmp_cp_ret3=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret3));
+    ((void)(_tmp_cp_ret3) /* ^?{} */);
     ((void)__extension__ sizeof(3));
     ((void)__extension__ (((int )(3!=0)) || ((int )(4!=0))));

src/tests/.expect/64/extension.txt

@@ -70 +70 @@
 static inline void ___destructor__F_P2uU_autogen___1(union U *___dst__P2uU_1){
 }
+static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){
+    void *_tmp_cp_ret2;
+    ((void)((_tmp_cp_ret2=__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&__src__i_1)), sizeof(int ))) , _tmp_cp_ret2));
+    ((void)(_tmp_cp_ret2) /* ^?{} */);
+}
 __extension__ enum E {
     __R__C2eE_1,
@@ -89 +94 @@
     __extension__ int __c__i_2;
     ((void)(__extension__ __a__i_2=(__extension__ __b__i_2+__extension__ __c__i_2)));
-    int _tmp_cp_ret2;
-    ((void)((_tmp_cp_ret2=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret2));
-    ((void)(_tmp_cp_ret2) /* ^?{} */);
+    int _tmp_cp_ret3;
+    ((void)((_tmp_cp_ret3=__extension__ __fred__Fi_i__1(3)) , _tmp_cp_ret3));
+    ((void)(_tmp_cp_ret3) /* ^?{} */);
     ((void)__extension__ sizeof(3));
     ((void)__extension__ (((int )(3!=0)) || ((int )(4!=0))));

src/tests/Makefile.am

@@ -62 +62 @@
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
+ctorWarnings: ctorWarnings.c
+        ${CC} ${CFALGS} -CFA -XCFA -p ${<} -o /dev/null 2> ${@}
+

src/tests/Makefile.in

@@ -670 +670 @@
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
 
+ctorWarnings: ctorWarnings.c
+        ${CC} ${CFALGS} -CFA -XCFA -p ${<} -o /dev/null 2> ${@}
+
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.