Changeset 3403534 for src/SymTab

Timestamp:

Sep 4, 2016, 10:34:35 PM (10 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, stuck-waitfor-destruct, with_gc

Children:

f04a8b81

Parents:

28307be (diff), b16898e (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/SymTab

Files:

• Autogen.cc (modified) (3 diffs)
• Autogen.h (modified) (1 diff)
• Indexer.cc (modified) (4 diffs)
• Indexer.h (modified) (1 diff)
• Validate.cc (modified) (7 diffs)

src/SymTab/Autogen.cc

@@ -64 +64 @@
 
         template< typename OutputIterator >
-        void makeUnionFieldsAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, UnionInstType *unionType, OutputIterator out ) {
+        void makeUnionFieldsAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, OutputIterator out ) {
                 UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
@@ -413 +413 @@
                 dtorDecl->fixUniqueId();
 
-                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
-                if ( isDynamicLayout ) makeUnionFieldsAssignment( srcParam, returnVal, cloneWithParams( refType, unionParams ), back_inserter( assignDecl->get_statements()->get_kids() ) );
+                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                if ( isDynamicLayout ) makeUnionFieldsAssignment( srcParam, returnVal, back_inserter( assignDecl->get_statements()->get_kids() ) );
                 else assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
 
@@ -434 +434 @@
                                 ctor->fixUniqueId();
 
-                                makeUnionFieldsAssignment( srcParam, dstParam, cloneWithParams( refType, unionParams ), back_inserter( ctor->get_statements()->get_kids() ) );
+                                makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( ctor->get_statements()->get_kids() ) );
                                 memCtors.push_back( ctor );
                                 // only generate a ctor for the first field

src/SymTab/Autogen.h

@@ -102 +102 @@
                 }
 
-                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), NULL );
-
-                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
-                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
-                init->get_args().push_back( begin );
-                index->set_init( new SingleInit( init, std::list<Expression*>() ) );
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), new SingleInit( begin, std::list<Expression*>() ) );
 
                 UntypedExpr *cond = new UntypedExpr( cmp );

src/SymTab/Indexer.cc

@@ -21 +21 @@
 #include <unordered_set>
 #include <utility>
+#include <algorithm>
 
 #include "Mangler.h"
@@ -33 +34 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
+
+#include "InitTweak/InitTweak.h"
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
@@ -99 +102 @@
 
                 if ( --toFree->refCount == 0 ) delete toFree;
+        }
+
+        void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
+                // only need to perform this step for constructors and destructors
+                if ( ! InitTweak::isCtorDtor( id ) ) return;
+
+                // helpful data structure
+                struct ValueType {
+                        struct DeclBall {
+                                FunctionDecl * decl;
+                                bool isUserDefinedFunc; // properties for this particular decl
+                                bool isDefaultFunc;
+                                bool isCopyFunc;
+                        };
+                        // properties for this type
+                        bool userDefinedFunc = false; // any user defined function found
+                        bool userDefinedDefaultFunc = false; // user defined default ctor found
+                        bool userDefinedCopyFunc = false; // user defined copy ctor found
+                        std::list< DeclBall > decls;
+
+                        // another FunctionDecl for the current type was found - determine
+                        // if it has special properties and update data structure accordingly
+                        ValueType & operator+=( FunctionDecl * function ) {
+                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->get_linkage() );
+                                bool isDefaultFunc = function->get_functionType()->get_parameters().size() == 1;
+                                bool isCopyFunc = InitTweak::isCopyConstructor( function );
+                                decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultFunc, isCopyFunc } );
+                                userDefinedFunc = userDefinedFunc || isUserDefinedFunc;
+                                userDefinedDefaultFunc = userDefinedDefaultFunc || (isUserDefinedFunc && isDefaultFunc);
+                                userDefinedCopyFunc = userDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
+                                return *this;
+                        }
+                }; // ValueType
+
+                std::list< DeclarationWithType * > copy;
+                copy.splice( copy.end(), out );
+
+                // organize discovered declarations by type
+                std::unordered_map< std::string, ValueType > funcMap;
+                for ( DeclarationWithType * decl : copy ) {
+                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
+                                std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters();
+                                assert( ! params.empty() );
+                                funcMap[ Mangler::mangle( params.front()->get_type() ) ] += function;
+                        } else {
+                                out.push_back( decl );
+                        }
+                }
+
+                // if a type contains user defined ctor/dtors, then special rules trigger, which determine
+                // the set of ctor/dtors that are seen by the requester. In particular, if the user defines
+                // a default ctor, then the generated default ctor should never be seen, likewise for copy ctor
+                // and dtor. If the user defines any ctor/dtor, then no generated field ctors should be seen.
+                for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
+                        ValueType & val = pair.second;
+                        for ( ValueType::DeclBall ball : val.decls ) {
+                                if ( ! val.userDefinedFunc || ball.isUserDefinedFunc || (! val.userDefinedDefaultFunc && ball.isDefaultFunc) || (! val.userDefinedCopyFunc && ball.isCopyFunc) ) {
+                                        // decl conforms to the rules described above, so it should be seen by the requester
+                                        out.push_back( ball.decl );
+                                }
+                        }
+                }
         }
 
@@ -461 +526 @@
                         searchTables = searchTables->base.tables;
                 }
+
+                // some special functions, e.g. constructors and destructors
+                // remove autogenerated functions when they are defined so that
+                // they can never be matched
+                removeSpecialOverrides( id, out );
         }
 

src/SymTab/Indexer.h

@@ -128 +128 @@
                 static void deleteRef( Impl *toFree );
 
+                // Removes matching autogenerated constructors and destructors
+                // so that they will not be selected
+                // void removeSpecialOverrides( FunctionDecl *decl );
+                void removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const;
+
                 /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
                 void makeWritable();

src/SymTab/Validate.cc

@@ -86 +86 @@
 
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        class Pass1 : public Visitor {
+        class EnumAndPointerDecayPass : public Visitor {
                 typedef Visitor Parent;
                 virtual void visit( EnumDecl *aggregateDecl );
@@ -189 +189 @@
 
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
-                Pass1 pass1;
+                EnumAndPointerDecayPass epc;
                 Pass2 pass2( doDebug, 0 );
                 Pass3 pass3( 0 );
@@ -196 +196 @@
                 EliminateTypedef::eliminateTypedef( translationUnit );
                 HoistStruct::hoistStruct( translationUnit );
-                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs Pass1
-                acceptAll( translationUnit, pass1 );
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
+                acceptAll( translationUnit, epc );
                 acceptAll( translationUnit, pass2 );
                 ReturnChecker::checkFunctionReturns( translationUnit );
@@ -206 +206 @@
 
         void validateType( Type *type, const Indexer *indexer ) {
-                Pass1 pass1;
+                EnumAndPointerDecayPass epc;
                 Pass2 pass2( false, indexer );
                 Pass3 pass3( indexer );
-                type->accept( pass1 );
+                type->accept( epc );
                 type->accept( pass2 );
                 type->accept( pass3 );
@@ -272 +272 @@
         }
 
-        void Pass1::visit( EnumDecl *enumDecl ) {
+        void EnumAndPointerDecayPass::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 ) {
@@ -296 +296 @@
                                 DWTIterator j = i;
                                 ++i;
+                                delete *j;
                                 dwts.erase( j );
                                 if ( i != end ) {
@@ -313 +314 @@
         }
 
-        void Pass1::visit( FunctionType *func ) {
+        void EnumAndPointerDecayPass::visit( FunctionType *func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->get_parameters(), func );